#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 67 of file G4CollisionOutput.hh.

Constructor & Destructor Documentation

G4CollisionOutput::G4CollisionOutput ( )

Definition at line 82 of file G4CollisionOutput.cc.

   : 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 174 of file G4CollisionOutput.hh.

174 { return on_shell; };

Here is the caller graph for this function:

void G4CollisionOutput::add ( const G4CollisionOutput & right )

Definition at line 121 of file G4CollisionOutput.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 137 of file G4CollisionOutput.cc.

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

Here is the caller graph for this function:

void G4CollisionOutput::addOutgoingNucleus ( const G4InuclNuclei & nuclei )

inline

Definition at line 86 of file G4CollisionOutput.hh.

                                                        {
     outgoingNuclei.push_back(nuclei);
   };

Here is the caller graph for this function:

void G4CollisionOutput::addOutgoingParticle ( const G4InuclElementaryParticle & particle )

inline

Definition at line 80 of file G4CollisionOutput.hh.

                                                                       {
     outgoingParticles.push_back(particle);
   }

Here is the caller graph for this function:

void G4CollisionOutput::addOutgoingParticle ( const G4CascadParticle & cparticle )

Definition at line 143 of file G4CollisionOutput.cc.

                                                                              {
   addOutgoingParticle(cparticle.getParticle());
 }

Here is the call graph for this function:

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

Definition at line 132 of file G4CollisionOutput.cc.

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

Here is the caller graph for this function:

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

Definition at line 147 of file G4CollisionOutput.cc.

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

Here is the call graph for this function:

void G4CollisionOutput::addOutgoingParticles ( const G4ReactionProductVector * rproducts )

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

Here is the call graph for this function:

void G4CollisionOutput::addRecoilFragment ( const G4Fragment * aFragment )

inline

Definition at line 99 of file G4CollisionOutput.hh.

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

Here is the caller graph for this function:

void G4CollisionOutput::addRecoilFragment ( const G4Fragment & aFragment )

inline

Definition at line 103 of file G4CollisionOutput.hh.

                                                       {
     recoilFragments.push_back(aFragment);
   }

void G4CollisionOutput::boostToLabFrame ( const G4LorentzConvertor & convertor )

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

Here is the caller graph for this function:

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

Definition at line 347 of file G4CollisionOutput.cc.

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

Here is the call graph for this function:

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

inline

Definition at line 137 of file G4CollisionOutput.hh.

                                                             {
     return outgoingNuclei;
   };

Here is the caller graph for this function:

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

inline

Definition at line 141 of file G4CollisionOutput.hh.

141 { return outgoingNuclei; };

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

inline

Definition at line 127 of file G4CollisionOutput.hh.

                                                                            {
     return outgoingParticles;
   };

Here is the caller graph for this function:

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

inline

Definition at line 131 of file G4CollisionOutput.hh.

                                                                {
     return outgoingParticles;
   };

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

Definition at line 113 of file G4CollisionOutput.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

inline

Definition at line 147 of file G4CollisionOutput.hh.

                                                           {
     return recoilFragments;
   };

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

inline

Definition at line 151 of file G4CollisionOutput.hh.

151 { return recoilFragments; };

double G4CollisionOutput::getRemainingExitationEnergy ( ) const

inline

Definition at line 173 of file G4CollisionOutput.hh.

173 { return eex_rest; };

G4int G4CollisionOutput::getTotalBaryonNumber ( ) const

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4int G4CollisionOutput::getTotalCharge ( ) const

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4LorentzVector G4CollisionOutput::getTotalOutputMomentum ( ) const

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4int G4CollisionOutput::getTotalStrangeness ( ) const

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4int G4CollisionOutput::numberOfFragments ( ) const

inline

Definition at line 143 of file G4CollisionOutput.hh.

143 { return recoilFragments.size(); }

Here is the caller graph for this function:

G4int G4CollisionOutput::numberOfOutgoingNuclei ( ) const

inline

Definition at line 135 of file G4CollisionOutput.hh.

135 { return outgoingNuclei.size(); };

Here is the caller graph for this function:

G4int G4CollisionOutput::numberOfOutgoingParticles ( ) const

inline

Definition at line 125 of file G4CollisionOutput.hh.

125 { return outgoingParticles.size(); }

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4CollisionOutput::removeOutgoingNucleus ( G4int index )

Definition at line 200 of file G4CollisionOutput.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4CollisionOutput::removeOutgoingNucleus ( const G4InuclNuclei & nuclei )

Definition at line 213 of file G4CollisionOutput.cc.

                                                                          {
   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 117 of file G4CollisionOutput.hh.

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

Here is the call graph for this function:

void G4CollisionOutput::removeOutgoingParticle ( G4int index )

Definition at line 195 of file G4CollisionOutput.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4CollisionOutput::removeOutgoingParticle ( const G4InuclElementaryParticle & particle )

Definition at line 207 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 111 of file G4CollisionOutput.hh.

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

Here is the call graph for this function:

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

Definition at line 221 of file G4CollisionOutput.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4CollisionOutput::reset ( )

Definition at line 102 of file G4CollisionOutput.cc.

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

Here is the caller graph for this function:

void G4CollisionOutput::rotateEvent ( const G4LorentzRotation & rotate )

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

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4CollisionOutput::setRemainingExitationEnergy ( )

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4CollisionOutput::setVerboseLevel ( G4int verbose )

inline

Definition at line 72 of file G4CollisionOutput.hh.

72 { verboseLevel = verbose; };

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

geant4.10.03.p01/source/processes/hadronic/models/cascade/cascade/include/G4CollisionOutput.hh
geant4.10.03.p01/source/processes/hadronic/models/cascade/cascade/src/G4CollisionOutput.cc

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation