Geant4 11.2.2
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Typedefs | Functions | Variables
G4INCL::ParticleTable Namespace Reference

Typedefs

typedef G4double(* NuclearMassFn) (const G4int, 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.
 
G4int getIsospin (const ParticleType t)
 Get the isospin of a particle.
 
std::string getName (const ParticleType t)
 Get the native INCL name of the particle.
 
std::string getShortName (const ParticleType t)
 Get the short INCL name of the particle.
 
std::string getName (const ParticleSpecies &s)
 Get the native INCL name of the particle.
 
std::string getShortName (const ParticleSpecies &s)
 Get the short INCL name of the particle.
 
std::string getName (const G4int A, const G4int Z)
 Get the native INCL name of the ion.
 
std::string getName (const G4int A, const G4int Z, const G4int S)
 Get the native INCL name of the ion.
 
std::string getShortName (const G4int A, const G4int Z)
 Get the short INCL name of the ion.
 
G4double getINCLMass (const G4int A, const G4int Z, const G4int S)
 Get INCL nuclear mass (in MeV/c^2)
 
G4double getINCLMass (const ParticleType t)
 Get INCL particle mass (in MeV/c^2)
 
G4double getRealMass (const G4INCL::ParticleType t)
 Get particle mass (in MeV/c^2)
 
G4double getRealMass (const G4int A, const G4int Z, const G4int S=0)
 Get nuclear mass (in MeV/c^2)
 
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)
 
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)
 
G4double getTableSpeciesMass (const ParticleSpecies &p)
 
G4int getMassNumber (const ParticleType t)
 Get mass number from particle type.
 
G4int getChargeNumber (const ParticleType t)
 Get charge number from particle type.
 
G4int getStrangenessNumber (const ParticleType t)
 Get strangeness number from particle type.
 
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)
 
G4double getSeparationEnergyINCL (const ParticleType t, const G4int, const G4int)
 Return INCL's default separation energy.
 
G4double getSeparationEnergyReal (const ParticleType t, const G4int A, const G4int Z)
 Return the real separation energy.
 
G4double getSeparationEnergyRealForLight (const ParticleType t, const G4int A, const G4int Z)
 Return the real separation energy only for light nuclei.
 
G4double getProtonSeparationEnergy ()
 Getter for protonSeparationEnergy.
 
G4double getNeutronSeparationEnergy ()
 Getter for neutronSeparationEnergy.
 
void setProtonSeparationEnergy (const G4double s)
 Setter for protonSeparationEnergy.
 
void setNeutronSeparationEnergy (const G4double s)
 Setter for protonSeparationEnergy.
 
std::string getElementName (const G4int Z)
 Get the name of the element from the atomic number.
 
std::string getIUPACElementName (const G4int Z)
 Get the name of an unnamed element from the IUPAC convention.
 
G4int parseElement (std::string pS)
 Get the name of the element from the atomic number.
 
G4int parseIUPACElement (std::string const &pS)
 Parse a IUPAC element name.
 
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.
 
G4double getFermiMomentumConstantLight (const G4int A, const G4int Z)
 Return the constant value of the Fermi momentum - special for light.
 
G4double getFermiMomentumMassDependent (const G4int A, const G4int)
 Return the value Fermi momentum from a fit.
 
G4double getRPCorrelationCoefficient (const ParticleType t)
 Get the value of the r-p correlation coefficient.
 
G4double getNeutronSkin ()
 Get the thickness of the neutron skin.
 
G4double getNeutronHalo ()
 Get the size of the neutron halo.
 
ParticleType getPionType (const G4int isosp)
 Get the type of pion.
 
ParticleType getNucleonType (const G4int isosp)
 Get the type of nucleon.
 
ParticleType getDeltaType (const G4int isosp)
 Get the type of delta.
 
ParticleType getSigmaType (const G4int isosp)
 Get the type of sigma.
 
ParticleType getKaonType (const G4int isosp)
 Get the type of kaon.
 
ParticleType getAntiKaonType (const G4int isosp)
 Get the type of antikaon.
 
ParticleType getXiType (const G4int isosp)
 Get the type of xi.
 
ParticleType getAntiNucleonType (const G4int isosp)
 Get the type of antinucleon.
 
ParticleType getAntiXiType (const G4int isosp)
 Get the type of antidelta.
 
ParticleType getAntiSigmaType (const G4int isosp)
 Get the type of antisigma.
 
G4double getWidth (const ParticleType t)
 Get particle width (in s)
 
G4double getLambdaSeparationEnergy ()
 
void setLambdaSeparationEnergy (const G4double sen)
 

Variables

const G4int maxClusterMass = 12
 
const G4int maxClusterCharge = 8
 
const G4int clusterTableZSize = maxClusterCharge+1
 
const G4int clusterTableASize = maxClusterMass+1
 
const G4int clusterTableSSize = 4
 
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 effectiveLambdaMass = 1115.683
 
const G4double effectiveSigmaMass = 1197.45
 
const G4double effectiveXiMass = 1321.71
 
const G4double effectiveKaonMass = 497.614
 
const G4double effectiveAntiKaonMass = 497.614
 
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.
 
G4ThreadLocal ParticleMassFn getTableParticleMass = NULL
 Static pointer to the mass function for particles.
 
G4ThreadLocal SeparationEnergyFn getSeparationEnergy = NULL
 Static pointer to the separation-energy function.
 
G4ThreadLocal FermiMomentumFn getFermiMomentum = NULL
 

Typedef Documentation

◆ FermiMomentumFn

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

Definition at line 235 of file G4INCLParticleTable.hh.

◆ NuclearMassFn

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

Definition at line 222 of file G4INCLParticleTable.hh.

◆ ParticleMassFn

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

Definition at line 223 of file G4INCLParticleTable.hh.

◆ SeparationEnergyFn

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

Definition at line 230 of file G4INCLParticleTable.hh.

Function Documentation

◆ drawRandomNaturalIsotope()

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

Definition at line 1400 of file G4INCLParticleTable.cc.

1400 {
1401 return getNaturalIsotopicDistributions()->drawRandomIsotope(Z);
1402 }

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

◆ getAntiKaonType()

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

Get the type of antikaon.

Definition at line 1547 of file G4INCLParticleTable.cc.

1547 {
1548// assert(isosp == -1 || isosp == 1);
1549 if (isosp == -1) {
1550 return KMinus;
1551 }
1552 else {
1553 return KZeroBar;
1554 }
1555 }

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

◆ getAntiNucleonType()

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

Get the type of antinucleon.

◆ getAntiSigmaType()

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

Get the type of antisigma.

Definition at line 1514 of file G4INCLParticleTable.cc.

1514 {
1515// assert(isosp == -2 || isosp == 0 || isosp == 2);
1516 if (isosp == -2) {
1517 return antiSigmaPlus;
1518 }
1519 else if (isosp == 0) {
1520 return antiSigmaZero;
1521 }
1522 else {
1523 return antiSigmaMinus;
1524 }
1525 }

◆ getAntiXiType()

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

Get the type of antidelta.

Definition at line 1527 of file G4INCLParticleTable.cc.

1527 {
1528// assert(isosp == -1 || isosp == 1);
1529 if (isosp == -1) {
1530 return antiXiZero;
1531 }
1532 else {
1533 return antiXiMinus;
1534 }
1535 }

◆ getChargeNumber()

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

Get charge number from particle type.

Definition at line 1061 of file G4INCLParticleTable.cc.

1061 {
1062 switch(t) {
1063 case DeltaPlusPlus:
1064 return 2;
1065 break;
1066 case Proton:
1067 case DeltaPlus:
1068 case PiPlus:
1069 case SigmaPlus:
1070 case KPlus:
1071 case antiSigmaMinus:
1072 case antiXiMinus:
1073 return 1;
1074 break;
1075 case Neutron:
1076 case DeltaZero:
1077 case PiZero:
1078 case SigmaZero:
1079 case Lambda:
1080 case KZero:
1081 case KZeroBar:
1082 case KShort:
1083 case KLong:
1084 case Eta:
1085 case Omega:
1086 case EtaPrime:
1087 case Photon:
1088 case XiZero:
1089 case antiNeutron:
1090 case antiLambda:
1091 case antiSigmaZero:
1092 case antiXiZero:
1093 return 0;
1094 break;
1095 case DeltaMinus:
1096 case PiMinus:
1097 case SigmaMinus:
1098 case KMinus:
1099 case antiProton:
1100 case XiMinus:
1101 case antiSigmaPlus:
1102 return -1;
1103 break;
1104 default:
1105 return 0;
1106 break;
1107 }
1108 }

◆ getDeltaType()

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

Get the type of delta.

Definition at line 1465 of file G4INCLParticleTable.cc.

1465 {
1466// assert(isosp == -3 || isosp == -1 || isosp == 1 || isosp == 3);
1467 if (isosp == -3) {
1468 return DeltaMinus;
1469 }
1470 else if (isosp == -1) {
1471 return DeltaZero;
1472 }
1473 else if (isosp == 1) {
1474 return DeltaPlus;
1475 }
1476 else {
1477 return DeltaPlusPlus;
1478 }
1479 }

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

1351 {
1352 if(Z<1) {
1353 INCL_WARN("getElementName called with Z<1" << '\n');
1354 return elementTable[0];
1355 } else if(Z<elementTableSize)
1356 return elementTable[Z];
1357 else
1358 return getIUPACElementName(Z);
1359 }
INCL_WARN
#define INCL_WARN(x)
Definition G4INCLLogger.hh:232

Referenced by getName(), getName(), and getShortName().

◆ getFermiMomentumConstant()

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

Return the constant value of the Fermi momentum.

Definition at line 1404 of file G4INCLParticleTable.cc.

1404 {
1405 return constantFermiMomentum;
1406 }

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
Amass number
Zcharge number

Definition at line 1408 of file G4INCLParticleTable.cc.

1408 {
1409// assert(Z>0 && A>0 && Z<=A);
1410 if(Z<clusterTableZSize && A<clusterTableASize) {
1411 const G4double rms = momentumRMS[Z][A];
1412 return ((rms>0.) ? rms : momentumRMS[6][12]) * Math::sqrtFiveThirds;
1413 } else
1414 return getFermiMomentumConstant(A,Z);
1415 }
G4double
double G4double
Definition G4Types.hh:83
A
const G4double A[17]
Definition G4WaterStopping.cc:53

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
Amass number

Definition at line 1417 of file G4INCLParticleTable.cc.

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

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

972 {
973// assert(A>=0);
974 // For nuclei with Z<0 or Z>A, assume that the exotic charge state is due to pions
975 // Note that S<0 for lambda
976 if(Z<0 && S<0)
977 return (A+S)*neutronMass - S*LambdaMass - Z*getINCLMass(PiMinus);
978 else if(Z>A && S<0)
979 return (A+S)*protonMass - S*LambdaMass + (A+S-Z)*getINCLMass(PiPlus);
980 else if(Z<0)
981 return (A)*neutronMass - Z*getINCLMass(PiMinus);
982 else if(Z>A)
983 return (A)*protonMass + (A-Z)*getINCLMass(PiPlus);
984 else if(A>1 && S<0)
985 return Z*(protonMass - protonSeparationEnergy) + (A+S-Z)*(neutronMass - neutronSeparationEnergy) + std::abs(S)*(LambdaMass - lambdaSeparationEnergy);
986 else if(A>1)
987 return Z*(protonMass - protonSeparationEnergy) + (A-Z)*(neutronMass - neutronSeparationEnergy);
988 else if(A==1 && Z==0 && S==0)
989 return getINCLMass(Neutron);
990 else if(A==1 && Z==1 && S==0)
991 return getINCLMass(Proton);
992 else if(A==1 && Z==0 && S==-1)
993 return getINCLMass(Lambda);
994 else
995 return 0.;
996 }
S
G4double S(G4double temp)
Definition G4DNAElectronHoleRecombination.cc:79
G4INCL::ParticleTable::getINCLMass
G4double getINCLMass(const G4int A, const G4int Z, const G4int S)
Get INCL nuclear mass (in MeV/c^2)
Definition G4INCLParticleTable.cc:972

Referenced by G4INCL::Nucleus::computeTotalEnergy(), G4INCL::CrossSectionsMultiPionsAndResonances::etaNToPiN(), G4INCL::DeltaDecayChannel::fillFinalState(), G4INCL::NNToMissingStrangenessChannel::fillFinalState(), G4INCL::NpiToMissingStrangenessChannel::fillFinalState(), G4INCL::PionResonanceDecayChannel::fillFinalState(), G4INCL::SigmaZeroDecayChannel::fillFinalState(), G4INCL::StrangeAbsorbtionChannel::fillFinalState(), G4INCL::Particle::getEmissionPbarQvalueCorrection(), G4INCL::Particle::getEmissionQValueCorrection(), G4INCL::Particle::getEmissionQValueCorrection(), G4INCL::Particle::getINCLMass(), getINCLMass(), G4INCL::Particle::getTransferQValueCorrection(), G4INCL::Particle::getTransferQValueCorrection(), initialize(), G4INCL::CrossSectionsMultiPionsAndResonances::omegaNToPiN(), and G4INCL::PbarAtrestEntryChannel::PbarCoulombicCascadeEnergy().

◆ getINCLMass() [2/2]

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

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

Definition at line 793 of file G4INCLParticleTable.cc.

793 {
794 if(pt == Proton) {
795 return protonMass;
796 } else if(pt == Neutron) {
797 return neutronMass;
798 } else if(pt == PiPlus) {
799 return piPlusMass;
800 } else if(pt == PiMinus) {
801 return piMinusMass;
802 } else if(pt == PiZero) {
803 return piZeroMass;
804 } else if(pt == SigmaPlus) {
805 return SigmaPlusMass;
806 } else if(pt == SigmaMinus) {
807 return SigmaMinusMass;
808 } else if(pt == SigmaZero) {
809 return SigmaZeroMass;
810 } else if(pt == Lambda) {
811 return LambdaMass;
812 } else if(pt == antiProton) {
813 return antiProtonMass;
814 } else if(pt == XiMinus) {
815 return XiMinusMass;
816 } else if(pt == XiZero) {
817 return XiZeroMass;
818 } else if(pt == antiNeutron) {
819 return antiNeutronMass;
820 } else if(pt == antiSigmaPlus) {
821 return antiSigmaPlusMass;
822 } else if(pt == antiSigmaMinus) {
823 return antiSigmaMinusMass;
824 } else if(pt == antiSigmaZero) {
825 return antiSigmaZeroMass;
826 } else if(pt == antiLambda) {
827 return antiLambdaMass;
828 } else if(pt == antiXiMinus) {
829 return antiXiMinusMass;
830 } else if(pt == antiXiZero) {
831 return antiXiZeroMass;
832 } else if(pt == KPlus) {
833 return KPlusMass;
834 } else if(pt == KZero) {
835 return KZeroMass;
836 } else if(pt == KZeroBar) {
837 return KZeroBarMass;
838 } else if(pt == KMinus) {
839 return KMinusMass;
840 } else if(pt == KShort) {
841 return KShortMass;
842 } else if(pt == KLong) {
843 return KLongMass;
844 } else if(pt == Eta) {
845 return etaMass;
846 } else if(pt == Omega) {
847 return omegaMass;
848 } else if(pt == EtaPrime) {
849 return etaPrimeMass;
850 } else if(pt == Photon) {
851 return photonMass;
852 } else {
853 INCL_ERROR("getMass : Unknown particle type." << '\n');
854 return 0.0;
855 }
856 }
INCL_ERROR
#define INCL_ERROR(x)
Definition G4INCLLogger.hh:225

◆ getIsospin()

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

Get the isospin of a particle.

Definition at line 531 of file G4INCLParticleTable.cc.

531 {
532 // Actually this is the 3rd component of isospin (I_z) multiplied by 2!
533 if(t == Proton) {
534 return 1;
535 } else if(t == Neutron) {
536 return -1;
537 } else if(t == PiPlus) {
538 return 2;
539 } else if(t == PiMinus) {
540 return -2;
541 } else if(t == PiZero) {
542 return 0;
543 } else if(t == DeltaPlusPlus) {
544 return 3;
545 } else if(t == DeltaPlus) {
546 return 1;
547 } else if(t == DeltaZero) {
548 return -1;
549 } else if(t == DeltaMinus) {
550 return -3;
551 } else if(t == Lambda) {
552 return 0;
553 } else if(t == SigmaPlus) {
554 return 2;
555 } else if(t == SigmaZero) {
556 return 0;
557 } else if(t == SigmaMinus) {
558 return -2;
559 } else if(t == KPlus) {
560 return 1;
561 } else if(t == KZero) {
562 return -1;
563 } else if(t == KZeroBar) {
564 return 1;
565 } else if(t == KShort) {
566 return 0;
567 } else if(t == KLong) {
568 return 0;
569 } else if(t == KMinus) {
570 return -1;
571 } else if(t == Eta) {
572 return 0;
573 } else if(t == Omega) {
574 return 0;
575 } else if(t == EtaPrime) {
576 return 0;
577 } else if(t == Photon) {
578 return 0;
579 } else if(t == antiProton) {
580 return -1;
581 } else if(t == XiMinus) {
582 return -1;
583 } else if(t == XiZero) {
584 return 1;
585 } else if(t == antiNeutron) {
586 return 1;
587 } else if(t == antiLambda) {
588 return 0;
589 } else if(t == antiSigmaPlus) {
590 return -2;
591 } else if(t == antiSigmaZero) {
592 return 0;
593 } else if(t == antiSigmaMinus) {
594 return 2;
595 } else if(t == antiXiMinus) {
596 return 1;
597 } else if(t == antiXiZero) {
598 return -1;
599 }
600 INCL_ERROR("Requested isospin of an unknown particle!");
601 return -10; // Unknown
602 }

Referenced by G4INCL::CrossSectionsINCL46::elasticNNLegacy(), G4INCL::DeltaProductionChannel::fillFinalState(), G4INCL::ElasticChannel::fillFinalState(), G4INCL::EtaNToPiPiNChannel::fillFinalState(), G4INCL::NDeltaEtaProductionChannel::fillFinalState(), G4INCL::NDeltaOmegaProductionChannel::fillFinalState(), G4INCL::NDeltaToDeltaLKChannel::fillFinalState(), G4INCL::NDeltaToDeltaSKChannel::fillFinalState(), G4INCL::NDeltaToNLKChannel::fillFinalState(), G4INCL::NDeltaToNNKKbChannel::fillFinalState(), G4INCL::NDeltaToNSKChannel::fillFinalState(), G4INCL::NKbToL2piChannel::fillFinalState(), G4INCL::NKbToLpiChannel::fillFinalState(), G4INCL::NKbToNKb2piChannel::fillFinalState(), G4INCL::NKbToNKbpiChannel::fillFinalState(), G4INCL::NKbToS2piChannel::fillFinalState(), G4INCL::NKbToSpiChannel::fillFinalState(), G4INCL::NKToNK2piChannel::fillFinalState(), G4INCL::NKToNKpiChannel::fillFinalState(), G4INCL::NLToNSChannel::fillFinalState(), G4INCL::NNEtaToMultiPionsChannel::fillFinalState(), G4INCL::NNOmegaToMultiPionsChannel::fillFinalState(), G4INCL::NNToMissingStrangenessChannel::fillFinalState(), G4INCL::NNToMultiPionsChannel::fillFinalState(), G4INCL::NNToNLK2piChannel::fillFinalState(), G4INCL::NNToNLKChannel::fillFinalState(), G4INCL::NNToNLKpiChannel::fillFinalState(), G4INCL::NNToNNEtaChannel::fillFinalState(), G4INCL::NNToNNKKbChannel::fillFinalState(), G4INCL::NNToNNOmegaChannel::fillFinalState(), G4INCL::NNToNSK2piChannel::fillFinalState(), G4INCL::NNToNSKChannel::fillFinalState(), G4INCL::NNToNSKpiChannel::fillFinalState(), G4INCL::NpiToLK2piChannel::fillFinalState(), G4INCL::NpiToLKChannel::fillFinalState(), G4INCL::NpiToLKpiChannel::fillFinalState(), G4INCL::NpiToMissingStrangenessChannel::fillFinalState(), G4INCL::NpiToNKKbChannel::fillFinalState(), G4INCL::NpiToSK2piChannel::fillFinalState(), G4INCL::NpiToSKChannel::fillFinalState(), G4INCL::NpiToSKpiChannel::fillFinalState(), G4INCL::NSToNLChannel::fillFinalState(), G4INCL::NSToNSChannel::fillFinalState(), G4INCL::OmegaNToPiPiNChannel::fillFinalState(), G4INCL::PiNElasticChannel::fillFinalState(), G4INCL::PiNToEtaChannel::fillFinalState(), G4INCL::PiNToMultiPionsChannel::fillFinalState(), G4INCL::PiNToOmegaChannel::fillFinalState(), G4INCL::Nucleus::insertParticle(), G4INCL::CrossSectionsStrangeness::NDeltaToDeltaLK(), G4INCL::CrossSectionsStrangeness::NDeltaToDeltaSK(), G4INCL::CrossSectionsStrangeness::NDeltaToNLK(), G4INCL::CrossSectionsINCL46::NDeltaToNN(), G4INCL::CrossSectionsMultiPions::NDeltaToNN(), G4INCL::CrossSectionsStrangeness::NDeltaToNNKKb(), G4INCL::CrossSectionsStrangeness::NDeltaToNSK(), G4INCL::CrossSectionsStrangeness::NKbToL2pi(), G4INCL::CrossSectionsStrangeness::NKbToLpi(), G4INCL::CrossSectionsStrangeness::NKbToNKb(), G4INCL::CrossSectionsStrangeness::NKbToNKb2pi(), G4INCL::CrossSectionsStrangeness::NKbToNKbpi(), G4INCL::CrossSectionsStrangeness::NKbToS2pi(), G4INCL::CrossSectionsStrangeness::NKbToSpi(), G4INCL::CrossSectionsStrangeness::NKToNK(), G4INCL::CrossSectionsStrangeness::NKToNK2pi(), G4INCL::CrossSectionsStrangeness::NKToNKpi(), G4INCL::CrossSectionsAntiparticles::NNbarCEX(), G4INCL::CrossSectionsAntiparticles::NNbarElastic(), G4INCL::CrossSectionsAntiparticles::NNbarToAnnihilation(), G4INCL::CrossSectionsAntiparticles::NNbarToLLbar(), G4INCL::CrossSectionsAntiparticles::NNbarToNNbar2pi(), G4INCL::CrossSectionsAntiparticles::NNbarToNNbar3pi(), G4INCL::CrossSectionsAntiparticles::NNbarToNNbarpi(), G4INCL::CrossSectionsMultiPions::NNElastic(), G4INCL::CrossSectionsMultiPions::NNOnePi(), G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta(), G4INCL::CrossSectionsMultiPions::NNThreePi(), G4INCL::CrossSectionsStrangeness::NNToMissingStrangeness(), G4INCL::CrossSectionsINCL46::NNToNDelta(), G4INCL::CrossSectionsMultiPions::NNToNDelta(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNDeltaEta(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNDeltaOmega(), G4INCL::CrossSectionsStrangeness::NNToNLK2pi(), G4INCL::CrossSectionsStrangeness::NNToNLKpi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEta(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaExclu(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaFourPi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaOnePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaOnePiOrDelta(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaThreePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaTwoPi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaxPi(), G4INCL::CrossSectionsStrangeness::NNToNNKKb(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmega(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaExclu(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaFourPi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaOnePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaOnePiOrDelta(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaThreePi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaTwoPi(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaxPi(), G4INCL::CrossSectionsStrangeness::NNToNSK2pi(), G4INCL::CrossSectionsStrangeness::NNToNSKpi(), G4INCL::CrossSectionsMultiPions::NNTot(), G4INCL::CrossSectionsMultiPions::NNTwoPi(), G4INCL::CrossSectionsStrangeness::NpiToLK(), G4INCL::CrossSectionsStrangeness::NpiToLK2pi(), G4INCL::CrossSectionsStrangeness::NpiToLKpi(), G4INCL::CrossSectionsStrangeness::NpiToSK(), G4INCL::CrossSectionsStrangeness::NpiToSK2pi(), G4INCL::CrossSectionsStrangeness::NpiToSKpi(), G4INCL::CrossSectionsStrangeness::NSToNL(), G4INCL::CrossSectionsStrangeness::NSToNS(), G4INCL::CrossSectionsMultiPions::piNIne(), G4INCL::CrossSectionsMultiPions::piNOnePi(), G4INCL::CrossSectionsINCL46::piNToDelta(), G4INCL::CrossSectionsMultiPions::piNToDelta(), G4INCL::CrossSectionsMultiPionsAndResonances::piNToEtaN(), G4INCL::CrossSectionsMultiPionsAndResonances::piNToOmegaN(), G4INCL::CrossSectionsMultiPions::piNTot(), and G4INCL::CrossSectionsMultiPions::piNTwoPi().

◆ getIUPACElementName()

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

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

Definition at line 1361 of file G4INCLParticleTable.cc.

1361 {
1362 std::stringstream elementStream;
1363 elementStream << Z;
1364 std::string elementName = elementStream.str();
1365 std::transform(elementName.begin(), elementName.end(), elementName.begin(), intToIUPAC);
1366 elementName[0] = (char)std::toupper(elementName.at(0));
1367 return elementName;
1368 }

Referenced by getElementName().

◆ getKaonType()

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

Get the type of kaon.

Definition at line 1537 of file G4INCLParticleTable.cc.

1537 {
1538// assert(isosp == -1 || isosp == 1);
1539 if (isosp == -1) {
1540 return KZero;
1541 }
1542 else {
1543 return KPlus;
1544 }
1545 }

Referenced by G4INCL::NDeltaToDeltaLKChannel::fillFinalState(), G4INCL::NDeltaToDeltaSKChannel::fillFinalState(), G4INCL::NDeltaToNLKChannel::fillFinalState(), G4INCL::NDeltaToNNKKbChannel::fillFinalState(), G4INCL::NDeltaToNSKChannel::fillFinalState(), G4INCL::NKToNK2piChannel::fillFinalState(), G4INCL::NKToNKpiChannel::fillFinalState(), G4INCL::NNToMissingStrangenessChannel::fillFinalState(), G4INCL::NpiToLK2piChannel::fillFinalState(), G4INCL::NpiToLKpiChannel::fillFinalState(), G4INCL::NpiToMissingStrangenessChannel::fillFinalState(), G4INCL::NpiToNKKbChannel::fillFinalState(), G4INCL::NpiToSK2piChannel::fillFinalState(), G4INCL::NpiToSKChannel::fillFinalState(), and G4INCL::NpiToSKpiChannel::fillFinalState().

◆ getLambdaSeparationEnergy()

G4double G4INCL::ParticleTable::getLambdaSeparationEnergy ( )

Definition at line 1343 of file G4INCLParticleTable.cc.

1343{ return lambdaSeparationEnergy; }

◆ getLargestNuclearRadius()

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

Definition at line 1193 of file G4INCLParticleTable.cc.

1193 {
1194 return Math::max(getNuclearRadius(Proton, A, Z), getNuclearRadius(Neutron, A, Z));
1195 }
G4INCL::ParticleTable::getNuclearRadius
G4double getNuclearRadius(const ParticleType t, const G4int A, const G4int Z)
Definition G4INCLParticleTable.cc:1165

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

◆ getMassNumber()

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

Get mass number from particle type.

Definition at line 1013 of file G4INCLParticleTable.cc.

1013 {
1014
1015 switch(t) {
1016 case Proton:
1017 case Neutron:
1018 case DeltaPlusPlus:
1019 case DeltaPlus:
1020 case DeltaZero:
1021 case DeltaMinus:
1022 case SigmaPlus:
1023 case SigmaZero:
1024 case SigmaMinus:
1025 case Lambda:
1026 case XiZero:
1027 case XiMinus:
1028 return 1;
1029 break;
1030 case antiProton:
1031 case antiNeutron:
1032 case antiSigmaPlus:
1033 case antiSigmaZero:
1034 case antiSigmaMinus:
1035 case antiLambda:
1036 case antiXiZero:
1037 case antiXiMinus:
1038 return -1;
1039 break;
1040 case PiPlus:
1041 case PiMinus:
1042 case PiZero:
1043 case KPlus:
1044 case KZero:
1045 case KZeroBar:
1046 case KShort:
1047 case KLong:
1048 case KMinus:
1049 case Eta:
1050 case Omega:
1051 case EtaPrime:
1052 case Photon:
1053 return 0;
1054 break;
1055 default:
1056 return 0;
1057 break;
1058 }
1059 }

◆ getMaximumNuclearRadius()

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

Definition at line 1249 of file G4INCLParticleTable.cc.

1249 {
1250 const G4double XFOISA = 8.0;
1251 if(A > 19) {
1252 return getNuclearRadius(t,A,Z) + XFOISA * getSurfaceDiffuseness(t,A,Z);
1253 } else if(A <= 19 && A >= 6) {
1254 return 5.5 + 0.3 * (G4double(A) - 6.0)/12.0;
1255 } else if(A >= 2) {
1256 return getNuclearRadius(t, A, Z) + 4.5;
1257 } else {
1258 INCL_ERROR("getMaximumNuclearRadius : No maximum radius for nucleus A = " << A << " Z = " << Z << '\n');
1259 return 0.0;
1260 }
1261 }
G4INCL::ParticleTable::getSurfaceDiffuseness
G4double getSurfaceDiffuseness(const ParticleType t, const G4int A, const G4int Z)
Definition G4INCLParticleTable.cc:1263

Referenced by G4INCL::NuclearDensityFactory::createRCDFTable(), G4INCL::NuclearDensityFactory::createRPCorrelationTable(), G4INCL::PbarAtrestEntryChannel::densityN(), G4INCL::PbarAtrestEntryChannel::densityP(), G4INCL::PbarAtrestEntryChannel::getAnnihilationPosition(), and G4INCL::INCL::initUniverseRadiusForAntiprotonAtRest().

◆ getMomentumRMS()

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

Return the RMS of the momentum distribution (light clusters)

Definition at line 1297 of file G4INCLParticleTable.cc.

1297 {
1298// assert(Z>=0 && A>=0 && Z<=A);
1299 return getFermiMomentum(A,Z) * Math::sqrtThreeFifths;
1300 }
G4INCL::ParticleTable::getFermiMomentum
G4ThreadLocal FermiMomentumFn getFermiMomentum
Definition G4INCLParticleTable.cc:1440

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

622 {
623 std::stringstream stream;
624 stream << getElementName(Z) << "-" << A;
625 return stream.str();
626 }
G4INCL::ParticleTable::getElementName
std::string getElementName(const G4int Z)
Get the name of the element from the atomic number.
Definition G4INCLParticleTable.cc:1351

◆ getName() [2/4]

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

Get the native INCL name of the ion.

Definition at line 628 of file G4INCLParticleTable.cc.

628 {
629 std::stringstream stream;
630 if(S >= 0) // S < 0 for hypernuclei
631 return getName(A, Z);
632 else if(S == -1)
633 stream << getElementName(Z) << "-" << A << "_" << "Lambda";
634 else
635 stream << getElementName(Z) << "-" << A << "_" << S << "-Lambda";
636 return stream.str();
637 }
G4INCL::ParticleTable::getName
std::string getName(const ParticleType t)
Get the native INCL name of the particle.
Definition G4INCLParticleTable.cc:647

◆ getName() [3/4]

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

Get the native INCL name of the particle.

Definition at line 613 of file G4INCLParticleTable.cc.

613 {
614 if(sp.theType==Composite && sp.theS == 0)
615 return getName(sp.theA,sp.theZ);
616 else if(sp.theType==Composite)
617 return getName(sp.theA,sp.theZ,sp.theS);
618 else
619 return getName(sp.theType);
620 }

◆ getName() [4/4]

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

Get the native INCL name of the particle.

Definition at line 647 of file G4INCLParticleTable.cc.

647 {
648 if(p == G4INCL::Proton) {
649 return std::string("proton");
650 } else if(p == G4INCL::Neutron) {
651 return std::string("neutron");
652 } else if(p == G4INCL::DeltaPlusPlus) {
653 return std::string("delta++");
654 } else if(p == G4INCL::DeltaPlus) {
655 return std::string("delta+");
656 } else if(p == G4INCL::DeltaZero) {
657 return std::string("delta0");
658 } else if(p == G4INCL::DeltaMinus) {
659 return std::string("delta-");
660 } else if(p == G4INCL::PiPlus) {
661 return std::string("pi+");
662 } else if(p == G4INCL::PiZero) {
663 return std::string("pi0");
664 } else if(p == G4INCL::PiMinus) {
665 return std::string("pi-");
666 } else if(p == G4INCL::Lambda) {
667 return std::string("lambda");
668 } else if(p == G4INCL::SigmaPlus) {
669 return std::string("sigma+");
670 } else if(p == G4INCL::SigmaZero) {
671 return std::string("sigma0");
672 } else if(p == G4INCL::SigmaMinus) {
673 return std::string("sigma-");
674 } else if(p == G4INCL::antiProton) {
675 return std::string("antiproton");
676 } else if(p == G4INCL::XiMinus) {
677 return std::string("xi-");
678 } else if(p == G4INCL::XiZero) {
679 return std::string("xi0");
680 } else if(p == G4INCL::antiNeutron) {
681 return std::string("antineutron");
682 } else if(p == G4INCL::antiSigmaPlus) {
683 return std::string("antisigma+");
684 } else if(p == G4INCL::antiSigmaZero) {
685 return std::string("antisigma0");
686 } else if(p == G4INCL::antiSigmaMinus) {
687 return std::string("antisigma-");
688 } else if(p == G4INCL::antiLambda) {
689 return std::string("antilambda");
690 } else if(p == G4INCL::antiXiMinus) {
691 return std::string("antixi-");
692 } else if(p == G4INCL::antiXiZero) {
693 return std::string("antixi0");
694 } else if(p == G4INCL::KPlus) {
695 return std::string("kaon+");
696 } else if(p == G4INCL::KZero) {
697 return std::string("kaon0");
698 } else if(p == G4INCL::KZeroBar) {
699 return std::string("kaon0bar");
700 } else if(p == G4INCL::KMinus) {
701 return std::string("kaon-");
702 } else if(p == G4INCL::KShort) {
703 return std::string("kaonshort");
704 } else if(p == G4INCL::KLong) {
705 return std::string("kaonlong");
706 } else if(p == G4INCL::Composite) {
707 return std::string("composite");
708 } else if(p == G4INCL::Eta) {
709 return std::string("eta");
710 } else if(p == G4INCL::Omega) {
711 return std::string("omega");
712 } else if(p == G4INCL::EtaPrime) {
713 return std::string("etaprime");
714 } else if(p == G4INCL::Photon) {
715 return std::string("photon");
716 }
717 return std::string("unknown");
718 }

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

◆ getNaturalIsotopicDistribution()

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

Definition at line 1396 of file G4INCLParticleTable.cc.

1396 {
1397 return getNaturalIsotopicDistributions()->getIsotopicDistribution(Z);
1398 }

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

◆ getNeutronHalo()

G4double G4INCL::ParticleTable::getNeutronHalo ( )

Get the size of the neutron halo.

Definition at line 1432 of file G4INCLParticleTable.cc.

1432{ return neutronHalo; }

◆ getNeutronSeparationEnergy()

G4double G4INCL::ParticleTable::getNeutronSeparationEnergy ( )

Getter for neutronSeparationEnergy.

Definition at line 1341 of file G4INCLParticleTable.cc.

1341{ return neutronSeparationEnergy; }

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

◆ getNeutronSkin()

G4double G4INCL::ParticleTable::getNeutronSkin ( )

Get the thickness of the neutron skin.

Definition at line 1430 of file G4INCLParticleTable.cc.

1430{ return neutronSkin; }

◆ getNuclearRadius()

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

Definition at line 1165 of file G4INCLParticleTable.cc.

1165 {
1166// assert(A>=0);
1167 if(A > 19 || (A < 6 && A >= 2)) {
1168 // For large (Woods-Saxon or Modified Harmonic Oscillator) or small
1169 // (Gaussian) nuclei, the radius parameter is just the nuclear radius
1170 return getRadiusParameter(t,A,Z);
1171 } else if(A < clusterTableASize && Z>=0 && Z < clusterTableZSize && A >= 6) {
1172 const G4double thisRMS = positionRMS[Z][A];
1173 if(thisRMS>0.0)
1174 return thisRMS;
1175 else {
1176 INCL_DEBUG("getNuclearRadius: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'
1177 << "returning radius for C12");
1178 return positionRMS[6][12];
1179 }
1180 } else if(A <= 19) {
1181 const G4double theRadiusParameter = getRadiusParameter(t, A, Z);
1182 const G4double theDiffusenessParameter = getSurfaceDiffuseness(t, A, Z);
1183 // The formula yields the nuclear RMS radius based on the parameters of
1184 // the nuclear-density function
1185 return 1.225*theDiffusenessParameter*
1186 std::sqrt((2.+5.*theRadiusParameter)/(2.+3.*theRadiusParameter));
1187 } else {
1188 INCL_ERROR("getNuclearRadius: No radius for nucleus A = " << A << " Z = " << Z << '\n');
1189 return 0.0;
1190 }
1191 }
INCL_DEBUG
#define INCL_DEBUG(x)
Definition G4INCLLogger.hh:240
G4INCL::ParticleTable::getRadiusParameter
G4double getRadiusParameter(const ParticleType t, const G4int A, const G4int Z)
Definition G4INCLParticleTable.cc:1197

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

◆ getNucleonType()

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

Get the type of nucleon.

Definition at line 1455 of file G4INCLParticleTable.cc.

1455 {
1456// assert(isosp == -1 || isosp == 1);
1457 if (isosp == -1) {
1458 return Neutron;
1459 }
1460 else {
1461 return Proton;
1462 }
1463 }

Referenced by G4INCL::EtaNToPiPiNChannel::fillFinalState(), G4INCL::NDeltaToNLKChannel::fillFinalState(), G4INCL::NDeltaToNNKKbChannel::fillFinalState(), G4INCL::NDeltaToNSKChannel::fillFinalState(), G4INCL::NKbToNKb2piChannel::fillFinalState(), G4INCL::NKbToNKbpiChannel::fillFinalState(), G4INCL::NKToNK2piChannel::fillFinalState(), G4INCL::NKToNKpiChannel::fillFinalState(), G4INCL::NLToNSChannel::fillFinalState(), G4INCL::NNEtaToMultiPionsChannel::fillFinalState(), G4INCL::NNOmegaToMultiPionsChannel::fillFinalState(), G4INCL::NNToMissingStrangenessChannel::fillFinalState(), G4INCL::NNToMultiPionsChannel::fillFinalState(), G4INCL::NNToNNEtaChannel::fillFinalState(), G4INCL::NNToNNOmegaChannel::fillFinalState(), G4INCL::NpiToMissingStrangenessChannel::fillFinalState(), G4INCL::NpiToNKKbChannel::fillFinalState(), G4INCL::NSToNLChannel::fillFinalState(), G4INCL::NSToNSChannel::fillFinalState(), G4INCL::OmegaNToPiPiNChannel::fillFinalState(), G4INCL::PiNElasticChannel::fillFinalState(), and G4INCL::PiNToMultiPionsChannel::fillFinalState().

◆ getPionType()

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

Get the type of pion.

Definition at line 1442 of file G4INCLParticleTable.cc.

1442 {
1443// assert(isosp == -2 || isosp == 0 || isosp == 2);
1444 if (isosp == -2) {
1445 return PiMinus;
1446 }
1447 else if (isosp == 0) {
1448 return PiZero;
1449 }
1450 else {
1451 return PiPlus;
1452 }
1453 }

Referenced by G4INCL::NKbToL2piChannel::fillFinalState(), G4INCL::NKbToLpiChannel::fillFinalState(), G4INCL::NKbToNKb2piChannel::fillFinalState(), G4INCL::NKbToNKbpiChannel::fillFinalState(), G4INCL::NKbToS2piChannel::fillFinalState(), G4INCL::NKbToSpiChannel::fillFinalState(), G4INCL::NKToNK2piChannel::fillFinalState(), G4INCL::NKToNKpiChannel::fillFinalState(), G4INCL::NNEtaToMultiPionsChannel::fillFinalState(), G4INCL::NNOmegaToMultiPionsChannel::fillFinalState(), G4INCL::NNToMissingStrangenessChannel::fillFinalState(), G4INCL::NNToMultiPionsChannel::fillFinalState(), G4INCL::NpiToLK2piChannel::fillFinalState(), G4INCL::NpiToLKpiChannel::fillFinalState(), G4INCL::NpiToMissingStrangenessChannel::fillFinalState(), G4INCL::NpiToSK2piChannel::fillFinalState(), G4INCL::NpiToSKpiChannel::fillFinalState(), G4INCL::PiNElasticChannel::fillFinalState(), and G4INCL::PiNToMultiPionsChannel::fillFinalState().

◆ getProtonSeparationEnergy()

G4double G4INCL::ParticleTable::getProtonSeparationEnergy ( )

Getter for protonSeparationEnergy.

Definition at line 1339 of file G4INCLParticleTable.cc.

1339{ return protonSeparationEnergy; }

Referenced by G4INCL::Nucleus::computeExcitationEnergy(), and G4INCL::Nucleus::computeTotalEnergy().

◆ getRadiusParameter()

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

Definition at line 1197 of file G4INCLParticleTable.cc.

1197 {
1198// assert(A>0);
1199 if(A > 19) {
1200 // radius fit for lambdas
1201 if(t==Lambda){
1202 G4double r0 = (1.128+0.439*std::pow(A,-2./3.)) * std::pow(A, 1.0/3.0);
1203 return r0;
1204 }
1205 // phenomenological radius fit
1206 G4double r0 = (2.745e-4 * A + 1.063) * std::pow(A, 1.0/3.0);
1207 // HFB calculations
1208 if(getRPCorrelationCoefficient(t)<1.){
1209 G4double r0hfb = HFB::getRadiusParameterHFB(t,A,Z);
1210 if(r0hfb>0.)r0 = r0hfb;
1211 }
1212 //
1213 if(t==Neutron)
1214 r0 += neutronSkin;
1215 return r0;
1216 } else if(A < 6 && A >= 2) {
1217 if(Z<clusterTableZSize && Z>=0) {
1218 const G4double thisRMS = positionRMS[Z][A];
1219 if(thisRMS>0.0)
1220 return thisRMS;
1221 else {
1222 INCL_DEBUG("getRadiusParameter: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'
1223 << "returning radius for C12");
1224 return positionRMS[6][12];
1225 }
1226 } else {
1227 INCL_DEBUG("getRadiusParameter: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'
1228 << "returning radius for C12");
1229 return positionRMS[6][12];
1230 }
1231 } else if(A <= 19 && A >= 6) {
1232 if(t==Lambda){
1233 G4double r0 = (1.128+0.439*std::pow(A,-2./3.)) * std::pow(A, 1.0/3.0);
1234 return r0;
1235 }
1236 // HFB calculations
1237 if(getRPCorrelationCoefficient(t)<1.){
1238 G4double r0hfb = HFB::getSurfaceDiffusenessHFB(t,A,Z);
1239 if(r0hfb>0.)return r0hfb;
1240 }
1241 return mediumRadius[A-1];
1242 // return 1.581*mediumDiffuseness[A-1]*(2.+5.*mediumRadius[A-1])/(2.+3.*mediumRadius[A-1]);
1243 } else {
1244 INCL_ERROR("getRadiusParameter: No radius for nucleus A = " << A << " Z = " << Z << '\n');
1245 return 0.0;
1246 }
1247 }
G4INCL::ParticleTable::getRPCorrelationCoefficient
G4double getRPCorrelationCoefficient(const ParticleType t)
Get the value of the r-p correlation coefficient.
Definition G4INCLParticleTable.cc:1425

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

◆ getRealMass() [1/2]

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

Get particle mass (in MeV/c^2)

Definition at line 858 of file G4INCLParticleTable.cc.

858 {
859 switch(t) {
860 case Proton:
861 return theRealProtonMass;
862 break;
863 case Neutron:
864 return theRealNeutronMass;
865 break;
866 case PiPlus:
867 case PiMinus:
868 return theRealChargedPiMass;
869 break;
870 case PiZero:
871 return theRealPiZeroMass;
872 break;
873 case Eta:
874 return theRealEtaMass;
875 break;
876 case Omega:
877 return theRealOmegaMass;
878 break;
879 case EtaPrime:
880 return theRealEtaPrimeMass;
881 break;
882 case Photon:
883 return theRealPhotonMass;
884 break;
885 case Lambda:
886 return theRealLambdaMass;
887 break;
888 case KPlus:
889 case KMinus:
890 return theRealChargedKaonMass;
891 break;
892 case KZero:
893 case KZeroBar:
894 case KShort:
895 case KLong:
896 return theRealNeutralKaonMass;
897 break;
898 case SigmaPlus:
899 return theRealSigmaPlusMass;
900 break;
901 case SigmaZero:
902 return theRealSigmaZeroMass;
903 break;
904 case SigmaMinus:
905 return theRealSigmaMinusMass;
906 break;
907 case antiProton:
908 return theRealAntiProtonMass;
909 break;
910 case XiMinus:
911 return theRealXiMinusMass;
912 break;
913 case XiZero:
914 return theRealXiZeroMass;
915 break;
916 case antiNeutron:
917 return theRealAntiNeutronMass;
918 break;
919 case antiSigmaPlus:
920 return theRealAntiSigmaPlusMass;
921 break;
922 case antiSigmaZero:
923 return theRealAntiSigmaZeroMass;
924 break;
925 case antiSigmaMinus:
926 return theRealAntiSigmaMinusMass;
927 break;
928 case antiXiMinus:
929 return theRealAntiXiMinusMass;
930 break;
931 case antiXiZero:
932 return theRealAntiXiZeroMass;
933 break;
934 case antiLambda:
935 return theRealAntiLambdaMass;
936 break;
937 default:
938 INCL_ERROR("Particle::getRealMass : Unknown particle type." << '\n');
939 return 0.0;
940 break;
941 }
942 }

Referenced by G4INCL::Nucleus::computeTotalEnergy(), G4INCL::EventInfo::fillInverseKinematics(), G4INCL::Particle::getRealMass(), getRealMass(), initialize(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaExcluIso(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNEtaIso(), G4INCL::CrossSectionsMultiPionsAndResonances::NNToNNOmegaExcluIso(), G4INCL::CrossSectionsMultiPionsAndResonances::piMinuspToEtaN(), G4INCL::CrossSectionsMultiPionsAndResonances::piMinuspToOmegaN(), and G4INCL::INCL::processEvent().

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

944 {
945// assert(A>=0);
946 // For nuclei with Z<0 or Z>A, assume that the exotic charge state is due to pions
947 if(Z<0 && S<0)
948 return (A+S)*theRealNeutronMass - S*LambdaMass - Z*getRealMass(PiMinus);
949 else if(Z>A && S<0)
950 return (A+S)*theRealProtonMass - S*LambdaMass + (A+S-Z)*getRealMass(PiPlus);
951 if(Z<0)
952 return (A)*theRealNeutronMass - Z*getRealMass(PiMinus);
953 else if(Z>A)
954 return (A)*theRealProtonMass + (A-Z)*getRealMass(PiPlus);
955 else if(Z==0 && S==0)
956 return A*theRealNeutronMass;
957 else if(A==Z)
958 return A*theRealProtonMass;
959 else if(Z==0 && S<0)
960 return (A+S)*theRealNeutronMass-S*LambdaMass;
961 else if(A>1) {
962#ifndef INCLXX_IN_GEANT4_MODE
963 return ::G4INCL::NuclearMassTable::getMass(A,Z,S);
964#else
965 if(S<0) return theG4IonTable->GetNucleusMass(Z,A,std::abs(S)) / MeV;
966 else return theG4IonTable->GetNucleusMass(Z,A) / MeV;
967#endif
968 } else
969 return 0.;
970 }
G4INCL::ParticleTable::getRealMass
G4double getRealMass(const G4INCL::ParticleType t)
Get particle mass (in MeV/c^2)
Definition G4INCLParticleTable.cc:858

◆ getRPCorrelationCoefficient()

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

Get the value of the r-p correlation coefficient.

Parameters
tthe type of the particle (Proton or Neutron)
Returns
the value of the r-p correlation coefficient

Definition at line 1425 of file G4INCLParticleTable.cc.

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

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

1302 {
1303 if(t==Proton)
1304 return theINCLProtonSeparationEnergy;
1305 else if(t==Neutron)
1306 return theINCLNeutronSeparationEnergy;
1307 else if(t==Lambda)
1308 return theINCLLambdaSeparationEnergy;
1309 else if(t==antiProton)
1310 return theINCLantiProtonSeparationEnergy;
1311 else {
1312 INCL_ERROR("ParticleTable::getSeparationEnergyINCL : Unknown particle type." << '\n');
1313 return 0.0;
1314 }
1315 }

Referenced by G4INCL::Nucleus::computeTotalEnergy(), 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 1317 of file G4INCLParticleTable.cc.

1317 {
1318 // Real separation energies for all nuclei
1319 if(t==Proton)
1320 return (*getTableParticleMass)(Proton) + (*getTableMass)(A-1,Z-1,0) - (*getTableMass)(A,Z,0);
1321 else if(t==Neutron)
1322 return (*getTableParticleMass)(Neutron) + (*getTableMass)(A-1,Z,0) - (*getTableMass)(A,Z,0);
1323 else if(t==Lambda)
1324 return (*getTableParticleMass)(Lambda) + (*getTableMass)(A-1,Z,0) - (*getTableMass)(A,Z,-1);
1325 else {
1326 INCL_ERROR("ParticleTable::getSeparationEnergyReal : Unknown particle type." << '\n');
1327 return 0.0;
1328 }
1329 }

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

1331 {
1332 // Real separation energies for light nuclei, fixed values for heavy nuclei
1333 if(Z<clusterTableZSize && A<clusterTableASize)
1334 return getSeparationEnergyReal(t, A, Z);
1335 else
1336 return getSeparationEnergyINCL(t, A, Z);
1337 }
G4INCL::ParticleTable::getSeparationEnergyReal
G4double getSeparationEnergyReal(const ParticleType t, const G4int A, const G4int Z)
Return the real separation energy.
Definition G4INCLParticleTable.cc:1317
G4INCL::ParticleTable::getSeparationEnergyINCL
G4double getSeparationEnergyINCL(const ParticleType t, const G4int, const G4int)
Return INCL's default separation energy.
Definition G4INCLParticleTable.cc:1302

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

639 {
640 std::stringstream stream;
641 stream << getElementName(Z);
642 if(A>0)
643 stream << A;
644 return stream.str();
645 }

◆ getShortName() [2/3]

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

Get the short INCL name of the particle.

Definition at line 604 of file G4INCLParticleTable.cc.

604 {
605 if(sp.theType==Composite && sp.theS == 0)
606 return getShortName(sp.theA,sp.theZ);
607 else if(sp.theType==Composite)
608 return getName(sp.theA,sp.theZ,sp.theS);
609 else
610 return getShortName(sp.theType);
611 }
G4INCL::ParticleTable::getShortName
std::string getShortName(const ParticleType t)
Get the short INCL name of the particle.
Definition G4INCLParticleTable.cc:720

◆ getShortName() [3/3]

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

Get the short INCL name of the particle.

Definition at line 720 of file G4INCLParticleTable.cc.

720 {
721 if(p == G4INCL::Proton) {
722 return std::string("p");
723 } else if(p == G4INCL::Neutron) {
724 return std::string("n");
725 } else if(p == G4INCL::DeltaPlusPlus) {
726 return std::string("d++");
727 } else if(p == G4INCL::DeltaPlus) {
728 return std::string("d+");
729 } else if(p == G4INCL::DeltaZero) {
730 return std::string("d0");
731 } else if(p == G4INCL::DeltaMinus) {
732 return std::string("d-");
733 } else if(p == G4INCL::PiPlus) {
734 return std::string("pi+");
735 } else if(p == G4INCL::PiZero) {
736 return std::string("pi0");
737 } else if(p == G4INCL::PiMinus) {
738 return std::string("pi-");
739 } else if(p == G4INCL::Lambda) {
740 return std::string("l");
741 } else if(p == G4INCL::SigmaPlus) {
742 return std::string("s+");
743 } else if(p == G4INCL::SigmaZero) {
744 return std::string("s0");
745 } else if(p == G4INCL::SigmaMinus) {
746 return std::string("s-");
747 } else if(p == G4INCL::antiProton) {
748 return std::string("pb");
749 } else if(p == G4INCL::XiMinus) {
750 return std::string("x-");
751 } else if(p == G4INCL::XiZero) {
752 return std::string("x0");
753 } else if(p == G4INCL::antiNeutron) {
754 return std::string("nb");
755 } else if(p == G4INCL::antiSigmaPlus) {
756 return std::string("s+b");
757 } else if(p == G4INCL::antiSigmaZero) {
758 return std::string("s0b");
759 } else if(p == G4INCL::antiSigmaMinus) {
760 return std::string("s-b");
761 } else if(p == G4INCL::antiLambda) {
762 return std::string("lb");
763 } else if(p == G4INCL::antiXiMinus) {
764 return std::string("x-b");
765 } else if(p == G4INCL::antiXiZero) {
766 return std::string("x0b");
767 } else if(p == G4INCL::KPlus) {
768 return std::string("k+");
769 } else if(p == G4INCL::KZero) {
770 return std::string("k0");
771 } else if(p == G4INCL::KZeroBar) {
772 return std::string("k0b");
773 } else if(p == G4INCL::KMinus) {
774 return std::string("k-");
775 } else if(p == G4INCL::KShort) {
776 return std::string("ks");
777 } else if(p == G4INCL::KLong) {
778 return std::string("kl");
779 } else if(p == G4INCL::Composite) {
780 return std::string("comp");
781 } else if(p == G4INCL::Eta) {
782 return std::string("eta");
783 } else if(p == G4INCL::Omega) {
784 return std::string("omega");
785 } else if(p == G4INCL::EtaPrime) {
786 return std::string("etap");
787 } else if(p == G4INCL::Photon) {
788 return std::string("photon");
789 }
790 return std::string("unknown");
791 }

Referenced by getShortName().

◆ getSigmaType()

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

Get the type of sigma.

Definition at line 1481 of file G4INCLParticleTable.cc.

1481 {
1482// assert(isosp == -2 || isosp == 0 || isosp == 2);
1483 if (isosp == -2) {
1484 return SigmaMinus;
1485 }
1486 else if (isosp == 0) {
1487 return SigmaZero;
1488 }
1489 else {
1490 return SigmaPlus;
1491 }
1492 }

Referenced by G4INCL::NDeltaToDeltaSKChannel::fillFinalState(), G4INCL::NDeltaToNSKChannel::fillFinalState(), G4INCL::NKbToS2piChannel::fillFinalState(), G4INCL::NKbToSpiChannel::fillFinalState(), G4INCL::NLToNSChannel::fillFinalState(), G4INCL::NNToMissingStrangenessChannel::fillFinalState(), G4INCL::NpiToMissingStrangenessChannel::fillFinalState(), G4INCL::NpiToSK2piChannel::fillFinalState(), G4INCL::NpiToSKChannel::fillFinalState(), G4INCL::NpiToSKpiChannel::fillFinalState(), and G4INCL::NSToNSChannel::fillFinalState().

◆ getStrangenessNumber()

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

Get strangeness number from particle type.

Definition at line 1110 of file G4INCLParticleTable.cc.

1110 {
1111 switch(t) {
1112 case DeltaPlusPlus:
1113 case DeltaPlus:
1114 case DeltaZero:
1115 case DeltaMinus:
1116 case Proton:
1117 case Neutron:
1118 case PiPlus:
1119 case PiZero:
1120 case PiMinus:
1121 case Eta:
1122 case Omega:
1123 case EtaPrime:
1124 case Photon:
1125 case antiProton:
1126 case antiNeutron:
1127 return 0;
1128 break;
1129 case XiMinus:
1130 case XiZero:
1131 case antiXiMinus:
1132 case antiXiZero:
1133 return 2;
1134 break;
1135 case antiLambda:
1136 case antiSigmaPlus:
1137 case antiSigmaZero:
1138 case antiSigmaMinus:
1139 return 1;
1140 break;
1141 case Lambda:
1142 case SigmaPlus:
1143 case SigmaZero:
1144 case SigmaMinus:
1145 case KZeroBar:
1146 case KMinus:
1147 return -1;
1148 break;
1149 case KPlus:
1150 case KZero:
1151 return 1;
1152 break;
1153 case KShort:
1154 return 0;
1155 break;
1156 case KLong:
1157 return 0;
1158 break;
1159 default:
1160 return 0;
1161 break;
1162 }
1163 }

◆ getSurfaceDiffuseness()

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

Definition at line 1263 of file G4INCLParticleTable.cc.

1263 {
1264 if(A > 19) {
1265 // phenomenological fit
1266 G4double a = 1.63e-4 * A + 0.510;
1267 // HFB calculations
1268 if(getRPCorrelationCoefficient(t)<1.){
1269 G4double ahfb = HFB::getSurfaceDiffusenessHFB(t,A,Z);
1270 if(ahfb>0.)a=ahfb;
1271 }
1272 //
1273 if(t==Lambda){
1274 // Like for neutrons
1275 G4double ahfb = HFB::getSurfaceDiffusenessHFB(Neutron,A,Z);
1276 if(ahfb>0.)a=ahfb;
1277 }
1278 if(t==Neutron)
1279 a += neutronHalo;
1280 return a;
1281 } else if(A <= 19 && A >= 6) {
1282 // HFB calculations
1283 if(getRPCorrelationCoefficient(t)<1.){
1284 G4double ahfb = HFB::getRadiusParameterHFB(t,A,Z);
1285 if(ahfb>0.)return ahfb;
1286 }
1287 return mediumDiffuseness[A-1];
1288 } else if(A < 6 && A >= 2) {
1289 INCL_ERROR("getSurfaceDiffuseness: was called for A = " << A << " Z = " << Z << '\n');
1290 return 0.0;
1291 } else {
1292 INCL_ERROR("getSurfaceDiffuseness: No diffuseness for nucleus A = " << A << " Z = " << Z << '\n');
1293 return 0.0;
1294 }
1295 }

Referenced by G4INCL::NuclearDensityFactory::createRCDFTable(), G4INCL::NuclearDensityFactory::createRPCorrelationTable(), G4INCL::PbarAtrestEntryChannel::densityN(), G4INCL::PbarAtrestEntryChannel::densityP(), 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 998 of file G4INCLParticleTable.cc.

998 {
999 return getTableMass(A1,Z1,S1) + getTableMass(A2,Z2,S2) - getTableMass(A1+A2,Z1+Z2,S1+S2);
1000 }
G4INCL::ParticleTable::getTableMass
G4ThreadLocal NuclearMassFn getTableMass
Static pointer to the mass function for nuclei.
Definition G4INCLParticleTable.cc:1437

Referenced by G4INCL::Particle::getEmissionQValueCorrection(), G4INCL::Particle::getEmissionQValueCorrection(), G4INCL::Particle::getTransferQValueCorrection(), 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 1002 of file G4INCLParticleTable.cc.

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

◆ getTableSpeciesMass()

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

Definition at line 1006 of file G4INCLParticleTable.cc.

1006 {
1007 if(p.theType == Composite)
1008 return (*getTableMass)(p.theA, p.theZ, p.theS);
1009 else
1010 return (*getTableParticleMass)(p.theType);
1011 }

◆ getWidth()

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

Get particle width (in s)

Definition at line 1557 of file G4INCLParticleTable.cc.

1557 {
1558// 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 || pt == antiLambda || pt == antiSigmaPlus || pt == antiSigmaZero || pt == antiSigmaMinus || pt == XiMinus || pt == XiZero || pt == antiXiZero || pt == antiXiMinus || );
1559 if(pt == PiPlus) {
1560 return piPlusWidth;
1561 } else if(pt == PiMinus) {
1562 return piMinusWidth;
1563 } else if(pt == PiZero) {
1564 return piZeroWidth;
1565 } else if(pt == Eta) {
1566 return etaWidth;
1567 } else if(pt == Omega) {
1568 return omegaWidth;
1569 } else if(pt == EtaPrime) {
1570 return etaPrimeWidth;
1571 } else if(pt == SigmaPlus) {
1572 return SigmaPlusWidth;
1573 } else if(pt == SigmaZero) {
1574 return SigmaZeroWidth;
1575 } else if(pt == SigmaMinus) {
1576 return SigmaMinusWidth;
1577 } else if(pt == KPlus) {
1578 return KPlusWidth;
1579 } else if(pt == KMinus) {
1580 return KMinusWidth;
1581 } else if(pt == KShort) {
1582 return KShortWidth;
1583 } else if(pt == KLong) {
1584 return KLongWidth;
1585 } else if(pt == Lambda) {
1586 return LambdaWidth;
1587 } else if(pt == XiMinus) {
1588 return XiMinusWidth;
1589 } else if(pt == XiZero) {
1590 return XiZeroWidth;
1591 } else if(pt == antiSigmaPlus) {
1592 return antiSigmaPlusWidth;
1593 } else if(pt == antiSigmaZero) {
1594 return antiSigmaZeroWidth;
1595 } else if(pt == antiSigmaMinus) {
1596 return antiSigmaMinusWidth;
1597 } else if(pt == antiLambda) {
1598 return antiLambdaWidth;
1599 } else if(pt == antiXiMinus) {
1600 return antiXiMinusWidth;
1601 } else if(pt == antiXiZero) {
1602 return antiXiZeroWidth;
1603 } else {
1604 INCL_ERROR("getWidth : Unknown particle type." << '\n');
1605 return 0.0;
1606 }
1607 }

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

◆ getXiType()

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

Get the type of xi.

Definition at line 1494 of file G4INCLParticleTable.cc.

1494 {
1495// assert(isosp == -1 || isosp == 1);
1496 if (isosp == -1) {
1497 return XiMinus;
1498 }
1499 else {
1500 return XiZero;
1501 }
1502 }

◆ initialize()

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

Initialize the particle table.

Definition at line 375 of file G4INCLParticleTable.cc.

375 {
376 protonMass = theINCLNucleonMass;
377 neutronMass = theINCLNucleonMass;
378 piPlusMass = theINCLPionMass;
379 piMinusMass = theINCLPionMass;
380 piZeroMass = theINCLPionMass;
381
382 etaMass = theINCLEtaMass;
383 omegaMass = theINCLOmegaMass;
384 etaPrimeMass = theINCLEtaPrimeMass;
385 photonMass = theINCLPhotonMass;
386
387 SigmaPlusMass = theRealSigmaPlusMass;
388 SigmaMinusMass = theRealSigmaMinusMass;
389 SigmaZeroMass = theRealSigmaZeroMass;
390 LambdaMass = theINCLLambdaMass;
391 KPlusMass = theRealChargedKaonMass;
392 KZeroMass = theRealNeutralKaonMass;
393 KZeroBarMass = theRealNeutralKaonMass;
394 KShortMass = theRealNeutralKaonMass;
395 KLongMass = theRealNeutralKaonMass;
396 KMinusMass = theRealChargedKaonMass;
397
398 antiProtonMass = theRealAntiProtonMass;
399 XiZeroMass = theRealXiZeroMass;
400 XiMinusMass = theRealXiMinusMass;
401 antiNeutronMass = theRealAntiNeutronMass;
402 antiSigmaPlusMass = theRealAntiSigmaPlusMass;
403 antiSigmaMinusMass = theRealAntiSigmaMinusMass;
404 antiSigmaZeroMass = theRealAntiSigmaZeroMass;
405 antiLambdaMass = theRealAntiLambdaMass; //!
406 antiXiZeroMass = theRealAntiXiZeroMass;
407 antiXiMinusMass = theRealAntiXiMinusMass;
408
409 if(theConfig && theConfig->getUseRealMasses()) {
410 getTableMass = getRealMass;
411 getTableParticleMass = getRealMass;
412 } else {
413 getTableMass = getINCLMass;
414 getTableParticleMass = getINCLMass;
415 }
416
417#ifndef INCLXX_IN_GEANT4_MODE
418 std::string dataFilePath;
419 if(theConfig)
420 dataFilePath = theConfig->getINCLXXDataFilePath();
421 NuclearMassTable::initialize(dataFilePath, getRealMass(Proton), getRealMass(Neutron));
422#endif
423
424#ifdef INCLXX_IN_GEANT4_MODE
425 G4ParticleTable *theG4ParticleTable = G4ParticleTable::GetParticleTable();
426 theG4IonTable = theG4ParticleTable->GetIonTable();
427 theRealProtonMass = theG4ParticleTable->FindParticle("proton")->GetPDGMass() / MeV;
428 theRealNeutronMass = theG4ParticleTable->FindParticle("neutron")->GetPDGMass() / MeV;
429 theRealChargedPiMass = theG4ParticleTable->FindParticle("pi+")->GetPDGMass() / MeV;
430 theRealPiZeroMass = theG4ParticleTable->FindParticle("pi0")->GetPDGMass() / MeV;
431
432 theRealEtaMass = theG4ParticleTable->FindParticle("eta")->GetPDGMass() / MeV;
433 theRealOmegaMass = theG4ParticleTable->FindParticle("omega")->GetPDGMass() / MeV;
434 theRealEtaPrimeMass = theG4ParticleTable->FindParticle("eta_prime")->GetPDGMass() / MeV;
435 theRealPhotonMass = theG4ParticleTable->FindParticle("gamma")->GetPDGMass() / MeV;
436
437 theRealSigmaPlusMass = theG4ParticleTable->FindParticle("sigma+")->GetPDGMass() / MeV;
438 theRealSigmaZeroMass = theG4ParticleTable->FindParticle("sigma0")->GetPDGMass() / MeV;
439 theRealSigmaMinusMass = theG4ParticleTable->FindParticle("sigma-")->GetPDGMass() / MeV;
440 theRealLambdaMass = theG4ParticleTable->FindParticle("lambda")->GetPDGMass() / MeV;
441 theRealChargedKaonMass = theG4ParticleTable->FindParticle("kaon+")->GetPDGMass() / MeV;
442 theRealNeutralKaonMass = theG4ParticleTable->FindParticle("kaon0")->GetPDGMass() / MeV;
443
444 theRealAntiProtonMass = theG4ParticleTable->FindParticle("anti_proton")->GetPDGMass() / MeV;
445 theRealAntiNeutronMass = theG4ParticleTable->FindParticle("anti_neutron")->GetPDGMass() / MeV;
446 theRealXiZeroMass = theG4ParticleTable->FindParticle("xi0")->GetPDGMass() / MeV;
447 theRealXiMinusMass = theG4ParticleTable->FindParticle("xi-")->GetPDGMass() / MeV;
448 theRealAntiSigmaPlusMass = theG4ParticleTable->FindParticle("anti_sigma+")->GetPDGMass() / MeV;
449 theRealAntiSigmaZeroMass = theG4ParticleTable->FindParticle("anti_sigma0")->GetPDGMass() / MeV;
450 theRealAntiSigmaMinusMass = theG4ParticleTable->FindParticle("anti_sigma-")->GetPDGMass() / MeV;
451 theRealAntiLambdaMass = theG4ParticleTable->FindParticle("anti_lambda")->GetPDGMass() / MeV;
452 theRealAntiXiZeroMass = theG4ParticleTable->FindParticle("anti_xi0")->GetPDGMass() / MeV;
453 theRealAntiXiMinusMass = theG4ParticleTable->FindParticle("anti_xi-")->GetPDGMass() / MeV;
454#endif
455
456 minDeltaMass = theRealNeutronMass + theRealChargedPiMass + 0.5;
457 minDeltaMass2 = minDeltaMass*minDeltaMass;
458 minDeltaMassRndm = std::atan((minDeltaMass-effectiveDeltaMass)*2./effectiveDeltaWidth);
459
460 piPlusWidth = theChargedPiWidth;
461 piMinusWidth = theChargedPiWidth;
462 piZeroWidth = thePiZeroWidth;
463 etaWidth = theEtaWidth;
464 omegaWidth = theOmegaWidth;
465 etaPrimeWidth = theEtaPrimeWidth;
466
467 SigmaMinusWidth = theSigmaMinusWidth;
468 SigmaPlusWidth = theSigmaPlusWidth;
469 SigmaZeroWidth = theSigmaZeroWidth;
470 LambdaWidth = theLambdaWidth;
471 KPlusWidth = theChargedKaonWidth;
472 KMinusWidth = theChargedKaonWidth;
473 KShortWidth = theKShortWidth;
474 KLongWidth = theKLongWidth;
475
476 // Initialise HFB tables
477#ifdef INCLXX_IN_GEANT4_MODE
478 HFB::initialize();
479#else
480 HFB::initialize(dataFilePath);
481#endif
482
483 // Initialise the separation-energy function
484 if(!theConfig || theConfig->getSeparationEnergyType()==INCLSeparationEnergy)
485 getSeparationEnergy = getSeparationEnergyINCL;
486 else if(theConfig->getSeparationEnergyType()==RealSeparationEnergy)
487 getSeparationEnergy = getSeparationEnergyReal;
488 else if(theConfig->getSeparationEnergyType()==RealForLightSeparationEnergy)
489 getSeparationEnergy = getSeparationEnergyRealForLight;
490 else {
491 INCL_FATAL("Unrecognized separation-energy type in ParticleTable initialization: " << theConfig->getSeparationEnergyType() << '\n');
492 return;
493 }
494
495 // Initialise the Fermi-momentum function
496 if(!theConfig || theConfig->getFermiMomentumType()==ConstantFermiMomentum) {
497 getFermiMomentum = ParticleTable::getFermiMomentumConstant;
498 if(theConfig) {
499 const G4double aFermiMomentum = theConfig->getFermiMomentum();
500 if(aFermiMomentum>0.)
501 constantFermiMomentum = aFermiMomentum;
502 else
503 constantFermiMomentum = PhysicalConstants::Pf;
504 } else {
505 constantFermiMomentum = PhysicalConstants::Pf;
506 }
507 } else if(theConfig->getFermiMomentumType()==ConstantLightFermiMomentum)
508 getFermiMomentum = ParticleTable::getFermiMomentumConstantLight;
509 else if(theConfig->getFermiMomentumType()==MassDependentFermiMomentum)
510 getFermiMomentum = ParticleTable::getFermiMomentumMassDependent;
511 else {
512 INCL_FATAL("Unrecognized Fermi-momentum type in ParticleTable initialization: " << theConfig->getFermiMomentumType() << '\n');
513 return;
514 }
515
516 // Initialise the r-p correlation coefficients
517 std::fill(rpCorrelationCoefficient, rpCorrelationCoefficient + UnknownParticle, 1.);
518 if(theConfig) {
519 rpCorrelationCoefficient[Proton] = theConfig->getRPCorrelationCoefficient(Proton);
520 rpCorrelationCoefficient[Neutron] = theConfig->getRPCorrelationCoefficient(Neutron);
521 }
522
523 // Initialise the neutron-skin parameters
524 if(theConfig) {
525 neutronSkin = theConfig->getNeutronSkin();
526 neutronHalo = theConfig->getNeutronHalo();
527 }
528
529 }
INCL_FATAL
#define INCL_FATAL(x)
Definition G4INCLLogger.hh:216
G4ParticleTable::GetIonTable
G4IonTable * GetIonTable() const
Definition G4ParticleTable.cc:588
G4ParticleTable::FindParticle
G4ParticleDefinition * FindParticle(G4int PDGEncoding)
Definition G4ParticleTable.cc:498
G4ParticleTable::GetParticleTable
static G4ParticleTable * GetParticleTable()
Definition G4ParticleTable.cc:82
G4INCL::ParticleTable::getTableParticleMass
G4ThreadLocal ParticleMassFn getTableParticleMass
Static pointer to the mass function for particles.
Definition G4INCLParticleTable.cc:1438

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

1370 {
1371 // Normalize the element name
1372 std::transform(pS.begin(), pS.end(), pS.begin(), ::tolower);
1373 pS[0] = (char)std::toupper(pS[0]);
1374
1375 const std::string *iter = std::find(elementTable, elementTable+elementTableSize, pS);
1376 if(iter != elementTable+elementTableSize)
1377 return G4int(iter - elementTable);
1378 else
1379 return ParticleTable::parseIUPACElement(pS);
1380 }
G4int
int G4int
Definition G4Types.hh:85

◆ 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
pSa normalised string (lowercase)
Returns
the charge number of the nuclide, or zero on fail

Definition at line 1382 of file G4INCLParticleTable.cc.

1382 {
1383 // Normalise to lower case
1384 std::string elementName(sel);
1385 std::transform(elementName.begin(), elementName.end(), elementName.begin(), ::tolower);
1386 // Return 0 if the element name contains anything but IUPAC digits
1387 if(elementName.find_first_not_of(elementIUPACDigits)!=std::string::npos)
1388 return 0;
1389 std::transform(elementName.begin(), elementName.end(), elementName.begin(), iupacToInt);
1390 std::stringstream elementStream(elementName);
1391 G4int Z;
1392 elementStream >> Z;
1393 return Z;
1394 }

Referenced by parseElement().

◆ setLambdaSeparationEnergy()

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

Definition at line 1349 of file G4INCLParticleTable.cc.

1349{ lambdaSeparationEnergy = sen; }

◆ setNeutronSeparationEnergy()

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

Setter for protonSeparationEnergy.

Definition at line 1347 of file G4INCLParticleTable.cc.

1347{ neutronSeparationEnergy = sen; }

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

◆ setProtonSeparationEnergy()

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

Setter for protonSeparationEnergy.

Definition at line 1345 of file G4INCLParticleTable.cc.

1345{ protonSeparationEnergy = sen; }

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(), and getSeparationEnergyRealForLight().

◆ clusterTableSSize

const G4int G4INCL::ParticleTable::clusterTableSSize = 4

Definition at line 67 of file G4INCLParticleTable.hh.

◆ clusterTableZSize

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

Definition at line 65 of file G4INCLParticleTable.hh.

Referenced by getFermiMomentumConstantLight(), and getSeparationEnergyRealForLight().

◆ effectiveAntiKaonMass

const G4double G4INCL::ParticleTable::effectiveAntiKaonMass = 497.614

Definition at line 78 of file G4INCLParticleTable.hh.

◆ effectiveDeltaMass

const G4double G4INCL::ParticleTable::effectiveDeltaMass = 1232.0

Definition at line 71 of file G4INCLParticleTable.hh.

Referenced by initialize().

◆ effectiveDeltaWidth

const G4double G4INCL::ParticleTable::effectiveDeltaWidth = 130.0

Definition at line 72 of file G4INCLParticleTable.hh.

Referenced by initialize().

◆ effectiveEtaMass

const G4double G4INCL::ParticleTable::effectiveEtaMass = 547.862

Definition at line 79 of file G4INCLParticleTable.hh.

◆ effectiveEtaPrimeMass

const G4double G4INCL::ParticleTable::effectiveEtaPrimeMass = 957.78

Definition at line 81 of file G4INCLParticleTable.hh.

◆ effectiveKaonMass

const G4double G4INCL::ParticleTable::effectiveKaonMass = 497.614

Definition at line 77 of file G4INCLParticleTable.hh.

◆ effectiveLambdaMass

const G4double G4INCL::ParticleTable::effectiveLambdaMass = 1115.683

Definition at line 74 of file G4INCLParticleTable.hh.

◆ effectiveNucleonMass

const G4double G4INCL::ParticleTable::effectiveNucleonMass = 938.2796

Definition at line 69 of file G4INCLParticleTable.hh.

Referenced by G4INCL::DeltaDecayChannel::computeDecayTime(), G4INCL::Nucleus::computeTotalEnergy(), G4INCL::CrossSectionsINCL46::elasticNNLegacy(), G4INCL::BystrickyEvaluator< N >::eval(), G4INCL::DeltaProductionChannel::fillFinalState(), G4INCL::ElasticChannel::fillFinalState(), G4INCL::CrossSectionsINCL46::NDeltaToNN(), G4INCL::CrossSectionsMultiPions::NDeltaToNN(), G4INCL::CrossSectionsMultiPions::NNElastic(), G4INCL::CrossSectionsMultiPions::NNElasticFixed(), G4INCL::CrossSectionsMultiPions::NNOnePiOrDelta(), G4INCL::CrossSectionsMultiPions::NNThreePi(), G4INCL::CrossSectionsINCL46::NNToNDelta(), G4INCL::CrossSectionsMultiPions::NNTotFixed(), and G4INCL::CrossSectionsMultiPions::NNTwoPi().

◆ 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 80 of file G4INCLParticleTable.hh.

◆ effectivePhotonMass

const G4double G4INCL::ParticleTable::effectivePhotonMass = 0.0

Definition at line 82 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.

◆ effectiveXiMass

const G4double G4INCL::ParticleTable::effectiveXiMass = 1321.71

Definition at line 76 of file G4INCLParticleTable.hh.

◆ getFermiMomentum

G4ThreadLocal FermiMomentumFn G4INCL::ParticleTable::getFermiMomentum = NULL

Definition at line 1440 of file G4INCLParticleTable.cc.

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

◆ getSeparationEnergy

G4ThreadLocal SeparationEnergyFn G4INCL::ParticleTable::getSeparationEnergy = NULL

Static pointer to the separation-energy function.

Definition at line 1439 of file G4INCLParticleTable.cc.

Referenced by initialize().

◆ getTableMass

G4ThreadLocal NuclearMassFn G4INCL::ParticleTable::getTableMass = NULL

Static pointer to the mass function for nuclei.

Definition at line 1437 of file G4INCLParticleTable.cc.

Referenced by G4INCL::ProjectileRemnant::addAllDynamicalSpectators(), G4INCL::ProjectileRemnant::addMostDynamicalSpectators(), G4INCL::Nucleus::computeRecoilKinematics(), G4INCL::ParticleEntryChannel::fillFinalState(), G4INCL::Nucleus::finalizeProjectileRemnant(), G4INCL::KinematicsUtils::gammaFromKineticEnergy(), G4INCL::Nucleus::getConservationBalance(), G4INCL::Particle::getEmissionPbarQvalueCorrection(), G4INCL::Particle::getEmissionQValueCorrection(), G4INCL::Particle::getEmissionQValueCorrection(), getSeparationEnergyReal(), G4INCL::Particle::getTableMass(), getTableQValue(), getTableQValue(), getTableSpeciesMass(), initialize(), G4INCL::PbarAtrestEntryChannel::makeMesonStar(), G4INCL::StandardPropagationModel::shootAtrest(), 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 1438 of file G4INCLParticleTable.cc.

Referenced by G4INCL::KinematicsUtils::gammaFromKineticEnergy(), getSeparationEnergyReal(), G4INCL::Particle::getTableMass(), getTableSpeciesMass(), initialize(), G4INCL::StandardPropagationModel::shootAtrest(), 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 1434 of file G4INCLParticleTable.cc.

Referenced by G4INCL::InteractionAvatar::enforceEnergyConservation(), initialize(), and G4INCL::InteractionAvatar::postInteraction().

◆ minDeltaMass2

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

Definition at line 1435 of file G4INCLParticleTable.cc.

Referenced by initialize().

◆ minDeltaMassRndm

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

Definition at line 1436 of file G4INCLParticleTable.cc.

Referenced by initialize().