#include <G4INCLNuclearDensityFactory.hh>

Static Public Member Functions
static NuclearDensity *	createDensity (const G4int A, const G4int Z)

static InverseInterpolationTable *	createRPCorrelationTable (const G4int A, const G4int Z)

static InverseInterpolationTable *	createRCDFTable (const G4int A, const G4int Z)

static InverseInterpolationTable *	createPCDFTable (const G4int A, const G4int Z)

static ParticleSampler *	createParticleSampler (const G4int A, const G4int Z)

static void	clearCache ()

Protected Member Functions
	NuclearDensityFactory ()

	~NuclearDensityFactory ()

Static Protected Attributes
static std::map< G4int, NuclearDensity * >	nuclearDensityCache

static std::map< G4int, InverseInterpolationTable * >	rpCorrelationTableCache

static std::map< G4int, InverseInterpolationTable * >	rCDFTableCache

static std::map< G4int, InverseInterpolationTable * >	pCDFTableCache

Detailed Description

Definition at line 49 of file G4INCLNuclearDensityFactory.hh.

Constructor & Destructor Documentation

◆ NuclearDensityFactory()

G4INCL::NuclearDensityFactory::NuclearDensityFactory ( )

inlineprotected

Definition at line 81 of file G4INCLNuclearDensityFactory.hh.

81{}

◆ ~NuclearDensityFactory()

G4INCL::NuclearDensityFactory::~NuclearDensityFactory ( )

inlineprotected

Definition at line 82 of file G4INCLNuclearDensityFactory.hh.

82{}

Member Function Documentation

◆ clearCache()

static void G4INCL::NuclearDensityFactory::clearCache ( )

inlinestatic

Definition at line 61 of file G4INCLNuclearDensityFactory.hh.

                             {
      for(std::map<G4int,NuclearDensity*>::const_iterator i = nuclearDensityCache.begin(); i!=nuclearDensityCache.end(); ++i)
        delete i->second;
      nuclearDensityCache.clear();
 
      for(std::map<G4int,InverseInterpolationTable*>::const_iterator i = rpCorrelationTableCache.begin(); i!=rpCorrelationTableCache.end(); ++i)
        delete i->second;
      rpCorrelationTableCache.clear();
 
      for(std::map<G4int,InverseInterpolationTable*>::const_iterator i = rCDFTableCache.begin(); i!=rCDFTableCache.end(); ++i)
        delete i->second;
      rCDFTableCache.clear();
 
      for(std::map<G4int,InverseInterpolationTable*>::const_iterator i = pCDFTableCache.begin(); i!=pCDFTableCache.end(); ++i)
        delete i->second;
      pCDFTableCache.clear();
    }

Referenced by G4INCL::INCL::~INCL().

◆ createDensity()

NuclearDensity * G4INCL::NuclearDensityFactory::createDensity	(	const G4int	A,
		const G4int	Z
	)

static

Definition at line 56 of file G4INCLNuclearDensityFactory.cc.

                                                                                   {
    const G4int nuclideID = 1000*Z + A; // MCNP-style nuclide IDs
    const std::map<G4int,NuclearDensity*>::const_iterator mapEntry = nuclearDensityCache.find(nuclideID);
    if(mapEntry == nuclearDensityCache.end()) {
      InverseInterpolationTable *rpCorrelationTable = NuclearDensityFactory::createRPCorrelationTable(A, Z);
      if(!rpCorrelationTable)
        return NULL;
      NuclearDensity *density = new NuclearDensity(A, Z, rpCorrelationTable);
      nuclearDensityCache[nuclideID] = density;
      return density;
    } else {
      return mapEntry->second;
    }
  }

Referenced by G4INCL::Nucleus::Nucleus().

◆ createParticleSampler()

ParticleSampler * G4INCL::NuclearDensityFactory::createParticleSampler	(	const G4int	A,
		const G4int	Z
	)

static

Definition at line 196 of file G4INCLNuclearDensityFactory.cc.

                                                                                            {
    InverseInterpolationTable *rCDFTable = NuclearDensityFactory::createRCDFTable(A, Z);
    InverseInterpolationTable *pCDFTable = NuclearDensityFactory::createPCDFTable(A, Z);
    return new ParticleSampler(A, Z, rCDFTable, pCDFTable);
  }

Referenced by G4INCL::Cluster::Cluster().

◆ createPCDFTable()

InverseInterpolationTable * G4INCL::NuclearDensityFactory::createPCDFTable	(	const G4int	A,
		const G4int	Z
	)

static

Definition at line 166 of file G4INCLNuclearDensityFactory.cc.

                                                                                                {
    const G4int nuclideID = 1000*Z + A; // MCNP-style nuclide IDs
    const std::map<G4int,InverseInterpolationTable*>::const_iterator mapEntry = pCDFTableCache.find(nuclideID);
    if(mapEntry == pCDFTableCache.end()) {
      IFunction1D *pDensityFunction;
      if(A > 19) {
        pDensityFunction = new NuclearDensityFunctions::HardSphere(PhysicalConstants::Pf);
      } else if(A <= 19 && A > 2) { // Gaussian distribution for light nuclei
        G4double momentumRMS = Math::oneOverSqrtThree * ParticleTable::getMomentumRMS(A, Z);
        pDensityFunction = new NuclearDensityFunctions::Gaussian(5.*momentumRMS, momentumRMS);
      } else if(A == 2 && Z == 1) { // density from the Paris potential for deuterons
        pDensityFunction = new NuclearDensityFunctions::ParisP();
      } else {
        ERROR("No nuclear density function for target A = "
            << A << " Z = " << Z << std::endl);
        return NULL;
      }
 
      InverseInterpolationTable *theTable = pDensityFunction->inverseCDFTable();
      delete pDensityFunction;
      DEBUG("Creating inverse momentum CDF for A=" << A << ", Z=" << Z << ":" <<
          std::endl << theTable->print() << std::endl);
 
      pCDFTableCache[nuclideID] = theTable;
      return theTable;
    } else {
      return mapEntry->second;
    }
  }

Referenced by createParticleSampler().

◆ createRCDFTable()

InverseInterpolationTable * G4INCL::NuclearDensityFactory::createRCDFTable	(	const G4int	A,
		const G4int	Z
	)

static

Definition at line 126 of file G4INCLNuclearDensityFactory.cc.

                                                                                                {
    const G4int nuclideID = 1000*Z + A; // MCNP-style nuclide IDs
    const std::map<G4int,InverseInterpolationTable*>::const_iterator mapEntry = rCDFTableCache.find(nuclideID);
    if(mapEntry == rCDFTableCache.end()) {
 
      IFunction1D *rDensityFunction;
      if(A > 19) {
        G4double radius = ParticleTable::getRadiusParameter(A, Z);
        G4double diffuseness = ParticleTable::getSurfaceDiffuseness(A, Z);
        G4double maximumRadius = ParticleTable::getMaximumNuclearRadius(A, Z);
        rDensityFunction = new NuclearDensityFunctions::WoodsSaxon(radius, maximumRadius, diffuseness);
      } else if(A <= 19 && A > 6) {
        G4double radius = ParticleTable::getRadiusParameter(A, Z);
        G4double diffuseness = ParticleTable::getSurfaceDiffuseness(A, Z);
        G4double maximumRadius = ParticleTable::getMaximumNuclearRadius(A, Z);
        rDensityFunction = new NuclearDensityFunctions::ModifiedHarmonicOscillator(radius, maximumRadius, diffuseness);
      } else if(A <= 6 && A > 2) { // Gaussian distribution for light nuclei
        G4double radius = ParticleTable::getRadiusParameter(A, Z);
        G4double maximumRadius = ParticleTable::getMaximumNuclearRadius(A, Z);
        rDensityFunction = new NuclearDensityFunctions::Gaussian(maximumRadius, Math::oneOverSqrtThree * radius);
      } else if(A == 2 && Z == 1) { // density from the Paris potential for deuterons
        rDensityFunction = new NuclearDensityFunctions::ParisR();
      } else {
        ERROR("No nuclear density function for target A = "
            << A << " Z = " << Z << std::endl);
        return NULL;
      }
 
      InverseInterpolationTable *theTable = rDensityFunction->inverseCDFTable();
      delete rDensityFunction;
      DEBUG("Creating inverse position CDF for A=" << A << ", Z=" << Z << ":" <<
          std::endl << theTable->print() << std::endl);
 
      rCDFTableCache[nuclideID] = theTable;
      return theTable;
    } else {
      return mapEntry->second;
    }
  }

Referenced by createParticleSampler().

◆ createRPCorrelationTable()

InverseInterpolationTable * G4INCL::NuclearDensityFactory::createRPCorrelationTable	(	const G4int	A,
		const G4int	Z
	)

static

Definition at line 71 of file G4INCLNuclearDensityFactory.cc.

                                                                                                         {
    const G4int nuclideID = 1000*Z + A; // MCNP-style nuclide IDs
    const std::map<G4int,InverseInterpolationTable*>::const_iterator mapEntry = rpCorrelationTableCache.find(nuclideID);
    if(mapEntry == rpCorrelationTableCache.end()) {
 
      IFunction1D *rpCorrelationFunction;
      if(A > 19) {
        const G4double radius = ParticleTable::getRadiusParameter(A, Z);
        const G4double diffuseness = ParticleTable::getSurfaceDiffuseness(A, Z);
        const G4double maximumRadius = ParticleTable::getMaximumNuclearRadius(A, Z);
        rpCorrelationFunction = new NuclearDensityFunctions::WoodsSaxonRP(radius, maximumRadius, diffuseness);
      } else if(A <= 19 && A > 6) {
        const G4double radius = ParticleTable::getRadiusParameter(A, Z);
        const G4double diffuseness = ParticleTable::getSurfaceDiffuseness(A, Z);
        const G4double maximumRadius = ParticleTable::getMaximumNuclearRadius(A, Z);
        rpCorrelationFunction = new NuclearDensityFunctions::ModifiedHarmonicOscillatorRP(radius, maximumRadius, diffuseness);
      } else if(A <= 6 && A > 1) { // Gaussian distribution for light nuclei
        const G4double radius = ParticleTable::getRadiusParameter(A, Z);
        const G4double maximumRadius = ParticleTable::getMaximumNuclearRadius(A, Z);
        rpCorrelationFunction = new NuclearDensityFunctions::GaussianRP(maximumRadius, Math::oneOverSqrtThree * radius);
      } else {
        ERROR("No r-p correlation function for target A = "
            << A << " Z = " << Z << std::endl);
        return NULL;
      }
 
      class InverseCDFOneThird : public IFunction1D {
        public:
          InverseCDFOneThird(IFunction1D const * const f) :
            IFunction1D(f->getXMinimum(), f->getXMaximum()),
            theFunction(f),
            normalisation(1./theFunction->integrate(xMin,xMax))
        {}
 
          G4double operator()(const G4double x) const {
            return Math::pow13(normalisation * theFunction->integrate(xMin,x));
          }
        private:
          IFunction1D const * const theFunction;
          const G4double normalisation;
      } *theInverseCDFOneThird = new InverseCDFOneThird(rpCorrelationFunction);
 
      InverseInterpolationTable *theTable = new InverseInterpolationTable(*theInverseCDFOneThird);
      delete theInverseCDFOneThird;
      delete rpCorrelationFunction;
      DEBUG("Creating r-p correlation function for A=" << A << ", Z=" << Z << ":"
          << std::endl << theTable->print() << std::endl);
 
      rpCorrelationTableCache[nuclideID] = theTable;
      return theTable;
    } else {
      return mapEntry->second;
    }
  }