G4INCL::INCL Class Reference

#include <G4INCLCascade.hh>

Data Structures
class	RecoilCMFunctor
	Class to adjust remnant recoil in the reaction CM system. More...
class	RecoilFunctor
	Class to adjust remnant recoil. More...

Public Member Functions
void	finalizeGlobalInfo (Random::SeedVector const &initialSeeds)
const GlobalInfo &	getGlobalInfo () const
	INCL (Config const *const config)
	INCL (const INCL &rhs)
	Dummy copy constructor to silence Coverity warning. More...
G4bool	initializeTarget (const G4int A, const G4int Z, const G4int S)
INCL &	operator= (const INCL &rhs)
	Dummy assignment operator to silence Coverity warning. More...
G4bool	prepareReaction (const ParticleSpecies &projectileSpecies, const G4double kineticEnergy, const G4int A, const G4int Z, const G4int S)
const EventInfo &	processEvent ()
const EventInfo &	processEvent (ParticleSpecies const &projectileSpecies, const G4double kineticEnergy, const G4int targetA, const G4int targetZ, const G4int targetS)
	~INCL ()

Private Member Functions
void	cascade ()
	The actual cascade loop. More...
G4bool	continueCascade ()
	Stopping criterion for the cascade. More...
void	initMaxInteractionDistance (ParticleSpecies const &p, const G4double kineticEnergy)
	Initialise the maximum interaction distance. More...
void	initUniverseRadius (ParticleSpecies const &p, const G4double kineticEnergy, const G4int A, const G4int Z)
	Initialize the universe radius. More...
void	makeCompoundNucleus ()
	Make a compound nucleus. More...
G4int	makeProjectileRemnant ()
	Make a projectile pre-fragment out of geometrical spectators. More...
void	postCascade ()
	Finalise the cascade and clean up. More...
G4bool	preCascade (ParticleSpecies const &projectileSpecies, const G4double kineticEnergy)
	Initialise the cascade. More...
void	rescaleOutgoingForRecoil ()
	Rescale the energies of the outgoing particles. More...
void	updateGlobalInfo ()
	Update global counters and other members of theGlobalInfo object. More...

Private Attributes
CascadeAction *	cascadeAction
G4double	fixedImpactParameter
G4bool	forceTransparent
G4double	maxImpactParameter
G4double	maxInteractionDistance
G4double	maxUniverseRadius
G4int	minRemnantSize
	Remnant size below which cascade stops. More...
Nucleus *	nucleus
IPropagationModel *	propagationModel
G4bool	targetInitSuccess
G4int	theA
Config const *const	theConfig
EventInfo	theEventInfo
GlobalInfo	theGlobalInfo
G4int	theS
G4int	theZ

Detailed Description

Definition at line 52 of file G4INCLCascade.hh.

Constructor & Destructor Documentation

INCL() [1/2]

G4INCL::INCL::INCL

(

Config const *const

config

)

Definition at line 79 of file G4INCLCascade.cc.

    :propagationModel(0), theA(208), theZ(82), theS(0),
    targetInitSuccess(false),
    maxImpactParameter(0.),
    maxUniverseRadius(0.),
    maxInteractionDistance(0.),
    fixedImpactParameter(0.),
    theConfig(config),
    nucleus(NULL),
    forceTransparent(false),
    minRemnantSize(4)
  {
    // Set the logger object.
#ifdef INCLXX_IN_GEANT4_MODE
    Logger::initVerbosityLevelFromEnvvar();
#else // INCLXX_IN_GEANT4_MODE
    Logger::initialize(theConfig);
#endif // INCLXX_IN_GEANT4_MODE
 
    // Set the random number generator algorithm. The system can support
    // multiple different generator algorithms in a completely
    // transparent way.
    Random::initialize(theConfig);
 
    // Select the Pauli and CDPP blocking algorithms
    Pauli::initialize(theConfig);
 
    // Set the cross-section set
    CrossSections::initialize(theConfig);
 
    // Set the phase-space generator
    PhaseSpaceGenerator::initialize(theConfig);
 
    // Select the Coulomb-distortion algorithm:
    CoulombDistortion::initialize(theConfig);
 
    // Select the clustering algorithm:
    Clustering::initialize(theConfig);
 
    // Initialize the INCL particle table:
    ParticleTable::initialize(theConfig);
 
    // Initialize the value of cutNN in BinaryCollisionAvatar
    BinaryCollisionAvatar::setCutNN(theConfig->getCutNN());
 
    // Initialize the value of strange cross section bias
    BinaryCollisionAvatar::setBias(theConfig->getBias());
 
    // Propagation model is responsible for finding avatars and
    // transporting the particles. In principle this step is "hidden"
    // behind an abstract interface and the rest of the system does not
    // care how the transportation and avatar finding is done. This
    // should allow us to "easily" experiment with different avatar
    // finding schemes and even to support things like curved
    // trajectories in the future.
    propagationModel = new StandardPropagationModel(theConfig->getLocalEnergyBBType(),theConfig->getLocalEnergyPiType(),theConfig->getHadronizationTime());
    if(theConfig->getCascadeActionType() == AvatarDumpActionType)
      cascadeAction = new AvatarDumpAction();
    else
      cascadeAction = new CascadeAction();
    cascadeAction->beforeRunAction(theConfig);
 
    theGlobalInfo.cascadeModel = theConfig->getVersionString();
    theGlobalInfo.deexcitationModel = theConfig->getDeExcitationString();
#ifdef INCL_ROOT_USE
    theGlobalInfo.rootSelection = theConfig->getROOTSelectionString();
#endif
 
#ifndef INCLXX_IN_GEANT4_MODE
    // Fill in the global information
    theGlobalInfo.At = theConfig->getTargetA();
    theGlobalInfo.Zt = theConfig->getTargetZ();
    theGlobalInfo.St = theConfig->getTargetS();
    const ParticleSpecies theSpecies = theConfig->getProjectileSpecies();
    theGlobalInfo.Ap = theSpecies.theA;
    theGlobalInfo.Zp = theSpecies.theZ;
    theGlobalInfo.Sp = theSpecies.theS;
    theGlobalInfo.Ep = theConfig->getProjectileKineticEnergy();
    theGlobalInfo.biasFactor = theConfig->getBias();
#endif
 
    fixedImpactParameter = theConfig->getImpactParameter();
  }

References G4INCL::GlobalInfo::Ap, G4INCL::GlobalInfo::At, G4INCL::AvatarDumpActionType, G4INCL::CascadeAction::beforeRunAction(), G4INCL::GlobalInfo::biasFactor, cascadeAction, G4INCL::GlobalInfo::cascadeModel, G4INCL::GlobalInfo::deexcitationModel, G4INCL::GlobalInfo::Ep, fixedImpactParameter, G4INCL::Config::getBias(), G4INCL::Config::getCascadeActionType(), G4INCL::Config::getCutNN(), G4INCL::Config::getDeExcitationString(), G4INCL::Config::getHadronizationTime(), G4INCL::Config::getImpactParameter(), G4INCL::Config::getLocalEnergyBBType(), G4INCL::Config::getLocalEnergyPiType(), G4INCL::Config::getProjectileKineticEnergy(), G4INCL::Config::getProjectileSpecies(), G4INCL::Config::getTargetA(), G4INCL::Config::getTargetS(), G4INCL::Config::getTargetZ(), G4INCL::Config::getVersionString(), G4INCL::Pauli::initialize(), G4INCL::Clustering::initialize(), G4INCL::CoulombDistortion::initialize(), G4INCL::CrossSections::initialize(), G4INCL::PhaseSpaceGenerator::initialize(), G4INCL::ParticleTable::initialize(), G4INCL::Random::initialize(), G4INCL::Logger::initVerbosityLevelFromEnvvar(), propagationModel, G4INCL::BinaryCollisionAvatar::setBias(), G4INCL::BinaryCollisionAvatar::setCutNN(), G4INCL::GlobalInfo::Sp, G4INCL::GlobalInfo::St, G4INCL::ParticleSpecies::theA, theConfig, theGlobalInfo, G4INCL::ParticleSpecies::theS, G4INCL::ParticleSpecies::theZ, G4INCL::GlobalInfo::Zp, and G4INCL::GlobalInfo::Zt.

~INCL()

G4INCL::INCL::~INCL

(

)

Definition at line 163 of file G4INCLCascade.cc.

              {
    InteractionAvatar::deleteBackupParticles();
#ifndef INCLXX_IN_GEANT4_MODE
    NuclearMassTable::deleteTable();
#endif
    PhaseSpaceGenerator::deletePhaseSpaceGenerator();
    CrossSections::deleteCrossSections();
    Pauli::deleteBlockers();
    CoulombDistortion::deleteCoulomb();
    Random::deleteGenerator();
    Clustering::deleteClusteringModel();
#ifndef INCLXX_IN_GEANT4_MODE
    Logger::deleteLoggerSlave();
#endif
    NuclearDensityFactory::clearCache();
    NuclearPotential::clearCache();
    cascadeAction->afterRunAction();
    delete cascadeAction;
    delete propagationModel;
    delete theConfig;
  }

References G4INCL::CascadeAction::afterRunAction(), cascadeAction, G4INCL::NuclearPotential::clearCache(), G4INCL::NuclearDensityFactory::clearCache(), G4INCL::InteractionAvatar::deleteBackupParticles(), G4INCL::Pauli::deleteBlockers(), G4INCL::Clustering::deleteClusteringModel(), G4INCL::CoulombDistortion::deleteCoulomb(), G4INCL::CrossSections::deleteCrossSections(), G4INCL::Random::deleteGenerator(), G4INCL::PhaseSpaceGenerator::deletePhaseSpaceGenerator(), propagationModel, and theConfig.

INCL() [2/2]

G4INCL::INCL::INCL

(

const INCL &

rhs

)

Dummy copy constructor to silence Coverity warning.

Member Function Documentation

cascade()

void G4INCL::INCL::cascade ( )

private

The actual cascade loop.

Definition at line 331 of file G4INCLCascade.cc.

                     {
    FinalState *finalState = new FinalState;
 
    unsigned long loopCounter = 0;
    const unsigned long maxLoopCounter = 10000000;
    do {
      // Run book keeping actions that should take place before propagation:
      cascadeAction->beforePropagationAction(propagationModel);
 
      // Get the avatar with the smallest time and propagate particles
      // to that point in time.
      IAvatar *avatar = propagationModel->propagate(finalState);
 
      finalState->reset();
 
      // Run book keeping actions that should take place after propagation:
      cascadeAction->afterPropagationAction(propagationModel, avatar);
 
      if(avatar == 0) break; // No more avatars in the avatar list.
 
      // Run book keeping actions that should take place before avatar:
      cascadeAction->beforeAvatarAction(avatar, nucleus);
 
      // Channel is responsible for calculating the outcome of the
      // selected avatar. There are different kinds of channels. The
      // class IChannel is, again, an abstract interface that defines
      // the externally observable behavior of all interaction
      // channels.
      // The handling of the channel is transparent to the API.
      // Final state tells what changed...
      avatar->fillFinalState(finalState);
      // Run book keeping actions that should take place after avatar:
      cascadeAction->afterAvatarAction(avatar, nucleus, finalState);
 
      // So now we must give this information to the nucleus
      nucleus->applyFinalState(finalState);
      // and now we are ready to process the next avatar!
 
      delete avatar;
 
      ++loopCounter;
    } while(continueCascade() && loopCounter<maxLoopCounter); /* Loop checking, 10.07.2015, D.Mancusi */
    
    delete finalState;
  }

References G4INCL::CascadeAction::afterAvatarAction(), G4INCL::CascadeAction::afterPropagationAction(), G4INCL::Nucleus::applyFinalState(), G4INCL::CascadeAction::beforeAvatarAction(), G4INCL::CascadeAction::beforePropagationAction(), cascadeAction, continueCascade(), G4INCL::IAvatar::fillFinalState(), nucleus, G4INCL::IPropagationModel::propagate(), propagationModel, and G4INCL::FinalState::reset().

Referenced by processEvent().

continueCascade()

G4bool G4INCL::INCL::continueCascade ( )

private

Stopping criterion for the cascade.

Returns true if the cascade should continue, and false if any of the stopping criteria is satisfied.

Definition at line 713 of file G4INCLCascade.cc.

                               {
    // Stop if we have passed the stopping time
    if(propagationModel->getCurrentTime() > propagationModel->getStoppingTime()) {
      INCL_DEBUG("Cascade time (" << propagationModel->getCurrentTime()
          << ") exceeded stopping time (" << propagationModel->getStoppingTime()
          << "), stopping cascade" << '\n');
      return false;
    }
    // Stop if there are no participants and no pions inside the nucleus
    if(nucleus->getStore()->getBook().getCascading()==0 &&
        nucleus->getStore()->getIncomingParticles().empty()) {
      INCL_DEBUG("No participants in the nucleus and no incoming particles left, stopping cascade" << '\n');
      return false;
    }
    // Stop if the remnant is smaller than minRemnantSize
    if(nucleus->getA() <= minRemnantSize) {
      INCL_DEBUG("Remnant size (" << nucleus->getA()
          << ") smaller than or equal to minimum (" << minRemnantSize
          << "), stopping cascade" << '\n');
      return false;
    }
    // Stop if we have to try and make a compound nucleus or if we have to
    // force a transparent
    if(nucleus->getTryCompoundNucleus()) {
      INCL_DEBUG("Trying to make a compound nucleus, stopping cascade" << '\n');
      return false;
    }
 
    return true;
  }

References G4INCL::Particle::getA(), G4INCL::Store::getBook(), G4INCL::Book::getCascading(), G4INCL::IPropagationModel::getCurrentTime(), G4INCL::Store::getIncomingParticles(), G4INCL::IPropagationModel::getStoppingTime(), G4INCL::Nucleus::getStore(), G4INCL::Nucleus::getTryCompoundNucleus(), INCL_DEBUG, minRemnantSize, nucleus, and propagationModel.

Referenced by cascade().

finalizeGlobalInfo()

void G4INCL::INCL::finalizeGlobalInfo

(

Random::SeedVector const &

initialSeeds

)

Definition at line 744 of file G4INCLCascade.cc.

                                                                    {
    const G4double normalisationFactor = theGlobalInfo.geometricCrossSection /
      ((G4double) theGlobalInfo.nShots);
    theGlobalInfo.nucleonAbsorptionCrossSection = normalisationFactor *
      ((G4double) theGlobalInfo.nNucleonAbsorptions);
    theGlobalInfo.pionAbsorptionCrossSection = normalisationFactor *
      ((G4double) theGlobalInfo.nPionAbsorptions);
    theGlobalInfo.reactionCrossSection = normalisationFactor *
      ((G4double) (theGlobalInfo.nShots - theGlobalInfo.nTransparents));
    theGlobalInfo.errorReactionCrossSection = normalisationFactor *
      std::sqrt((G4double) (theGlobalInfo.nShots - theGlobalInfo.nTransparents));
    theGlobalInfo.forcedCNCrossSection = normalisationFactor *
      ((G4double) theGlobalInfo.nForcedCompoundNucleus);
    theGlobalInfo.errorForcedCNCrossSection = normalisationFactor *
      std::sqrt((G4double) (theGlobalInfo.nForcedCompoundNucleus));
    theGlobalInfo.completeFusionCrossSection = normalisationFactor *
      ((G4double) theGlobalInfo.nCompleteFusion);
    theGlobalInfo.errorCompleteFusionCrossSection = normalisationFactor *
      std::sqrt((G4double) (theGlobalInfo.nCompleteFusion));
    theGlobalInfo.energyViolationInteractionCrossSection = normalisationFactor *
      ((G4double) theGlobalInfo.nEnergyViolationInteraction);
 
    theGlobalInfo.initialRandomSeeds.assign(initialSeeds.begin(), initialSeeds.end());
 
    Random::SeedVector theSeeds = Random::getSeeds();
    theGlobalInfo.finalRandomSeeds.assign(theSeeds.begin(), theSeeds.end());
  }

References G4INCL::GlobalInfo::completeFusionCrossSection, G4INCL::GlobalInfo::energyViolationInteractionCrossSection, G4INCL::GlobalInfo::errorCompleteFusionCrossSection, G4INCL::GlobalInfo::errorForcedCNCrossSection, G4INCL::GlobalInfo::errorReactionCrossSection, G4INCL::GlobalInfo::finalRandomSeeds, G4INCL::GlobalInfo::forcedCNCrossSection, G4INCL::GlobalInfo::geometricCrossSection, G4INCL::Random::getSeeds(), G4INCL::GlobalInfo::initialRandomSeeds, G4INCL::GlobalInfo::nCompleteFusion, G4INCL::GlobalInfo::nEnergyViolationInteraction, G4INCL::GlobalInfo::nForcedCompoundNucleus, G4INCL::GlobalInfo::nNucleonAbsorptions, G4INCL::GlobalInfo::nPionAbsorptions, G4INCL::GlobalInfo::nShots, G4INCL::GlobalInfo::nTransparents, G4INCL::GlobalInfo::nucleonAbsorptionCrossSection, G4INCL::GlobalInfo::pionAbsorptionCrossSection, G4INCL::GlobalInfo::reactionCrossSection, and theGlobalInfo.

getGlobalInfo()

const GlobalInfo & G4INCL::INCL::getGlobalInfo ( ) const

inline

Definition at line 84 of file G4INCLCascade.hh.

{ return theGlobalInfo; }

References theGlobalInfo.

initializeTarget()

G4bool G4INCL::INCL::initializeTarget	(	const G4int	A,
		const G4int	Z,
		const G4int	S
	)

Definition at line 233 of file G4INCLCascade.cc.

                                                                           {
    delete nucleus;
 
    nucleus = new Nucleus(A, Z, S, theConfig, maxUniverseRadius);
    nucleus->getStore()->getBook().reset();
    nucleus->initializeParticles();
 
    propagationModel->setNucleus(nucleus);
    return true;
  }

References A, G4INCL::Store::getBook(), G4INCL::Nucleus::getStore(), G4INCL::Nucleus::initializeParticles(), maxUniverseRadius, nucleus, propagationModel, G4INCL::Book::reset(), S(), G4INCL::IPropagationModel::setNucleus(), theConfig, and Z.

Referenced by prepareReaction().

initMaxInteractionDistance()

void G4INCL::INCL::initMaxInteractionDistance ( ParticleSpecies const &  p, const G4double  kineticEnergy  )

private

Initialise the maximum interaction distance.

Used in forced CN events.

Definition at line 808 of file G4INCLCascade.cc.

                                                                                                              {
    if(projectileSpecies.theType != Composite) {
      maxInteractionDistance = 0.;
      return;
    }
 
    const G4double r0 = std::max(ParticleTable::getNuclearRadius(Proton, theA, theZ),
                               ParticleTable::getNuclearRadius(Neutron, theA, theZ));
 
    const G4double theNNDistance = CrossSections::interactionDistanceNN(projectileSpecies, kineticEnergy);
    maxInteractionDistance = r0 + theNNDistance;
    INCL_DEBUG("Initialised interaction distance: r0 = " << r0 << '\n'
          << "    theNNDistance = " << theNNDistance << '\n'
          << "    maxInteractionDistance = " << maxInteractionDistance << '\n');
  }

References G4INCL::Composite, G4INCL::ParticleTable::getNuclearRadius(), INCL_DEBUG, G4INCL::CrossSections::interactionDistanceNN(), G4INCL::Math::max(), maxInteractionDistance, G4INCL::Neutron, G4INCL::Proton, theA, G4INCL::ParticleSpecies::theType, and theZ.

Referenced by prepareReaction().

initUniverseRadius()

void G4INCL::INCL::initUniverseRadius ( ParticleSpecies const &  p, const G4double  kineticEnergy, const G4int  A, const G4int  Z  )

private

Initialize the universe radius.

Used for determining the energy-dependent size of the volume particles live in.

Definition at line 824 of file G4INCLCascade.cc.

                                                                                                                    {
    G4double rMax = 0.0;
    if(A==0) {
      IsotopicDistribution const &anIsotopicDistribution =
        ParticleTable::getNaturalIsotopicDistribution(Z);
      IsotopeVector theIsotopes = anIsotopicDistribution.getIsotopes();
      for(IsotopeIter i=theIsotopes.begin(), e=theIsotopes.end(); i!=e; ++i) {
        const G4double pMaximumRadius = ParticleTable::getMaximumNuclearRadius(Proton, i->theA, Z);
        const G4double nMaximumRadius = ParticleTable::getMaximumNuclearRadius(Neutron, i->theA, Z);
        const G4double maximumRadius = std::max(pMaximumRadius, nMaximumRadius);
        rMax = std::max(maximumRadius, rMax);
      }
    } else {
      const G4double pMaximumRadius = ParticleTable::getMaximumNuclearRadius(Proton, A, Z);
      const G4double nMaximumRadius = ParticleTable::getMaximumNuclearRadius(Neutron, A, Z);
      const G4double maximumRadius = std::max(pMaximumRadius, nMaximumRadius);
      rMax = std::max(maximumRadius, rMax);
    }
    if(p.theType==Composite || p.theType==Proton || p.theType==Neutron) {
      const G4double interactionDistanceNN = CrossSections::interactionDistanceNN(p, kineticEnergy);
      maxUniverseRadius = rMax + interactionDistanceNN;
    } else if(p.theType==PiPlus
        || p.theType==PiZero
        || p.theType==PiMinus) {
      const G4double interactionDistancePiN = CrossSections::interactionDistancePiN(kineticEnergy);
      maxUniverseRadius = rMax + interactionDistancePiN;
    } else if(p.theType==KPlus
        || p.theType==KZero) {
      const G4double interactionDistanceKN = CrossSections::interactionDistanceKN(kineticEnergy);
      maxUniverseRadius = rMax + interactionDistanceKN;
    } else if(p.theType==KZeroBar
        || p.theType==KMinus) {
      const G4double interactionDistanceKbarN = CrossSections::interactionDistanceKbarN(kineticEnergy);
      maxUniverseRadius = rMax + interactionDistanceKbarN;
    } else if(p.theType==Lambda
        ||p.theType==SigmaPlus
        || p.theType==SigmaZero
        || p.theType==SigmaMinus) {
      const G4double interactionDistanceYN = CrossSections::interactionDistanceYN(kineticEnergy);
      maxUniverseRadius = rMax + interactionDistanceYN;
    }
    INCL_DEBUG("Initialised universe radius: " << maxUniverseRadius << '\n');
  }

References A, G4INCL::Composite, G4INCL::IsotopicDistribution::getIsotopes(), G4INCL::ParticleTable::getMaximumNuclearRadius(), G4INCL::ParticleTable::getNaturalIsotopicDistribution(), INCL_DEBUG, G4INCL::CrossSections::interactionDistanceKbarN(), G4INCL::CrossSections::interactionDistanceKN(), G4INCL::CrossSections::interactionDistanceNN(), G4INCL::CrossSections::interactionDistancePiN(), G4INCL::CrossSections::interactionDistanceYN(), G4INCL::KMinus, G4INCL::KPlus, G4INCL::KZero, G4INCL::KZeroBar, G4INCL::Lambda, G4INCL::Math::max(), maxUniverseRadius, G4INCL::Neutron, G4INCL::PiMinus, G4INCL::PiPlus, G4INCL::PiZero, G4INCL::Proton, G4INCL::SigmaMinus, G4INCL::SigmaPlus, G4INCL::SigmaZero, G4INCL::ParticleSpecies::theType, and Z.

Referenced by prepareReaction().

makeCompoundNucleus()

void G4INCL::INCL::makeCompoundNucleus ( )

private

Make a compound nucleus.

Selects the projectile components that can actually enter their potential and puts them into the target nucleus. If the CN excitation energy turns out to be negative, the event is considered a transparent. This method modifies theEventInfo and theGlobalInfo.

Definition at line 503 of file G4INCLCascade.cc.

                                 {
    // If this is not a nucleus-nucleus collision, don't attempt to make a
    // compound nucleus.
    //
    // Yes, even nucleon-nucleus collisions can lead to particles entering
    // below the Fermi level. Take e.g. 1-MeV p + He4.
    if(!nucleus->isNucleusNucleusCollision()) {
      forceTransparent = true;
      return;
    }
 
    // Reset the internal Nucleus variables
    nucleus->getStore()->clearIncoming();
    nucleus->getStore()->clearOutgoing();
    nucleus->getProjectileRemnant()->reset();
    nucleus->setA(theEventInfo.At);
    nucleus->setZ(theEventInfo.Zt);
 
    // CN kinematical variables
    // Note: the CN orbital angular momentum is neglected in what follows. We
    // should actually take it into account!
    ThreeVector theCNMomentum = nucleus->getIncomingMomentum();
    ThreeVector theCNSpin = nucleus->getIncomingAngularMomentum();
    const G4double theTargetMass = ParticleTable::getTableMass(theEventInfo.At, theEventInfo.Zt, theEventInfo.St);
    G4int theCNA=theEventInfo.At, theCNZ=theEventInfo.Zt, theCNS=theEventInfo.St;
    Cluster * const theProjectileRemnant = nucleus->getProjectileRemnant();
    G4double theCNEnergy = theTargetMass + theProjectileRemnant->getEnergy();
 
    // Loop over the potential participants
    ParticleList const &initialProjectileComponents = theProjectileRemnant->getParticles();
    std::vector<Particle *> shuffledComponents(initialProjectileComponents.begin(), initialProjectileComponents.end());
    // Shuffle the list of potential participants
    std::shuffle(shuffledComponents.begin(), shuffledComponents.end(), Random::getAdapter());
 
    G4bool success = true;
    G4bool atLeastOneNucleonEntering = false;
    for(std::vector<Particle*>::const_iterator p=shuffledComponents.begin(), e=shuffledComponents.end(); p!=e; ++p) {
      // Skip particles that miss the interaction distance
      Intersection intersectionInteractionDistance(IntersectionFactory::getEarlierTrajectoryIntersection(
            (*p)->getPosition(),
            (*p)->getPropagationVelocity(),
            maxInteractionDistance));
      if(!intersectionInteractionDistance.exists)
        continue;
 
      // Build an entry avatar for this nucleon
      atLeastOneNucleonEntering = true;
      ParticleEntryAvatar *theAvatar = new ParticleEntryAvatar(0.0, nucleus, *p);
      nucleus->getStore()->addParticleEntryAvatar(theAvatar);
      FinalState *fs = theAvatar->getFinalState();
      nucleus->applyFinalState(fs);
      FinalStateValidity validity = fs->getValidity();
      delete fs;
      switch(validity) {
        case ValidFS:
        case ParticleBelowFermiFS:
        case ParticleBelowZeroFS:
          // Add the particle to the CN
          theCNA++;
          theCNZ += (*p)->getZ();
          theCNS += (*p)->getS();
          break;
        case PauliBlockedFS:
        case NoEnergyConservationFS:
        default:
          success = false;
          break;
      }
    }
 
    if(!success || !atLeastOneNucleonEntering) {
      INCL_DEBUG("No nucleon entering in forced CN, forcing a transparent" << '\n');
      forceTransparent = true;
      return;
    }
 
// assert(theCNA==nucleus->getA());
// assert(theCNA<=theEventInfo.At+theEventInfo.Ap);
// assert(theCNZ<=theEventInfo.Zt+theEventInfo.Zp);
// assert(theCNS>=theEventInfo.St+theEventInfo.Sp);
 
    // Update the kinematics of the CN
    theCNEnergy -= theProjectileRemnant->getEnergy();
    theCNMomentum -= theProjectileRemnant->getMomentum();
 
    // Deal with the projectile remnant
    nucleus->finalizeProjectileRemnant(propagationModel->getCurrentTime());
 
    // Subtract the angular momentum of the projectile remnant
// assert(nucleus->getStore()->getOutgoingParticles().empty());
    theCNSpin -= theProjectileRemnant->getAngularMomentum();
 
    // Compute the excitation energy of the CN
    const G4double theCNMass = ParticleTable::getTableMass(theCNA,theCNZ,theCNS);
    const G4double theCNInvariantMassSquared = theCNEnergy*theCNEnergy-theCNMomentum.mag2();
    if(theCNInvariantMassSquared<0.) {
      // Negative invariant mass squared, return a transparent
      forceTransparent = true;
      return;
    }
    const G4double theCNExcitationEnergy = std::sqrt(theCNInvariantMassSquared) - theCNMass;
    if(theCNExcitationEnergy<0.) {
      // Negative excitation energy, return a transparent
      INCL_DEBUG("CN excitation energy is negative, forcing a transparent" << '\n'
            << "  theCNA = " << theCNA << '\n'
            << "  theCNZ = " << theCNZ << '\n'
            << "  theCNS = " << theCNS << '\n'
            << "  theCNEnergy = " << theCNEnergy << '\n'
            << "  theCNMomentum = (" << theCNMomentum.getX() << ", "<< theCNMomentum.getY() << ", "  << theCNMomentum.getZ() << ")" << '\n'
            << "  theCNExcitationEnergy = " << theCNExcitationEnergy << '\n'
            << "  theCNSpin = (" << theCNSpin.getX() << ", "<< theCNSpin.getY() << ", "  << theCNSpin.getZ() << ")" << '\n'
            );
      forceTransparent = true;
      return;
    } else {
      // Positive excitation energy, can make a CN
      INCL_DEBUG("CN excitation energy is positive, forcing a CN" << '\n'
            << "  theCNA = " << theCNA << '\n'
            << "  theCNZ = " << theCNZ << '\n'
            << "  theCNS = " << theCNS << '\n'
            << "  theCNEnergy = " << theCNEnergy << '\n'
            << "  theCNMomentum = (" << theCNMomentum.getX() << ", "<< theCNMomentum.getY() << ", "  << theCNMomentum.getZ() << ")" << '\n'
            << "  theCNExcitationEnergy = " << theCNExcitationEnergy << '\n'
            << "  theCNSpin = (" << theCNSpin.getX() << ", "<< theCNSpin.getY() << ", "  << theCNSpin.getZ() << ")" << '\n'
            );
      nucleus->setA(theCNA);
      nucleus->setZ(theCNZ);
      nucleus->setS(theCNS);
      nucleus->setMomentum(theCNMomentum);
      nucleus->setEnergy(theCNEnergy);
      nucleus->setExcitationEnergy(theCNExcitationEnergy);
      nucleus->setMass(theCNMass+theCNExcitationEnergy);
      nucleus->setSpin(theCNSpin); // neglects any orbital angular momentum of the CN
 
      // Take care of any remaining deltas
      theEventInfo.forcedDeltasOutside = nucleus->decayOutgoingDeltas();
 
      // Take care of any remaining etas and/or omegas
      G4double timeThreshold=theConfig->getDecayTimeThreshold();
      theEventInfo.forcedPionResonancesOutside = nucleus->decayOutgoingPionResonances(timeThreshold);
      
      // Take care of any remaining Kaons
      theEventInfo.emitKaon = nucleus->emitInsideKaon();
        
      // Cluster decay
      theEventInfo.clusterDecay = nucleus->decayOutgoingClusters() || nucleus->decayMe();
 
      // Fill the EventInfo structure
      nucleus->fillEventInfo(&theEventInfo);
    }
  }

References G4INCL::Store::addParticleEntryAvatar(), G4INCL::Nucleus::applyFinalState(), G4INCL::EventInfo::At, G4INCL::Store::clearIncoming(), G4INCL::Store::clearOutgoing(), G4INCL::EventInfo::clusterDecay, G4INCL::Nucleus::decayMe(), G4INCL::Nucleus::decayOutgoingClusters(), G4INCL::Nucleus::decayOutgoingDeltas(), G4INCL::Nucleus::decayOutgoingPionResonances(), G4INCL::Nucleus::emitInsideKaon(), G4INCL::EventInfo::emitKaon, G4INCL::Intersection::exists, G4INCL::Nucleus::fillEventInfo(), G4INCL::Nucleus::finalizeProjectileRemnant(), G4INCL::EventInfo::forcedDeltasOutside, G4INCL::EventInfo::forcedPionResonancesOutside, forceTransparent, G4INCL::Random::getAdapter(), G4INCL::Cluster::getAngularMomentum(), G4INCL::IPropagationModel::getCurrentTime(), G4INCL::Config::getDecayTimeThreshold(), G4INCL::IntersectionFactory::getEarlierTrajectoryIntersection(), G4INCL::Particle::getEnergy(), G4INCL::IAvatar::getFinalState(), G4INCL::Nucleus::getIncomingAngularMomentum(), G4INCL::Nucleus::getIncomingMomentum(), G4INCL::Particle::getMomentum(), G4INCL::Cluster::getParticles(), G4INCL::Nucleus::getProjectileRemnant(), G4INCL::Nucleus::getStore(), G4INCL::ParticleTable::getTableMass, G4INCL::FinalState::getValidity(), G4INCL::ThreeVector::getX(), G4INCL::ThreeVector::getY(), G4INCL::ThreeVector::getZ(), INCL_DEBUG, G4INCL::Nucleus::isNucleusNucleusCollision(), G4INCL::ThreeVector::mag2(), maxInteractionDistance, G4INCL::NoEnergyConservationFS, nucleus, G4INCL::ParticleBelowFermiFS, G4INCL::ParticleBelowZeroFS, G4INCL::PauliBlockedFS, propagationModel, G4INCL::ProjectileRemnant::reset(), G4INCL::Cluster::setA(), G4INCL::Particle::setEnergy(), G4INCL::Cluster::setExcitationEnergy(), G4INCL::Particle::setMass(), G4INCL::Particle::setMomentum(), G4INCL::Cluster::setS(), G4INCL::Cluster::setSpin(), G4INCL::Cluster::setZ(), G4INCL::EventInfo::St, theConfig, theEventInfo, G4INCL::ValidFS, and G4INCL::EventInfo::Zt.

Referenced by postCascade().

makeProjectileRemnant()

G4int G4INCL::INCL::makeProjectileRemnant ( )

private

Make a projectile pre-fragment out of geometrical spectators.

The projectile pre-fragment is assigned an excitation energy given by , where is the sum of the energies of the spectator particles, and is the sum of the smallest particle energies initially present in the projectile, being the mass of the projectile pre-fragment. This is equivalent to assuming that the excitation energy is given by the sum of the transitions of all excited projectile components to the "holes" left by the participants.

This method can modify the outgoing list and adds a projectile pre-fragment.

Returns

the number of dynamical spectators that were merged back in the projectile

Definition at line 772 of file G4INCLCascade.cc.

                                    {
    // Do nothing if this is not a nucleus-nucleus reaction
    if(!nucleus->getProjectileRemnant())
      return 0;
 
    // Get the spectators (geometrical+dynamical) from the Store
    ParticleList geomSpectators(nucleus->getProjectileRemnant()->getParticles());
    ParticleList dynSpectators(nucleus->getStore()->extractDynamicalSpectators());
 
    G4int nUnmergedSpectators = 0;
 
    // If there are no spectators, do nothing
    if(dynSpectators.empty() && geomSpectators.empty()) {
      return 0;
    } else if(dynSpectators.size()==1 && geomSpectators.empty()) {
      // No geometrical spectators, one dynamical spectator
      // Just put it back in the outgoing list
      nucleus->getStore()->addToOutgoing(dynSpectators.front());
    } else {
      // Make a cluster out of the geometrical spectators
      ProjectileRemnant *theProjectileRemnant = nucleus->getProjectileRemnant();
 
      // Add the dynamical spectators to the bunch
      ParticleList rejected = theProjectileRemnant->addAllDynamicalSpectators(dynSpectators);
      // Put back the rejected spectators into the outgoing list
      nUnmergedSpectators = rejected.size();
      nucleus->getStore()->addToOutgoing(rejected);
 
      // Deal with the projectile remnant
      nucleus->finalizeProjectileRemnant(propagationModel->getCurrentTime());
 
    }
 
    return nUnmergedSpectators;
  }

References G4INCL::ProjectileRemnant::addAllDynamicalSpectators(), G4INCL::Store::addToOutgoing(), G4INCL::Store::extractDynamicalSpectators(), G4INCL::Nucleus::finalizeProjectileRemnant(), G4INCL::IPropagationModel::getCurrentTime(), G4INCL::Cluster::getParticles(), G4INCL::Nucleus::getProjectileRemnant(), G4INCL::Nucleus::getStore(), nucleus, and propagationModel.

Referenced by postCascade().

operator=()

INCL & G4INCL::INCL::operator=

(

const INCL &

rhs

)

Dummy assignment operator to silence Coverity warning.

postCascade()

void G4INCL::INCL::postCascade ( )

private

Finalise the cascade and clean up.

Definition at line 377 of file G4INCLCascade.cc.

                         {
    // Fill in the event information
    theEventInfo.stoppingTime = propagationModel->getCurrentTime();
 
    // The event bias
    theEventInfo.eventBias = (Double_t) Particle::getTotalBias();
    
    // Forced CN?
    if(nucleus->getTryCompoundNucleus()) {
      INCL_DEBUG("Trying compound nucleus" << '\n');
      makeCompoundNucleus();
      theEventInfo.transparent = forceTransparent;
      // Global checks of conservation laws
#ifndef INCLXX_IN_GEANT4_MODE
      if(!theEventInfo.transparent) globalConservationChecks(true);
#endif
      return;
    }
 
    theEventInfo.transparent = forceTransparent || nucleus->isEventTransparent();
 
    if(theEventInfo.transparent) {
      ProjectileRemnant * const projectileRemnant = nucleus->getProjectileRemnant();
      if(projectileRemnant) {
        // Clear the incoming list (particles will be deleted by the ProjectileRemnant)
        nucleus->getStore()->clearIncoming();
      } else {
        // Delete particles in the incoming list
        nucleus->getStore()->deleteIncoming();
      }
    } else {
      
      // Check if the nucleus contains strange particles
      theEventInfo.sigmasInside = nucleus->containsSigma();
      theEventInfo.antikaonsInside = nucleus->containsAntiKaon();
      theEventInfo.lambdasInside = nucleus->containsLambda();
      theEventInfo.kaonsInside = nucleus->containsKaon();
      
      // Capture antiKaons and Sigmas and produce Lambda instead
      theEventInfo.absorbedStrangeParticle = nucleus->decayInsideStrangeParticles();
      
      // Emit strange particles still inside the nucleus
      nucleus->emitInsideStrangeParticles();
      theEventInfo.emitKaon = nucleus->emitInsideKaon();
 
#ifdef INCLXX_IN_GEANT4_MODE
      theEventInfo.emitLambda = nucleus->emitInsideLambda();
#endif // INCLXX_IN_GEANT4_MODE
      
      // Check if the nucleus contains deltas
      theEventInfo.deltasInside = nucleus->containsDeltas();
 
      // Take care of any remaining deltas
      theEventInfo.forcedDeltasOutside = nucleus->decayOutgoingDeltas();
      theEventInfo.forcedDeltasInside = nucleus->decayInsideDeltas();
 
      // Take care of any remaining etas, omegas, neutral Sigmas and/or neutral kaons
      G4double timeThreshold=theConfig->getDecayTimeThreshold();
      theEventInfo.forcedPionResonancesOutside = nucleus->decayOutgoingPionResonances(timeThreshold);
      nucleus->decayOutgoingSigmaZero(timeThreshold);
      nucleus->decayOutgoingNeutralKaon();
        
      // Apply Coulomb distortion, if appropriate
      // Note that this will apply Coulomb distortion also on pions emitted by
      // unphysical remnants (see decayInsideDeltas). This is at variance with
      // what INCL4.6 does, but these events are (should be!) so rare that
      // whatever we do doesn't (shouldn't!) make any noticeable difference.
      CoulombDistortion::distortOut(nucleus->getStore()->getOutgoingParticles(), nucleus);
 
      // If the normal cascade predicted complete fusion, use the tabulated
      // masses to compute the excitation energy, the recoil, etc.
      if(nucleus->getStore()->getOutgoingParticles().size()==0
         && (!nucleus->getProjectileRemnant()
             || nucleus->getProjectileRemnant()->getParticles().size()==0)) {
 
        INCL_DEBUG("Cascade resulted in complete fusion, using realistic fusion kinematics" << '\n');
 
        nucleus->useFusionKinematics();
 
        if(nucleus->getExcitationEnergy()<0.) {
          // Complete fusion is energetically impossible, return a transparent
          INCL_WARN("Complete-fusion kinematics yields negative excitation energy, returning a transparent!" << '\n');
          theEventInfo.transparent = true;
          return;
        }
 
      } else { // Normal cascade here
 
        // Set the excitation energy
        nucleus->setExcitationEnergy(nucleus->computeExcitationEnergy());
 
        // Make a projectile pre-fragment out of the geometrical and dynamical
        // spectators
        theEventInfo.nUnmergedSpectators = makeProjectileRemnant();
 
        // Compute recoil momentum, energy and spin of the nucleus
        if(nucleus->getA()==1 && minRemnantSize>1) {
          INCL_ERROR("Computing one-nucleon recoil kinematics. We should never be here nowadays, cascade should stop earlier than this." << '\n');
        }
        nucleus->computeRecoilKinematics();
 
#ifndef INCLXX_IN_GEANT4_MODE
        // Global checks of conservation laws
        globalConservationChecks(false);
#endif
 
        // Make room for the remnant recoil by rescaling the energies of the
        // outgoing particles.
        if(nucleus->hasRemnant()) rescaleOutgoingForRecoil();
 
      }
 
      // Cluster decay
      theEventInfo.clusterDecay = nucleus->decayOutgoingClusters() || nucleus->decayMe();
 
#ifndef INCLXX_IN_GEANT4_MODE
      // Global checks of conservation laws
      globalConservationChecks(true);
#endif
 
      // Fill the EventInfo structure
      nucleus->fillEventInfo(&theEventInfo);
 
    }
  }

References G4INCL::EventInfo::absorbedStrangeParticle, G4INCL::EventInfo::antikaonsInside, G4INCL::Store::clearIncoming(), G4INCL::EventInfo::clusterDecay, G4INCL::Nucleus::computeExcitationEnergy(), G4INCL::Nucleus::computeRecoilKinematics(), G4INCL::Nucleus::containsAntiKaon(), G4INCL::Nucleus::containsDeltas(), G4INCL::Nucleus::containsKaon(), G4INCL::Nucleus::containsLambda(), G4INCL::Nucleus::containsSigma(), G4INCL::Nucleus::decayInsideDeltas(), G4INCL::Nucleus::decayInsideStrangeParticles(), G4INCL::Nucleus::decayMe(), G4INCL::Nucleus::decayOutgoingClusters(), G4INCL::Nucleus::decayOutgoingDeltas(), G4INCL::Nucleus::decayOutgoingNeutralKaon(), G4INCL::Nucleus::decayOutgoingPionResonances(), G4INCL::Nucleus::decayOutgoingSigmaZero(), G4INCL::Store::deleteIncoming(), G4INCL::EventInfo::deltasInside, G4INCL::CoulombDistortion::distortOut(), G4INCL::Nucleus::emitInsideKaon(), G4INCL::Nucleus::emitInsideLambda(), G4INCL::Nucleus::emitInsideStrangeParticles(), G4INCL::EventInfo::emitKaon, G4INCL::EventInfo::emitLambda, G4INCL::EventInfo::eventBias, G4INCL::Nucleus::fillEventInfo(), G4INCL::EventInfo::forcedDeltasInside, G4INCL::EventInfo::forcedDeltasOutside, G4INCL::EventInfo::forcedPionResonancesOutside, forceTransparent, G4INCL::Particle::getA(), G4INCL::IPropagationModel::getCurrentTime(), G4INCL::Config::getDecayTimeThreshold(), G4INCL::Nucleus::getExcitationEnergy(), G4INCL::Store::getOutgoingParticles(), G4INCL::Cluster::getParticles(), G4INCL::Nucleus::getProjectileRemnant(), G4INCL::Nucleus::getStore(), G4INCL::Particle::getTotalBias(), G4INCL::Nucleus::getTryCompoundNucleus(), G4INCL::Nucleus::hasRemnant(), INCL_DEBUG, INCL_ERROR, INCL_WARN, G4INCL::Nucleus::isEventTransparent(), G4INCL::EventInfo::kaonsInside, G4INCL::EventInfo::lambdasInside, makeCompoundNucleus(), makeProjectileRemnant(), minRemnantSize, nucleus, G4INCL::EventInfo::nUnmergedSpectators, propagationModel, rescaleOutgoingForRecoil(), G4INCL::Cluster::setExcitationEnergy(), G4INCL::EventInfo::sigmasInside, G4INCL::EventInfo::stoppingTime, theConfig, theEventInfo, G4INCL::EventInfo::transparent, and G4INCL::Nucleus::useFusionKinematics().

Referenced by processEvent().

preCascade()

G4bool G4INCL::INCL::preCascade ( ParticleSpecies const &  projectileSpecies, const G4double  kineticEnergy  )

private

Initialise the cascade.

Definition at line 277 of file G4INCLCascade.cc.

                                                                                                {
    // Reset theEventInfo
    theEventInfo.reset();
 
    EventInfo::eventNumber++;
 
    // Fill in the event information
    theEventInfo.projectileType = projectileSpecies.theType;
    theEventInfo.Ap = projectileSpecies.theA;
    theEventInfo.Zp = projectileSpecies.theZ;
    theEventInfo.Sp = projectileSpecies.theS;
    theEventInfo.Ep = kineticEnergy;
    theEventInfo.At = nucleus->getA();
    theEventInfo.Zt = nucleus->getZ();
    theEventInfo.St = nucleus->getS();
 
    // Do nothing below the Coulomb barrier
    if(maxImpactParameter<=0.) {
      // Fill in the event information
      theEventInfo.transparent = true;
 
      return false;
    }
 
    // Randomly draw an impact parameter or use a fixed value, depending on the
    // Config option
    G4double impactParameter, phi;
    if(fixedImpactParameter<0.) {
      impactParameter = maxImpactParameter * std::sqrt(Random::shoot0());
      phi = Random::shoot() * Math::twoPi;
    } else {
      impactParameter = fixedImpactParameter;
      phi = 0.;
    }
    INCL_DEBUG("Selected impact parameter: " << impactParameter << '\n');
 
    // Fill in the event information
    theEventInfo.impactParameter = impactParameter;
 
    const G4double effectiveImpactParameter = propagationModel->shoot(projectileSpecies, kineticEnergy, impactParameter, phi);
    if(effectiveImpactParameter < 0.) {
      // Fill in the event information
      theEventInfo.transparent = true;
 
      return false;
    }
 
    // Fill in the event information
    theEventInfo.transparent = false;
    theEventInfo.effectiveImpactParameter = effectiveImpactParameter;
 
    return true;
  }

References G4INCL::EventInfo::Ap, G4INCL::EventInfo::At, G4INCL::EventInfo::effectiveImpactParameter, G4INCL::EventInfo::Ep, G4INCL::EventInfo::eventNumber, fixedImpactParameter, G4INCL::Particle::getA(), G4INCL::Particle::getS(), G4INCL::Particle::getZ(), G4INCL::EventInfo::impactParameter, INCL_DEBUG, maxImpactParameter, nucleus, G4INCL::EventInfo::projectileType, propagationModel, G4INCL::EventInfo::reset(), G4INCL::Random::shoot(), G4INCL::IPropagationModel::shoot(), G4INCL::Random::shoot0(), G4INCL::EventInfo::Sp, G4INCL::EventInfo::St, G4INCL::ParticleSpecies::theA, theEventInfo, G4INCL::ParticleSpecies::theS, G4INCL::ParticleSpecies::theType, G4INCL::ParticleSpecies::theZ, G4INCL::EventInfo::transparent, G4INCL::Math::twoPi, G4INCL::EventInfo::Zp, and G4INCL::EventInfo::Zt.

Referenced by processEvent().

prepareReaction()

G4bool G4INCL::INCL::prepareReaction	(	const ParticleSpecies &	projectileSpecies,
		const G4double	kineticEnergy,
		const G4int	A,
		const G4int	Z,
		const G4int	S
	)

Definition at line 185 of file G4INCLCascade.cc.

                                                                                                                                                  {
    if(A < 0 || A > 300 || Z < 1 || Z > 200) {
      INCL_ERROR("Unsupported target: A = " << A << " Z = " << Z << " S = " << S << '\n'
                 << "Target configuration rejected." << '\n');
      return false;
    }
    if(projectileSpecies.theType==Composite &&
       (projectileSpecies.theZ==projectileSpecies.theA || projectileSpecies.theZ==0)) {
      INCL_ERROR("Unsupported projectile: A = " << projectileSpecies.theA << " Z = " << projectileSpecies.theZ << " S = " << projectileSpecies.theS << '\n'
                 << "Projectile configuration rejected." << '\n');
      return false;
    }
 
    // Reset the forced-transparent flag
    forceTransparent = false;
 
    // Initialise the maximum universe radius
    initUniverseRadius(projectileSpecies, kineticEnergy, A, Z);
 
    // Initialise the nucleus
    theZ = Z;
    theS = S;
    if(theConfig->isNaturalTarget())
      theA = ParticleTable::drawRandomNaturalIsotope(Z);
    else
      theA = A;
    initializeTarget(theA, theZ, theS);
 
    // Set the maximum impact parameter
    maxImpactParameter = CoulombDistortion::maxImpactParameter(projectileSpecies, kineticEnergy, nucleus);
    INCL_DEBUG("Maximum impact parameter initialised: " << maxImpactParameter << '\n');
 
    // For forced CN events
    initMaxInteractionDistance(projectileSpecies, kineticEnergy);
 
    // Set the geometric cross section
    theGlobalInfo.geometricCrossSection =
      Math::tenPi*std::pow(maxImpactParameter,2);
 
    // Set the minimum remnant size
    if(projectileSpecies.theA > 0)
      minRemnantSize = std::min(theA, 4);
    else
      minRemnantSize = std::min(theA-1, 4);
 
    return true;
  }

References A, G4INCL::Composite, G4INCL::ParticleTable::drawRandomNaturalIsotope(), forceTransparent, G4INCL::GlobalInfo::geometricCrossSection, INCL_DEBUG, INCL_ERROR, initializeTarget(), initMaxInteractionDistance(), initUniverseRadius(), G4INCL::Config::isNaturalTarget(), maxImpactParameter, G4INCL::CoulombDistortion::maxImpactParameter(), G4INCL::Math::min(), minRemnantSize, nucleus, S(), G4INCL::Math::tenPi, theA, G4INCL::ParticleSpecies::theA, theConfig, theGlobalInfo, theS, G4INCL::ParticleSpecies::theS, G4INCL::ParticleSpecies::theType, theZ, G4INCL::ParticleSpecies::theZ, and Z.

Referenced by processEvent().

processEvent() [1/2]

const EventInfo & G4INCL::INCL::processEvent ( )

inline

Definition at line 66 of file G4INCLCascade.hh.

                                             {
        return processEvent(
            theConfig->getProjectileSpecies(),
            theConfig->getProjectileKineticEnergy(),
            theConfig->getTargetA(),
            theConfig->getTargetZ(),
            theConfig->getTargetS()
            );
      }

References G4INCL::Config::getProjectileKineticEnergy(), G4INCL::Config::getProjectileSpecies(), G4INCL::Config::getTargetA(), G4INCL::Config::getTargetS(), G4INCL::Config::getTargetZ(), processEvent(), and theConfig.

Referenced by G4INCLXXInterface::ApplyYourself(), and processEvent().

processEvent() [2/2]

const EventInfo & G4INCL::INCL::processEvent	(	ParticleSpecies const &	projectileSpecies,
		const G4double	kineticEnergy,
		const G4int	targetA,
		const G4int	targetZ,
		const G4int	targetS
	)

Definition at line 244 of file G4INCLCascade.cc.

        {
    // ReInitialize the bias vector
    Particle::INCLBiasVector.clear();
    //Particle::INCLBiasVector.Clear();
    Particle::nextBiasedCollisionID = 0;
    
    // Set the target and the projectile
    targetInitSuccess = prepareReaction(projectileSpecies, kineticEnergy, targetA, targetZ, targetS);
 
    if(!targetInitSuccess) {
      INCL_WARN("Target initialisation failed for A=" << targetA << ", Z=" << targetZ << ", S=" << targetS << '\n');
      theEventInfo.transparent=true;
      return theEventInfo;
    }
 
    cascadeAction->beforeCascadeAction(propagationModel);
 
    const G4bool canRunCascade = preCascade(projectileSpecies, kineticEnergy);
    if(canRunCascade) {
      cascade();
      postCascade();
      cascadeAction->afterCascadeAction(nucleus);
    }
    updateGlobalInfo();
    return theEventInfo;
  }

References G4INCL::CascadeAction::afterCascadeAction(), G4INCL::CascadeAction::beforeCascadeAction(), cascade(), cascadeAction, INCL_WARN, G4INCL::Particle::INCLBiasVector, G4INCL::Particle::nextBiasedCollisionID, nucleus, postCascade(), preCascade(), prepareReaction(), propagationModel, targetInitSuccess, theEventInfo, G4INCL::EventInfo::transparent, and updateGlobalInfo().

rescaleOutgoingForRecoil()

void G4INCL::INCL::rescaleOutgoingForRecoil ( )

private

Rescale the energies of the outgoing particles.

Allow for the remnant recoil energy by rescaling the energy (and momenta) of the outgoing particles.

Definition at line 655 of file G4INCLCascade.cc.

                                      {
    RecoilCMFunctor theRecoilFunctor(nucleus, theEventInfo);
 
    // Apply the root-finding algorithm
    const RootFinder::Solution theSolution = RootFinder::solve(&theRecoilFunctor, 1.0);
    if(theSolution.success) {
      theRecoilFunctor(theSolution.x); // Apply the solution
    } else {
      INCL_WARN("Couldn't accommodate remnant recoil while satisfying energy conservation, root-finding algorithm failed." << '\n');
    }
 
  }

References INCL_WARN, nucleus, G4INCL::RootFinder::solve(), G4INCL::RootFinder::Solution::success, theEventInfo, and G4INCL::RootFinder::Solution::x.

Referenced by postCascade().

updateGlobalInfo()

void G4INCL::INCL::updateGlobalInfo ( )

private

Update global counters and other members of theGlobalInfo object.

Definition at line 868 of file G4INCLCascade.cc.

                              {
    // Increment the global counter for the number of shots
    theGlobalInfo.nShots++;
 
    if(theEventInfo.transparent) {
      // Increment the global counter for the number of transparents
      theGlobalInfo.nTransparents++;
      // Increment the global counter for the number of forced transparents
      if(forceTransparent)
        theGlobalInfo.nForcedTransparents++;
      return;
    }
 
    // Check if we have an absorption:
    if(theEventInfo.nucleonAbsorption) theGlobalInfo.nNucleonAbsorptions++;
    if(theEventInfo.pionAbsorption) theGlobalInfo.nPionAbsorptions++;
 
    // Count complete-fusion events
    if(theEventInfo.nCascadeParticles==0) theGlobalInfo.nCompleteFusion++;
 
    if(nucleus->getTryCompoundNucleus())
      theGlobalInfo.nForcedCompoundNucleus++;
 
    // Counters for the number of violations of energy conservation in
    // collisions
    theGlobalInfo.nEnergyViolationInteraction += theEventInfo.nEnergyViolationInteraction;
  }

References forceTransparent, G4INCL::Nucleus::getTryCompoundNucleus(), G4INCL::EventInfo::nCascadeParticles, G4INCL::GlobalInfo::nCompleteFusion, G4INCL::EventInfo::nEnergyViolationInteraction, G4INCL::GlobalInfo::nEnergyViolationInteraction, G4INCL::GlobalInfo::nForcedCompoundNucleus, G4INCL::GlobalInfo::nForcedTransparents, G4INCL::GlobalInfo::nNucleonAbsorptions, G4INCL::GlobalInfo::nPionAbsorptions, G4INCL::GlobalInfo::nShots, G4INCL::GlobalInfo::nTransparents, G4INCL::EventInfo::nucleonAbsorption, nucleus, G4INCL::EventInfo::pionAbsorption, theEventInfo, theGlobalInfo, and G4INCL::EventInfo::transparent.

Referenced by processEvent().

Field Documentation

cascadeAction

CascadeAction* G4INCL::INCL::cascadeAction

private

Definition at line 95 of file G4INCLCascade.hh.

Referenced by cascade(), INCL(), processEvent(), and ~INCL().

fixedImpactParameter

G4double G4INCL::INCL::fixedImpactParameter

private

Definition at line 94 of file G4INCLCascade.hh.

Referenced by INCL(), and preCascade().

forceTransparent

G4bool G4INCL::INCL::forceTransparent

private

Definition at line 98 of file G4INCLCascade.hh.

Referenced by makeCompoundNucleus(), postCascade(), prepareReaction(), and updateGlobalInfo().

maxImpactParameter

G4double G4INCL::INCL::maxImpactParameter

private

Definition at line 91 of file G4INCLCascade.hh.

Referenced by preCascade(), and prepareReaction().

maxInteractionDistance

G4double G4INCL::INCL::maxInteractionDistance

private

Definition at line 93 of file G4INCLCascade.hh.

Referenced by initMaxInteractionDistance(), and makeCompoundNucleus().

maxUniverseRadius

G4double G4INCL::INCL::maxUniverseRadius

private

Definition at line 92 of file G4INCLCascade.hh.

Referenced by initializeTarget(), and initUniverseRadius().

minRemnantSize

G4int G4INCL::INCL::minRemnantSize

private

Remnant size below which cascade stops.

Definition at line 104 of file G4INCLCascade.hh.

Referenced by continueCascade(), postCascade(), and prepareReaction().

nucleus

Nucleus* G4INCL::INCL::nucleus

private

Definition at line 97 of file G4INCLCascade.hh.

Referenced by cascade(), continueCascade(), initializeTarget(), makeCompoundNucleus(), makeProjectileRemnant(), postCascade(), preCascade(), prepareReaction(), processEvent(), rescaleOutgoingForRecoil(), and updateGlobalInfo().

propagationModel

IPropagationModel* G4INCL::INCL::propagationModel

private

Definition at line 88 of file G4INCLCascade.hh.

Referenced by cascade(), continueCascade(), INCL(), initializeTarget(), makeCompoundNucleus(), makeProjectileRemnant(), postCascade(), preCascade(), processEvent(), and ~INCL().

targetInitSuccess

G4bool G4INCL::INCL::targetInitSuccess

private

Definition at line 90 of file G4INCLCascade.hh.

Referenced by processEvent().

theA

G4int G4INCL::INCL::theA

private

Definition at line 89 of file G4INCLCascade.hh.

Referenced by initMaxInteractionDistance(), and prepareReaction().

theConfig

Config const* const G4INCL::INCL::theConfig

private

Definition at line 96 of file G4INCLCascade.hh.

Referenced by INCL(), initializeTarget(), makeCompoundNucleus(), postCascade(), prepareReaction(), processEvent(), and ~INCL().

theEventInfo

EventInfo G4INCL::INCL::theEventInfo

private

Definition at line 100 of file G4INCLCascade.hh.

Referenced by makeCompoundNucleus(), postCascade(), preCascade(), processEvent(), rescaleOutgoingForRecoil(), and updateGlobalInfo().

theGlobalInfo

GlobalInfo G4INCL::INCL::theGlobalInfo

private

Definition at line 101 of file G4INCLCascade.hh.

Referenced by finalizeGlobalInfo(), getGlobalInfo(), INCL(), prepareReaction(), and updateGlobalInfo().

theS

G4int G4INCL::INCL::theS

private

Definition at line 89 of file G4INCLCascade.hh.

Referenced by prepareReaction().

theZ

G4int G4INCL::INCL::theZ

private

Definition at line 89 of file G4INCLCascade.hh.

Referenced by initMaxInteractionDistance(), and prepareReaction().

---

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

• source/processes/hadronic/models/inclxx/incl_physics/include/G4INCLCascade.hh
• source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLCascade.cc