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 ()
virtual void	ModelDescription (std::ostream &outFile) const
virtual void	DumpConfiguration (std::ostream &outFile) const
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

---

Detailed Description

Definition at line 84 of file G4CascadeInterface.hh.

---

Constructor & Destructor Documentation

G4CascadeInterface::G4CascadeInterface

(

const G4String &

name = "BertiniCascade"

)

Definition at line 144 of file G4CascadeInterface.cc.

References 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 157 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 230 of file G4CascadeInterface.cc.

References checkFinalResult(), clear(), G4HadFinalState::Clear(), G4CascadeCheckBalance::collide(), G4InuclCollider::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(), 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();
  return &theParticleChange;
}

void G4CascadeInterface::checkFinalResult

(

)

[protected]

Definition at line 598 of file G4CascadeInterface.cc.

References G4CascadeCheckBalance::baryonOkay(), G4CascadeCheckBalance::chargeOkay(), G4CascadeCheckBalance::collide(), G4CascadeCheckBalance::deltaB(), G4CascadeCheckBalance::deltaE(), G4CascadeCheckBalance::deltaKE(), G4CascadeCheckBalance::deltaQ(), G4cerr, G4cout, G4endl, G4InuclParticle::getEnergy(), 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

(

)

[protected]

Definition at line 183 of file G4CascadeInterface.cc.

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

                               {
  bullet=0;
  target=0;
}

void G4CascadeInterface::copyOutputToHadronicResult

(

)

[protected]

Definition at line 529 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 556 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 634 of file G4CascadeInterface.cc.

References G4CollisionOutput::getOutgoingParticles(), 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 415 of file G4CascadeInterface.cc.

References G4InuclNuclei::fill(), G4InuclElementaryParticle::fill(), G4cerr, G4cout, G4endl, G4HadProjectile::Get4Momentum(), G4ParticleDefinition::GetAtomicMass(), G4ParticleDefinition::GetAtomicNumber(), G4HadProjectile::GetDefinition(), G4ParticleDefinition::GetParticleName(), G4InuclElementaryParticle::type(), 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 (bulletType > 0) {
    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	(	G4int	A,
		G4int	Z
	)			[protected]

Definition at line 473 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
}

G4bool G4CascadeInterface::createTarget

(

G4V3DNucleus *

theNucleus

)

[protected]

Definition at line 469 of file G4CascadeInterface.cc.

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

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

G4bool G4CascadeInterface::createTarget

(

G4Nucleus &

theNucleus

)

[protected]

Definition at line 465 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());
}

void G4CascadeInterface::DumpConfiguration

(

std::ostream &

outFile

)

const [virtual]

Definition at line 178 of file G4CascadeInterface.cc.

References G4CascadeParameters::DumpConfiguration().

                                                                    {
  G4CascadeParameters::DumpConfiguration(outFile);
}

G4bool G4CascadeInterface::IsApplicable

(

const G4ParticleDefinition *

aPD

)

const

Definition at line 218 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 (type>0 && G4CascadeChannelTables::GetTable(type));
}

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

Reimplemented from G4HadronicInteraction.

Definition at line 213 of file G4CascadeInterface.cc.

References G4HadProjectile::GetDefinition().

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

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

G4DynamicParticle * G4CascadeInterface::makeDynamicParticle

(

const G4InuclNuclei &

inuc

)

const [protected]

Definition at line 517 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());
}

G4DynamicParticle * G4CascadeInterface::makeDynamicParticle

(

const G4InuclElementaryParticle &

iep

)

const [protected]

Definition at line 491 of file G4CascadeInterface.cc.

References G4KaonZeroLong::Definition(), G4KaonZeroShort::Definition(), G4cerr, G4endl, G4UniformRand, G4InuclParticle::getDynamicParticle(), G4InuclParticle::getKineticEnergy(), G4InuclParticle::getMomentum(), G4InuclParticleNames::kaonZero, G4InuclParticleNames::kaonZeroBar, G4InuclElementaryParticle::quasi_deutron(), and G4InuclElementaryParticle::type().

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

void G4CascadeInterface::ModelDescription

(

std::ostream &

outFile

)

const [virtual]

Reimplemented from G4VIntraNuclearTransportModel.

Definition at line 164 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 398 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 323 of file G4CascadeInterface.cc.

References clear(), G4HadFinalState::Clear(), G4CascadeCheckBalance::collide(), copyOutputToReactionProducts(), createBullet(), createTarget(), G4cerr, G4cout, G4endl, G4V3DNucleus::GetCharge(), G4V3DNucleus::GetMassNumber(), G4VIntraNuclearTransportModel::GetPrimaryProjectile(), G4CascadeCheckBalance::okay(), G4CollisionOutput::printCollisionOutput(), G4InuclCollider::rescatter(), G4CollisionOutput::reset(), retryInelasticNucleus(), 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 685 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 653 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

)

Reimplemented from G4HadronicInteraction.

Definition at line 203 of file G4CascadeInterface.cc.

References G4CollisionOutput::setVerboseLevel(), G4VCascadeCollider::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 733 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 192 of file G4CascadeInterface.cc.

References G4InuclCollider::useCascadeDeexcitation().

                                                {
  collider->useCascadeDeexcitation();
}

void G4CascadeInterface::usePreCompoundDeexcitation

(

)

Definition at line 196 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:

• G4CascadeInterface.hh
• G4CascadeInterface.cc

---