G4INCL::INCL Class Reference

#include <G4INCLCascade.hh>

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

Detailed Description

Definition at line 56 of file G4INCLCascade.hh.

Constructor & Destructor Documentation

INCL() [1/2]

G4INCL::INCL::INCL

(

Config const *const

config

)

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

~INCL()

G4INCL::INCL::~INCL

(

)

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

INCL() [2/2]

G4INCL::INCL::INCL

(

const INCL &

rhs

)

Dummy copy constructor to silence Coverity warning.

Member Function Documentation

finalizeGlobalInfo()

void G4INCL::INCL::finalizeGlobalInfo

(

Random::SeedVector const &

initialSeeds

)

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

getGlobalInfo()

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

inline

Definition at line 90 of file G4INCLCascade.hh.

{ return theGlobalInfo; }

initializeTarget()

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

Definition at line 296 of file G4INCLCascade.cc.

                                                                                                      { 
    delete nucleus;
 
    if (theAType==PType || theAType==NType) {
      G4double newmaxUniverseRadius=0.;
      if (theAType==PType) newmaxUniverseRadius=initUniverseRadiusForAntiprotonAtRest(A+1, Z+1);
      else newmaxUniverseRadius=initUniverseRadiusForAntiprotonAtRest(A+1, Z);
      nucleus = new Nucleus(A, Z, S, theConfig, newmaxUniverseRadius, theAType);
    }
    else{
      nucleus = new Nucleus(A, Z, S, theConfig, maxUniverseRadius, theAType);
    }
    nucleus->getStore()->getBook().reset();
    nucleus->initializeParticles();
    propagationModel->setNucleus(nucleus);
    return true;
  }

Referenced by prepareReaction().

initUniverseRadiusForAntiprotonAtRest()

G4double G4INCL::INCL::initUniverseRadiusForAntiprotonAtRest	(	const G4int	A,
		const G4int	Z )

Definition at line 1164 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);
    }
    return rMax;                
    }

Referenced by initializeTarget().

operator=()

INCL & G4INCL::INCL::operator=

(

const INCL &

rhs

)

Dummy assignment operator to silence Coverity warning.

prepareReaction()

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

Definition at line 188 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
 
//D
    //reset
    G4bool ProtonIsTheVictim = false; 
    G4bool NeutronIsTheVictim = false;
    theEventInfo.annihilationP = false;
    theEventInfo.annihilationN = false;
 
    //G4double AnnihilationBarrier = kineticEnergy;
    if(projectileSpecies.theType == antiProton && kineticEnergy <= theConfig->getAtrestThreshold()){
      G4double SpOverSn = 1.331;//from experiments with deuteron (E.Klempt)
      //INCL_WARN("theA number set to A-1 from " << A <<'\n');
 
      G4double neutronprob;
      if(theConfig->isNaturalTarget()){ // A = 0 in this case
        theA = ParticleTable::drawRandomNaturalIsotope(Z) - 1; //43 and 61 are ok (Technetium and Promethium)
        neutronprob = (theA + 1 - Z)/(theA + 1 - Z + SpOverSn*Z);  
      }
      else{
        theA = A - 1;
        neutronprob = (A - Z)/(A - Z + SpOverSn*Z);  //from experiments with deuteron (E.Klempt)
      }
 
      theS = S;
      
      G4double rndm = Random::shoot();
      if(rndm >= neutronprob){     //proton is annihilated
        theEventInfo.annihilationP = true;
        theZ = Z - 1;
        ProtonIsTheVictim = true;
        //INCL_WARN("theZ number set to Z-1 from " << Z << '\n');
      }  
      else{        //neutron is annihilated
        theEventInfo.annihilationN = true;
        theZ = Z;
        NeutronIsTheVictim = true;
      }  
    }
    else{ // not annihilation of pbar
      theZ = Z;
      theS = S;
      if(theConfig->isNaturalTarget())
        theA = ParticleTable::drawRandomNaturalIsotope(Z); //change order
      else
        theA = A;
    }
 
    AnnihilationType theAType = Def;
    if(ProtonIsTheVictim == true && NeutronIsTheVictim == false)
    theAType = PType;
    if(NeutronIsTheVictim == true && ProtonIsTheVictim == false)
    theAType = NType;
 
//D
 
    initializeTarget(theA, theZ, theS, theAType);
    
    // 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 sectiony section
    if(projectileSpecies.theType == antiProton && kineticEnergy <= theConfig->getAtrestThreshold()){
      G4int currentA = A;
      if(theConfig->isNaturalTarget()){
        currentA = ParticleTable::drawRandomNaturalIsotope(Z);
      }
      G4double kineticEnergy2=kineticEnergy;
      if (kineticEnergy2 <= 0.) kineticEnergy2=0.001;
      theGlobalInfo.geometricCrossSection = 9.7* //normalization factor from Corradini
        Math::pi*std::pow((1.840 + 1.120*std::pow(currentA,(1./3.))),2)*
        (1. + (Z*G4INCL::PhysicalConstants::eSquared*(currentA+1))/(currentA*kineticEnergy2*(1.840 + 1.120*std::pow(currentA,(1./3.))))); 
         //xsection formula was borrowed from Corradini et al. https://doi.org/10.1016/j.physletb.2011.09.069    
    }
    else{
      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;
  }

Referenced by processEvent().

processEvent() [1/2]

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

inline

Definition at line 72 of file G4INCLCascade.hh.

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

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 314 of file G4INCLCascade.cc.

        {
 
    ParticleList starlistH2;
 
    if (projectileSpecies.theType==antiProton && (targetA==1 || targetA==2) && targetZ==1 && targetS==0) {
 
      if (targetA==1) {
        preCascade_pbarH1(projectileSpecies, kineticEnergy);
      } else {
        preCascade_pbarH2(projectileSpecies, kineticEnergy);
        theEventInfo.annihilationP = false;
        theEventInfo.annihilationN = false;
 
        G4double SpOverSn = 1.331;  //from experiments with deuteron (E.Klempt)
 
        ThreeVector dummy(0.,0.,0.);
        G4double rndm = Random::shoot()*(SpOverSn+1);
        if (rndm <= SpOverSn) {  //proton is annihilated
          theEventInfo.annihilationP = true;
          Particle *p2 = new Particle(Neutron, dummy, dummy);
          starlistH2.push_back(p2);
          //delete p2;
        } else {                 //neutron is annihilated
          theEventInfo.annihilationN = true;
          Particle *p2 = new Particle(Proton, dummy, dummy);
          starlistH2.push_back(p2);
          //delete p2;
        }
      }
 
      // File names
#ifdef INCLXX_IN_GEANT4_MODE
      if (!G4FindDataDir("G4INCLDATA") ) {
        G4ExceptionDescription ed;
        ed << " Data missing: set environment variable G4INCLDATA\n"
           << " to point to the directory containing data files needed\n"
           << " by the INCL++ model" << G4endl;
        G4Exception("G4INCLDataFile::readData()","rawppbarFS.dat, ...", FatalException, ed);
      }
      G4String dataPath0(G4FindDataDir("G4INCLDATA"));
      G4String dataPathppbar(dataPath0 + "/rawppbarFS.dat");
      G4String dataPathnpbar(dataPath0 + "/rawnpbarFS.dat");
      G4String dataPathppbark(dataPath0 + "/rawppbarFSkaonic.dat");
      G4String dataPathnpbark(dataPath0 + "/rawnpbarFSkaonic.dat");
#else
      G4String path;
      if (theConfig) path = theConfig->getINCLXXDataFilePath();
      G4String dataPathppbar(path + "/rawppbarFS.dat");
      INCL_DEBUG("Reading https://doi.org/10.1016/0375-9474(92)90362-N ppbar final states" << dataPathppbar << '\n');
      G4String dataPathnpbar(path + "/rawnpbarFS.dat");
      INCL_DEBUG("Reading https://doi.org/10.1016/0375-9474(92)90362-N npbar final states" << dataPathnpbar << '\n');
      G4String dataPathppbark(path + "/rawppbarFSkaonic.dat");
      INCL_DEBUG("Reading https://doi.org/10.1016/j.physrep.2005.03.002 ppbar kaonic final states" << dataPathppbark << '\n');
      G4String dataPathnpbark(path + "/rawnpbarFSkaonic.dat");
      INCL_DEBUG("Reading https://doi.org/10.1007/BF02818764 and https://link.springer.com/article/10.1007/BF02754930 npbar kaonic final states" << dataPathnpbark << '\n');
      #endif
 
      //read probabilities and particle types from file
      std::vector<G4double> probabilities;  //will store each FS yield
      std::vector<std::vector<G4String>> particle_types;  //will store particle names
      G4double sum = 0.0;  //will contain a sum of probabilities of all FS in the file
      G4double kaonicFSprob=0.05;  //probability to kave kaonic FS
 
      ParticleList starlist;
      ThreeVector mommy;  //momentum to be assigned later
 
      G4double rdm = Random::shoot();
      ThreeVector annihilationPosition(0.,0.,0.);
      if (rdm < (1.-kaonicFSprob)) {  // pionic FS was chosen
        INCL_DEBUG("pionic pp final state chosen" << '\n');
        sum = read_file(dataPathppbar, probabilities, particle_types);
        rdm = (rdm/(1.-kaonicFSprob))*sum;  //99.88 normalize by the sum of probabilities in the file
        //now get the line number in the file where the FS particles are stored:
        G4int n = findStringNumber(rdm, probabilities)-1;
        if ( n < 0 ) return theEventInfo;
        for (G4int j = 0; j < static_cast<G4int>(particle_types[n].size()); j++) {
          if (particle_types[n][j] == "pi0") {
            Particle *p = new Particle(PiZero, mommy, annihilationPosition);
            starlist.push_back(p);
          } else if (particle_types[n][j] == "pi-") {
            Particle *p = new Particle(PiMinus, mommy, annihilationPosition);
            starlist.push_back(p);
          } else if (particle_types[n][j] == "pi+") {
            Particle *p = new Particle(PiPlus, mommy, annihilationPosition);
            starlist.push_back(p);
          } else if (particle_types[n][j] == "omega") {
            Particle *p = new Particle(Omega, mommy, annihilationPosition);
            starlist.push_back(p);
          } else if (particle_types[n][j] == "eta") {
            Particle *p = new Particle(Eta, mommy, annihilationPosition);
            starlist.push_back(p);
          } else if (particle_types[n][j] == "rho-") {
            Particle *p = new Particle(PiMinus, mommy, annihilationPosition);
            starlist.push_back(p);
            Particle *pp = new Particle(PiZero, mommy, annihilationPosition);
            starlist.push_back(pp);
          } else if (particle_types[n][j] == "rho+") {
            Particle *p = new Particle(PiPlus, mommy, annihilationPosition);
            starlist.push_back(p);
            Particle *pp = new Particle(PiZero, mommy, annihilationPosition);
            starlist.push_back(pp);
          } else if (particle_types[n][j] == "rho0") {
            Particle *p = new Particle(PiMinus, mommy, annihilationPosition);
            starlist.push_back(p);
            Particle *pp = new Particle(PiPlus, mommy, annihilationPosition);
            starlist.push_back(pp);
          } else {
            INCL_ERROR("Some non-existing FS particle detected when reading pbar FS files");
            for (G4int jj = 0; jj < static_cast<G4int>(particle_types[n].size()); jj++) {
#ifdef INCLXX_IN_GEANT4_MODE
              G4cout << "gotcha! " << particle_types[n][jj] << G4endl;
#else
              std::cout << "gotcha! " << particle_types[n][jj] << std::endl;
#endif              
            }
#ifdef INCLXX_IN_GEANT4_MODE
            G4cout << "Some non-existing FS particle detected when reading pbar FS files" << G4endl;
#else
            std::cout << "Some non-existing FS particle detected when reading pbar FS files" << std::endl;
#endif              
          }
        }
      } else {
        INCL_DEBUG("kaonic pp final state chosen" << '\n');
        sum = read_file(dataPathppbark, probabilities, particle_types);
        rdm = ((1.-rdm)/kaonicFSprob)*sum;  //2670 normalize by the sum of probabilities in the file
        //now get the line number in the file where the FS particles are stored:
        G4int n = findStringNumber(rdm, probabilities)-1;
        if ( n < 0 ) return theEventInfo;
        for (G4int j = 0; j < static_cast<G4int>(particle_types[n].size()); j++) {
          if (particle_types[n][j] == "pi0") {
            Particle *p = new Particle(PiZero, mommy, annihilationPosition);
            starlist.push_back(p);
          } else if (particle_types[n][j] == "pi-") {
            Particle *p = new Particle(PiMinus, mommy, annihilationPosition);
            starlist.push_back(p);
          } else if (particle_types[n][j] == "pi+") {
            Particle *p = new Particle(PiPlus, mommy, annihilationPosition);
            starlist.push_back(p);
          } else if (particle_types[n][j] == "omega") {
            Particle *p = new Particle(Omega, mommy, annihilationPosition);
            starlist.push_back(p);
          } else if (particle_types[n][j] == "eta") {
            Particle *p = new Particle(Eta, mommy, annihilationPosition);
            starlist.push_back(p);
          } else if (particle_types[n][j] == "K-") {
            Particle *p = new Particle(KMinus, mommy, annihilationPosition);
            starlist.push_back(p);
          } else if (particle_types[n][j] == "K+") {
            Particle *p = new Particle(KPlus, mommy, annihilationPosition);
            starlist.push_back(p);
          } else if (particle_types[n][j] == "K0") {
            Particle *p = new Particle(KZero, mommy, annihilationPosition);
            starlist.push_back(p);
          } else if (particle_types[n][j] == "K0b") {
            Particle *p = new Particle(KZeroBar, mommy, annihilationPosition);
            starlist.push_back(p);
          } else {
            INCL_ERROR("Some non-existing FS particle detected when reading pbar FS files");
            for (G4int jj = 0; jj < static_cast<G4int>(particle_types[n].size()); jj++) {
#ifdef INCLXX_IN_GEANT4_MODE
              G4cout << "gotcha! " << particle_types[n][jj] << G4endl;
#else
              std::cout << "gotcha! " << particle_types[n][jj] << std::endl;
#endif              
            }
#ifdef INCLXX_IN_GEANT4_MODE
            G4cout << "Some non-existing FS particle detected when reading pbar FS files" << G4endl;
#else
            std::cout << "Some non-existing FS particle detected when reading pbar FS files" << std::endl;
#endif              
          }
        }
      }
 
      //compute energies of mesons with a phase-space model
      G4double energyOfMesonStar=ParticleTable::getRealMass(Proton)+ParticleTable::getRealMass(antiProton);
      if (starlist.size() < 2) {
        INCL_ERROR("should never happen, at least 2 final state particles!" << '\n');
      } else if (starlist.size() == 2) {
        ParticleIter first = starlist.begin();
        ParticleIter last = std::next(first, 1);
        G4double m1 = (*first)->getMass();
        G4double m2 = (*last)->getMass();
        G4double s = energyOfMesonStar*energyOfMesonStar;
        G4double mom1 = std::sqrt(s/4. - (std::pow(m1,2) + std::pow(m2,2))/2. - std::pow(m1,2)*std::pow(m2,2)/s + (std::pow(m1,4) + 2.*std::pow(m1*m2,2) + std::pow(m2,4))/(4.*s));
        ThreeVector momentello = Random::normVector(mom1);
        (*first)->setMomentum(momentello);
        (*first)->adjustEnergyFromMomentum();
        (*last)->setMomentum(-momentello);
        (*last)->adjustEnergyFromMomentum();
      } else {
        PhaseSpaceGenerator::generate(energyOfMesonStar, starlist);
      }
 
      if (targetA==1) postCascade_pbarH1(starlist);
      else            postCascade_pbarH2(starlist,starlistH2);
 
      theGlobalInfo.nShots++;
      return theEventInfo;
    }  // pbar on H1
 
    // 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(projectileSpecies, kineticEnergy);
      cascadeAction->afterCascadeAction(nucleus);
    }
    updateGlobalInfo();
    return theEventInfo;
  }

---

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

• G4INCLCascade.hh
• G4INCLCascade.cc