#include <G4CollisionOutput.hh>

Public Member Functions
G4bool	acceptable () const

void	add (const G4CollisionOutput &right)

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

void	addOutgoingNucleus (const G4InuclNuclei &nuclei)

void	addOutgoingParticle (const G4CascadParticle &cparticle)

void	addOutgoingParticle (const G4InuclElementaryParticle &particle)

void	addOutgoingParticles (const G4ReactionProductVector *rproducts)

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

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

void	addRecoilFragment (const G4Fragment &aFragment)

void	addRecoilFragment (const G4Fragment *aFragment)

void	boostToLabFrame (const G4LorentzConvertor &convertor)

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

	G4CollisionOutput ()

std::vector< G4InuclNuclei > &	getOutgoingNuclei ()

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

std::vector< G4InuclElementaryParticle > &	getOutgoingParticles ()

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

const G4Fragment &	getRecoilFragment (G4int index=0) const

std::vector< G4Fragment > &	getRecoilFragments ()

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

double	getRemainingExitationEnergy () const

G4int	getTotalBaryonNumber () const

G4int	getTotalCharge () const

G4LorentzVector	getTotalOutputMomentum () const

G4int	getTotalStrangeness () const

G4int	numberOfFragments () const

G4int	numberOfOutgoingNuclei () const

G4int	numberOfOutgoingParticles () const

G4CollisionOutput &	operator= (const G4CollisionOutput &right)

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

void	removeOutgoingNucleus (const G4InuclNuclei &nuclei)

void	removeOutgoingNucleus (const G4InuclNuclei *nuclei)

void	removeOutgoingNucleus (G4int index)

void	removeOutgoingParticle (const G4InuclElementaryParticle &particle)

void	removeOutgoingParticle (const G4InuclElementaryParticle *particle)

void	removeOutgoingParticle (G4int index)

void	removeRecoilFragment (G4int index=-1)

void	reset ()

void	rotateEvent (const G4LorentzRotation &rotate)

void	setOnShell (G4InuclParticle bullet, G4InuclParticle target)

void	setRemainingExitationEnergy ()

void	setVerboseLevel (G4int verbose)

void	trivialise (G4InuclParticle bullet, G4InuclParticle target)

Private Member Functions
std::pair< std::pair< G4int, G4int >, G4int >	selectPairToTune (G4double de) const

G4bool	tuneSelectedPair (G4LorentzVector &mom1, G4LorentzVector &mom2, G4int mom_index) const

Private Attributes
G4double	eex_rest

G4LorentzVector	mom_non_cons

G4bool	on_shell

std::vector< G4InuclNuclei >	outgoingNuclei

std::vector< G4InuclElementaryParticle >	outgoingParticles

std::vector< G4Fragment >	recoilFragments

G4int	verboseLevel

Static Private Attributes
static const G4Fragment	emptyFragment

Detailed Description

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

References G4cout, G4endl, and verboseLevel.

Member Function Documentation

◆ acceptable()

G4bool G4CollisionOutput::acceptable ( ) const

inline

Definition at line 173 of file G4CollisionOutput.hh.

173{ return on_shell; };

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

References addOutgoingNuclei(), addOutgoingParticles(), eex_rest, on_shell, outgoingNuclei, outgoingParticles, and recoilFragments.

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

References outgoingNuclei.

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

◆ addOutgoingNucleus()

void G4CollisionOutput::addOutgoingNucleus ( const G4InuclNuclei & nuclei )

inline

Definition at line 85 of file G4CollisionOutput.hh.

                                                       {
    outgoingNuclei.push_back(nuclei);
  };

References G4InuclParticleNames::nuclei, and outgoingNuclei.

Referenced by G4CascadeCoalescence::createNuclei(), and G4EquilibriumEvaporator::deExcite().

◆ addOutgoingParticle() [1/2]

void G4CollisionOutput::addOutgoingParticle ( const G4CascadParticle & cparticle )

Definition at line 145 of file G4CollisionOutput.cc.

                                                                             {
  addOutgoingParticle(cparticle.getParticle());
}

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

◆ addOutgoingParticle() [2/2]

void G4CollisionOutput::addOutgoingParticle ( const G4InuclElementaryParticle & particle )

inline

Definition at line 79 of file G4CollisionOutput.hh.

                                                                      {
    outgoingParticles.push_back(particle);
  }

References outgoingParticles.

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

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

◆ 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]);
}

References addOutgoingParticle().

◆ 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());
}

References outgoingParticles.

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

                                                      {
    recoilFragments.push_back(aFragment);
  }

References recoilFragments.

◆ addRecoilFragment() [2/2]

void G4CollisionOutput::addRecoilFragment ( const G4Fragment * aFragment )

inline

Definition at line 98 of file G4CollisionOutput.hh.

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

References addRecoilFragment().

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

References boostToLabFrame(), G4cout, G4endl, GeV, outgoingNuclei, outgoingParticles, recoilFragments, and verboseLevel.

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

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

◆ getOutgoingNuclei() [1/2]

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

inline

Definition at line 140 of file G4CollisionOutput.hh.

140{ return outgoingNuclei; };

References outgoingNuclei.

◆ getOutgoingNuclei() [2/2]

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

inline

Definition at line 136 of file G4CollisionOutput.hh.

                                                            {
    return outgoingNuclei;
  };

References 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 130 of file G4CollisionOutput.hh.

                                                               {
    return outgoingParticles;
  };

References outgoingParticles.

◆ getOutgoingParticles() [2/2]

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

inline

Definition at line 126 of file G4CollisionOutput.hh.

                                                                           {
    return outgoingParticles;
  };

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

References emptyFragment, numberOfFragments(), and recoilFragments.

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

150{ return recoilFragments; };

References recoilFragments.

◆ getRecoilFragments() [2/2]

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

inline

Definition at line 146 of file G4CollisionOutput.hh.

                                                          {
    return recoilFragments;
  };

References recoilFragments.

◆ getRemainingExitationEnergy()

double G4CollisionOutput::getRemainingExitationEnergy ( ) const

inline

Definition at line 172 of file G4CollisionOutput.hh.

172{ return eex_rest; };

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

References G4InuclParticleNames::baryon(), G4cout, G4endl, numberOfFragments(), numberOfOutgoingNuclei(), numberOfOutgoingParticles(), outgoingNuclei, outgoingParticles, recoilFragments, and verboseLevel.

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

References G4cout, G4endl, numberOfFragments(), numberOfOutgoingNuclei(), numberOfOutgoingParticles(), outgoingNuclei, outgoingParticles, recoilFragments, and verboseLevel.

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

References G4cout, G4endl, GeV, numberOfFragments(), numberOfOutgoingNuclei(), numberOfOutgoingParticles(), outgoingNuclei, outgoingParticles, recoilFragments, and verboseLevel.

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

References G4cout, G4endl, numberOfOutgoingParticles(), outgoingParticles, and verboseLevel.

Referenced by G4CascadeCheckBalance::collide().

◆ numberOfFragments()

G4int G4CollisionOutput::numberOfFragments ( ) const

inline

Definition at line 142 of file G4CollisionOutput.hh.

142{ return recoilFragments.size(); }

References recoilFragments.

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

◆ numberOfOutgoingNuclei()

G4int G4CollisionOutput::numberOfOutgoingNuclei ( ) const

inline

Definition at line 134 of file G4CollisionOutput.hh.

134{ return outgoingNuclei.size(); };

References outgoingNuclei.

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

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

References eex_rest, on_shell, outgoingNuclei, outgoingParticles, recoilFragments, and verboseLevel.

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

References G4endl, numberOfFragments(), numberOfOutgoingNuclei(), numberOfOutgoingParticles(), outgoingNuclei, outgoingParticles, and recoilFragments.

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

References G4InuclParticleNames::nuclei, outgoingNuclei, and pos.

◆ removeOutgoingNucleus() [2/3]

void G4CollisionOutput::removeOutgoingNucleus ( const G4InuclNuclei * nuclei )

inline

Definition at line 116 of file G4CollisionOutput.hh.

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

References G4InuclParticleNames::nuclei, and removeOutgoingNucleus().

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

References numberOfOutgoingNuclei(), and outgoingNuclei.

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

References outgoingParticles, and pos.

◆ removeOutgoingParticle() [2/3]

void G4CollisionOutput::removeOutgoingParticle ( const G4InuclElementaryParticle * particle )

inline

Definition at line 110 of file G4CollisionOutput.hh.

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

References removeOutgoingParticle().

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

References numberOfOutgoingParticles(), and outgoingParticles.

Referenced by G4CascadeCoalescence::removeNucleons(), and 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);
}

References numberOfFragments(), and recoilFragments.

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

References eex_rest, on_shell, outgoingNuclei, outgoingParticles, and recoilFragments.

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

References G4cout, G4endl, outgoingNuclei, outgoingParticles, recoilFragments, and verboseLevel.

◆ selectPairToTune()

std::pair< std::pair< G4int, G4int >, G4int > G4CollisionOutput::selectPairToTune ( G4double de ) const

private

Definition at line 630 of file G4CollisionOutput.cc.

                                                     {
  if (verboseLevel > 2)
    G4cout << " >>> G4CollisionOutput::selectPairToTune" << G4endl;
 
  std::pair<G4int, G4int> tup(-1, -1);
  G4int i3 = -1; 
  std::pair<std::pair<G4int, G4int>, G4int> tuner(tup, i3); // Set invalid
 
  if (outgoingParticles.size() < 2) return tuner;   // Nothing to do
 
  G4int ibest1 = -1;
  G4int ibest2 = -1;  
  G4double pbest = 0.0;
  G4double pcut = 0.3 * std::sqrt(1.88 * std::fabs(de));
  G4double p1 = 0.0;
  
  for (G4int i = 0; i < G4int(outgoingParticles.size())-1; i++) {
    G4LorentzVector mom1 = outgoingParticles[i].getMomentum();
    
    for (G4int j = i+1; j < G4int(outgoingParticles.size()); j++) {
      G4LorentzVector mom2 = outgoingParticles[j].getMomentum();
      
      for (G4int l = G4LorentzVector::X; l<=G4LorentzVector::Z; l++) {
    if (mom1[l]*mom2[l]<0.0) { 
      if (std::fabs(mom1[l])>pcut && std::fabs(mom2[l])>pcut) {
        G4double psum = std::fabs(mom1[l]) + std::fabs(mom2[l]);  
        
        if (psum > pbest) {
          ibest1 = i;
          ibest2 = j;
          i3 = l;
          p1 = mom1[l];
          pbest = psum;
        }   // psum > pbest
      } // mom1 and mom2 > pcut
    }   // mom1 ~ -mom2
      } // for (G4int l ...
    }   // for (G4int j ...
  } // for (G4int i ...
 
  if (i3 < 0) return tuner;     
  
  tuner.second = i3;        // Momentum axis for tuning
  
  // NOTE: Sign of de determines order for special case of p1==0.
  if (de > 0.0) {
    tuner.first.first  = (p1>0.) ? ibest1 : ibest2;
    tuner.first.second = (p1>0.) ? ibest2 : ibest1;
  } else {
    tuner.first.first  = (p1<0.) ? ibest2 : ibest1;
    tuner.first.second = (p1<0.) ? ibest1 : ibest2;
  }      
  
  return tuner;
}

References G4cout, G4endl, outgoingParticles, verboseLevel, CLHEP::HepLorentzVector::X, and CLHEP::HepLorentzVector::Z.

Referenced by setOnShell().

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

References eex_rest, GeV, numberOfFragments(), numberOfOutgoingNuclei(), outgoingNuclei, and recoilFragments.

Referenced by setOnShell().

◆ setVerboseLevel()

void G4CollisionOutput::setVerboseLevel ( G4int verbose )

inline

Definition at line 71 of file G4CollisionOutput.hh.

71{ verboseLevel = verbose; };

References verboseLevel.

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

References G4cout, G4endl, outgoingNuclei, outgoingParticles, reset(), and verboseLevel.

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

◆ tuneSelectedPair()

G4bool G4CollisionOutput::tuneSelectedPair	(	G4LorentzVector &	mom1,
		G4LorentzVector &	mom2,
		G4int	mom_index
	)		const

private

Definition at line 687 of file G4CollisionOutput.cc.

                                             {
  if (verboseLevel > 2)
    G4cout << " >>> G4CollisionOutput::tuneSelectedPair" << G4endl;
 
  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 : tuning failed" << G4endl;
    return false;
  }
 
  // 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 false;
  }
 
  mom1[mom_ind] += x;         // retune momentums
  mom2[mom_ind] -= x;
  return true;
}

References CLHEP::HepLorentzVector::e(), G4cout, G4endl, mom_non_cons, Q, and verboseLevel.

Referenced by setOnShell().

Field Documentation

◆ eex_rest

G4double G4CollisionOutput::eex_rest

private

Definition at line 187 of file G4CollisionOutput.hh.

Referenced by add(), getRemainingExitationEnergy(), operator=(), reset(), setOnShell(), and setRemainingExitationEnergy().

◆ emptyFragment

const G4Fragment G4CollisionOutput::emptyFragment

staticprivate

Definition at line 181 of file G4CollisionOutput.hh.

Referenced by getRecoilFragment().

◆ mom_non_cons

G4LorentzVector G4CollisionOutput::mom_non_cons

private

Definition at line 188 of file G4CollisionOutput.hh.

Referenced by setOnShell(), and tuneSelectedPair().

◆ on_shell

G4bool G4CollisionOutput::on_shell

private

Definition at line 189 of file G4CollisionOutput.hh.

Referenced by acceptable(), add(), operator=(), reset(), and setOnShell().

◆ outgoingNuclei

std::vector<G4InuclNuclei> G4CollisionOutput::outgoingNuclei

private

◆ outgoingParticles

std::vector<G4InuclElementaryParticle> G4CollisionOutput::outgoingParticles

private

◆ recoilFragments

std::vector<G4Fragment> G4CollisionOutput::recoilFragments

private

Definition at line 180 of file G4CollisionOutput.hh.

Referenced by add(), addRecoilFragment(), boostToLabFrame(), getRecoilFragment(), getRecoilFragments(), getTotalBaryonNumber(), getTotalCharge(), getTotalOutputMomentum(), numberOfFragments(), operator=(), printCollisionOutput(), removeRecoilFragment(), reset(), rotateEvent(), setOnShell(), and setRemainingExitationEnergy().

◆ verboseLevel

G4int G4CollisionOutput::verboseLevel

private

Definition at line 176 of file G4CollisionOutput.hh.

Referenced by addOutgoingParticles(), boostToLabFrame(), G4CollisionOutput(), getTotalBaryonNumber(), getTotalCharge(), getTotalOutputMomentum(), getTotalStrangeness(), operator=(), rotateEvent(), selectPairToTune(), setOnShell(), setVerboseLevel(), trivialise(), and tuneSelectedPair().

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

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

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

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

◆ selectPairToTune()

◆ setOnShell()

◆ setRemainingExitationEnergy()

◆ setVerboseLevel()

◆ trivialise()

◆ tuneSelectedPair()

Field Documentation

◆ eex_rest

◆ emptyFragment

◆ mom_non_cons

◆ on_shell

◆ outgoingNuclei

◆ outgoingParticles

◆ recoilFragments

◆ verboseLevel