G4ElementaryParticleCollider Class Reference

#include <G4ElementaryParticleCollider.hh>

Inheritance diagram for G4ElementaryParticleCollider:

Public Member Functions
void	collide (G4InuclParticle *bullet, G4InuclParticle *target, G4CollisionOutput &output)
	G4ElementaryParticleCollider ()
virtual void	rescatter (G4InuclParticle *, G4KineticTrackVector *, G4V3DNucleus *, G4CollisionOutput &)
void	setNucleusState (G4int a, G4int z)
virtual void	setVerboseLevel (G4int verbose=0)
virtual	~G4ElementaryParticleCollider ()

Protected Member Functions
virtual G4bool	inelasticInteractionPossible (G4InuclParticle *bullet, G4InuclParticle *target, G4double ekin) const
virtual void	setName (const G4String &name)
virtual G4bool	useEPCollider (G4InuclParticle *bullet, G4InuclParticle *target) const
virtual G4bool	validateOutput (const G4Fragment &fragment, G4CollisionOutput &output)
virtual G4bool	validateOutput (G4InuclParticle *bullet, G4InuclParticle *target, const std::vector< G4InuclElementaryParticle > &particles)
virtual G4bool	validateOutput (G4InuclParticle *bullet, G4InuclParticle *target, G4CollisionOutput &output)

Protected Attributes
G4CascadeCheckBalance *	balance
G4InteractionCase	interCase
G4String	theName
G4int	verboseLevel

Private Member Functions
void	fillOutgoingMasses ()
	G4ElementaryParticleCollider (const G4ElementaryParticleCollider &)
G4int	generateMultiplicity (G4int is, G4double ekin) const
void	generateOutgoingPartTypes (G4int is, G4int mult, G4double ekin)
void	generateSCMfinalState (G4double ekin, G4double etot_scm, G4InuclElementaryParticle *particle1, G4InuclElementaryParticle *particle2)
void	generateSCMmuonAbsorption (G4double etot_scm, G4InuclElementaryParticle *particle1, G4InuclElementaryParticle *particle2)
void	generateSCMpionAbsorption (G4double etot_scm, G4InuclElementaryParticle *particle1, G4InuclElementaryParticle *particle2)
void	generateSCMpionNAbsorption (G4double etot_scm, G4InuclElementaryParticle *particle1, G4InuclElementaryParticle *particle2)
G4ElementaryParticleCollider &	operator= (const G4ElementaryParticleCollider &)
G4bool	pionNucleonAbsorption (G4double ekin) const

Private Attributes
G4CascadeFinalStateGenerator	fsGenerator
std::vector< G4double >	masses
std::vector< G4double >	masses2
std::vector< G4double >	modules
G4int	nucleusA
G4int	nucleusZ
std::vector< G4int >	particle_kinds
std::vector< G4InuclElementaryParticle >	particles
std::vector< G4LorentzVector >	scm_momentums

Detailed Description

Definition at line 73 of file G4ElementaryParticleCollider.hh.

Constructor & Destructor Documentation

G4ElementaryParticleCollider() [1/2]

G4ElementaryParticleCollider::G4ElementaryParticleCollider

(

)

Definition at line 137 of file G4ElementaryParticleCollider.cc.

  : G4CascadeColliderBase("G4ElementaryParticleCollider"),
    nucleusA(0), nucleusZ(0) {;}

~G4ElementaryParticleCollider()

virtual G4ElementaryParticleCollider::~G4ElementaryParticleCollider ( )

inlinevirtual

Definition at line 76 of file G4ElementaryParticleCollider.hh.

{};

G4ElementaryParticleCollider() [2/2]

G4ElementaryParticleCollider::G4ElementaryParticleCollider ( const G4ElementaryParticleCollider &  )

private

Member Function Documentation

collide()

void G4ElementaryParticleCollider::collide ( G4InuclParticle *  bullet, G4InuclParticle *  target, G4CollisionOutput &  output  )

virtual

Implements G4VCascadeCollider.

Definition at line 143 of file G4ElementaryParticleCollider.cc.

{
  if (verboseLevel > 1)
    G4cout << " >>> G4ElementaryParticleCollider::collide" << G4endl;
 
  if (!useEPCollider(bullet,target)) {      // Sanity check
    G4cerr << " ElementaryParticleCollider -> can collide only particle with particle " 
           << G4endl;
    return;
  }
 
#ifdef G4CASCADE_DEBUG_SAMPLER
  static G4bool doPrintTables = true;   // Once and only once per job
  if (doPrintTables) {
    G4CascadeChannelTables::Print();
    doPrintTables = false;
  }
#endif
 
  interCase.set(bullet, target);    // To identify kind of collision
 
  if (verboseLevel > 1) G4cout << *bullet << G4endl << *target << G4endl;
 
  G4InuclElementaryParticle* particle1 =
    dynamic_cast<G4InuclElementaryParticle*>(bullet);
  G4InuclElementaryParticle* particle2 =    
    dynamic_cast<G4InuclElementaryParticle*>(target);
 
  if (!particle1 || !particle2) {   // Redundant with useEPCollider()
    G4cerr << " ElementaryParticleCollider -> can only collide hadrons"
           << G4endl;
    return;
  }
 
  if (particle1->isNeutrino() || particle2->isNeutrino()) return;
 
  // Check for available interaction, or pion+dibaryon special case
  if (!G4CascadeChannelTables::GetTable(interCase.hadrons()) &&
      !particle1->quasi_deutron() && !particle2->quasi_deutron()) {
    G4cerr << " ElementaryParticleCollider -> cannot collide " 
       << particle1->getDefinition()->GetParticleName() << " with "
           << particle2->getDefinition()->GetParticleName() << G4endl;
    return;
  }
 
  G4LorentzConvertor convertToSCM;  // Utility to handle frame manipulation
  if (particle2->nucleon() || particle2->quasi_deutron()) {
    convertToSCM.setBullet(particle1);
    convertToSCM.setTarget(particle2);
  } else {
    convertToSCM.setBullet(particle2);
    convertToSCM.setTarget(particle1);
  }
 
  convertToSCM.setVerbose(verboseLevel);
  convertToSCM.toTheCenterOfMass();
 
  G4double etot_scm = convertToSCM.getTotalSCMEnergy();
 
  // Generate any particle collision with nucleon
  if (particle1->nucleon() || particle2->nucleon()) {
    G4double ekin = convertToSCM.getKinEnergyInTheTRS();
 
    // SPECIAL:  Very low energy pions may be absorbed by a nucleon
    if (pionNucleonAbsorption(ekin)) {
      generateSCMpionNAbsorption(etot_scm, particle1, particle2);
    } else {
      generateSCMfinalState(ekin, etot_scm, particle1, particle2);
    }
  }
 
  // Generate pion or photon collision with quasi-deuteron
  if (particle1->quasi_deutron() || particle2->quasi_deutron()) {
    if (!G4NucleiModel::useQuasiDeuteron(particle1->type(),particle2->type()) &&
    !G4NucleiModel::useQuasiDeuteron(particle2->type(),particle1->type())) {
      G4cerr << " ElementaryParticleCollider -> can only collide pi,mu,gamma with"
         << " dibaryons " << G4endl;
      return;
    }
 
    if (particle1->isMuon() || particle2->isMuon()) {
      generateSCMmuonAbsorption(etot_scm, particle1, particle2);
    } else {        // Currently, pion absoprtion also handles gammas
      generateSCMpionAbsorption(etot_scm, particle1, particle2);
    }
  }    
 
  if (particles.empty()) {  // No final state possible, pass bullet through
    if (verboseLevel) {
      G4cerr << " ElementaryParticleCollider -> failed to collide " 
         << particle1->getMomModule() << " GeV/c " 
         << particle1->getDefinition()->GetParticleName() << " with "
         << particle2->getDefinition()->GetParticleName() << G4endl;
    }
    return;
  }
 
  // Convert final state back to lab frame
  G4LorentzVector mom;      // Buffer to avoid memory churn
  particleIterator ipart;
  for(ipart = particles.begin(); ipart != particles.end(); ipart++) {   
    mom = convertToSCM.backToTheLab(ipart->getMomentum());
    ipart->setMomentum(mom); 
  };
 
  if (verboseLevel) {
    // Check conservation in multibody final state
    const G4ParticleDefinition* bDef = bullet->getDefinition();
    const G4ParticleDefinition* tDef = target->getDefinition();
 
    G4int initBaryonNumber = bDef->GetBaryonNumber() + tDef->GetBaryonNumber();
    G4int initCharge = bullet->getCharge() + target->getCharge();
    G4int initStrangeness = bDef->GetQuarkContent(3) - bDef->GetAntiQuarkContent(3) +
                            tDef->GetQuarkContent(3) - tDef->GetAntiQuarkContent(3);
 
    G4int finalBaryonNumber = 0;
    G4int finalCharge = 0;
    G4int finalStrangeness = 0;
 
    for (ipart = particles.begin(); ipart != particles.end(); ipart++) {
      finalBaryonNumber += ipart->baryon();
      finalCharge += ipart->getCharge();
      finalStrangeness += ipart->getStrangeness();
    }
 
    G4int bnc = finalBaryonNumber - initBaryonNumber;
    G4int cnc = finalCharge - initCharge;
    G4int snc = finalStrangeness - initStrangeness;
 
    if (bnc != 0 || cnc != 0 || snc != 0) {
      G4cout << " G4ElementaryParticleCollider: quantum number non-conservation " << G4endl;
      G4cout << "   Baryon number: initial = " << initBaryonNumber << ", final = "
                                               << finalBaryonNumber << G4endl;
      G4cout << "   Charge: initial = " << initCharge << ", final = "
                                        << finalCharge << G4endl;
      G4cout << "   Strangeness: initial = " << initStrangeness << ", final = "
                                             << finalStrangeness << G4endl;
 
      G4cout << " bullet = " << bDef->GetParticleName() << G4endl;
      G4cout << " target = " << tDef->GetParticleName() << G4endl;
      G4cout << " secondaries = " ;
      for (ipart = particles.begin(); ipart != particles.end(); ipart++) {
        G4cout << ipart->getDefinition()->GetParticleName() << " " ;
      }
      G4cout << G4endl;
    }
  }
 
  if (verboseLevel && !validateOutput(bullet, target, particles)) {
    G4cout << " incoming particles: \n" << *particle1 << G4endl
       << *particle2 << G4endl
       << " outgoing particles: " << G4endl;
    for(ipart = particles.begin(); ipart != particles.end(); ipart++)
      G4cout << *ipart << G4endl;
    
    G4cout << " <<< Non-conservation in G4ElementaryParticleCollider"
       << G4endl;
  }
    
  std::sort(particles.begin(), particles.end(), G4ParticleLargerEkin());
  output.addOutgoingParticles(particles);
}

References G4CollisionOutput::addOutgoingParticles(), G4LorentzConvertor::backToTheLab(), G4cerr, G4cout, G4endl, generateSCMfinalState(), generateSCMmuonAbsorption(), generateSCMpionAbsorption(), generateSCMpionNAbsorption(), G4ParticleDefinition::GetAntiQuarkContent(), G4ParticleDefinition::GetBaryonNumber(), G4InuclParticle::getCharge(), G4InuclParticle::getDefinition(), G4LorentzConvertor::getKinEnergyInTheTRS(), G4InuclParticle::getMomModule(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetQuarkContent(), G4CascadeChannelTables::GetTable(), G4LorentzConvertor::getTotalSCMEnergy(), G4InteractionCase::hadrons(), G4CascadeColliderBase::interCase, G4InuclElementaryParticle::isMuon(), G4InuclElementaryParticle::isNeutrino(), G4InuclElementaryParticle::nucleon(), particles, pionNucleonAbsorption(), G4CascadeChannelTables::Print(), G4InuclElementaryParticle::quasi_deutron(), G4InteractionCase::set(), G4LorentzConvertor::setBullet(), G4LorentzConvertor::setTarget(), G4LorentzConvertor::setVerbose(), G4LorentzConvertor::toTheCenterOfMass(), G4InuclElementaryParticle::type(), G4CascadeColliderBase::useEPCollider(), G4NucleiModel::useQuasiDeuteron(), G4CascadeColliderBase::validateOutput(), and G4VCascadeCollider::verboseLevel.

Referenced by G4InuclCollider::collide(), G4LightTargetCollider::collide(), and G4NucleiModel::generateParticleFate().

fillOutgoingMasses()

void G4ElementaryParticleCollider::fillOutgoingMasses ( )

private

Definition at line 425 of file G4ElementaryParticleCollider.cc.

                                                      {
  G4int mult = particle_kinds.size();
 
  masses.resize(mult,0.);
  masses2.resize(mult,0.);      // Allows direct [i] setting
 
  for (G4int i = 0; i < mult; i++) {
    masses[i] = G4InuclElementaryParticle::getParticleMass(particle_kinds[i]);
    masses2[i] = masses[i] * masses[i];
  }
}

References G4InuclElementaryParticle::getParticleMass(), masses, masses2, and particle_kinds.

Referenced by generateSCMfinalState(), generateSCMmuonAbsorption(), generateSCMpionAbsorption(), and generateSCMpionNAbsorption().

generateMultiplicity()

G4int G4ElementaryParticleCollider::generateMultiplicity ( G4int  is, G4double  ekin  ) const

private

Definition at line 310 of file G4ElementaryParticleCollider.cc.

{
  G4int mul = 0;
 
  const G4CascadeChannel* xsecTable = G4CascadeChannelTables::GetTable(is);
 
  if (xsecTable) mul = xsecTable->getMultiplicity(ekin);
  else {
    G4cerr << " G4ElementaryParticleCollider: Unknown interaction channel "
       << is << " - multiplicity not generated " << G4endl;
  }
 
  if(verboseLevel > 3){
    G4cout << " G4ElementaryParticleCollider::generateMultiplicity: "  
           << " multiplicity = " << mul << G4endl; 
  }
 
  return mul;
}

References G4cerr, G4cout, G4endl, G4CascadeChannel::getMultiplicity(), G4CascadeChannelTables::GetTable(), and G4VCascadeCollider::verboseLevel.

Referenced by generateSCMfinalState().

generateOutgoingPartTypes()

void G4ElementaryParticleCollider::generateOutgoingPartTypes ( G4int  is, G4int  mult, G4double  ekin  )

private

Definition at line 333 of file G4ElementaryParticleCollider.cc.

{
  particle_kinds.clear();   // Initialize buffer for generation
 
  const G4CascadeChannel* xsecTable = G4CascadeChannelTables::GetTable(is);
 
  if (xsecTable)
    xsecTable->getOutgoingParticleTypes(particle_kinds, mult, ekin);
  else {
    G4cerr << " G4ElementaryParticleCollider: Unknown interaction channel "
       << is << " - outgoing kinds not generated " << G4endl;
  }
 
  return;
}

References G4cerr, G4endl, G4CascadeChannel::getOutgoingParticleTypes(), G4CascadeChannelTables::GetTable(), and particle_kinds.

Referenced by generateSCMfinalState().

generateSCMfinalState()

void G4ElementaryParticleCollider::generateSCMfinalState ( G4double  ekin, G4double  etot_scm, G4InuclElementaryParticle *  particle1, G4InuclElementaryParticle *  particle2  )

private

Definition at line 352 of file G4ElementaryParticleCollider.cc.

                                                                   {
  if (verboseLevel > 2) {
    G4cout << " >>> G4ElementaryParticleCollider::generateSCMfinalState" 
           << G4endl;
  }
 
  fsGenerator.SetVerboseLevel(verboseLevel);
 
  const G4int itry_max = 10;
 
  G4int type1 = particle1->type();
  G4int type2 = particle2->type();
 
  G4int is = type1 * type2;
 
  if (verboseLevel > 3) G4cout << " is " << is << G4endl;
 
  G4int multiplicity = 0;
  G4bool generate = true;
 
  G4int itry = 0;
  while (generate && itry++ < itry_max) {  /* Loop checking 08.06.2015 MHK */
    particles.clear();      // Initialize buffers for this event
    particle_kinds.clear();
 
    // Generate list of final-state particles
    multiplicity = generateMultiplicity(is, ekin);
 
    generateOutgoingPartTypes(is, multiplicity, ekin);
    if (particle_kinds.empty()) {
      if (verboseLevel > 3) {
    G4cout << " generateOutgoingPartTypes failed mult " << multiplicity
           << G4endl;
      }
      continue;
    }
 
    fillOutgoingMasses();   // Fill mass buffer from particle types
 
    // Attempt to produce final state kinematics
    fsGenerator.Configure(particle1, particle2, particle_kinds);
    generate = !fsGenerator.Generate(etot_scm, masses, scm_momentums);
  } // while (generate) 
 
  if (itry >= itry_max) {       // Unable to generate valid final state
    if (verboseLevel > 2)
      G4cout << " generateSCMfinalState failed " << itry << " attempts"
         << G4endl;
    return;
  }
 
  // Store generated momenta into outgoing particles
 
  particles.resize(multiplicity);       // Preallocate buffer
  for (G4int i=0; i<multiplicity; i++) {
    particles[i].fill(scm_momentums[i], particle_kinds[i],
              G4InuclParticle::EPCollider);
  }
 
  if (verboseLevel > 3) {
    G4cout << " <<< G4ElementaryParticleCollider::generateSCMfinalState"
       << G4endl;
  }
 
  return;   // Particles buffer filled
}

References G4CascadeFinalStateGenerator::Configure(), G4InuclParticle::EPCollider, fillOutgoingMasses(), fsGenerator, G4cout, G4endl, G4INCL::PhaseSpaceGenerator::generate(), G4HadDecayGenerator::Generate(), generateMultiplicity(), generateOutgoingPartTypes(), masses, particle_kinds, particles, scm_momentums, G4HadDecayGenerator::SetVerboseLevel(), G4InuclElementaryParticle::type(), and G4VCascadeCollider::verboseLevel.

Referenced by collide().

generateSCMmuonAbsorption()

void G4ElementaryParticleCollider::generateSCMmuonAbsorption ( G4double  etot_scm, G4InuclElementaryParticle *  particle1, G4InuclElementaryParticle *  particle2  )

private

Definition at line 499 of file G4ElementaryParticleCollider.cc.

{
  if (verboseLevel > 3)
    G4cout << " >>> G4ElementaryParticleCollider::generateSCMmuonAbsorption"
           << G4endl;
 
  particles.clear();            // Initialize buffers for this event
  particles.resize(3);
 
  scm_momentums.clear();
  scm_momentums.resize(3);
 
  particle_kinds.clear();
 
  G4int typeProduct = particle1->type() * particle2->type();
 
  if (typeProduct == G4int(mum)*G4int(diproton)) {
    particle_kinds.push_back(pro);
    particle_kinds.push_back(neu);
  } else if (typeProduct == G4int(mum)*G4int(unboundPN)) {
    particle_kinds.push_back(neu);
    particle_kinds.push_back(neu);
  } else {
    G4cerr << " Illegal absorption: "
           << particle1->getDefinition()->GetParticleName() << " + "
           << particle2->getDefinition()->GetParticleName() << " -> ?"
           << G4endl;
    return;
  }
  particle_kinds.push_back(mnu);
  
  fillOutgoingMasses();
 
  // Phase space generator required for the 3-body final state
  G4GDecay3 breakup(etot_scm, masses[0], masses[1], masses[2]);
  std::vector<G4ThreeVector> theMomenta = breakup.GetThreeBodyMomenta();
 
  if (theMomenta.empty()) {
    G4cerr << " generateSCMmuonAbsorption: GetThreeBodyMomenta() failed"
       << " for " << particle2->type() << " dibaryon" << G4endl;
    particle_kinds.clear();
    masses.clear();
    particles.clear();
    return;
  }
 
  for (size_t i=0; i<3; i++) {
    scm_momentums[i].setVectM(theMomenta[i], masses[i]);
    particles[i].fill(scm_momentums[i], particle_kinds[i], G4InuclParticle::EPCollider);
  }
} 

References G4InuclParticleNames::diproton, G4InuclParticle::EPCollider, fillOutgoingMasses(), G4cerr, G4cout, G4endl, G4InuclParticle::getDefinition(), G4ParticleDefinition::GetParticleName(), G4GDecay3::GetThreeBodyMomenta(), masses, G4InuclParticleNames::mnu, G4InuclParticleNames::mum, G4InuclParticleNames::neu, particle_kinds, particles, G4InuclParticleNames::pro, scm_momentums, G4InuclElementaryParticle::type(), G4InuclParticleNames::unboundPN, and G4VCascadeCollider::verboseLevel.

Referenced by collide().

generateSCMpionAbsorption()

void G4ElementaryParticleCollider::generateSCMpionAbsorption ( G4double  etot_scm, G4InuclElementaryParticle *  particle1, G4InuclElementaryParticle *  particle2  )

private

Definition at line 442 of file G4ElementaryParticleCollider.cc.

{
  if (verboseLevel > 3)
    G4cout << " >>> G4ElementaryParticleCollider::generateSCMpionAbsorption" 
       << G4endl;
 
  particles.clear();        // Initialize buffers for this event
  particles.resize(2);
 
  particle_kinds.clear();
 
  G4int typeProduct = particle1->type() * particle2->type();
 
  if (typeProduct == G4int(pi0)*G4int(diproton) || typeProduct == G4int(pip)*G4int(unboundPN) ||
      typeProduct == G4int(gam)*G4int(diproton)) {
    particle_kinds.push_back(pro);
    particle_kinds.push_back(pro);
 
  } else if (typeProduct == G4int(pim)*G4int(diproton) || typeProduct == G4int(pip)*G4int(dineutron) ||
             typeProduct == G4int(pi0)*G4int(unboundPN) || typeProduct == G4int(gam)*G4int(unboundPN)) {
    particle_kinds.push_back(pro);
    particle_kinds.push_back(neu);
 
  } else if (typeProduct == G4int(pi0)*G4int(dineutron) || typeProduct == G4int(pim)*G4int(unboundPN) ||
             typeProduct == G4int(gam)*G4int(dineutron)) {
    particle_kinds.push_back(neu);
    particle_kinds.push_back(neu);
 
  } else {
    G4cerr << " Illegal absorption: "
           << particle1->getDefinition()->GetParticleName() << " + "
           << particle2->getDefinition()->GetParticleName() << " -> ?"
           << G4endl;
    return;
  }
 
  fillOutgoingMasses();
 
  G4double a = 0.5 * (etot_scm * etot_scm - masses2[0] - masses2[1]);
 
  G4double pmod = std::sqrt((a*a - masses2[0]*masses2[1])
                / (etot_scm*etot_scm) );
  G4LorentzVector mom1 = generateWithRandomAngles(pmod, masses[0]);
  G4LorentzVector mom2;
  mom2.setVectM(-mom1.vect(), masses[1]);
 
  particles[0].fill(mom1, particle_kinds[0], G4InuclParticle::EPCollider);
  particles[1].fill(mom2, particle_kinds[1], G4InuclParticle::EPCollider);
}

References G4InuclParticleNames::dineutron, G4InuclParticleNames::diproton, G4InuclParticle::EPCollider, fillOutgoingMasses(), G4cerr, G4cout, G4endl, G4InuclParticleNames::gam, G4InuclSpecialFunctions::generateWithRandomAngles(), G4InuclParticle::getDefinition(), G4ParticleDefinition::GetParticleName(), masses, masses2, G4InuclParticleNames::neu, particle_kinds, particles, G4InuclParticleNames::pi0, G4InuclParticleNames::pim, G4InuclParticleNames::pip, G4InuclParticleNames::pro, CLHEP::HepLorentzVector::setVectM(), G4InuclElementaryParticle::type(), G4InuclParticleNames::unboundPN, CLHEP::HepLorentzVector::vect(), and G4VCascadeCollider::verboseLevel.

Referenced by collide().

generateSCMpionNAbsorption()

void G4ElementaryParticleCollider::generateSCMpionNAbsorption ( G4double  etot_scm, G4InuclElementaryParticle *  particle1, G4InuclElementaryParticle *  particle2  )

private

Definition at line 557 of file G4ElementaryParticleCollider.cc.

                                                               {
  if (verboseLevel > 3)
    G4cout << " >>> G4ElementaryParticleCollider::generateSCMpionNAbsorption" 
       << G4endl;
 
  particles.clear();        // Initialize buffers for this event
  particles.resize(1);
 
  particle_kinds.clear();
 
  G4int type1 = particle1->type();
  G4int type2 = particle2->type();
 
  // Ensure that single-nucleon absportion is valid (charge exchangeable)
  if ((type1*type2 != pim*pro && type1*type2 != pip*neu)) {
    G4cerr << " pion-nucleon absorption: "
       << particle1->getDefinition()->GetParticleName() << " + "
       << particle2->getDefinition()->GetParticleName() << " -> ?"
       << G4endl;
    return;
  }
 
  // Get outgoing nucleon type using charge exchange
  // Proton code is 1, neutron code is 2, so 3-# swaps them
  G4int ntype = (particle2->nucleon() ? type2 : type1);
  G4int outType = 3 - ntype;
  particle_kinds.push_back(outType);
 
  fillOutgoingMasses();
 
  // Get mass of residual nucleus (2-ntype = 1 for proton, 0 for neutron)
  G4double mRecoil =
    G4InuclNuclei::getNucleiMass(nucleusA-1, nucleusZ-(2-ntype));
  G4double mRecoil2 = mRecoil*mRecoil;
 
  // Recompute Ecm to include nucleus (for recoil kinematics)
  G4LorentzVector piN4 = particle1->getMomentum() + particle2->getMomentum();
  G4LorentzVector vsum(0.,0.,0.,mRecoil);
  vsum += piN4;
 
  // Two-body kinematics (nucleon against nucleus) in overall CM system
  G4double esq_scm = vsum.m2();
  G4double a = 0.5 * (esq_scm - masses2[0] - mRecoil2);
 
  G4double pmod = std::sqrt((a*a - masses2[0]*mRecoil2) / esq_scm );
  G4LorentzVector mom1 = generateWithRandomAngles(pmod, masses[0]);
 
  if (verboseLevel > 3) {
    G4cout << " outgoing type " << outType << " recoiling on nuclear mass "
       << mRecoil << "\n a " << a << " p " << pmod << " Ekin "
       << mom1.e()-masses[0] << G4endl;
  }
 
  mom1.boost(-piN4.boostVector());  // Boost into CM of pi-N collision
 
  if (verboseLevel > 3) {
    G4cout << " in original pi-N frame p(SCM) " << mom1.rho() << " Ekin "
       << mom1.e()-masses[0] << G4endl;
  }
 
  // Fill only the ejected nucleon
  particles[0].fill(mom1, particle_kinds[0], G4InuclParticle::EPCollider);
}

References CLHEP::HepLorentzVector::boost(), CLHEP::HepLorentzVector::boostVector(), CLHEP::HepLorentzVector::e(), G4InuclParticle::EPCollider, fillOutgoingMasses(), G4cerr, G4cout, G4endl, G4InuclSpecialFunctions::generateWithRandomAngles(), G4InuclParticle::getDefinition(), G4InuclParticle::getMomentum(), G4InuclNuclei::getNucleiMass(), G4ParticleDefinition::GetParticleName(), CLHEP::HepLorentzVector::m2(), masses, masses2, G4InuclParticleNames::neu, G4InuclElementaryParticle::nucleon(), nucleusA, nucleusZ, particle_kinds, particles, G4InuclParticleNames::pim, G4InuclParticleNames::pip, G4InuclParticleNames::pro, CLHEP::HepLorentzVector::rho(), G4InuclElementaryParticle::type(), and G4VCascadeCollider::verboseLevel.

Referenced by collide().

inelasticInteractionPossible()

G4bool G4CascadeColliderBase::inelasticInteractionPossible ( G4InuclParticle *  bullet, G4InuclParticle *  target, G4double  ekin  ) const

protectedvirtualinherited

Definition at line 85 of file G4CascadeColliderBase.cc.

                                                 {
  if (verboseLevel) {
    G4cout << " >>> " << theName << "::inelasticInteractionPossible" << G4endl;
  }
 
  // If hadron-hadron collision, defer to ElementaryParticleCollider
  if (useEPCollider(bullet, target)) return true;
 
  // See which one of the two (or both) is a nucleus, get properties
  // FIXME:  Should set a = baryon() for both, but that's not in base
  G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet);
  G4double ab = nuclei_bullet ? nuclei_bullet->getA() : 1;  // FIXME
  G4double zb = nuclei_bullet ? nuclei_bullet->getZ() : bullet->getCharge();
  
  G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target);
  G4double at = nuclei_target ? nuclei_target->getA() : 1;  // FIXME
  G4double zt = nuclei_target ? nuclei_target->getZ() : target->getCharge();
  
  // VCOL (Coulomb barrier) used for testing if elastic collision necessary
  const G4double coeff = 0.001 * 1.2;
 
  G4double VCOL = coeff * zt * zb / (G4cbrt(at) + G4cbrt(ab)); 
  
  G4bool possible = true;   // Force inelastic; should be (ekin >= VCOL)
 
  if (verboseLevel > 3) {
    G4cout << " VCOL: " << VCOL << " ekin: " << ekin << " inelastic possible: "
       << possible << G4endl;
  }
 
  return possible;
}

References ab, G4InuclSpecialFunctions::G4cbrt(), G4cout, G4endl, G4InuclNuclei::getA(), G4InuclParticle::getCharge(), G4InuclNuclei::getZ(), G4VCascadeCollider::theName, G4CascadeColliderBase::useEPCollider(), and G4VCascadeCollider::verboseLevel.

Referenced by G4InuclCollider::collide().

operator=()

G4ElementaryParticleCollider & G4ElementaryParticleCollider::operator= ( const G4ElementaryParticleCollider &  )

private

pionNucleonAbsorption()

G4bool G4ElementaryParticleCollider::pionNucleonAbsorption ( G4double  ekin ) const

private

Definition at line 626 of file G4ElementaryParticleCollider.cc.

                                                                       {
  if (verboseLevel > 3)
    G4cout << " >>> G4ElementaryParticleCollider::pionNucleonAbsorption ?"
           << " ekin " << ekin << " is " << interCase.hadrons() << G4endl;
 
  // Absorption occurs with specified probability
  const G4double absProb = G4CascadeParameters::piNAbsorption();
 
  // Absorption occurs only for pi- p -> n, or pi+ n -> p
  // Restrict to "very slow" pions, to allow for some normal scattering
  return ((interCase.hadrons() == pim*pro ||
       interCase.hadrons() == pip*neu)
      && (ekin < 0.05)      // 50 MeV kinetic energy or less
      && (G4UniformRand() < absProb)
      );
}

References G4cout, G4endl, G4UniformRand, G4InteractionCase::hadrons(), G4CascadeColliderBase::interCase, G4InuclParticleNames::neu, G4InuclParticleNames::pim, G4CascadeParameters::piNAbsorption(), G4InuclParticleNames::pip, G4InuclParticleNames::pro, and G4VCascadeCollider::verboseLevel.

Referenced by collide().

rescatter()

virtual void G4CascadeColliderBase::rescatter ( G4InuclParticle *  , G4KineticTrackVector *  , G4V3DNucleus *  , G4CollisionOutput &    )

inlinevirtualinherited

Reimplemented in G4IntraNucleiCascader, and G4InuclCollider.

Definition at line 68 of file G4CascadeColliderBase.hh.

                                   { ; }

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

setNucleusState()

void G4ElementaryParticleCollider::setNucleusState ( G4int  a, G4int  z  )

inline

Definition at line 81 of file G4ElementaryParticleCollider.hh.

                                         {  // Nucleus to use for recoil
    nucleusA = a; nucleusZ = z;
  }

References nucleusA, and nucleusZ.

Referenced by G4NucleiModel::generateParticleFate().

setVerboseLevel()

void G4CascadeColliderBase::setVerboseLevel ( G4int  verbose = 0 )

virtualinherited

Reimplemented from G4VCascadeCollider.

Reimplemented in G4IntraNucleiCascader, G4InuclCollider, and G4LightTargetCollider.

Definition at line 67 of file G4CascadeColliderBase.cc.

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

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

Referenced by G4IntraNucleiCascader::setVerboseLevel(), G4InuclCollider::setVerboseLevel(), and G4LightTargetCollider::setVerboseLevel().

useEPCollider()

G4bool G4CascadeColliderBase::useEPCollider ( G4InuclParticle *  bullet, G4InuclParticle *  target  ) const

protectedvirtualinherited

Definition at line 75 of file G4CascadeColliderBase.cc.

                                                       {
  return (dynamic_cast<G4InuclElementaryParticle*>(bullet) &&
      dynamic_cast<G4InuclElementaryParticle*>(target));
}

Referenced by G4InuclCollider::collide(), collide(), and G4CascadeColliderBase::inelasticInteractionPossible().

validateOutput() [1/3]

G4bool G4CascadeColliderBase::validateOutput ( const G4Fragment &  fragment, G4CollisionOutput &  output  )

protectedvirtualinherited

Definition at line 139 of file G4CascadeColliderBase.cc.

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

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

validateOutput() [2/3]

G4bool G4CascadeColliderBase::validateOutput ( G4InuclParticle *  bullet, G4InuclParticle *  target, const std::vector< G4InuclElementaryParticle > &  particles  )

protectedvirtualinherited

Definition at line 151 of file G4CascadeColliderBase.cc.

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

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

validateOutput() [3/3]

G4bool G4CascadeColliderBase::validateOutput ( G4InuclParticle *  bullet, G4InuclParticle *  target, G4CollisionOutput &  output  )

protectedvirtualinherited

Definition at line 123 of file G4CascadeColliderBase.cc.

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

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

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

Field Documentation

balance

G4CascadeCheckBalance* G4CascadeColliderBase::balance

protectedinherited

Definition at line 88 of file G4CascadeColliderBase.hh.

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

fsGenerator

G4CascadeFinalStateGenerator G4ElementaryParticleCollider::fsGenerator

private

Definition at line 114 of file G4ElementaryParticleCollider.hh.

Referenced by generateSCMfinalState().

interCase

G4InteractionCase G4CascadeColliderBase::interCase

protectedinherited

Definition at line 76 of file G4CascadeColliderBase.hh.

Referenced by G4InuclCollider::collide(), collide(), G4IntraNucleiCascader::finishCascade(), G4IntraNucleiCascader::generateCascade(), G4IntraNucleiCascader::initialize(), G4IntraNucleiCascader::newCascade(), G4InuclCollider::photonuclearOkay(), pionNucleonAbsorption(), and G4IntraNucleiCascader::setupCascade().

masses

std::vector<G4double> G4ElementaryParticleCollider::masses

private

Definition at line 120 of file G4ElementaryParticleCollider.hh.

Referenced by fillOutgoingMasses(), generateSCMfinalState(), generateSCMmuonAbsorption(), generateSCMpionAbsorption(), and generateSCMpionNAbsorption().

masses2

std::vector<G4double> G4ElementaryParticleCollider::masses2

private

Definition at line 121 of file G4ElementaryParticleCollider.hh.

Referenced by fillOutgoingMasses(), generateSCMpionAbsorption(), and generateSCMpionNAbsorption().

modules

std::vector<G4double> G4ElementaryParticleCollider::modules

private

Definition at line 119 of file G4ElementaryParticleCollider.hh.

nucleusA

G4int G4ElementaryParticleCollider::nucleusA

private

Definition at line 125 of file G4ElementaryParticleCollider.hh.

Referenced by generateSCMpionNAbsorption(), and setNucleusState().

nucleusZ

G4int G4ElementaryParticleCollider::nucleusZ

private

Definition at line 125 of file G4ElementaryParticleCollider.hh.

Referenced by generateSCMpionNAbsorption(), and setNucleusState().

particle_kinds

std::vector<G4int> G4ElementaryParticleCollider::particle_kinds

private

Definition at line 122 of file G4ElementaryParticleCollider.hh.

Referenced by fillOutgoingMasses(), generateOutgoingPartTypes(), generateSCMfinalState(), generateSCMmuonAbsorption(), generateSCMpionAbsorption(), and generateSCMpionNAbsorption().

particles

std::vector<G4InuclElementaryParticle> G4ElementaryParticleCollider::particles

private

Definition at line 117 of file G4ElementaryParticleCollider.hh.

Referenced by collide(), generateSCMfinalState(), generateSCMmuonAbsorption(), generateSCMpionAbsorption(), and generateSCMpionNAbsorption().

scm_momentums

std::vector<G4LorentzVector> G4ElementaryParticleCollider::scm_momentums

private

Definition at line 118 of file G4ElementaryParticleCollider.hh.

Referenced by generateSCMfinalState(), and generateSCMmuonAbsorption().

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(), collide(), G4IntraNucleiCascader::copySecondaries(), G4IntraNucleiCascader::copyWoundedNucleus(), G4IntraNucleiCascader::decayTrappedParticle(), G4CascadeDeexcitation::deExcite(), G4InuclCollider::deexcite(), G4PreCompoundDeexcitation::deExcite(), G4BigBanger::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(), G4BigBanger::generateBangInSCM(), G4IntraNucleiCascader::generateCascade(), G4BigBanger::generateMomentumModules(), generateMultiplicity(), generateSCMfinalState(), generateSCMmuonAbsorption(), generateSCMpionAbsorption(), generateSCMpionNAbsorption(), G4BigBanger::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(), G4BigBanger::maxProbability(), G4CascadeCheckBalance::momentumOkay(), G4IntraNucleiCascader::newCascade(), G4InuclCollider::photonuclearOkay(), 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 G4BigBanger::xProbability().

---

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

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