Namespaces
namespace	anonymous_namespace{G4INCLParticleTable.cc}

Typedefs
typedef G4double(*	FermiMomentumFn) (const G4int, const G4int)

typedef G4double(*	NuclearMassFn) (const G4int, const G4int, const G4int)

typedef G4double(*	ParticleMassFn) (const ParticleType)

typedef G4double(*	SeparationEnergyFn) (const ParticleType, const G4int, const G4int)

Functions
G4int	drawRandomNaturalIsotope (const G4int Z)

ParticleType	getAntiKaonType (const G4int isosp)
	Get the type of antikaon. More...

G4int	getChargeNumber (const ParticleType t)
	Get charge number from particle type. More...

ParticleType	getDeltaType (const G4int isosp)
	Get the type of delta. More...

std::string	getElementName (const G4int Z)
	Get the name of the element from the atomic number. More...

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	getINCLMass (const G4int A, const G4int Z, const G4int S)
	Get INCL nuclear mass (in MeV/c^2) More...

G4double	getINCLMass (const ParticleType t)
	Get INCL particle mass (in MeV/c^2) More...

G4int	getIsospin (const ParticleType t)
	Get the isospin of a particle. More...

std::string	getIUPACElementName (const G4int Z)
	Get the name of an unnamed element from the IUPAC convention. More...

ParticleType	getKaonType (const G4int isosp)
	Get the type of kaon. More...

G4double	getLambdaSeparationEnergy ()

G4double	getLargestNuclearRadius (const G4int A, const G4int Z)

G4int	getMassNumber (const ParticleType t)
	Get mass number from particle type. More...

G4double	getMaximumNuclearRadius (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...

std::string	getName (const G4int A, const G4int Z)
	Get the native INCL name of the ion. More...

std::string	getName (const G4int A, const G4int Z, const G4int S)

std::string	getName (const ParticleSpecies &s)
	Get the native INCL name of the particle. More...

std::string	getName (const ParticleType t)
	Get the native INCL name of the particle. More...

IsotopicDistribution const &	getNaturalIsotopicDistribution (const G4int Z)

G4double	getNeutronHalo ()
	Get the size of the neutron halo. More...

G4double	getNeutronSeparationEnergy ()
	Getter for neutronSeparationEnergy. More...

G4double	getNeutronSkin ()
	Get the thickness of the neutron skin. More...

G4double	getNuclearRadius (const ParticleType t, const G4int A, const G4int Z)

ParticleType	getNucleonType (const G4int isosp)
	Get the type of nucleon. More...

ParticleType	getPionType (const G4int isosp)
	Get the type of pion. More...

G4double	getProtonSeparationEnergy ()
	Getter for protonSeparationEnergy. More...

G4double	getRadiusParameter (const ParticleType t, const G4int A, const G4int Z)

G4double	getRealMass (const G4INCL::ParticleType t)
	Get particle mass (in MeV/c^2) More...

G4double	getRealMass (const G4int A, const G4int Z, const G4int S=0)
	Get nuclear mass (in MeV/c^2) More...

G4double	getRPCorrelationCoefficient (const ParticleType t)
	Get the value of the r-p correlation coefficient. 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...

std::string	getShortName (const G4int A, const G4int Z)
	Get the short INCL name of the ion. More...

std::string	getShortName (const ParticleSpecies &s)
	Get the short INCL name of the particle. More...

std::string	getShortName (const ParticleType t)
	Get the short INCL name of the particle. More...

ParticleType	getSigmaType (const G4int isosp)
	Get the type of sigma. More...

G4int	getStrangenessNumber (const ParticleType t)
	Get strangeness number from particle type. More...

G4double	getSurfaceDiffuseness (const ParticleType t, const G4int A, const G4int Z)

G4double	getTableQValue (const G4int A1, const G4int Z1, const G4int S1, const G4int A2, const G4int Z2, const G4int S2)
	Get Q-value (in MeV/c^2) More...

G4double	getTableQValue (const G4int A1, const G4int Z1, const G4int S1, const G4int A2, const G4int Z2, const G4int S2, const G4int A3, const G4int Z3, const G4int S3)
	Get Q-value (in MeV/c^2) More...

G4double	getTableSpeciesMass (const ParticleSpecies &p)

G4double	getWidth (const ParticleType t)
	Get particle width (in s) More...

void	initialize (Config const *const theConfig=0)
	Initialize the particle table. 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...

void	setLambdaSeparationEnergy (const G4double sen)

void	setNeutronSeparationEnergy (const G4double s)
	Setter for protonSeparationEnergy. More...

void	setProtonSeparationEnergy (const G4double s)
	Setter for protonSeparationEnergy. More...

Variables
const G4int	clusterTableASize = maxClusterMass+1

const G4int	clusterTableSSize = 4

const G4int	clusterTableZSize = maxClusterCharge+1

const G4double	effectiveAntiKaonMass = 497.614

const G4double	effectiveDeltaMass = 1232.0

const G4double	effectiveDeltaWidth = 130.0

const G4double	effectiveEtaMass = 547.862

const G4double	effectiveEtaPrimeMass = 957.78

const G4double	effectiveKaonMass = 497.614

const G4double	effectiveLambdaMass = 1115.683

const G4double	effectiveNucleonMass = 938.2796

const G4double	effectiveNucleonMass2 = 8.8036860777616e5

const G4double	effectiveOmegaMass = 782.65

const G4double	effectivePhotonMass = 0.0

const G4double	effectivePionMass = 138.0

const G4double	effectiveSigmaMass = 1197.45

G4ThreadLocal FermiMomentumFn	getFermiMomentum = NULL

G4ThreadLocal SeparationEnergyFn	getSeparationEnergy = NULL
	Static pointer to the separation-energy function. More...

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...

const G4int	maxClusterCharge = 8

const G4int	maxClusterMass = 12

G4ThreadLocal G4double	minDeltaMass = 0.

G4ThreadLocal G4double	minDeltaMass2 = 0.

G4ThreadLocal G4double	minDeltaMassRndm = 0.

Typedef Documentation

◆ FermiMomentumFn

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

Definition at line 232 of file G4INCLParticleTable.hh.

◆ NuclearMassFn

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

Definition at line 219 of file G4INCLParticleTable.hh.

◆ ParticleMassFn

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

Definition at line 220 of file G4INCLParticleTable.hh.

◆ SeparationEnergyFn

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

Definition at line 227 of file G4INCLParticleTable.hh.

Function Documentation

◆ drawRandomNaturalIsotope()

G4int G4INCL::ParticleTable::drawRandomNaturalIsotope ( const G4int Z )

Definition at line 1198 of file G4INCLParticleTable.cc.

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

References G4INCL::NaturalIsotopicDistributions::drawRandomIsotope(), G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::getNaturalIsotopicDistributions(), and Z.

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

◆ getAntiKaonType()

ParticleType G4INCL::ParticleTable::getAntiKaonType ( const G4int isosp )

Get the type of antikaon.

Definition at line 1303 of file G4INCLParticleTable.cc.

                                                    {
// assert(isosp == -1 || isosp == 1);
        if (isosp == -1) {
            return KMinus;
        }
        else {
            return KZeroBar;
        }
    }

References G4INCL::KMinus, and G4INCL::KZeroBar.

Referenced by G4INCL::NDeltaToNNKKbChannel::fillFinalState(), G4INCL::NKbToNKb2piChannel::fillFinalState(), G4INCL::NKbToNKbpiChannel::fillFinalState(), G4INCL::NNToMissingStrangenessChannel::fillFinalState(), G4INCL::NpiToMissingStrangenessChannel::fillFinalState(), and G4INCL::NpiToNKKbChannel::fillFinalState().

◆ getChargeNumber()

G4int G4INCL::ParticleTable::getChargeNumber ( const ParticleType t )

Get charge number from particle type.

Definition at line 885 of file G4INCLParticleTable.cc.

                                                {
      switch(t) {
        case DeltaPlusPlus:
          return 2;
          break;
        case Proton:
        case DeltaPlus:
        case PiPlus:
        case SigmaPlus:
        case KPlus:
          return 1;
          break;
        case Neutron:
        case DeltaZero:
        case PiZero:
        case SigmaZero:
        case Lambda:
        case KZero:
        case KZeroBar:
        case KShort:
        case KLong:
        case Eta:
        case Omega:
        case EtaPrime:
        case Photon:
          return 0;
          break;
        case DeltaMinus:
        case PiMinus:
        case SigmaMinus:
        case KMinus:
          return -1;
          break;
        default:
          return 0;
          break;
      }
    }

References G4INCL::DeltaMinus, G4INCL::DeltaPlus, G4INCL::DeltaPlusPlus, G4INCL::DeltaZero, G4INCL::Eta, G4INCL::EtaPrime, G4INCL::KLong, G4INCL::KMinus, G4INCL::KPlus, G4INCL::KShort, G4INCL::KZero, G4INCL::KZeroBar, G4INCL::Lambda, G4INCL::Neutron, G4INCL::Omega, G4INCL::Photon, G4INCL::PiMinus, G4INCL::PiPlus, G4INCL::PiZero, G4INCL::Proton, G4INCL::SigmaMinus, G4INCL::SigmaPlus, and G4INCL::SigmaZero.

◆ getDeltaType()

ParticleType G4INCL::ParticleTable::getDeltaType ( const G4int isosp )

Get the type of delta.

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

References G4INCL::DeltaMinus, G4INCL::DeltaPlus, G4INCL::DeltaPlusPlus, and G4INCL::DeltaZero.

Referenced by G4INCL::NDeltaToDeltaLKChannel::fillFinalState(), and G4INCL::NDeltaToDeltaSKChannel::fillFinalState().

◆ getElementName()

std::string G4INCL::ParticleTable::getElementName ( const G4int Z )

Get the name of the element from the atomic number.

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

References G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::elementTable, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::elementTableSize, getIUPACElementName(), INCL_WARN, and Z.

Referenced by getName(), and getShortName().

◆ getFermiMomentumConstant()

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

Return the constant value of the Fermi momentum.

Definition at line 1202 of file G4INCLParticleTable.cc.

                                                                    {
      return constantFermiMomentum;
    }

References G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::constantFermiMomentum.

Referenced by getFermiMomentumConstantLight(), and initialize().

◆ getFermiMomentumConstantLight()

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

References A, clusterTableASize, clusterTableZSize, getFermiMomentumConstant(), G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::momentumRMS, G4INCL::Math::sqrtFiveThirds, and Z.

Referenced by initialize().

◆ getFermiMomentumMassDependent()

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

$p_F(A)=\alpha-\beta\cdot e^{(-A\cdot\gamma)}$

with $\alpha=259.416$ MeV/ $c$ , $\beta=152.824$ MeV/ $c$ and $\gamma=9.5157\cdot10^{-2}$ .

Parameters

A	mass number

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

References A.

Referenced by initialize().

◆ getINCLMass() [1/2]

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

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

Definition at line 809 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
      // Note that S<0 for lambda
      if(Z<0 && S<0)
        return (A+S)*neutronMass - S*LambdaMass - Z*getINCLMass(PiMinus);
      else if(Z>A && S<0)
        return (A+S)*protonMass - S*LambdaMass + (A+S-Z)*getINCLMass(PiPlus);  
      else if(Z<0)
        return (A)*neutronMass - Z*getINCLMass(PiMinus);
      else if(Z>A)
        return (A)*protonMass + (A-Z)*getINCLMass(PiPlus);
      else if(A>1 && S<0)
        return Z*(protonMass - protonSeparationEnergy) + (A+S-Z)*(neutronMass - neutronSeparationEnergy) + std::abs(S)*(LambdaMass - lambdaSeparationEnergy);
      else if(A>1)
        return Z*(protonMass - protonSeparationEnergy) + (A-Z)*(neutronMass - neutronSeparationEnergy);
      else if(A==1 && Z==0 && S==0)
        return getINCLMass(Neutron);
      else if(A==1 && Z==1 && S==0)
        return getINCLMass(Proton);
      else if(A==1 && Z==0 && S==-1)
        return getINCLMass(Lambda);
      else
        return 0.;
    }

References A, getINCLMass(), G4INCL::Lambda, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::LambdaMass, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::lambdaSeparationEnergy, G4INCL::Neutron, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::neutronMass, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::neutronSeparationEnergy, G4INCL::PiMinus, G4INCL::PiPlus, G4INCL::Proton, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::protonMass, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::protonSeparationEnergy, S(), and Z.

Referenced by G4INCL::CrossSectionsMultiPionsAndResonances::etaNToPiN(), G4INCL::DeltaDecayChannel::fillFinalState(), G4INCL::NNToMissingStrangenessChannel::fillFinalState(), G4INCL::NpiToMissingStrangenessChannel::fillFinalState(), G4INCL::PionResonanceDecayChannel::fillFinalState(), G4INCL::SigmaZeroDecayChannel::fillFinalState(), G4INCL::StrangeAbsorbtionChannel::fillFinalState(), G4INCL::Particle::getEmissionQValueCorrection(), G4INCL::Particle::getINCLMass(), getINCLMass(), G4INCL::Particle::getTransferQValueCorrection(), G4INCL::NuclearPotential::NuclearPotentialConstant::initialize(), G4INCL::NuclearPotential::NuclearPotentialIsospin::initialize(), initialize(), and G4INCL::CrossSectionsMultiPionsAndResonances::omegaNToPiN().

◆ getINCLMass() [2/2]

G4double G4INCL::ParticleTable::getINCLMass ( const ParticleType t )

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

Definition at line 680 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 == SigmaPlus) {
        return SigmaPlusMass;
      } else if(pt == SigmaMinus) {
        return SigmaMinusMass;
      } else if(pt == SigmaZero) {
        return SigmaZeroMass;
      } else if(pt == Lambda) {
        return LambdaMass;
      } else if(pt == KPlus) {
        return KPlusMass;
      } else if(pt == KZero) {
        return KZeroMass;
      } else if(pt == KZeroBar) {
        return KZeroBarMass;
      } else if(pt == KMinus) {
        return KMinusMass;
      } else if(pt == KShort) {
        return KShortMass;
      } else if(pt == KLong) {
        return KLongMass;
      } 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;
      }
    }

◆ getIsospin()

G4int G4INCL::ParticleTable::getIsospin ( const ParticleType t )

Get the isospin of a particle.

Definition at line 478 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 == Lambda) {
        return 0;
      } else if(t == SigmaPlus) {
        return 2;
      } else if(t == SigmaZero) {
        return 0;
      } else if(t == SigmaMinus) {
        return -2;
      } else if(t == KPlus) {
        return 1;
      } else if(t == KZero) {
        return -1;
      } else if(t == KZeroBar) {
        return 1;
      } else if(t == KShort) {
        return 0;
      } else if(t == KLong) {
        return 0;
      } else if(t == KMinus) {
        return -1;
      } 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
    }

References G4INCL::DeltaMinus, G4INCL::DeltaPlus, G4INCL::DeltaPlusPlus, G4INCL::DeltaZero, G4INCL::Eta, G4INCL::EtaPrime, INCL_ERROR, G4INCL::KLong, G4INCL::KMinus, G4INCL::KPlus, G4INCL::KShort, G4INCL::KZero, G4INCL::KZeroBar, G4INCL::Lambda, G4INCL::Neutron, G4INCL::Omega, G4INCL::Photon, G4INCL::PiMinus, G4INCL::PiPlus, G4INCL::PiZero, G4INCL::Proton, G4INCL::SigmaMinus, G4INCL::SigmaPlus, and G4INCL::SigmaZero.

◆ getIUPACElementName()

std::string G4INCL::ParticleTable::getIUPACElementName ( const G4int Z )

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

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

References G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::intToIUPAC(), G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform(), and Z.

Referenced by getElementName().

◆ getKaonType()

ParticleType G4INCL::ParticleTable::getKaonType ( const G4int isosp )

Get the type of kaon.

Definition at line 1293 of file G4INCLParticleTable.cc.

                                                {
// assert(isosp == -1 || isosp == 1);
        if (isosp == -1) {
            return KZero;
        }
        else {
            return KPlus;
        }
    }

References G4INCL::KPlus, and G4INCL::KZero.

◆ getLambdaSeparationEnergy()

G4double G4INCL::ParticleTable::getLambdaSeparationEnergy ( )

Definition at line 1141 of file G4INCLParticleTable.cc.

1141{ return lambdaSeparationEnergy; }

References G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::lambdaSeparationEnergy.

◆ getLargestNuclearRadius()

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

Definition at line 993 of file G4INCLParticleTable.cc.

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

References A, getNuclearRadius(), G4INCL::Math::max(), G4INCL::Neutron, G4INCL::Proton, and Z.

Referenced by G4INCL::CoulombNonRelativistic::getCoulombRadius(), G4INCL::CoulombNonRelativistic::maxImpactParameter(), G4INCL::CoulombNone::maxImpactParameter(), and G4INCL::StandardPropagationModel::shootComposite().

◆ getMassNumber()

G4int G4INCL::ParticleTable::getMassNumber ( const ParticleType t )

Get mass number from particle type.

Definition at line 850 of file G4INCLParticleTable.cc.

                                              {
      switch(t) {
        case Proton:
        case Neutron:
        case DeltaPlusPlus:
        case DeltaPlus:
        case DeltaZero:
        case DeltaMinus:
        case SigmaPlus:
        case SigmaZero:
        case SigmaMinus:
        case Lambda:
          return 1;
          break;
        case PiPlus:
        case PiMinus:
        case PiZero:
        case KPlus:
        case KZero:
        case KZeroBar:
        case KShort:
        case KLong:
        case KMinus:
        case Eta:
        case Omega:
        case EtaPrime:
        case Photon:
          return 0;
          break;
        default:
          return 0;
          break;
      }
    }

References G4INCL::DeltaMinus, G4INCL::DeltaPlus, G4INCL::DeltaPlusPlus, G4INCL::DeltaZero, G4INCL::Eta, G4INCL::EtaPrime, G4INCL::KLong, G4INCL::KMinus, G4INCL::KPlus, G4INCL::KShort, G4INCL::KZero, G4INCL::KZeroBar, G4INCL::Lambda, G4INCL::Neutron, G4INCL::Omega, G4INCL::Photon, G4INCL::PiMinus, G4INCL::PiPlus, G4INCL::PiZero, G4INCL::Proton, G4INCL::SigmaMinus, G4INCL::SigmaPlus, and G4INCL::SigmaZero.

◆ getMaximumNuclearRadius()

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

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

References A, getNuclearRadius(), getSurfaceDiffuseness(), INCL_ERROR, and Z.

Referenced by G4INCL::NuclearDensityFactory::createRCDFTable(), G4INCL::NuclearDensityFactory::createRPCorrelationTable(), and G4INCL::INCL::initUniverseRadius().

◆ getMomentumRMS()

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

Return the RMS of the momentum distribution (light clusters)

Definition at line 1097 of file G4INCLParticleTable.cc.

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

References A, getFermiMomentum, G4INCL::Math::sqrtThreeFifths, and Z.

Referenced by G4INCL::NuclearDensityFactory::createPCDFTable().

◆ getName() [1/4]

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

Get the native INCL name of the ion.

Definition at line 549 of file G4INCLParticleTable.cc.

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

References A, getElementName(), and Z.

◆ getName() [2/4]

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

Definition at line 555 of file G4INCLParticleTable.cc.

                                                                   {
      std::stringstream stream;
      if(S >= 0) // S < 0 for hypernuclei
        return getName(A, Z);
      else if(S == -1)
        stream << getElementName(Z) << "-" << A << "_" << "Lambda";
      else
        stream << getElementName(Z) << "-" << A << "_" << S << "-Lambda";
      return stream.str();
    }

References A, getElementName(), getName(), S(), and Z.

◆ getName() [3/4]

std::string G4INCL::ParticleTable::getName ( const ParticleSpecies & s )

Get the native INCL name of the particle.

Definition at line 540 of file G4INCLParticleTable.cc.

                                                 {
      if(sp.theType==Composite && sp.theS == 0)
        return getName(sp.theA,sp.theZ);
      else if(sp.theType==Composite)
        return getName(sp.theA,sp.theZ,sp.theS);
      else
        return getName(sp.theType);
    }

References G4INCL::Composite, getName(), and G4InuclParticleNames::sp.

◆ getName() [4/4]

std::string G4INCL::ParticleTable::getName ( const ParticleType t )

Get the native INCL name of the particle.

Definition at line 574 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::Lambda) {
        return std::string("lambda");
      } else if(p == G4INCL::SigmaPlus) {
        return std::string("sigma+");
      } else if(p == G4INCL::SigmaZero) {
        return std::string("sigma0");
      } else if(p == G4INCL::SigmaMinus) {
        return std::string("sigma-");
      } else if(p == G4INCL::KPlus) {
        return std::string("kaon+");
      } else if(p == G4INCL::KZero) {
        return std::string("kaon0");
      } else if(p == G4INCL::KZeroBar) {
        return std::string("kaon0bar");
      } else if(p == G4INCL::KMinus) {
        return std::string("kaon-");
      } else if(p == G4INCL::KShort) {
        return std::string("kaonshort");
      } else if(p == G4INCL::KLong) {
        return std::string("kaonlong");
      } 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");
    }

References G4INCL::Composite, G4INCL::DeltaMinus, G4INCL::DeltaPlus, G4INCL::DeltaPlusPlus, G4INCL::DeltaZero, G4INCL::Eta, G4INCL::EtaPrime, G4INCL::KLong, G4INCL::KMinus, G4INCL::KPlus, G4INCL::KShort, G4INCL::KZero, G4INCL::KZeroBar, G4INCL::Lambda, G4INCL::Neutron, G4INCL::Omega, G4INCL::Photon, G4INCL::PiMinus, G4INCL::PiPlus, G4INCL::PiZero, G4INCL::Proton, G4INCL::SigmaMinus, G4INCL::SigmaPlus, and G4INCL::SigmaZero.

Referenced by G4INCL::Particle::dump(), getName(), getShortName(), G4INCL::Cluster::print(), G4INCL::Particle::print(), and G4INCL::Config::summary().

◆ getNaturalIsotopicDistribution()

IsotopicDistribution const & G4INCL::ParticleTable::getNaturalIsotopicDistribution ( const G4int Z )

Definition at line 1194 of file G4INCLParticleTable.cc.

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

References G4INCL::NaturalIsotopicDistributions::getIsotopicDistribution(), G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::getNaturalIsotopicDistributions(), and Z.

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

◆ getNeutronHalo()

G4double G4INCL::ParticleTable::getNeutronHalo ( )

Get the size of the neutron halo.

Definition at line 1230 of file G4INCLParticleTable.cc.

1230{ return neutronHalo; }

G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::neutronHalo

G4ThreadLocal G4double neutronHalo

Definition: G4INCLParticleTable.cc:310

References G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::neutronHalo.

◆ getNeutronSeparationEnergy()

G4double G4INCL::ParticleTable::getNeutronSeparationEnergy ( )

Getter for neutronSeparationEnergy.

Definition at line 1139 of file G4INCLParticleTable.cc.

1139{ return neutronSeparationEnergy; }

References G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::neutronSeparationEnergy.

◆ getNeutronSkin()

G4double G4INCL::ParticleTable::getNeutronSkin ( )

Get the thickness of the neutron skin.

Definition at line 1228 of file G4INCLParticleTable.cc.

1228{ return neutronSkin; }

G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::neutronSkin

G4ThreadLocal G4double neutronSkin

Definition: G4INCLParticleTable.cc:309

References G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::neutronSkin.

◆ getNuclearRadius()

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

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

References A, getRadiusParameter(), getSurfaceDiffuseness(), INCL_DEBUG, INCL_ERROR, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::positionRMS, and Z.

Referenced by G4INCL::PauliStandard::getBlockingProbability(), getLargestNuclearRadius(), getMaximumNuclearRadius(), G4INCL::NuclearDensity::getTransmissionRadius(), and G4INCL::INCL::initMaxInteractionDistance().

◆ getNucleonType()

ParticleType G4INCL::ParticleTable::getNucleonType ( const G4int isosp )

Get the type of nucleon.

Definition at line 1253 of file G4INCLParticleTable.cc.

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

References G4INCL::Neutron, and G4INCL::Proton.

◆ getPionType()

ParticleType G4INCL::ParticleTable::getPionType ( const G4int isosp )

Get the type of pion.

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

References G4INCL::PiMinus, G4INCL::PiPlus, and G4INCL::PiZero.

◆ getProtonSeparationEnergy()

G4double G4INCL::ParticleTable::getProtonSeparationEnergy ( )

Getter for protonSeparationEnergy.

Definition at line 1137 of file G4INCLParticleTable.cc.

1137{ return protonSeparationEnergy; }

References G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::protonSeparationEnergy.

◆ getRadiusParameter()

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

Definition at line 997 of file G4INCLParticleTable.cc.

                                                                                    {
// assert(A>0);
      if(A > 19) {
        // radius fit for lambdas
        if(t==Lambda){
         G4double r0 = (1.128+0.439*std::pow(A,-2./3.)) * std::pow(A, 1.0/3.0);
         return r0;
        }
        // phenomenological radius fit
        G4double r0 = (2.745e-4 * A + 1.063) * std::pow(A, 1.0/3.0);
        // HFB calculations
        if(getRPCorrelationCoefficient(t)<1.){
         G4double r0hfb = HFB::getRadiusParameterHFB(t,A,Z);
         if(r0hfb>0.)r0 = r0hfb;
        }
        //
        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 <= 19 && A >= 6) {
        if(t==Lambda){
         G4double r0 = (1.128+0.439*std::pow(A,-2./3.)) * std::pow(A, 1.0/3.0);
         return r0;
        }
        // HFB calculations
        if(getRPCorrelationCoefficient(t)<1.){
         G4double r0hfb = HFB::getSurfaceDiffusenessHFB(t,A,Z);
         if(r0hfb>0.)return r0hfb;
        }
        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;
      }
    }

References A, G4INCL::HFB::getRadiusParameterHFB(), getRPCorrelationCoefficient(), G4INCL::HFB::getSurfaceDiffusenessHFB(), INCL_DEBUG, INCL_ERROR, G4INCL::Lambda, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::mediumRadius, G4INCL::Neutron, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::neutronSkin, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::positionRMS, and Z.

Referenced by G4INCL::NuclearDensityFactory::createRCDFTable(), G4INCL::NuclearDensityFactory::createRPCorrelationTable(), and getNuclearRadius().

◆ getRealMass() [1/2]

G4double G4INCL::ParticleTable::getRealMass ( const G4INCL::ParticleType t )

Get particle mass (in MeV/c^2)

Definition at line 725 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 SigmaPlus:
          return theRealSigmaPlusMass;
          break;
        case SigmaZero:
          return theRealSigmaZeroMass;
          break;
        case SigmaMinus:
          return theRealSigmaMinusMass;
          break;
        case Lambda:
          return theRealLambdaMass;
          break;
        case KPlus:
        case KMinus:
          return theRealChargedKaonMass;
          break;
        case KZero:
        case KZeroBar:
        case KShort:
        case KLong:
          return theRealNeutralKaonMass;
          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;
      }
    }

Referenced by G4INCL::Nucleus::computeTotalEnergy(), G4INCL::EventInfo::fillInverseKinematics(), G4INCL::ClusteringModelIntercomparison::findClusterStartingFrom(), G4INCL::Particle::getRealMass(), getRealMass(), initialize(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaExcluIso(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaIso(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaExcluIso(), G4INCL::CrossSectionsMultiPionsAndResonances::piMinuspToEtaN(), G4INCL::CrossSectionsMultiPionsAndResonances::piMinuspToOmegaN(), G4INCL::ClusterDecay::anonymous_namespace{G4INCLClusterDecay.cc}::threeBodyDecay(), and G4INCL::ClusterDecay::anonymous_namespace{G4INCLClusterDecay.cc}::twoBodyDecay().

◆ getRealMass() [2/2]

G4double G4INCL::ParticleTable::getRealMass	(	const G4int	A,
		const G4int	Z,
		const G4int	S = `0`
	)

Get nuclear mass (in MeV/c^2)

Definition at line 781 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 && S<0)
        return (A+S)*theRealNeutronMass - S*LambdaMass - Z*getRealMass(PiMinus);
      else if(Z>A && S<0)
        return (A+S)*theRealProtonMass - S*LambdaMass + (A+S-Z)*getRealMass(PiPlus);
      if(Z<0)
        return (A)*theRealNeutronMass - Z*getRealMass(PiMinus);
      else if(Z>A)
        return (A)*theRealProtonMass + (A-Z)*getRealMass(PiPlus);
      else if(Z==0 && S==0)
        return A*theRealNeutronMass;
      else if(A==Z)
        return A*theRealProtonMass;
      else if(Z==0 && S<0)
        return (A+S)*theRealNeutronMass-S*LambdaMass;
      else if(A>1) {
#ifndef INCLXX_IN_GEANT4_MODE
        return ::G4INCL::NuclearMassTable::getMass(A,Z,S);
#else
        if(S<0) return theG4IonTable->GetNucleusMass(Z,A,std::abs(S)) / MeV;
        else    return theG4IonTable->GetNucleusMass(Z,A) / MeV;
#endif
      } else
        return 0.;
    }

References A, G4IonTable::GetNucleusMass(), getRealMass(), G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::LambdaMass, MeV, G4INCL::PiMinus, G4INCL::PiPlus, S(), G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::theG4IonTable, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::theRealNeutronMass, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::theRealProtonMass, and Z.

◆ getRPCorrelationCoefficient()

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 1223 of file G4INCLParticleTable.cc.

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

References G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::rpCorrelationCoefficient.

Referenced by getRadiusParameter(), getSurfaceDiffuseness(), and G4INCL::ParticleSampler::ParticleSampler().

◆ getSeparationEnergyINCL()

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

Return INCL's default separation energy.

Definition at line 1102 of file G4INCLParticleTable.cc.

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

References INCL_ERROR, G4INCL::Lambda, G4INCL::Neutron, G4INCL::Proton, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::theINCLLambdaSeparationEnergy, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::theINCLNeutronSeparationEnergy, and G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::theINCLProtonSeparationEnergy.

Referenced by getSeparationEnergyRealForLight(), and initialize().

◆ getSeparationEnergyReal()

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

Return the real separation energy.

Definition at line 1115 of file G4INCLParticleTable.cc.

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

References A, getTableMass, getTableParticleMass, INCL_ERROR, G4INCL::Lambda, G4INCL::Neutron, G4INCL::Proton, and Z.

Referenced by getSeparationEnergyRealForLight(), and initialize().

◆ getSeparationEnergyRealForLight()

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

References A, clusterTableASize, clusterTableZSize, getSeparationEnergyINCL(), getSeparationEnergyReal(), and Z.

Referenced by initialize().

◆ getShortName() [1/3]

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

Get the short INCL name of the ion.

Definition at line 566 of file G4INCLParticleTable.cc.

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

References A, getElementName(), and Z.

◆ getShortName() [2/3]

std::string G4INCL::ParticleTable::getShortName ( const ParticleSpecies & s )

Get the short INCL name of the particle.

Definition at line 531 of file G4INCLParticleTable.cc.

                                                      {
      if(sp.theType==Composite && sp.theS == 0)
        return getShortName(sp.theA,sp.theZ);
      else if(sp.theType==Composite)
        return getName(sp.theA,sp.theZ,sp.theS);
      else
        return getShortName(sp.theType);
    }

References G4INCL::Composite, getName(), getShortName(), and G4InuclParticleNames::sp.

◆ getShortName() [3/3]

std::string G4INCL::ParticleTable::getShortName ( const ParticleType t )

Get the short INCL name of the particle.

Definition at line 627 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::Lambda) {
        return std::string("l");
      } else if(p == G4INCL::SigmaPlus) {
        return std::string("s+");
      } else if(p == G4INCL::SigmaZero) {
        return std::string("s0");
      } else if(p == G4INCL::SigmaMinus) {
        return std::string("s-");
      } else if(p == G4INCL::KPlus) {
        return std::string("k+");
      } else if(p == G4INCL::KZero) {
        return std::string("k0");
      } else if(p == G4INCL::KZeroBar) {
        return std::string("k0b");
      } else if(p == G4INCL::KMinus) {
        return std::string("k-");
      } else if(p == G4INCL::KShort) {
        return std::string("ks");
      } else if(p == G4INCL::KLong) {
        return std::string("kl");
      } 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");
    }

References G4INCL::Composite, G4INCL::DeltaMinus, G4INCL::DeltaPlus, G4INCL::DeltaPlusPlus, G4INCL::DeltaZero, G4INCL::Eta, G4INCL::EtaPrime, G4INCL::KLong, G4INCL::KMinus, G4INCL::KPlus, G4INCL::KShort, G4INCL::KZero, G4INCL::KZeroBar, G4INCL::Lambda, G4INCL::Neutron, G4INCL::Omega, G4INCL::Photon, G4INCL::PiMinus, G4INCL::PiPlus, G4INCL::PiZero, G4INCL::Proton, G4INCL::SigmaMinus, G4INCL::SigmaPlus, and G4INCL::SigmaZero.

Referenced by G4INCL::CoulombNonRelativistic::getCoulombRadius(), and getShortName().

◆ getSigmaType()

ParticleType G4INCL::ParticleTable::getSigmaType ( const G4int isosp )

Get the type of sigma.

Definition at line 1280 of file G4INCLParticleTable.cc.

                                                 {
// assert(isosp == -2 || isosp == 0 || isosp == 2);
        if (isosp == -2) {
            return SigmaMinus;
        }
        else if (isosp == 0) {
            return SigmaZero;
        }
        else {
            return SigmaPlus;
        }
    }

References G4INCL::SigmaMinus, G4INCL::SigmaPlus, and G4INCL::SigmaZero.

◆ getStrangenessNumber()

G4int G4INCL::ParticleTable::getStrangenessNumber ( const ParticleType t )

Get strangeness number from particle type.

Definition at line 924 of file G4INCLParticleTable.cc.

                                                     {
      switch(t) {
        case DeltaPlusPlus:
        case DeltaPlus:
        case DeltaZero:
        case DeltaMinus:
        case Proton:
        case Neutron:
        case PiPlus:
        case PiZero:
        case PiMinus:
        case Eta:
        case Omega:
        case EtaPrime:
        case Photon:
          return 0;
          break;
        case Lambda:
        case SigmaPlus:
        case SigmaZero:
        case SigmaMinus:
        case KZeroBar:
        case KMinus:
          return -1;
          break;
        case KPlus:
        case KZero:
          return 1;
          break;
        case KShort:
          return 0;
          break;
        case KLong:
          return 0;
          break;
        default:
          return 0;
          break;
      }
    }

References G4INCL::DeltaMinus, G4INCL::DeltaPlus, G4INCL::DeltaPlusPlus, G4INCL::DeltaZero, G4INCL::Eta, G4INCL::EtaPrime, G4INCL::KLong, G4INCL::KMinus, G4INCL::KPlus, G4INCL::KShort, G4INCL::KZero, G4INCL::KZeroBar, G4INCL::Lambda, G4INCL::Neutron, G4INCL::Omega, G4INCL::Photon, G4INCL::PiMinus, G4INCL::PiPlus, G4INCL::PiZero, G4INCL::Proton, G4INCL::SigmaMinus, G4INCL::SigmaPlus, and G4INCL::SigmaZero.

◆ getSurfaceDiffuseness()

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

Definition at line 1063 of file G4INCLParticleTable.cc.

                                                                                       {
      if(A > 19) {
        // phenomenological fit
        G4double a = 1.63e-4 * A + 0.510;
        // HFB calculations
        if(getRPCorrelationCoefficient(t)<1.){
          G4double ahfb = HFB::getSurfaceDiffusenessHFB(t,A,Z);
          if(ahfb>0.)a=ahfb;
        }
        //
        if(t==Lambda){
        // Like for neutrons
          G4double ahfb = HFB::getSurfaceDiffusenessHFB(Neutron,A,Z);
          if(ahfb>0.)a=ahfb;
        }
        if(t==Neutron)
          a += neutronHalo;
        return a;
      } else if(A <= 19 && A >= 6) {
        // HFB calculations
        if(getRPCorrelationCoefficient(t)<1.){
          G4double ahfb = HFB::getRadiusParameterHFB(t,A,Z);
          if(ahfb>0.)return ahfb;
        }
        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;
      }
    }

References A, G4INCL::HFB::getRadiusParameterHFB(), getRPCorrelationCoefficient(), G4INCL::HFB::getSurfaceDiffusenessHFB(), INCL_ERROR, G4INCL::Lambda, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::mediumDiffuseness, G4INCL::Neutron, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::neutronHalo, and Z.

Referenced by G4INCL::NuclearDensityFactory::createRCDFTable(), G4INCL::NuclearDensityFactory::createRPCorrelationTable(), getMaximumNuclearRadius(), and getNuclearRadius().

◆ getTableQValue() [1/2]

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

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

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

$(A_1,Z_1) + (A_2, Z_2) --> (A_1+A_2,Z_1+Z_2)$

Definition at line 835 of file G4INCLParticleTable.cc.

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

References getTableMass, and anonymous_namespace{paraMaker.cc}::Z1.

Referenced by G4INCL::Particle::getEmissionQValueCorrection(), and G4INCL::Particle::getTransferQValueCorrection().

◆ getTableQValue() [2/2]

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

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

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

$(A_1,Z_1) + (A_2, Z_2) --> (A_3,Z_3) + (A1+A2-A3,Z1+Z2-Z3)$

Definition at line 839 of file G4INCLParticleTable.cc.

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

References getTableMass, and anonymous_namespace{paraMaker.cc}::Z1.

◆ getTableSpeciesMass()

G4double G4INCL::ParticleTable::getTableSpeciesMass ( const ParticleSpecies & p )

Definition at line 843 of file G4INCLParticleTable.cc.

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

References G4INCL::Composite, getTableMass, getTableParticleMass, G4INCL::ParticleSpecies::theA, G4INCL::ParticleSpecies::theS, G4INCL::ParticleSpecies::theType, and G4INCL::ParticleSpecies::theZ.

Referenced by G4INCL::CoulombNonRelativistic::minimumDistance().

◆ getWidth()

G4double G4INCL::ParticleTable::getWidth ( const ParticleType t )

Get particle width (in s)

Definition at line 1313 of file G4INCLParticleTable.cc.

                                             {
// assert(pt == PiPlus || pt == PiMinus || pt == PiZero || pt == Eta || pt == Omega || pt == EtaPrime || pt == KShort || pt == KLong || pt== KPlus || pt == KMinus || pt == Lambda || pt == SigmaPlus || pt == SigmaZero || pt == SigmaMinus);
          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 if(pt == SigmaPlus) {
              return SigmaPlusWidth;
          } else if(pt == SigmaZero) {
              return SigmaZeroWidth;
          } else if(pt == SigmaMinus) {
              return SigmaMinusWidth;
          } else if(pt == KPlus) {
              return KPlusWidth;
          } else if(pt == KMinus) {
              return KMinusWidth;
          } else if(pt == KShort) {
              return KShortWidth;
          } else if(pt == KLong) {
              return KLongWidth;
          } else {
              INCL_ERROR("getWidth : Unknown particle type." << '\n');
              return 0.0;
          }
      }

Referenced by G4INCL::SigmaZeroDecayChannel::computeDecayTime(), G4INCL::Nucleus::decayOutgoingPionResonances(), and G4INCL::Nucleus::decayOutgoingSigmaZero().

◆ initialize()

void G4INCL::ParticleTable::initialize ( Config const *const theConfig = 0 )

Initialize the particle table.

Definition at line 336 of file G4INCLParticleTable.cc.

                                                      {
      protonMass = theINCLNucleonMass;
      neutronMass = theINCLNucleonMass;
      piPlusMass = theINCLPionMass;
      piMinusMass = theINCLPionMass;
      piZeroMass = theINCLPionMass;
      /*
      SigmaPlusMass = theINCLSigmaMass;
      SigmaMinusMass = theINCLSigmaMass;
      SigmaZeroMass = theINCLSigmaMass;
      LambdaMass = theINCLLambdaMass;
      KPlusMass = theINCLKaonMass;
      KZeroMass = theINCLKaonMass;
      KZeroBarMass = theINCLKaonMass;
      KShortMass = theINCLKaonMass;
      KLongMass = theINCLKaonMass;
      KMinusMass = theINCLKaonMass;
      */
      SigmaPlusMass = theRealSigmaPlusMass;
      SigmaMinusMass = theRealSigmaMinusMass;
      SigmaZeroMass = theRealSigmaZeroMass;
      LambdaMass = theINCLLambdaMass;
      KPlusMass = theRealChargedKaonMass;
      KZeroMass = theRealNeutralKaonMass;
      KZeroBarMass = theRealNeutralKaonMass;
      KShortMass = theRealNeutralKaonMass;
      KLongMass = theRealNeutralKaonMass;
      KMinusMass = theRealChargedKaonMass;
      
      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;
      theRealSigmaPlusMass = theG4ParticleTable->FindParticle("sigma+")->GetPDGMass() / MeV;
      theRealSigmaZeroMass = theG4ParticleTable->FindParticle("sigma0")->GetPDGMass() / MeV;
      theRealSigmaMinusMass = theG4ParticleTable->FindParticle("sigma-")->GetPDGMass() / MeV;
      theRealLambdaMass = theG4ParticleTable->FindParticle("lambda")->GetPDGMass() / MeV;
      theRealChargedKaonMass = theG4ParticleTable->FindParticle("kaon+")->GetPDGMass() / MeV;
      theRealNeutralKaonMass = theG4ParticleTable->FindParticle("kaon0")->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;
      
      SigmaMinusWidth = theSigmaMinusWidth;
      SigmaPlusWidth = theSigmaPlusWidth;
      SigmaZeroWidth = theSigmaZeroWidth;
      LambdaWidth = theLambdaWidth;
      KPlusWidth = theChargedKaonWidth;
      KMinusWidth = theChargedKaonWidth;
      KShortWidth = theKShortWidth;
      KLongWidth = theKLongWidth;
        
      // Initialise HFB tables
#ifdef INCLXX_IN_GEANT4_MODE
        HFB::initialize();
#else
        HFB::initialize(dataFilePath);
#endif
 
      // 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();
      }
 
    }

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

◆ parseElement()

G4int G4INCL::ParticleTable::parseElement ( std::string pS )

Get the name of the element from the atomic number.

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

References G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::elementTable, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::elementTableSize, parseIUPACElement(), and G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform().

Referenced by G4INCL::ParticleSpecies::parseElement().

◆ parseIUPACElement()

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 1180 of file G4INCLParticleTable.cc.

                                                  {
      // Normalise to lower case
      std::string elementName(sel);
      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;
    }

References G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::elementIUPACDigits, G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::iupacToInt(), G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform(), and Z.

Referenced by G4INCL::ParticleSpecies::parseElement(), parseElement(), and G4INCL::ParticleSpecies::parseIUPACElement().

◆ setLambdaSeparationEnergy()

void G4INCL::ParticleTable::setLambdaSeparationEnergy ( const G4double sen )

Definition at line 1147 of file G4INCLParticleTable.cc.

1147{ lambdaSeparationEnergy = sen; }

References G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::lambdaSeparationEnergy.

◆ setNeutronSeparationEnergy()

void G4INCL::ParticleTable::setNeutronSeparationEnergy ( const G4double s )

Setter for protonSeparationEnergy.

Definition at line 1145 of file G4INCLParticleTable.cc.

1145{ neutronSeparationEnergy = sen; }

References G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::neutronSeparationEnergy.

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

◆ setProtonSeparationEnergy()

void G4INCL::ParticleTable::setProtonSeparationEnergy ( const G4double s )

Setter for protonSeparationEnergy.

Definition at line 1143 of file G4INCLParticleTable.cc.

1143{ protonSeparationEnergy = sen; }

References G4INCL::ParticleTable::anonymous_namespace{G4INCLParticleTable.cc}::protonSeparationEnergy.

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

Variable Documentation

◆ clusterTableASize

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

Definition at line 66 of file G4INCLParticleTable.hh.

Referenced by getFermiMomentumConstantLight(), getSeparationEnergyRealForLight(), G4INCL::ClusterDecay::anonymous_namespace{G4INCLClusterDecay.cc}::phaseSpaceDecay(), and G4INCL::ClusterDecay::anonymous_namespace{G4INCLClusterDecay.cc}::recursiveDecay().

◆ clusterTableSSize

const G4int G4INCL::ParticleTable::clusterTableSSize = 4

Definition at line 67 of file G4INCLParticleTable.hh.

Referenced by G4INCL::ClusterDecay::anonymous_namespace{G4INCLClusterDecay.cc}::recursiveDecay().

◆ clusterTableZSize

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

Definition at line 65 of file G4INCLParticleTable.hh.

Referenced by getFermiMomentumConstantLight(), getSeparationEnergyRealForLight(), G4INCL::ClusterDecay::anonymous_namespace{G4INCLClusterDecay.cc}::phaseSpaceDecay(), and G4INCL::ClusterDecay::anonymous_namespace{G4INCLClusterDecay.cc}::recursiveDecay().

◆ effectiveAntiKaonMass

const G4double G4INCL::ParticleTable::effectiveAntiKaonMass = 497.614

Definition at line 77 of file G4INCLParticleTable.hh.

◆ effectiveDeltaMass

const G4double G4INCL::ParticleTable::effectiveDeltaMass = 1232.0

Definition at line 71 of file G4INCLParticleTable.hh.

Referenced by initialize(), G4INCL::DeltaProductionChannel::sampleDeltaMass(), G4INCL::NDeltaEtaProductionChannel::sampleDeltaMass(), G4INCL::NDeltaOmegaProductionChannel::sampleDeltaMass(), G4INCL::NDeltaToDeltaLKChannel::sampleDeltaMass(), and G4INCL::NDeltaToDeltaSKChannel::sampleDeltaMass().

◆ effectiveDeltaWidth

const G4double G4INCL::ParticleTable::effectiveDeltaWidth = 130.0

Definition at line 72 of file G4INCLParticleTable.hh.

Referenced by initialize(), G4INCL::DeltaProductionChannel::sampleDeltaMass(), G4INCL::NDeltaEtaProductionChannel::sampleDeltaMass(), G4INCL::NDeltaOmegaProductionChannel::sampleDeltaMass(), G4INCL::NDeltaToDeltaLKChannel::sampleDeltaMass(), and G4INCL::NDeltaToDeltaSKChannel::sampleDeltaMass().

◆ effectiveEtaMass

const G4double G4INCL::ParticleTable::effectiveEtaMass = 547.862

Definition at line 78 of file G4INCLParticleTable.hh.

◆ effectiveEtaPrimeMass

const G4double G4INCL::ParticleTable::effectiveEtaPrimeMass = 957.78

Definition at line 80 of file G4INCLParticleTable.hh.

◆ effectiveKaonMass

const G4double G4INCL::ParticleTable::effectiveKaonMass = 497.614

Definition at line 76 of file G4INCLParticleTable.hh.

Referenced by G4INCL::NDeltaToDeltaLKChannel::sampleDeltaMass(), and G4INCL::NDeltaToDeltaSKChannel::sampleDeltaMass().

◆ effectiveLambdaMass

const G4double G4INCL::ParticleTable::effectiveLambdaMass = 1115.683

Definition at line 74 of file G4INCLParticleTable.hh.

Referenced by G4INCL::NDeltaToDeltaLKChannel::sampleDeltaMass().

◆ effectiveNucleonMass

const G4double G4INCL::ParticleTable::effectiveNucleonMass = 938.2796

Definition at line 69 of file G4INCLParticleTable.hh.

◆ effectiveNucleonMass2

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

Definition at line 70 of file G4INCLParticleTable.hh.

Referenced by G4INCL::BystrickyEvaluator< N >::eval(), G4INCL::DeltaProductionChannel::fillFinalState(), G4INCL::CrossSectionsINCL46::NDeltaToNN(), and G4INCL::CrossSectionsMultiPions::NDeltaToNN().

◆ effectiveOmegaMass

const G4double G4INCL::ParticleTable::effectiveOmegaMass = 782.65

Definition at line 79 of file G4INCLParticleTable.hh.

◆ effectivePhotonMass

const G4double G4INCL::ParticleTable::effectivePhotonMass = 0.0

Definition at line 81 of file G4INCLParticleTable.hh.

◆ effectivePionMass

const G4double G4INCL::ParticleTable::effectivePionMass = 138.0

Definition at line 73 of file G4INCLParticleTable.hh.

Referenced by G4INCL::DeltaDecayChannel::computeDecayTime(), and G4INCL::CrossSectionsINCL46::NNToNDelta().

◆ effectiveSigmaMass

const G4double G4INCL::ParticleTable::effectiveSigmaMass = 1197.45

Definition at line 75 of file G4INCLParticleTable.hh.

Referenced by G4INCL::NDeltaToDeltaSKChannel::sampleDeltaMass().

◆ getFermiMomentum

G4ThreadLocal FermiMomentumFn G4INCL::ParticleTable::getFermiMomentum = NULL

Definition at line 1238 of file G4INCLParticleTable.cc.

Referenced by G4INCL::NuclearDensityFactory::createPCDFTable(), getMomentumRMS(), G4INCL::NuclearPotential::NuclearPotentialConstant::initialize(), G4INCL::NuclearPotential::NuclearPotentialIsospin::initialize(), and initialize().

◆ getSeparationEnergy

G4ThreadLocal SeparationEnergyFn G4INCL::ParticleTable::getSeparationEnergy = NULL

Static pointer to the separation-energy function.

Definition at line 1237 of file G4INCLParticleTable.cc.

Referenced by G4INCL::NuclearPotential::NuclearPotentialConstant::initialize(), G4INCL::NuclearPotential::NuclearPotentialIsospin::initialize(), and initialize().

◆ getTableMass

G4ThreadLocal NuclearMassFn G4INCL::ParticleTable::getTableMass = NULL

Static pointer to the mass function for nuclei.

Definition at line 1235 of file G4INCLParticleTable.cc.

Referenced by G4INCL::ProjectileRemnant::addAllDynamicalSpectators(), G4INCL::ProjectileRemnant::addDynamicalSpectator(), G4INCL::ProjectileRemnant::addMostDynamicalSpectators(), G4INCL::Nucleus::computeRecoilKinematics(), G4INCL::ParticleEntryChannel::fillFinalState(), G4INCL::Nucleus::finalizeProjectileRemnant(), G4INCL::KinematicsUtils::gammaFromKineticEnergy(), G4INCL::Nucleus::getConservationBalance(), G4INCL::Particle::getEmissionQValueCorrection(), getSeparationEnergyReal(), G4INCL::Particle::getTableMass(), getTableQValue(), getTableSpeciesMass(), initialize(), G4INCL::INCL::makeCompoundNucleus(), G4INCL::INCL::RecoilCMFunctor::scaleParticleCMMomenta(), G4INCL::INCL::RecoilFunctor::scaleParticleEnergies(), G4INCL::StandardPropagationModel::shootComposite(), and G4INCL::StandardPropagationModel::shootParticle().

◆ getTableParticleMass

G4ThreadLocal ParticleMassFn G4INCL::ParticleTable::getTableParticleMass = NULL

Static pointer to the mass function for particles.

Definition at line 1236 of file G4INCLParticleTable.cc.

Referenced by G4INCL::KinematicsUtils::gammaFromKineticEnergy(), getSeparationEnergyReal(), G4INCL::Particle::getTableMass(), getTableSpeciesMass(), initialize(), and G4INCL::StandardPropagationModel::shootParticle().

◆ maxClusterCharge

const G4int G4INCL::ParticleTable::maxClusterCharge = 8

Definition at line 63 of file G4INCLParticleTable.hh.

◆ maxClusterMass

const G4int G4INCL::ParticleTable::maxClusterMass = 12

Definition at line 62 of file G4INCLParticleTable.hh.

Referenced by G4INCL::ClusteringModelIntercomparison::ClusteringModelIntercomparison().

◆ minDeltaMass

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

Definition at line 1232 of file G4INCLParticleTable.cc.

Referenced by G4INCL::InteractionAvatar::enforceEnergyConservation(), initialize(), G4INCL::InteractionAvatar::postInteraction(), G4INCL::DeltaProductionChannel::sampleDeltaMass(), G4INCL::NDeltaEtaProductionChannel::sampleDeltaMass(), G4INCL::NDeltaOmegaProductionChannel::sampleDeltaMass(), G4INCL::NDeltaToDeltaLKChannel::sampleDeltaMass(), G4INCL::NDeltaToDeltaSKChannel::sampleDeltaMass(), and G4INCL::InteractionAvatar::ViolationEEnergyFunctor::setParticleEnergy().

◆ minDeltaMass2

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

Definition at line 1233 of file G4INCLParticleTable.cc.

Referenced by initialize(), and G4INCL::InteractionAvatar::ViolationEEnergyFunctor::setParticleEnergy().

◆ minDeltaMassRndm

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

Definition at line 1234 of file G4INCLParticleTable.cc.

Referenced by initialize(), G4INCL::DeltaProductionChannel::sampleDeltaMass(), G4INCL::NDeltaEtaProductionChannel::sampleDeltaMass(), G4INCL::NDeltaOmegaProductionChannel::sampleDeltaMass(), G4INCL::NDeltaToDeltaLKChannel::sampleDeltaMass(), and G4INCL::NDeltaToDeltaSKChannel::sampleDeltaMass().

Namespaces

Typedefs

Functions

Variables

Typedef Documentation

◆ FermiMomentumFn

◆ NuclearMassFn

◆ ParticleMassFn

◆ SeparationEnergyFn

Function Documentation

◆ drawRandomNaturalIsotope()

◆ getAntiKaonType()

◆ getChargeNumber()

◆ getDeltaType()

◆ getElementName()

◆ getFermiMomentumConstant()

◆ getFermiMomentumConstantLight()

◆ getFermiMomentumMassDependent()

◆ getINCLMass() [1/2]

◆ getINCLMass() [2/2]

◆ getIsospin()

◆ getIUPACElementName()

◆ getKaonType()

◆ getLambdaSeparationEnergy()

◆ getLargestNuclearRadius()

◆ getMassNumber()

◆ getMaximumNuclearRadius()

◆ getMomentumRMS()

◆ getName() [1/4]

◆ getName() [2/4]

◆ getName() [3/4]

◆ getName() [4/4]

◆ getNaturalIsotopicDistribution()

◆ getNeutronHalo()

◆ getNeutronSeparationEnergy()

◆ getNeutronSkin()

◆ getNuclearRadius()

◆ getNucleonType()

◆ getPionType()

◆ getProtonSeparationEnergy()

◆ getRadiusParameter()

◆ getRealMass() [1/2]

◆ getRealMass() [2/2]

◆ getRPCorrelationCoefficient()

◆ getSeparationEnergyINCL()

◆ getSeparationEnergyReal()

◆ getSeparationEnergyRealForLight()

◆ getShortName() [1/3]

◆ getShortName() [2/3]

◆ getShortName() [3/3]

◆ getSigmaType()

◆ getStrangenessNumber()

◆ getSurfaceDiffuseness()

◆ getTableQValue() [1/2]

◆ getTableQValue() [2/2]

◆ getTableSpeciesMass()

◆ getWidth()

◆ initialize()

◆ parseElement()

◆ parseIUPACElement()

◆ setLambdaSeparationEnergy()

◆ setNeutronSeparationEnergy()

◆ setProtonSeparationEnergy()

Variable Documentation

◆ clusterTableASize

◆ clusterTableSSize

◆ clusterTableZSize

◆ effectiveAntiKaonMass

◆ effectiveDeltaMass

◆ effectiveDeltaWidth

◆ effectiveEtaMass

◆ effectiveEtaPrimeMass

◆ effectiveKaonMass

◆ effectiveLambdaMass

◆ effectiveNucleonMass

◆ effectiveNucleonMass2

◆ effectiveOmegaMass

◆ effectivePhotonMass

◆ effectivePionMass

◆ effectiveSigmaMass