#include <G4CollisionOutput.hh>

Public Member Functions
	G4CollisionOutput ()

G4CollisionOutput &	operator= (const G4CollisionOutput &right)

void	setVerboseLevel (G4int verbose)

void	reset ()

void	add (const G4CollisionOutput &right)

void	addOutgoingParticle (const G4InuclElementaryParticle &particle)

void	addOutgoingParticles (const std::vector< G4InuclElementaryParticle > &particles)

void	addOutgoingNucleus (const G4InuclNuclei &nuclei)

void	addOutgoingNuclei (const std::vector< G4InuclNuclei > &nuclea)

void	addOutgoingParticle (const G4CascadParticle &cparticle)

void	addOutgoingParticles (const std::vector< G4CascadParticle > &cparticles)

void	addOutgoingParticles (const G4ReactionProductVector *rproducts)

void	addRecoilFragment (const G4Fragment *aFragment)

void	addRecoilFragment (const G4Fragment &aFragment)

void	removeOutgoingParticle (G4int index)

void	removeOutgoingParticle (const G4InuclElementaryParticle &particle)

void	removeOutgoingParticle (const G4InuclElementaryParticle *particle)

void	removeOutgoingNucleus (G4int index)

void	removeOutgoingNucleus (const G4InuclNuclei &nuclei)

void	removeOutgoingNucleus (const G4InuclNuclei *nuclei)

void	removeRecoilFragment (G4int index=-1)

G4int	numberOfOutgoingParticles () const

const std::vector< G4InuclElementaryParticle > &	getOutgoingParticles () const

std::vector< G4InuclElementaryParticle > &	getOutgoingParticles ()

G4int	numberOfOutgoingNuclei () const

const std::vector< G4InuclNuclei > &	getOutgoingNuclei () const

std::vector< G4InuclNuclei > &	getOutgoingNuclei ()

G4int	numberOfFragments () const

const G4Fragment &	getRecoilFragment (G4int index=0) const

const std::vector< G4Fragment > &	getRecoilFragments () const

std::vector< G4Fragment > &	getRecoilFragments ()

G4LorentzVector	getTotalOutputMomentum () const

G4int	getTotalCharge () const

G4int	getTotalBaryonNumber () const

G4int	getTotalStrangeness () const

void	printCollisionOutput (std::ostream &os=G4cout) const

void	boostToLabFrame (const G4LorentzConvertor &convertor)

G4LorentzVector	boostToLabFrame (G4LorentzVector mom, const G4LorentzConvertor &convertor) const

void	rotateEvent (const G4LorentzRotation &rotate)

void	trivialise (G4InuclParticle bullet, G4InuclParticle target)

void	setOnShell (G4InuclParticle bullet, G4InuclParticle target)

void	setRemainingExitationEnergy ()

G4double	getRemainingExitationEnergy () const

G4bool	acceptable () const

Detailed Description

Definition at line 65 of file G4CollisionOutput.hh.

Constructor & Destructor Documentation

◆ G4CollisionOutput()

G4CollisionOutput::G4CollisionOutput ( )

Definition at line 84 of file G4CollisionOutput.cc.

  : verboseLevel(0), eex_rest(0), on_shell(false) {
  if (verboseLevel > 1)
    G4cout << " >>> G4CollisionOutput::G4CollisionOutput" << G4endl;
}

Member Function Documentation

◆ acceptable()

G4bool G4CollisionOutput::acceptable ( ) const

inline

Definition at line 174 of file G4CollisionOutput.hh.

174{ return on_shell; };

Referenced by G4InuclCollider::collide(), and G4IntraNucleiCascader::finishCascade().

◆ add()

void G4CollisionOutput::add ( const G4CollisionOutput & right )

Definition at line 123 of file G4CollisionOutput.cc.

                                                          {
  addOutgoingParticles(right.outgoingParticles);
  addOutgoingNuclei(right.outgoingNuclei);
  recoilFragments = right.recoilFragments;  // Replace, don't combine
  eex_rest = 0.;
  on_shell = false;
}

Referenced by G4InuclCollider::collide(), G4CascadeCheckBalance::collide(), G4CascadeDeexcitation::deExcite(), G4InuclCollider::deexcite(), G4IntraNucleiCascader::finalize(), and G4InuclCollider::rescatter().

◆ addOutgoingNuclei()

void G4CollisionOutput::addOutgoingNuclei ( const std::vector< G4InuclNuclei > & nuclea )

Definition at line 139 of file G4CollisionOutput.cc.

                                                                                {
  outgoingNuclei.insert(outgoingNuclei.end(), nuclea.begin(), nuclea.end());
}

Referenced by add(), and G4CascadeCheckBalance::collide().

◆ addOutgoingNucleus()

void G4CollisionOutput::addOutgoingNucleus ( const G4InuclNuclei & nuclei )

inline

Definition at line 86 of file G4CollisionOutput.hh.

                                                       {
    outgoingNuclei.push_back(nuclei);
  };

Referenced by G4EquilibriumEvaporator::deExcite().

◆ addOutgoingParticle() [1/2]

void G4CollisionOutput::addOutgoingParticle ( const G4CascadParticle & cparticle )

Definition at line 145 of file G4CollisionOutput.cc.

                                                                             {
  addOutgoingParticle(cparticle.getParticle());
}

◆ addOutgoingParticle() [2/2]

void G4CollisionOutput::addOutgoingParticle ( const G4InuclElementaryParticle & particle )

inline

Definition at line 80 of file G4CollisionOutput.hh.

                                                                      {
    outgoingParticles.push_back(particle);
  }

Referenced by addOutgoingParticle(), addOutgoingParticles(), G4LightTargetCollider::collide(), G4IntraNucleiCascader::decayTrappedParticle(), G4EquilibriumEvaporator::deExcite(), G4NonEquilibriumEvaporator::deExcite(), G4IntraNucleiCascader::finishCascade(), G4IntraNucleiCascader::generateCascade(), and G4IntraNucleiCascader::processTrappedParticle().

◆ addOutgoingParticles() [1/3]

void G4CollisionOutput::addOutgoingParticles ( const G4ReactionProductVector * rproducts )

Definition at line 156 of file G4CollisionOutput.cc.

                                                                                     {
  if (!rproducts) return;       // Sanity check, no error if null
 
  if (verboseLevel) {
    G4cout << " >>> G4CollisionOutput::addOutgoingParticles(G4RPVector)"
       << G4endl;
  }
 
  G4ReactionProductVector::const_iterator j;
  for (j=rproducts->begin(); j!=rproducts->end(); ++j) {
    const G4ParticleDefinition* pd = (*j)->GetDefinition();
    G4int type = G4InuclElementaryParticle::type(pd);
 
    // FIXME:  Momentum returned by value; extra copying here!
    G4LorentzVector mom((*j)->GetMomentum(), (*j)->GetTotalEnergy());
    mom /= GeV;     // Convert from GEANT4 to Bertini units
    
    if (verboseLevel>1)
      G4cout << " Processing " << pd->GetParticleName() << " (" << type
         << "), momentum " << mom << " GeV" << G4endl;
 
    // Nucleons and nuclei are jumbled together in the list
    // NOTE: Resize and set/fill avoid unnecessary temporary copies
    if (type) {
      outgoingParticles.resize(numberOfOutgoingParticles()+1);
      outgoingParticles.back().fill(mom, pd, G4InuclParticle::PreCompound);
 
      if (verboseLevel>1) G4cout << outgoingParticles.back() << G4endl;
    } else {
      outgoingNuclei.resize(numberOfOutgoingNuclei()+1);
      outgoingNuclei.back().fill(mom,pd->GetAtomicMass(),pd->GetAtomicNumber(),
                 0.,G4InuclParticle::PreCompound);
 
      if (verboseLevel>1) G4cout << outgoingNuclei.back() << G4endl;
    }
  }
}

◆ addOutgoingParticles() [2/3]

void G4CollisionOutput::addOutgoingParticles ( const std::vector< G4CascadParticle > & cparticles )

Definition at line 149 of file G4CollisionOutput.cc.

                                                                                          {
  for (unsigned i=0; i<cparticles.size(); i++)
    addOutgoingParticle(cparticles[i]);
}

◆ addOutgoingParticles() [3/3]

void G4CollisionOutput::addOutgoingParticles ( const std::vector< G4InuclElementaryParticle > & particles )

Definition at line 134 of file G4CollisionOutput.cc.

                                                                                                  {
  outgoingParticles.insert(outgoingParticles.end(),
               particles.begin(), particles.end());
}

Referenced by add(), G4CascadeCheckBalance::collide(), G4ElementaryParticleCollider::collide(), G4CascadeDeexcitation::deExcite(), G4PreCompoundDeexcitation::deExcite(), G4BigBanger::deExcite(), G4IntraNucleiCascader::finishCascade(), and G4IntraNucleiCascader::setupCascade().

◆ addRecoilFragment() [1/2]

void G4CollisionOutput::addRecoilFragment ( const G4Fragment & aFragment )

inline

Definition at line 103 of file G4CollisionOutput.hh.

                                                      {
    recoilFragments.push_back(aFragment);
  }

◆ addRecoilFragment() [2/2]

void G4CollisionOutput::addRecoilFragment ( const G4Fragment * aFragment )

inline

Definition at line 99 of file G4CollisionOutput.hh.

                                                      {
    if (aFragment) addRecoilFragment(*aFragment);
  }

Referenced by addRecoilFragment(), G4EquilibriumEvaporator::deExcite(), G4Fissioner::deExcite(), G4NonEquilibriumEvaporator::deExcite(), and G4IntraNucleiCascader::finishCascade().

◆ boostToLabFrame() [1/2]

void G4CollisionOutput::boostToLabFrame ( const G4LorentzConvertor & convertor )

Definition at line 322 of file G4CollisionOutput.cc.

                                                                           {
  if (verboseLevel > 1)
    G4cout << " >>> G4CollisionOutput::boostToLabFrame" << G4endl;
 
  particleIterator ipart = outgoingParticles.begin();
  for(; ipart != outgoingParticles.end(); ipart++) {
    ipart->setMomentum(boostToLabFrame(ipart->getMomentum(), convertor));
  }
  
  std::sort(outgoingParticles.begin(), outgoingParticles.end(),
        G4ParticleLargerEkin());
  
  nucleiIterator inuc = outgoingNuclei.begin();
  for (; inuc != outgoingNuclei.end(); inuc++) {
    inuc->setMomentum(boostToLabFrame(inuc->getMomentum(), convertor)); 
  }
 
  // NOTE: Fragment momentum must be converted to and from Bertini units
  G4LorentzVector fmom;
  fragmentIterator ifrag = recoilFragments.begin();
  for (; ifrag != recoilFragments.end(); ifrag++) {
    fmom = ifrag->GetMomentum() / GeV;
    ifrag->SetMomentum(boostToLabFrame(fmom, convertor)*GeV);
  }
}

Referenced by boostToLabFrame(), G4InuclCollider::collide(), and G4EquilibriumEvaporator::deExcite().

◆ boostToLabFrame() [2/2]

G4LorentzVector G4CollisionOutput::boostToLabFrame	(	G4LorentzVector	mom,
		const G4LorentzConvertor &	convertor
	)		const

Definition at line 350 of file G4CollisionOutput.cc.

                                                              {
  if (convertor.reflectionNeeded()) mom.setZ(-mom.z());
  mom = convertor.rotate(mom);
  mom = convertor.backToTheLab(mom);
 
  return mom;
}

◆ getOutgoingNuclei() [1/2]

std::vector< G4InuclNuclei > & G4CollisionOutput::getOutgoingNuclei ( )

inline

Definition at line 141 of file G4CollisionOutput.hh.

141{ return outgoingNuclei; };

◆ getOutgoingNuclei() [2/2]

const std::vector< G4InuclNuclei > & G4CollisionOutput::getOutgoingNuclei ( ) const

inline

Definition at line 137 of file G4CollisionOutput.hh.

                                                            {
    return outgoingNuclei;
  };

Referenced by G4Analyser::analyse(), G4InuclEvaporation::BreakItUp(), G4CascadeInterface::copyOutputToHadronicResult(), G4CascadeInterface::copyOutputToReactionProducts(), G4EquilibriumEvaporator::deExcite(), G4InuclCollider::photonuclearOkay(), and G4IntraNucleiCascader::releaseSecondary().

◆ getOutgoingParticles() [1/2]

std::vector< G4InuclElementaryParticle > & G4CollisionOutput::getOutgoingParticles ( )

inline

Definition at line 131 of file G4CollisionOutput.hh.

                                                               {
    return outgoingParticles;
  };

◆ getOutgoingParticles() [2/2]

const std::vector< G4InuclElementaryParticle > & G4CollisionOutput::getOutgoingParticles ( ) const

inline

Definition at line 127 of file G4CollisionOutput.hh.

                                                                           {
    return outgoingParticles;
  };

Referenced by G4Analyser::analyse(), G4InuclEvaporation::BreakItUp(), G4CascadeCheckBalance::collide(), G4CascadeInterface::copyOutputToHadronicResult(), G4CascadeInterface::copyOutputToReactionProducts(), G4CascadeInterface::coulombBarrierViolation(), G4CascadeDeexcitation::deExcite(), G4EquilibriumEvaporator::deExcite(), G4CascadeCoalescence::FindClusters(), G4IntraNucleiCascader::finishCascade(), G4IntraNucleiCascader::generateCascade(), G4NucleiModel::generateParticleFate(), G4IntraNucleiCascader::releaseSecondary(), G4CascadeInterface::retryInelasticNucleus(), and G4CascadeInterface::retryInelasticProton().

◆ getRecoilFragment()

const G4Fragment & G4CollisionOutput::getRecoilFragment ( G4int index = 0 ) const

Definition at line 115 of file G4CollisionOutput.cc.

                                                                        {
  return ( (index >= 0 && index < numberOfFragments())
       ? recoilFragments[index] : emptyFragment);
}

Referenced by G4InuclCollider::collide(), G4CascadeDeexcitation::deExcite(), G4EquilibriumEvaporator::deExcite(), G4NonEquilibriumEvaporator::deExcite(), and G4InuclCollider::rescatter().

◆ getRecoilFragments() [1/2]

std::vector< G4Fragment > & G4CollisionOutput::getRecoilFragments ( )

inline

Definition at line 151 of file G4CollisionOutput.hh.

151{ return recoilFragments; };

◆ getRecoilFragments() [2/2]

const std::vector< G4Fragment > & G4CollisionOutput::getRecoilFragments ( ) const

inline

Definition at line 147 of file G4CollisionOutput.hh.

                                                          {
    return recoilFragments;
  };

◆ getRemainingExitationEnergy()

G4double G4CollisionOutput::getRemainingExitationEnergy ( ) const

inline

Definition at line 173 of file G4CollisionOutput.hh.

173{ return eex_rest; };

◆ getTotalBaryonNumber()

G4int G4CollisionOutput::getTotalBaryonNumber ( ) const

Definition at line 271 of file G4CollisionOutput.cc.

                                                    {
  if (verboseLevel > 1)
    G4cout << " >>> G4CollisionOutput::getTotalBaryonNumber" << G4endl;
 
  G4int baryon = 0;
  G4int i(0);
  for(i=0; i < numberOfOutgoingParticles(); i++) {
    baryon += outgoingParticles[i].baryon();
  }
  for(i=0; i < numberOfOutgoingNuclei(); i++) {
    baryon += G4int(outgoingNuclei[i].getA());
  }
  for(i=0; i < numberOfFragments(); i++) {
    baryon += recoilFragments[i].GetA_asInt();
  }
 
  return baryon;
}

Referenced by G4CascadeCheckBalance::collide().

◆ getTotalCharge()

G4int G4CollisionOutput::getTotalCharge ( ) const

Definition at line 251 of file G4CollisionOutput.cc.

                                              {
  if (verboseLevel > 1)
    G4cout << " >>> G4CollisionOutput::getTotalCharge" << G4endl;
 
  G4int charge = 0;
  G4int i(0);
 
  for (i = 0; i < numberOfOutgoingParticles(); i++)
    charge += G4int(outgoingParticles[i].getCharge());
 
  for (i = 0; i < numberOfOutgoingNuclei(); i++)
    charge += G4int(outgoingNuclei[i].getCharge());
 
  for (i = 0; i < numberOfFragments(); i++)
    charge += recoilFragments[i].GetZ_asInt();
 
  return charge;
}

Referenced by G4CascadeCheckBalance::collide().

◆ getTotalOutputMomentum()

G4LorentzVector G4CollisionOutput::getTotalOutputMomentum ( ) const

Definition at line 232 of file G4CollisionOutput.cc.

                                                                {
  if (verboseLevel > 1)
    G4cout << " >>> G4CollisionOutput::getTotalOutputMomentum" << G4endl;
 
  G4LorentzVector tot_mom;
  G4int i(0);
  for(i=0; i < numberOfOutgoingParticles(); i++) {
    tot_mom += outgoingParticles[i].getMomentum();
  }
  for(i=0; i < numberOfOutgoingNuclei(); i++) {
    tot_mom += outgoingNuclei[i].getMomentum();
  }
  for(i=0; i < numberOfFragments(); i++) {
    tot_mom += recoilFragments[i].GetMomentum()/GeV;    // Need Bertini units!
  }
 
  return tot_mom;
}

Referenced by G4CascadeCheckBalance::collide(), and setOnShell().

◆ getTotalStrangeness()

G4int G4CollisionOutput::getTotalStrangeness ( ) const

Definition at line 290 of file G4CollisionOutput.cc.

                                                   {
  if (verboseLevel > 1)
    G4cout << " >>> G4CollisionOutput::getTotalStrangeness" << G4endl;
 
  G4int strange = 0;
  G4int i(0);
  for(i=0; i < numberOfOutgoingParticles(); i++) {
    strange += outgoingParticles[i].getStrangeness();
  }
 
  return strange;
}

Referenced by G4CascadeCheckBalance::collide().

◆ numberOfFragments()

G4int G4CollisionOutput::numberOfFragments ( ) const

inline

Definition at line 143 of file G4CollisionOutput.hh.

143{ return (G4int)recoilFragments.size(); }

Referenced by G4EquilibriumEvaporator::deExcite(), getRecoilFragment(), getTotalBaryonNumber(), getTotalCharge(), getTotalOutputMomentum(), printCollisionOutput(), removeRecoilFragment(), setOnShell(), and setRemainingExitationEnergy().

◆ numberOfOutgoingNuclei()

G4int G4CollisionOutput::numberOfOutgoingNuclei ( ) const

inline

Definition at line 135 of file G4CollisionOutput.hh.

135{ return (G4int)outgoingNuclei.size(); };

Referenced by addOutgoingParticles(), G4IntraNucleiCascader::copySecondaries(), getTotalBaryonNumber(), getTotalCharge(), getTotalOutputMomentum(), G4InuclCollider::photonuclearOkay(), printCollisionOutput(), G4IntraNucleiCascader::releaseSecondary(), removeOutgoingNucleus(), G4CascadeInterface::retryInelasticNucleus(), setOnShell(), and setRemainingExitationEnergy().

◆ numberOfOutgoingParticles()

G4int G4CollisionOutput::numberOfOutgoingParticles ( ) const

inline

Definition at line 125 of file G4CollisionOutput.hh.

125{ return (G4int)outgoingParticles.size(); }

Referenced by addOutgoingParticles(), G4LightTargetCollider::collide(), G4CascadeCheckBalance::collide(), G4IntraNucleiCascader::copySecondaries(), G4NonEquilibriumEvaporator::deExcite(), G4IntraNucleiCascader::finishCascade(), G4NucleiModel::generateParticleFate(), getTotalBaryonNumber(), getTotalCharge(), getTotalOutputMomentum(), getTotalStrangeness(), printCollisionOutput(), G4IntraNucleiCascader::releaseSecondary(), removeOutgoingParticle(), G4CascadeInterface::retryInelasticNucleus(), and setOnShell().

◆ operator=()

G4CollisionOutput & G4CollisionOutput::operator= ( const G4CollisionOutput & right )

Definition at line 91 of file G4CollisionOutput.cc.

{
  if (this != &right) {
    verboseLevel = right.verboseLevel;
    outgoingParticles = right.outgoingParticles;
    outgoingNuclei = right.outgoingNuclei; 
    recoilFragments = right.recoilFragments;
    eex_rest = right.eex_rest;
    on_shell = right.on_shell;
  }
  return *this;
}

◆ printCollisionOutput()

void G4CollisionOutput::printCollisionOutput ( std::ostream & os = G4cout ) const

Definition at line 304 of file G4CollisionOutput.cc.

                                                                 {
  os << " Output: " << G4endl
     << " Outgoing Particles: " << numberOfOutgoingParticles() << G4endl;
 
  G4int i(0);
  for(i=0; i < numberOfOutgoingParticles(); i++)
    os << outgoingParticles[i] << G4endl;
 
  os << " Outgoing Nuclei: " << numberOfOutgoingNuclei() << G4endl;      
  for(i=0; i < numberOfOutgoingNuclei(); i++)
    os << outgoingNuclei[i] << G4endl;
  for(i=0; i < numberOfFragments(); i++)
    os << recoilFragments[i] << G4endl;
}

Referenced by G4CascadeInterface::ApplyYourself(), G4CascadeDeexcitation::deExcite(), G4EvaporationInuclCollider::deExcite(), G4CascadeCoalescence::FindClusters(), G4IntraNucleiCascader::finishCascade(), G4NucleiModel::generateParticleFate(), G4CascadeInterface::Propagate(), setOnShell(), G4CascadeInterface::throwNonConservationFailure(), and G4CascadeColliderBase::validateOutput().

◆ removeOutgoingNucleus() [1/3]

void G4CollisionOutput::removeOutgoingNucleus ( const G4InuclNuclei & nuclei )

Definition at line 215 of file G4CollisionOutput.cc.

                                                                         {
  nucleiIterator pos =
    std::find(outgoingNuclei.begin(), outgoingNuclei.end(), nuclei);
  if (pos != outgoingNuclei.end()) outgoingNuclei.erase(pos);
}

◆ removeOutgoingNucleus() [2/3]

void G4CollisionOutput::removeOutgoingNucleus ( const G4InuclNuclei * nuclei )

inline

Definition at line 117 of file G4CollisionOutput.hh.

                                                          {
    if (nuclei) removeOutgoingNucleus(*nuclei);
  }

◆ removeOutgoingNucleus() [3/3]

void G4CollisionOutput::removeOutgoingNucleus ( G4int index )

Definition at line 202 of file G4CollisionOutput.cc.

                                                         {
  if (index >= 0 && index < numberOfOutgoingNuclei())
    outgoingNuclei.erase(outgoingNuclei.begin()+(size_t)index);
}

Referenced by removeOutgoingNucleus().

◆ removeOutgoingParticle() [1/3]

void G4CollisionOutput::removeOutgoingParticle ( const G4InuclElementaryParticle & particle )

Definition at line 209 of file G4CollisionOutput.cc.

                                                                                        {
  particleIterator pos =
    std::find(outgoingParticles.begin(), outgoingParticles.end(), particle);
  if (pos != outgoingParticles.end()) outgoingParticles.erase(pos);
}

◆ removeOutgoingParticle() [2/3]

void G4CollisionOutput::removeOutgoingParticle ( const G4InuclElementaryParticle * particle )

inline

Definition at line 111 of file G4CollisionOutput.hh.

                                                                         {
    if (particle) removeOutgoingParticle(*particle);
  }

◆ removeOutgoingParticle() [3/3]

void G4CollisionOutput::removeOutgoingParticle ( G4int index )

Definition at line 197 of file G4CollisionOutput.cc.

                                                          {
  if (index >= 0 && index < numberOfOutgoingParticles())
    outgoingParticles.erase(outgoingParticles.begin()+(size_t)index);
}

Referenced by removeOutgoingParticle().

◆ removeRecoilFragment()

void G4CollisionOutput::removeRecoilFragment ( G4int index = -1 )

Definition at line 223 of file G4CollisionOutput.cc.

                                                        {
  if (index < 0) recoilFragments.clear();
  else if (index < numberOfFragments()) 
    recoilFragments.erase(recoilFragments.begin()+(size_t)index);
}

Referenced by G4InuclCollider::collide(), and G4InuclCollider::rescatter().

◆ reset()

void G4CollisionOutput::reset ( )

Definition at line 104 of file G4CollisionOutput.cc.

                              {
  outgoingNuclei.clear();
  outgoingParticles.clear();
  recoilFragments.clear();
  eex_rest = 0.;
  on_shell = false;
}

Referenced by G4CascadeInterface::ApplyYourself(), G4CascadeCheckBalance::collide(), G4InuclCollider::collide(), G4LightTargetCollider::collide(), G4CascadeDeexcitation::deExcite(), G4InuclCollider::deexcite(), G4EquilibriumEvaporator::deExcite(), G4NucleiModel::generateParticleFate(), G4IntraNucleiCascader::newCascade(), G4CascadeInterface::Propagate(), G4InuclCollider::rescatter(), and trivialise().

◆ rotateEvent()

void G4CollisionOutput::rotateEvent ( const G4LorentzRotation & rotate )

Definition at line 361 of file G4CollisionOutput.cc.

                                                                   {
  if (verboseLevel > 1)
    G4cout << " >>> G4CollisionOutput::rotateEvent" << G4endl;
 
  particleIterator ipart = outgoingParticles.begin();
  for(; ipart != outgoingParticles.end(); ipart++)
    ipart->setMomentum(ipart->getMomentum()*=rotate);
 
  nucleiIterator inuc = outgoingNuclei.begin();
  for (; inuc != outgoingNuclei.end(); inuc++)
    inuc->setMomentum(inuc->getMomentum()*=rotate);
 
  fragmentIterator ifrag = recoilFragments.begin();
  for (; ifrag != recoilFragments.end(); ifrag++) {
    G4LorentzVector mom = ifrag->GetMomentum();     // Need copy
    ifrag->SetMomentum(mom*=rotate);
  }
}

◆ setOnShell()

void G4CollisionOutput::setOnShell	(	G4InuclParticle *	bullet,
		G4InuclParticle *	target
	)

Definition at line 406 of file G4CollisionOutput.cc.

                                            {
  if (verboseLevel > 1)
    G4cout << " >>> G4CollisionOutput::setOnShell" << G4endl;
 
  const G4double accuracy = 0.00001; // momentum concerves at the level of 10 keV
 
  on_shell = false;
    
  G4LorentzVector ini_mom = bullet->getMomentum();
  G4LorentzVector momt    = target->getMomentum();
  G4LorentzVector out_mom = getTotalOutputMomentum();
  if(verboseLevel > 2){
    G4cout << " bullet momentum = " << ini_mom.e() <<", "<< ini_mom.x() <<", "<< ini_mom.y()<<", "<< ini_mom.z()<<G4endl;
    G4cout << " target momentum = " << momt.e()<<", "<< momt.x()<<", "<< momt.y()<<", "<< momt.z()<<G4endl;
    G4cout << " Fstate momentum = " << out_mom.e()<<", "<< out_mom.x()<<", "<< out_mom.y()<<", "<< out_mom.z()<<G4endl;
  }
  // correction for internal conversion
  G4LorentzVector el4mom(0.,0.,0.,electron_mass_c2/GeV);
  for(G4int i=0; i < numberOfOutgoingParticles(); ++i) {
    if (outgoingParticles[i].getDefinition() == G4Electron::Electron())
      momt += el4mom;
  }
 
  ini_mom += momt;
 
  mom_non_cons = ini_mom - out_mom;
  G4double pnc = mom_non_cons.rho();
  G4double enc = mom_non_cons.e();
 
  setRemainingExitationEnergy();       
 
  if(verboseLevel > 2) {
    printCollisionOutput();
    G4cout << " momentum non conservation: " << G4endl
           << " e " << enc << " p " << pnc << G4endl
       << " remaining exitation " << eex_rest << G4endl;
  }
 
  if (std::fabs(enc) <= accuracy && pnc <= accuracy) {
    on_shell = true;
    return;
  }
 
  // Adjust "last" particle's four-momentum to balance event
  // ONLY adjust particles with sufficient e or p to remain physical!
 
  if (verboseLevel > 2) G4cout << " re-balancing four-momenta" << G4endl;
 
  G4int npart = numberOfOutgoingParticles();
  G4int nnuc = numberOfOutgoingNuclei();
  G4int nfrag = numberOfFragments();
 
  G4LorentzVector last_mom;     // Buffer to reduce memory churn
 
  if (npart > 0) {
    for (G4int ip=npart-1; ip>=0; ip--) {
      if (outgoingParticles[ip].getKineticEnergy()+enc > 0.) {
    last_mom = outgoingParticles[ip].getMomentum(); 
    last_mom += mom_non_cons;
    outgoingParticles[ip].setMomentum(last_mom);
    break;
      }
    }
  } else if (nnuc > 0) {
    for (G4int in=nnuc-1; in>=0; in--) {
      if (outgoingNuclei[in].getKineticEnergy()+enc > 0.) {
    last_mom = outgoingNuclei[in].getMomentum();
    last_mom += mom_non_cons;
    outgoingNuclei[in].setMomentum(last_mom);
    break;
      }
    }
  } else if (nfrag > 0) {
    for (G4int ifr=nfrag-1; ifr>=0; ifr--) {
      // NOTE:  G4Fragment does not use Bertini units!
      last_mom = recoilFragments[ifr].GetMomentum()/GeV;
      if ((last_mom.e()-last_mom.m())+enc > 0.) {
    last_mom += mom_non_cons;
    recoilFragments[ifr].SetMomentum(last_mom*GeV);
    break;
      }
    }
  }
 
  // Recompute momentum non-conservation parameters
  out_mom = getTotalOutputMomentum();
  mom_non_cons = ini_mom - out_mom;
  pnc = mom_non_cons.rho();
  enc = mom_non_cons.e();
 
  if(verboseLevel > 2){
    printCollisionOutput();
    G4cout << " momentum non conservation after (1): " << G4endl 
       << " e " << enc << " p " << pnc << G4endl;
  }
 
  // Can energy be balanced just with nuclear excitation?
  G4bool need_hard_tuning = true;
  
  G4double encMeV = mom_non_cons.e() / GeV; // Excitation below is in MeV
  if (nfrag > 0) {
    for (G4int i=0; i < nfrag; i++) {
      G4double eex = recoilFragments[0].GetExcitationEnergy();
      if (eex > 0.0 && eex + encMeV >= 0.0) {
    // NOTE:  G4Fragment doesn't have function to change excitation energy
    // ==> theRecoilFragment.SetExcitationEnergy(eex+encMeV);
 
    G4LorentzVector fragMom = recoilFragments[i].GetMomentum();
    G4double newMass = fragMom.m() + encMeV;    // .m() includes eex
    fragMom.setVectM(fragMom.vect(), newMass);
    need_hard_tuning = false;
    break;
      }
    }
  } else if (nnuc > 0) {
    for (G4int i=0; i < nnuc; i++) {
      G4double eex = outgoingNuclei[i].getExitationEnergy();
      if (eex > 0.0 && eex + encMeV >= 0.0) {
    outgoingNuclei[i].setExitationEnergy(eex+encMeV);
    need_hard_tuning = false;
    break;
      }
    }
    if (need_hard_tuning && encMeV > 0.) {
      outgoingNuclei[0].setExitationEnergy(encMeV);
      need_hard_tuning = false;
    }
  }
  
  if (!need_hard_tuning) {
    on_shell = true;
    return;
  }
 
  // Momentum (hard) tuning required for energy conservation
  if (verboseLevel > 2) {
    G4cout << " trying hard (particle-pair) tuning" << G4endl;
  }
  /*****
  // Hard tuning of quasielastic particle against nucleus
  if (npart == 1) {
    if (verboseLevel > 2)
      G4cout << " tuning particle 0 against recoil nucleus" << G4endl;
 
    G4LorentzVector mom1 = outgoingParticles[0].getMomentum();
    G4LorentzVector mom2 = recoilFragments[0].GetMomentum()/GeV;
 
    // Preserve momentum direction of outgoing particle
    G4ThreeVector pdir = mom1.vect().unit();
 
    // Two-body kinematics (nucleon against nucleus) in overall CM system
    G4double ecmsq = ini_mom.m2();
    G4double a = 0.5 * (ecmsq - mom1.m2() - mom2.m2());
    G4double pmod = std::sqrt((a*a - mom1.m2()*mom2.m2()) / ecmsq);
 
    mom1.setVectM(pdir*pmod, mom1.m());
    mom2.setVectM(-pdir*pmod, mom2.m());
 
    // Boost CM momenta back into lab frame, assign back to particles
    mom1.boost(-ini_mom.boostVector());
    mom2.boost(-ini_mom.boostVector());
 
    outgoingParticles[0].setMomentum(mom1);
    recoilFragments[0].SetMomentum(mom2*GeV);
  } else {  // Hard tuning using pair of outgoing particles
  *****/
    std::pair<std::pair<G4int, G4int>, G4int> tune_par = selectPairToTune(enc);
    std::pair<G4int, G4int> tune_particles = tune_par.first;
    G4int mom_ind = tune_par.second;
    
    G4bool tuning_possible = 
      (tune_particles.first >= 0 && tune_particles.second >= 0 &&
       mom_ind >= G4LorentzVector::X);
    
    if (!tuning_possible) {
      if (verboseLevel > 2) G4cout << " tuning impossible " << G4endl;
      return;
    }
    
    if(verboseLevel > 2) {
      G4cout << " p1 " << tune_particles.first << " p2 " << tune_particles.second
         << " ind " << mom_ind << G4endl;
    }
    
    G4LorentzVector mom1 = outgoingParticles[tune_particles.first].getMomentum();
    G4LorentzVector mom2 = outgoingParticles[tune_particles.second].getMomentum();
    
    if (tuneSelectedPair(mom1, mom2, mom_ind)) {
      outgoingParticles[tune_particles.first ].setMomentum(mom1);
      outgoingParticles[tune_particles.second].setMomentum(mom2);
    }
    else return;
    //*****  }
 
  out_mom = getTotalOutputMomentum();
  std::sort(outgoingParticles.begin(), outgoingParticles.end(), G4ParticleLargerEkin());
  mom_non_cons = ini_mom - out_mom;
  pnc = mom_non_cons.rho();
  enc = mom_non_cons.e();
 
  on_shell = (std::fabs(enc) < accuracy || pnc < accuracy);
 
  if(verboseLevel > 2) {
    G4cout << " momentum non conservation tuning: " << G4endl 
       << " e " << enc << " p " << pnc 
       << (on_shell?" success":" FAILURE") << G4endl;
  }
}

Referenced by G4InuclCollider::collide(), and G4IntraNucleiCascader::finishCascade().

◆ setRemainingExitationEnergy()

void G4CollisionOutput::setRemainingExitationEnergy ( )

Definition at line 619 of file G4CollisionOutput.cc.

                                                    { 
  eex_rest = 0.;
  G4int i(0);
  for (i=0; i < numberOfOutgoingNuclei(); i++) 
    eex_rest += outgoingNuclei[i].getExitationEnergyInGeV();
  for (i=0; i < numberOfFragments(); i++) 
    eex_rest += recoilFragments[i].GetExcitationEnergy() / GeV;
}

Referenced by setOnShell().

◆ setVerboseLevel()

void G4CollisionOutput::setVerboseLevel ( G4int verbose )

inline

Definition at line 72 of file G4CollisionOutput.hh.

72{ verboseLevel = verbose; };

Referenced by G4PreCompoundDeexcitation::deExcite(), G4IntraNucleiCascader::finishCascade(), G4CascadeInterface::SetVerboseLevel(), G4InuclCollider::setVerboseLevel(), and G4LightTargetCollider::setVerboseLevel().

◆ trivialise()

void G4CollisionOutput::trivialise	(	G4InuclParticle *	bullet,
		G4InuclParticle *	target
	)

Definition at line 381 of file G4CollisionOutput.cc.

                                            {
  if (verboseLevel > 1)
    G4cout << " >>> G4CollisionOutput::trivialize" << G4endl;
 
  reset();      // Discard existing output, replace with bullet/target
 
  if (G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target)) {
    outgoingNuclei.push_back(*nuclei_target);
  } else {
    G4InuclElementaryParticle* particle =
      dynamic_cast<G4InuclElementaryParticle*>(target);
    outgoingParticles.push_back(*particle);
  }
 
  if (G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet)) {
    outgoingNuclei.push_back(*nuclei_bullet);
  } else {
    G4InuclElementaryParticle* particle =
      dynamic_cast<G4InuclElementaryParticle*>(bullet);
    outgoingParticles.push_back(*particle);
  }
}

Referenced by G4InuclCollider::collide(), G4LightTargetCollider::collide(), and G4IntraNucleiCascader::finalize().

The documentation for this class was generated from the following files:

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ G4CollisionOutput()

Member Function Documentation

◆ acceptable()

◆ add()

◆ addOutgoingNuclei()

◆ addOutgoingNucleus()

◆ addOutgoingParticle() [1/2]

◆ addOutgoingParticle() [2/2]

◆ addOutgoingParticles() [1/3]

◆ addOutgoingParticles() [2/3]

◆ addOutgoingParticles() [3/3]

◆ addRecoilFragment() [1/2]

◆ addRecoilFragment() [2/2]

◆ boostToLabFrame() [1/2]

◆ boostToLabFrame() [2/2]

◆ getOutgoingNuclei() [1/2]

◆ getOutgoingNuclei() [2/2]

◆ getOutgoingParticles() [1/2]

◆ getOutgoingParticles() [2/2]

◆ getRecoilFragment()

◆ getRecoilFragments() [1/2]

◆ getRecoilFragments() [2/2]

◆ getRemainingExitationEnergy()

◆ getTotalBaryonNumber()

◆ getTotalCharge()

◆ getTotalOutputMomentum()

◆ getTotalStrangeness()

◆ numberOfFragments()

◆ numberOfOutgoingNuclei()

◆ numberOfOutgoingParticles()

◆ operator=()

◆ printCollisionOutput()

◆ removeOutgoingNucleus() [1/3]

◆ removeOutgoingNucleus() [2/3]

◆ removeOutgoingNucleus() [3/3]

◆ removeOutgoingParticle() [1/3]

◆ removeOutgoingParticle() [2/3]

◆ removeOutgoingParticle() [3/3]

◆ removeRecoilFragment()

◆ reset()

◆ rotateEvent()

◆ setOnShell()

◆ setRemainingExitationEnergy()

◆ setVerboseLevel()

◆ trivialise()