G4CollisionOutput Class Reference

#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::G4CollisionOutput

(

)

Definition at line 84 of file G4CollisionOutput.cc.

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

Member Function Documentation

acceptable()

G4bool G4CollisionOutput::acceptable ( ) const

inline

Definition at line 173 of file G4CollisionOutput.hh.

{ return on_shell; };

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

add()

void G4CollisionOutput::add

(

const G4CollisionOutput &

right

)

Definition at line 123 of file G4CollisionOutput.cc.

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

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

addOutgoingNuclei()

void G4CollisionOutput::addOutgoingNuclei

(

const std::vector< G4InuclNuclei > &

nuclea

)

Definition at line 139 of file G4CollisionOutput.cc.

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

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

addOutgoingNucleus()

void G4CollisionOutput::addOutgoingNucleus ( const G4InuclNuclei &  nuclei )

inline

Definition at line 85 of file G4CollisionOutput.hh.

                                                       {
    outgoingNuclei.push_back(nuclei);
  };

Referenced by G4EquilibriumEvaporator::deExcite().

addOutgoingParticle() [1/2]

void G4CollisionOutput::addOutgoingParticle

(

const G4CascadParticle &

cparticle

)

Definition at line 145 of file G4CollisionOutput.cc.

                                                                             {
  addOutgoingParticle(cparticle.getParticle());
}

addOutgoingParticle() [2/2]

void G4CollisionOutput::addOutgoingParticle ( const G4InuclElementaryParticle &  particle )

inline

Definition at line 79 of file G4CollisionOutput.hh.

                                                                      {
    outgoingParticles.push_back(particle);
  }

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

addOutgoingParticles() [1/3]

void G4CollisionOutput::addOutgoingParticles

(

const G4ReactionProductVector *

rproducts

)

Definition at line 156 of file G4CollisionOutput.cc.

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

addOutgoingParticles() [2/3]

void G4CollisionOutput::addOutgoingParticles

(

const std::vector< G4CascadParticle > &

cparticles

)

Definition at line 149 of file G4CollisionOutput.cc.

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

addOutgoingParticles() [3/3]

void G4CollisionOutput::addOutgoingParticles

(

const std::vector< G4InuclElementaryParticle > &

particles

)

Definition at line 134 of file G4CollisionOutput.cc.

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

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

addRecoilFragment() [1/2]

void G4CollisionOutput::addRecoilFragment ( const G4Fragment &  aFragment )

inline

Definition at line 102 of file G4CollisionOutput.hh.

                                                      {
    recoilFragments.push_back(aFragment);
  }

addRecoilFragment() [2/2]

void G4CollisionOutput::addRecoilFragment ( const G4Fragment *  aFragment )

inline

Definition at line 98 of file G4CollisionOutput.hh.

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

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

boostToLabFrame() [1/2]

void G4CollisionOutput::boostToLabFrame

(

const G4LorentzConvertor &

convertor

)

Definition at line 322 of file G4CollisionOutput.cc.

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

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

boostToLabFrame() [2/2]

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

Definition at line 350 of file G4CollisionOutput.cc.

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

getOutgoingNuclei() [1/2]

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

inline

Definition at line 140 of file G4CollisionOutput.hh.

{ return outgoingNuclei; };

getOutgoingNuclei() [2/2]

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

inline

Definition at line 136 of file G4CollisionOutput.hh.

                                                            {
    return outgoingNuclei;
  };

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

getOutgoingParticles() [1/2]

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

inline

Definition at line 130 of file G4CollisionOutput.hh.

                                                               {
    return outgoingParticles;
  };

getOutgoingParticles() [2/2]

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

inline

Definition at line 126 of file G4CollisionOutput.hh.

                                                                           {
    return outgoingParticles;
  };

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

getRecoilFragment()

const G4Fragment & G4CollisionOutput::getRecoilFragment

(

G4int

index = 0

)

const

Definition at line 115 of file G4CollisionOutput.cc.

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

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

getRecoilFragments() [1/2]

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

inline

Definition at line 150 of file G4CollisionOutput.hh.

{ return recoilFragments; };

getRecoilFragments() [2/2]

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

inline

Definition at line 146 of file G4CollisionOutput.hh.

                                                          {
    return recoilFragments;
  };

getRemainingExitationEnergy()

double G4CollisionOutput::getRemainingExitationEnergy ( ) const

inline

Definition at line 172 of file G4CollisionOutput.hh.

{ return eex_rest; };

getTotalBaryonNumber()

G4int G4CollisionOutput::getTotalBaryonNumber

(

)

const

Definition at line 271 of file G4CollisionOutput.cc.

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

Referenced by G4CascadeCheckBalance::collide().

getTotalCharge()

G4int G4CollisionOutput::getTotalCharge

(

)

const

Definition at line 251 of file G4CollisionOutput.cc.

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

Referenced by G4CascadeCheckBalance::collide().

getTotalOutputMomentum()

G4LorentzVector G4CollisionOutput::getTotalOutputMomentum

(

)

const

Definition at line 232 of file G4CollisionOutput.cc.

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

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

getTotalStrangeness()

G4int G4CollisionOutput::getTotalStrangeness

(

)

const

Definition at line 290 of file G4CollisionOutput.cc.

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

Referenced by G4CascadeCheckBalance::collide().

numberOfFragments()

G4int G4CollisionOutput::numberOfFragments ( ) const

inline

Definition at line 142 of file G4CollisionOutput.hh.

{ return recoilFragments.size(); }

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.

{ return outgoingNuclei.size(); };

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

numberOfOutgoingParticles()

G4int G4CollisionOutput::numberOfOutgoingParticles ( ) const

inline

Definition at line 124 of file G4CollisionOutput.hh.

{ return outgoingParticles.size(); }

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

operator=()

G4CollisionOutput & G4CollisionOutput::operator=

(

const G4CollisionOutput &

right

)

Definition at line 91 of file G4CollisionOutput.cc.

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

printCollisionOutput()

void G4CollisionOutput::printCollisionOutput

(

std::ostream &

os = G4cout

)

const

Definition at line 304 of file G4CollisionOutput.cc.

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

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

removeOutgoingNucleus() [1/3]

void G4CollisionOutput::removeOutgoingNucleus

(

const G4InuclNuclei &

nuclei

)

Definition at line 215 of file G4CollisionOutput.cc.

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

removeOutgoingNucleus() [2/3]

void G4CollisionOutput::removeOutgoingNucleus ( const G4InuclNuclei *  nuclei )

inline

Definition at line 116 of file G4CollisionOutput.hh.

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

removeOutgoingNucleus() [3/3]

void G4CollisionOutput::removeOutgoingNucleus

(

G4int

index

)

Definition at line 202 of file G4CollisionOutput.cc.

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

Referenced by removeOutgoingNucleus().

removeOutgoingParticle() [1/3]

void G4CollisionOutput::removeOutgoingParticle

(

const G4InuclElementaryParticle &

particle

)

Definition at line 209 of file G4CollisionOutput.cc.

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

removeOutgoingParticle() [2/3]

void G4CollisionOutput::removeOutgoingParticle ( const G4InuclElementaryParticle *  particle )

inline

Definition at line 110 of file G4CollisionOutput.hh.

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

removeOutgoingParticle() [3/3]

void G4CollisionOutput::removeOutgoingParticle

(

G4int

index

)

Definition at line 197 of file G4CollisionOutput.cc.

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

Referenced by removeOutgoingParticle().

removeRecoilFragment()

void G4CollisionOutput::removeRecoilFragment

(

G4int

index = -1

)

Definition at line 223 of file G4CollisionOutput.cc.

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

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

reset()

void G4CollisionOutput::reset

(

)

Definition at line 104 of file G4CollisionOutput.cc.

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

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

rotateEvent()

void G4CollisionOutput::rotateEvent

(

const G4LorentzRotation &

rotate

)

Definition at line 361 of file G4CollisionOutput.cc.

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

setOnShell()

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

Definition at line 406 of file G4CollisionOutput.cc.

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

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

setRemainingExitationEnergy()

void G4CollisionOutput::setRemainingExitationEnergy

(

)

Definition at line 619 of file G4CollisionOutput.cc.

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

Referenced by setOnShell().

setVerboseLevel()

void G4CollisionOutput::setVerboseLevel ( G4int  verbose )

inline

Definition at line 71 of file G4CollisionOutput.hh.

{ verboseLevel = verbose; };

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

trivialise()

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

Definition at line 381 of file G4CollisionOutput.cc.

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

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

---

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

• G4CollisionOutput.hh
• G4CollisionOutput.cc