G4LightTargetCollider Class Reference

#include <G4LightTargetCollider.hh>

Inheritance diagram for G4LightTargetCollider:

Public Member Functions
	G4LightTargetCollider ()
virtual	~G4LightTargetCollider ()
void	collide (G4InuclParticle *bullet, G4InuclParticle *target, G4CollisionOutput &globalOutput)
void	setVerboseLevel (G4int verbose=0)
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 52 of file G4LightTargetCollider.hh.

Constructor & Destructor Documentation

G4LightTargetCollider()

G4LightTargetCollider::G4LightTargetCollider

(

)

Definition at line 55 of file G4LightTargetCollider.cc.

 : G4CascadeColliderBase("G4LightTargetCollider"),
   theElementaryParticleCollider(new G4ElementaryParticleCollider)
{
  mP = G4Proton::Proton()->GetPDGMass()/CLHEP::GeV;
  mN = G4Neutron::Neutron()->GetPDGMass()/CLHEP::GeV;
  mD = G4Deuteron::Deuteron()->GetPDGMass()/CLHEP::GeV;
  pFermiD = 0.045;  // Fermi momentum of nucleon in deuteron Hulthen potential
}

~G4LightTargetCollider()

G4LightTargetCollider::~G4LightTargetCollider ( )

virtual

Definition at line 65 of file G4LightTargetCollider.cc.

                                              {
  delete theElementaryParticleCollider;
}

Member Function Documentation

collide()

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

virtual

Implements G4VCascadeCollider.

Definition at line 78 of file G4LightTargetCollider.cc.

{
  if (verboseLevel) {
    G4cout << " >>> G4LightTargetCollider::collide" << G4endl;
    G4cout << "     Projectile: " << bullet->getDefinition()->GetParticleName() << G4endl; 
    G4cout << "     Target: " << target->getDefinition()->GetParticleName() << G4endl;
  }
 
  G4double ke = bullet->getKineticEnergy();
 
  if (target->getDefinition() == G4Proton::Proton() ) {
    if (ke < 0.1447) {
      // Below threshold lab energy for pi0 creation 
      globalOutput.trivialise(bullet, target);
    } else {
      // Need inelastic cross section in this class if we want to replace ElementaryParticleCollider 
      // with SingleNucleonScattering
      theElementaryParticleCollider->collide(bullet, target, globalOutput);
      if (globalOutput.numberOfOutgoingParticles() == 0) globalOutput.trivialise(bullet, target);
    }
 
  } else if (target->getDefinition() == G4Deuteron::Deuteron() ) {
 
    if (ke < mP + mN - mD) {
      // Should not happen as long as inelastic cross section is zero
      G4Exception("G4LightTargetCollider::collide()","HAD_BERT_201",
                  JustWarning, "Projectile energy below reaction threshold");
      globalOutput.trivialise(bullet, target);
 
    } else {
      // Get p, n and deuteron cross sections; use lab energy to access 
      G4double gammaPXS = G4CascadeChannelTables::GetTable(9)->getCrossSection(ke);
      G4double gammaNXS = G4CascadeChannelTables::GetTable(18)->getCrossSection(ke);
      G4double gammaDXS = GammaDCrossSection(ke);
 
      G4double probP = 0.0;
      G4double probN = 0.0;
      // Highest threshold is 0.152 (for gamma p -> n pi+)
      // Because of Fermi momentum in deuteron, raise this to 0.159
      if (ke > 0.159) {
        G4double totalDXS = gammaPXS + gammaNXS + gammaDXS;
        probP = gammaPXS/totalDXS;
        probN = (gammaPXS+gammaNXS)/totalDXS;
      }
 
      G4double rndm = G4UniformRand();
      if (rndm < probP) {
        // Generate Fermi momenta of bullet and target
        G4ThreeVector fermiMomentum = pFermiD*G4RandomDirection();
        G4LorentzVector protonMomentum(fermiMomentum, std::sqrt(mP*mP + pFermiD*pFermiD) );
        G4LorentzVector neutronMomentum(-fermiMomentum, std::sqrt(mN*mN + pFermiD*pFermiD) );
 
        G4LorentzVector bulletMomentum = bullet->getMomentum();
        G4ThreeVector betacm = bulletMomentum.findBoostToCM(protonMomentum);
 
        // First boost bullet and target so that target is at rest
        G4ThreeVector toProtonRest = -protonMomentum.boostVector();
        protonMomentum.boost(toProtonRest);
        bulletMomentum.boost(toProtonRest);
 
        G4InuclElementaryParticle projectile(bulletMomentum, bullet->getDefinition() );
        G4InuclElementaryParticle targetNucleon(protonMomentum, G4Proton::Proton() );
        G4InuclElementaryParticle spectatorNucleon(neutronMomentum, G4Neutron::Neutron() );
        ScatteringProducts products = SingleNucleonScattering(projectile, targetNucleon);
 
        // Particles from SingleNucleonScattering are in CM frame of projectile 
        // and moving proton.  Transform back to lab frame with -betacm, then
        // add them to outgoing list.
        globalOutput.reset();
        G4LorentzVector temp;
        for (G4int i = 0; i < G4int(products.size()); i++) {
          temp = products[i].getMomentum();
          temp.boost(-betacm);
          products[i].setMomentum(temp);
          globalOutput.addOutgoingParticle(products[i]);
        }
 
        // Add the recoil nucleon unmodified
        globalOutput.addOutgoingParticle(spectatorNucleon);
 
      } else if (rndm < probN) {
        G4ThreeVector fermiMomentum = pFermiD*G4RandomDirection();
        G4LorentzVector protonMomentum(fermiMomentum, std::sqrt(mP*mP + pFermiD*pFermiD) );
        G4LorentzVector neutronMomentum(-fermiMomentum, std::sqrt(mN*mN + pFermiD*pFermiD) );
 
        G4LorentzVector bulletMomentum = bullet->getMomentum();
        G4ThreeVector betacm = bulletMomentum.findBoostToCM(neutronMomentum);
 
        // First boost bullet and target so that target is at rest
        G4ThreeVector toNeutronRest = -neutronMomentum.boostVector();
        neutronMomentum.boost(toNeutronRest);
        bulletMomentum.boost(toNeutronRest);
 
        G4InuclElementaryParticle projectile(bulletMomentum, bullet->getDefinition() );
        G4InuclElementaryParticle targetNucleon(neutronMomentum, G4Neutron::Neutron() );
        G4InuclElementaryParticle spectatorNucleon(protonMomentum, G4Proton::Proton() );
 
        ScatteringProducts products = SingleNucleonScattering(projectile, targetNucleon);
 
        // Particles from SingleNucleonScattering are in CM frame of projectile
        // and moving neutron.  Transform back to lab frame with -betacm, then add
        // them to outgoing list
        globalOutput.reset();
        G4LorentzVector temp;
        for (G4int i = 0; i < G4int(products.size()); i++) {
          temp = products[i].getMomentum();
          temp.boost(-betacm);
          products[i].setMomentum(temp);
          globalOutput.addOutgoingParticle(products[i]);
        }
 
        // Add the recoil nucleon unmodified
        globalOutput.addOutgoingParticle(spectatorNucleon);
 
      } else {
        NucleonPair products = AbsorptionOnDeuteron(bullet);
        globalOutput.reset();
        globalOutput.addOutgoingParticle(products.first);
        globalOutput.addOutgoingParticle(products.second);
      }
    }  // Energy above threshold ?
 
    // Test code
    // G4int numPart = globalOutput.numberOfOutgoingParticles();
    // std::vector<G4InuclElementaryParticle> testList = globalOutput.getOutgoingParticles();
    // G4LorentzVector sumP;
    // G4cout << " Global output " << G4endl;
    // for (G4int i = 0; i < numPart; i++) {
    //  sumP += testList[i].getMomentum();
    //  G4cout << testList[i] << G4endl;
    // }
    // G4cout << " Global 4-momentum sum = " << sumP << G4endl;
    // G4cout << " Initial lab energy = " << mD + bullet->getEnergy() << G4endl;
 
  } else {
    G4Exception("G4LightTargetCollider::collide()","HAD_BERT_203",
                FatalException, "Scattering from this target not implemented");
  } 
 
  return;
}

Referenced by G4CascadeInterface::ApplyYourself().

setVerboseLevel()

void G4LightTargetCollider::setVerboseLevel ( G4int  verbose = 0 )

virtual

Reimplemented from G4CascadeColliderBase.

Definition at line 71 of file G4LightTargetCollider.cc.

                                                         {
  G4CascadeColliderBase::setVerboseLevel(verbose);
  theElementaryParticleCollider->setVerboseLevel(verboseLevel);
  output.setVerboseLevel(verboseLevel);
}

---

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

• G4LightTargetCollider.hh
• G4LightTargetCollider.cc