G4LightTargetCollider Class Reference

#include <G4LightTargetCollider.hh>

Inheritance diagram for G4LightTargetCollider:

Public Member Functions
void	collide (G4InuclParticle *bullet, G4InuclParticle *target, G4CollisionOutput &globalOutput)
	G4LightTargetCollider ()
virtual void	rescatter (G4InuclParticle *, G4KineticTrackVector *, G4V3DNucleus *, G4CollisionOutput &)
void	setVerboseLevel (G4int verbose=0)
virtual	~G4LightTargetCollider ()

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
NucleonPair	AbsorptionOnDeuteron (G4InuclParticle *bullet)
	G4LightTargetCollider (const G4LightTargetCollider &)
G4double	GammaDCrossSection (G4double)
G4LightTargetCollider &	operator= (const G4LightTargetCollider &)
ScatteringProducts	SingleNucleonScattering (const G4InuclElementaryParticle &projectile, const G4InuclElementaryParticle &targetNucleon)

Private Attributes
G4CascadeFinalStateGenerator	fsGen
G4double	mD
G4double	mN
G4double	mP
G4CollisionOutput	output
G4double	pFermiD
G4ElementaryParticleCollider *	theElementaryParticleCollider

Detailed Description

Definition at line 52 of file G4LightTargetCollider.hh.

Constructor & Destructor Documentation

G4LightTargetCollider() [1/2]

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
}

References G4Deuteron::Deuteron(), G4ParticleDefinition::GetPDGMass(), CLHEP::GeV, mD, mN, mP, G4Neutron::Neutron(), pFermiD, and G4Proton::Proton().

~G4LightTargetCollider()

G4LightTargetCollider::~G4LightTargetCollider ( )

virtual

Definition at line 65 of file G4LightTargetCollider.cc.

                                              {
  delete theElementaryParticleCollider;
}

References theElementaryParticleCollider.

G4LightTargetCollider() [2/2]

G4LightTargetCollider::G4LightTargetCollider ( const G4LightTargetCollider &  )

private

Member Function Documentation

AbsorptionOnDeuteron()

NucleonPair G4LightTargetCollider::AbsorptionOnDeuteron ( G4InuclParticle *  bullet )

private

Definition at line 241 of file G4LightTargetCollider.cc.

{
  // Do break-up in center of mass, convert to lab frame before returning 
  // particles
 
  G4double bulletMass = bullet->getMass();
  G4double bulletE = bullet->getEnergy();
 
  G4double S = bulletMass*bulletMass + mD*mD + 2.*mD*bulletE;
 
  G4double qcm = 0.;
  G4int outType1 = 0;
  G4int outType2 = 0;
  G4LorentzVector Mom1;
  G4LorentzVector Mom2;
 
  // Set up outgoing particle types
  if (bullet->getDefinition() == G4Gamma::Gamma() || 
      bullet->getDefinition() == G4PionZero::PionZero() ) {
    qcm = std::sqrt( (S - (mP + mN)*(mP + mN)) * (S - (mP - mN)*(mP - mN))/S/4.);
    Mom1.setE(std::sqrt(mP*mP + qcm*qcm) );
    outType1 = G4InuclParticleNames::proton;
    Mom2.setE(std::sqrt(mN*mN + qcm*qcm) );
    outType2 = G4InuclParticleNames::neutron;
 
  } else if (bullet->getDefinition() == G4PionPlus::PionPlus() ) {
    qcm = std::sqrt( (S - 4.*mP*mP)/4.);
    Mom1.setE(std::sqrt(mP*mP + qcm*qcm) );
    outType1 = G4InuclParticleNames::proton;
    Mom2.setE(std::sqrt(mP*mP + qcm*qcm) );
    outType2 = G4InuclParticleNames::proton;
 
  } else if (bullet->getDefinition() == G4PionMinus::PionMinus() ) {
    qcm = std::sqrt( (S - 4.*mN*mN)/4.);
    Mom1.setE(std::sqrt(mN*mN + qcm*qcm) );
    outType1 = G4InuclParticleNames::neutron;
    Mom2.setE(std::sqrt(mN*mN + qcm*qcm) );
    outType2 = G4InuclParticleNames::neutron;
 
  } else {
    G4Exception("G4LightTargetCollider::collide()","HAD_BERT_204",
                FatalException, "Illegal bullet type");
  } 
 
  // Sample angular distribution, assuming 100% S wave (no D-wave)
  G4ThreeVector qVect = qcm*G4RandomDirection();
  Mom1.setVect(qVect);
  Mom2.setVect(-qVect);
 
  // Boost to lab frame
  G4ThreeVector betacm(0., 0., bullet->getMomModule()/(bulletE + mD) );
  Mom1.boost(betacm);
  Mom2.boost(betacm);
 
  G4InuclElementaryParticle particle1(Mom1, outType1);
  G4InuclElementaryParticle particle2(Mom2, outType2);
  NucleonPair nucleon_pair(particle1, particle2); 
 
  // if pion, use parameterization of B.G. Ritchie, PRC 44, 533 (1991)
  // Total cross section: 1/E + Lorentzian
 
  return nucleon_pair;
}

References CLHEP::HepLorentzVector::boost(), FatalException, G4Exception(), G4RandomDirection(), G4Gamma::Gamma(), G4InuclParticle::getDefinition(), G4InuclParticle::getEnergy(), G4InuclParticle::getMass(), G4InuclParticle::getMomModule(), mD, mN, mP, G4InuclParticleNames::neutron, G4PionMinus::PionMinus(), G4PionPlus::PionPlus(), G4PionZero::PionZero(), G4InuclParticleNames::proton, S(), CLHEP::HepLorentzVector::setE(), and CLHEP::HepLorentzVector::setVect().

Referenced by collide().

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

References AbsorptionOnDeuteron(), G4CollisionOutput::addOutgoingParticle(), CLHEP::HepLorentzVector::boost(), CLHEP::HepLorentzVector::boostVector(), G4ElementaryParticleCollider::collide(), G4Deuteron::Deuteron(), FatalException, CLHEP::HepLorentzVector::findBoostToCM(), G4cout, G4endl, G4Exception(), G4RandomDirection(), G4UniformRand, GammaDCrossSection(), G4CascadeChannel::getCrossSection(), G4InuclParticle::getDefinition(), G4InuclParticle::getKineticEnergy(), G4InuclParticle::getMomentum(), G4ParticleDefinition::GetParticleName(), G4CascadeChannelTables::GetTable(), JustWarning, mD, mN, mP, G4Neutron::Neutron(), G4CollisionOutput::numberOfOutgoingParticles(), pFermiD, G4Proton::Proton(), G4CollisionOutput::reset(), SingleNucleonScattering(), theElementaryParticleCollider, G4CollisionOutput::trivialise(), and G4VCascadeCollider::verboseLevel.

Referenced by G4CascadeInterface::ApplyYourself().

GammaDCrossSection()

G4double G4LightTargetCollider::GammaDCrossSection ( G4double  gammaEnergy )

private

Definition at line 223 of file G4LightTargetCollider.cc.

{
  // Gamma deuteron cross section in mb parameterized from JLab data
  // No parameterization needed below pi0 threshold where cross section
  // is 100% disintegration
  G4double sigma = 1000.0;
  G4double term = 0.;
  if (gammaEnergy > 0.144 && gammaEnergy < 0.42) {
    term = (gammaEnergy - 0.24)/0.155;
    sigma = 0.065*std::exp(-term*term);
  } else if (gammaEnergy >= 0.42) {
    sigma = 0.000526/gammaEnergy/gammaEnergy/gammaEnergy/gammaEnergy;
  }
 
  return sigma;
}

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

G4LightTargetCollider & G4LightTargetCollider::operator= ( const G4LightTargetCollider &  )

private

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

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

References output, G4CollisionOutput::setVerboseLevel(), G4CascadeColliderBase::setVerboseLevel(), theElementaryParticleCollider, and G4VCascadeCollider::verboseLevel.

SingleNucleonScattering()

ScatteringProducts G4LightTargetCollider::SingleNucleonScattering ( const G4InuclElementaryParticle &  projectile, const G4InuclElementaryParticle &  targetNucleon  )

private

Definition at line 307 of file G4LightTargetCollider.cc.

{
  // At this point projectile and nucleon momenta are in nucleon rest frame
  G4int reactionIndex = G4InuclElementaryParticle::type(projectile.getDefinition() ) 
                      * G4InuclElementaryParticle::type(nucleon.getDefinition() );
 
  const G4CascadeChannel* xsecTable = G4CascadeChannelTables::GetTable(reactionIndex);
  G4double ke = projectile.getKineticEnergy();
  G4int mult = xsecTable->getMultiplicity(ke);
 
  std::vector<G4double> masses;
  G4double mass = 0.0;
  G4LorentzVector totalMom = projectile.getMomentum() + nucleon.getMomentum();
  G4double Ecm = totalMom.mag(); 
 
  std::vector<G4LorentzVector> cmMomenta;
  std::vector<G4int> particle_kinds;
  G4int itry = 0;
  G4int itry_max = 200;
  G4bool generate = true;
 
  while (mult > 1) {
    itry = 0;
    generate = true;
    while (generate && itry < itry_max) {
      particle_kinds.clear();
      xsecTable->getOutgoingParticleTypes(particle_kinds, mult, ke);
      masses.clear();
      for (G4int i = 0; i < mult; i++) {
        mass = G4InuclElementaryParticle::getParticleMass(particle_kinds[i]);
        masses.push_back(mass);
      }
 
      fsGen.Configure(const_cast<G4InuclElementaryParticle*>(&projectile),
                      const_cast<G4InuclElementaryParticle*>(&nucleon),
                      particle_kinds);
      // Generate final state in CM of projectile and at-rest nucleon
      cmMomenta.clear();
      generate = !fsGen.Generate(Ecm, masses, cmMomenta);
      itry++;
    } // while 
 
    if (itry == itry_max) mult--;
    else break;
 
  } // while mult
 
  ScatteringProducts finalState;
  if (mult < 2) { 
    G4Exception("G4LightTargetCollider::SingleNucleonScattering()","HAD_BERT_202",
                 JustWarning, "Failed to generate final state");
    // Final state particles not in CM - just using them as dummies 
    finalState.push_back(projectile);
    finalState.push_back(nucleon);
 
  } else {
    for (G4int i = 0; i < mult; i++) {
      G4InuclElementaryParticle fsPart(cmMomenta[i], particle_kinds[i]);
      finalState.push_back(fsPart);
    }
  }
 
  return finalState;
}

References G4CascadeFinalStateGenerator::Configure(), fsGen, G4Exception(), G4INCL::PhaseSpaceGenerator::generate(), G4HadDecayGenerator::Generate(), G4InuclParticle::getDefinition(), G4InuclParticle::getKineticEnergy(), G4InuclParticle::getMomentum(), G4CascadeChannel::getMultiplicity(), G4CascadeChannel::getOutgoingParticleTypes(), G4InuclElementaryParticle::getParticleMass(), G4CascadeChannelTables::GetTable(), JustWarning, CLHEP::HepLorentzVector::mag(), G4InuclParticleNames::nucleon(), and G4InuclElementaryParticle::type().

Referenced by collide().

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(), G4ElementaryParticleCollider::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 G4ElementaryParticleCollider::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().

fsGen

G4CascadeFinalStateGenerator G4LightTargetCollider::fsGen

private

Definition at line 74 of file G4LightTargetCollider.hh.

Referenced by SingleNucleonScattering().

interCase

G4InteractionCase G4CascadeColliderBase::interCase

protectedinherited

Definition at line 76 of file G4CascadeColliderBase.hh.

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

mD

G4double G4LightTargetCollider::mD

private

Definition at line 83 of file G4LightTargetCollider.hh.

Referenced by AbsorptionOnDeuteron(), collide(), and G4LightTargetCollider().

mN

G4double G4LightTargetCollider::mN

private

Definition at line 82 of file G4LightTargetCollider.hh.

Referenced by AbsorptionOnDeuteron(), collide(), and G4LightTargetCollider().

mP

G4double G4LightTargetCollider::mP

private

Definition at line 81 of file G4LightTargetCollider.hh.

Referenced by AbsorptionOnDeuteron(), collide(), and G4LightTargetCollider().

output

G4CollisionOutput G4LightTargetCollider::output

private

Definition at line 65 of file G4LightTargetCollider.hh.

Referenced by setVerboseLevel().

pFermiD

G4double G4LightTargetCollider::pFermiD

private

Definition at line 84 of file G4LightTargetCollider.hh.

Referenced by collide(), and G4LightTargetCollider().

theElementaryParticleCollider

G4ElementaryParticleCollider* G4LightTargetCollider::theElementaryParticleCollider

private

Definition at line 63 of file G4LightTargetCollider.hh.

Referenced by collide(), setVerboseLevel(), and ~G4LightTargetCollider().

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(), collide(), G4VCascadeDeexcitation::collide(), G4CascadeCheckBalance::collide(), G4CascadeRecoilMaker::collide(), G4ElementaryParticleCollider::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(), G4ElementaryParticleCollider::generateMultiplicity(), G4ElementaryParticleCollider::generateSCMfinalState(), G4ElementaryParticleCollider::generateSCMmuonAbsorption(), G4ElementaryParticleCollider::generateSCMpionAbsorption(), G4ElementaryParticleCollider::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(), G4ElementaryParticleCollider::pionNucleonAbsorption(), G4Fissioner::potentialMinimization(), G4IntraNucleiCascader::preloadCascade(), G4IntraNucleiCascader::processSecondary(), G4IntraNucleiCascader::processTrappedParticle(), G4IntraNucleiCascader::releaseSecondary(), G4IntraNucleiCascader::rescatter(), G4InuclCollider::rescatter(), G4IntraNucleiCascader::setupCascade(), G4InuclCollider::setVerboseLevel(), 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/G4LightTargetCollider.hh
• source/processes/hadronic/models/cascade/cascade/src/G4LightTargetCollider.cc