#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 ()

double	getRemainingExitationEnergy () const

G4bool	acceptable () const

Detailed Description

Definition at line 66 of file G4CollisionOutput.hh.

Constructor & Destructor Documentation

G4CollisionOutput::G4CollisionOutput ( )

Definition at line 81 of file G4CollisionOutput.cc.

References G4cout, and G4endl.

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

Member Function Documentation

G4bool G4CollisionOutput::acceptable ( ) const

inline

Definition at line 173 of file G4CollisionOutput.hh.

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

173 { return on_shell; };

void G4CollisionOutput::add ( const G4CollisionOutput & right )

Definition at line 120 of file G4CollisionOutput.cc.

References addOutgoingNuclei(), and addOutgoingParticles().

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

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

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

Definition at line 136 of file G4CollisionOutput.cc.

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

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

void G4CollisionOutput::addOutgoingNucleus ( const G4InuclNuclei & nuclei )

inline

Definition at line 85 of file G4CollisionOutput.hh.

Referenced by G4EquilibriumEvaporator::deExcite().

                                                        {
     outgoingNuclei.push_back(nuclei);
   };

void G4CollisionOutput::addOutgoingParticle ( const G4InuclElementaryParticle & particle )

inline

Definition at line 79 of file G4CollisionOutput.hh.

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

                                                                       {
     outgoingParticles.push_back(particle);
   }

void G4CollisionOutput::addOutgoingParticle ( const G4CascadParticle & cparticle )

Definition at line 142 of file G4CollisionOutput.cc.

References addOutgoingParticle(), and G4CascadParticle::getParticle().

                                                                              {
   addOutgoingParticle(cparticle.getParticle());
 }

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

Definition at line 131 of file G4CollisionOutput.cc.

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

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

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

Definition at line 146 of file G4CollisionOutput.cc.

References addOutgoingParticle().

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

void G4CollisionOutput::addOutgoingParticles ( const G4ReactionProductVector * rproducts )

Definition at line 153 of file G4CollisionOutput.cc.

References G4cout, G4endl, G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), G4ParticleDefinition::GetParticleName(), python.hepunit::GeV, numberOfOutgoingNuclei(), numberOfOutgoingParticles(), G4InuclParticle::PreCompound, and G4InuclElementaryParticle::type().

                                                                                      {
   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) {
     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;
     }
   }
 }

void G4CollisionOutput::addRecoilFragment ( const G4Fragment * aFragment )

inline

Definition at line 98 of file G4CollisionOutput.hh.

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

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

void G4CollisionOutput::addRecoilFragment ( const G4Fragment & aFragment )

inline

Definition at line 102 of file G4CollisionOutput.hh.

                                                       {
     recoilFragments.push_back(aFragment);
   }

void G4CollisionOutput::boostToLabFrame ( const G4LorentzConvertor & convertor )

Definition at line 318 of file G4CollisionOutput.cc.

References G4cout, G4endl, python.hepunit::GeV, and sort().

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

                                                                            {
   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);
   }
 }

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

Definition at line 346 of file G4CollisionOutput.cc.

References G4LorentzConvertor::backToTheLab(), G4LorentzConvertor::reflectionNeeded(), G4LorentzConvertor::rotate(), CLHEP::HepLorentzVector::setZ(), and CLHEP::HepLorentzVector::z().

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

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

inline

Definition at line 136 of file G4CollisionOutput.hh.

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

                                                             {
     return outgoingNuclei;
   };

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

inline

Definition at line 140 of file G4CollisionOutput.hh.

140 { return outgoingNuclei; };

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

inline

Definition at line 126 of file G4CollisionOutput.hh.

Referenced by G4Analyser::analyse(), G4InuclEvaporation::BreakItUp(), 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().

                                                                            {
     return outgoingParticles;
   };

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

inline

Definition at line 130 of file G4CollisionOutput.hh.

                                                                {
     return outgoingParticles;
   };

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

Definition at line 112 of file G4CollisionOutput.cc.

References numberOfFragments().

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

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

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

inline

Definition at line 146 of file G4CollisionOutput.hh.

                                                           {
     return recoilFragments;
   };

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

inline

Definition at line 150 of file G4CollisionOutput.hh.

150 { return recoilFragments; };

double G4CollisionOutput::getRemainingExitationEnergy ( ) const

inline

Definition at line 172 of file G4CollisionOutput.hh.

172 { return eex_rest; };

G4int G4CollisionOutput::getTotalBaryonNumber ( ) const

Definition at line 267 of file G4CollisionOutput.cc.

References G4InuclParticleNames::baryon(), G4cout, G4endl, numberOfFragments(), numberOfOutgoingNuclei(), and numberOfOutgoingParticles().

Referenced by G4CascadeCheckBalance::collide().

                                                     {
   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;
 }

G4int G4CollisionOutput::getTotalCharge ( ) const

Definition at line 248 of file G4CollisionOutput.cc.

References G4cout, G4endl, numberOfFragments(), numberOfOutgoingNuclei(), and numberOfOutgoingParticles().

Referenced by G4CascadeCheckBalance::collide().

                                               {
   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;
 }

G4LorentzVector G4CollisionOutput::getTotalOutputMomentum ( ) const

Definition at line 229 of file G4CollisionOutput.cc.

References G4cout, G4endl, python.hepunit::GeV, numberOfFragments(), numberOfOutgoingNuclei(), and numberOfOutgoingParticles().

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

                                                                 {
   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;
 }

G4int G4CollisionOutput::getTotalStrangeness ( ) const

Definition at line 286 of file G4CollisionOutput.cc.

References G4cout, G4endl, and numberOfOutgoingParticles().

Referenced by G4CascadeCheckBalance::collide().

                                                    {
   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;
 }

G4int G4CollisionOutput::numberOfFragments ( ) const

inline

Definition at line 142 of file G4CollisionOutput.hh.

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

142 { return recoilFragments.size(); }

G4int G4CollisionOutput::numberOfOutgoingNuclei ( ) const

inline

Definition at line 134 of file G4CollisionOutput.hh.

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

134 { return outgoingNuclei.size(); };

G4int G4CollisionOutput::numberOfOutgoingParticles ( ) const

inline

Definition at line 124 of file G4CollisionOutput.hh.

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

124 { return outgoingParticles.size(); }

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

Definition at line 88 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;
 }

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

Definition at line 300 of file G4CollisionOutput.cc.

References G4endl, numberOfFragments(), numberOfOutgoingNuclei(), and numberOfOutgoingParticles().

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

                                                                  {
   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;
 }

void G4CollisionOutput::removeOutgoingNucleus ( G4int index )

Definition at line 199 of file G4CollisionOutput.cc.

References numberOfOutgoingNuclei().

Referenced by removeOutgoingNucleus().

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

void G4CollisionOutput::removeOutgoingNucleus ( const G4InuclNuclei & nuclei )

Definition at line 212 of file G4CollisionOutput.cc.

References G4InuclParticleNames::nuclei.

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

void G4CollisionOutput::removeOutgoingNucleus ( const G4InuclNuclei * nuclei )

inline

Definition at line 116 of file G4CollisionOutput.hh.

References removeOutgoingNucleus().

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

void G4CollisionOutput::removeOutgoingParticle ( G4int index )

Definition at line 194 of file G4CollisionOutput.cc.

References numberOfOutgoingParticles().

Referenced by removeOutgoingParticle().

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

void G4CollisionOutput::removeOutgoingParticle ( const G4InuclElementaryParticle & particle )

Definition at line 206 of file G4CollisionOutput.cc.

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

void G4CollisionOutput::removeOutgoingParticle ( const G4InuclElementaryParticle * particle )

inline

Definition at line 110 of file G4CollisionOutput.hh.

References removeOutgoingParticle().

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

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

Definition at line 220 of file G4CollisionOutput.cc.

References numberOfFragments().

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

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

void G4CollisionOutput::reset ( )

Definition at line 101 of file G4CollisionOutput.cc.

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

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

void G4CollisionOutput::rotateEvent ( const G4LorentzRotation & rotate )

Definition at line 357 of file G4CollisionOutput.cc.

References G4cout, G4endl, and rotate().

Referenced by G4CascadeInterface::ApplyYourself().

                                                                    {
   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);
   }
 }

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

Definition at line 402 of file G4CollisionOutput.cc.

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

                                             {
   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;
   }
 
   ini_mom += momt;
   G4LorentzVector 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;
 
   std::pair<std::pair<G4int, G4int>, G4int> tune_par = selectPairToTune(mom_non_cons.e());
   std::pair<G4int, G4int> tune_particles = tune_par.first;
   G4int mom_ind = tune_par.second;
   
   if(verboseLevel > 2) {
     G4cout << " p1 " << tune_particles.first << " p2 " << tune_particles.second
        << " ind " << mom_ind << G4endl;
   }
 
   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;
   }
     
   G4LorentzVector mom1 = outgoingParticles[tune_particles.first].getMomentum();
   G4LorentzVector mom2 = outgoingParticles[tune_particles.second].getMomentum();
   G4double newE12 = mom1.e() + mom2.e() + mom_non_cons.e();
   G4double R = 0.5 * (newE12 * newE12 + mom2.e() * mom2.e() - mom1.e() * mom1.e()) / newE12;
   G4double Q = -(mom1[mom_ind] + mom2[mom_ind]) / newE12;
   G4double UDQ = 1.0 / (Q * Q - 1.0);
   G4double W = (R * Q + mom2[mom_ind]) * UDQ;
   G4double V = (mom2.e() * mom2.e() - R * R) * UDQ;
   G4double DET = W * W + V;
   
   if (DET < 0.0) {
     if (verboseLevel > 2) G4cout << " DET < 0 " << G4endl;
     return;
   }
 
   // Tuning allowed only for non-negative determinant
   G4double x1 = -(W + std::sqrt(DET));
   G4double x2 = -(W - std::sqrt(DET));
   
   // choose the appropriate solution
   G4bool xset = false;
   G4double x = 0.0;
   
   if(mom_non_cons.e() > 0.0) { // x has to be > 0.0
     if(x1 > 0.0) {
       if(R + Q * x1 >= 0.0) {
     x = x1;
     xset = true;
       };
     };  
     if(!xset && x2 > 0.0) {
       if(R + Q * x2 >= 0.0) {
     x = x2;
     xset = true;
       };
     };
   } else { 
     if(x1 < 0.0) {
       if(R + Q * x1 >= 0.) {
     x = x1;
     xset = true;
       };
     };  
     if(!xset && x2 < 0.0) {
       if(R + Q * x2 >= 0.0) {
     x = x2;
     xset = true;
       };
     };
   } // if(mom_non_cons.e() > 0.0)
   
   if(!xset) {
     if(verboseLevel > 2)
       G4cout << " no appropriate solution found " << G4endl;
     return;
   } // if(xset)
 
   // retune momentums
   mom1[mom_ind] += x;
   mom2[mom_ind] -= x;
   outgoingParticles[tune_particles.first ].setMomentum(mom1);
   outgoingParticles[tune_particles.second].setMomentum(mom2);
   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;
   }
 }

void G4CollisionOutput::setRemainingExitationEnergy ( )

Definition at line 633 of file G4CollisionOutput.cc.

References python.hepunit::GeV, numberOfFragments(), and numberOfOutgoingNuclei().

Referenced by setOnShell().

                                                     { 
   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;
 }

void G4CollisionOutput::setVerboseLevel ( G4int verbose )

inline

Definition at line 71 of file G4CollisionOutput.hh.

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

71 { verboseLevel = verbose; };

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

Definition at line 377 of file G4CollisionOutput.cc.

References G4cout, G4endl, and reset().

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

                                             {
   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);
   }
 }

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

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation