Geant4 11.4.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
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.
G4double getantiProtonSeparationEnergy ()
 Getter for antiprotonSeparationEnergy.
G4double getantiNeutronSeparationEnergy ()
 Getter for antineutronSeparationEnergy.
G4double getantiLambdaSeparationEnergy ()
 Getter for antilambdaSeparationEnergy.
G4double getLambdaSeparationEnergy ()
 Getter for lambdaSeparationEnergy.
void setProtonSeparationEnergy (const G4double s)
 Setter for protonSeparationEnergy.
void setNeutronSeparationEnergy (const G4double s)
 Setter for protonSeparationEnergy.
void setLambdaSeparationEnergy (const G4double s)
 Setter for lambdaSeparationEnergy.
void setantiLambdaSeparationEnergy (const G4double s)
 Setter for antilambdaSeparationEnergy.
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.
G4bool getsrcPairConfig ()
 Get the configuration of src-pair correlations.
G4float getsrcPairDistance ()
 Get the distance between src nucleons.
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).

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

◆ NuclearMassFn

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

Definition at line 240 of file G4INCLParticleTable.hh.

◆ ParticleMassFn

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

Definition at line 241 of file G4INCLParticleTable.hh.

◆ SeparationEnergyFn

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

Definition at line 248 of file G4INCLParticleTable.hh.

Function Documentation

◆ drawRandomNaturalIsotope()

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

Definition at line 1455 of file G4INCLParticleTable.cc.

1455 {
1456 return getNaturalIsotopicDistributions()->drawRandomIsotope(Z);
1457 }

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

◆ getAntiKaonType()

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

Get the type of antikaon.

Definition at line 1602 of file G4INCLParticleTable.cc.

1602 {
1603// assert(isosp == -1 || isosp == 1);
1604 if (isosp == -1) {
1605 return KMinus;
1606 }
1607 else {
1608 return KZeroBar;
1609 }
1610 }

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

◆ getantiLambdaSeparationEnergy()

G4double G4INCL::ParticleTable::getantiLambdaSeparationEnergy ( )

Getter for antilambdaSeparationEnergy.

Definition at line 1392 of file G4INCLParticleTable.cc.

1392{ return antilambdaSeparationEnergy; }

◆ getantiNeutronSeparationEnergy()

G4double G4INCL::ParticleTable::getantiNeutronSeparationEnergy ( )

Getter for antineutronSeparationEnergy.

Definition at line 1396 of file G4INCLParticleTable.cc.

1396{ return antineutronSeparationEnergy; }

◆ getAntiNucleonType()

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

Get the type of antinucleon.

◆ getantiProtonSeparationEnergy()

G4double G4INCL::ParticleTable::getantiProtonSeparationEnergy ( )

Getter for antiprotonSeparationEnergy.

Definition at line 1394 of file G4INCLParticleTable.cc.

1394{ return antiprotonSeparationEnergy; }

◆ getAntiSigmaType()

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

Get the type of antisigma.

Definition at line 1569 of file G4INCLParticleTable.cc.

1569 {
1570// assert(isosp == -2 || isosp == 0 || isosp == 2);
1571 if (isosp == -2) {
1572 return antiSigmaPlus;
1573 }
1574 else if (isosp == 0) {
1575 return antiSigmaZero;
1576 }
1577 else {
1578 return antiSigmaMinus;
1579 }
1580 }

◆ getAntiXiType()

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

Get the type of antidelta.

Definition at line 1582 of file G4INCLParticleTable.cc.

1582 {
1583// assert(isosp == -1 || isosp == 1);
1584 if (isosp == -1) {
1585 return antiXiZero;
1586 }
1587 else {
1588 return antiXiMinus;
1589 }
1590 }

◆ getChargeNumber()

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

Get charge number from particle type.

Definition at line 1094 of file G4INCLParticleTable.cc.

1094 {
1095 switch(t) {
1096 case DeltaPlusPlus:
1097 return 2;
1098 break;
1099 case Proton:
1100 case DeltaPlus:
1101 case PiPlus:
1102 case SigmaPlus:
1103 case KPlus:
1104 case antiSigmaMinus:
1105 case antiXiMinus:
1106 return 1;
1107 break;
1108 case Neutron:
1109 case DeltaZero:
1110 case PiZero:
1111 case SigmaZero:
1112 case Lambda:
1113 case KZero:
1114 case KZeroBar:
1115 case KShort:
1116 case KLong:
1117 case Eta:
1118 case Omega:
1119 case EtaPrime:
1120 case Photon:
1121 case XiZero:
1122 case antiNeutron:
1123 case antiLambda:
1124 case antiSigmaZero:
1125 case antiXiZero:
1126 return 0;
1127 break;
1128 case DeltaMinus:
1129 case PiMinus:
1130 case SigmaMinus:
1131 case KMinus:
1132 case antiProton:
1133 case XiMinus:
1134 case antiSigmaPlus:
1135 return -1;
1136 break;
1137 default:
1138 return 0;
1139 break;
1140 }
1141 }

◆ getDeltaType()

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

Get the type of delta.

Definition at line 1520 of file G4INCLParticleTable.cc.

1520 {
1521// assert(isosp == -3 || isosp == -1 || isosp == 1 || isosp == 3);
1522 if (isosp == -3) {
1523 return DeltaMinus;
1524 }
1525 else if (isosp == -1) {
1526 return DeltaZero;
1527 }
1528 else if (isosp == 1) {
1529 return DeltaPlus;
1530 }
1531 else {
1532 return DeltaPlusPlus;
1533 }
1534 }

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

1406 {
1407 if(Z<1) {
1408 INCL_WARN("getElementName called with Z<1" << '\n');
1409 return elementTable[0];
1410 } else if(Z<elementTableSize)
1411 return elementTable[Z];
1412 else
1413 return getIUPACElementName(Z);
1414 }
INCL_WARN
#define INCL_WARN(x)
Definition G4INCLLogger.hh:232
G4INCL::ParticleTable::getIUPACElementName
std::string getIUPACElementName(const G4int Z)
Get the name of an unnamed element from the IUPAC convention.
Definition G4INCLParticleTable.cc:1416

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

1459 {
1460 return constantFermiMomentum;
1461 }

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

1463 {
1464// assert(Z>0 && A>0 && Z<=A);
1465 if(Z<clusterTableZSize && A<clusterTableASize) {
1466 const G4double rms = momentumRMS[Z][A];
1467 return ((rms>0.) ? rms : momentumRMS[6][12]) * Math::sqrtFiveThirds;
1468 } else
1469 return getFermiMomentumConstant(A,Z);
1470 }
G4double
double G4double
Definition G4Types.hh:83
A
const G4double A[17]
Definition G4WaterStopping.cc:53
G4INCL::Math::sqrtFiveThirds
const G4double sqrtFiveThirds
Definition G4INCLGlobals.hh:77
G4INCL::ParticleTable::getFermiMomentumConstant
G4double getFermiMomentumConstant(const G4int, const G4int)
Return the constant value of the Fermi momentum.
Definition G4INCLParticleTable.cc:1459

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

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

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

1003 {
1004// assert(A>=0);
1005 // For nuclei with Z<0 or Z>A, assume that the exotic charge state is due to pions
1006 // Note that S<0 for lambda
1007 if(Z<0 && S<0)
1008 return (A+S)*neutronMass - S*LambdaMass - Z*getINCLMass(PiMinus);
1009 else if(Z>A && S<0)
1010 return (A+S)*protonMass - S*LambdaMass + (A+S-Z)*getINCLMass(PiPlus);
1011 else if(Z<0)
1012 return (A)*neutronMass - Z*getINCLMass(PiMinus);
1013 else if(Z>A)
1014 return (A)*protonMass + (A-Z)*getINCLMass(PiPlus);
1015 else if(A>1 && S<0)
1016 return Z*(protonMass - protonSeparationEnergy) + (A+S-Z)*(neutronMass - neutronSeparationEnergy) + std::abs(S)*(LambdaMass - lambdaSeparationEnergy);
1017 else if(A>1)
1018 return Z*(protonMass - protonSeparationEnergy) + (A-Z)*(neutronMass - neutronSeparationEnergy);
1019 else if(A==1 && Z==0 && S==0)
1020 return getINCLMass(Neutron);
1021 else if(A==1 && Z==1 && S==0)
1022 return getINCLMass(Proton);
1023 else if(A==1 && Z==0 && S==-1)
1024 return getINCLMass(Lambda);
1025 else
1026 return 0.;
1027 }
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:1003

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::getEmissionQValueCorrection(), G4INCL::Particle::getINCLMass(), getINCLMass(), G4INCL::Particle::getTransferQValueCorrection(), G4INCL::Particle::getTransferQValueCorrection(), initialize(), G4INCL::CrossSectionsStrangeness::omegaNToLK(), G4INCL::CrossSectionsMultiPionsAndResonances::omegaNToPiN(), G4INCL::CrossSectionsStrangeness::omegaNToSK(), 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 824 of file G4INCLParticleTable.cc.

824 {
825 if(pt == Proton) {
826 return protonMass;
827 } else if(pt == Neutron) {
828 return neutronMass;
829 } else if(pt == PiPlus) {
830 return piPlusMass;
831 } else if(pt == PiMinus) {
832 return piMinusMass;
833 } else if(pt == PiZero) {
834 return piZeroMass;
835 } else if(pt == SigmaPlus) {
836 return SigmaPlusMass;
837 } else if(pt == SigmaMinus) {
838 return SigmaMinusMass;
839 } else if(pt == SigmaZero) {
840 return SigmaZeroMass;
841 } else if(pt == Lambda) {
842 return LambdaMass;
843 } else if(pt == antiProton) {
844 return antiProtonMass;
845 } else if(pt == XiMinus) {
846 return XiMinusMass;
847 } else if(pt == XiZero) {
848 return XiZeroMass;
849 } else if(pt == antiNeutron) {
850 return antiNeutronMass;
851 } else if(pt == antiSigmaPlus) {
852 return antiSigmaPlusMass;
853 } else if(pt == antiSigmaMinus) {
854 return antiSigmaMinusMass;
855 } else if(pt == antiSigmaZero) {
856 return antiSigmaZeroMass;
857 } else if(pt == antiLambda) {
858 return antiLambdaMass;
859 } else if(pt == antiXiMinus) {
860 return antiXiMinusMass;
861 } else if(pt == antiXiZero) {
862 return antiXiZeroMass;
863 } else if(pt == KPlus) {
864 return KPlusMass;
865 } else if(pt == KZero) {
866 return KZeroMass;
867 } else if(pt == KZeroBar) {
868 return KZeroBarMass;
869 } else if(pt == KMinus) {
870 return KMinusMass;
871 } else if(pt == KShort) {
872 return KShortMass;
873 } else if(pt == KLong) {
874 return KLongMass;
875 } else if(pt == Eta) {
876 return etaMass;
877 } else if(pt == Omega) {
878 return omegaMass;
879 } else if(pt == EtaPrime) {
880 return etaPrimeMass;
881 } else if(pt == Photon) {
882 return photonMass;
883 } else {
884 INCL_ERROR("getMass : Unknown particle type." << '\n');
885 return 0.0;
886 }
887 }
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 548 of file G4INCLParticleTable.cc.

548 {
549 // Actually this is the 3rd component of isospin (I_z) multiplied by 2!
550 if(t == Proton) {
551 return 1;
552 } else if(t == Neutron) {
553 return -1;
554 } else if(t == PiPlus) {
555 return 2;
556 } else if(t == PiMinus) {
557 return -2;
558 } else if(t == PiZero) {
559 return 0;
560 } else if(t == DeltaPlusPlus) {
561 return 3;
562 } else if(t == DeltaPlus) {
563 return 1;
564 } else if(t == DeltaZero) {
565 return -1;
566 } else if(t == DeltaMinus) {
567 return -3;
568 } else if(t == Lambda) {
569 return 0;
570 } else if(t == SigmaPlus) {
571 return 2;
572 } else if(t == SigmaZero) {
573 return 0;
574 } else if(t == SigmaMinus) {
575 return -2;
576 } else if(t == KPlus) {
577 return 1;
578 } else if(t == KZero) {
579 return -1;
580 } else if(t == KZeroBar) {
581 return 1;
582 } else if(t == KShort) {
583 return 0;
584 } else if(t == KLong) {
585 return 0;
586 } else if(t == KMinus) {
587 return -1;
588 } else if(t == Eta) {
589 return 0;
590 } else if(t == Omega) {
591 return 0;
592 } else if(t == EtaPrime) {
593 return 0;
594 } else if(t == Photon) {
595 return 0;
596 } else if(t == antiProton) {
597 return -1;
598 } else if(t == XiMinus) {
599 return -1;
600 } else if(t == XiZero) {
601 return 1;
602 } else if(t == antiNeutron) {
603 return 1;
604 } else if(t == antiLambda) {
605 return 0;
606 } else if(t == antiSigmaPlus) {
607 return -2;
608 } else if(t == antiSigmaZero) {
609 return 0;
610 } else if(t == antiSigmaMinus) {
611 return 2;
612 } else if(t == antiXiMinus) {
613 return 1;
614 } else if(t == antiXiZero) {
615 return -1;
616 }
617 INCL_ERROR("Requested isospin of an unknown particle!");
618 return -10; // Unknown
619 }

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(), G4INCL::CrossSectionsMultiPions::piNTwoPi(), and G4INCL::CrossSectionsAntiparticles::total().

◆ getIUPACElementName()

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

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

Definition at line 1416 of file G4INCLParticleTable.cc.

1416 {
1417 std::stringstream elementStream;
1418 elementStream << Z;
1419 std::string elementName = elementStream.str();
1420 std::transform(elementName.begin(), elementName.end(), elementName.begin(), intToIUPAC);
1421 elementName[0] = (char)std::toupper(elementName.at(0));
1422 return elementName;
1423 }

Referenced by getElementName().

◆ getKaonType()

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

Get the type of kaon.

Definition at line 1592 of file G4INCLParticleTable.cc.

1592 {
1593// assert(isosp == -1 || isosp == 1);
1594 if (isosp == -1) {
1595 return KZero;
1596 }
1597 else {
1598 return KPlus;
1599 }
1600 }

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 ( )

Getter for lambdaSeparationEnergy.

Definition at line 1390 of file G4INCLParticleTable.cc.

1390{ return lambdaSeparationEnergy; }

◆ getLargestNuclearRadius()

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

Definition at line 1226 of file G4INCLParticleTable.cc.

1226 {
1227 return Math::max(getNuclearRadius(Proton, A, Z), getNuclearRadius(Neutron, A, Z));
1228 }
G4INCL::Math::max
T max(const T t1, const T t2)
brief Return the largest of the two arguments
Definition G4INCLGlobals.hh:113
G4INCL::ParticleTable::getNuclearRadius
G4double getNuclearRadius(const ParticleType t, const G4int A, const G4int Z)
Definition G4INCLParticleTable.cc:1198

Referenced by G4INCL::AntinucleiAtrestEntryChannel::getAnnihilationPosition(), 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 1046 of file G4INCLParticleTable.cc.

1046 {
1047
1048 switch(t) {
1049 case Proton:
1050 case Neutron:
1051 case DeltaPlusPlus:
1052 case DeltaPlus:
1053 case DeltaZero:
1054 case DeltaMinus:
1055 case SigmaPlus:
1056 case SigmaZero:
1057 case SigmaMinus:
1058 case Lambda:
1059 case XiZero:
1060 case XiMinus:
1061 return 1;
1062 break;
1063 case antiProton:
1064 case antiNeutron:
1065 case antiSigmaPlus:
1066 case antiSigmaZero:
1067 case antiSigmaMinus:
1068 case antiLambda:
1069 case antiXiZero:
1070 case antiXiMinus:
1071 return -1;
1072 break;
1073 case PiPlus:
1074 case PiMinus:
1075 case PiZero:
1076 case KPlus:
1077 case KZero:
1078 case KZeroBar:
1079 case KShort:
1080 case KLong:
1081 case KMinus:
1082 case Eta:
1083 case Omega:
1084 case EtaPrime:
1085 case Photon:
1086 return 0;
1087 break;
1088 default:
1089 return 0;
1090 break;
1091 }
1092 }

◆ getMaximumNuclearRadius()

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

Definition at line 1282 of file G4INCLParticleTable.cc.

1282 {
1283 const G4double XFOISA = 8.0;
1284 if(A > 19) {
1285 return getNuclearRadius(t,A,Z) + XFOISA * getSurfaceDiffuseness(t,A,Z);
1286 } else if(A <= 19 && A >= 6) {
1287 return 5.5 + 0.3 * (G4double(A) - 6.0)/12.0;
1288 } else if(A >= 2) {
1289 return getNuclearRadius(t, A, Z) + 4.5;
1290 } else {
1291 INCL_ERROR("getMaximumNuclearRadius : No maximum radius for nucleus A = " << A << " Z = " << Z << '\n');
1292 return 0.0;
1293 }
1294 }
G4INCL::ParticleTable::getSurfaceDiffuseness
G4double getSurfaceDiffuseness(const ParticleType t, const G4int A, const G4int Z)
Definition G4INCLParticleTable.cc:1296

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

1330 {
1331// assert(Z>=0 && A>=0 && Z<=A);
1332 return getFermiMomentum(A,Z) * Math::sqrtThreeFifths;
1333 }
G4INCL::Math::sqrtThreeFifths
const G4double sqrtThreeFifths
Definition G4INCLGlobals.hh:78
G4INCL::ParticleTable::getFermiMomentum
G4ThreadLocal FermiMomentumFn getFermiMomentum
Definition G4INCLParticleTable.cc:1495

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

643 {
644 std::stringstream stream;
645 if(A<0)
646 stream << getElementName(-Z) << "b" << -A;
647 else
648 stream << getElementName(Z) << "-" << A;
649 return stream.str();
650 }
G4INCL::ParticleTable::getElementName
std::string getElementName(const G4int Z)
Get the name of the element from the atomic number.
Definition G4INCLParticleTable.cc:1406

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

652 {
653 std::stringstream stream;
654 if(S >= 0) // S < 0 for hypernuclei
655 return getName(A, Z);
656 else if(S == -1)
657 stream << getElementName(Z) << "-" << A << "_" << "Lambda";
658 else
659 stream << getElementName(Z) << "-" << A << "_" << -S << "-Lambda";
660 return stream.str();
661 }
G4INCL::ParticleTable::getName
std::string getName(const ParticleType t)
Get the native INCL name of the particle.
Definition G4INCLParticleTable.cc:674

◆ getName() [3/4]

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

Get the native INCL name of the particle.

Definition at line 632 of file G4INCLParticleTable.cc.

632 {
633 if(sp.theType==Composite && sp.theS == 0)
634 return getName(sp.theA,sp.theZ);
635 else if(sp.theType==Composite)
636 return getName(sp.theA,sp.theZ,sp.theS);
637 else if(sp.theType==antiComposite)
638 return getName(sp.theA,sp.theZ);
639 else
640 return getName(sp.theType);
641 }

◆ getName() [4/4]

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

Get the native INCL name of the particle.

Definition at line 674 of file G4INCLParticleTable.cc.

674 {
675 if(p == G4INCL::Proton) {
676 return std::string("proton");
677 } else if(p == G4INCL::Neutron) {
678 return std::string("neutron");
679 } else if(p == G4INCL::DeltaPlusPlus) {
680 return std::string("delta++");
681 } else if(p == G4INCL::DeltaPlus) {
682 return std::string("delta+");
683 } else if(p == G4INCL::DeltaZero) {
684 return std::string("delta0");
685 } else if(p == G4INCL::DeltaMinus) {
686 return std::string("delta-");
687 } else if(p == G4INCL::PiPlus) {
688 return std::string("pi+");
689 } else if(p == G4INCL::PiZero) {
690 return std::string("pi0");
691 } else if(p == G4INCL::PiMinus) {
692 return std::string("pi-");
693 } else if(p == G4INCL::Lambda) {
694 return std::string("lambda");
695 } else if(p == G4INCL::SigmaPlus) {
696 return std::string("sigma+");
697 } else if(p == G4INCL::SigmaZero) {
698 return std::string("sigma0");
699 } else if(p == G4INCL::SigmaMinus) {
700 return std::string("sigma-");
701 } else if(p == G4INCL::antiProton) {
702 return std::string("antiproton");
703 } else if(p == G4INCL::XiMinus) {
704 return std::string("xi-");
705 } else if(p == G4INCL::XiZero) {
706 return std::string("xi0");
707 } else if(p == G4INCL::antiNeutron) {
708 return std::string("antineutron");
709 } else if(p == G4INCL::antiSigmaPlus) {
710 return std::string("antisigma+");
711 } else if(p == G4INCL::antiSigmaZero) {
712 return std::string("antisigma0");
713 } else if(p == G4INCL::antiSigmaMinus) {
714 return std::string("antisigma-");
715 } else if(p == G4INCL::antiLambda) {
716 return std::string("antilambda");
717 } else if(p == G4INCL::antiXiMinus) {
718 return std::string("antixi-");
719 } else if(p == G4INCL::antiXiZero) {
720 return std::string("antixi0");
721 } else if(p == G4INCL::KPlus) {
722 return std::string("kaon+");
723 } else if(p == G4INCL::KZero) {
724 return std::string("kaon0");
725 } else if(p == G4INCL::KZeroBar) {
726 return std::string("kaon0bar");
727 } else if(p == G4INCL::KMinus) {
728 return std::string("kaon-");
729 } else if(p == G4INCL::KShort) {
730 return std::string("kaonshort");
731 } else if(p == G4INCL::KLong) {
732 return std::string("kaonlong");
733 } else if(p == G4INCL::Composite) {
734 return std::string("composite");
735 } else if(p == G4INCL::Eta) {
736 return std::string("eta");
737 } else if(p == G4INCL::Omega) {
738 return std::string("omega");
739 } else if(p == G4INCL::EtaPrime) {
740 return std::string("etaprime");
741 } else if(p == G4INCL::Photon) {
742 return std::string("photon");
743 } else if(p == G4INCL::antiComposite){
744 return std::string("anticomposite");
745 }
746 return std::string("unknown");
747 }

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

1451 {
1452 return getNaturalIsotopicDistributions()->getIsotopicDistribution(Z);
1453 }

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

◆ getNeutronHalo()

G4double G4INCL::ParticleTable::getNeutronHalo ( )

Get the size of the neutron halo.

Definition at line 1487 of file G4INCLParticleTable.cc.

1487{ return neutronHalo; }

◆ getNeutronSeparationEnergy()

G4double G4INCL::ParticleTable::getNeutronSeparationEnergy ( )

Getter for neutronSeparationEnergy.

Definition at line 1388 of file G4INCLParticleTable.cc.

1388{ return neutronSeparationEnergy; }

◆ getNeutronSkin()

G4double G4INCL::ParticleTable::getNeutronSkin ( )

Get the thickness of the neutron skin.

Definition at line 1485 of file G4INCLParticleTable.cc.

1485{ return neutronSkin; }

◆ getNuclearRadius()

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

Definition at line 1198 of file G4INCLParticleTable.cc.

1198 {
1199// assert(A>=0);
1200 if(A > 19 || (A < 6 && A >= 2)) {
1201 // For large (Woods-Saxon or Modified Harmonic Oscillator) or small
1202 // (Gaussian) nuclei, the radius parameter is just the nuclear radius
1203 return getRadiusParameter(t,A,Z);
1204 } else if(A < clusterTableASize && Z>=0 && Z < clusterTableZSize && A >= 6) {
1205 const G4double thisRMS = positionRMS[Z][A];
1206 if(thisRMS>0.0)
1207 return thisRMS;
1208 else {
1209 INCL_DEBUG("getNuclearRadius: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'
1210 << "returning radius for C12");
1211 return positionRMS[6][12];
1212 }
1213 } else if(A <= 19) {
1214 const G4double theRadiusParameter = getRadiusParameter(t, A, Z);
1215 const G4double theDiffusenessParameter = getSurfaceDiffuseness(t, A, Z);
1216 // The formula yields the nuclear RMS radius based on the parameters of
1217 // the nuclear-density function
1218 return 1.225*theDiffusenessParameter*
1219 std::sqrt((2.+5.*theRadiusParameter)/(2.+3.*theRadiusParameter));
1220 } else {
1221 INCL_ERROR("getNuclearRadius: No radius for nucleus A = " << A << " Z = " << Z << '\n');
1222 return 0.0;
1223 }
1224 }
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:1230

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

1510 {
1511// assert(isosp == -1 || isosp == 1);
1512 if (isosp == -1) {
1513 return Neutron;
1514 }
1515 else {
1516 return Proton;
1517 }
1518 }

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

1497 {
1498// assert(isosp == -2 || isosp == 0 || isosp == 2);
1499 if (isosp == -2) {
1500 return PiMinus;
1501 }
1502 else if (isosp == 0) {
1503 return PiZero;
1504 }
1505 else {
1506 return PiPlus;
1507 }
1508 }

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

1386{ return protonSeparationEnergy; }

◆ getRadiusParameter()

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

Definition at line 1230 of file G4INCLParticleTable.cc.

1230 {
1231// assert(A>0);
1232 if(A > 19) {
1233 // radius fit for lambdas
1234 if(t==Lambda){
1235 G4double r0 = (1.128+0.439*std::pow(A,-2./3.)) * std::pow(A, 1.0/3.0);
1236 return r0;
1237 }
1238 // phenomenological radius fit
1239 G4double r0 = (2.745e-4 * A + 1.063) * std::pow(A, 1.0/3.0);
1240 // HFB calculations
1241 if(getRPCorrelationCoefficient(t)<1.){
1242 G4double r0hfb = HFB::getRadiusParameterHFB(t,A,Z);
1243 if(r0hfb>0.)r0 = r0hfb;
1244 }
1245 //
1246 if(t==Neutron)
1247 r0 += neutronSkin;
1248 return r0;
1249 } else if(A < 6 && A >= 2) {
1250 if(Z<clusterTableZSize && Z>=0) {
1251 const G4double thisRMS = positionRMS[Z][A];
1252 if(thisRMS>0.0)
1253 return thisRMS;
1254 else {
1255 INCL_DEBUG("getRadiusParameter: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'
1256 << "returning radius for C12");
1257 return positionRMS[6][12];
1258 }
1259 } else {
1260 INCL_DEBUG("getRadiusParameter: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'
1261 << "returning radius for C12");
1262 return positionRMS[6][12];
1263 }
1264 } else if(A <= 19 && A >= 6) {
1265 if(t==Lambda){
1266 G4double r0 = (1.128+0.439*std::pow(A,-2./3.)) * std::pow(A, 1.0/3.0);
1267 return r0;
1268 }
1269 // HFB calculations
1270 if(getRPCorrelationCoefficient(t)<1.){
1271 G4double r0hfb = HFB::getSurfaceDiffusenessHFB(t,A,Z);
1272 if(r0hfb>0.)return r0hfb;
1273 }
1274 return mediumRadius[A-1];
1275 // return 1.581*mediumDiffuseness[A-1]*(2.+5.*mediumRadius[A-1])/(2.+3.*mediumRadius[A-1]);
1276 } else {
1277 INCL_ERROR("getRadiusParameter: No radius for nucleus A = " << A << " Z = " << Z << '\n');
1278 return 0.0;
1279 }
1280 }
G4INCL::HFB::getSurfaceDiffusenessHFB
G4double getSurfaceDiffusenessHFB(const ParticleType t, const G4int A, const G4int Z)
Definition G4INCLHFB.cc:142
G4INCL::HFB::getRadiusParameterHFB
G4double getRadiusParameterHFB(const ParticleType t, const G4int A, const G4int Z)
Get the radius and diffuseness parameters from HFB calculations.
Definition G4INCLHFB.cc:132
G4INCL::ParticleTable::getRPCorrelationCoefficient
G4double getRPCorrelationCoefficient(const ParticleType t)
Get the value of the r-p correlation coefficient.
Definition G4INCLParticleTable.cc:1480

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

889 {
890 switch(t) {
891 case Proton:
892 return theRealProtonMass;
893 break;
894 case Neutron:
895 return theRealNeutronMass;
896 break;
897 case PiPlus:
898 case PiMinus:
899 return theRealChargedPiMass;
900 break;
901 case PiZero:
902 return theRealPiZeroMass;
903 break;
904 case Eta:
905 return theRealEtaMass;
906 break;
907 case Omega:
908 return theRealOmegaMass;
909 break;
910 case EtaPrime:
911 return theRealEtaPrimeMass;
912 break;
913 case Photon:
914 return theRealPhotonMass;
915 break;
916 case Lambda:
917 return theRealLambdaMass;
918 break;
919 case KPlus:
920 case KMinus:
921 return theRealChargedKaonMass;
922 break;
923 case KZero:
924 case KZeroBar:
925 case KShort:
926 case KLong:
927 return theRealNeutralKaonMass;
928 break;
929 case SigmaPlus:
930 return theRealSigmaPlusMass;
931 break;
932 case SigmaZero:
933 return theRealSigmaZeroMass;
934 break;
935 case SigmaMinus:
936 return theRealSigmaMinusMass;
937 break;
938 case antiProton:
939 return theRealAntiProtonMass;
940 break;
941 case XiMinus:
942 return theRealXiMinusMass;
943 break;
944 case XiZero:
945 return theRealXiZeroMass;
946 break;
947 case antiNeutron:
948 return theRealAntiNeutronMass;
949 break;
950 case antiSigmaPlus:
951 return theRealAntiSigmaPlusMass;
952 break;
953 case antiSigmaZero:
954 return theRealAntiSigmaZeroMass;
955 break;
956 case antiSigmaMinus:
957 return theRealAntiSigmaMinusMass;
958 break;
959 case antiXiMinus:
960 return theRealAntiXiMinusMass;
961 break;
962 case antiXiZero:
963 return theRealAntiXiZeroMass;
964 break;
965 case antiLambda:
966 return theRealAntiLambdaMass;
967 break;
968 default:
969 INCL_ERROR("Particle::getRealMass : Unknown particle type." << '\n');
970 return 0.0;
971 break;
972 }
973 }

Referenced by G4INCL::Nucleus::computeTotalEnergy(), G4INCL::EventInfo::fillInverseKinematics(), G4INCL::Particle::getRealMass(), getRealMass(), initialize(), G4INCL::CrossSectionsAntiparticles::NNbarToAnnihilation(), 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 975 of file G4INCLParticleTable.cc.

975 {
976// assert(A>=0);
977 // For nuclei with Z<0 or Z>A, assume that the exotic charge state is due to pions
978 if(Z<0 && S<0)
979 return (A+S)*theRealNeutronMass - S*LambdaMass - Z*getRealMass(PiMinus);
980 else if(Z>A && S<0)
981 return (A+S)*theRealProtonMass - S*LambdaMass + (A+S-Z)*getRealMass(PiPlus);
982 if(Z<0)
983 return (A)*theRealNeutronMass - Z*getRealMass(PiMinus);
984 else if(Z>A)
985 return (A)*theRealProtonMass + (A-Z)*getRealMass(PiPlus);
986 else if(Z==0 && S==0)
987 return A*theRealNeutronMass;
988 else if(A==Z)
989 return A*theRealProtonMass;
990 else if(Z==0 && S<0)
991 return (A+S)*theRealNeutronMass-S*LambdaMass;
992 else if(A>1) {
993#ifndef INCLXX_IN_GEANT4_MODE
994 return ::G4INCL::NuclearMassTable::getMass(A,Z,S);
995#else
996 if(S<0) return theG4IonTable->GetNucleusMass(Z,A,std::abs(S)) / MeV;
997 else return theG4IonTable->GetNucleusMass(Z,A) / MeV;
998#endif
999 } else
1000 return 0.;
1001 }
G4INCL::ParticleTable::getRealMass
G4double getRealMass(const G4INCL::ParticleType t)
Get particle mass (in MeV/c^2).
Definition G4INCLParticleTable.cc:889

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

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

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

1335 {
1336 if(t==Proton)
1337 return theINCLProtonSeparationEnergy;
1338 else if(t==Neutron)
1339 return theINCLNeutronSeparationEnergy;
1340 else if(t==Lambda)
1341 return theINCLLambdaSeparationEnergy;
1342 else if(t==antiLambda)
1343 return theINCLantiLambdaSeparationEnergy;
1344 else if(t==antiProton)
1345 return theINCLantiProtonSeparationEnergy;
1346 else if(t==antiNeutron)
1347 return theINCLantiNeutronSeparationEnergy;
1348 else {
1349 INCL_ERROR("ParticleTable::getSeparationEnergyINCL : Unknown particle type." << '\n');
1350 return 0.0;
1351 }
1352 }

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

1354 {
1355 // Real separation energies for all nuclei
1356 if(t==Proton)
1357 return (*getTableParticleMass)(Proton) + (*getTableMass)(A-1,Z-1,0) - (*getTableMass)(A,Z,0);
1358 else if(t==Neutron)
1359 return (*getTableParticleMass)(Neutron) + (*getTableMass)(A-1,Z,0) - (*getTableMass)(A,Z,0);
1360 else if(t==Lambda)
1361 return (*getTableParticleMass)(Lambda) + (*getTableMass)(A-1,Z,0) - (*getTableMass)(A,Z,-1);
1362 else if(t==antiLambda)
1363 return (*getTableParticleMass)(antiLambda) + (*getTableMass)(A+1,Z,0) - (*getTableMass)(A,Z,+1);
1364 else if(t==antiProton)
1365 return (*getTableParticleMass)(antiProton) + (*getTableMass)(A+1,Z+1,0) - (*getTableMass)(A,Z,0);
1366 else if(t==antiNeutron)
1367 return (*getTableParticleMass)(antiNeutron) + (*getTableMass)(A+1,Z,0) - (*getTableMass)(A,Z,0);
1368 else {
1369 INCL_ERROR("ParticleTable::getSeparationEnergyReal : Unknown particle type." << '\n');
1370 return 0.0;
1371 }
1372 }
G4INCL::ParticleTable::getTableMass
G4ThreadLocal NuclearMassFn getTableMass
Static pointer to the mass function for nuclei.
Definition G4INCLParticleTable.cc:1492
G4INCL::ParticleTable::getTableParticleMass
G4ThreadLocal ParticleMassFn getTableParticleMass
Static pointer to the mass function for particles.
Definition G4INCLParticleTable.cc:1493

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

1374 {
1375 // Real separation energies for light nuclei, fixed values for heavy nuclei
1376 if(Z<clusterTableZSize && A<clusterTableASize)
1377 return getSeparationEnergyReal(t, A, Z);
1378 else
1379 return getSeparationEnergyINCL(t, A, Z);
1380 }
G4INCL::ParticleTable::getSeparationEnergyReal
G4double getSeparationEnergyReal(const ParticleType t, const G4int A, const G4int Z)
Return the real separation energy.
Definition G4INCLParticleTable.cc:1354
G4INCL::ParticleTable::getSeparationEnergyINCL
G4double getSeparationEnergyINCL(const ParticleType t, const G4int, const G4int)
Return INCL's default separation energy.
Definition G4INCLParticleTable.cc:1335

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

663 {
664 std::stringstream stream;
665 if(A>0)
666 stream << getElementName(Z) << A;
667 else if(A<0)
668 stream << getElementName(-Z) << "b" << -A;
669 else
670 stream << getElementName(Z);
671 return stream.str();
672 }

◆ getShortName() [2/3]

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

Get the short INCL name of the particle.

Definition at line 621 of file G4INCLParticleTable.cc.

621 {
622 if(sp.theType==Composite && sp.theS == 0)
623 return getShortName(sp.theA,sp.theZ);
624 else if(sp.theType==Composite)
625 return getName(sp.theA,sp.theZ,sp.theS);
626 else if (sp.theType==antiComposite)
627 return getShortName(sp.theA,sp.theZ);
628 else
629 return getShortName(sp.theType);
630 }
G4INCL::ParticleTable::getShortName
std::string getShortName(const ParticleType t)
Get the short INCL name of the particle.
Definition G4INCLParticleTable.cc:749

◆ getShortName() [3/3]

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

Get the short INCL name of the particle.

Definition at line 749 of file G4INCLParticleTable.cc.

749 {
750 if(p == G4INCL::Proton) {
751 return std::string("p");
752 } else if(p == G4INCL::Neutron) {
753 return std::string("n");
754 } else if(p == G4INCL::DeltaPlusPlus) {
755 return std::string("d++");
756 } else if(p == G4INCL::DeltaPlus) {
757 return std::string("d+");
758 } else if(p == G4INCL::DeltaZero) {
759 return std::string("d0");
760 } else if(p == G4INCL::DeltaMinus) {
761 return std::string("d-");
762 } else if(p == G4INCL::PiPlus) {
763 return std::string("pi+");
764 } else if(p == G4INCL::PiZero) {
765 return std::string("pi0");
766 } else if(p == G4INCL::PiMinus) {
767 return std::string("pi-");
768 } else if(p == G4INCL::Lambda) {
769 return std::string("l");
770 } else if(p == G4INCL::SigmaPlus) {
771 return std::string("s+");
772 } else if(p == G4INCL::SigmaZero) {
773 return std::string("s0");
774 } else if(p == G4INCL::SigmaMinus) {
775 return std::string("s-");
776 } else if(p == G4INCL::antiProton) {
777 return std::string("pb");
778 } else if(p == G4INCL::XiMinus) {
779 return std::string("x-");
780 } else if(p == G4INCL::XiZero) {
781 return std::string("x0");
782 } else if(p == G4INCL::antiNeutron) {
783 return std::string("nb");
784 } else if(p == G4INCL::antiSigmaPlus) {
785 return std::string("s+b");
786 } else if(p == G4INCL::antiSigmaZero) {
787 return std::string("s0b");
788 } else if(p == G4INCL::antiSigmaMinus) {
789 return std::string("s-b");
790 } else if(p == G4INCL::antiLambda) {
791 return std::string("lb");
792 } else if(p == G4INCL::antiXiMinus) {
793 return std::string("x-b");
794 } else if(p == G4INCL::antiXiZero) {
795 return std::string("x0b");
796 } else if(p == G4INCL::KPlus) {
797 return std::string("k+");
798 } else if(p == G4INCL::KZero) {
799 return std::string("k0");
800 } else if(p == G4INCL::KZeroBar) {
801 return std::string("k0b");
802 } else if(p == G4INCL::KMinus) {
803 return std::string("k-");
804 } else if(p == G4INCL::KShort) {
805 return std::string("ks");
806 } else if(p == G4INCL::KLong) {
807 return std::string("kl");
808 } else if(p == G4INCL::Composite) {
809 return std::string("comp");
810 } else if(p == G4INCL::Eta) {
811 return std::string("eta");
812 } else if(p == G4INCL::Omega) {
813 return std::string("omega");
814 } else if(p == G4INCL::EtaPrime) {
815 return std::string("etap");
816 } else if(p == G4INCL::Photon) {
817 return std::string("photon");
818 } else if(p == G4INCL::antiComposite) {
819 return std::string("anticomp");
820 }
821 return std::string("unknown");
822 }

Referenced by getShortName().

◆ getSigmaType()

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

Get the type of sigma.

Definition at line 1536 of file G4INCLParticleTable.cc.

1536 {
1537// assert(isosp == -2 || isosp == 0 || isosp == 2);
1538 if (isosp == -2) {
1539 return SigmaMinus;
1540 }
1541 else if (isosp == 0) {
1542 return SigmaZero;
1543 }
1544 else {
1545 return SigmaPlus;
1546 }
1547 }

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

◆ getsrcPairConfig()

G4bool G4INCL::ParticleTable::getsrcPairConfig ( )

Get the configuration of src-pair correlations.

Definition at line 1382 of file G4INCLParticleTable.cc.

1382{ return srcPairConfig; }

Referenced by G4INCL::BinaryCollisionAvatar::getChannel().

◆ getsrcPairDistance()

G4float G4INCL::ParticleTable::getsrcPairDistance ( )

Get the distance between src nucleons.

Definition at line 1384 of file G4INCLParticleTable.cc.

1384{ return srcPairDist; }

Referenced by G4INCL::SrcChannel::SrcChannel().

◆ getStrangenessNumber()

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

Get strangeness number from particle type.

Definition at line 1143 of file G4INCLParticleTable.cc.

1143 {
1144 switch(t) {
1145 case DeltaPlusPlus:
1146 case DeltaPlus:
1147 case DeltaZero:
1148 case DeltaMinus:
1149 case Proton:
1150 case Neutron:
1151 case PiPlus:
1152 case PiZero:
1153 case PiMinus:
1154 case Eta:
1155 case Omega:
1156 case EtaPrime:
1157 case Photon:
1158 case antiProton:
1159 case antiNeutron:
1160 return 0;
1161 break;
1162 case XiMinus:
1163 case XiZero:
1164 case antiXiMinus:
1165 case antiXiZero:
1166 return 2;
1167 break;
1168 case antiLambda:
1169 case antiSigmaPlus:
1170 case antiSigmaZero:
1171 case antiSigmaMinus:
1172 return 1;
1173 break;
1174 case Lambda:
1175 case SigmaPlus:
1176 case SigmaZero:
1177 case SigmaMinus:
1178 case KZeroBar:
1179 case KMinus:
1180 return -1;
1181 break;
1182 case KPlus:
1183 case KZero:
1184 return 1;
1185 break;
1186 case KShort:
1187 return 0;
1188 break;
1189 case KLong:
1190 return 0;
1191 break;
1192 default:
1193 return 0;
1194 break;
1195 }
1196 }

◆ getSurfaceDiffuseness()

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

Definition at line 1296 of file G4INCLParticleTable.cc.

1296 {
1297 if(A > 19) {
1298 // phenomenological fit
1299 G4double a = 1.63e-4 * A + 0.510;
1300 // HFB calculations
1301 if(getRPCorrelationCoefficient(t)<1.){
1302 G4double ahfb = HFB::getSurfaceDiffusenessHFB(t,A,Z);
1303 if(ahfb>0.)a=ahfb;
1304 }
1305 //
1306 if(t==Lambda){
1307 // Like for neutrons
1308 G4double ahfb = HFB::getSurfaceDiffusenessHFB(Neutron,A,Z);
1309 if(ahfb>0.)a=ahfb;
1310 }
1311 if(t==Neutron)
1312 a += neutronHalo;
1313 return a;
1314 } else if(A <= 19 && A >= 6) {
1315 // HFB calculations
1316 if(getRPCorrelationCoefficient(t)<1.){
1317 G4double ahfb = HFB::getRadiusParameterHFB(t,A,Z);
1318 if(ahfb>0.)return ahfb;
1319 }
1320 return mediumDiffuseness[A-1];
1321 } else if(A < 6 && A >= 2) {
1322 INCL_ERROR("getSurfaceDiffuseness: was called for A = " << A << " Z = " << Z << '\n');
1323 return 0.0;
1324 } else {
1325 INCL_ERROR("getSurfaceDiffuseness: No diffuseness for nucleus A = " << A << " Z = " << Z << '\n');
1326 return 0.0;
1327 }
1328 }

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

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

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

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

◆ getTableSpeciesMass()

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

Definition at line 1037 of file G4INCLParticleTable.cc.

1037 {
1038 if(p.theType == Composite)
1039 return (*getTableMass)(p.theA, p.theZ, p.theS);
1040 else if (p.theType == antiComposite)
1041 return (*getTableMass)(-p.theA,-p.theZ,p.theS);
1042 else
1043 return (*getTableParticleMass)(p.theType);
1044 }

◆ getWidth()

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

Get particle width (in s).

Definition at line 1612 of file G4INCLParticleTable.cc.

1612 {
1613// 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 || );
1614 if(pt == PiPlus) {
1615 return piPlusWidth;
1616 } else if(pt == PiMinus) {
1617 return piMinusWidth;
1618 } else if(pt == PiZero) {
1619 return piZeroWidth;
1620 } else if(pt == Eta) {
1621 return etaWidth;
1622 } else if(pt == Omega) {
1623 return omegaWidth;
1624 } else if(pt == EtaPrime) {
1625 return etaPrimeWidth;
1626 } else if(pt == SigmaPlus) {
1627 return SigmaPlusWidth;
1628 } else if(pt == SigmaZero) {
1629 return SigmaZeroWidth;
1630 } else if(pt == SigmaMinus) {
1631 return SigmaMinusWidth;
1632 } else if(pt == KPlus) {
1633 return KPlusWidth;
1634 } else if(pt == KMinus) {
1635 return KMinusWidth;
1636 } else if(pt == KShort) {
1637 return KShortWidth;
1638 } else if(pt == KLong) {
1639 return KLongWidth;
1640 } else if(pt == Lambda) {
1641 return LambdaWidth;
1642 } else if(pt == XiMinus) {
1643 return XiMinusWidth;
1644 } else if(pt == XiZero) {
1645 return XiZeroWidth;
1646 } else if(pt == antiSigmaPlus) {
1647 return antiSigmaPlusWidth;
1648 } else if(pt == antiSigmaZero) {
1649 return antiSigmaZeroWidth;
1650 } else if(pt == antiSigmaMinus) {
1651 return antiSigmaMinusWidth;
1652 } else if(pt == antiLambda) {
1653 return antiLambdaWidth;
1654 } else if(pt == antiXiMinus) {
1655 return antiXiMinusWidth;
1656 } else if(pt == antiXiZero) {
1657 return antiXiZeroWidth;
1658 } else {
1659 INCL_ERROR("getWidth : Unknown particle type." << '\n');
1660 return 0.0;
1661 }
1662 }

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

1549 {
1550// assert(isosp == -1 || isosp == 1);
1551 if (isosp == -1) {
1552 return XiMinus;
1553 }
1554 else {
1555 return XiZero;
1556 }
1557 }

◆ initialize()

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

Initialize the particle table.

Definition at line 390 of file G4INCLParticleTable.cc.

390 {
391 protonMass = theINCLNucleonMass;
392 neutronMass = theINCLNucleonMass;
393 piPlusMass = theINCLPionMass;
394 piMinusMass = theINCLPionMass;
395 piZeroMass = theINCLPionMass;
396
397 etaMass = theINCLEtaMass;
398 omegaMass = theINCLOmegaMass;
399 etaPrimeMass = theINCLEtaPrimeMass;
400 photonMass = theINCLPhotonMass;
401
402 SigmaPlusMass = theRealSigmaPlusMass;
403 SigmaMinusMass = theRealSigmaMinusMass;
404 SigmaZeroMass = theRealSigmaZeroMass;
405 LambdaMass = theINCLLambdaMass;
406 KPlusMass = theRealChargedKaonMass;
407 KZeroMass = theRealNeutralKaonMass;
408 KZeroBarMass = theRealNeutralKaonMass;
409 KShortMass = theRealNeutralKaonMass;
410 KLongMass = theRealNeutralKaonMass;
411 KMinusMass = theRealChargedKaonMass;
412
413 antiProtonMass = theRealAntiProtonMass;
414 XiZeroMass = theRealXiZeroMass;
415 XiMinusMass = theRealXiMinusMass;
416 antiNeutronMass = theRealAntiNeutronMass;
417 antiSigmaPlusMass = theRealAntiSigmaPlusMass;
418 antiSigmaMinusMass = theRealAntiSigmaMinusMass;
419 antiSigmaZeroMass = theRealAntiSigmaZeroMass;
420 antiLambdaMass = theRealAntiLambdaMass; //!
421 antiXiZeroMass = theRealAntiXiZeroMass;
422 antiXiMinusMass = theRealAntiXiMinusMass;
423
424 if(theConfig && theConfig->getUseRealMasses()) {
425 getTableMass = getRealMass;
426 getTableParticleMass = getRealMass;
427 } else {
428 getTableMass = getINCLMass;
429 getTableParticleMass = getINCLMass;
430 }
431
432#ifndef INCLXX_IN_GEANT4_MODE
433 std::string dataFilePath;
434 if(theConfig)
435 dataFilePath = theConfig->getINCLXXDataFilePath();
436 NuclearMassTable::initialize(dataFilePath, getRealMass(Proton), getRealMass(Neutron));
437#endif
438
439#ifdef INCLXX_IN_GEANT4_MODE
440 G4ParticleTable *theG4ParticleTable = G4ParticleTable::GetParticleTable();
441 theG4IonTable = theG4ParticleTable->GetIonTable();
442 theRealProtonMass = theG4ParticleTable->FindParticle("proton")->GetPDGMass() / MeV;
443 theRealNeutronMass = theG4ParticleTable->FindParticle("neutron")->GetPDGMass() / MeV;
444 theRealChargedPiMass = theG4ParticleTable->FindParticle("pi+")->GetPDGMass() / MeV;
445 theRealPiZeroMass = theG4ParticleTable->FindParticle("pi0")->GetPDGMass() / MeV;
446
447 theRealEtaMass = theG4ParticleTable->FindParticle("eta")->GetPDGMass() / MeV;
448 theRealOmegaMass = theG4ParticleTable->FindParticle("omega")->GetPDGMass() / MeV;
449 theRealEtaPrimeMass = theG4ParticleTable->FindParticle("eta_prime")->GetPDGMass() / MeV;
450 theRealPhotonMass = theG4ParticleTable->FindParticle("gamma")->GetPDGMass() / MeV;
451
452 theRealSigmaPlusMass = theG4ParticleTable->FindParticle("sigma+")->GetPDGMass() / MeV;
453 theRealSigmaZeroMass = theG4ParticleTable->FindParticle("sigma0")->GetPDGMass() / MeV;
454 theRealSigmaMinusMass = theG4ParticleTable->FindParticle("sigma-")->GetPDGMass() / MeV;
455 theRealLambdaMass = theG4ParticleTable->FindParticle("lambda")->GetPDGMass() / MeV;
456 theRealChargedKaonMass = theG4ParticleTable->FindParticle("kaon+")->GetPDGMass() / MeV;
457 theRealNeutralKaonMass = theG4ParticleTable->FindParticle("kaon0")->GetPDGMass() / MeV;
458
459 theRealAntiProtonMass = theG4ParticleTable->FindParticle("anti_proton")->GetPDGMass() / MeV;
460 theRealAntiNeutronMass = theG4ParticleTable->FindParticle("anti_neutron")->GetPDGMass() / MeV;
461 theRealXiZeroMass = theG4ParticleTable->FindParticle("xi0")->GetPDGMass() / MeV;
462 theRealXiMinusMass = theG4ParticleTable->FindParticle("xi-")->GetPDGMass() / MeV;
463 theRealAntiSigmaPlusMass = theG4ParticleTable->FindParticle("anti_sigma+")->GetPDGMass() / MeV;
464 theRealAntiSigmaZeroMass = theG4ParticleTable->FindParticle("anti_sigma0")->GetPDGMass() / MeV;
465 theRealAntiSigmaMinusMass = theG4ParticleTable->FindParticle("anti_sigma-")->GetPDGMass() / MeV;
466 theRealAntiLambdaMass = theG4ParticleTable->FindParticle("anti_lambda")->GetPDGMass() / MeV;
467 theRealAntiXiZeroMass = theG4ParticleTable->FindParticle("anti_xi0")->GetPDGMass() / MeV;
468 theRealAntiXiMinusMass = theG4ParticleTable->FindParticle("anti_xi-")->GetPDGMass() / MeV;
469#endif
470
471 minDeltaMass = theRealNeutronMass + theRealChargedPiMass + 0.5;
472 minDeltaMass2 = minDeltaMass*minDeltaMass;
473 minDeltaMassRndm = std::atan((minDeltaMass-effectiveDeltaMass)*2./effectiveDeltaWidth);
474
475 piPlusWidth = theChargedPiWidth;
476 piMinusWidth = theChargedPiWidth;
477 piZeroWidth = thePiZeroWidth;
478 etaWidth = theEtaWidth;
479 omegaWidth = theOmegaWidth;
480 etaPrimeWidth = theEtaPrimeWidth;
481
482 SigmaMinusWidth = theSigmaMinusWidth;
483 SigmaPlusWidth = theSigmaPlusWidth;
484 SigmaZeroWidth = theSigmaZeroWidth;
485 LambdaWidth = theLambdaWidth;
486 KPlusWidth = theChargedKaonWidth;
487 KMinusWidth = theChargedKaonWidth;
488 KShortWidth = theKShortWidth;
489 KLongWidth = theKLongWidth;
490
491 // Initialise HFB tables
492#ifdef INCLXX_IN_GEANT4_MODE
493 HFB::initialize();
494#else
495 HFB::initialize(dataFilePath);
496#endif
497
498 // Initialise the separation-energy function
499 if(!theConfig || theConfig->getSeparationEnergyType()==INCLSeparationEnergy)
500 getSeparationEnergy = getSeparationEnergyINCL;
501 else if(theConfig->getSeparationEnergyType()==RealSeparationEnergy)
502 getSeparationEnergy = getSeparationEnergyReal;
503 else if(theConfig->getSeparationEnergyType()==RealForLightSeparationEnergy)
504 getSeparationEnergy = getSeparationEnergyRealForLight;
505 else {
506 INCL_FATAL("Unrecognized separation-energy type in ParticleTable initialization: " << theConfig->getSeparationEnergyType() << '\n');
507 return;
508 }
509
510 // Initialise the Fermi-momentum function
511 if(!theConfig || theConfig->getFermiMomentumType()==ConstantFermiMomentum) {
512 getFermiMomentum = ParticleTable::getFermiMomentumConstant;
513 if(theConfig) {
514 const G4double aFermiMomentum = theConfig->getFermiMomentum();
515 if(aFermiMomentum>0.)
516 constantFermiMomentum = aFermiMomentum;
517 else
518 constantFermiMomentum = PhysicalConstants::Pf;
519 } else {
520 constantFermiMomentum = PhysicalConstants::Pf;
521 }
522 } else if(theConfig->getFermiMomentumType()==ConstantLightFermiMomentum)
523 getFermiMomentum = ParticleTable::getFermiMomentumConstantLight;
524 else if(theConfig->getFermiMomentumType()==MassDependentFermiMomentum)
525 getFermiMomentum = ParticleTable::getFermiMomentumMassDependent;
526 else {
527 INCL_FATAL("Unrecognized Fermi-momentum type in ParticleTable initialization: " << theConfig->getFermiMomentumType() << '\n');
528 return;
529 }
530
531 // Initialise the r-p correlation coefficients
532 std::fill(rpCorrelationCoefficient, rpCorrelationCoefficient + UnknownParticle, 1.);
533 if(theConfig) {
534 // Initialise the rp correlations
535 rpCorrelationCoefficient[Proton] = theConfig->getRPCorrelationCoefficient(Proton);
536 rpCorrelationCoefficient[Neutron] = theConfig->getRPCorrelationCoefficient(Neutron);
537 // Initialise the SRC parameters
538 srcPairConfig = theConfig->getsrcPairConfig();
539 srcPairDist = theConfig->getsrcPairDist();
540
541 // Initialise the neutron-skin parameters
542 neutronSkin = theConfig->getNeutronSkin();
543 neutronHalo = theConfig->getNeutronHalo();
544 }
545
546 }
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::HFB::initialize
void initialize()
Definition G4INCLHFB.cc:83
G4INCL::ParticleTable::effectiveDeltaWidth
const G4double effectiveDeltaWidth
Definition G4INCLParticleTable.hh:72
G4INCL::ParticleTable::minDeltaMass2
G4ThreadLocal G4double minDeltaMass2
Definition G4INCLParticleTable.cc:1490
G4INCL::ParticleTable::getSeparationEnergy
G4ThreadLocal SeparationEnergyFn getSeparationEnergy
Static pointer to the separation-energy function.
Definition G4INCLParticleTable.cc:1494
G4INCL::ParticleTable::effectiveDeltaMass
const G4double effectiveDeltaMass
Definition G4INCLParticleTable.hh:71
G4INCL::ParticleTable::getFermiMomentumMassDependent
G4double getFermiMomentumMassDependent(const G4int A, const G4int)
Return the value Fermi momentum from a fit.
Definition G4INCLParticleTable.cc:1472
G4INCL::ParticleTable::minDeltaMass
G4ThreadLocal G4double minDeltaMass
Definition G4INCLParticleTable.cc:1489
G4INCL::ParticleTable::minDeltaMassRndm
G4ThreadLocal G4double minDeltaMassRndm
Definition G4INCLParticleTable.cc:1491
G4INCL::ParticleTable::getFermiMomentumConstantLight
G4double getFermiMomentumConstantLight(const G4int A, const G4int Z)
Return the constant value of the Fermi momentum - special for light.
Definition G4INCLParticleTable.cc:1463
G4INCL::ParticleTable::getSeparationEnergyRealForLight
G4double getSeparationEnergyRealForLight(const ParticleType t, const G4int A, const G4int Z)
Return the real separation energy only for light nuclei.
Definition G4INCLParticleTable.cc:1374
G4INCL::PhysicalConstants::Pf
const G4double Pf
Fermi momentum [MeV/c].
Definition G4INCLGlobals.hh:58
G4INCL::MassDependentFermiMomentum
@ MassDependentFermiMomentum
Definition G4INCLConfigEnums.hh:107
G4INCL::ConstantLightFermiMomentum
@ ConstantLightFermiMomentum
Definition G4INCLConfigEnums.hh:106
G4INCL::RealForLightSeparationEnergy
@ RealForLightSeparationEnergy
Definition G4INCLConfigEnums.hh:100

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

1425 {
1426 // Normalize the element name
1427 std::transform(pS.begin(), pS.end(), pS.begin(), ::tolower);
1428 pS[0] = (char)std::toupper(pS[0]);
1429
1430 const std::string *iter = std::find(elementTable, elementTable+elementTableSize, pS);
1431 if(iter != elementTable+elementTableSize)
1432 return G4int(iter - elementTable);
1433 else
1434 return ParticleTable::parseIUPACElement(pS);
1435 }
G4int
int G4int
Definition G4Types.hh:85
G4INCL::ParticleTable::parseIUPACElement
G4int parseIUPACElement(std::string const &pS)
Parse a IUPAC element name.
Definition G4INCLParticleTable.cc:1437

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

1437 {
1438 // Normalise to lower case
1439 std::string elementName(sel);
1440 std::transform(elementName.begin(), elementName.end(), elementName.begin(), ::tolower);
1441 // Return 0 if the element name contains anything but IUPAC digits
1442 if(elementName.find_first_not_of(elementIUPACDigits)!=std::string::npos)
1443 return 0;
1444 std::transform(elementName.begin(), elementName.end(), elementName.begin(), iupacToInt);
1445 std::stringstream elementStream(elementName);
1446 G4int Z;
1447 elementStream >> Z;
1448 return Z;
1449 }

Referenced by parseElement().

◆ setantiLambdaSeparationEnergy()

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

Setter for antilambdaSeparationEnergy.

Definition at line 1404 of file G4INCLParticleTable.cc.

1404{ antilambdaSeparationEnergy = sen; }

◆ setLambdaSeparationEnergy()

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

Setter for lambdaSeparationEnergy.

Definition at line 1402 of file G4INCLParticleTable.cc.

1402{ lambdaSeparationEnergy = sen; }

◆ setNeutronSeparationEnergy()

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

Setter for protonSeparationEnergy.

Definition at line 1400 of file G4INCLParticleTable.cc.

1400{ neutronSeparationEnergy = sen; }

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

◆ setProtonSeparationEnergy()

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

Setter for protonSeparationEnergy.

Definition at line 1398 of file G4INCLParticleTable.cc.

1398{ 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(), G4INCL::CrossSectionsMultiPions::NNTwoPi(), and G4INCL::InteractionAvatar::postInteraction().

◆ 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 1495 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 1494 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 1492 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::getEmissionQValueCorrection(), G4INCL::Particle::getEmissionQValueCorrection(), getSeparationEnergyReal(), G4INCL::Particle::getTableMass(), getTableQValue(), getTableQValue(), getTableSpeciesMass(), initialize(), G4INCL::AntinucleiAtrestEntryChannel::makeMesonStar(), G4INCL::NbarAtrestEntryChannel::makeMesonStar(), G4INCL::PbarAtrestEntryChannel::makeMesonStar(), G4INCL::StandardPropagationModel::shootAtrest(), G4INCL::StandardPropagationModel::shootComposite(), G4INCL::StandardPropagationModel::shootCompositeAtrest(), and G4INCL::StandardPropagationModel::shootParticle().

◆ getTableParticleMass

G4ThreadLocal ParticleMassFn G4INCL::ParticleTable::getTableParticleMass = NULL

Static pointer to the mass function for particles.

Definition at line 1493 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 1489 of file G4INCLParticleTable.cc.

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

◆ minDeltaMass2

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

Definition at line 1490 of file G4INCLParticleTable.cc.

Referenced by initialize().

◆ minDeltaMassRndm

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

Definition at line 1491 of file G4INCLParticleTable.cc.

Referenced by initialize().