G4INCL::ParticleTable Namespace Reference

Typedefs
typedef G4double(*	NuclearMassFn )(const G4int, const G4int)
typedef G4double(*	ParticleMassFn )(const ParticleType)
typedef G4double(*	SeparationEnergyFn )(const ParticleType, const G4int, const G4int)
typedef G4double(*	FermiMomentumFn )(const G4int, const G4int)

Functions
void	initialize (Config const *const theConfig=0)
	Initialize the particle table. More...
G4int	getIsospin (const ParticleType t)
	Get the isospin of a particle. More...
std::string	getName (const ParticleType t)
	Get the native INCL name of the particle. More...
std::string	getShortName (const ParticleType t)
	Get the short INCL name of the particle. More...
std::string	getName (const ParticleSpecies &s)
	Get the native INCL name of the particle. More...
std::string	getShortName (const ParticleSpecies &s)
	Get the short INCL name of the particle. More...
std::string	getName (const G4int A, const G4int Z)
	Get the native INCL name of the ion. More...
std::string	getShortName (const G4int A, const G4int Z)
	Get the short INCL name of the ion. More...
G4double	getINCLMass (const G4int A, const G4int Z)
	Get INCL nuclear mass (in MeV/c^2) More...
G4double	getINCLMass (const ParticleType t)
	Get INCL particle mass (in MeV/c^2) More...
G4double	getRealMass (const G4INCL::ParticleType t)
	Get particle mass (in MeV/c^2) More...
G4double	getRealMass (const G4int A, const G4int Z)
	Get nuclear mass (in MeV/c^2) More...
G4double	getTableQValue (const G4int A1, const G4int Z1, const G4int A2, const G4int Z2)
	Get Q-value (in MeV/c^2) More...
G4double	getTableQValue (const G4int A1, const G4int Z1, const G4int A2, const G4int Z2, const G4int A3, const G4int Z3)
	Get Q-value (in MeV/c^2) More...
G4double	getTableSpeciesMass (const ParticleSpecies &p)
G4int	getMassNumber (const ParticleType t)
	Get mass number from particle type. More...
G4int	getChargeNumber (const ParticleType t)
	Get charge number from particle type. More...
G4double	getNuclearRadius (const ParticleType t, const G4int A, const G4int Z)
G4double	getLargestNuclearRadius (const G4int A, const G4int Z)
G4double	getRadiusParameter (const ParticleType t, const G4int A, const G4int Z)
G4double	getMaximumNuclearRadius (const ParticleType t, const G4int A, const G4int Z)
G4double	getSurfaceDiffuseness (const ParticleType t, const G4int A, const G4int Z)
G4double	getMomentumRMS (const G4int A, const G4int Z)
	Return the RMS of the momentum distribution (light clusters) More...
G4double	getSeparationEnergyINCL (const ParticleType t, const G4int, const G4int)
	Return INCL's default separation energy. More...
G4double	getSeparationEnergyReal (const ParticleType t, const G4int A, const G4int Z)
	Return the real separation energy. More...
G4double	getSeparationEnergyRealForLight (const ParticleType t, const G4int A, const G4int Z)
	Return the real separation energy only for light nuclei. More...
G4double	getProtonSeparationEnergy ()
	Getter for protonSeparationEnergy. More...
G4double	getNeutronSeparationEnergy ()
	Getter for neutronSeparationEnergy. More...
void	setProtonSeparationEnergy (const G4double s)
	Setter for protonSeparationEnergy. More...
void	setNeutronSeparationEnergy (const G4double s)
	Setter for protonSeparationEnergy. More...
std::string	getElementName (const G4int Z)
	Get the name of the element from the atomic number. More...
std::string	getIUPACElementName (const G4int Z)
	Get the name of an unnamed element from the IUPAC convention. More...
G4int	parseElement (std::string pS)
	Get the name of the element from the atomic number. More...
G4int	parseIUPACElement (std::string const &pS)
	Parse a IUPAC element name. More...
IsotopicDistribution const &	getNaturalIsotopicDistribution (const G4int Z)
G4int	drawRandomNaturalIsotope (const G4int Z)
G4double	getFermiMomentumConstant (const G4int, const G4int)
	Return the constant value of the Fermi momentum. More...
G4double	getFermiMomentumConstantLight (const G4int A, const G4int Z)
	Return the constant value of the Fermi momentum - special for light. More...
G4double	getFermiMomentumMassDependent (const G4int A, const G4int)
	Return the value Fermi momentum from a fit. More...
G4double	getRPCorrelationCoefficient (const ParticleType t)
	Get the value of the r-p correlation coefficient. More...
G4double	getNeutronSkin ()
	Get the thickness of the neutron skin. More...
G4double	getNeutronHalo ()
	Get the size of the neutron halo. More...
ParticleType	getPionType (const G4int isosp)
	Get the type of pion. More...
ParticleType	getNucleonType (const G4int isosp)
	Get the type of nucleon. More...
ParticleType	getDeltaType (const G4int isosp)
	Get the type of delta. More...
G4double	getWidth (const ParticleType t)
	Get particle width (in s) More...

Variables
const G4int	maxClusterMass = 12
const G4int	maxClusterCharge = 8
const G4int	clusterTableZSize = maxClusterCharge+1
const G4int	clusterTableASize = maxClusterMass+1
const G4double	effectiveNucleonMass = 938.2796
const G4double	effectiveNucleonMass2 = 8.8036860777616e5
const G4double	effectiveDeltaMass = 1232.0
const G4double	effectiveDeltaWidth = 130.0
const G4double	effectivePionMass = 138.0
const G4double	effectiveEtaMass = 547.862
const G4double	effectiveOmegaMass = 782.65
const G4double	effectiveEtaPrimeMass = 957.78
const G4double	effectivePhotonMass = 0.0
G4ThreadLocal G4double	minDeltaMass = 0.
G4ThreadLocal G4double	minDeltaMass2 = 0.
G4ThreadLocal G4double	minDeltaMassRndm = 0.
G4ThreadLocal NuclearMassFn	getTableMass = NULL
	Static pointer to the mass function for nuclei. More...
G4ThreadLocal ParticleMassFn	getTableParticleMass = NULL
	Static pointer to the mass function for particles. More...
G4ThreadLocal SeparationEnergyFn	getSeparationEnergy = NULL
	Static pointer to the separation-energy function. More...
G4ThreadLocal FermiMomentumFn	getFermiMomentum = NULL

Typedef Documentation

typedef G4double(* G4INCL::ParticleTable::FermiMomentumFn)(const G4int, const G4int)

Definition at line 221 of file G4INCLParticleTable.hh.

typedef G4double(* G4INCL::ParticleTable::NuclearMassFn)(const G4int, const G4int)

Definition at line 208 of file G4INCLParticleTable.hh.

typedef G4double(* G4INCL::ParticleTable::ParticleMassFn)(const ParticleType)

Definition at line 209 of file G4INCLParticleTable.hh.

typedef G4double(* G4INCL::ParticleTable::SeparationEnergyFn)(const ParticleType, const G4int, const G4int)

Definition at line 216 of file G4INCLParticleTable.hh.

Function Documentation

G4int G4INCL::ParticleTable::drawRandomNaturalIsotope

(

const G4int

Z

)

Definition at line 883 of file G4INCLParticleTable.cc.

                                                  {
      return getNaturalIsotopicDistributions()->drawRandomIsotope(Z);
    }

Here is the caller graph for this function:

G4int G4INCL::ParticleTable::getChargeNumber

(

const ParticleType

t

)

Get charge number from particle type.

Definition at line 664 of file G4INCLParticleTable.cc.

                                                {
      switch(t) {
        case DeltaPlusPlus:
          return 2;
          break;
        case Proton:
        case DeltaPlus:
        case PiPlus:
          return 1;
          break;
        case Neutron:
        case DeltaZero:
        case PiZero:
        case Eta:
        case Omega:
        case EtaPrime:
        case Photon:
          return 0;
          break;
        case DeltaMinus:
        case PiMinus:
          return -1;
          break;
        default:
          return 0;
          break;
      }
    }

ParticleType G4INCL::ParticleTable::getDeltaType

(

const G4int

isosp

)

Get the type of delta.

Definition at line 948 of file G4INCLParticleTable.cc.

                                                 {
// assert(isosp == -3 || isosp == -1 || isosp == 1 || isosp == 3);
        if (isosp == -3) {
            return DeltaMinus;
        }
        else if (isosp == -1) {
            return DeltaZero;
        }
        else if (isosp == 1) {
            return DeltaPlus;
        }
        else {
            return DeltaPlusPlus;
        }
    }

std::string G4INCL::ParticleTable::getElementName

(

const G4int

Z

)

Get the name of the element from the atomic number.

Definition at line 834 of file G4INCLParticleTable.cc.

                                            {
      if(Z<1) {
        INCL_WARN("getElementName called with Z<1" << '\n');
        return elementTable[0];
      } else if(Z<elementTableSize)
        return elementTable[Z];
      else
        return getIUPACElementName(Z);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4INCL::ParticleTable::getFermiMomentumConstant	(	const G4int	,
		const G4int
	)

Return the constant value of the Fermi momentum.

Definition at line 887 of file G4INCLParticleTable.cc.

                                                                    {
      return constantFermiMomentum;
    }

Here is the caller graph for this function:

G4double G4INCL::ParticleTable::getFermiMomentumConstantLight	(	const G4int	A,
		const G4int	Z
	)

Return the constant value of the Fermi momentum - special for light.

This function should always return PhysicalConstants::Pf for heavy nuclei, and values from the momentumRMS table for light nuclei.

Parameters

A	mass number
Z	charge number

Definition at line 891 of file G4INCLParticleTable.cc.

                                                                         {
// assert(Z>0 && A>0 && Z<=A);
      if(Z<clusterTableZSize && A<clusterTableASize) {
        const G4double rms = momentumRMS[Z][A];
        return ((rms>0.) ? rms : momentumRMS[6][12]) * Math::sqrtFiveThirds;
      } else
        return getFermiMomentumConstant(A,Z);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4INCL::ParticleTable::getFermiMomentumMassDependent	(	const G4int	A,
		const G4int
	)

Return the value Fermi momentum from a fit.

This function returns a fitted Fermi momentum, based on data from Moniz et al., Phys. Rev. Lett. 26 (1971) 445. The fitted functional form is

with MeV/ , MeV/ and .

Parameters

A	mass number

Definition at line 900 of file G4INCLParticleTable.cc.

                                                                         {
// assert(A>0);
      static const G4double alphaParam = 259.416; // MeV/c
      static const G4double betaParam  = 152.824; // MeV/c
      static const G4double gammaParam = 9.5157E-2;
      return alphaParam - betaParam*std::exp(-gammaParam*((G4double)A));
    }

Here is the caller graph for this function:

G4double G4INCL::ParticleTable::getINCLMass	(	const G4int	A,
		const G4int	Z
	)

Get INCL nuclear mass (in MeV/c^2)

Definition at line 607 of file G4INCLParticleTable.cc.

                                                       {
// assert(A>=0);
      // For nuclei with Z<0 or Z>A, assume that the exotic charge state is due to pions
      if(Z<0)
        return A*neutronMass - Z*getINCLMass(PiMinus);
      else if(Z>A)
        return A*protonMass + (A-Z)*getINCLMass(PiPlus);
      else if(A>1)
        return Z*(protonMass - protonSeparationEnergy) + (A-Z)*(neutronMass - neutronSeparationEnergy);
      else if(A==1 && Z==0)
        return getINCLMass(Neutron);
      else if(A==1 && Z==1)
        return getINCLMass(Proton);
      else
        return 0.;
    }

Here is the caller graph for this function:

G4double G4INCL::ParticleTable::getINCLMass

(

const ParticleType

t

)

Get INCL particle mass (in MeV/c^2)

Definition at line 527 of file G4INCLParticleTable.cc.

                                                {
      if(pt == Proton) {
        return protonMass;
      } else if(pt == Neutron) {
        return neutronMass;
      } else if(pt == PiPlus) {
        return piPlusMass;
      } else if(pt == PiMinus) {
        return piMinusMass;
      } else if(pt == PiZero) {
        return piZeroMass;
      } else if(pt == Eta) {
        return etaMass;
      } else if(pt == Omega) {
        return omegaMass;
      } else if(pt == EtaPrime) {
        return etaPrimeMass;
      } else if(pt == Photon) {
        return photonMass;
      } else {
        INCL_ERROR("getMass : Unknown particle type." << '\n');
        return 0.0;
      }
    }

G4int G4INCL::ParticleTable::getIsospin

(

const ParticleType

t

)

Get the isospin of a particle.

Definition at line 399 of file G4INCLParticleTable.cc.

                                           {
      // Actually this is the 3rd component of isospin (I_z) multiplied by 2!
      if(t == Proton) {
        return 1;
      } else if(t == Neutron) {
        return -1;
      } else if(t == PiPlus) {
        return 2;
      } else if(t == PiMinus) {
        return -2;
      } else if(t == PiZero) {
        return 0;
      } else if(t == DeltaPlusPlus) {
        return 3;
      } else if(t == DeltaPlus) {
        return 1;
      } else if(t == DeltaZero) {
        return -1;
      } else if(t == DeltaMinus) {
        return -3;
      } else if(t == Eta) {
        return 0;
      } else if(t == Omega) {
        return 0;
      } else if(t == EtaPrime) {
        return 0;
      } else if(t == Photon) {
        return 0;
      }

      INCL_ERROR("Requested isospin of an unknown particle!");
      return -10; // Unknown
    }

std::string G4INCL::ParticleTable::getIUPACElementName

(

const G4int

Z

)

Get the name of an unnamed element from the IUPAC convention.

Definition at line 844 of file G4INCLParticleTable.cc.

                                                 {
      std::stringstream elementStream;
      elementStream << Z;
      std::string elementName = elementStream.str();
      std::transform(elementName.begin(), elementName.end(), elementName.begin(), intToIUPAC);
      elementName[0] = std::toupper(elementName.at(0));
      return elementName;
    }

Here is the caller graph for this function:

G4double G4INCL::ParticleTable::getLargestNuclearRadius	(	const G4int	A,
		const G4int	Z
	)

Definition at line 721 of file G4INCLParticleTable.cc.

                                                                   {
      return Math::max(getNuclearRadius(Proton, A, Z), getNuclearRadius(Neutron, A, Z));
    }

Here is the call graph for this function:

Here is the caller graph for this function:

G4int G4INCL::ParticleTable::getMassNumber

(

const ParticleType

t

)

Get mass number from particle type.

Definition at line 639 of file G4INCLParticleTable.cc.

                                              {
      switch(t) {
        case Proton:
        case Neutron:
        case DeltaPlusPlus:
        case DeltaPlus:
        case DeltaZero:
        case DeltaMinus:
          return 1;
          break;
        case PiPlus:
        case PiMinus:
        case PiZero:
        case Eta:
        case Omega:
        case EtaPrime:
        case Photon:
          return 0;
          break;
        default:
          return 0;
          break;
      }
    }

G4double G4INCL::ParticleTable::getMaximumNuclearRadius	(	const ParticleType	t,
		const G4int	A,
		const G4int	Z
	)

Definition at line 757 of file G4INCLParticleTable.cc.

                                                                                         {
      const G4double XFOISA = 8.0;
      if(A >= 19) {
        return getNuclearRadius(t,A,Z) + XFOISA * getSurfaceDiffuseness(t,A,Z);
      } else if(A < 19 && A >= 6) {
        return 5.5 + 0.3 * (G4double(A) - 6.0)/12.0;
      } else if(A >= 2) {
        return getNuclearRadius(t, A, Z) + 4.5;
      } else {
        INCL_ERROR("getMaximumNuclearRadius : No maximum radius for nucleus A = " << A << " Z = " << Z << '\n');
        return 0.0;
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4INCL::ParticleTable::getMomentumRMS	(	const G4int	A,
		const G4int	Z
	)

Return the RMS of the momentum distribution (light clusters)

Definition at line 790 of file G4INCLParticleTable.cc.

                                                          {
// assert(Z>=0 && A>=0 && Z<=A);
      return getFermiMomentum(A,Z) * Math::sqrtThreeFifths;
    }

Here is the caller graph for this function:

std::string G4INCL::ParticleTable::getName

(

const ParticleType

t

)

Get the native INCL name of the particle.

Definition at line 461 of file G4INCLParticleTable.cc.

                                            {
      if(p == G4INCL::Proton) {
        return std::string("proton");
      } else if(p == G4INCL::Neutron) {
        return std::string("neutron");
      } else if(p == G4INCL::DeltaPlusPlus) {
        return std::string("delta++");
      } else if(p == G4INCL::DeltaPlus) {
        return std::string("delta+");
      } else if(p == G4INCL::DeltaZero) {
        return std::string("delta0");
      } else if(p == G4INCL::DeltaMinus) {
        return std::string("delta-");
      } else if(p == G4INCL::PiPlus) {
        return std::string("pi+");
      } else if(p == G4INCL::PiZero) {
        return std::string("pi0");
      } else if(p == G4INCL::PiMinus) {
        return std::string("pi-");
      } else if(p == G4INCL::Composite) {
        return std::string("composite");
      } else if(p == G4INCL::Eta) {
        return std::string("eta");
      } else if(p == G4INCL::Omega) {
        return std::string("omega");
      } else if(p == G4INCL::EtaPrime) {
        return std::string("etaprime");
      } else if(p == G4INCL::Photon) {
        return std::string("photon");
      }
      return std::string("unknown");
    }

Here is the caller graph for this function:

std::string G4INCL::ParticleTable::getName

(

const ParticleSpecies &

s

)

Get the native INCL name of the particle.

Definition at line 440 of file G4INCLParticleTable.cc.

                                                {
      if(s.theType==Composite)
        return getName(s.theA,s.theZ);
      else
        return getName(s.theType);
    }

Here is the call graph for this function:

std::string G4INCL::ParticleTable::getName	(	const G4int	A,
		const G4int	Z
	)

Get the native INCL name of the ion.

Definition at line 447 of file G4INCLParticleTable.cc.

                                                    {
      std::stringstream stream;
      stream << getElementName(Z) << "-" << A;
      return stream.str();
    }

Here is the call graph for this function:

IsotopicDistribution const & G4INCL::ParticleTable::getNaturalIsotopicDistribution

(

const G4int

Z

)

Definition at line 879 of file G4INCLParticleTable.cc.

                                                                              {
      return getNaturalIsotopicDistributions()->getIsotopicDistribution(Z);
    }

G4double G4INCL::ParticleTable::getNeutronHalo

(

)

Get the size of the neutron halo.

Definition at line 915 of file G4INCLParticleTable.cc.

{ return neutronHalo; }

G4double G4INCL::ParticleTable::getNeutronSeparationEnergy

(

)

Getter for neutronSeparationEnergy.

Definition at line 828 of file G4INCLParticleTable.cc.

{ return neutronSeparationEnergy; }

G4double G4INCL::ParticleTable::getNeutronSkin

(

)

Get the thickness of the neutron skin.

Definition at line 913 of file G4INCLParticleTable.cc.

{ return neutronSkin; }

G4double G4INCL::ParticleTable::getNuclearRadius	(	const ParticleType	t,
		const G4int	A,
		const G4int	Z
	)

Definition at line 693 of file G4INCLParticleTable.cc.

                                                                                  {
// assert(A>=0);
      if(A >= 19 || (A < 6 && A >= 2)) {
        // For large (Woods-Saxon or Modified Harmonic Oscillator) or small
        // (Gaussian) nuclei, the radius parameter is just the nuclear radius
        return getRadiusParameter(t,A,Z);
      } else if(A < clusterTableASize && Z>=0 && Z < clusterTableZSize && A >= 6) {
        const G4double thisRMS = positionRMS[Z][A];
        if(thisRMS>0.0)
          return thisRMS;
        else {
          INCL_DEBUG("getNuclearRadius: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'
                     << "returning radius for C12");
          return positionRMS[6][12];
        }
      } else if(A < 19) {
        const G4double theRadiusParameter = getRadiusParameter(t, A, Z);
        const G4double theDiffusenessParameter = getSurfaceDiffuseness(t, A, Z);
        // The formula yields the nuclear RMS radius based on the parameters of
        // the nuclear-density function
        return 1.225*theDiffusenessParameter*
          std::sqrt((2.+5.*theRadiusParameter)/(2.+3.*theRadiusParameter));
      } else {
        INCL_ERROR("getNuclearRadius: No radius for nucleus A = " << A << " Z = " << Z << '\n');
        return 0.0;
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

ParticleType G4INCL::ParticleTable::getNucleonType

(

const G4int

isosp

)

Get the type of nucleon.

Definition at line 938 of file G4INCLParticleTable.cc.

                                                   {
// assert(isosp == -1 || isosp == 1);
        if (isosp == -1) {
            return Neutron;
        }
        else {
            return Proton;
        }
    }

Here is the caller graph for this function:

ParticleType G4INCL::ParticleTable::getPionType

(

const G4int

isosp

)

Get the type of pion.

Definition at line 925 of file G4INCLParticleTable.cc.

                                                {
// assert(isosp == -2 || isosp == 0 || isosp == 2);
        if (isosp == -2) {
            return PiMinus;
        }
        else if (isosp == 0) {
            return PiZero;
        }
        else {
            return PiPlus;
        }
    }

Here is the caller graph for this function:

G4double G4INCL::ParticleTable::getProtonSeparationEnergy

(

)

Getter for protonSeparationEnergy.

Definition at line 826 of file G4INCLParticleTable.cc.

{ return protonSeparationEnergy; }

G4double G4INCL::ParticleTable::getRadiusParameter	(	const ParticleType	t,
		const G4int	A,
		const G4int	Z
	)

Definition at line 725 of file G4INCLParticleTable.cc.

                                                                                    {
// assert(A>0);
      if(A >= 28) {
        // phenomenological radius fit
        G4double r0 = (2.745e-4 * A + 1.063) * std::pow(A, 1.0/3.0);
        if(t==Neutron)
          r0 += neutronSkin;
        return r0;
      } else if(A < 6 && A >= 2) {
        if(Z<clusterTableZSize && Z>=0) {
          const G4double thisRMS = positionRMS[Z][A];
          if(thisRMS>0.0)
            return thisRMS;
          else {
            INCL_DEBUG("getRadiusParameter: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'
                       << "returning radius for C12");
            return positionRMS[6][12];
          }
        } else {
          INCL_DEBUG("getRadiusParameter: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'
                     << "returning radius for C12");
          return positionRMS[6][12];
        }
      } else if(A < 28 && A >= 6) {
        return mediumRadius[A-1];
        //      return 1.581*mediumDiffuseness[A-1]*(2.+5.*mediumRadius[A-1])/(2.+3.*mediumRadius[A-1]);
      } else {
        INCL_ERROR("getRadiusParameter: No radius for nucleus A = " << A << " Z = " << Z << '\n');
        return 0.0;
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4INCL::ParticleTable::getRealMass

(

const G4INCL::ParticleType

t

)

Get particle mass (in MeV/c^2)

Definition at line 552 of file G4INCLParticleTable.cc.

                                               {
      switch(t) {
        case Proton:
          return theRealProtonMass;
          break;
        case Neutron:
          return theRealNeutronMass;
          break;
        case PiPlus:
        case PiMinus:
          return theRealChargedPiMass;
          break;
        case PiZero:
          return theRealPiZeroMass;
          break;
        case Eta:
          return theRealEtaMass;
          break;
        case Omega:
          return theRealOmegaMass;
          break;
        case EtaPrime:
          return theRealEtaPrimeMass;
          break;
        case Photon:
          return theRealPhotonMass;
          break;
        default:
          INCL_ERROR("Particle::getRealMass : Unknown particle type." << '\n');
          return 0.0;
          break;
      }
    }

Here is the caller graph for this function:

G4double G4INCL::ParticleTable::getRealMass	(	const G4int	A,
		const G4int	Z
	)

Get nuclear mass (in MeV/c^2)

Definition at line 586 of file G4INCLParticleTable.cc.

                                                       {
// assert(A>=0);
      // For nuclei with Z<0 or Z>A, assume that the exotic charge state is due to pions
      if(Z<0)
        return A*neutronMass - Z*getRealMass(PiMinus);
      else if(Z>A)
        return A*protonMass + (A-Z)*getRealMass(PiPlus);
      else if(Z==0)
        return A*getRealMass(Neutron);
      else if(A==Z)
        return A*getRealMass(Proton);
      else if(A>1) {
#ifndef INCLXX_IN_GEANT4_MODE
        return ::G4INCL::NuclearMassTable::getMass(A,Z);
#else
        return theG4IonTable->GetNucleusMass(Z,A) / MeV;
#endif
      } else
        return 0.;
    }

Here is the call graph for this function:

G4double G4INCL::ParticleTable::getRPCorrelationCoefficient

(

const ParticleType

t

)

Get the value of the r-p correlation coefficient.

Parameters

t	the type of the particle (Proton or Neutron)

Returns

the value of the r-p correlation coefficient

Definition at line 908 of file G4INCLParticleTable.cc.

                                                               {
// assert(t==Proton || t==Neutron);
      return rpCorrelationCoefficient[t];
    }

Here is the caller graph for this function:

G4double G4INCL::ParticleTable::getSeparationEnergyINCL	(	const ParticleType	t,
		const G4int	,
		const G4int
	)

Return INCL's default separation energy.

Definition at line 795 of file G4INCLParticleTable.cc.

                                                                                         {
      if(t==Proton)
        return theINCLProtonSeparationEnergy;
      else if(t==Neutron)
        return theINCLNeutronSeparationEnergy;
      else {
        INCL_ERROR("ParticleTable::getSeparationEnergyINCL : Unknown particle type." << '\n');
        return 0.0;
      }
    }

Here is the caller graph for this function:

G4double G4INCL::ParticleTable::getSeparationEnergyReal	(	const ParticleType	t,
		const G4int	A,
		const G4int	Z
	)

Return the real separation energy.

Definition at line 806 of file G4INCLParticleTable.cc.

                                                                                         {
      // Real separation energies for all nuclei
      if(t==Proton)
        return (*getTableParticleMass)(Proton) + (*getTableMass)(A-1,Z-1) - (*getTableMass)(A,Z);
      else if(t==Neutron)
        return (*getTableParticleMass)(Neutron) + (*getTableMass)(A-1,Z) - (*getTableMass)(A,Z);
      else {
        INCL_ERROR("ParticleTable::getSeparationEnergyReal : Unknown particle type." << '\n');
        return 0.0;
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4INCL::ParticleTable::getSeparationEnergyRealForLight	(	const ParticleType	t,
		const G4int	A,
		const G4int	Z
	)

Return the real separation energy only for light nuclei.

Definition at line 818 of file G4INCLParticleTable.cc.

                                                                                                 {
      // Real separation energies for light nuclei, fixed values for heavy nuclei
      if(Z<clusterTableZSize && A<clusterTableASize)
        return getSeparationEnergyReal(t, A, Z);
      else
        return getSeparationEnergyINCL(t, A, Z);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G4INCL::ParticleTable::getShortName

(

const ParticleType

t

)

Get the short INCL name of the particle.

Definition at line 494 of file G4INCLParticleTable.cc.

                                                 {
      if(p == G4INCL::Proton) {
        return std::string("p");
      } else if(p == G4INCL::Neutron) {
        return std::string("n");
      } else if(p == G4INCL::DeltaPlusPlus) {
        return std::string("d++");
      } else if(p == G4INCL::DeltaPlus) {
        return std::string("d+");
      } else if(p == G4INCL::DeltaZero) {
        return std::string("d0");
      } else if(p == G4INCL::DeltaMinus) {
        return std::string("d-");
      } else if(p == G4INCL::PiPlus) {
        return std::string("pi+");
      } else if(p == G4INCL::PiZero) {
        return std::string("pi0");
      } else if(p == G4INCL::PiMinus) {
        return std::string("pi-");
      } else if(p == G4INCL::Composite) {
        return std::string("comp");
      } else if(p == G4INCL::Eta) {
        return std::string("eta");
      } else if(p == G4INCL::Omega) {
        return std::string("omega");
      } else if(p == G4INCL::EtaPrime) {
        return std::string("etap");
      } else if(p == G4INCL::Photon) {
        return std::string("photon");
      }
      return std::string("unknown");
    }

Here is the caller graph for this function:

std::string G4INCL::ParticleTable::getShortName

(

const ParticleSpecies &

s

)

Get the short INCL name of the particle.

Definition at line 433 of file G4INCLParticleTable.cc.

                                                     {
      if(s.theType==Composite)
        return getShortName(s.theA,s.theZ);
      else
        return getShortName(s.theType);
    }

Here is the call graph for this function:

std::string G4INCL::ParticleTable::getShortName	(	const G4int	A,
		const G4int	Z
	)

Get the short INCL name of the ion.

Definition at line 453 of file G4INCLParticleTable.cc.

                                                         {
      std::stringstream stream;
      stream << getElementName(Z);
      if(A>0)
        stream << A;
      return stream.str();
    }

Here is the call graph for this function:

G4double G4INCL::ParticleTable::getSurfaceDiffuseness	(	const ParticleType	t,
		const G4int	A,
		const G4int	Z
	)

Definition at line 771 of file G4INCLParticleTable.cc.

                                                                                       {
      if(A >= 28) {
        G4double a = 1.63e-4 * A + 0.510;
        if(t==Neutron)
          a += neutronHalo;
        return a;
      } else if(A < 28 && A >= 19) {
        return mediumDiffuseness[A-1];
      } else if(A < 19 && A >= 6) {
        return mediumDiffuseness[A-1];
      } else if(A < 6 && A >= 2) {
        INCL_ERROR("getSurfaceDiffuseness: was called for A = " << A << " Z = " << Z << '\n');
        return 0.0;
      } else {
        INCL_ERROR("getSurfaceDiffuseness: No diffuseness for nucleus A = " << A << " Z = " << Z << '\n');
        return 0.0;
      }
    }

Here is the caller graph for this function:

G4double G4INCL::ParticleTable::getTableQValue	(	const G4int	A1,
		const G4int	Z1,
		const G4int	A2,
		const G4int	Z2
	)

Get Q-value (in MeV/c^2)

Uses the getTableMass function to compute the Q-value for the following reaction:

Definition at line 624 of file G4INCLParticleTable.cc.

                                                                                            {
      return getTableMass(A1,Z1) + getTableMass(A2,Z2) - getTableMass(A1+A2,Z1+Z2);
    }

Here is the caller graph for this function:

G4double G4INCL::ParticleTable::getTableQValue	(	const G4int	A1,
		const G4int	Z1,
		const G4int	A2,
		const G4int	Z2,
		const G4int	A3,
		const G4int	Z3
	)

Get Q-value (in MeV/c^2)

Uses the getTableMass function to compute the Q-value for the following reaction:

Definition at line 628 of file G4INCLParticleTable.cc.

                                                                                                                            {
      return getTableMass(A1,Z1) + getTableMass(A2,Z2) - getTableMass(A3,Z3) - getTableMass(A1+A2-A3,Z1+Z2-Z3);
    }

G4double G4INCL::ParticleTable::getTableSpeciesMass

(

const ParticleSpecies &

p

)

Definition at line 632 of file G4INCLParticleTable.cc.

                                                           {
      if(p.theType == Composite)
        return (*getTableMass)(p.theA, p.theZ);
      else
        return (*getTableParticleMass)(p.theType);
    }

G4double G4INCL::ParticleTable::getWidth

(

const ParticleType

t

)

Get particle width (in s)

Definition at line 964 of file G4INCLParticleTable.cc.

                                             {
// assert(pt == PiPlus || pt == PiMinus || pt == PiZero || pt == Eta || pt == Omega || pt == EtaPrime);
          if(pt == PiPlus) {
              return piPlusWidth;
          } else if(pt == PiMinus) {
              return piMinusWidth;
          } else if(pt == PiZero) {
              return piZeroWidth;
          } else if(pt == Eta) {
              return etaWidth;
          } else if(pt == Omega) {
              return omegaWidth;
          } else if(pt == EtaPrime) {
              return etaPrimeWidth;
          } else {
              INCL_ERROR("getWidth : Unknown particle type." << '\n');
              return 0.0;
          }
      }

Here is the caller graph for this function:

void G4INCL::ParticleTable::initialize

(

Config const *const

theConfig = 0

)

Initialize the particle table.

Definition at line 300 of file G4INCLParticleTable.cc.

                                                      {
      protonMass = theINCLNucleonMass;
      neutronMass = theINCLNucleonMass;
      piPlusMass = theINCLPionMass;
      piMinusMass = theINCLPionMass;
      piZeroMass = theINCLPionMass;
      etaMass = theINCLEtaMass;
      omegaMass = theINCLOmegaMass;
      etaPrimeMass = theINCLEtaPrimeMass;
      photonMass = theINCLPhotonMass;

      if(theConfig && theConfig->getUseRealMasses()) {
        getTableMass = getRealMass;
        getTableParticleMass = getRealMass;
      } else {
        getTableMass = getINCLMass;
        getTableParticleMass = getINCLMass;
      }

#ifndef INCLXX_IN_GEANT4_MODE
      std::string dataFilePath;
      if(theConfig)
        dataFilePath = theConfig->getINCLXXDataFilePath();
      NuclearMassTable::initialize(dataFilePath, getRealMass(Proton), getRealMass(Neutron));
#endif

#ifdef INCLXX_IN_GEANT4_MODE
      G4ParticleTable *theG4ParticleTable = G4ParticleTable::GetParticleTable();
      theG4IonTable = theG4ParticleTable->GetIonTable();
      theRealProtonMass = theG4ParticleTable->FindParticle("proton")->GetPDGMass() / MeV;
      theRealNeutronMass = theG4ParticleTable->FindParticle("neutron")->GetPDGMass() / MeV;
      theRealChargedPiMass = theG4ParticleTable->FindParticle("pi+")->GetPDGMass() / MeV;
      theRealPiZeroMass = theG4ParticleTable->FindParticle("pi0")->GetPDGMass() / MeV;
      theRealEtaMass = theG4ParticleTable->FindParticle("eta")->GetPDGMass() / MeV;
      theRealOmegaMass = theG4ParticleTable->FindParticle("omega")->GetPDGMass() / MeV;
      theRealEtaPrimeMass = theG4ParticleTable->FindParticle("eta_prime")->GetPDGMass() / MeV;
      theRealPhotonMass = theG4ParticleTable->FindParticle("gamma")->GetPDGMass() / MeV;
#endif

      minDeltaMass = theRealNeutronMass + theRealChargedPiMass + 0.5;
      minDeltaMass2 = minDeltaMass*minDeltaMass;
      minDeltaMassRndm = std::atan((minDeltaMass-effectiveDeltaMass)*2./effectiveDeltaWidth);

      piPlusWidth   = theChargedPiWidth;
      piMinusWidth  = theChargedPiWidth;
      piZeroWidth   = thePiZeroWidth;
      etaWidth      = theEtaWidth;
      omegaWidth    = theOmegaWidth;
      etaPrimeWidth = theEtaPrimeWidth;
        
        
      // Initialise the separation-energy function
      if(!theConfig || theConfig->getSeparationEnergyType()==INCLSeparationEnergy)
        getSeparationEnergy = getSeparationEnergyINCL;
      else if(theConfig->getSeparationEnergyType()==RealSeparationEnergy)
        getSeparationEnergy = getSeparationEnergyReal;
      else if(theConfig->getSeparationEnergyType()==RealForLightSeparationEnergy)
        getSeparationEnergy = getSeparationEnergyRealForLight;
      else {
        INCL_FATAL("Unrecognized separation-energy type in ParticleTable initialization: " << theConfig->getSeparationEnergyType() << '\n');
        return;
      }

      // Initialise the Fermi-momentum function
      if(!theConfig || theConfig->getFermiMomentumType()==ConstantFermiMomentum) {
        getFermiMomentum = ParticleTable::getFermiMomentumConstant;
        if(theConfig) {
          const G4double aFermiMomentum = theConfig->getFermiMomentum();
          if(aFermiMomentum>0.)
            constantFermiMomentum = aFermiMomentum;
          else
            constantFermiMomentum = PhysicalConstants::Pf;
        } else {
          constantFermiMomentum = PhysicalConstants::Pf;
        }
      } else if(theConfig->getFermiMomentumType()==ConstantLightFermiMomentum)
        getFermiMomentum = ParticleTable::getFermiMomentumConstantLight;
      else if(theConfig->getFermiMomentumType()==MassDependentFermiMomentum)
        getFermiMomentum = ParticleTable::getFermiMomentumMassDependent;
      else {
        INCL_FATAL("Unrecognized Fermi-momentum type in ParticleTable initialization: " << theConfig->getFermiMomentumType() << '\n');
        return;
      }

      // Initialise the r-p correlation coefficients
      std::fill(rpCorrelationCoefficient, rpCorrelationCoefficient + UnknownParticle, 1.);
      if(theConfig) {
        rpCorrelationCoefficient[Proton] = theConfig->getRPCorrelationCoefficient(Proton);
        rpCorrelationCoefficient[Neutron] = theConfig->getRPCorrelationCoefficient(Neutron);
      }

      // Initialise the neutron-skin parameters
      if(theConfig) {
        neutronSkin = theConfig->getNeutronSkin();
        neutronHalo = theConfig->getNeutronHalo();
      }

    }

Here is the call graph for this function:

Here is the caller graph for this function:

G4int G4INCL::ParticleTable::parseElement

(

std::string

pS

)

Get the name of the element from the atomic number.

Definition at line 853 of file G4INCLParticleTable.cc.

                                     {
      // Normalize the element name
      std::transform(pS.begin(), pS.end(), pS.begin(), ::tolower);
      pS[0] = ::toupper(pS[0]);

      const std::string *iter = std::find(elementTable, elementTable+elementTableSize, pS);
      if(iter != elementTable+elementTableSize)
        return iter - elementTable;
      else
        return ParticleTable::parseIUPACElement(pS);
    }

Here is the call graph for this function:

G4int G4INCL::ParticleTable::parseIUPACElement

(

std::string const &

pS

)

Parse a IUPAC element name.

Note: this function is UGLY. Look at it at your own peril.

Parameters

pS	a normalised string (lowercase)

Returns

the charge number of the nuclide, or zero on fail

Definition at line 865 of file G4INCLParticleTable.cc.

                                                {
      // Normalise to lower case
      std::string elementName(s);
      std::transform(elementName.begin(), elementName.end(), elementName.begin(), ::tolower);
      // Return 0 if the element name contains anything but IUPAC digits
      if(elementName.find_first_not_of(elementIUPACDigits)!=std::string::npos)
        return 0;
      std::transform(elementName.begin(), elementName.end(), elementName.begin(), iupacToInt);
      std::stringstream elementStream(elementName);
      G4int Z;
      elementStream >> Z;
      return Z;
    }

Here is the caller graph for this function:

void G4INCL::ParticleTable::setNeutronSeparationEnergy

(

const G4double

s

)

Setter for protonSeparationEnergy.

Definition at line 832 of file G4INCLParticleTable.cc.

{ neutronSeparationEnergy  = s; }

Here is the caller graph for this function:

void G4INCL::ParticleTable::setProtonSeparationEnergy

(

const G4double

s

)

Setter for protonSeparationEnergy.

Definition at line 830 of file G4INCLParticleTable.cc.

{ protonSeparationEnergy = s; }

Here is the caller graph for this function:

Variable Documentation

const G4int G4INCL::ParticleTable::clusterTableASize = maxClusterMass+1

Definition at line 65 of file G4INCLParticleTable.hh.

const G4int G4INCL::ParticleTable::clusterTableZSize = maxClusterCharge+1

Definition at line 64 of file G4INCLParticleTable.hh.

const G4double G4INCL::ParticleTable::effectiveDeltaMass = 1232.0

Definition at line 69 of file G4INCLParticleTable.hh.

const G4double G4INCL::ParticleTable::effectiveDeltaWidth = 130.0

Definition at line 70 of file G4INCLParticleTable.hh.

const G4double G4INCL::ParticleTable::effectiveEtaMass = 547.862

Definition at line 72 of file G4INCLParticleTable.hh.

const G4double G4INCL::ParticleTable::effectiveEtaPrimeMass = 957.78

Definition at line 74 of file G4INCLParticleTable.hh.

const G4double G4INCL::ParticleTable::effectiveNucleonMass = 938.2796

Definition at line 67 of file G4INCLParticleTable.hh.

const G4double G4INCL::ParticleTable::effectiveNucleonMass2 = 8.8036860777616e5

Definition at line 68 of file G4INCLParticleTable.hh.

const G4double G4INCL::ParticleTable::effectiveOmegaMass = 782.65

Definition at line 73 of file G4INCLParticleTable.hh.

const G4double G4INCL::ParticleTable::effectivePhotonMass = 0.0

Definition at line 75 of file G4INCLParticleTable.hh.

const G4double G4INCL::ParticleTable::effectivePionMass = 138.0

Definition at line 71 of file G4INCLParticleTable.hh.

G4ThreadLocal FermiMomentumFn G4INCL::ParticleTable::getFermiMomentum = NULL

Definition at line 923 of file G4INCLParticleTable.cc.

G4ThreadLocal SeparationEnergyFn G4INCL::ParticleTable::getSeparationEnergy = NULL

Static pointer to the separation-energy function.

Definition at line 922 of file G4INCLParticleTable.cc.

G4ThreadLocal NuclearMassFn G4INCL::ParticleTable::getTableMass = NULL

Static pointer to the mass function for nuclei.

Definition at line 920 of file G4INCLParticleTable.cc.

G4ThreadLocal ParticleMassFn G4INCL::ParticleTable::getTableParticleMass = NULL

Static pointer to the mass function for particles.

Definition at line 921 of file G4INCLParticleTable.cc.

const G4int G4INCL::ParticleTable::maxClusterCharge = 8

Definition at line 62 of file G4INCLParticleTable.hh.

const G4int G4INCL::ParticleTable::maxClusterMass = 12

Definition at line 61 of file G4INCLParticleTable.hh.

G4ThreadLocal G4double G4INCL::ParticleTable::minDeltaMass = 0.

Definition at line 917 of file G4INCLParticleTable.cc.

G4ThreadLocal G4double G4INCL::ParticleTable::minDeltaMass2 = 0.

Definition at line 918 of file G4INCLParticleTable.cc.

G4ThreadLocal G4double G4INCL::ParticleTable::minDeltaMassRndm = 0.

Definition at line 919 of file G4INCLParticleTable.cc.