Geant4 11.1.1
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)
 
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.
 
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 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 232 of file G4INCLParticleTable.hh.

◆ NuclearMassFn

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

Definition at line 219 of file G4INCLParticleTable.hh.

◆ ParticleMassFn

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

Definition at line 220 of file G4INCLParticleTable.hh.

◆ SeparationEnergyFn

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

Definition at line 227 of file G4INCLParticleTable.hh.

Function Documentation

◆ drawRandomNaturalIsotope()

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

Definition at line 1198 of file G4INCLParticleTable.cc.

1198 {
1199 return getNaturalIsotopicDistributions()->drawRandomIsotope(Z);
1200 }
Z
const G4int Z[17]
Definition: G4WaterStopping.cc:51

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

◆ getAntiKaonType()

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

Get the type of antikaon.

Definition at line 1303 of file G4INCLParticleTable.cc.

1303 {
1304// assert(isosp == -1 || isosp == 1);
1305 if (isosp == -1) {
1306 return KMinus;
1307 }
1308 else {
1309 return KZeroBar;
1310 }
1311 }

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

◆ getChargeNumber()

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

Get charge number from particle type.

Definition at line 885 of file G4INCLParticleTable.cc.

885 {
886 switch(t) {
887 case DeltaPlusPlus:
888 return 2;
889 break;
890 case Proton:
891 case DeltaPlus:
892 case PiPlus:
893 case SigmaPlus:
894 case KPlus:
895 return 1;
896 break;
897 case Neutron:
898 case DeltaZero:
899 case PiZero:
900 case SigmaZero:
901 case Lambda:
902 case KZero:
903 case KZeroBar:
904 case KShort:
905 case KLong:
906 case Eta:
907 case Omega:
908 case EtaPrime:
909 case Photon:
910 return 0;
911 break;
912 case DeltaMinus:
913 case PiMinus:
914 case SigmaMinus:
915 case KMinus:
916 return -1;
917 break;
918 default:
919 return 0;
920 break;
921 }
922 }

◆ getDeltaType()

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

Get the type of delta.

Definition at line 1263 of file G4INCLParticleTable.cc.

1263 {
1264// assert(isosp == -3 || isosp == -1 || isosp == 1 || isosp == 3);
1265 if (isosp == -3) {
1266 return DeltaMinus;
1267 }
1268 else if (isosp == -1) {
1269 return DeltaZero;
1270 }
1271 else if (isosp == 1) {
1272 return DeltaPlus;
1273 }
1274 else {
1275 return DeltaPlusPlus;
1276 }
1277 }

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

◆ getElementName()

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

Get the name of the element from the atomic number.

Definition at line 1149 of file G4INCLParticleTable.cc.

1149 {
1150 if(Z<1) {
1151 INCL_WARN("getElementName called with Z<1" << '\n');
1152 return elementTable[0];
1153 } else if(Z<elementTableSize)
1154 return elementTable[Z];
1155 else
1156 return getIUPACElementName(Z);
1157 }
INCL_WARN
#define INCL_WARN(x)
Definition: G4INCLLogger.hh:232

Referenced by getName(), and getShortName().

◆ getFermiMomentumConstant()

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

Return the constant value of the Fermi momentum.

Definition at line 1202 of file G4INCLParticleTable.cc.

1202 {
1203 return constantFermiMomentum;
1204 }

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

1206 {
1207// assert(Z>0 && A>0 && Z<=A);
1208 if(Z<clusterTableZSize && A<clusterTableASize) {
1209 const G4double rms = momentumRMS[Z][A];
1210 return ((rms>0.) ? rms : momentumRMS[6][12]) * Math::sqrtFiveThirds;
1211 } else
1212 return getFermiMomentumConstant(A,Z);
1213 }
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 1215 of file G4INCLParticleTable.cc.

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

Referenced by initialize().

◆ getINCLMass() [1/2]

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

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

Definition at line 809 of file G4INCLParticleTable.cc.

809 {
810// assert(A>=0);
811 // For nuclei with Z<0 or Z>A, assume that the exotic charge state is due to pions
812 // Note that S<0 for lambda
813 if(Z<0 && S<0)
814 return (A+S)*neutronMass - S*LambdaMass - Z*getINCLMass(PiMinus);
815 else if(Z>A && S<0)
816 return (A+S)*protonMass - S*LambdaMass + (A+S-Z)*getINCLMass(PiPlus);
817 else if(Z<0)
818 return (A)*neutronMass - Z*getINCLMass(PiMinus);
819 else if(Z>A)
820 return (A)*protonMass + (A-Z)*getINCLMass(PiPlus);
821 else if(A>1 && S<0)
822 return Z*(protonMass - protonSeparationEnergy) + (A+S-Z)*(neutronMass - neutronSeparationEnergy) + std::abs(S)*(LambdaMass - lambdaSeparationEnergy);
823 else if(A>1)
824 return Z*(protonMass - protonSeparationEnergy) + (A-Z)*(neutronMass - neutronSeparationEnergy);
825 else if(A==1 && Z==0 && S==0)
826 return getINCLMass(Neutron);
827 else if(A==1 && Z==1 && S==0)
828 return getINCLMass(Proton);
829 else if(A==1 && Z==0 && S==-1)
830 return getINCLMass(Lambda);
831 else
832 return 0.;
833 }
S
G4double S(G4double temp)
Definition: G4DNAElectronHoleRecombination.cc:76
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:809

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

◆ getINCLMass() [2/2]

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

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

Definition at line 680 of file G4INCLParticleTable.cc.

680 {
681 if(pt == Proton) {
682 return protonMass;
683 } else if(pt == Neutron) {
684 return neutronMass;
685 } else if(pt == PiPlus) {
686 return piPlusMass;
687 } else if(pt == PiMinus) {
688 return piMinusMass;
689 } else if(pt == PiZero) {
690 return piZeroMass;
691 } else if(pt == SigmaPlus) {
692 return SigmaPlusMass;
693 } else if(pt == SigmaMinus) {
694 return SigmaMinusMass;
695 } else if(pt == SigmaZero) {
696 return SigmaZeroMass;
697 } else if(pt == Lambda) {
698 return LambdaMass;
699 } else if(pt == KPlus) {
700 return KPlusMass;
701 } else if(pt == KZero) {
702 return KZeroMass;
703 } else if(pt == KZeroBar) {
704 return KZeroBarMass;
705 } else if(pt == KMinus) {
706 return KMinusMass;
707 } else if(pt == KShort) {
708 return KShortMass;
709 } else if(pt == KLong) {
710 return KLongMass;
711 } else if(pt == Eta) {
712 return etaMass;
713 } else if(pt == Omega) {
714 return omegaMass;
715 } else if(pt == EtaPrime) {
716 return etaPrimeMass;
717 } else if(pt == Photon) {
718 return photonMass;
719 } else {
720 INCL_ERROR("getMass : Unknown particle type." << '\n');
721 return 0.0;
722 }
723 }
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 478 of file G4INCLParticleTable.cc.

478 {
479 // Actually this is the 3rd component of isospin (I_z) multiplied by 2!
480 if(t == Proton) {
481 return 1;
482 } else if(t == Neutron) {
483 return -1;
484 } else if(t == PiPlus) {
485 return 2;
486 } else if(t == PiMinus) {
487 return -2;
488 } else if(t == PiZero) {
489 return 0;
490 } else if(t == DeltaPlusPlus) {
491 return 3;
492 } else if(t == DeltaPlus) {
493 return 1;
494 } else if(t == DeltaZero) {
495 return -1;
496 } else if(t == DeltaMinus) {
497 return -3;
498 } else if(t == Lambda) {
499 return 0;
500 } else if(t == SigmaPlus) {
501 return 2;
502 } else if(t == SigmaZero) {
503 return 0;
504 } else if(t == SigmaMinus) {
505 return -2;
506 } else if(t == KPlus) {
507 return 1;
508 } else if(t == KZero) {
509 return -1;
510 } else if(t == KZeroBar) {
511 return 1;
512 } else if(t == KShort) {
513 return 0;
514 } else if(t == KLong) {
515 return 0;
516 } else if(t == KMinus) {
517 return -1;
518 } else if(t == Eta) {
519 return 0;
520 } else if(t == Omega) {
521 return 0;
522 } else if(t == EtaPrime) {
523 return 0;
524 } else if(t == Photon) {
525 return 0;
526 }
527 INCL_ERROR("Requested isospin of an unknown particle!");
528 return -10; // Unknown
529 }

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

1159 {
1160 std::stringstream elementStream;
1161 elementStream << Z;
1162 std::string elementName = elementStream.str();
1163 std::transform(elementName.begin(), elementName.end(), elementName.begin(), intToIUPAC);
1164 elementName[0] = (char)std::toupper(elementName.at(0));
1165 return elementName;
1166 }

Referenced by getElementName().

◆ getKaonType()

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

Get the type of kaon.

Definition at line 1293 of file G4INCLParticleTable.cc.

1293 {
1294// assert(isosp == -1 || isosp == 1);
1295 if (isosp == -1) {
1296 return KZero;
1297 }
1298 else {
1299 return KPlus;
1300 }
1301 }

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

1141{ return lambdaSeparationEnergy; }

◆ getLargestNuclearRadius()

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

Definition at line 993 of file G4INCLParticleTable.cc.

993 {
994 return Math::max(getNuclearRadius(Proton, A, Z), getNuclearRadius(Neutron, A, Z));
995 }
G4INCL::ParticleTable::getNuclearRadius
G4double getNuclearRadius(const ParticleType t, const G4int A, const G4int Z)
Definition: G4INCLParticleTable.cc:965

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

◆ getMassNumber()

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

Get mass number from particle type.

Definition at line 850 of file G4INCLParticleTable.cc.

850 {
851 switch(t) {
852 case Proton:
853 case Neutron:
854 case DeltaPlusPlus:
855 case DeltaPlus:
856 case DeltaZero:
857 case DeltaMinus:
858 case SigmaPlus:
859 case SigmaZero:
860 case SigmaMinus:
861 case Lambda:
862 return 1;
863 break;
864 case PiPlus:
865 case PiMinus:
866 case PiZero:
867 case KPlus:
868 case KZero:
869 case KZeroBar:
870 case KShort:
871 case KLong:
872 case KMinus:
873 case Eta:
874 case Omega:
875 case EtaPrime:
876 case Photon:
877 return 0;
878 break;
879 default:
880 return 0;
881 break;
882 }
883 }

◆ getMaximumNuclearRadius()

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

Definition at line 1049 of file G4INCLParticleTable.cc.

1049 {
1050 const G4double XFOISA = 8.0;
1051 if(A > 19) {
1052 return getNuclearRadius(t,A,Z) + XFOISA * getSurfaceDiffuseness(t,A,Z);
1053 } else if(A <= 19 && A >= 6) {
1054 return 5.5 + 0.3 * (G4double(A) - 6.0)/12.0;
1055 } else if(A >= 2) {
1056 return getNuclearRadius(t, A, Z) + 4.5;
1057 } else {
1058 INCL_ERROR("getMaximumNuclearRadius : No maximum radius for nucleus A = " << A << " Z = " << Z << '\n');
1059 return 0.0;
1060 }
1061 }
G4INCL::ParticleTable::getSurfaceDiffuseness
G4double getSurfaceDiffuseness(const ParticleType t, const G4int A, const G4int Z)
Definition: G4INCLParticleTable.cc:1063

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

◆ getMomentumRMS()

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

Return the RMS of the momentum distribution (light clusters)

Definition at line 1097 of file G4INCLParticleTable.cc.

1097 {
1098// assert(Z>=0 && A>=0 && Z<=A);
1099 return getFermiMomentum(A,Z) * Math::sqrtThreeFifths;
1100 }
G4INCL::ParticleTable::getFermiMomentum
G4ThreadLocal FermiMomentumFn getFermiMomentum
Definition: G4INCLParticleTable.cc:1238

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

◆ getName() [1/4]

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

Get the native INCL name of the ion.

Definition at line 549 of file G4INCLParticleTable.cc.

549 {
550 std::stringstream stream;
551 stream << getElementName(Z) << "-" << A;
552 return stream.str();
553 }
G4INCL::ParticleTable::getElementName
std::string getElementName(const G4int Z)
Get the name of the element from the atomic number.
Definition: G4INCLParticleTable.cc:1149

◆ getName() [2/4]

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

Definition at line 555 of file G4INCLParticleTable.cc.

555 {
556 std::stringstream stream;
557 if(S >= 0) // S < 0 for hypernuclei
558 return getName(A, Z);
559 else if(S == -1)
560 stream << getElementName(Z) << "-" << A << "_" << "Lambda";
561 else
562 stream << getElementName(Z) << "-" << A << "_" << S << "-Lambda";
563 return stream.str();
564 }
G4INCL::ParticleTable::getName
std::string getName(const ParticleType t)
Get the native INCL name of the particle.
Definition: G4INCLParticleTable.cc:574

◆ getName() [3/4]

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

Get the native INCL name of the particle.

Definition at line 540 of file G4INCLParticleTable.cc.

540 {
541 if(sp.theType==Composite && sp.theS == 0)
542 return getName(sp.theA,sp.theZ);
543 else if(sp.theType==Composite)
544 return getName(sp.theA,sp.theZ,sp.theS);
545 else
546 return getName(sp.theType);
547 }

◆ getName() [4/4]

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

Get the native INCL name of the particle.

Definition at line 574 of file G4INCLParticleTable.cc.

574 {
575 if(p == G4INCL::Proton) {
576 return std::string("proton");
577 } else if(p == G4INCL::Neutron) {
578 return std::string("neutron");
579 } else if(p == G4INCL::DeltaPlusPlus) {
580 return std::string("delta++");
581 } else if(p == G4INCL::DeltaPlus) {
582 return std::string("delta+");
583 } else if(p == G4INCL::DeltaZero) {
584 return std::string("delta0");
585 } else if(p == G4INCL::DeltaMinus) {
586 return std::string("delta-");
587 } else if(p == G4INCL::PiPlus) {
588 return std::string("pi+");
589 } else if(p == G4INCL::PiZero) {
590 return std::string("pi0");
591 } else if(p == G4INCL::PiMinus) {
592 return std::string("pi-");
593 } else if(p == G4INCL::Lambda) {
594 return std::string("lambda");
595 } else if(p == G4INCL::SigmaPlus) {
596 return std::string("sigma+");
597 } else if(p == G4INCL::SigmaZero) {
598 return std::string("sigma0");
599 } else if(p == G4INCL::SigmaMinus) {
600 return std::string("sigma-");
601 } else if(p == G4INCL::KPlus) {
602 return std::string("kaon+");
603 } else if(p == G4INCL::KZero) {
604 return std::string("kaon0");
605 } else if(p == G4INCL::KZeroBar) {
606 return std::string("kaon0bar");
607 } else if(p == G4INCL::KMinus) {
608 return std::string("kaon-");
609 } else if(p == G4INCL::KShort) {
610 return std::string("kaonshort");
611 } else if(p == G4INCL::KLong) {
612 return std::string("kaonlong");
613 } else if(p == G4INCL::Composite) {
614 return std::string("composite");
615 } else if(p == G4INCL::Eta) {
616 return std::string("eta");
617 } else if(p == G4INCL::Omega) {
618 return std::string("omega");
619 } else if(p == G4INCL::EtaPrime) {
620 return std::string("etaprime");
621 } else if(p == G4INCL::Photon) {
622 return std::string("photon");
623 }
624 return std::string("unknown");
625 }

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

◆ getNaturalIsotopicDistribution()

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

Definition at line 1194 of file G4INCLParticleTable.cc.

1194 {
1195 return getNaturalIsotopicDistributions()->getIsotopicDistribution(Z);
1196 }

◆ getNeutronHalo()

G4double G4INCL::ParticleTable::getNeutronHalo ( )

Get the size of the neutron halo.

Definition at line 1230 of file G4INCLParticleTable.cc.

1230{ return neutronHalo; }

◆ getNeutronSeparationEnergy()

G4double G4INCL::ParticleTable::getNeutronSeparationEnergy ( )

Getter for neutronSeparationEnergy.

Definition at line 1139 of file G4INCLParticleTable.cc.

1139{ return neutronSeparationEnergy; }

◆ getNeutronSkin()

G4double G4INCL::ParticleTable::getNeutronSkin ( )

Get the thickness of the neutron skin.

Definition at line 1228 of file G4INCLParticleTable.cc.

1228{ return neutronSkin; }

◆ getNuclearRadius()

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

Definition at line 965 of file G4INCLParticleTable.cc.

965 {
966// assert(A>=0);
967 if(A > 19 || (A < 6 && A >= 2)) {
968 // For large (Woods-Saxon or Modified Harmonic Oscillator) or small
969 // (Gaussian) nuclei, the radius parameter is just the nuclear radius
970 return getRadiusParameter(t,A,Z);
971 } else if(A < clusterTableASize && Z>=0 && Z < clusterTableZSize && A >= 6) {
972 const G4double thisRMS = positionRMS[Z][A];
973 if(thisRMS>0.0)
974 return thisRMS;
975 else {
976 INCL_DEBUG("getNuclearRadius: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'
977 << "returning radius for C12");
978 return positionRMS[6][12];
979 }
980 } else if(A <= 19) {
981 const G4double theRadiusParameter = getRadiusParameter(t, A, Z);
982 const G4double theDiffusenessParameter = getSurfaceDiffuseness(t, A, Z);
983 // The formula yields the nuclear RMS radius based on the parameters of
984 // the nuclear-density function
985 return 1.225*theDiffusenessParameter*
986 std::sqrt((2.+5.*theRadiusParameter)/(2.+3.*theRadiusParameter));
987 } else {
988 INCL_ERROR("getNuclearRadius: No radius for nucleus A = " << A << " Z = " << Z << '\n');
989 return 0.0;
990 }
991 }
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:997

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

1253 {
1254// assert(isosp == -1 || isosp == 1);
1255 if (isosp == -1) {
1256 return Neutron;
1257 }
1258 else {
1259 return Proton;
1260 }
1261 }

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

1240 {
1241// assert(isosp == -2 || isosp == 0 || isosp == 2);
1242 if (isosp == -2) {
1243 return PiMinus;
1244 }
1245 else if (isosp == 0) {
1246 return PiZero;
1247 }
1248 else {
1249 return PiPlus;
1250 }
1251 }

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

1137{ return protonSeparationEnergy; }

◆ getRadiusParameter()

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

Definition at line 997 of file G4INCLParticleTable.cc.

997 {
998// assert(A>0);
999 if(A > 19) {
1000 // radius fit for lambdas
1001 if(t==Lambda){
1002 G4double r0 = (1.128+0.439*std::pow(A,-2./3.)) * std::pow(A, 1.0/3.0);
1003 return r0;
1004 }
1005 // phenomenological radius fit
1006 G4double r0 = (2.745e-4 * A + 1.063) * std::pow(A, 1.0/3.0);
1007 // HFB calculations
1008 if(getRPCorrelationCoefficient(t)<1.){
1009 G4double r0hfb = HFB::getRadiusParameterHFB(t,A,Z);
1010 if(r0hfb>0.)r0 = r0hfb;
1011 }
1012 //
1013 if(t==Neutron)
1014 r0 += neutronSkin;
1015 return r0;
1016 } else if(A < 6 && A >= 2) {
1017 if(Z<clusterTableZSize && Z>=0) {
1018 const G4double thisRMS = positionRMS[Z][A];
1019 if(thisRMS>0.0)
1020 return thisRMS;
1021 else {
1022 INCL_DEBUG("getRadiusParameter: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'
1023 << "returning radius for C12");
1024 return positionRMS[6][12];
1025 }
1026 } else {
1027 INCL_DEBUG("getRadiusParameter: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'
1028 << "returning radius for C12");
1029 return positionRMS[6][12];
1030 }
1031 } else if(A <= 19 && A >= 6) {
1032 if(t==Lambda){
1033 G4double r0 = (1.128+0.439*std::pow(A,-2./3.)) * std::pow(A, 1.0/3.0);
1034 return r0;
1035 }
1036 // HFB calculations
1037 if(getRPCorrelationCoefficient(t)<1.){
1038 G4double r0hfb = HFB::getSurfaceDiffusenessHFB(t,A,Z);
1039 if(r0hfb>0.)return r0hfb;
1040 }
1041 return mediumRadius[A-1];
1042 // return 1.581*mediumDiffuseness[A-1]*(2.+5.*mediumRadius[A-1])/(2.+3.*mediumRadius[A-1]);
1043 } else {
1044 INCL_ERROR("getRadiusParameter: No radius for nucleus A = " << A << " Z = " << Z << '\n');
1045 return 0.0;
1046 }
1047 }
G4INCL::ParticleTable::getRPCorrelationCoefficient
G4double getRPCorrelationCoefficient(const ParticleType t)
Get the value of the r-p correlation coefficient.
Definition: G4INCLParticleTable.cc:1223

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

◆ getRealMass() [1/2]

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

Get particle mass (in MeV/c^2)

Definition at line 725 of file G4INCLParticleTable.cc.

725 {
726 switch(t) {
727 case Proton:
728 return theRealProtonMass;
729 break;
730 case Neutron:
731 return theRealNeutronMass;
732 break;
733 case PiPlus:
734 case PiMinus:
735 return theRealChargedPiMass;
736 break;
737 case PiZero:
738 return theRealPiZeroMass;
739 break;
740 case SigmaPlus:
741 return theRealSigmaPlusMass;
742 break;
743 case SigmaZero:
744 return theRealSigmaZeroMass;
745 break;
746 case SigmaMinus:
747 return theRealSigmaMinusMass;
748 break;
749 case Lambda:
750 return theRealLambdaMass;
751 break;
752 case KPlus:
753 case KMinus:
754 return theRealChargedKaonMass;
755 break;
756 case KZero:
757 case KZeroBar:
758 case KShort:
759 case KLong:
760 return theRealNeutralKaonMass;
761 break;
762 case Eta:
763 return theRealEtaMass;
764 break;
765 case Omega:
766 return theRealOmegaMass;
767 break;
768 case EtaPrime:
769 return theRealEtaPrimeMass;
770 break;
771 case Photon:
772 return theRealPhotonMass;
773 break;
774 default:
775 INCL_ERROR("Particle::getRealMass : Unknown particle type." << '\n');
776 return 0.0;
777 break;
778 }
779 }

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(), and G4INCL::CrossSectionsMultiPionsAndResonances::piMinuspToOmegaN().

◆ getRealMass() [2/2]

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

Get nuclear mass (in MeV/c^2)

Definition at line 781 of file G4INCLParticleTable.cc.

781 {
782// assert(A>=0);
783 // For nuclei with Z<0 or Z>A, assume that the exotic charge state is due to pions
784 if(Z<0 && S<0)
785 return (A+S)*theRealNeutronMass - S*LambdaMass - Z*getRealMass(PiMinus);
786 else if(Z>A && S<0)
787 return (A+S)*theRealProtonMass - S*LambdaMass + (A+S-Z)*getRealMass(PiPlus);
788 if(Z<0)
789 return (A)*theRealNeutronMass - Z*getRealMass(PiMinus);
790 else if(Z>A)
791 return (A)*theRealProtonMass + (A-Z)*getRealMass(PiPlus);
792 else if(Z==0 && S==0)
793 return A*theRealNeutronMass;
794 else if(A==Z)
795 return A*theRealProtonMass;
796 else if(Z==0 && S<0)
797 return (A+S)*theRealNeutronMass-S*LambdaMass;
798 else if(A>1) {
799#ifndef INCLXX_IN_GEANT4_MODE
800 return ::G4INCL::NuclearMassTable::getMass(A,Z,S);
801#else
802 if(S<0) return theG4IonTable->GetNucleusMass(Z,A,std::abs(S)) / MeV;
803 else return theG4IonTable->GetNucleusMass(Z,A) / MeV;
804#endif
805 } else
806 return 0.;
807 }
G4INCL::ParticleTable::getRealMass
G4double getRealMass(const G4INCL::ParticleType t)
Get particle mass (in MeV/c^2)
Definition: G4INCLParticleTable.cc:725

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

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

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

◆ getSeparationEnergyINCL()

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

Return INCL's default separation energy.

Definition at line 1102 of file G4INCLParticleTable.cc.

1102 {
1103 if(t==Proton)
1104 return theINCLProtonSeparationEnergy;
1105 else if(t==Neutron)
1106 return theINCLNeutronSeparationEnergy;
1107 else if(t==Lambda)
1108 return theINCLLambdaSeparationEnergy;
1109 else {
1110 INCL_ERROR("ParticleTable::getSeparationEnergyINCL : Unknown particle type." << '\n');
1111 return 0.0;
1112 }
1113 }

Referenced by getSeparationEnergyRealForLight(), and initialize().

◆ getSeparationEnergyReal()

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

Return the real separation energy.

Definition at line 1115 of file G4INCLParticleTable.cc.

1115 {
1116 // Real separation energies for all nuclei
1117 if(t==Proton)
1118 return (*getTableParticleMass)(Proton) + (*getTableMass)(A-1,Z-1,0) - (*getTableMass)(A,Z,0);
1119 else if(t==Neutron)
1120 return (*getTableParticleMass)(Neutron) + (*getTableMass)(A-1,Z,0) - (*getTableMass)(A,Z,0);
1121 else if(t==Lambda)
1122 return (*getTableParticleMass)(Lambda) + (*getTableMass)(A-1,Z,0) - (*getTableMass)(A,Z,-1);
1123 else {
1124 INCL_ERROR("ParticleTable::getSeparationEnergyReal : Unknown particle type." << '\n');
1125 return 0.0;
1126 }
1127 }

Referenced by getSeparationEnergyRealForLight(), and initialize().

◆ getSeparationEnergyRealForLight()

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

Return the real separation energy only for light nuclei.

Definition at line 1129 of file G4INCLParticleTable.cc.

1129 {
1130 // Real separation energies for light nuclei, fixed values for heavy nuclei
1131 if(Z<clusterTableZSize && A<clusterTableASize)
1132 return getSeparationEnergyReal(t, A, Z);
1133 else
1134 return getSeparationEnergyINCL(t, A, Z);
1135 }
G4INCL::ParticleTable::getSeparationEnergyReal
G4double getSeparationEnergyReal(const ParticleType t, const G4int A, const G4int Z)
Return the real separation energy.
Definition: G4INCLParticleTable.cc:1115
G4INCL::ParticleTable::getSeparationEnergyINCL
G4double getSeparationEnergyINCL(const ParticleType t, const G4int, const G4int)
Return INCL's default separation energy.
Definition: G4INCLParticleTable.cc:1102

Referenced by initialize().

◆ getShortName() [1/3]

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

Get the short INCL name of the ion.

Definition at line 566 of file G4INCLParticleTable.cc.

566 {
567 std::stringstream stream;
568 stream << getElementName(Z);
569 if(A>0)
570 stream << A;
571 return stream.str();
572 }

◆ getShortName() [2/3]

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

Get the short INCL name of the particle.

Definition at line 531 of file G4INCLParticleTable.cc.

531 {
532 if(sp.theType==Composite && sp.theS == 0)
533 return getShortName(sp.theA,sp.theZ);
534 else if(sp.theType==Composite)
535 return getName(sp.theA,sp.theZ,sp.theS);
536 else
537 return getShortName(sp.theType);
538 }
G4INCL::ParticleTable::getShortName
std::string getShortName(const ParticleType t)
Get the short INCL name of the particle.
Definition: G4INCLParticleTable.cc:627

◆ getShortName() [3/3]

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

Get the short INCL name of the particle.

Definition at line 627 of file G4INCLParticleTable.cc.

627 {
628 if(p == G4INCL::Proton) {
629 return std::string("p");
630 } else if(p == G4INCL::Neutron) {
631 return std::string("n");
632 } else if(p == G4INCL::DeltaPlusPlus) {
633 return std::string("d++");
634 } else if(p == G4INCL::DeltaPlus) {
635 return std::string("d+");
636 } else if(p == G4INCL::DeltaZero) {
637 return std::string("d0");
638 } else if(p == G4INCL::DeltaMinus) {
639 return std::string("d-");
640 } else if(p == G4INCL::PiPlus) {
641 return std::string("pi+");
642 } else if(p == G4INCL::PiZero) {
643 return std::string("pi0");
644 } else if(p == G4INCL::PiMinus) {
645 return std::string("pi-");
646 } else if(p == G4INCL::Lambda) {
647 return std::string("l");
648 } else if(p == G4INCL::SigmaPlus) {
649 return std::string("s+");
650 } else if(p == G4INCL::SigmaZero) {
651 return std::string("s0");
652 } else if(p == G4INCL::SigmaMinus) {
653 return std::string("s-");
654 } else if(p == G4INCL::KPlus) {
655 return std::string("k+");
656 } else if(p == G4INCL::KZero) {
657 return std::string("k0");
658 } else if(p == G4INCL::KZeroBar) {
659 return std::string("k0b");
660 } else if(p == G4INCL::KMinus) {
661 return std::string("k-");
662 } else if(p == G4INCL::KShort) {
663 return std::string("ks");
664 } else if(p == G4INCL::KLong) {
665 return std::string("kl");
666 } else if(p == G4INCL::Composite) {
667 return std::string("comp");
668 } else if(p == G4INCL::Eta) {
669 return std::string("eta");
670 } else if(p == G4INCL::Omega) {
671 return std::string("omega");
672 } else if(p == G4INCL::EtaPrime) {
673 return std::string("etap");
674 } else if(p == G4INCL::Photon) {
675 return std::string("photon");
676 }
677 return std::string("unknown");
678 }

Referenced by getShortName().

◆ getSigmaType()

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

Get the type of sigma.

Definition at line 1280 of file G4INCLParticleTable.cc.

1280 {
1281// assert(isosp == -2 || isosp == 0 || isosp == 2);
1282 if (isosp == -2) {
1283 return SigmaMinus;
1284 }
1285 else if (isosp == 0) {
1286 return SigmaZero;
1287 }
1288 else {
1289 return SigmaPlus;
1290 }
1291 }

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

924 {
925 switch(t) {
926 case DeltaPlusPlus:
927 case DeltaPlus:
928 case DeltaZero:
929 case DeltaMinus:
930 case Proton:
931 case Neutron:
932 case PiPlus:
933 case PiZero:
934 case PiMinus:
935 case Eta:
936 case Omega:
937 case EtaPrime:
938 case Photon:
939 return 0;
940 break;
941 case Lambda:
942 case SigmaPlus:
943 case SigmaZero:
944 case SigmaMinus:
945 case KZeroBar:
946 case KMinus:
947 return -1;
948 break;
949 case KPlus:
950 case KZero:
951 return 1;
952 break;
953 case KShort:
954 return 0;
955 break;
956 case KLong:
957 return 0;
958 break;
959 default:
960 return 0;
961 break;
962 }
963 }

◆ getSurfaceDiffuseness()

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

Definition at line 1063 of file G4INCLParticleTable.cc.

1063 {
1064 if(A > 19) {
1065 // phenomenological fit
1066 G4double a = 1.63e-4 * A + 0.510;
1067 // HFB calculations
1068 if(getRPCorrelationCoefficient(t)<1.){
1069 G4double ahfb = HFB::getSurfaceDiffusenessHFB(t,A,Z);
1070 if(ahfb>0.)a=ahfb;
1071 }
1072 //
1073 if(t==Lambda){
1074 // Like for neutrons
1075 G4double ahfb = HFB::getSurfaceDiffusenessHFB(Neutron,A,Z);
1076 if(ahfb>0.)a=ahfb;
1077 }
1078 if(t==Neutron)
1079 a += neutronHalo;
1080 return a;
1081 } else if(A <= 19 && A >= 6) {
1082 // HFB calculations
1083 if(getRPCorrelationCoefficient(t)<1.){
1084 G4double ahfb = HFB::getRadiusParameterHFB(t,A,Z);
1085 if(ahfb>0.)return ahfb;
1086 }
1087 return mediumDiffuseness[A-1];
1088 } else if(A < 6 && A >= 2) {
1089 INCL_ERROR("getSurfaceDiffuseness: was called for A = " << A << " Z = " << Z << '\n');
1090 return 0.0;
1091 } else {
1092 INCL_ERROR("getSurfaceDiffuseness: No diffuseness for nucleus A = " << A << " Z = " << Z << '\n');
1093 return 0.0;
1094 }
1095 }

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

◆ getTableQValue() [1/2]

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

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

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

\[ (A_1,Z_1) + (A_2, Z_2) --> (A_1+A_2,Z_1+Z_2) \]

Definition at line 835 of file G4INCLParticleTable.cc.

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

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

◆ getTableQValue() [2/2]

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

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

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

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

Definition at line 839 of file G4INCLParticleTable.cc.

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

◆ getTableSpeciesMass()

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

Definition at line 843 of file G4INCLParticleTable.cc.

843 {
844 if(p.theType == Composite)
845 return (*getTableMass)(p.theA, p.theZ, p.theS);
846 else
847 return (*getTableParticleMass)(p.theType);
848 }

◆ getWidth()

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

Get particle width (in s)

Definition at line 1313 of file G4INCLParticleTable.cc.

1313 {
1314// 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);
1315 if(pt == PiPlus) {
1316 return piPlusWidth;
1317 } else if(pt == PiMinus) {
1318 return piMinusWidth;
1319 } else if(pt == PiZero) {
1320 return piZeroWidth;
1321 } else if(pt == Eta) {
1322 return etaWidth;
1323 } else if(pt == Omega) {
1324 return omegaWidth;
1325 } else if(pt == EtaPrime) {
1326 return etaPrimeWidth;
1327 } else if(pt == SigmaPlus) {
1328 return SigmaPlusWidth;
1329 } else if(pt == SigmaZero) {
1330 return SigmaZeroWidth;
1331 } else if(pt == SigmaMinus) {
1332 return SigmaMinusWidth;
1333 } else if(pt == KPlus) {
1334 return KPlusWidth;
1335 } else if(pt == KMinus) {
1336 return KMinusWidth;
1337 } else if(pt == KShort) {
1338 return KShortWidth;
1339 } else if(pt == KLong) {
1340 return KLongWidth;
1341 } else {
1342 INCL_ERROR("getWidth : Unknown particle type." << '\n');
1343 return 0.0;
1344 }
1345 }

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

◆ initialize()

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

Initialize the particle table.

Definition at line 336 of file G4INCLParticleTable.cc.

336 {
337 protonMass = theINCLNucleonMass;
338 neutronMass = theINCLNucleonMass;
339 piPlusMass = theINCLPionMass;
340 piMinusMass = theINCLPionMass;
341 piZeroMass = theINCLPionMass;
342 /*
343 SigmaPlusMass = theINCLSigmaMass;
344 SigmaMinusMass = theINCLSigmaMass;
345 SigmaZeroMass = theINCLSigmaMass;
346 LambdaMass = theINCLLambdaMass;
347 KPlusMass = theINCLKaonMass;
348 KZeroMass = theINCLKaonMass;
349 KZeroBarMass = theINCLKaonMass;
350 KShortMass = theINCLKaonMass;
351 KLongMass = theINCLKaonMass;
352 KMinusMass = theINCLKaonMass;
353 */
354 SigmaPlusMass = theRealSigmaPlusMass;
355 SigmaMinusMass = theRealSigmaMinusMass;
356 SigmaZeroMass = theRealSigmaZeroMass;
357 LambdaMass = theINCLLambdaMass;
358 KPlusMass = theRealChargedKaonMass;
359 KZeroMass = theRealNeutralKaonMass;
360 KZeroBarMass = theRealNeutralKaonMass;
361 KShortMass = theRealNeutralKaonMass;
362 KLongMass = theRealNeutralKaonMass;
363 KMinusMass = theRealChargedKaonMass;
364
365 etaMass = theINCLEtaMass;
366 omegaMass = theINCLOmegaMass;
367 etaPrimeMass = theINCLEtaPrimeMass;
368 photonMass = theINCLPhotonMass;
369 if(theConfig && theConfig->getUseRealMasses()) {
370 getTableMass = getRealMass;
371 getTableParticleMass = getRealMass;
372 } else {
373 getTableMass = getINCLMass;
374 getTableParticleMass = getINCLMass;
375 }
376
377#ifndef INCLXX_IN_GEANT4_MODE
378 std::string dataFilePath;
379 if(theConfig)
380 dataFilePath = theConfig->getINCLXXDataFilePath();
381 NuclearMassTable::initialize(dataFilePath, getRealMass(Proton), getRealMass(Neutron));
382#endif
383
384#ifdef INCLXX_IN_GEANT4_MODE
385 G4ParticleTable *theG4ParticleTable = G4ParticleTable::GetParticleTable();
386 theG4IonTable = theG4ParticleTable->GetIonTable();
387 theRealProtonMass = theG4ParticleTable->FindParticle("proton")->GetPDGMass() / MeV;
388 theRealNeutronMass = theG4ParticleTable->FindParticle("neutron")->GetPDGMass() / MeV;
389 theRealChargedPiMass = theG4ParticleTable->FindParticle("pi+")->GetPDGMass() / MeV;
390 theRealPiZeroMass = theG4ParticleTable->FindParticle("pi0")->GetPDGMass() / MeV;
391 theRealEtaMass = theG4ParticleTable->FindParticle("eta")->GetPDGMass() / MeV;
392 theRealOmegaMass = theG4ParticleTable->FindParticle("omega")->GetPDGMass() / MeV;
393 theRealEtaPrimeMass = theG4ParticleTable->FindParticle("eta_prime")->GetPDGMass() / MeV;
394 theRealPhotonMass = theG4ParticleTable->FindParticle("gamma")->GetPDGMass() / MeV;
395 theRealSigmaPlusMass = theG4ParticleTable->FindParticle("sigma+")->GetPDGMass() / MeV;
396 theRealSigmaZeroMass = theG4ParticleTable->FindParticle("sigma0")->GetPDGMass() / MeV;
397 theRealSigmaMinusMass = theG4ParticleTable->FindParticle("sigma-")->GetPDGMass() / MeV;
398 theRealLambdaMass = theG4ParticleTable->FindParticle("lambda")->GetPDGMass() / MeV;
399 theRealChargedKaonMass = theG4ParticleTable->FindParticle("kaon+")->GetPDGMass() / MeV;
400 theRealNeutralKaonMass = theG4ParticleTable->FindParticle("kaon0")->GetPDGMass() / MeV;
401#endif
402
403 minDeltaMass = theRealNeutronMass + theRealChargedPiMass + 0.5;
404 minDeltaMass2 = minDeltaMass*minDeltaMass;
405 minDeltaMassRndm = std::atan((minDeltaMass-effectiveDeltaMass)*2./effectiveDeltaWidth);
406
407 piPlusWidth = theChargedPiWidth;
408 piMinusWidth = theChargedPiWidth;
409 piZeroWidth = thePiZeroWidth;
410 etaWidth = theEtaWidth;
411 omegaWidth = theOmegaWidth;
412 etaPrimeWidth = theEtaPrimeWidth;
413
414 SigmaMinusWidth = theSigmaMinusWidth;
415 SigmaPlusWidth = theSigmaPlusWidth;
416 SigmaZeroWidth = theSigmaZeroWidth;
417 LambdaWidth = theLambdaWidth;
418 KPlusWidth = theChargedKaonWidth;
419 KMinusWidth = theChargedKaonWidth;
420 KShortWidth = theKShortWidth;
421 KLongWidth = theKLongWidth;
422
423 // Initialise HFB tables
424#ifdef INCLXX_IN_GEANT4_MODE
425 HFB::initialize();
426#else
427 HFB::initialize(dataFilePath);
428#endif
429
430 // Initialise the separation-energy function
431 if(!theConfig || theConfig->getSeparationEnergyType()==INCLSeparationEnergy)
432 getSeparationEnergy = getSeparationEnergyINCL;
433 else if(theConfig->getSeparationEnergyType()==RealSeparationEnergy)
434 getSeparationEnergy = getSeparationEnergyReal;
435 else if(theConfig->getSeparationEnergyType()==RealForLightSeparationEnergy)
436 getSeparationEnergy = getSeparationEnergyRealForLight;
437 else {
438 INCL_FATAL("Unrecognized separation-energy type in ParticleTable initialization: " << theConfig->getSeparationEnergyType() << '\n');
439 return;
440 }
441
442 // Initialise the Fermi-momentum function
443 if(!theConfig || theConfig->getFermiMomentumType()==ConstantFermiMomentum) {
444 getFermiMomentum = ParticleTable::getFermiMomentumConstant;
445 if(theConfig) {
446 const G4double aFermiMomentum = theConfig->getFermiMomentum();
447 if(aFermiMomentum>0.)
448 constantFermiMomentum = aFermiMomentum;
449 else
450 constantFermiMomentum = PhysicalConstants::Pf;
451 } else {
452 constantFermiMomentum = PhysicalConstants::Pf;
453 }
454 } else if(theConfig->getFermiMomentumType()==ConstantLightFermiMomentum)
455 getFermiMomentum = ParticleTable::getFermiMomentumConstantLight;
456 else if(theConfig->getFermiMomentumType()==MassDependentFermiMomentum)
457 getFermiMomentum = ParticleTable::getFermiMomentumMassDependent;
458 else {
459 INCL_FATAL("Unrecognized Fermi-momentum type in ParticleTable initialization: " << theConfig->getFermiMomentumType() << '\n');
460 return;
461 }
462
463 // Initialise the r-p correlation coefficients
464 std::fill(rpCorrelationCoefficient, rpCorrelationCoefficient + UnknownParticle, 1.);
465 if(theConfig) {
466 rpCorrelationCoefficient[Proton] = theConfig->getRPCorrelationCoefficient(Proton);
467 rpCorrelationCoefficient[Neutron] = theConfig->getRPCorrelationCoefficient(Neutron);
468 }
469
470 // Initialise the neutron-skin parameters
471 if(theConfig) {
472 neutronSkin = theConfig->getNeutronSkin();
473 neutronHalo = theConfig->getNeutronHalo();
474 }
475
476 }
INCL_FATAL
#define INCL_FATAL(x)
Definition: G4INCLLogger.hh:216
G4ParticleTable::GetIonTable
G4IonTable * GetIonTable() const
Definition: G4ParticleTable.cc:698
G4ParticleTable::FindParticle
G4ParticleDefinition * FindParticle(G4int PDGEncoding)
Definition: G4ParticleTable.cc:586
G4ParticleTable::GetParticleTable
static G4ParticleTable * GetParticleTable()
Definition: G4ParticleTable.cc:87
G4INCL::ParticleTable::getTableParticleMass
G4ThreadLocal ParticleMassFn getTableParticleMass
Static pointer to the mass function for particles.
Definition: G4INCLParticleTable.cc:1236

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

◆ parseElement()

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

Get the name of the element from the atomic number.

Definition at line 1168 of file G4INCLParticleTable.cc.

1168 {
1169 // Normalize the element name
1170 std::transform(pS.begin(), pS.end(), pS.begin(), ::tolower);
1171 pS[0] = (char)std::toupper(pS[0]);
1172
1173 const std::string *iter = std::find(elementTable, elementTable+elementTableSize, pS);
1174 if(iter != elementTable+elementTableSize)
1175 return G4int(iter - elementTable);
1176 else
1177 return ParticleTable::parseIUPACElement(pS);
1178 }
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 1180 of file G4INCLParticleTable.cc.

1180 {
1181 // Normalise to lower case
1182 std::string elementName(sel);
1183 std::transform(elementName.begin(), elementName.end(), elementName.begin(), ::tolower);
1184 // Return 0 if the element name contains anything but IUPAC digits
1185 if(elementName.find_first_not_of(elementIUPACDigits)!=std::string::npos)
1186 return 0;
1187 std::transform(elementName.begin(), elementName.end(), elementName.begin(), iupacToInt);
1188 std::stringstream elementStream(elementName);
1189 G4int Z;
1190 elementStream >> Z;
1191 return Z;
1192 }

Referenced by parseElement().

◆ setLambdaSeparationEnergy()

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

Definition at line 1147 of file G4INCLParticleTable.cc.

1147{ lambdaSeparationEnergy = sen; }

◆ setNeutronSeparationEnergy()

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

Setter for protonSeparationEnergy.

Definition at line 1145 of file G4INCLParticleTable.cc.

1145{ neutronSeparationEnergy = sen; }

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

◆ setProtonSeparationEnergy()

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

Setter for protonSeparationEnergy.

Definition at line 1143 of file G4INCLParticleTable.cc.

1143{ protonSeparationEnergy = sen; }

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

◆ effectiveEtaPrimeMass

const G4double G4INCL::ParticleTable::effectiveEtaPrimeMass = 957.78

Definition at line 80 of file G4INCLParticleTable.hh.

◆ effectiveKaonMass

const G4double G4INCL::ParticleTable::effectiveKaonMass = 497.614

Definition at line 76 of file G4INCLParticleTable.hh.

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

◆ effectivePhotonMass

const G4double G4INCL::ParticleTable::effectivePhotonMass = 0.0

Definition at line 81 of file G4INCLParticleTable.hh.

◆ effectivePionMass

const G4double G4INCL::ParticleTable::effectivePionMass = 138.0

Definition at line 73 of file G4INCLParticleTable.hh.

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

◆ effectiveSigmaMass

const G4double G4INCL::ParticleTable::effectiveSigmaMass = 1197.45

Definition at line 75 of file G4INCLParticleTable.hh.

◆ getFermiMomentum

G4ThreadLocal FermiMomentumFn G4INCL::ParticleTable::getFermiMomentum = NULL

Definition at line 1238 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 1237 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 1235 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(), getSeparationEnergyReal(), G4INCL::Particle::getTableMass(), getTableQValue(), getTableSpeciesMass(), initialize(), G4INCL::StandardPropagationModel::shootComposite(), and G4INCL::StandardPropagationModel::shootParticle().

◆ getTableParticleMass

G4ThreadLocal ParticleMassFn G4INCL::ParticleTable::getTableParticleMass = NULL

Static pointer to the mass function for particles.

Definition at line 1236 of file G4INCLParticleTable.cc.

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

◆ maxClusterCharge

const G4int G4INCL::ParticleTable::maxClusterCharge = 8

Definition at line 63 of file G4INCLParticleTable.hh.

◆ maxClusterMass

const G4int G4INCL::ParticleTable::maxClusterMass = 12

Definition at line 62 of file G4INCLParticleTable.hh.

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

◆ minDeltaMass

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

Definition at line 1232 of file G4INCLParticleTable.cc.

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

◆ minDeltaMass2

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

Definition at line 1233 of file G4INCLParticleTable.cc.

Referenced by initialize().

◆ minDeltaMassRndm

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

Definition at line 1234 of file G4INCLParticleTable.cc.

Referenced by initialize().