G4BigBanger Class Reference

#include <G4BigBanger.hh>

Inheritance diagram for G4BigBanger:

Public Member Functions
virtual void	collide (G4InuclParticle *bullet, G4InuclParticle *target, G4CollisionOutput &globalOutput)
virtual void	deExcite (const G4Fragment &target, G4CollisionOutput &output)
	G4BigBanger ()
virtual void	setVerboseLevel (G4int verbose=0)
virtual	~G4BigBanger ()

Protected Member Functions
virtual G4bool	explosion (const G4Fragment &target) const
virtual G4bool	explosion (G4int A, G4int Z, G4double excitation) const
void	getTargetData (const G4Fragment &target)
const G4Fragment &	makeFragment (G4int A, G4int Z, G4double EX=0.)
const G4Fragment &	makeFragment (G4LorentzVector mom, G4int A, G4int Z, G4double EX=0.)
virtual void	setName (const G4String &name)
virtual G4bool	validateOutput (const G4Fragment &target, const std::vector< G4InuclElementaryParticle > &particles)
virtual G4bool	validateOutput (const G4Fragment &target, const std::vector< G4InuclNuclei > &fragments)
virtual G4bool	validateOutput (const G4Fragment &target, G4CollisionOutput &output)

Protected Attributes
G4int	A
G4Fragment	aFragment
G4CascadeCheckBalance *	balance
G4double	EEXS
G4LorentzVector	PEX
G4String	theName
G4int	verboseLevel
G4int	Z

Private Member Functions
	G4BigBanger (const G4BigBanger &)
void	generateBangInSCM (G4double etot, G4int a, G4int z)
void	generateMomentumModules (G4double etot, G4int a, G4int z)
G4double	generateX (G4int ia, G4double promax) const
G4double	maxProbability (G4int a) const
G4BigBanger &	operator= (const G4BigBanger &)
G4double	xProbability (G4double x, G4int a) const

Private Attributes
std::vector< G4double >	momModules
std::vector< G4InuclElementaryParticle >	particles
std::vector< G4LorentzVector >	scm_momentums

Detailed Description

Definition at line 47 of file G4BigBanger.hh.

Constructor & Destructor Documentation

G4BigBanger() [1/2]

G4BigBanger::G4BigBanger

(

)

Definition at line 66 of file G4BigBanger.cc.

: G4CascadeDeexciteBase("G4BigBanger") {}

~G4BigBanger()

virtual G4BigBanger::~G4BigBanger ( )

inlinevirtual

Definition at line 50 of file G4BigBanger.hh.

{};

G4BigBanger() [2/2]

G4BigBanger::G4BigBanger ( const G4BigBanger &  )

private

Member Function Documentation

collide()

void G4VCascadeDeexcitation::collide ( G4InuclParticle *  bullet, G4InuclParticle *  target, G4CollisionOutput &  globalOutput  )

virtualinherited

Implements G4VCascadeCollider.

Definition at line 37 of file G4VCascadeDeexcitation.cc.

                                           {
  if (verboseLevel) {
    G4cout << " >>> G4VCascadeDeexcitation[" << theName << "]::collide "
       << " *** SHOULD NOT BE CALLED ***" << G4endl;
  }
 
  throw G4HadronicException(__FILE__, __LINE__, 
    "G4VCascadeDeexcitation::collide() invalid, must use ::deExcite(G4Fagment*)");
}

References G4cout, G4endl, G4VCascadeCollider::theName, and G4VCascadeCollider::verboseLevel.

Referenced by G4InuclEvaporation::BreakItUp().

deExcite()

void G4BigBanger::deExcite ( const G4Fragment &  target, G4CollisionOutput &  output  )

virtual

Implements G4VCascadeDeexcitation.

Definition at line 68 of file G4BigBanger.cc.

                                                {
  if (verboseLevel) G4cout << " >>> G4BigBanger::deExcite" << G4endl;
 
  getTargetData(target);
  G4ThreeVector toTheLabFrame = PEX.boostVector();  // From rest to lab
 
  // This "should" be difference between E-target and sum of m(nucleons)
  G4double etot = (EEXS - bindingEnergy(A,Z)) * MeV/GeV;  // To Bertini units
  if (etot < 0.0) etot = 0.0;
  
  if (verboseLevel > 2) {
    G4cout << " BigBanger: target\n" << target
       << "\n etot " << etot << G4endl;
  }
 
  if (verboseLevel > 3) {
    G4LorentzVector PEXrest = PEX;
    PEXrest.boost(-toTheLabFrame);
    G4cout << " target rest frame: px " << PEXrest.px() << " py "
       << PEXrest.py() << " pz " << PEXrest.pz() << " E " << PEXrest.e()
       << G4endl;
  }
 
  generateBangInSCM(etot, A, Z);
  
  if (verboseLevel > 2) {
    G4cout << " particles " << particles.size() << G4endl;
    for(G4int i = 0; i < G4int(particles.size()); i++) 
      G4cout << particles[i] << G4endl;
  }
 
  if (particles.empty()) {  // No bang!  Don't know why...
    G4cerr << " >>> G4BigBanger unable to process fragment "
       << target << G4endl;
 
    // FIXME:  This will violate baryon number, momentum, energy, etc.
    return;
  }
 
  // convert back to Lab
  G4LorentzVector totscm;
  G4LorentzVector totlab;
 
  if (verboseLevel > 2) G4cout << " BigBanger: boosting to lab" << G4endl;
 
  particleIterator ipart;
  for(ipart = particles.begin(); ipart != particles.end(); ipart++) {
    G4LorentzVector mom = ipart->getMomentum();
    if (verboseLevel > 2) totscm += mom;
 
    mom.boost(toTheLabFrame);
    if (verboseLevel > 2) totlab += mom;
 
    ipart->setMomentum(mom); 
    if (verboseLevel > 2) G4cout << *ipart << G4endl;
  }
  
  std::sort(particles.begin(), particles.end(), G4ParticleLargerEkin());
 
  validateOutput(target, particles);        // Checks <vector> directly
  
  if (verboseLevel > 2) {
    G4cout << " In SCM: total outgoing momentum " << G4endl 
       << " E " << totscm.e() << " px " << totscm.x()
       << " py " << totscm.y() << " pz " << totscm.z() << G4endl; 
    G4cout << " In Lab: mom cons " << G4endl 
       << " E " << PEX.e() - totlab.e() // PEX now includes EEXS
       << " px " << PEX.x() - totlab.x()
       << " py " << PEX.y() - totlab.y() 
       << " pz " << PEX.z() - totlab.z() << G4endl; 
  }
 
  globalOutput.addOutgoingParticles(particles);
}            

References G4CascadeDeexciteBase::A, G4CollisionOutput::addOutgoingParticles(), G4InuclSpecialFunctions::bindingEnergy(), CLHEP::HepLorentzVector::boost(), CLHEP::HepLorentzVector::boostVector(), CLHEP::HepLorentzVector::e(), G4CascadeDeexciteBase::EEXS, G4cerr, G4cout, G4endl, generateBangInSCM(), G4CascadeDeexciteBase::getTargetData(), GeV, MeV, particles, G4CascadeDeexciteBase::PEX, CLHEP::HepLorentzVector::px(), CLHEP::HepLorentzVector::py(), CLHEP::HepLorentzVector::pz(), G4CascadeDeexciteBase::validateOutput(), G4VCascadeCollider::verboseLevel, CLHEP::HepLorentzVector::x(), CLHEP::HepLorentzVector::y(), CLHEP::HepLorentzVector::z(), and G4CascadeDeexciteBase::Z.

Referenced by G4CascadeDeexcitation::deExcite(), and G4EquilibriumEvaporator::deExcite().

explosion() [1/2]

G4bool G4CascadeDeexciteBase::explosion ( const G4Fragment &  target ) const

protectedvirtualinherited

Reimplemented in G4EquilibriumEvaporator.

Definition at line 109 of file G4CascadeDeexciteBase.cc.

                                                                        {
  return explosion(fragment.GetA_asInt(), fragment.GetZ_asInt(),
           fragment.GetExcitationEnergy());     // in MeV
}

References G4CascadeDeexciteBase::explosion(), G4Fragment::GetA_asInt(), G4Fragment::GetExcitationEnergy(), and G4Fragment::GetZ_asInt().

Referenced by G4CascadeDeexcitation::deExcite(), G4PreCompoundDeexcitation::deExcite(), G4CascadeDeexciteBase::explosion(), and G4EquilibriumEvaporator::explosion().

explosion() [2/2]

G4bool G4CascadeDeexciteBase::explosion ( G4int  A, G4int  Z, G4double  excitation  ) const

protectedvirtualinherited

Reimplemented in G4EquilibriumEvaporator.

Definition at line 114 of file G4CascadeDeexciteBase.cc.

                                                {
  if (verboseLevel) G4cout << " >>> " << theName << "::explosion ?" << G4endl;
 
  const G4int a_cut = 20;
  const G4double be_cut = 3.0;
 
  // Neutron balls, or small fragments with high excitations can explode
  return ((fragA <= a_cut || fragZ==0) && 
      (excitation >= be_cut * bindingEnergy(fragA,fragZ))
      );
}

References G4InuclSpecialFunctions::bindingEnergy(), G4cout, G4endl, G4VCascadeCollider::theName, and G4VCascadeCollider::verboseLevel.

generateBangInSCM()

void G4BigBanger::generateBangInSCM ( G4double  etot, G4int  a, G4int  z  )

private

Definition at line 144 of file G4BigBanger.cc.

                                                                   {
  if (verboseLevel > 3) {
    G4cout << " >>> G4BigBanger::generateBangInSCM" << G4endl;
  }
 
  const G4double ang_cut = 0.9999;
  const G4int itry_max = 1000;
  
  if (verboseLevel > 2) {
    G4cout << " a " << a << " z " << z << G4endl;
  }
 
  particles.clear();    // Reset output vector before filling
  
  if (a == 1) {     // Special -- bare nucleon doesn't really "explode"
    G4int knd = (z>0) ? 1 : 2;
    particles.push_back(G4InuclElementaryParticle(knd)); // zero momentum
    return;
  }
     
  // NOTE:  If distribution fails, need to regenerate magnitudes and angles!
  //*** generateMomentumModules(etot, a, z);
 
  scm_momentums.reserve(a);
  G4LorentzVector tot_mom;
 
  G4bool bad = true;
  G4int itry = 0;
  while(bad && itry < itry_max) {   /* Loop checking 08.06.2015 MHK */
    itry++;
    scm_momentums.clear();
 
    generateMomentumModules(etot, a, z);
    if (a == 2) {
      // This is only a three-vector, not a four-vector
      G4LorentzVector mom = generateWithRandomAngles(momModules[0]);
      scm_momentums.push_back(mom);
      scm_momentums.push_back(-mom);    // Only safe since three-vector!
      bad = false;
    } else {
      tot_mom *= 0.;        // Easy way to reset accumulator
 
      for(G4int i = 0; i < a-2; i++) {      // All but last two are thrown
      // This is only a three-vector, not a four-vector
    G4LorentzVector mom = generateWithRandomAngles(momModules[i]);
    scm_momentums.push_back(mom);
    tot_mom += mom;      
      };
 
      //                handle last two
      G4double tot_mod = tot_mom.rho(); 
      G4double ct = -0.5*(tot_mod*tot_mod + momModules[a-2]*momModules[a-2]
              - momModules[a-1]*momModules[a-1]) / tot_mod
    / momModules[a-2];
 
      if (verboseLevel > 2) G4cout << " ct last " << ct << G4endl;
  
      if(std::fabs(ct) < ang_cut) {
    // This is only a three-vector, not a four-vector
    G4LorentzVector mom2 = generateWithFixedTheta(ct, momModules[a - 2]);
 
    // rotate to the normal system
    G4LorentzVector apr = tot_mom/tot_mod;
    G4double a_tr = std::sqrt(apr.x()*apr.x() + apr.y()*apr.y());
    G4LorentzVector mom;
    mom.setX(mom2.z()*apr.x() + ( mom2.x()*apr.y() + mom2.y()*apr.z()*apr.x())/a_tr);
    mom.setY(mom2.z()*apr.y() + (-mom2.x()*apr.x() + mom2.y()*apr.z()*apr.y())/a_tr);
    mom.setZ(mom2.z()*apr.z() - mom2.y()*a_tr);
 
    scm_momentums.push_back(mom);
 
    // and the last one (again, not actually a four-vector!)
    G4LorentzVector mom1 = -mom - tot_mom;
 
    scm_momentums.push_back(mom1);  
    bad = false;
      } // if (abs(ct) < ang_cut)
    }   // (a > 2)
  } // while (bad && itry<itry_max)
 
  if (!bad) {
    particles.resize(a);    // Use assignment to avoid temporaries
    for(G4int i = 0; i < a; i++) {
      G4int knd = i < z ? 1 : 2;
      particles[i].fill(scm_momentums[i], knd, G4InuclParticle::BigBanger);
    };
  };
 
  if (verboseLevel > 2) {
    if (itry == itry_max) G4cout << " BigBanger -> can not generate bang " << G4endl;
  }
 
  return;
}

References G4InuclParticle::BigBanger, G4cout, G4endl, generateMomentumModules(), G4InuclSpecialFunctions::generateWithFixedTheta(), G4InuclSpecialFunctions::generateWithRandomAngles(), momModules, particles, CLHEP::HepLorentzVector::rho(), scm_momentums, CLHEP::HepLorentzVector::setX(), CLHEP::HepLorentzVector::setY(), CLHEP::HepLorentzVector::setZ(), G4VCascadeCollider::verboseLevel, CLHEP::HepLorentzVector::x(), CLHEP::HepLorentzVector::y(), and CLHEP::HepLorentzVector::z().

Referenced by deExcite().

generateMomentumModules()

void G4BigBanger::generateMomentumModules ( G4double  etot, G4int  a, G4int  z  )

private

Definition at line 239 of file G4BigBanger.cc.

                                                                         {
  if (verboseLevel > 3) {
    G4cout << " >>> G4BigBanger::generateMomentumModules" << G4endl;
  }
 
  // Proton and neutron masses
  const G4double mp = G4InuclElementaryParticle::getParticleMass(1);
  const G4double mn = G4InuclElementaryParticle::getParticleMass(2);
 
  momModules.clear();       // Reset buffer for filling
 
  G4double xtot = 0.0;
 
  if (a > 2) {          // For "large" nuclei, energy is distributed
    G4double promax = maxProbability(a);
 
    momModules.resize(a, 0.);   // Pre-allocate to avoid memory churn
    for(G4int i = 0; i < a; i++) { 
      momModules[i] = generateX(a, promax);
      xtot += momModules[i];
      
      if (verboseLevel > 2) {
    G4cout << " i " << i << " x " << momModules[i] << G4endl;
      }
    }
  } else {          // Two-body case is special, must be 50%
    xtot = 1.;
    momModules.push_back(0.5);
    momModules.push_back(0.5);
  }
 
  for(G4int i = 0; i < a; i++) {
    G4double mass = i < z ? mp : mn;
 
    momModules[i] *= etot/xtot;
    momModules[i] = std::sqrt(momModules[i] * (momModules[i] + 2.0 * mass));
 
    if (verboseLevel > 2) {
      G4cout << " i " << i << " pmod " << momModules[i] << G4endl;
    }
  };
 
  return;  
}

References G4cout, G4endl, generateX(), G4InuclElementaryParticle::getParticleMass(), maxProbability(), momModules, and G4VCascadeCollider::verboseLevel.

Referenced by generateBangInSCM().

generateX()

G4double G4BigBanger::generateX ( G4int  ia, G4double  promax  ) const

private

Definition at line 312 of file G4BigBanger.cc.

                                                              {
  if (verboseLevel > 3) G4cout << " >>> G4BigBanger::generateX" << G4endl;
 
  const G4int itry_max = 1000;
  G4int itry = 0;
  G4double x;
  
  while(itry < itry_max) {  /* Loop checking 08.06.2015 MHK */
    itry++;
    x = inuclRndm();
 
    if(xProbability(x, a) >= promax * inuclRndm()) return x;
  };
  if (verboseLevel > 2) {
    G4cout << " BigBanger -> can not generate x " << G4endl;
  }
 
  return maxProbability(a);
}

References G4cout, G4endl, G4InuclSpecialFunctions::inuclRndm(), maxProbability(), G4VCascadeCollider::verboseLevel, and xProbability().

Referenced by generateMomentumModules().

getTargetData()

void G4CascadeDeexciteBase::getTargetData ( const G4Fragment &  target )

protectedinherited

Definition at line 66 of file G4CascadeDeexciteBase.cc.

                                                                  {
  A = target.GetA_asInt();
  Z = target.GetZ_asInt();
  PEX = target.GetMomentum()/GeV;   // Convert from G4 to Bertini units
  EEXS = target.GetExcitationEnergy();
}

References G4CascadeDeexciteBase::A, G4CascadeDeexciteBase::EEXS, G4Fragment::GetA_asInt(), G4Fragment::GetExcitationEnergy(), G4Fragment::GetMomentum(), G4Fragment::GetZ_asInt(), GeV, G4CascadeDeexciteBase::PEX, and G4CascadeDeexciteBase::Z.

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

makeFragment() [1/2]

const G4Fragment & G4CascadeDeexciteBase::makeFragment ( G4int  A, G4int  Z, G4double  EX = 0.  )

protectedinherited

Definition at line 81 of file G4CascadeDeexciteBase.cc.

                                                                         {
  return makeFragment(zero, fragA, fragZ, EX);
}

References G4CascadeDeexciteBase::makeFragment(), and anonymous_namespace{G4CascadeDeexciteBase.cc}::zero.

makeFragment() [2/2]

const G4Fragment & G4CascadeDeexciteBase::makeFragment ( G4LorentzVector  mom, G4int  A, G4int  Z, G4double  EX = 0.  )

protectedinherited

Definition at line 86 of file G4CascadeDeexciteBase.cc.

                                              {
  if (verboseLevel>2) {
    G4cout << " >>> " << theName << "::makeFragment " << mom << " " << fragA
       << " " << fragZ << " " << EX << G4endl;
  }
 
  // Adjust four-momentum so that mass is nucleus + excitation
  G4double mass =
    G4InuclNuclei::getNucleiMass(fragA,fragZ) + EX/GeV;
  mom.setVectM(mom.vect(), mass);
 
  // Overwrite previous fragment contents, zeroing out excitons
  aFragment.SetZandA_asInt(fragZ, fragA);
  aFragment.SetMomentum(mom*GeV);           // Bertini uses GeV!
  aFragment.SetNumberOfHoles(0,0);
  aFragment.SetNumberOfExcitedParticle(0,0);
 
  return aFragment;
}

References G4CascadeDeexciteBase::aFragment, G4cout, G4endl, G4InuclNuclei::getNucleiMass(), GeV, G4Fragment::SetMomentum(), G4Fragment::SetNumberOfExcitedParticle(), G4Fragment::SetNumberOfHoles(), CLHEP::HepLorentzVector::setVectM(), G4Fragment::SetZandA_asInt(), G4VCascadeCollider::theName, CLHEP::HepLorentzVector::vect(), and G4VCascadeCollider::verboseLevel.

Referenced by G4EquilibriumEvaporator::deExcite(), G4Fissioner::deExcite(), G4NonEquilibriumEvaporator::deExcite(), and G4CascadeDeexciteBase::makeFragment().

maxProbability()

G4double G4BigBanger::maxProbability ( G4int  a ) const

private

Definition at line 304 of file G4BigBanger.cc.

                                                  {
  if (verboseLevel > 3) {
    G4cout << " >>> G4BigBanger::maxProbability" << G4endl;
  }
 
  return xProbability(2./3./(a-1.0), a);
}

References G4cout, G4endl, G4VCascadeCollider::verboseLevel, and xProbability().

Referenced by generateMomentumModules(), and generateX().

operator=()

G4BigBanger & G4BigBanger::operator= ( const G4BigBanger &  )

private

setName()

virtual void G4VCascadeCollider::setName ( const G4String &  name )

inlineprotectedvirtualinherited

Definition at line 55 of file G4VCascadeCollider.hh.

{ theName = name; }

References G4InuclParticleNames::name(), and G4VCascadeCollider::theName.

Referenced by G4CascadeCheckBalance::setOwner().

setVerboseLevel()

void G4CascadeDeexciteBase::setVerboseLevel ( G4int  verbose = 0 )

virtualinherited

Reimplemented from G4VCascadeCollider.

Reimplemented in G4CascadeDeexcitation, G4EquilibriumEvaporator, and G4PreCompoundDeexcitation.

Definition at line 58 of file G4CascadeDeexciteBase.cc.

                                                         {
  G4VCascadeDeexcitation::setVerboseLevel(verbose);
  if (balance) balance->setVerboseLevel(verbose);
}

References G4CascadeDeexciteBase::balance, and G4VCascadeCollider::setVerboseLevel().

Referenced by G4CascadeDeexcitation::setVerboseLevel(), G4EquilibriumEvaporator::setVerboseLevel(), and G4PreCompoundDeexcitation::setVerboseLevel().

validateOutput() [1/3]

G4bool G4CascadeDeexciteBase::validateOutput ( const G4Fragment &  target, const std::vector< G4InuclElementaryParticle > &  particles  )

protectedvirtualinherited

Definition at line 142 of file G4CascadeDeexciteBase.cc.

                                                                    {
  if (!balance) return true;        // Skip checks unless requested
 
  if (verboseLevel > 1)
    G4cout << " >>> " << theName << "::validateOutput" << G4endl;
 
  balance->setVerboseLevel(verboseLevel);
  balance->collide(target, particles);
  return balance->okay();           // Returns false if violations
}

References G4CascadeDeexciteBase::balance, G4CascadeCheckBalance::collide(), G4cout, G4endl, G4CascadeCheckBalance::okay(), G4VCascadeCollider::setVerboseLevel(), G4VCascadeCollider::theName, and G4VCascadeCollider::verboseLevel.

validateOutput() [2/3]

G4bool G4CascadeDeexciteBase::validateOutput ( const G4Fragment &  target, const std::vector< G4InuclNuclei > &  fragments  )

protectedvirtualinherited

Definition at line 154 of file G4CascadeDeexciteBase.cc.

                                                        {
  if (!balance) return true;        // Skip checks unless requested
 
  if (verboseLevel > 1)
    G4cout << " >>> " << theName << "::validateOutput" << G4endl;
 
  balance->setVerboseLevel(verboseLevel);
  balance->collide(target, fragments);
  return balance->okay();           // Returns false if violations
}

References G4CascadeDeexciteBase::balance, G4CascadeCheckBalance::collide(), G4cout, G4endl, G4CascadeCheckBalance::okay(), G4VCascadeCollider::setVerboseLevel(), G4VCascadeCollider::theName, and G4VCascadeCollider::verboseLevel.

validateOutput() [3/3]

G4bool G4CascadeDeexciteBase::validateOutput ( const G4Fragment &  target, G4CollisionOutput &  output  )

protectedvirtualinherited

Definition at line 130 of file G4CascadeDeexciteBase.cc.

                                                    {
  if (!balance) return true;        // Skip checks unless requested
 
  if (verboseLevel > 1)
    G4cout << " >>> " << theName << "::validateOutput" << G4endl;
 
  balance->setVerboseLevel(verboseLevel);
  balance->collide(target, output);
  return balance->okay();           // Returns false if violations
}

References G4CascadeDeexciteBase::balance, G4CascadeCheckBalance::collide(), G4cout, G4endl, G4CascadeCheckBalance::okay(), G4VCascadeCollider::setVerboseLevel(), G4VCascadeCollider::theName, and G4VCascadeCollider::verboseLevel.

Referenced by deExcite(), G4EquilibriumEvaporator::deExcite(), and G4NonEquilibriumEvaporator::deExcite().

xProbability()

G4double G4BigBanger::xProbability ( G4double  x, G4int  a  ) const

private

Definition at line 284 of file G4BigBanger.cc.

                                                            {
  if (verboseLevel > 3) G4cout << " >>> G4BigBanger::xProbability" << G4endl;
 
  G4Pow* theG4Pow = G4Pow::GetInstance();   // For convenience
 
  G4double ekpr = 0.0;
  if(x < 1.0 || x > 0.0) {
    ekpr = x * x;
 
    if (a%2 == 0) { // even A
      ekpr *= std::sqrt(1.0 - x) * theG4Pow->powN((1.0 - x), (3*a-6)/2); 
    }
    else {
      ekpr *= theG4Pow->powN((1.0 - x), (3*a-5)/2);
    };
  }; 
  
  return ekpr;
}

References G4cout, G4endl, G4Pow::GetInstance(), G4Pow::powN(), and G4VCascadeCollider::verboseLevel.

Referenced by generateX(), and maxProbability().

Field Documentation

A

G4int G4CascadeDeexciteBase::A

protectedinherited

Definition at line 73 of file G4CascadeDeexciteBase.hh.

Referenced by deExcite(), G4EquilibriumEvaporator::deExcite(), G4Fissioner::deExcite(), G4NonEquilibriumEvaporator::deExcite(), G4CascadeDeexciteBase::getTargetData(), and mcscore.MCParticle::printout().

aFragment

G4Fragment G4CascadeDeexciteBase::aFragment

protectedinherited

Definition at line 82 of file G4CascadeDeexciteBase.hh.

Referenced by G4CascadeDeexciteBase::makeFragment().

balance

G4CascadeCheckBalance* G4CascadeDeexciteBase::balance

protectedinherited

Definition at line 57 of file G4CascadeDeexciteBase.hh.

Referenced by G4CascadeDeexciteBase::G4CascadeDeexciteBase(), G4CascadeDeexciteBase::setVerboseLevel(), G4CascadeDeexciteBase::validateOutput(), and G4CascadeDeexciteBase::~G4CascadeDeexciteBase().

EEXS

G4double G4CascadeDeexciteBase::EEXS

protectedinherited

Definition at line 76 of file G4CascadeDeexciteBase.hh.

Referenced by deExcite(), G4EquilibriumEvaporator::deExcite(), G4Fissioner::deExcite(), G4NonEquilibriumEvaporator::deExcite(), and G4CascadeDeexciteBase::getTargetData().

momModules

std::vector<G4double> G4BigBanger::momModules

private

Definition at line 63 of file G4BigBanger.hh.

Referenced by generateBangInSCM(), and generateMomentumModules().

particles

std::vector<G4InuclElementaryParticle> G4BigBanger::particles

private

Definition at line 62 of file G4BigBanger.hh.

Referenced by deExcite(), and generateBangInSCM().

PEX

G4LorentzVector G4CascadeDeexciteBase::PEX

protectedinherited

Definition at line 75 of file G4CascadeDeexciteBase.hh.

Referenced by deExcite(), G4EquilibriumEvaporator::deExcite(), G4Fissioner::deExcite(), G4NonEquilibriumEvaporator::deExcite(), and G4CascadeDeexciteBase::getTargetData().

scm_momentums

std::vector<G4LorentzVector> G4BigBanger::scm_momentums

private

Definition at line 64 of file G4BigBanger.hh.

Referenced by generateBangInSCM().

theName

G4String G4VCascadeCollider::theName

protectedinherited

Definition at line 52 of file G4VCascadeCollider.hh.

Referenced by G4CascadeCheckBalance::baryonOkay(), G4CascadeCheckBalance::chargeOkay(), G4VCascadeDeexcitation::collide(), G4CascadeCheckBalance::collide(), G4CascadeCheckBalance::ekinOkay(), G4CascadeCheckBalance::energyOkay(), G4CascadeDeexciteBase::explosion(), G4CascadeRecoilMaker::G4CascadeRecoilMaker(), G4VCascadeCollider::G4VCascadeCollider(), G4CascadeColliderBase::inelasticInteractionPossible(), G4CascadeDeexciteBase::makeFragment(), G4CascadeRecoilMaker::makeRecoilFragment(), G4CascadeRecoilMaker::makeRecoilNuclei(), G4CascadeCheckBalance::momentumOkay(), G4VCascadeCollider::setName(), G4CascadeCheckBalance::strangeOkay(), G4CascadeDeexciteBase::validateOutput(), and G4CascadeColliderBase::validateOutput().

verboseLevel

G4int G4VCascadeCollider::verboseLevel

protectedinherited

Definition at line 53 of file G4VCascadeCollider.hh.

Referenced by G4CascadeCheckBalance::baryonOkay(), G4CascadeCheckBalance::chargeOkay(), G4IntraNucleiCascader::collide(), G4InuclCollider::collide(), G4LightTargetCollider::collide(), G4VCascadeDeexcitation::collide(), G4CascadeCheckBalance::collide(), G4CascadeRecoilMaker::collide(), G4ElementaryParticleCollider::collide(), G4IntraNucleiCascader::copySecondaries(), G4IntraNucleiCascader::copyWoundedNucleus(), G4IntraNucleiCascader::decayTrappedParticle(), G4CascadeDeexcitation::deExcite(), G4InuclCollider::deexcite(), G4PreCompoundDeexcitation::deExcite(), deExcite(), G4EquilibriumEvaporator::deExcite(), G4EvaporationInuclCollider::deExcite(), G4Fissioner::deExcite(), G4NonEquilibriumEvaporator::deExcite(), G4CascadeCheckBalance::ekinOkay(), G4CascadeCheckBalance::energyOkay(), G4EquilibriumEvaporator::explosion(), G4CascadeDeexciteBase::explosion(), G4CascadeRecoilMaker::fillRecoil(), G4IntraNucleiCascader::finalize(), G4IntraNucleiCascader::finishCascade(), G4VCascadeCollider::G4VCascadeCollider(), generateBangInSCM(), G4IntraNucleiCascader::generateCascade(), generateMomentumModules(), G4ElementaryParticleCollider::generateMultiplicity(), G4ElementaryParticleCollider::generateSCMfinalState(), G4ElementaryParticleCollider::generateSCMmuonAbsorption(), G4ElementaryParticleCollider::generateSCMpionAbsorption(), G4ElementaryParticleCollider::generateSCMpionNAbsorption(), generateX(), G4EquilibriumEvaporator::getAF(), G4Fissioner::getC2(), G4EquilibriumEvaporator::getE0(), G4NonEquilibriumEvaporator::getE0(), G4NonEquilibriumEvaporator::getMatrixElement(), G4NonEquilibriumEvaporator::getParLev(), G4EquilibriumEvaporator::getPARLEVDEN(), G4EquilibriumEvaporator::getQF(), G4Fissioner::getZopt(), G4CascadeRecoilMaker::goodNucleus(), G4EquilibriumEvaporator::goodRemnant(), G4CascadeColliderBase::inelasticInteractionPossible(), G4IntraNucleiCascader::initialize(), G4CascadeDeexciteBase::makeFragment(), G4CascadeRecoilMaker::makeRecoilFragment(), G4CascadeRecoilMaker::makeRecoilNuclei(), maxProbability(), G4CascadeCheckBalance::momentumOkay(), G4IntraNucleiCascader::newCascade(), G4InuclCollider::photonuclearOkay(), G4ElementaryParticleCollider::pionNucleonAbsorption(), G4Fissioner::potentialMinimization(), G4IntraNucleiCascader::preloadCascade(), G4IntraNucleiCascader::processSecondary(), G4IntraNucleiCascader::processTrappedParticle(), G4IntraNucleiCascader::releaseSecondary(), G4IntraNucleiCascader::rescatter(), G4InuclCollider::rescatter(), G4IntraNucleiCascader::setupCascade(), G4InuclCollider::setVerboseLevel(), G4LightTargetCollider::setVerboseLevel(), G4VCascadeCollider::setVerboseLevel(), G4CascadeCheckBalance::strangeOkay(), G4InuclCollider::useCascadeDeexcitation(), G4InuclCollider::usePreCompoundDeexcitation(), G4CascadeDeexciteBase::validateOutput(), G4CascadeColliderBase::validateOutput(), G4CascadeRecoilMaker::wholeEvent(), and xProbability().

Z

G4int G4CascadeDeexciteBase::Z

protectedinherited

Definition at line 74 of file G4CascadeDeexciteBase.hh.

Referenced by deExcite(), G4EquilibriumEvaporator::deExcite(), G4Fissioner::deExcite(), G4NonEquilibriumEvaporator::deExcite(), G4CascadeDeexciteBase::getTargetData(), and mcscore.MCParticle::printout().

---

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

• source/processes/hadronic/models/cascade/cascade/include/G4BigBanger.hh
• source/processes/hadronic/models/cascade/cascade/src/G4BigBanger.cc