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

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

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

Public Member Functions inherited from G4VIntraNuclearTransportModel
	G4VIntraNuclearTransportModel (const G4String &modelName="CascadeModel", G4VPreCompoundModel *ptr=0)

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

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)

const G4HadronicInteraction *	GetMyPointer () const

virtual G4int	GetVerboseLevel () const

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

G4bool	operator== (const G4HadronicInteraction &right) const

G4bool	operator!= (const G4HadronicInteraction &right) const

virtual const std::pair < G4double, G4double >	GetFatalEnergyCheckLevels () const

virtual std::pair< G4double, G4double >	GetEnergyMomentumCheckLevels () const

void	SetEnergyMomentumCheckLevels (G4double relativeLevel, G4double absoluteLevel)

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 86 of file G4CascadeInterface.hh.

Constructor & Destructor Documentation

G4CascadeInterface::G4CascadeInterface ( const G4String & name = "BertiniCascade" )

Definition at line 149 of file G4CascadeInterface.cc.

References python.hepunit::GeV, python.hepunit::MeV, python.hepunit::perCent, G4HadronicInteraction::SetEnergyMomentumCheckLevels(), G4CascadeCheckBalance::setLimits(), SetVerboseLevel(), G4CascadeParameters::usePreCompound(), usePreCompoundDeexcitation(), and G4CascadeParameters::verbose().

   : G4VIntraNuclearTransportModel(name), numberOfTries(0),
     collider(new G4InuclCollider), balance(new G4CascadeCheckBalance(name)),
     bullet(0), target(0), output(new G4CollisionOutput) {
   SetEnergyMomentumCheckLevels(5*perCent, 10*MeV);
   balance->setLimits(5*perCent, 10*MeV/GeV);    // Bertini internal units
   // Description();                                // Model description
 
   this->SetVerboseLevel(G4CascadeParameters::verbose());
   if (G4CascadeParameters::usePreCompound()) usePreCompoundDeexcitation();
 }

G4CascadeInterface::~G4CascadeInterface ( )

virtual

Definition at line 161 of file G4CascadeInterface.cc.

References clear().

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

Member Function Documentation

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

virtual

Implements G4HadronicInteraction.

Definition at line 244 of file G4CascadeInterface.cc.

References checkFinalResult(), G4HadFinalState::Clear(), clear(), G4InuclCollider::collide(), G4CascadeCheckBalance::collide(), copyOutputToHadronicResult(), createBullet(), createTarget(), G4cerr, G4cout, G4endl, G4Nucleus::GetA_asInt(), G4HadProjectile::GetDefinition(), G4HadProjectile::GetKineticEnergy(), G4ParticleDefinition::GetParticleName(), IsApplicable(), NoInteraction(), G4CascadeCheckBalance::okay(), G4CollisionOutput::printCollisionOutput(), G4CollisionOutput::reset(), retryInelasticNucleus(), retryInelasticProton(), G4CollisionOutput::rotateEvent(), CLHEP::HepRandom::saveEngineStatus(), G4HadronicInteraction::theParticleChange, throwNonConservationFailure(), and G4HadronicInteraction::verboseLevel.

                                          {
   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);
   }
 
   // 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++;
   } 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();
   }
 
   // Rotate event to put Z axis along original projectile direction
   output->rotateEvent(bulletInLabFrame);
 
   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;
 }

void G4CascadeInterface::checkFinalResult ( )

protected

Definition at line 621 of file G4CascadeInterface.cc.

References G4CascadeCheckBalance::baryonOkay(), G4CascadeCheckBalance::chargeOkay(), G4CascadeCheckBalance::collide(), G4CascadeCheckBalance::deltaB(), G4CascadeCheckBalance::deltaE(), G4CascadeCheckBalance::deltaKE(), G4CascadeCheckBalance::deltaQ(), G4cerr, G4cout, G4endl, G4InuclParticle::getEnergy(), python.hepunit::GeV, and G4HadronicInteraction::verboseLevel.

Referenced by ApplyYourself().

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

void G4CascadeInterface::clear ( void )

protected

Definition at line 186 of file G4CascadeInterface.cc.

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

                                {
   bullet=0;
   target=0;
 }

void G4CascadeInterface::copyOutputToHadronicResult ( )

protected

Definition at line 552 of file G4CascadeInterface.cc.

References G4HadFinalState::AddSecondary(), G4cout, G4endl, G4CollisionOutput::getOutgoingNuclei(), G4CollisionOutput::getOutgoingParticles(), makeDynamicParticle(), G4HadFinalState::SetEnergyChange(), G4HadFinalState::SetStatusChange(), stopAndKill, G4HadronicInteraction::theParticleChange, and G4HadronicInteraction::verboseLevel.

Referenced by ApplyYourself().

                                                     {
   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));
     }
   }
 
   // get nuclei fragments
   if (!outgoingNuclei.empty()) { 
     nucleiIterator ifrag = outgoingNuclei.begin();
     for (; ifrag != outgoingNuclei.end(); ifrag++) {
       theParticleChange.AddSecondary(makeDynamicParticle(*ifrag)); 
     }
   }
 }

G4ReactionProductVector * G4CascadeInterface::copyOutputToReactionProducts ( )

protected

Definition at line 579 of file G4CascadeInterface.cc.

References G4cout, G4endl, G4CollisionOutput::getOutgoingNuclei(), G4CollisionOutput::getOutgoingParticles(), makeDynamicParticle(), and G4HadronicInteraction::verboseLevel.

Referenced by Propagate().

                                                                           {
   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
       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
       propResult->push_back(rp);
       delete dp;
     }
   }
 
   return propResult;
 }

G4bool G4CascadeInterface::coulombBarrierViolation ( ) const

protected

Definition at line 657 of file G4CascadeInterface.cc.

References G4CollisionOutput::getOutgoingParticles(), python.hepunit::GeV, python.hepunit::MeV, and G4InuclParticleNames::proton.

Referenced by retryInelasticNucleus().

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

G4bool G4CascadeInterface::createBullet ( const G4HadProjectile & aTrack )

protected

Definition at line 439 of file G4CascadeInterface.cc.

References CLHEP::HepLorentzVector::e(), G4InuclElementaryParticle::fill(), G4InuclNuclei::fill(), G4cerr, G4cout, G4endl, G4HadProjectile::Get4Momentum(), G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), G4HadProjectile::GetDefinition(), G4ParticleDefinition::GetParticleName(), python.hepunit::GeV, CLHEP::HepLorentzRotation::IDENTITY, CLHEP::HepLorentzRotation::invert(), CLHEP::HepLorentzVector::phi(), CLHEP::HepLorentzVector::rho(), CLHEP::HepLorentzRotation::rotateY(), CLHEP::HepLorentzRotation::rotateZ(), CLHEP::HepLorentzVector::theta(), G4InuclElementaryParticle::type(), G4InuclElementaryParticle::valid(), and G4HadronicInteraction::verboseLevel.

Referenced by ApplyYourself(), and Propagate().

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

G4bool G4CascadeInterface::createTarget ( G4Nucleus & theNucleus )

protected

Definition at line 488 of file G4CascadeInterface.cc.

References G4Nucleus::GetA_asInt(), and G4Nucleus::GetZ_asInt().

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

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

G4bool G4CascadeInterface::createTarget ( G4V3DNucleus * theNucleus )

protected

Definition at line 492 of file G4CascadeInterface.cc.

References createTarget(), G4V3DNucleus::GetCharge(), and G4V3DNucleus::GetMassNumber().

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

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

protected

Definition at line 496 of file G4CascadeInterface.cc.

References G4InuclElementaryParticle::fill(), G4InuclNuclei::fill(), G4cout, G4endl, neutron, G4InuclParticleNames::proton, and G4HadronicInteraction::verboseLevel.

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

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

virtual

Definition at line 182 of file G4CascadeInterface.cc.

References G4CascadeParameters::DumpConfiguration().

                                                                     {
   G4CascadeParameters::DumpConfiguration(outFile);
 }

void G4CascadeInterface::Initialize ( )

static

Definition at line 194 of file G4CascadeInterface.cc.

References G4UnboundPN::Definition(), G4Dineutron::Definition(), G4Diproton::Definition(), G4CascadeChannelTables::GetTable(), G4InuclParticleNames::nn, G4InuclParticleNames::pn, and G4InuclParticleNames::pp.

Referenced by G4MTRunManager::InitializePhysics().

                                     {
   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"
 }

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

virtual

Reimplemented from G4HadronicInteraction.

Definition at line 227 of file G4CascadeInterface.cc.

References G4HadProjectile::GetDefinition().

Referenced by ApplyYourself(), and G4HadronicAbsorptionBertini::IsApplicable().

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

G4bool G4CascadeInterface::IsApplicable ( const G4ParticleDefinition * aPD ) const

Definition at line 232 of file G4CascadeInterface.cc.

References G4ParticleDefinition::GetAtomicMass(), G4CascadeChannelTables::GetTable(), and G4InuclElementaryParticle::type().

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

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

protected

Definition at line 514 of file G4CascadeInterface.cc.

References G4KaonZeroShort::Definition(), G4KaonZeroLong::Definition(), G4cerr, G4endl, G4UniformRand, G4InuclParticle::getDynamicParticle(), G4InuclParticle::getKineticEnergy(), G4InuclParticle::getMomentum(), python.hepunit::GeV, G4InuclParticleNames::kaonZero, G4InuclParticleNames::kaonZeroBar, G4InuclElementaryParticle::quasi_deutron(), G4InuclElementaryParticle::type(), CLHEP::Hep3Vector::unit(), and CLHEP::HepLorentzVector::vect().

Referenced by copyOutputToHadronicResult(), and copyOutputToReactionProducts().

                                                                 {
   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!
 }

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

protected

Definition at line 540 of file G4CascadeInterface.cc.

References G4cout, G4endl, G4InuclParticle::getDynamicParticle(), and G4HadronicInteraction::verboseLevel.

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

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

virtual

Reimplemented from G4VIntraNuclearTransportModel.

Definition at line 168 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";
 }

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

protected

Definition at line 422 of file G4CascadeInterface.cc.

References G4HadFinalState::Clear(), G4cout, G4endl, G4HadProjectile::GetKineticEnergy(), isAlive, G4HadFinalState::SetEnergyChange(), G4HadFinalState::SetStatusChange(), G4HadronicInteraction::theParticleChange, and G4HadronicInteraction::verboseLevel.

Referenced by ApplyYourself().

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

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

virtual

Implements G4VIntraNuclearTransportModel.

Definition at line 347 of file G4CascadeInterface.cc.

References G4HadFinalState::Clear(), clear(), G4CascadeCheckBalance::collide(), copyOutputToReactionProducts(), createBullet(), createTarget(), G4INCL::ClusterDecay::decay(), G4cerr, G4cout, G4endl, G4KineticTrack::Get4Momentum(), G4V3DNucleus::GetCharge(), G4KineticTrack::GetDefinition(), G4KineticTrack::GetFormationTime(), G4V3DNucleus::GetMassNumber(), G4ParticleDefinition::GetParticleName(), G4KineticTrack::GetPosition(), G4VIntraNuclearTransportModel::GetPrimaryProjectile(), G4CascadeCheckBalance::okay(), G4CollisionOutput::printCollisionOutput(), G4InuclCollider::rescatter(), G4CollisionOutput::reset(), retryInelasticNucleus(), CLHEP::HepRandom::saveEngineStatus(), G4HadronicInteraction::theParticleChange, throwNonConservationFailure(), and G4HadronicInteraction::verboseLevel.

                                             {
   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());
 
   // 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;
 }

G4bool G4CascadeInterface::retryInelasticNucleus ( ) const

protected

Definition at line 708 of file G4CascadeInterface.cc.

References coulombBarrierViolation(), G4cout, G4endl, G4InuclParticle::getDefinition(), G4CollisionOutput::getOutgoingParticles(), G4CollisionOutput::numberOfOutgoingNuclei(), G4CollisionOutput::numberOfOutgoingParticles(), and G4CascadeCheckBalance::okay().

Referenced by ApplyYourself(), and Propagate().

                                                        {
   // 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 collsion 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
        );
 }

G4bool G4CascadeInterface::retryInelasticProton ( ) const

protected

Definition at line 676 of file G4CascadeInterface.cc.

References G4cout, G4endl, G4InuclParticle::getDefinition(), and G4CollisionOutput::getOutgoingParticles().

Referenced by ApplyYourself().

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

void G4CascadeInterface::SetVerboseLevel ( G4int verbose )

virtual

Reimplemented from G4HadronicInteraction.

Definition at line 217 of file G4CascadeInterface.cc.

References G4VCascadeCollider::setVerboseLevel(), G4CollisionOutput::setVerboseLevel(), G4InuclCollider::setVerboseLevel(), and G4HadronicInteraction::SetVerboseLevel().

Referenced by G4CascadeInterface().

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

void G4CascadeInterface::throwNonConservationFailure ( )

protected

Definition at line 756 of file G4CascadeInterface.cc.

References G4CascadeCheckBalance::baryonOkay(), G4CascadeCheckBalance::chargeOkay(), G4CascadeCheckBalance::deltaB(), G4CascadeCheckBalance::deltaE(), G4CascadeCheckBalance::deltaP(), G4CascadeCheckBalance::deltaQ(), G4CascadeCheckBalance::energyOkay(), G4cerr, G4endl, G4CascadeCheckBalance::momentumOkay(), G4CollisionOutput::printCollisionOutput(), G4CascadeCheckBalance::relativeE(), and G4CascadeCheckBalance::relativeP().

Referenced by ApplyYourself(), and Propagate().

                                                      {
   // 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!
 }

void G4CascadeInterface::useCascadeDeexcitation ( )

Definition at line 206 of file G4CascadeInterface.cc.

References G4InuclCollider::useCascadeDeexcitation().

                                                 {
   collider->useCascadeDeexcitation();
 }

void G4CascadeInterface::usePreCompoundDeexcitation ( )

Definition at line 210 of file G4CascadeInterface.cc.

References G4InuclCollider::usePreCompoundDeexcitation().

Referenced by G4CascadeInterface(), and G4HadronicAbsorptionBertini::G4HadronicAbsorptionBertini().

                                                     {
   collider->usePreCompoundDeexcitation();
 }

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation