Cluster coalescence algorithm used in the IAEA intercomparison. More...

#include <G4INCLClusteringModelIntercomparison.hh>

Inheritance diagram for G4INCL::ClusteringModelIntercomparison:

Data Structures
class	SortedNucleonConfiguration
	Class for storing and comparing sorted nucleon configurations. More...

Public Member Functions
virtual G4bool	clusterCanEscape (Nucleus const const, Cluster const const)

	ClusteringModelIntercomparison (Config const *const theConfig)

virtual Cluster *	getCluster (Nucleus , Particle )

virtual	~ClusteringModelIntercomparison ()

Private Types
typedef std::set< SortedNucleonConfiguration >	SortedNucleonConfigurationContainer

typedef SortedNucleonConfigurationContainer::iterator	SortedNucleonConfigurationIterator

Private Member Functions
void	findClusterStartingFrom (const G4int oldA, const G4int oldZ, const G4int oldS)

G4double	getPhaseSpace (const G4int oldA, ConsideredPartner const &p)

Private Attributes
Particle *	candidateConfiguration [ParticleTable::maxClusterMass]
	Best cluster configuration. More...

G4double	cascadingEnergyPool

SortedNucleonConfigurationContainer	checkedConfigurations [ParticleTable::maxClusterMass-2]
	Array of containers for configurations that have already been checked. More...

G4int	clusterNMaxAll

G4int	clusterZMaxAll

ConsideredPartner *	consideredPartners
	Array of considered cluster partners. More...

G4bool *	isInRunningConfiguration
	Array of flags for nucleons in the running configuration. More...

const G4double	lambdaMass

G4int	maxMassConfigurationSkipping
	Maximum mass for configuration storage. More...

G4int	nConsidered

G4int	nConsideredMax

const G4double	neutronMass

const G4double	protonMass

G4int	runningConfiguration [ParticleTable::maxClusterMass]

G4double	runningEnergies [ParticleTable::maxClusterMass+1]

G4int	runningMaxClusterAlgorithmMass

ThreeVector	runningMomenta [ParticleTable::maxClusterMass+1]

ThreeVector	runningPositions [ParticleTable::maxClusterMass+1]

G4double	runningPotentials [ParticleTable::maxClusterMass+1]

G4int	selectedA

G4int	selectedS

G4int	selectedZ

G4double	sqtot

Nucleus *	theNucleus

Static Private Attributes
static const G4double	clusterPhaseSpaceCut [ParticleTable::maxClusterMass+1]
	Phase-space parameters for cluster formation. More...

static const G4double	clusterPosFact [ParticleTable::maxClusterMass+1]
	Precomputed factor 1.0/A. More...

static const G4double	clusterPosFact2 [ParticleTable::maxClusterMass+1]
	Precomputed factor (1.0/A)^2. More...

static const G4int	clusterZMax [ParticleTable::maxClusterMass+1] = {0, 0, 1, 2, 3, 3, 5, 5, 6, 6, 7, 7, 8}
	Upper limit of Z for cluster of mass A. More...

static const G4int	clusterZMin [ParticleTable::maxClusterMass+1] = {0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3}
	Lower limit of Z for cluster of mass A. More...

static const G4double	limitCosEscapeAngle = 0.7

Detailed Description

Cluster coalescence algorithm used in the IAEA intercomparison.

Definition at line 96 of file G4INCLClusteringModelIntercomparison.hh.

Member Typedef Documentation

◆ SortedNucleonConfigurationContainer

typedef std::set<SortedNucleonConfiguration> G4INCL::ClusteringModelIntercomparison::SortedNucleonConfigurationContainer

private

Definition at line 303 of file G4INCLClusteringModelIntercomparison.hh.

◆ SortedNucleonConfigurationIterator

typedef SortedNucleonConfigurationContainer::iterator G4INCL::ClusteringModelIntercomparison::SortedNucleonConfigurationIterator

private

Definition at line 304 of file G4INCLClusteringModelIntercomparison.hh.

Constructor & Destructor Documentation

◆ ClusteringModelIntercomparison()

G4INCL::ClusteringModelIntercomparison::ClusteringModelIntercomparison ( Config const *const theConfig )

inline

Definition at line 98 of file G4INCLClusteringModelIntercomparison.hh.

                                                                   :
      theNucleus(NULL),
      selectedA(0),
      selectedZ(0),
      selectedS(0),
      sqtot(0.),
      cascadingEnergyPool(0.),
      protonMass(ParticleTable::getRealMass(Proton)),
      neutronMass(ParticleTable::getRealMass(Neutron)),
      lambdaMass(ParticleTable::getRealMass(Lambda)),
      runningMaxClusterAlgorithmMass(theConfig->getClusterMaxMass()),
      nConsideredMax(0),
      nConsidered(0),
      consideredPartners(NULL),
      isInRunningConfiguration(NULL),
      maxMassConfigurationSkipping(ParticleTable::maxClusterMass)
    {
      // Set up the maximum charge and neutron number for clusters
      clusterZMaxAll = 0;
      clusterNMaxAll = 0;
      for(G4int A=0; A<=runningMaxClusterAlgorithmMass; ++A) {
        if(clusterZMax[A]>clusterZMaxAll)
          clusterZMaxAll = clusterZMax[A];
        if(A-clusterZMin[A]>clusterNMaxAll)
          clusterNMaxAll = A-clusterZMin[A];
      }
      std::fill(candidateConfiguration,
                candidateConfiguration + ParticleTable::maxClusterMass,
                static_cast<Particle*>(NULL));
 
      std::fill(runningEnergies,
                runningEnergies + ParticleTable::maxClusterMass,
                0.0);
 
      std::fill(runningPotentials,
                runningPotentials + ParticleTable::maxClusterMass,
                0.0);
 
      std::fill(runningConfiguration,
                runningConfiguration + ParticleTable::maxClusterMass,
                -1);
 
    }

References A, candidateConfiguration, clusterNMaxAll, clusterZMax, clusterZMaxAll, clusterZMin, G4INCL::ParticleTable::maxClusterMass, runningConfiguration, runningEnergies, runningMaxClusterAlgorithmMass, and runningPotentials.

◆ ~ClusteringModelIntercomparison()

virtual G4INCL::ClusteringModelIntercomparison::~ClusteringModelIntercomparison ( )

inlinevirtual

Definition at line 142 of file G4INCLClusteringModelIntercomparison.hh.

                                              {
      delete [] consideredPartners;
      delete [] isInRunningConfiguration;
    }

References consideredPartners, and isInRunningConfiguration.

Member Function Documentation

◆ clusterCanEscape()

G4bool G4INCL::ClusteringModelIntercomparison::clusterCanEscape	(	Nucleus const * const	,
		Cluster const * const
	)

virtual

Determine whether cluster can escape or not.

Implements G4INCL::IClusteringModel.

Definition at line 380 of file G4INCLClusteringModelIntercomparison.cc.

                                                                                                          {
    // Forbid emission of the whole nucleus
    if(c->getA()>=n->getA() || c->getS()>0)
      return false;
 
    // Check the escape angle of the cluster
    const ThreeVector &pos = c->getPosition();
    const ThreeVector &mom = c->getMomentum();
    const G4double cosEscapeAngle = pos.dot(mom) / std::sqrt(pos.mag2()*mom.mag2());
    if(cosEscapeAngle < limitCosEscapeAngle)
      return false;
 
    return true;
  }

References G4INCL::Particle::getA(), G4INCL::Particle::getMomentum(), G4INCL::Particle::getPosition(), G4INCL::Particle::getS(), limitCosEscapeAngle, G4INCL::ThreeVector::mag2(), CLHEP::detail::n, and pos.

◆ findClusterStartingFrom()

void G4INCL::ClusteringModelIntercomparison::findClusterStartingFrom	(	const G4int	oldA,
		const G4int	oldZ,
		const G4int	oldS
	)

private

Definition at line 222 of file G4INCLClusteringModelIntercomparison.cc.

                                                                                                                   {
    const G4int newA = oldA + 1;
    const G4int oldAMinusOne = oldA - 1;
    G4int newZ;
    G4int newN;
    G4int newS;
 
    // Look up the phase-space cut
    const G4double phaseSpaceCut = clusterPhaseSpaceCut[newA];
 
    // Configuration caching enabled only for a certain mass interval
    const G4bool cachingEnabled = (newA<=maxMassConfigurationSkipping && newA>=3);
 
    // Set the pointer to the container of cached configurations
#if defined(INCL_CACHING_CLUSTERING_MODEL_INTERCOMPARISON_HashMask)
    HashContainer *theHashContainer;
    if(cachingEnabled)
      theHashContainer = &(checkedConfigurations[oldA-2]);
    else
      theHashContainer = NULL;
#elif defined(INCL_CACHING_CLUSTERING_MODEL_INTERCOMPARISON_Set)
    SortedNucleonConfigurationContainer *theConfigContainer;
    if(cachingEnabled)
      theConfigContainer = &(checkedConfigurations[oldA-2]);
    else
      theConfigContainer = NULL;
#elif !defined(INCL_CACHING_CLUSTERING_MODEL_INTERCOMPARISON_None)
#error Unrecognized INCL_CACHING_CLUSTERING_MODEL_INTERCOMPARISON. Allowed values are: Set, HashMask, None.
#endif
 
    // Minimum and maximum Z values for this mass
    const G4int ZMinForNewA = clusterZMin[newA];
    const G4int ZMaxForNewA = clusterZMax[newA];
 
    for(G4int i=0; i<nConsidered; ++i) {
      // Only accept particles that are not already part of the cluster
      if(isInRunningConfiguration[i]) continue;
 
      ConsideredPartner const &candidateNucleon = consideredPartners[i];
 
      // Z and A of the new cluster
      newZ = oldZ + candidateNucleon.Z;
      newS = oldS + candidateNucleon.S;
      newN = newA - newZ;
 
      // Skip this nucleon if we already have too many protons or neutrons
      if(newZ > clusterZMaxAll || newN > clusterNMaxAll || newS>0)
        continue;
 
      // Compute the phase space factor for a new cluster which
      // consists of the previous running cluster and the new
      // candidate nucleon:
      const G4double phaseSpace = getPhaseSpace(oldA, candidateNucleon);
      if(phaseSpace > phaseSpaceCut) continue;
 
      // Store the candidate nucleon in the running configuration
      runningConfiguration[oldAMinusOne] = i;
#if defined(INCL_CACHING_CLUSTERING_MODEL_INTERCOMPARISON_HashMask)
      Hashing::HashType configHash;
      HashIterator aHashIter;
#elif defined(INCL_CACHING_CLUSTERING_MODEL_INTERCOMPARISON_Set)
      SortedNucleonConfiguration thisConfig;
      SortedNucleonConfigurationIterator thisConfigIter;
#endif
      if(cachingEnabled) {
#if defined(INCL_CACHING_CLUSTERING_MODEL_INTERCOMPARISON_HashMask)
        configHash = Hashing::hashConfig(runningConfiguration, oldA);
        aHashIter = theHashContainer->lower_bound(configHash);
        // If we have already checked this configuration, skip it
        if(aHashIter!=theHashContainer->end()
           && !(configHash < *aHashIter))
          continue;
#elif defined(INCL_CACHING_CLUSTERING_MODEL_INTERCOMPARISON_Set)
        thisConfig.fill(runningConfiguration,oldA);
        thisConfigIter = theConfigContainer->lower_bound(thisConfig);
        // If we have already checked this configuration, skip it
        if(thisConfigIter!=theConfigContainer->end()
           && !(thisConfig < *thisConfigIter))
          continue;
#endif
      }
 
      // Sum of the total energies of the cluster components
      runningEnergies[newA] = runningEnergies[oldA] + candidateNucleon.energy;
      // Sum of the potential energies of the cluster components
      runningPotentials[newA] = runningPotentials[oldA] + candidateNucleon.potentialEnergy;
 
      // Update the available cascading kinetic energy
      G4double oldCascadingEnergyPool = cascadingEnergyPool;
      if(!candidateNucleon.isTargetSpectator)
        cascadingEnergyPool -= candidateNucleon.energy - candidateNucleon.potentialEnergy - 931.3;
 
      // Check an approximate Coulomb barrier. If the cluster is below
      // 0.5*barrier and the remaining available energy from cascading nucleons
      // will not bring it above, reject the cluster.
      const G4double halfB = 0.72 * newZ *
        theNucleus->getZ()/(theNucleus->getDensity()->getProtonNuclearRadius()+1.7);
      const G4double tout = runningEnergies[newA] - runningPotentials[newA] -
        931.3*newA;
      if(tout<=halfB && tout+cascadingEnergyPool<=halfB) {
        cascadingEnergyPool = oldCascadingEnergyPool;
        continue;
      }
 
      // Here the nucleon has passed all the tests. Accept it in the cluster.
      runningPositions[newA] = (runningPositions[oldA] * oldA + candidateNucleon.position)*clusterPosFact[newA];
      runningMomenta[newA] = runningMomenta[oldA] + candidateNucleon.momentum;
 
      // Add the config to the container
      if(cachingEnabled) {
#if defined(INCL_CACHING_CLUSTERING_MODEL_INTERCOMPARISON_HashMask)
        theHashContainer->insert(aHashIter, configHash);
#elif defined(INCL_CACHING_CLUSTERING_MODEL_INTERCOMPARISON_Set)
        theConfigContainer->insert(thisConfigIter, thisConfig);
#endif
      }
 
      // Set the flag that reminds us that this nucleon has already been taken
      // in the running configuration
      isInRunningConfiguration[i] = true;
 
      // Keep track of the best physical cluster
      if(newZ >= ZMinForNewA && newZ <= ZMaxForNewA) {
        // Note: sqc is real kinetic energy, not the square of the kinetic energy!
        const G4double sqc = KinematicsUtils::invariantMass(runningEnergies[newA],
            runningMomenta[newA]);
        const G4double sqct = (sqc - 2.*newZ*protonMass - 2.*(newA+newS-newZ)*neutronMass + 2.*newS*lambdaMass
             + ParticleTable::getRealMass(newA, newZ, newS))
          *clusterPosFact[newA];
 
        if(sqct < sqtot) {
          // This is the best cluster we have found so far. Store its
          // kinematics.
          sqtot = sqct;
          selectedA = newA;
          selectedZ = newZ;
          selectedS = newS;
 
          // Store the running configuration in a ParticleList
          for(G4int j=0; j<oldA; ++j)
            candidateConfiguration[j] = consideredPartners[runningConfiguration[j]].particle;
 
          // Sanity check on number of nucleons in running configuration
// assert(std::count(isInRunningConfiguration, isInRunningConfiguration+nConsidered, true)==selectedA-1);
        }
      }
 
      // The method recursively calls itself for the next mass
      if(newA < runningMaxClusterAlgorithmMass && newA+1 < theNucleus->getA() && newS<=0) {
    findClusterStartingFrom(newA, newZ, newS);
      }
 
      // Reset the running configuration flag and the cascading energy pool
      isInRunningConfiguration[i] = false;
      cascadingEnergyPool = oldCascadingEnergyPool;
    }
  }

References candidateConfiguration, cascadingEnergyPool, checkedConfigurations, clusterNMaxAll, clusterPhaseSpaceCut, clusterPosFact, clusterZMax, clusterZMaxAll, clusterZMin, consideredPartners, G4INCL::ConsideredPartner::energy, G4INCL::ClusteringModelIntercomparison::SortedNucleonConfiguration::fill(), findClusterStartingFrom(), G4INCL::Particle::getA(), G4INCL::Nucleus::getDensity(), getPhaseSpace(), G4INCL::NuclearDensity::getProtonNuclearRadius(), G4INCL::ParticleTable::getRealMass(), G4INCL::Particle::getZ(), G4INCL::KinematicsUtils::invariantMass(), isInRunningConfiguration, G4INCL::ConsideredPartner::isTargetSpectator, lambdaMass, G4INCL::ConsideredPartner::momentum, nConsidered, neutronMass, G4INCL::ConsideredPartner::position, G4INCL::ConsideredPartner::potentialEnergy, protonMass, runningConfiguration, runningEnergies, runningMaxClusterAlgorithmMass, runningMomenta, runningPositions, runningPotentials, G4INCL::ConsideredPartner::S, selectedA, selectedS, selectedZ, sqtot, theNucleus, and G4INCL::ConsideredPartner::Z.

Referenced by findClusterStartingFrom(), and getCluster().

◆ getCluster()

Cluster * G4INCL::ClusteringModelIntercomparison::getCluster	(	Nucleus *	,
		Particle *
	)

virtual

Choose a cluster candidate to be produced. At this point we don't yet decide if it can pass through the Coulomb barrier or not.

Implements G4INCL::IClusteringModel.

Definition at line 80 of file G4INCLClusteringModelIntercomparison.cc.

                                                                                          {
    // Set the maximum clustering mass dynamically, based on the current nucleus
    const G4int maxClusterAlgorithmMass = nucleus->getStore()->getConfig()->getClusterMaxMass();
    runningMaxClusterAlgorithmMass = std::min(maxClusterAlgorithmMass, nucleus->getA()/2);
 
    // Nucleus too small?
    if(runningMaxClusterAlgorithmMass<=1)
      return NULL;
 
    theNucleus = nucleus;
    Particle *theLeadingParticle = particle;
 
    // Initialise sqtot to a large number
    sqtot = 50000.0;
    selectedA = 0;
    selectedZ = 0;
 
    // The distance parameter, known as h in publications.
    // Default value is 1 fm.
    const G4double transp = 1.0;
 
    const G4double rmaxws = theNucleus->getUniverseRadius();
 
    // Radius of the sphere where the leading particle is positioned.
    const G4double Rprime = theNucleus->getDensity()->getProtonNuclearRadius() + transp;
 
    // Bring the leading particle back to the coalescence sphere
    const G4double pk = theLeadingParticle->getMomentum().mag();
    const G4double cospr = theLeadingParticle->getPosition().dot(theLeadingParticle->getMomentum())/(theNucleus->getUniverseRadius() * pk);
    const G4double arg = rmaxws*rmaxws - Rprime*Rprime;
    G4double translat;
 
    if(arg > 0.0) {
      // coalescence sphere smaller than Rmax
      const G4double cosmin = std::sqrt(arg)/rmaxws;
      if(cospr <= cosmin) {
        // there is an intersection with the coalescence sphere
        translat = rmaxws * cospr;
      } else {
        // no intersection with the coalescence sphere
        translat = rmaxws * (cospr - std::sqrt(cospr*cospr - cosmin*cosmin));
      }
    } else {
      // coalescence sphere larger than Rmax
      translat = rmaxws * cospr - std::sqrt(Rprime*Rprime - rmaxws*rmaxws*(1.0 - cospr*cospr));
    }
 
    const ThreeVector oldLeadingParticlePosition = theLeadingParticle->getPosition();
    const ThreeVector leadingParticlePosition = oldLeadingParticlePosition - theLeadingParticle->getMomentum() * (translat/pk);
    const ThreeVector &leadingParticleMomentum = theLeadingParticle->getMomentum();
    theLeadingParticle->setPosition(leadingParticlePosition);
 
    // Initialise the array of considered nucleons
    const G4int theNucleusA = theNucleus->getA();
    if(nConsideredMax < theNucleusA) {
      delete [] consideredPartners;
      delete [] isInRunningConfiguration;
      nConsideredMax = 2*theNucleusA;
      consideredPartners = new ConsideredPartner[nConsideredMax];
      isInRunningConfiguration = new G4bool [nConsideredMax];
      std::fill(isInRunningConfiguration,
                isInRunningConfiguration + nConsideredMax,
                false);
    }
 
    // Select the subset of nucleons that will be considered in the
    // cluster production:
    cascadingEnergyPool = 0.;
    nConsidered = 0;
    ParticleList const &particles = theNucleus->getStore()->getParticles();
    for(ParticleIter i=particles.begin(), e=particles.end(); i!=e; ++i) {
      if (!(*i)->isNucleonorLambda()) continue; // Only nucleons and lambdas are allowed in clusters
      if ((*i)->getID() == theLeadingParticle->getID()) continue; // Don't count the leading particle
 
      G4double space = ((*i)->getPosition() - leadingParticlePosition).mag2();
      G4double momentum = ((*i)->getMomentum() - leadingParticleMomentum).mag2();
      G4double size = space*momentum*clusterPosFact2[runningMaxClusterAlgorithmMass];
      // Nucleons are accepted only if they are "close enough" in phase space
      // to the leading nucleon. The selected phase-space parameter corresponds
      // to the running maximum cluster mass.
      if(size < clusterPhaseSpaceCut[runningMaxClusterAlgorithmMass]) {
          consideredPartners[nConsidered] = *i;
        // Keep trace of how much energy is carried by cascading nucleons. This
        // is used to stop the clustering algorithm as soon as possible.
        if(!(*i)->isTargetSpectator())
          cascadingEnergyPool += consideredPartners[nConsidered].energy - consideredPartners[nConsidered].potentialEnergy - 931.3;
        nConsidered++;
        // Make sure we don't exceed the array size
// assert(nConsidered<=nConsideredMax);
      }
    }
    // Sort the list of considered partners so that we give priority
    // to participants. As soon as we encounter the first spectator in
    // the list we know that all the remaining nucleons will be
    // spectators too.
//    std::partition(consideredPartners, consideredPartners+nConsidered, cascadingFirstPredicate);
 
#ifndef INCL_CACHING_CLUSTERING_MODEL_INTERCOMPARISON_None
    // Clear the sets of checked configurations
    // We stop caching two masses short of the max mass -- there seems to be a
    // performance hit above
    maxMassConfigurationSkipping = runningMaxClusterAlgorithmMass-2;
    for(G4int i=0; i<runningMaxClusterAlgorithmMass-2; ++i) // no caching for A=1,2
      checkedConfigurations[i].clear();
#endif
 
    // Initialise position, momentum and energy of the running cluster
    // configuration
    runningPositions[1] = leadingParticlePosition;
    runningMomenta[1] = leadingParticleMomentum;
    runningEnergies[1] = theLeadingParticle->getEnergy();
    runningPotentials[1] = theLeadingParticle->getPotentialEnergy();
 
    // Make sure that all the elements of isInRunningConfiguration are false.
// assert(std::count(isInRunningConfiguration, isInRunningConfiguration+nConsidered, true)==0);
 
    // Start the cluster search!
    findClusterStartingFrom(1, theLeadingParticle->getZ(), 0);
 
    // Again, make sure that all the elements of isInRunningConfiguration have
    // been reset to false. This is a sanity check.
// assert(std::count(isInRunningConfiguration, isInRunningConfiguration+nConsidered, true)==0);
 
    Cluster *chosenCluster = 0;
    if(selectedA!=0) { // A cluster was found!
      candidateConfiguration[selectedA-1] = theLeadingParticle;
      chosenCluster =  new Cluster(candidateConfiguration,
          candidateConfiguration + selectedA);
    }
 
    // Restore the original position of the leading particle
    theLeadingParticle->setPosition(oldLeadingParticlePosition);
 
    return chosenCluster;
  }

References candidateConfiguration, cascadingEnergyPool, checkedConfigurations, clusterPhaseSpaceCut, clusterPosFact2, consideredPartners, G4INCL::ThreeVector::dot(), G4INCL::KinematicsUtils::energy(), findClusterStartingFrom(), G4INCL::Particle::getA(), G4INCL::Config::getClusterMaxMass(), G4INCL::Store::getConfig(), G4INCL::Nucleus::getDensity(), G4INCL::Particle::getEnergy(), G4INCL::Particle::getID(), G4INCL::Particle::getMomentum(), G4INCL::Store::getParticles(), G4INCL::Particle::getPosition(), G4INCL::Particle::getPotentialEnergy(), G4INCL::NuclearDensity::getProtonNuclearRadius(), G4INCL::Nucleus::getStore(), G4INCL::Nucleus::getUniverseRadius(), G4INCL::Particle::getZ(), isInRunningConfiguration, G4INCL::ThreeVector::mag(), maxMassConfigurationSkipping, G4INCL::Math::min(), nConsidered, nConsideredMax, runningEnergies, runningMaxClusterAlgorithmMass, runningMomenta, runningPositions, runningPotentials, selectedA, selectedZ, G4INCL::Particle::setPosition(), sqtot, and theNucleus.

◆ getPhaseSpace()

G4double G4INCL::ClusteringModelIntercomparison::getPhaseSpace	(	const G4int	oldA,
		ConsideredPartner const &	p
	)

private

Definition at line 216 of file G4INCLClusteringModelIntercomparison.cc.

                                                                                                     {
    const G4double psSpace = (p.position - runningPositions[oldA]).mag2();
    const G4double psMomentum = (p.momentum*oldA - runningMomenta[oldA]).mag2();
    return psSpace * psMomentum * clusterPosFact2[oldA + 1];
  }

References clusterPosFact2, G4INCL::ConsideredPartner::momentum, G4INCL::ConsideredPartner::position, runningMomenta, and runningPositions.

Referenced by findClusterStartingFrom().

Field Documentation

◆ candidateConfiguration

Particle* G4INCL::ClusteringModelIntercomparison::candidateConfiguration[ParticleTable::maxClusterMass]

private

Best cluster configuration.

This array contains pointers to the nucleons which make up the best cluster configuration that has been found so far.

Definition at line 227 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by ClusteringModelIntercomparison(), findClusterStartingFrom(), and getCluster().

◆ cascadingEnergyPool

G4double G4INCL::ClusteringModelIntercomparison::cascadingEnergyPool

private

Definition at line 173 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by findClusterStartingFrom(), and getCluster().

◆ checkedConfigurations

SortedNucleonConfigurationContainer G4INCL::ClusteringModelIntercomparison::checkedConfigurations[ParticleTable::maxClusterMass-2]

private

Array of containers for configurations that have already been checked.

Definition at line 307 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by findClusterStartingFrom(), and getCluster().

◆ clusterNMaxAll

G4int G4INCL::ClusteringModelIntercomparison::clusterNMaxAll

private

Definition at line 171 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by ClusteringModelIntercomparison(), and findClusterStartingFrom().

◆ clusterPhaseSpaceCut

const G4double G4INCL::ClusteringModelIntercomparison::clusterPhaseSpaceCut

staticprivate

Initial value:

= {0.0, 70000.0, 180000.0,
    90000.0, 90000.0,
    128941.0 ,145607.0,
    161365.0, 176389.0,
    190798.0, 204681.0,
    218109.0, 231135.0}

Phase-space parameters for cluster formation.

Definition at line 187 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by findClusterStartingFrom(), and getCluster().

◆ clusterPosFact

const G4double G4INCL::ClusteringModelIntercomparison::clusterPosFact

staticprivate

Initial value:

= {0.0, 1.0, 0.5,
33333, 0.25,
2, 0.16667,
14286, 0.125,
11111, 0.1,
09091, 0.083333}

Precomputed factor 1.0/A.

Definition at line 181 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by findClusterStartingFrom().

◆ clusterPosFact2

const G4double G4INCL::ClusteringModelIntercomparison::clusterPosFact2

staticprivate

Initial value:

= {0.0, 1.0, 0.25,
11111, 0.0625,
04, 0.0277778,
020408, 0.015625,
012346, 0.01,
0082645, 0.0069444}

Precomputed factor (1.0/A)^2.

Definition at line 184 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by getCluster(), and getPhaseSpace().

◆ clusterZMax

const G4int G4INCL::ClusteringModelIntercomparison::clusterZMax = {0, 0, 1, 2, 3, 3, 5, 5, 6, 6, 7, 7, 8}

staticprivate

Upper limit of Z for cluster of mass A.

Definition at line 178 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by ClusteringModelIntercomparison(), and findClusterStartingFrom().

◆ clusterZMaxAll

G4int G4INCL::ClusteringModelIntercomparison::clusterZMaxAll

private

Definition at line 171 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by ClusteringModelIntercomparison(), and findClusterStartingFrom().

◆ clusterZMin

const G4int G4INCL::ClusteringModelIntercomparison::clusterZMin = {0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3}

staticprivate

Lower limit of Z for cluster of mass A.

Definition at line 176 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by ClusteringModelIntercomparison(), and findClusterStartingFrom().

◆ consideredPartners

ConsideredPartner* G4INCL::ClusteringModelIntercomparison::consideredPartners

private

Array of considered cluster partners.

A dynamical array of ConsideredPartner objects is allocated on this variable and filled with pointers to nucleons which are eligible for clustering. We used to use a ParticleList for this purpose, but this made it very cumbersome to check whether nucleons had already been included in the running configuration. Using an array of Particle* coupled with a boolean mask (

See also: {isInRunningConfiguration}) reduces the overhead by a large amount. Running times for 1-GeV p+Pb208 went down by almost 30% (!).

Lesson learnt: when you need speed, nothing beats a good ol' array.

Definition at line 213 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by findClusterStartingFrom(), getCluster(), and ~ClusteringModelIntercomparison().

◆ isInRunningConfiguration

G4bool* G4INCL::ClusteringModelIntercomparison::isInRunningConfiguration

private

Array of flags for nucleons in the running configuration.

Clustering partners that are already used in the running cluster configuration are flagged as "true" in this array.

Definition at line 220 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by findClusterStartingFrom(), getCluster(), and ~ClusteringModelIntercomparison().

◆ lambdaMass

const G4double G4INCL::ClusteringModelIntercomparison::lambdaMass

private

Definition at line 193 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by findClusterStartingFrom().

◆ limitCosEscapeAngle

const G4double G4INCL::ClusteringModelIntercomparison::limitCosEscapeAngle = 0.7

staticprivate

Definition at line 189 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by clusterCanEscape().

◆ maxMassConfigurationSkipping

G4int G4INCL::ClusteringModelIntercomparison::maxMassConfigurationSkipping

private

Maximum mass for configuration storage.

Skipping configurations becomes inefficient above this mass.

Definition at line 316 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by getCluster().

◆ nConsidered

G4int G4INCL::ClusteringModelIntercomparison::nConsidered

private

Definition at line 198 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by findClusterStartingFrom(), and getCluster().

◆ nConsideredMax

G4int G4INCL::ClusteringModelIntercomparison::nConsideredMax

private

Definition at line 197 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by getCluster().

◆ neutronMass

const G4double G4INCL::ClusteringModelIntercomparison::neutronMass

private

Definition at line 192 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by findClusterStartingFrom().

◆ protonMass

const G4double G4INCL::ClusteringModelIntercomparison::protonMass

private

Definition at line 191 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by findClusterStartingFrom().

◆ runningConfiguration

G4int G4INCL::ClusteringModelIntercomparison::runningConfiguration[ParticleTable::maxClusterMass]

private

Definition at line 163 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by ClusteringModelIntercomparison(), and findClusterStartingFrom().

◆ runningEnergies

G4double G4INCL::ClusteringModelIntercomparison::runningEnergies[ParticleTable::maxClusterMass+1]

private

Definition at line 156 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by ClusteringModelIntercomparison(), findClusterStartingFrom(), and getCluster().

◆ runningMaxClusterAlgorithmMass

G4int G4INCL::ClusteringModelIntercomparison::runningMaxClusterAlgorithmMass

private

Definition at line 195 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by ClusteringModelIntercomparison(), findClusterStartingFrom(), and getCluster().

◆ runningMomenta

ThreeVector G4INCL::ClusteringModelIntercomparison::runningMomenta[ParticleTable::maxClusterMass+1]

private

Definition at line 157 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by findClusterStartingFrom(), getCluster(), and getPhaseSpace().

◆ runningPositions

ThreeVector G4INCL::ClusteringModelIntercomparison::runningPositions[ParticleTable::maxClusterMass+1]

private

Definition at line 158 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by findClusterStartingFrom(), getCluster(), and getPhaseSpace().

◆ runningPotentials

G4double G4INCL::ClusteringModelIntercomparison::runningPotentials[ParticleTable::maxClusterMass+1]

private

Definition at line 159 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by ClusteringModelIntercomparison(), findClusterStartingFrom(), and getCluster().

◆ selectedA

G4int G4INCL::ClusteringModelIntercomparison::selectedA

private

Definition at line 168 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by findClusterStartingFrom(), and getCluster().

◆ selectedS

G4int G4INCL::ClusteringModelIntercomparison::selectedS

private

Definition at line 168 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by findClusterStartingFrom().

◆ selectedZ

G4int G4INCL::ClusteringModelIntercomparison::selectedZ

private

Definition at line 168 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by findClusterStartingFrom(), and getCluster().

◆ sqtot

G4double G4INCL::ClusteringModelIntercomparison::sqtot

private

Definition at line 169 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by findClusterStartingFrom(), and getCluster().

◆ theNucleus

Nucleus* G4INCL::ClusteringModelIntercomparison::theNucleus

private

Definition at line 154 of file G4INCLClusteringModelIntercomparison.hh.

Referenced by findClusterStartingFrom(), and getCluster().

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

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

Data Structures

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ SortedNucleonConfigurationContainer

◆ SortedNucleonConfigurationIterator

Constructor & Destructor Documentation

◆ ClusteringModelIntercomparison()

◆ ~ClusteringModelIntercomparison()

Member Function Documentation

◆ clusterCanEscape()

◆ findClusterStartingFrom()

◆ getCluster()

◆ getPhaseSpace()

Field Documentation

◆ candidateConfiguration

◆ cascadingEnergyPool

◆ checkedConfigurations

◆ clusterNMaxAll

◆ clusterPhaseSpaceCut

◆ clusterPosFact

◆ clusterPosFact2

◆ clusterZMax

◆ clusterZMaxAll

◆ clusterZMin

◆ consideredPartners

◆ isInRunningConfiguration

◆ lambdaMass

◆ limitCosEscapeAngle

◆ maxMassConfigurationSkipping

◆ nConsidered

◆ nConsideredMax

◆ neutronMass

◆ protonMass

◆ runningConfiguration

◆ runningEnergies

◆ runningMaxClusterAlgorithmMass

◆ runningMomenta

◆ runningPositions

◆ runningPotentials

◆ selectedA

◆ selectedS

◆ selectedZ

◆ sqtot

◆ theNucleus