G4ElementaryParticleCollider Class Reference

#include <G4ElementaryParticleCollider.hh>

Inheritance diagram for G4ElementaryParticleCollider:

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

Additional Inherited Members
Protected Member Functions inherited from G4CascadeColliderBase
virtual G4bool	useEPCollider (G4InuclParticle *bullet, G4InuclParticle *target) const
virtual G4bool	inelasticInteractionPossible (G4InuclParticle *bullet, G4InuclParticle *target, G4double ekin) const
virtual G4bool	validateOutput (G4InuclParticle *bullet, G4InuclParticle *target, G4CollisionOutput &output)
virtual G4bool	validateOutput (const G4Fragment &fragment, G4CollisionOutput &output)
virtual G4bool	validateOutput (G4InuclParticle *bullet, G4InuclParticle *target, const std::vector< G4InuclElementaryParticle > &particles)
Protected Member Functions inherited from G4VCascadeCollider
virtual void	setName (const G4String &name)
Protected Attributes inherited from G4CascadeColliderBase
G4InteractionCase	interCase
G4CascadeCheckBalance *	balance
Protected Attributes inherited from G4VCascadeCollider
G4String	theName
G4int	verboseLevel

Detailed Description

Definition at line 73 of file G4ElementaryParticleCollider.hh.

Constructor & Destructor Documentation

G4ElementaryParticleCollider()

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.

{};

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

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

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

Referenced by G4NucleiModel::generateParticleFate().

---

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

• G4ElementaryParticleCollider.hh
• G4ElementaryParticleCollider.cc