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. More...
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)
G4bool	initializeTarget (const G4int A, const G4int Z)
const EventInfo &	processEvent ()
const EventInfo &	processEvent (ParticleSpecies const &projectileSpecies, const G4double kineticEnergy, const G4int targetA, const G4int targetZ)
void	finalizeGlobalInfo ()
const GlobalInfo &	getGlobalInfo () const

Detailed Description

Definition at line 51 of file G4INCLCascade.hh.

Constructor & Destructor Documentation

G4INCL::INCL::INCL

(

G4INCL::Config const *const

config

)

Definition at line 87 of file G4INCLCascade.cc.

References G4INCL::GlobalInfo::Ap, G4INCL::GlobalInfo::At, G4INCL::GlobalInfo::cascadeModel, G4INCL::GlobalInfo::deexcitationModel, G4INCL::GlobalInfo::Ep, G4INCL::Config::getCDPP(), G4INCL::Config::getClusterAlgorithm(), G4INCL::Config::getCoulombType(), G4INCL::Config::getCutNN(), G4INCL::Config::getDeExcitationString(), G4INCL::Config::getImpactParameter(), G4INCL::Config::getLocalEnergyBBType(), G4INCL::Config::getLocalEnergyPiType(), G4INCL::Config::getLogFileName(), G4INCL::Config::getPauliType(), G4INCL::Config::getProjectileKineticEnergy(), G4INCL::Config::getProjectileSpecies(), G4INCL::Config::getRandomSeeds(), G4INCL::Config::getTargetA(), G4INCL::Config::getTargetZ(), G4INCL::Config::getVerbosity(), G4INCL::Config::getVersionString(), G4INCL::GlobalPauli, INCL_INFO, G4INCL::ParticleTable::initialize(), G4INCL::Logger::initVerbosityLevelFromEnvvar(), G4INCL::IntercomparisonClusterAlgorithm, G4INCL::NonRelativisticCoulomb, G4INCL::NoPauli, G4INCL::Pauli::setBlocker(), G4INCL::Pauli::setCDPP(), G4INCL::Clustering::setClusteringModel(), G4INCL::CoulombDistortion::setCoulomb(), G4INCL::CrossSections::setCrossSections(), G4INCL::BinaryCollisionAvatar::setCutNN(), G4INCL::Random::setGenerator(), G4INCL::StatisticalPauli, G4INCL::StrictPauli, G4INCL::StrictStatisticalPauli, G4INCL::ParticleSpecies::theA, G4INCL::ParticleSpecies::theZ, G4INCL::GlobalInfo::Zp, and G4INCL::GlobalInfo::Zt.

    :propagationModel(0), theA(208), theZ(82),
    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
    G4INCL::Logger::initVerbosityLevelFromEnvvar();
#else // INCLXX_IN_GEANT4_MODE
    G4INCL::Logger::setLoggerSlave(new G4INCL::LoggerSlave(theConfig->getLogFileName()));
    G4INCL::Logger::setVerbosityLevel(theConfig->getVerbosity());
#endif // INCLXX_IN_GEANT4_MODE

    // Set the random number generator algorithm. The system can support
    // multiple different generator algorithms in a completely
    // transparent way.
#ifdef INCLXX_IN_GEANT4_MODE
    G4INCL::Random::setGenerator(new G4INCL::Geant4RandomGenerator());
#else // INCLXX_IN_GEANT4_MODE
    G4INCL::Random::setGenerator(new G4INCL::Ranecu(theConfig->getRandomSeeds()));
#endif // INCLXX_IN_GEANT4_MODE

    // Select the Pauli blocking algorithm:
    G4INCL::PauliType pauli = theConfig->getPauliType();
    if(pauli == G4INCL::StrictStatisticalPauli)
      G4INCL::Pauli::setBlocker(new G4INCL::PauliStrictStandard);
    else if(pauli == G4INCL::StatisticalPauli)
      G4INCL::Pauli::setBlocker(new G4INCL::PauliStandard);
    else if(pauli == G4INCL::StrictPauli)
      G4INCL::Pauli::setBlocker(new G4INCL::PauliStrict);
    else if(pauli == G4INCL::GlobalPauli)
      G4INCL::Pauli::setBlocker(new G4INCL::PauliGlobal);
    else if(pauli == G4INCL::NoPauli)
      G4INCL::Pauli::setBlocker(NULL);

    // Set the cross-section set
    CrossSections::setCrossSections(new CrossSectionsINCL46);

    if(theConfig->getCDPP())
      G4INCL::Pauli::setCDPP(new G4INCL::CDPP);
    else
      G4INCL::Pauli::setCDPP(NULL);

    // Select the Coulomb-distortion algorithm:
    G4INCL::CoulombType coulombType = theConfig->getCoulombType();
    if(coulombType == G4INCL::NonRelativisticCoulomb)
      G4INCL::CoulombDistortion::setCoulomb(new G4INCL::CoulombNonRelativistic);
    else // if(coulombType == G4INCL::NoCoulomb)
      G4INCL::CoulombDistortion::setCoulomb(new G4INCL::CoulombNone);

    // Select the clustering algorithm:
    G4INCL::ClusterAlgorithmType clusterAlgorithm = theConfig->getClusterAlgorithm();
    if(clusterAlgorithm == G4INCL::IntercomparisonClusterAlgorithm)
      G4INCL::Clustering::setClusteringModel(new G4INCL::ClusteringModelIntercomparison(theConfig));
    else // if(clusterAlgorithm == G4INCL::NoClusterAlgorithm)
      G4INCL::Clustering::setClusteringModel(new G4INCL::ClusteringModelNone);

    // Initialize the INCL particle table:
    G4INCL::ParticleTable::initialize(theConfig);

    // Initialize the value of cutNN in BinaryCollisionAvatar
    BinaryCollisionAvatar::setCutNN(theConfig->getCutNN());

    // 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 G4INCL::StandardPropagationModel(theConfig->getLocalEnergyBBType(),theConfig->getLocalEnergyPiType());
    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();
    const ParticleSpecies theSpecies = theConfig->getProjectileSpecies();
    theGlobalInfo.Ap = theSpecies.theA;
    theGlobalInfo.Zp = theSpecies.theZ;
    theGlobalInfo.Ep = theConfig->getProjectileKineticEnergy();
    // Echo the input parameters to the log file
    INCL_INFO(theConfig->echo() << std::endl);
#endif

    fixedImpactParameter = theConfig->getImpactParameter();
  }

G4INCL::INCL::~INCL

(

)

Definition at line 189 of file G4INCLCascade.cc.

References G4INCL::NuclearDensityFactory::clearCache(), G4INCL::NuclearPotential::clearCache(), G4INCL::InteractionAvatar::deleteBackupParticles(), G4INCL::Pauli::deleteBlockers(), G4INCL::Clustering::deleteClusteringModel(), G4INCL::CoulombDistortion::deleteCoulomb(), G4INCL::CrossSections::deleteCrossSections(), and G4INCL::Random::deleteGenerator().

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

G4INCL::INCL::INCL

(

const INCL &

rhs

)

Dummy copy constructor to silence Coverity warning.

Member Function Documentation

void G4INCL::INCL::finalizeGlobalInfo

(

)

Definition at line 711 of file G4INCLCascade.cc.

References G4INCL::GlobalInfo::completeFusionCrossSection, G4INCL::GlobalInfo::energyViolationInteractionCrossSection, G4INCL::GlobalInfo::errorCompleteFusionCrossSection, G4INCL::GlobalInfo::errorForcedCNCrossSection, G4INCL::GlobalInfo::errorReactionCrossSection, G4INCL::GlobalInfo::forcedCNCrossSection, G4INCL::GlobalInfo::geometricCrossSection, 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, and G4INCL::GlobalInfo::reactionCrossSection.

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

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

inline

Definition at line 81 of file G4INCLCascade.hh.

{ return theGlobalInfo; }

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

Definition at line 257 of file G4INCLCascade.cc.

References G4INCL::Store::getBook(), G4INCL::Nucleus::getStore(), G4INCL::Nucleus::initializeParticles(), G4INCL::Book::reset(), and G4INCL::IPropagationModel::setNucleus().

Referenced by prepareReaction().

                                                            {
    delete nucleus;

    nucleus = new Nucleus(A, Z, theConfig, maxUniverseRadius);
    nucleus->getStore()->getBook().reset();
    nucleus->initializeParticles();

    propagationModel->setNucleus(nucleus);
    return true;
  }

INCL& G4INCL::INCL::operator=

(

const INCL &

rhs

)

Dummy assignment operator to silence Coverity warning.

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

Definition at line 210 of file G4INCLCascade.cc.

References G4INCL::Composite, G4INCL::ParticleTable::drawRandomNaturalIsotope(), G4INCL::GlobalInfo::geometricCrossSection, INCL_DEBUG, INCL_ERROR, initializeTarget(), G4INCL::Config::isNaturalTarget(), G4INCL::CoulombDistortion::maxImpactParameter(), G4INCL::Math::min(), G4INCL::Math::tenPi, G4INCL::ParticleSpecies::theA, G4INCL::ParticleSpecies::theType, and G4INCL::ParticleSpecies::theZ.

Referenced by processEvent().

                                                                                                                                   {
    if(A < 0 || A > 300 || Z < 1 || Z > 200) {
      INCL_ERROR("Unsupported target: A = " << A << " Z = " << Z << std::endl
                 << "Target configuration rejected." << std::endl);
      return false;
    }
    if(projectileSpecies.theType==Composite &&
       (projectileSpecies.theZ==projectileSpecies.theA || projectileSpecies.theZ==0)) {
      INCL_ERROR("Unsupported projectile: A = " << projectileSpecies.theA << " Z = " << projectileSpecies.theZ << std::endl
                 << "Projectile configuration rejected." << std::endl);
      return false;
    }

    // Reset the forced-transparent flag
    forceTransparent = false;

    // Initialise the maximum universe radius
    initUniverseRadius(projectileSpecies, kineticEnergy, A, Z);

    // Initialise the nucleus
    theZ = Z;
    if(theConfig->isNaturalTarget())
      theA = ParticleTable::drawRandomNaturalIsotope(Z);
    else
      theA = A;
    initializeTarget(theA, theZ);

    // Set the maximum impact parameter
    maxImpactParameter = CoulombDistortion::maxImpactParameter(projectileSpecies, kineticEnergy, nucleus);
    INCL_DEBUG("Maximum impact parameter initialised: " << maxImpactParameter << std::endl);

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

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

inline

Definition at line 65 of file G4INCLCascade.hh.

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

Referenced by G4INCLXXInterface::ApplyYourself().

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

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

Definition at line 268 of file G4INCLCascade.cc.

References INCL_WARN, prepareReaction(), and G4INCL::EventInfo::transparent.

        {
    // Set the target and the projectile
    targetInitSuccess = prepareReaction(projectileSpecies, kineticEnergy, targetA, targetZ);

    if(!targetInitSuccess) {
      INCL_WARN("Target initialisation failed for A=" << targetA << ", Z=" << targetZ << std::endl);
      theEventInfo.transparent=true;
      return theEventInfo;
    }

    cascadeAction->beforeCascadeAction(propagationModel);

    const G4bool canRunCascade = preCascade(projectileSpecies, kineticEnergy);
    if(canRunCascade) {
      cascade();
      postCascade();
      cascadeAction->afterCascadeAction(nucleus);
    }
    updateGlobalInfo();
    return theEventInfo;
  }

---

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

• G4INCLCascade.hh
• G4INCLCascade.cc