G4CascadeInterface Class Reference

#include <G4CascadeInterface.hh>

Inheritance diagram for G4CascadeInterface:

Public Member Functions
	G4CascadeInterface (const G4String &name="BertiniCascade")
virtual	~G4CascadeInterface ()
G4ReactionProductVector *	Propagate (G4KineticTrackVector *theSecondaries, G4V3DNucleus *theNucleus)
G4HadFinalState *	ApplyYourself (const G4HadProjectile &aTrack, G4Nucleus &theNucleus)
void	SetVerboseLevel (G4int verbose)
G4bool	IsApplicable (const G4HadProjectile &aTrack, G4Nucleus &theNucleus)
G4bool	IsApplicable (const G4ParticleDefinition *aPD) const
void	useCascadeDeexcitation ()
void	usePreCompoundDeexcitation ()
void	useAblaDeexcitation ()
virtual void	ModelDescription (std::ostream &outFile) const
virtual void	DumpConfiguration (std::ostream &outFile) const
Public Member Functions inherited from G4VIntraNuclearTransportModel
	G4VIntraNuclearTransportModel (const G4String &mName="CascadeModel", G4VPreCompoundModel *ptr=nullptr)
virtual	~G4VIntraNuclearTransportModel ()
virtual G4ReactionProductVector *	PropagateNuclNucl (G4KineticTrackVector *theSecondaries, G4V3DNucleus *theNucleus, G4V3DNucleus *theProjectileNucleus)
void	SetDeExcitation (G4VPreCompoundModel *ptr)
void	Set3DNucleus (G4V3DNucleus *const value)
void	SetPrimaryProjectile (const G4HadProjectile &aPrimary)
const G4String &	GetModelName () const
virtual void	PropagateModelDescription (std::ostream &outFile) const
	G4VIntraNuclearTransportModel (const G4VIntraNuclearTransportModel &right)=delete
const G4VIntraNuclearTransportModel &	operator= (const G4VIntraNuclearTransportModel &right)=delete
G4bool	operator== (const G4VIntraNuclearTransportModel &right) const =delete
G4bool	operator!= (const G4VIntraNuclearTransportModel &right) const =delete
Public Member Functions inherited from G4HadronicInteraction
	G4HadronicInteraction (const G4String &modelName="HadronicModel")
virtual	~G4HadronicInteraction ()
virtual G4double	SampleInvariantT (const G4ParticleDefinition *p, G4double plab, G4int Z, G4int A)
G4double	GetMinEnergy () const
G4double	GetMinEnergy (const G4Material *aMaterial, const G4Element *anElement) const
void	SetMinEnergy (G4double anEnergy)
void	SetMinEnergy (G4double anEnergy, const G4Element *anElement)
void	SetMinEnergy (G4double anEnergy, const G4Material *aMaterial)
G4double	GetMaxEnergy () const
G4double	GetMaxEnergy (const G4Material *aMaterial, const G4Element *anElement) const
void	SetMaxEnergy (const G4double anEnergy)
void	SetMaxEnergy (G4double anEnergy, const G4Element *anElement)
void	SetMaxEnergy (G4double anEnergy, const G4Material *aMaterial)
G4int	GetVerboseLevel () const
void	SetVerboseLevel (G4int value)
const G4String &	GetModelName () const
void	DeActivateFor (const G4Material *aMaterial)
void	ActivateFor (const G4Material *aMaterial)
void	DeActivateFor (const G4Element *anElement)
void	ActivateFor (const G4Element *anElement)
G4bool	IsBlocked (const G4Material *aMaterial) const
G4bool	IsBlocked (const G4Element *anElement) const
void	SetRecoilEnergyThreshold (G4double val)
G4double	GetRecoilEnergyThreshold () const
virtual const std::pair< G4double, G4double >	GetFatalEnergyCheckLevels () const
virtual std::pair< G4double, G4double >	GetEnergyMomentumCheckLevels () const
void	SetEnergyMomentumCheckLevels (G4double relativeLevel, G4double absoluteLevel)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
virtual void	InitialiseModel ()
	G4HadronicInteraction (const G4HadronicInteraction &right)=delete
const G4HadronicInteraction &	operator= (const G4HadronicInteraction &right)=delete
G4bool	operator== (const G4HadronicInteraction &right) const =delete
G4bool	operator!= (const G4HadronicInteraction &right) const =delete

Static Public Member Functions
static void	Initialize ()

Protected Member Functions
void	clear ()
G4bool	createBullet (const G4HadProjectile &aTrack)
G4bool	createTarget (G4Nucleus &theNucleus)
G4bool	createTarget (G4V3DNucleus *theNucleus)
G4bool	createTarget (G4int A, G4int Z)
G4bool	coulombBarrierViolation () const
G4bool	retryInelasticProton () const
G4bool	retryInelasticNucleus () const
void	copyOutputToHadronicResult ()
G4ReactionProductVector *	copyOutputToReactionProducts ()
G4HadFinalState *	NoInteraction (const G4HadProjectile &aTrack, G4Nucleus &theNucleus)
void	checkFinalResult ()
void	throwNonConservationFailure ()
G4DynamicParticle *	makeDynamicParticle (const G4InuclElementaryParticle &iep) const
G4DynamicParticle *	makeDynamicParticle (const G4InuclNuclei &inuc) const
Protected Member Functions inherited from G4VIntraNuclearTransportModel
G4V3DNucleus *	Get3DNucleus () const
G4VPreCompoundModel *	GetDeExcitation () const
const G4HadProjectile *	GetPrimaryProjectile () const
Protected Member Functions inherited from G4HadronicInteraction
void	SetModelName (const G4String &nam)
G4bool	IsBlocked () const
void	Block ()

Additional Inherited Members
Protected Attributes inherited from G4VIntraNuclearTransportModel
G4String	theTransportModelName
G4V3DNucleus *	the3DNucleus
G4VPreCompoundModel *	theDeExcitation
const G4HadProjectile *	thePrimaryProjectile
Protected Attributes inherited from G4HadronicInteraction
G4HadFinalState	theParticleChange
G4int	verboseLevel
G4double	theMinEnergy
G4double	theMaxEnergy
G4bool	isBlocked

Detailed Description

Definition at line 88 of file G4CascadeInterface.hh.

Constructor & Destructor Documentation

G4CascadeInterface()

G4CascadeInterface::G4CascadeInterface

(

const G4String &

name = "BertiniCascade"

)

Definition at line 147 of file G4CascadeInterface.cc.

 : G4VIntraNuclearTransportModel(name), 
   randomFile(G4CascadeParameters::randomFile()),
   maximumTries(20), numberOfTries(0),
   collider(new G4InuclCollider), balance(new G4CascadeCheckBalance(name)), 
   ltcollider(new G4LightTargetCollider),
   bullet(0), target(0), output(new G4CollisionOutput), secID(-1)
{
  // Set up global objects for master thread or sequential build
  if (G4Threading::IsMasterThread()) Initialize();
 
  SetEnergyMomentumCheckLevels(5*perCent, 10*MeV);
  balance->setLimits(5*perCent, 10*MeV/GeV);    // Bertini internal units
  this->SetVerboseLevel(G4CascadeParameters::verbose());
 
  if ( G4CascadeParameters::usePreCompound() ) {
    usePreCompoundDeexcitation();
  } else if ( G4CascadeParameters::useAbla() ) {
    useAblaDeexcitation();
  } else {
    useCascadeDeexcitation();
  }
 
  secID = G4PhysicsModelCatalog::GetModelID( "model_BertiniCascade" );
}

~G4CascadeInterface()

G4CascadeInterface::~G4CascadeInterface ( )

virtual

Definition at line 173 of file G4CascadeInterface.cc.

                                        {
  clear();
  delete collider; collider=0;
  delete ltcollider; ltcollider = 0;
  delete balance; balance=0;
  delete output; output=0;
}

Member Function Documentation

ApplyYourself()

G4HadFinalState * G4CascadeInterface::ApplyYourself ( const G4HadProjectile & aTrack, G4Nucleus & theNucleus )

virtual

Reimplemented from G4HadronicInteraction.

Definition at line 261 of file G4CascadeInterface.cc.

                                         {
  if (verboseLevel)
    G4cout << " >>> G4CascadeInterface::ApplyYourself" << G4endl;
 
  if (aTrack.GetKineticEnergy() < 0.) {
    G4cerr << " >>> G4CascadeInterface got negative-energy track: "
       << aTrack.GetDefinition()->GetParticleName() << " Ekin = "
       << aTrack.GetKineticEnergy() << G4endl;
  }
 
#ifdef G4CASCADE_DEBUG_INTERFACE
  static G4int counter(0);
  counter++;
  G4cerr << "Reaction number "<< counter << " "
     << aTrack.GetDefinition()->GetParticleName() << " "
     << aTrack.GetKineticEnergy() << " MeV" << G4endl;
#endif
 
  if (!randomFile.empty()) {        // User requested random-seed capture
    if (verboseLevel>1) 
      G4cout << " Saving random engine state to " << randomFile << G4endl;
    CLHEP::HepRandom::saveEngineStatus(randomFile);
  }
 
  theParticleChange.Clear();
  clear();
 
  // Abort processing if no interaction is possible
  if (!IsApplicable(aTrack, theNucleus)) {
    if (verboseLevel) G4cerr << " No interaction possible " << G4endl;
    return NoInteraction(aTrack, theNucleus);
  }
 
  // If target A < 3 skip all cascade machinery and do scattering on
  // nucleons
 
  if (aTrack.GetDefinition() == G4Gamma::Gamma() &&
      theNucleus.GetA_asInt() < 3) {
    output->reset();
    createBullet(aTrack);
    createTarget(theNucleus);
    // Due to binning, gamma-p cross sections between 130 MeV and the inelastic threshold
    // (144 for pi0 p, 152 for pi+ n) are non-zero, causing energy non-conservation
    // So, if Egamma is between 144 and 152, only pi0 p is allowed.  
 
    // Also, inelastic gamma-p cross section from G4PhotoNuclearCrossSection seems to be
    // non-zero below between pi0 mass (135 MeV) and threshold (144 MeV) 
    ltcollider->collide(bullet, target, *output);
 
  } else {
 
    // Make conversion between native Geant4 and Bertini cascade classes.
    if (!createBullet(aTrack)) {
      if (verboseLevel) G4cerr << " Unable to create usable bullet" << G4endl;
      return NoInteraction(aTrack, theNucleus);
    }
 
    if (!createTarget(theNucleus)) {
      if (verboseLevel) G4cerr << " Unable to create usable target" << G4endl;
      return NoInteraction(aTrack, theNucleus);
    }
 
    // Different retry conditions for proton target vs. nucleus
    const G4bool isHydrogen = (theNucleus.GetA_asInt() == 1);
 
    numberOfTries = 0;
    do {            // we try to create inelastic interaction
      if (verboseLevel > 1)
        G4cout << " Generating cascade attempt " << numberOfTries << G4endl;
    
      output->reset();
      collider->collide(bullet, target, *output);
      balance->collide(bullet, target, *output);
    
      numberOfTries++;
      /* Loop checking 08.06.2015 MHK */
    } while ( isHydrogen ? retryInelasticProton() : retryInelasticNucleus() );
 
    // Null event if unsuccessful
    if (numberOfTries >= maximumTries) {
      if (verboseLevel) 
        G4cout << " Cascade aborted after trials " << numberOfTries << G4endl;
      return NoInteraction(aTrack, theNucleus);
    }
 
    // Abort job if energy or momentum are not conserved
    if (!balance->okay()) {
      throwNonConservationFailure();
      return NoInteraction(aTrack, theNucleus);
    }
 
    // Successful cascade -- clean up and return
    if (verboseLevel) {
      G4cout << " Cascade output after trials " << numberOfTries << G4endl;
      if (verboseLevel > 1) output->printCollisionOutput();
    }
 
  }  // end cascade-style collisions
 
  copyOutputToHadronicResult();
 
  // Report violations of conservation laws in original frame
  checkFinalResult();
 
  // Clean up and return final result;
  clear();
/*
  G4int nSec = theParticleChange.GetNumberOfSecondaries();
  for (G4int i = 0; i < nSec; i++) {
    G4HadSecondary* sec = theParticleChange.GetSecondary(i);
    G4DynamicParticle* dp = sec->GetParticle();
    if (dp->GetDefinition()->GetParticleName() == "neutron") 
      G4cout << dp->GetDefinition()->GetParticleName() << " has "
             << dp->GetKineticEnergy()/MeV << " MeV " << G4endl;
  }
*/
  return &theParticleChange;
}

checkFinalResult()

void G4CascadeInterface::checkFinalResult ( )

protected

Definition at line 660 of file G4CascadeInterface.cc.

                                          {
  balance->collide(bullet, target, *output);
 
  if (verboseLevel > 2) {
    if (!balance->baryonOkay()) {
      G4cerr << "ERROR: no baryon number conservation, sum of baryons = "
             << balance->deltaB() << G4endl;
    }
 
    if (!balance->chargeOkay()) {
      G4cerr << "ERROR: no charge conservation, sum of charges = "
         << balance->deltaQ() << G4endl;
    }
 
    if (std::abs(balance->deltaKE()) > 0.01 ) { // GeV
      G4cerr << "Kinetic energy conservation violated by "
         << balance->deltaKE() << " GeV" << G4endl;
    }
 
    G4double eInit = bullet->getEnergy() + target->getEnergy();
    G4double eFinal = eInit + balance->deltaE();
 
    G4cout << "Initial energy " << eInit << " final energy " << eFinal
       << "\nTotal energy conservation at level "
       << balance->deltaE() * GeV << " MeV" << G4endl;
    
    if (balance->deltaKE() > 5.0e-5 ) {     // 0.05 MeV
      G4cerr << "FATAL ERROR: kinetic energy created  "
             << balance->deltaKE() * GeV << " MeV" << G4endl;
    }
  }
}

Referenced by ApplyYourself().

clear()

void G4CascadeInterface::clear ( )

protected

Definition at line 199 of file G4CascadeInterface.cc.

                               {
  bullet=0;
  target=0;
}

Referenced by ApplyYourself(), Propagate(), and ~G4CascadeInterface().

copyOutputToHadronicResult()

void G4CascadeInterface::copyOutputToHadronicResult ( )

protected

Definition at line 589 of file G4CascadeInterface.cc.

                                                    {
  if (verboseLevel > 1)
    G4cout << " >>> G4CascadeInterface::copyOutputToHadronicResult" << G4endl;
 
  const std::vector<G4InuclNuclei>& outgoingNuclei = output->getOutgoingNuclei();
  const std::vector<G4InuclElementaryParticle>& particles = output->getOutgoingParticles();
 
  theParticleChange.SetStatusChange(stopAndKill);
  theParticleChange.SetEnergyChange(0.);
 
  // Get outcoming particles
  if (!particles.empty()) { 
    particleIterator ipart = particles.begin();
    for (; ipart != particles.end(); ipart++) {
      theParticleChange.AddSecondary(makeDynamicParticle(*ipart), secID);
    }
  }
 
  // get nuclei fragments
  if (!outgoingNuclei.empty()) { 
    nucleiIterator ifrag = outgoingNuclei.begin();
    for (; ifrag != outgoingNuclei.end(); ifrag++) {
      theParticleChange.AddSecondary(makeDynamicParticle(*ifrag), secID);
    }
  }
}

Referenced by ApplyYourself().

copyOutputToReactionProducts()

G4ReactionProductVector * G4CascadeInterface::copyOutputToReactionProducts ( )

protected

Definition at line 616 of file G4CascadeInterface.cc.

                                                                          {
  if (verboseLevel > 1)
    G4cout << " >>> G4CascadeInterface::copyOutputToReactionProducts" << G4endl;
 
  const std::vector<G4InuclElementaryParticle>& particles = output->getOutgoingParticles();
  const std::vector<G4InuclNuclei>& fragments = output->getOutgoingNuclei();
 
  G4ReactionProductVector* propResult = new G4ReactionProductVector;
 
  G4ReactionProduct* rp = 0;    // Buffers to create outgoing tracks
  G4DynamicParticle* dp = 0;
 
  // Get outcoming particles
  if (!particles.empty()) { 
    particleIterator ipart = particles.begin();
    for (; ipart != particles.end(); ipart++) {
      rp = new G4ReactionProduct;
      dp = makeDynamicParticle(*ipart);
      (*rp) = (*dp);        // This does all the necessary copying
      rp->SetCreatorModelID(secID);
      propResult->push_back(rp);
      delete dp;
    }
  }
 
  // get nuclei fragments
  if (!fragments.empty()) { 
    nucleiIterator ifrag = fragments.begin();
    for (; ifrag != fragments.end(); ifrag++) {
      rp = new G4ReactionProduct;
      dp = makeDynamicParticle(*ifrag);
      (*rp) = (*dp);        // This does all the necessary copying
      rp->SetCreatorModelID(secID);
      propResult->push_back(rp);
      delete dp;
    }
  }
 
  return propResult;
}

Referenced by Propagate().

coulombBarrierViolation()

G4bool G4CascadeInterface::coulombBarrierViolation ( ) const

protected

Definition at line 696 of file G4CascadeInterface.cc.

                                                         {
  G4bool violated = false;          // by default coulomb analysis is OK
 
  const G4double coulumbBarrier = 8.7 * MeV/GeV;    // Bertini uses GeV
 
  const std::vector<G4InuclElementaryParticle>& p =
    output->getOutgoingParticles();
 
  for (particleIterator ipart=p.begin(); ipart != p.end(); ipart++) {
    if (ipart->type() == proton) {
      violated |= (ipart->getKineticEnergy() < coulumbBarrier);
    }
  }
 
  return violated;
}

Referenced by retryInelasticNucleus().

createBullet()

G4bool G4CascadeInterface::createBullet ( const G4HadProjectile & aTrack )

protected

Definition at line 474 of file G4CascadeInterface.cc.

                                                                     {
  const G4ParticleDefinition* trkDef = aTrack.GetDefinition();
  G4int bulletType = 0;         // For elementary particles
  G4int bulletA = 0, bulletZ = 0;   // For nucleus projectile
 
  if (trkDef->GetAtomicMass() <= 1) {
    bulletType = G4InuclElementaryParticle::type(trkDef);
  } else {
    bulletA = trkDef->GetAtomicMass();
    bulletZ = trkDef->GetAtomicNumber();
  }
 
  if (0 == bulletType && 0 == bulletA*bulletZ) {
    if (verboseLevel) {
      G4cerr << " G4CascadeInterface: " << trkDef->GetParticleName()
         << " not usable as bullet." << G4endl;
    }
    bullet = 0;
    return false;
  }
 
  // Code momentum and energy -- Bertini wants z-axis and GeV units
  G4LorentzVector projectileMomentum = aTrack.Get4Momentum()/GeV;
 
  // Rotation/boost to get from z-axis back to original frame
  // According to bug report #1990 this rotation is unnecessary and causes
  // irreproducibility.  Verifed and fixed by DHW 27 Nov 2017
  // bulletInLabFrame = G4LorentzRotation::IDENTITY;    // Initialize
  // bulletInLabFrame.rotateZ(-projectileMomentum.phi());
  // bulletInLabFrame.rotateY(-projectileMomentum.theta());
  // bulletInLabFrame.invert();
 
  G4LorentzVector momentumBullet(0., 0., projectileMomentum.rho(),
                 projectileMomentum.e());
  
  if (G4InuclElementaryParticle::valid(bulletType)) {
    hadronBullet.fill(momentumBullet, bulletType);
    bullet = &hadronBullet;
  } else {
    nucleusBullet.fill(momentumBullet, bulletA, bulletZ);
    bullet = &nucleusBullet;
  }
 
  if (verboseLevel > 2) G4cout << "Bullet:  \n" << *bullet << G4endl;  
 
  return true;
}

Referenced by ApplyYourself(), and Propagate().

createTarget() [1/3]

G4bool G4CascadeInterface::createTarget ( G4int A, G4int Z )

protected

Definition at line 533 of file G4CascadeInterface.cc.

                                                        {
  if (A > 1) {
    nucleusTarget.fill(A, Z);
    target = &nucleusTarget;
  } else {
    hadronTarget.fill(0., (Z==1?proton:neutron));
    target = &hadronTarget;
  }
 
  if (verboseLevel > 2) G4cout << "Target:  \n" << *target << G4endl;
 
  return true;      // Right now, target never fails
}

createTarget() [2/3]

G4bool G4CascadeInterface::createTarget ( G4Nucleus & theNucleus )

protected

Definition at line 525 of file G4CascadeInterface.cc.

                                                             {
  return createTarget(theNucleus.GetA_asInt(), theNucleus.GetZ_asInt());
}

Referenced by ApplyYourself(), createTarget(), createTarget(), and Propagate().

createTarget() [3/3]

G4bool G4CascadeInterface::createTarget ( G4V3DNucleus * theNucleus )

protected

Definition at line 529 of file G4CascadeInterface.cc.

                                                                {
  return createTarget(theNucleus->GetMassNumber(), theNucleus->GetCharge());
}

DumpConfiguration()

void G4CascadeInterface::DumpConfiguration ( std::ostream & outFile ) const

virtual

Definition at line 195 of file G4CascadeInterface.cc.

                                                                    {
  G4CascadeParameters::DumpConfiguration(outFile);
}

Initialize()

void G4CascadeInterface::Initialize ( )

static

Definition at line 207 of file G4CascadeInterface.cc.

                                    {
  G4ParticleDefinition* pn = G4UnboundPN::Definition();
  G4ParticleDefinition* nn = G4Dineutron::Definition();
  G4ParticleDefinition* pp = G4Diproton::Definition();
  const G4CascadeChannel* ch = G4CascadeChannelTables::GetTable(0);
  if (!ch || !pn || !nn || !pp) return;     // Avoid "unused variables"
}

Referenced by G4CascadeInterface().

IsApplicable() [1/2]

G4bool G4CascadeInterface::IsApplicable ( const G4HadProjectile & aTrack, G4Nucleus & theNucleus )

virtual

Reimplemented from G4HadronicInteraction.

Definition at line 244 of file G4CascadeInterface.cc.

                                  {
  return IsApplicable(aTrack.GetDefinition());  
}

Referenced by ApplyYourself(), and IsApplicable().

IsApplicable() [2/2]

G4bool G4CascadeInterface::IsApplicable

(

const G4ParticleDefinition *

aPD

)

const

Definition at line 249 of file G4CascadeInterface.cc.

                                                                             {
  if (aPD->GetAtomicMass() > 1) return true;        // Nuclei are okay
 
  // Valid particle and have interactions available
  G4int type = G4InuclElementaryParticle::type(aPD);
  return (G4CascadeChannelTables::GetTable(type));
}

makeDynamicParticle() [1/2]

G4DynamicParticle * G4CascadeInterface::makeDynamicParticle ( const G4InuclElementaryParticle & iep ) const

protected

Definition at line 550 of file G4CascadeInterface.cc.

                                                                {
  G4int outgoingType = iep.type();
  
  if (iep.quasi_deutron()) {
    G4cerr << " ERROR: G4CascadeInterface incompatible particle type "
       << outgoingType << G4endl;
    return 0;
  }
  
  // Copy local G4DynPart to public output (handle kaon mixing specially)
  if (outgoingType == kaonZero || outgoingType == kaonZeroBar) {
    G4ThreeVector momDir = iep.getMomentum().vect().unit();
    G4double ekin = iep.getKineticEnergy()*GeV; // Bertini -> G4 units
    
    G4ParticleDefinition* pd = G4KaonZeroShort::Definition();
    if (G4UniformRand() > 0.5) pd = G4KaonZeroLong::Definition();
    
    return new G4DynamicParticle(pd, momDir, ekin);
  } else {
    return new G4DynamicParticle(iep.getDynamicParticle());
  }
  
  return 0; // Should never get here!
}

Referenced by copyOutputToHadronicResult(), and copyOutputToReactionProducts().

makeDynamicParticle() [2/2]

G4DynamicParticle * G4CascadeInterface::makeDynamicParticle ( const G4InuclNuclei & inuc ) const

protected

Definition at line 577 of file G4CascadeInterface.cc.

                                                                       {
  if (verboseLevel > 2) {
    G4cout << " Nuclei fragment: \n" << inuc << G4endl;
  }
  
  // Copy local G4DynPart to public output 
  return new G4DynamicParticle(inuc.getDynamicParticle());
}

ModelDescription()

void G4CascadeInterface::ModelDescription ( std::ostream & outFile ) const

virtual

Reimplemented from G4VIntraNuclearTransportModel.

Definition at line 181 of file G4CascadeInterface.cc.

{
  outFile << "The Bertini-style cascade implements the inelastic scattering\n"
          << "of hadrons by nuclei.  Nucleons, pions, kaons and hyperons\n"
          << "from 0 to 15 GeV may be used as projectiles in this model.\n"
          << "Final state hadrons are produced by a classical cascade\n"
          << "consisting of individual hadron-nucleon scatterings which use\n"
          << "free-space partial cross sections, corrected for various\n"
          << "nuclear medium effects.  The target nucleus is modeled as a\n"
          << "set of 1, 3 or 6 spherical shells, in which scattered hadrons\n"
          << "travel in straight lines until they are reflected from or\n"
          << "transmitted through shell boundaries.\n";
}

NoInteraction()

G4HadFinalState * G4CascadeInterface::NoInteraction ( const G4HadProjectile & aTrack, G4Nucleus & theNucleus )

protected

Definition at line 457 of file G4CascadeInterface.cc.

                                {
  if (verboseLevel) 
    G4cout << " >>> G4CascadeInterface::NoInteraction" << G4endl;
 
  theParticleChange.Clear();
  theParticleChange.SetStatusChange(isAlive);
 
  G4double ekin = aTrack.GetKineticEnergy()>0. ? aTrack.GetKineticEnergy() : 0.;
  theParticleChange.SetEnergyChange(ekin);  // Protect against rounding
 
  return &theParticleChange;
}

Referenced by ApplyYourself().

Propagate()

G4ReactionProductVector * G4CascadeInterface::Propagate ( G4KineticTrackVector * theSecondaries, G4V3DNucleus * theNucleus )

virtual

Implements G4VIntraNuclearTransportModel.

Definition at line 382 of file G4CascadeInterface.cc.

                                            {
  if (verboseLevel) G4cout << " >>> G4CascadeInterface::Propagate" << G4endl;
 
#ifdef G4CASCADE_DEBUG_INTERFACE
  if (verboseLevel>1) {
    G4cout << " G4V3DNucleus A " << theNucleus->GetMassNumber()
       << " Z " << theNucleus->GetCharge()
       << "\n " << theSecondaries->size() << " secondaries:" << G4endl;
    for (size_t i=0; i<theSecondaries->size(); i++) {
      G4KineticTrack* kt = (*theSecondaries)[i];
      G4cout << " " << i << ": " << kt->GetDefinition()->GetParticleName() 
         << " p " << kt->Get4Momentum() << " @ " << kt->GetPosition()
         << " t " << kt->GetFormationTime() << G4endl;
    }
  }
#endif
 
  if (!randomFile.empty()) {        // User requested random-seed capture
    if (verboseLevel>1) 
      G4cout << " Saving random engine state to " << randomFile << G4endl;
    CLHEP::HepRandom::saveEngineStatus(randomFile);
  }
 
  theParticleChange.Clear();
  clear();
 
  // Process input secondaries list to eliminate resonances
  G4DecayKineticTracks decay(theSecondaries);
 
  // NOTE:  Requires 9.4-ref-03 mods to base class and G4TheoFSGenerator
  const G4HadProjectile* projectile = GetPrimaryProjectile();
  if (projectile) createBullet(*projectile);
 
  if (!createTarget(theNucleus)) {
    if (verboseLevel) G4cerr << " Unable to create usable target" << G4endl;
    return 0;   // FIXME:  This will cause a segfault later
  }
 
  numberOfTries = 0;
  do {
    if (verboseLevel > 1)
      G4cout << " Generating rescatter attempt " << numberOfTries << G4endl;
 
    output->reset();
    collider->rescatter(bullet, theSecondaries, theNucleus, *output);
    balance->collide(bullet, target, *output);
 
    numberOfTries++;
    // FIXME:  retry checks will SEGFAULT until we can define the bullet!
  } while (retryInelasticNucleus());    /* Loop checking 08.06.2015 MHK */
 
  // Check whether repeated attempts have all failed; report and exit
  if (numberOfTries >= maximumTries && !balance->okay()) {
    throwNonConservationFailure();  // This terminates the job
  }
 
  // Successful cascade -- clean up and return
  if (verboseLevel) {
    G4cout << " Cascade rescatter after trials " << numberOfTries << G4endl;
    if (verboseLevel > 1) output->printCollisionOutput();
  }
 
  // Does calling code take ownership?  I hope so!
  G4ReactionProductVector* propResult = copyOutputToReactionProducts();
 
  // Clean up and and return final result
  clear();
  return propResult;
}

retryInelasticNucleus()

G4bool G4CascadeInterface::retryInelasticNucleus ( ) const

protected

Definition at line 747 of file G4CascadeInterface.cc.

                                                       {
  // Quantities necessary for conditional block below
  G4int npart = output->numberOfOutgoingParticles();
  G4int nfrag = output->numberOfOutgoingNuclei();
 
  const G4ParticleDefinition* firstOut = (npart == 0) ? 0 :
    output->getOutgoingParticles().begin()->getDefinition();
 
#ifdef G4CASCADE_DEBUG_INTERFACE
  // Report on all retry conditions, in order of return logic
  G4cout << " retryInelasticNucleus: numberOfTries "
     << ((numberOfTries < maximumTries) ? "RETRY (t)" : "EXIT (f)")
     << "\n retryInelasticNucleus: AND outputParticles "
     << ((npart != 0) ? "NON-ZERO (t)" : "EMPTY (f)")
#ifdef G4CASCADE_COULOMB_DEV
     << "\n retryInelasticNucleus: AND coulombBarrier (COULOMB_DEV) "
     << (coulombBarrierViolation() ? "VIOLATED (t)" : "PASSED (f)")
     << "\n retryInelasticNucleus: AND collision type (COULOMB_DEV) "
     << ((npart+nfrag > 2) ? "INELASTIC (t)" : "ELASTIC (f)")
#else
     << "\n retryInelasticNucleus: AND collision type "
     << ((npart+nfrag < 3) ? "ELASTIC (t)" : "INELASTIC (f)")
     << "\n retryInelasticNucleus: AND Leading particle bullet "
     << ((firstOut == bullet->getDefinition()) ? "YES (t)" : "NO (f)")
#endif
     << "\n retryInelasticNucleus: OR conservation "
     << (!balance->okay() ? "FAILED (t)" : "PASSED (f)")
     << G4endl;
#endif
 
  return ( (numberOfTries < maximumTries) &&
       ( ((npart != 0) &&
#ifdef G4CASCADE_COULOMB_DEV
          (coulombBarrierViolation() && npart+nfrag > 2)
#else
          (npart+nfrag < 3 && firstOut == bullet->getDefinition())
#endif
             )
#ifndef G4CASCADE_SKIP_ECONS
         || (!balance->okay())
#endif
           )
     );
}

Referenced by ApplyYourself(), and Propagate().

retryInelasticProton()

G4bool G4CascadeInterface::retryInelasticProton ( ) const

protected

Definition at line 715 of file G4CascadeInterface.cc.

                                                      {
  const std::vector<G4InuclElementaryParticle>& out =
    output->getOutgoingParticles();
 
#ifdef G4CASCADE_DEBUG_INTERFACE
  // Report on all retry conditions, in order of return logic
  G4cout << " retryInelasticProton: number of Tries "
     << ((numberOfTries < maximumTries) ? "RETRY (t)" : "EXIT (f)")
     << "\n retryInelasticProton: AND collision type ";
  if (out.empty()) G4cout << "FAILED" << G4endl;
  else {
    G4cout << (out.size() == 2 ? "ELASTIC (t)" : "INELASTIC (f)")
       << "\n retryInelasticProton: AND Leading particles bullet "
       << (out.size() >= 2 &&
           (out[0].getDefinition() == bullet->getDefinition() ||
        out[1].getDefinition() == bullet->getDefinition())
           ? "YES (t)" : "NO (f)")
       << G4endl;
  }
#endif
 
  return ( (numberOfTries < maximumTries) &&
       (out.empty() ||
        (out.size() == 2 &&
         (out[0].getDefinition() == bullet->getDefinition() ||
          out[1].getDefinition() == bullet->getDefinition())))
       );
}

Referenced by ApplyYourself().

SetVerboseLevel()

void G4CascadeInterface::SetVerboseLevel

(

G4int

verbose

)

Definition at line 234 of file G4CascadeInterface.cc.

                                                      {
  G4HadronicInteraction::SetVerboseLevel(verbose);
  collider->setVerboseLevel(verbose);
  balance->setVerboseLevel(verbose);
  output->setVerboseLevel(verbose);
}

Referenced by G4CascadeInterface().

throwNonConservationFailure()

void G4CascadeInterface::throwNonConservationFailure ( )

protected

Definition at line 796 of file G4CascadeInterface.cc.

                                                     {
  // NOTE:  Once G4HadronicException is changed, use the following line!
  // G4ExceptionDescription errInfo;
  std::ostream& errInfo = G4cerr;
 
  errInfo << " >>> G4CascadeInterface has non-conserving"
      << " cascade after " << numberOfTries << " attempts." << G4endl;
 
  G4String throwMsg = "G4CascadeInterface - ";
  if (!balance->energyOkay()) {
    throwMsg += "Energy";
    errInfo << " Energy conservation violated by " << balance->deltaE()
        << " GeV (" << balance->relativeE() << ")" << G4endl;
  }
  
  if (!balance->momentumOkay()) {
    throwMsg += "Momentum";
    errInfo << " Momentum conservation violated by " << balance->deltaP()
        << " GeV/c (" << balance->relativeP() << ")" << G4endl;
  }
  
  if (!balance->baryonOkay()) {
    throwMsg += "Baryon number";
    errInfo << " Baryon number violated by " << balance->deltaB() << G4endl;
  }
  
  if (!balance->chargeOkay()) {
    throwMsg += "Charge";
    errInfo << " Charge conservation violated by " << balance->deltaQ()
        << G4endl;
  }
 
  errInfo << " Final event output, for debugging:\n"
     << " Bullet:  \n" << *bullet << G4endl
     << " Target:  \n" << *target << G4endl;
  output->printCollisionOutput(errInfo);
  
  throwMsg += " non-conservation. More info in output.";
  throw G4HadronicException(__FILE__, __LINE__, throwMsg);   // Job ends here!
}

Referenced by ApplyYourself(), and Propagate().

useAblaDeexcitation()

void G4CascadeInterface::useAblaDeexcitation

(

)

Definition at line 227 of file G4CascadeInterface.cc.

                                             {
  collider->useAblaDeexcitation();
}

Referenced by G4CascadeInterface().

useCascadeDeexcitation()

void G4CascadeInterface::useCascadeDeexcitation

(

)

Definition at line 219 of file G4CascadeInterface.cc.

                                                {
  collider->useCascadeDeexcitation();
}

Referenced by G4CascadeInterface().

usePreCompoundDeexcitation()

void G4CascadeInterface::usePreCompoundDeexcitation

(

)

Definition at line 223 of file G4CascadeInterface.cc.

                                                    {
  collider->usePreCompoundDeexcitation();
}

Referenced by G4CascadeInterface().

---

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

• G4CascadeInterface.hh
• G4CascadeInterface.cc