Geant4 10.7.0
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 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 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 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 231 of file G4INCLParticleTable.hh.

◆ NuclearMassFn

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

Definition at line 218 of file G4INCLParticleTable.hh.

◆ ParticleMassFn

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

Definition at line 219 of file G4INCLParticleTable.hh.

◆ SeparationEnergyFn

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

Definition at line 226 of file G4INCLParticleTable.hh.

Function Documentation

◆ drawRandomNaturalIsotope()

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

Definition at line 1183 of file G4INCLParticleTable.cc.

1183 {
1184 return getNaturalIsotopicDistributions()->drawRandomIsotope(Z);
1185 }

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

◆ getAntiKaonType()

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

Get the type of antikaon.

Definition at line 1288 of file G4INCLParticleTable.cc.

1288 {
1289// assert(isosp == -1 || isosp == 1);
1290 if (isosp == -1) {
1291 return KMinus;
1292 }
1293 else {
1294 return KZeroBar;
1295 }
1296 }

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

870 {
871 switch(t) {
872 case DeltaPlusPlus:
873 return 2;
874 break;
875 case Proton:
876 case DeltaPlus:
877 case PiPlus:
878 case SigmaPlus:
879 case KPlus:
880 return 1;
881 break;
882 case Neutron:
883 case DeltaZero:
884 case PiZero:
885 case SigmaZero:
886 case Lambda:
887 case KZero:
888 case KZeroBar:
889 case KShort:
890 case KLong:
891 case Eta:
892 case Omega:
893 case EtaPrime:
894 case Photon:
895 return 0;
896 break;
897 case DeltaMinus:
898 case PiMinus:
899 case SigmaMinus:
900 case KMinus:
901 return -1;
902 break;
903 default:
904 return 0;
905 break;
906 }
907 }

◆ getDeltaType()

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

Get the type of delta.

Definition at line 1248 of file G4INCLParticleTable.cc.

1248 {
1249// assert(isosp == -3 || isosp == -1 || isosp == 1 || isosp == 3);
1250 if (isosp == -3) {
1251 return DeltaMinus;
1252 }
1253 else if (isosp == -1) {
1254 return DeltaZero;
1255 }
1256 else if (isosp == 1) {
1257 return DeltaPlus;
1258 }
1259 else {
1260 return DeltaPlusPlus;
1261 }
1262 }

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

1134 {
1135 if(Z<1) {
1136 INCL_WARN("getElementName called with Z<1" << '\n');
1137 return elementTable[0];
1138 } else if(Z<elementTableSize)
1139 return elementTable[Z];
1140 else
1141 return getIUPACElementName(Z);
1142 }
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 1187 of file G4INCLParticleTable.cc.

1187 {
1188 return constantFermiMomentum;
1189 }

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

1191 {
1192// assert(Z>0 && A>0 && Z<=A);
1193 if(Z<clusterTableZSize && A<clusterTableASize) {
1194 const G4double rms = momentumRMS[Z][A];
1195 return ((rms>0.) ? rms : momentumRMS[6][12]) * Math::sqrtFiveThirds;
1196 } else
1197 return getFermiMomentumConstant(A,Z);
1198 }
A
double A(double temperature)
Definition: G4DNAElectronHoleRecombination.cc:60
G4double
double G4double
Definition: G4Types.hh:83

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

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

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

794 {
795// assert(A>=0);
796 // For nuclei with Z<0 or Z>A, assume that the exotic charge state is due to pions
797 // Note that S<0 for lambda
798 if(Z<0 && S<0)
799 return (A+S)*neutronMass - S*LambdaMass - Z*getINCLMass(PiMinus);
800 else if(Z>A && S<0)
801 return (A+S)*protonMass - S*LambdaMass + (A+S-Z)*getINCLMass(PiPlus);
802 else if(Z<0)
803 return (A)*neutronMass - Z*getINCLMass(PiMinus);
804 else if(Z>A)
805 return (A)*protonMass + (A-Z)*getINCLMass(PiPlus);
806 else if(A>1 && S<0)
807 return Z*(protonMass - protonSeparationEnergy) + (A+S-Z)*(neutronMass - neutronSeparationEnergy) + std::abs(S)*(LambdaMass - lambdaSeparationEnergy);
808 else if(A>1)
809 return Z*(protonMass - protonSeparationEnergy) + (A-Z)*(neutronMass - neutronSeparationEnergy);
810 else if(A==1 && Z==0 && S==0)
811 return getINCLMass(Neutron);
812 else if(A==1 && Z==1 && S==0)
813 return getINCLMass(Proton);
814 else if(A==1 && Z==0 && S==-1)
815 return getINCLMass(Lambda);
816 else
817 return 0.;
818 }
S
double S(double temp)
Definition: G4DNAElectronHoleRecombination.cc:77
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:794

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

665 {
666 if(pt == Proton) {
667 return protonMass;
668 } else if(pt == Neutron) {
669 return neutronMass;
670 } else if(pt == PiPlus) {
671 return piPlusMass;
672 } else if(pt == PiMinus) {
673 return piMinusMass;
674 } else if(pt == PiZero) {
675 return piZeroMass;
676 } else if(pt == SigmaPlus) {
677 return SigmaPlusMass;
678 } else if(pt == SigmaMinus) {
679 return SigmaMinusMass;
680 } else if(pt == SigmaZero) {
681 return SigmaZeroMass;
682 } else if(pt == Lambda) {
683 return LambdaMass;
684 } else if(pt == KPlus) {
685 return KPlusMass;
686 } else if(pt == KZero) {
687 return KZeroMass;
688 } else if(pt == KZeroBar) {
689 return KZeroBarMass;
690 } else if(pt == KMinus) {
691 return KMinusMass;
692 } else if(pt == KShort) {
693 return KShortMass;
694 } else if(pt == KLong) {
695 return KLongMass;
696 } else if(pt == Eta) {
697 return etaMass;
698 } else if(pt == Omega) {
699 return omegaMass;
700 } else if(pt == EtaPrime) {
701 return etaPrimeMass;
702 } else if(pt == Photon) {
703 return photonMass;
704 } else {
705 INCL_ERROR("getMass : Unknown particle type." << '\n');
706 return 0.0;
707 }
708 }
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 1144 of file G4INCLParticleTable.cc.

1144 {
1145 std::stringstream elementStream;
1146 elementStream << Z;
1147 std::string elementName = elementStream.str();
1148 std::transform(elementName.begin(), elementName.end(), elementName.begin(), intToIUPAC);
1149 elementName[0] = std::toupper(elementName.at(0));
1150 return elementName;
1151 }

Referenced by getElementName().

◆ getKaonType()

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

Get the type of kaon.

Definition at line 1278 of file G4INCLParticleTable.cc.

1278 {
1279// assert(isosp == -1 || isosp == 1);
1280 if (isosp == -1) {
1281 return KZero;
1282 }
1283 else {
1284 return KPlus;
1285 }
1286 }

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

1126{ return lambdaSeparationEnergy; }

◆ getLargestNuclearRadius()

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

Definition at line 978 of file G4INCLParticleTable.cc.

978 {
979 return Math::max(getNuclearRadius(Proton, A, Z), getNuclearRadius(Neutron, A, Z));
980 }
G4INCL::ParticleTable::getNuclearRadius
G4double getNuclearRadius(const ParticleType t, const G4int A, const G4int Z)
Definition: G4INCLParticleTable.cc:950

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

835 {
836 switch(t) {
837 case Proton:
838 case Neutron:
839 case DeltaPlusPlus:
840 case DeltaPlus:
841 case DeltaZero:
842 case DeltaMinus:
843 case SigmaPlus:
844 case SigmaZero:
845 case SigmaMinus:
846 case Lambda:
847 return 1;
848 break;
849 case PiPlus:
850 case PiMinus:
851 case PiZero:
852 case KPlus:
853 case KZero:
854 case KZeroBar:
855 case KShort:
856 case KLong:
857 case KMinus:
858 case Eta:
859 case Omega:
860 case EtaPrime:
861 case Photon:
862 return 0;
863 break;
864 default:
865 return 0;
866 break;
867 }
868 }

◆ getMaximumNuclearRadius()

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

Definition at line 1034 of file G4INCLParticleTable.cc.

1034 {
1035 const G4double XFOISA = 8.0;
1036 if(A > 19) {
1037 return getNuclearRadius(t,A,Z) + XFOISA * getSurfaceDiffuseness(t,A,Z);
1038 } else if(A <= 19 && A >= 6) {
1039 return 5.5 + 0.3 * (G4double(A) - 6.0)/12.0;
1040 } else if(A >= 2) {
1041 return getNuclearRadius(t, A, Z) + 4.5;
1042 } else {
1043 INCL_ERROR("getMaximumNuclearRadius : No maximum radius for nucleus A = " << A << " Z = " << Z << '\n');
1044 return 0.0;
1045 }
1046 }
G4INCL::ParticleTable::getSurfaceDiffuseness
G4double getSurfaceDiffuseness(const ParticleType t, const G4int A, const G4int Z)
Definition: G4INCLParticleTable.cc:1048

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

1082 {
1083// assert(Z>=0 && A>=0 && Z<=A);
1084 return getFermiMomentum(A,Z) * Math::sqrtThreeFifths;
1085 }
G4INCL::ParticleTable::getFermiMomentum
G4ThreadLocal FermiMomentumFn getFermiMomentum
Definition: G4INCLParticleTable.cc:1223

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

◆ getName() [1/3]

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

Get the native INCL name of the ion.

Definition at line 545 of file G4INCLParticleTable.cc.

545 {
546 std::stringstream stream;
547 stream << getElementName(Z) << "-" << A;
548 return stream.str();
549 }
G4INCL::ParticleTable::getElementName
std::string getElementName(const G4int Z)
Get the name of the element from the atomic number.
Definition: G4INCLParticleTable.cc:1134

◆ getName() [2/3]

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

Get the native INCL name of the particle.

Definition at line 538 of file G4INCLParticleTable.cc.

538 {
539 if(s.theType==Composite)
540 return getName(s.theA,s.theZ);
541 else
542 return getName(s.theType);
543 }
G4INCL::ParticleTable::getName
std::string getName(const ParticleType t)
Get the native INCL name of the particle.
Definition: G4INCLParticleTable.cc:559

◆ getName() [3/3]

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

Get the native INCL name of the particle.

Definition at line 559 of file G4INCLParticleTable.cc.

559 {
560 if(p == G4INCL::Proton) {
561 return std::string("proton");
562 } else if(p == G4INCL::Neutron) {
563 return std::string("neutron");
564 } else if(p == G4INCL::DeltaPlusPlus) {
565 return std::string("delta++");
566 } else if(p == G4INCL::DeltaPlus) {
567 return std::string("delta+");
568 } else if(p == G4INCL::DeltaZero) {
569 return std::string("delta0");
570 } else if(p == G4INCL::DeltaMinus) {
571 return std::string("delta-");
572 } else if(p == G4INCL::PiPlus) {
573 return std::string("pi+");
574 } else if(p == G4INCL::PiZero) {
575 return std::string("pi0");
576 } else if(p == G4INCL::PiMinus) {
577 return std::string("pi-");
578 } else if(p == G4INCL::Lambda) {
579 return std::string("lambda");
580 } else if(p == G4INCL::SigmaPlus) {
581 return std::string("sigma+");
582 } else if(p == G4INCL::SigmaZero) {
583 return std::string("sigma0");
584 } else if(p == G4INCL::SigmaMinus) {
585 return std::string("sigma-");
586 } else if(p == G4INCL::KPlus) {
587 return std::string("kaon+");
588 } else if(p == G4INCL::KZero) {
589 return std::string("kaon0");
590 } else if(p == G4INCL::KZeroBar) {
591 return std::string("kaon0bar");
592 } else if(p == G4INCL::KMinus) {
593 return std::string("kaon-");
594 } else if(p == G4INCL::KShort) {
595 return std::string("kaonshort");
596 } else if(p == G4INCL::KLong) {
597 return std::string("kaonlong");
598 } else if(p == G4INCL::Composite) {
599 return std::string("composite");
600 } else if(p == G4INCL::Eta) {
601 return std::string("eta");
602 } else if(p == G4INCL::Omega) {
603 return std::string("omega");
604 } else if(p == G4INCL::EtaPrime) {
605 return std::string("etaprime");
606 } else if(p == G4INCL::Photon) {
607 return std::string("photon");
608 }
609 return std::string("unknown");
610 }

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

◆ getNaturalIsotopicDistribution()

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

Definition at line 1179 of file G4INCLParticleTable.cc.

1179 {
1180 return getNaturalIsotopicDistributions()->getIsotopicDistribution(Z);
1181 }

◆ getNeutronHalo()

G4double G4INCL::ParticleTable::getNeutronHalo ( )

Get the size of the neutron halo.

Definition at line 1215 of file G4INCLParticleTable.cc.

1215{ return neutronHalo; }

◆ getNeutronSeparationEnergy()

G4double G4INCL::ParticleTable::getNeutronSeparationEnergy ( )

Getter for neutronSeparationEnergy.

Definition at line 1124 of file G4INCLParticleTable.cc.

1124{ return neutronSeparationEnergy; }

◆ getNeutronSkin()

G4double G4INCL::ParticleTable::getNeutronSkin ( )

Get the thickness of the neutron skin.

Definition at line 1213 of file G4INCLParticleTable.cc.

1213{ return neutronSkin; }

◆ getNuclearRadius()

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

Definition at line 950 of file G4INCLParticleTable.cc.

950 {
951// assert(A>=0);
952 if(A > 19 || (A < 6 && A >= 2)) {
953 // For large (Woods-Saxon or Modified Harmonic Oscillator) or small
954 // (Gaussian) nuclei, the radius parameter is just the nuclear radius
955 return getRadiusParameter(t,A,Z);
956 } else if(A < clusterTableASize && Z>=0 && Z < clusterTableZSize && A >= 6) {
957 const G4double thisRMS = positionRMS[Z][A];
958 if(thisRMS>0.0)
959 return thisRMS;
960 else {
961 INCL_DEBUG("getNuclearRadius: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'
962 << "returning radius for C12");
963 return positionRMS[6][12];
964 }
965 } else if(A <= 19) {
966 const G4double theRadiusParameter = getRadiusParameter(t, A, Z);
967 const G4double theDiffusenessParameter = getSurfaceDiffuseness(t, A, Z);
968 // The formula yields the nuclear RMS radius based on the parameters of
969 // the nuclear-density function
970 return 1.225*theDiffusenessParameter*
971 std::sqrt((2.+5.*theRadiusParameter)/(2.+3.*theRadiusParameter));
972 } else {
973 INCL_ERROR("getNuclearRadius: No radius for nucleus A = " << A << " Z = " << Z << '\n');
974 return 0.0;
975 }
976 }
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:982

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

1238 {
1239// assert(isosp == -1 || isosp == 1);
1240 if (isosp == -1) {
1241 return Neutron;
1242 }
1243 else {
1244 return Proton;
1245 }
1246 }

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

1225 {
1226// assert(isosp == -2 || isosp == 0 || isosp == 2);
1227 if (isosp == -2) {
1228 return PiMinus;
1229 }
1230 else if (isosp == 0) {
1231 return PiZero;
1232 }
1233 else {
1234 return PiPlus;
1235 }
1236 }

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

1122{ return protonSeparationEnergy; }

◆ getRadiusParameter()

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

Definition at line 982 of file G4INCLParticleTable.cc.

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

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

710 {
711 switch(t) {
712 case Proton:
713 return theRealProtonMass;
714 break;
715 case Neutron:
716 return theRealNeutronMass;
717 break;
718 case PiPlus:
719 case PiMinus:
720 return theRealChargedPiMass;
721 break;
722 case PiZero:
723 return theRealPiZeroMass;
724 break;
725 case SigmaPlus:
726 return theRealSigmaPlusMass;
727 break;
728 case SigmaZero:
729 return theRealSigmaZeroMass;
730 break;
731 case SigmaMinus:
732 return theRealSigmaMinusMass;
733 break;
734 case Lambda:
735 return theRealLambdaMass;
736 break;
737 case KPlus:
738 case KMinus:
739 return theRealChargedKaonMass;
740 break;
741 case KZero:
742 case KZeroBar:
743 case KShort:
744 case KLong:
745 return theRealNeutralKaonMass;
746 break;
747 case Eta:
748 return theRealEtaMass;
749 break;
750 case Omega:
751 return theRealOmegaMass;
752 break;
753 case EtaPrime:
754 return theRealEtaPrimeMass;
755 break;
756 case Photon:
757 return theRealPhotonMass;
758 break;
759 default:
760 INCL_ERROR("Particle::getRealMass : Unknown particle type." << '\n');
761 return 0.0;
762 break;
763 }
764 }

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

766 {
767// assert(A>=0);
768 // For nuclei with Z<0 or Z>A, assume that the exotic charge state is due to pions
769 if(Z<0 && S<0)
770 return (A+S)*theRealNeutronMass - S*LambdaMass - Z*getRealMass(PiMinus);
771 else if(Z>A && S<0)
772 return (A+S)*theRealProtonMass - S*LambdaMass + (A+S-Z)*getRealMass(PiPlus);
773 if(Z<0)
774 return (A)*theRealNeutronMass - Z*getRealMass(PiMinus);
775 else if(Z>A)
776 return (A)*theRealProtonMass + (A-Z)*getRealMass(PiPlus);
777 else if(Z==0 && S==0)
778 return A*theRealNeutronMass;
779 else if(A==Z)
780 return A*theRealProtonMass;
781 else if(Z==0 && S<0)
782 return (A+S)*theRealNeutronMass-S*LambdaMass;
783 else if(A>1) {
784#ifndef INCLXX_IN_GEANT4_MODE
785 return ::G4INCL::NuclearMassTable::getMass(A,Z,S);
786#else
787 if(S<0) return theG4IonTable->GetNucleusMass(Z,A,std::abs(S)) / MeV;
788 else return theG4IonTable->GetNucleusMass(Z,A) / MeV;
789#endif
790 } else
791 return 0.;
792 }
G4INCL::ParticleTable::getRealMass
G4double getRealMass(const G4INCL::ParticleType t)
Get particle mass (in MeV/c^2)
Definition: G4INCLParticleTable.cc:710

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

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

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

1087 {
1088 if(t==Proton)
1089 return theINCLProtonSeparationEnergy;
1090 else if(t==Neutron)
1091 return theINCLNeutronSeparationEnergy;
1092 else if(t==Lambda)
1093 return theINCLLambdaSeparationEnergy;
1094 else {
1095 INCL_ERROR("ParticleTable::getSeparationEnergyINCL : Unknown particle type." << '\n');
1096 return 0.0;
1097 }
1098 }

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

1100 {
1101 // Real separation energies for all nuclei
1102 if(t==Proton)
1103 return (*getTableParticleMass)(Proton) + (*getTableMass)(A-1,Z-1,0) - (*getTableMass)(A,Z,0);
1104 else if(t==Neutron)
1105 return (*getTableParticleMass)(Neutron) + (*getTableMass)(A-1,Z,0) - (*getTableMass)(A,Z,0);
1106 else if(t==Lambda)
1107 return (*getTableParticleMass)(Lambda) + (*getTableMass)(A-1,Z,0) - (*getTableMass)(A,Z,-1);
1108 else {
1109 INCL_ERROR("ParticleTable::getSeparationEnergyReal : Unknown particle type." << '\n');
1110 return 0.0;
1111 }
1112 }

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

1114 {
1115 // Real separation energies for light nuclei, fixed values for heavy nuclei
1116 if(Z<clusterTableZSize && A<clusterTableASize)
1117 return getSeparationEnergyReal(t, A, Z);
1118 else
1119 return getSeparationEnergyINCL(t, A, Z);
1120 }
G4INCL::ParticleTable::getSeparationEnergyReal
G4double getSeparationEnergyReal(const ParticleType t, const G4int A, const G4int Z)
Return the real separation energy.
Definition: G4INCLParticleTable.cc:1100
G4INCL::ParticleTable::getSeparationEnergyINCL
G4double getSeparationEnergyINCL(const ParticleType t, const G4int, const G4int)
Return INCL's default separation energy.
Definition: G4INCLParticleTable.cc:1087

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

551 {
552 std::stringstream stream;
553 stream << getElementName(Z);
554 if(A>0)
555 stream << A;
556 return stream.str();
557 }

◆ 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(s.theType==Composite)
533 return getShortName(s.theA,s.theZ);
534 else
535 return getShortName(s.theType);
536 }
G4INCL::ParticleTable::getShortName
std::string getShortName(const ParticleType t)
Get the short INCL name of the particle.
Definition: G4INCLParticleTable.cc:612

◆ getShortName() [3/3]

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

Get the short INCL name of the particle.

Definition at line 612 of file G4INCLParticleTable.cc.

612 {
613 if(p == G4INCL::Proton) {
614 return std::string("p");
615 } else if(p == G4INCL::Neutron) {
616 return std::string("n");
617 } else if(p == G4INCL::DeltaPlusPlus) {
618 return std::string("d++");
619 } else if(p == G4INCL::DeltaPlus) {
620 return std::string("d+");
621 } else if(p == G4INCL::DeltaZero) {
622 return std::string("d0");
623 } else if(p == G4INCL::DeltaMinus) {
624 return std::string("d-");
625 } else if(p == G4INCL::PiPlus) {
626 return std::string("pi+");
627 } else if(p == G4INCL::PiZero) {
628 return std::string("pi0");
629 } else if(p == G4INCL::PiMinus) {
630 return std::string("pi-");
631 } else if(p == G4INCL::Lambda) {
632 return std::string("l");
633 } else if(p == G4INCL::SigmaPlus) {
634 return std::string("s+");
635 } else if(p == G4INCL::SigmaZero) {
636 return std::string("s0");
637 } else if(p == G4INCL::SigmaMinus) {
638 return std::string("s-");
639 } else if(p == G4INCL::KPlus) {
640 return std::string("k+");
641 } else if(p == G4INCL::KZero) {
642 return std::string("k0");
643 } else if(p == G4INCL::KZeroBar) {
644 return std::string("k0b");
645 } else if(p == G4INCL::KMinus) {
646 return std::string("k-");
647 } else if(p == G4INCL::KShort) {
648 return std::string("ks");
649 } else if(p == G4INCL::KLong) {
650 return std::string("kl");
651 } else if(p == G4INCL::Composite) {
652 return std::string("comp");
653 } else if(p == G4INCL::Eta) {
654 return std::string("eta");
655 } else if(p == G4INCL::Omega) {
656 return std::string("omega");
657 } else if(p == G4INCL::EtaPrime) {
658 return std::string("etap");
659 } else if(p == G4INCL::Photon) {
660 return std::string("photon");
661 }
662 return std::string("unknown");
663 }

Referenced by getShortName().

◆ getSigmaType()

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

Get the type of sigma.

Definition at line 1265 of file G4INCLParticleTable.cc.

1265 {
1266// assert(isosp == -2 || isosp == 0 || isosp == 2);
1267 if (isosp == -2) {
1268 return SigmaMinus;
1269 }
1270 else if (isosp == 0) {
1271 return SigmaZero;
1272 }
1273 else {
1274 return SigmaPlus;
1275 }
1276 }

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

909 {
910 switch(t) {
911 case DeltaPlusPlus:
912 case DeltaPlus:
913 case DeltaZero:
914 case DeltaMinus:
915 case Proton:
916 case Neutron:
917 case PiPlus:
918 case PiZero:
919 case PiMinus:
920 case Eta:
921 case Omega:
922 case EtaPrime:
923 case Photon:
924 return 0;
925 break;
926 case Lambda:
927 case SigmaPlus:
928 case SigmaZero:
929 case SigmaMinus:
930 case KZeroBar:
931 case KMinus:
932 return -1;
933 break;
934 case KPlus:
935 case KZero:
936 return 1;
937 break;
938 case KShort:
939 return 0;
940 break;
941 case KLong:
942 return 0;
943 break;
944 default:
945 return 0;
946 break;
947 }
948 }

◆ getSurfaceDiffuseness()

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

Definition at line 1048 of file G4INCLParticleTable.cc.

1048 {
1049 if(A > 19) {
1050 // phenomenological fit
1051 G4double a = 1.63e-4 * A + 0.510;
1052 // HFB calculations
1053 if(getRPCorrelationCoefficient(t)<1.){
1054 G4double ahfb = HFB::getSurfaceDiffusenessHFB(t,A,Z);
1055 if(ahfb>0.)a=ahfb;
1056 }
1057 //
1058 if(t==Lambda){
1059 // Like for neutrons
1060 G4double ahfb = HFB::getSurfaceDiffusenessHFB(Neutron,A,Z);
1061 if(ahfb>0.)a=ahfb;
1062 }
1063 if(t==Neutron)
1064 a += neutronHalo;
1065 return a;
1066 } else if(A <= 19 && A >= 6) {
1067 // HFB calculations
1068 if(getRPCorrelationCoefficient(t)<1.){
1069 G4double ahfb = HFB::getRadiusParameterHFB(t,A,Z);
1070 if(ahfb>0.)return ahfb;
1071 }
1072 return mediumDiffuseness[A-1];
1073 } else if(A < 6 && A >= 2) {
1074 INCL_ERROR("getSurfaceDiffuseness: was called for A = " << A << " Z = " << Z << '\n');
1075 return 0.0;
1076 } else {
1077 INCL_ERROR("getSurfaceDiffuseness: No diffuseness for nucleus A = " << A << " Z = " << Z << '\n');
1078 return 0.0;
1079 }
1080 }

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

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

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

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

◆ getTableSpeciesMass()

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

Definition at line 828 of file G4INCLParticleTable.cc.

828 {
829 if(p.theType == Composite)
830 return (*getTableMass)(p.theA, p.theZ, p.theS);
831 else
832 return (*getTableParticleMass)(p.theType);
833 }

◆ getWidth()

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

Get particle width (in s)

Definition at line 1298 of file G4INCLParticleTable.cc.

1298 {
1299// 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);
1300 if(pt == PiPlus) {
1301 return piPlusWidth;
1302 } else if(pt == PiMinus) {
1303 return piMinusWidth;
1304 } else if(pt == PiZero) {
1305 return piZeroWidth;
1306 } else if(pt == Eta) {
1307 return etaWidth;
1308 } else if(pt == Omega) {
1309 return omegaWidth;
1310 } else if(pt == EtaPrime) {
1311 return etaPrimeWidth;
1312 } else if(pt == SigmaPlus) {
1313 return SigmaPlusWidth;
1314 } else if(pt == SigmaZero) {
1315 return SigmaZeroWidth;
1316 } else if(pt == SigmaMinus) {
1317 return SigmaMinusWidth;
1318 } else if(pt == KPlus) {
1319 return KPlusWidth;
1320 } else if(pt == KMinus) {
1321 return KMinusWidth;
1322 } else if(pt == KShort) {
1323 return KShortWidth;
1324 } else if(pt == KLong) {
1325 return KLongWidth;
1326 } else {
1327 INCL_ERROR("getWidth : Unknown particle type." << '\n');
1328 return 0.0;
1329 }
1330 }

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:695
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:1221

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

1153 {
1154 // Normalize the element name
1155 std::transform(pS.begin(), pS.end(), pS.begin(), ::tolower);
1156 pS[0] = ::toupper(pS[0]);
1157
1158 const std::string *iter = std::find(elementTable, elementTable+elementTableSize, pS);
1159 if(iter != elementTable+elementTableSize)
1160 return iter - elementTable;
1161 else
1162 return ParticleTable::parseIUPACElement(pS);
1163 }

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

1165 {
1166 // Normalise to lower case
1167 std::string elementName(s);
1168 std::transform(elementName.begin(), elementName.end(), elementName.begin(), ::tolower);
1169 // Return 0 if the element name contains anything but IUPAC digits
1170 if(elementName.find_first_not_of(elementIUPACDigits)!=std::string::npos)
1171 return 0;
1172 std::transform(elementName.begin(), elementName.end(), elementName.begin(), iupacToInt);
1173 std::stringstream elementStream(elementName);
1174 G4int Z;
1175 elementStream >> Z;
1176 return Z;
1177 }
G4int
int G4int
Definition: G4Types.hh:85

Referenced by parseElement().

◆ setLambdaSeparationEnergy()

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

Definition at line 1132 of file G4INCLParticleTable.cc.

1132{ lambdaSeparationEnergy = s; }

◆ setNeutronSeparationEnergy()

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

Setter for protonSeparationEnergy.

Definition at line 1130 of file G4INCLParticleTable.cc.

1130{ neutronSeparationEnergy = s; }

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

◆ setProtonSeparationEnergy()

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

Setter for protonSeparationEnergy.

Definition at line 1128 of file G4INCLParticleTable.cc.

1128{ protonSeparationEnergy = s; }

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 1223 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 1222 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 1220 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 1221 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 1217 of file G4INCLParticleTable.cc.

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

◆ minDeltaMass2

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

Definition at line 1218 of file G4INCLParticleTable.cc.

Referenced by initialize().

◆ minDeltaMassRndm

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

Definition at line 1219 of file G4INCLParticleTable.cc.

Referenced by initialize().