34#define INCLXX_IN_GEANT4_MODE 1
45#ifdef INCLXX_IN_GEANT4_MODE
49#ifdef INCLXX_IN_GEANT4_MODE
56 namespace ParticleTable {
61 const NaturalIsotopicDistributions *theNaturalIsotopicDistributions = NULL;
63 const G4double theINCLNucleonMass = 938.2796;
64 const G4double theINCLPionMass = 138.0;
65 const G4double theINCLLambdaMass = 1115.683;
68 const G4double theINCLEtaMass = 547.862;
69 const G4double theINCLOmegaMass = 782.65;
70 const G4double theINCLEtaPrimeMass = 957.78;
71 const G4double theINCLPhotonMass = 0.0;
129 const G4double theChargedPiWidth = 2.6033e-08;
130 const G4double thePiZeroWidth = 8.52e-17;
131 const G4double theEtaWidth = 5.025e-19;
132 const G4double theOmegaWidth = 7.7528e-23;
133 const G4double theEtaPrimeWidth = 3.3243e-21;
134 const G4double theChargedKaonWidth = 1.238e-08;
135 const G4double theKShortWidth = 8.954e-11;
136 const G4double theKLongWidth = 5.116e-08;
137 const G4double theLambdaWidth = 2.632e-10;
138 const G4double theSigmaPlusWidth = 8.018e-11;
139 const G4double theSigmaZeroWidth = 7.4e-20;
140 const G4double theSigmaMinusWidth = 1.479e-10;
172 const G4int mediumNucleiTableSize = 30;
174 const G4double mediumDiffuseness[mediumNucleiTableSize] =
175 {0.0,0.0,0.0,0.0,0.0,1.78,1.77,1.77,1.69,1.71,
176 1.69,1.72,1.635,1.730,1.81,1.833,1.798,
177 1.93,0.567,0.571, 0.560,0.549,0.550,0.551,
178 0.580,0.575,0.569,0.537,0.0,0.0};
179 const G4double mediumRadius[mediumNucleiTableSize] =
180 {0.0,0.0,0.0,0.0,0.0,0.334,0.327,0.479,0.631,0.838,
181 0.811,0.84,1.403,1.335,1.25,1.544,1.498,1.57,
182 2.58,2.77, 2.775,2.78,2.88,2.98,3.22,3.03,2.84,
187 {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0},
188 {-1.0, -1.0, 2.10, 1.80, 1.70, 1.83, 2.60, 2.50, -1.0, -1.0, -1.0, -1.0, -1.0},
189 {-1.0, -1.0, -1.0, 1.80, 1.68, 1.70, 2.60, 2.50, 2.50, 2.50, 2.50, -1.0, -1.0},
190 {-1.0, -1.0, -1.0, -1.0, 1.70, 1.83, 2.56, 2.40, 2.50, 2.50, 2.50, 2.50, 2.50},
191 {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 2.60, 2.50, 2.50, 2.51, 2.50, 2.50, 2.50},
192 {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 2.50, 2.50, 2.50, 2.50, 2.45, 2.40, 2.50},
193 {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 2.50, 2.50, 2.50, 2.50, 2.47},
194 {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 2.50, 2.50, 2.50},
195 {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 2.50}
200 {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0},
201 {-1.0, -1.0, 77.0, 110., 153., 100., 100., 100., -1.0, -1.0, -1.0, -1.0, -1.0},
202 {-1.0, -1.0, -1.0, 110., 153., 100., 100., 100., 100., 100., 100., -1.0, -1.0},
203 {-1.0, -1.0, -1.0, -1.0, 153., 100., 100., 100., 100., 100., 100., 100., 100.},
204 {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 100., 100., 100., 100., 100., 100., 100.},
205 {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 100., 100., 100., 100., 100., 100., 100.},
206 {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 100., 100., 100., 100., 100.},
207 {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 100., 100., 100.},
208 {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 100.}
211 const G4int elementTableSize = 113;
214 const std::string elementTable[elementTableSize] = {
331 const std::string elementIUPACDigits =
"nubtqphsoe";
333#define INCL_DEFAULT_SEPARATION_ENERGY 6.83
338 const G4double theINCLantiProtonSeparationEnergy = 0.;
344#undef INCL_DEFAULT_SEPARATION_ENERGY
351#ifdef INCLXX_IN_GEANT4_MODE
359 char iupacToInt(
char c) {
360 return (
char)(((
G4int)
'0')+elementIUPACDigits.find(c));
364 char intToIUPAC(
char n) {
return elementIUPACDigits.at(n); }
367 const NaturalIsotopicDistributions *getNaturalIsotopicDistributions() {
368 if(!theNaturalIsotopicDistributions)
369 theNaturalIsotopicDistributions =
new NaturalIsotopicDistributions;
370 return theNaturalIsotopicDistributions;
376 protonMass = theINCLNucleonMass;
377 neutronMass = theINCLNucleonMass;
378 piPlusMass = theINCLPionMass;
379 piMinusMass = theINCLPionMass;
380 piZeroMass = theINCLPionMass;
382 etaMass = theINCLEtaMass;
383 omegaMass = theINCLOmegaMass;
384 etaPrimeMass = theINCLEtaPrimeMass;
385 photonMass = theINCLPhotonMass;
387 SigmaPlusMass = theRealSigmaPlusMass;
388 SigmaMinusMass = theRealSigmaMinusMass;
389 SigmaZeroMass = theRealSigmaZeroMass;
390 LambdaMass = theINCLLambdaMass;
391 KPlusMass = theRealChargedKaonMass;
392 KZeroMass = theRealNeutralKaonMass;
393 KZeroBarMass = theRealNeutralKaonMass;
394 KShortMass = theRealNeutralKaonMass;
395 KLongMass = theRealNeutralKaonMass;
396 KMinusMass = theRealChargedKaonMass;
398 antiProtonMass = theRealAntiProtonMass;
399 XiZeroMass = theRealXiZeroMass;
400 XiMinusMass = theRealXiMinusMass;
401 antiNeutronMass = theRealAntiNeutronMass;
402 antiSigmaPlusMass = theRealAntiSigmaPlusMass;
403 antiSigmaMinusMass = theRealAntiSigmaMinusMass;
404 antiSigmaZeroMass = theRealAntiSigmaZeroMass;
405 antiLambdaMass = theRealAntiLambdaMass;
406 antiXiZeroMass = theRealAntiXiZeroMass;
407 antiXiMinusMass = theRealAntiXiMinusMass;
417#ifndef INCLXX_IN_GEANT4_MODE
418 std::string dataFilePath;
424#ifdef INCLXX_IN_GEANT4_MODE
456 minDeltaMass = theRealNeutronMass + theRealChargedPiMass + 0.5;
460 piPlusWidth = theChargedPiWidth;
461 piMinusWidth = theChargedPiWidth;
462 piZeroWidth = thePiZeroWidth;
463 etaWidth = theEtaWidth;
464 omegaWidth = theOmegaWidth;
465 etaPrimeWidth = theEtaPrimeWidth;
467 SigmaMinusWidth = theSigmaMinusWidth;
468 SigmaPlusWidth = theSigmaPlusWidth;
469 SigmaZeroWidth = theSigmaZeroWidth;
470 LambdaWidth = theLambdaWidth;
471 KPlusWidth = theChargedKaonWidth;
472 KMinusWidth = theChargedKaonWidth;
473 KShortWidth = theKShortWidth;
474 KLongWidth = theKLongWidth;
477#ifdef INCLXX_IN_GEANT4_MODE
500 if(aFermiMomentum>0.)
501 constantFermiMomentum = aFermiMomentum;
517 std::fill(rpCorrelationCoefficient, rpCorrelationCoefficient +
UnknownParticle, 1.);
559 }
else if(t ==
KPlus) {
561 }
else if(t ==
KZero) {
567 }
else if(t ==
KLong) {
571 }
else if(t ==
Eta) {
573 }
else if(t ==
Omega) {
600 INCL_ERROR(
"Requested isospin of an unknown particle!");
605 if(sp.theType==
Composite && sp.theS == 0)
608 return getName(sp.theA,sp.theZ,sp.theS);
614 if(sp.theType==
Composite && sp.theS == 0)
615 return getName(sp.theA,sp.theZ);
617 return getName(sp.theA,sp.theZ,sp.theS);
623 std::stringstream stream;
629 std::stringstream stream;
640 std::stringstream stream;
649 return std::string(
"proton");
651 return std::string(
"neutron");
653 return std::string(
"delta++");
655 return std::string(
"delta+");
657 return std::string(
"delta0");
659 return std::string(
"delta-");
661 return std::string(
"pi+");
663 return std::string(
"pi0");
665 return std::string(
"pi-");
667 return std::string(
"lambda");
669 return std::string(
"sigma+");
671 return std::string(
"sigma0");
673 return std::string(
"sigma-");
675 return std::string(
"antiproton");
677 return std::string(
"xi-");
679 return std::string(
"xi0");
681 return std::string(
"antineutron");
683 return std::string(
"antisigma+");
685 return std::string(
"antisigma0");
687 return std::string(
"antisigma-");
689 return std::string(
"antilambda");
691 return std::string(
"antixi-");
693 return std::string(
"antixi0");
695 return std::string(
"kaon+");
697 return std::string(
"kaon0");
699 return std::string(
"kaon0bar");
701 return std::string(
"kaon-");
703 return std::string(
"kaonshort");
705 return std::string(
"kaonlong");
707 return std::string(
"composite");
709 return std::string(
"eta");
711 return std::string(
"omega");
713 return std::string(
"etaprime");
715 return std::string(
"photon");
717 return std::string(
"unknown");
722 return std::string(
"p");
724 return std::string(
"n");
726 return std::string(
"d++");
728 return std::string(
"d+");
730 return std::string(
"d0");
732 return std::string(
"d-");
734 return std::string(
"pi+");
736 return std::string(
"pi0");
738 return std::string(
"pi-");
740 return std::string(
"l");
742 return std::string(
"s+");
744 return std::string(
"s0");
746 return std::string(
"s-");
748 return std::string(
"pb");
750 return std::string(
"x-");
752 return std::string(
"x0");
754 return std::string(
"nb");
756 return std::string(
"s+b");
758 return std::string(
"s0b");
760 return std::string(
"s-b");
762 return std::string(
"lb");
764 return std::string(
"x-b");
766 return std::string(
"x0b");
768 return std::string(
"k+");
770 return std::string(
"k0");
772 return std::string(
"k0b");
774 return std::string(
"k-");
776 return std::string(
"ks");
778 return std::string(
"kl");
780 return std::string(
"comp");
782 return std::string(
"eta");
784 return std::string(
"omega");
786 return std::string(
"etap");
788 return std::string(
"photon");
790 return std::string(
"unknown");
805 return SigmaPlusMass;
807 return SigmaMinusMass;
809 return SigmaZeroMass;
813 return antiProtonMass;
819 return antiNeutronMass;
821 return antiSigmaPlusMass;
823 return antiSigmaMinusMass;
825 return antiSigmaZeroMass;
827 return antiLambdaMass;
829 return antiXiMinusMass;
831 return antiXiZeroMass;
832 }
else if(pt ==
KPlus) {
834 }
else if(pt ==
KZero) {
842 }
else if(pt ==
KLong) {
844 }
else if(pt ==
Eta) {
846 }
else if(pt ==
Omega) {
853 INCL_ERROR(
"getMass : Unknown particle type." <<
'\n');
861 return theRealProtonMass;
864 return theRealNeutronMass;
868 return theRealChargedPiMass;
871 return theRealPiZeroMass;
874 return theRealEtaMass;
877 return theRealOmegaMass;
880 return theRealEtaPrimeMass;
883 return theRealPhotonMass;
886 return theRealLambdaMass;
890 return theRealChargedKaonMass;
896 return theRealNeutralKaonMass;
899 return theRealSigmaPlusMass;
902 return theRealSigmaZeroMass;
905 return theRealSigmaMinusMass;
908 return theRealAntiProtonMass;
911 return theRealXiMinusMass;
914 return theRealXiZeroMass;
917 return theRealAntiNeutronMass;
920 return theRealAntiSigmaPlusMass;
923 return theRealAntiSigmaZeroMass;
926 return theRealAntiSigmaMinusMass;
929 return theRealAntiXiMinusMass;
932 return theRealAntiXiZeroMass;
935 return theRealAntiLambdaMass;
938 INCL_ERROR(
"Particle::getRealMass : Unknown particle type." <<
'\n');
955 else if(Z==0 &&
S==0)
956 return A*theRealNeutronMass;
958 return A*theRealProtonMass;
960 return (
A+
S)*theRealNeutronMass-
S*LambdaMass;
962#ifndef INCLXX_IN_GEANT4_MODE
963 return ::G4INCL::NuclearMassTable::getMass(
A,Z,
S);
965 if(
S<0)
return theG4IonTable->GetNucleusMass(Z,
A,std::abs(
S)) / MeV;
966 else return theG4IonTable->GetNucleusMass(Z,
A) / MeV;
985 return Z*(protonMass - protonSeparationEnergy) + (
A+
S-Z)*(neutronMass - neutronSeparationEnergy) + std::abs(
S)*(LambdaMass - lambdaSeparationEnergy);
987 return Z*(protonMass - protonSeparationEnergy) + (
A-Z)*(neutronMass - neutronSeparationEnergy);
988 else if(
A==1 && Z==0 &&
S==0)
990 else if(
A==1 && Z==1 &&
S==0)
992 else if(
A==1 && Z==0 &&
S==-1)
1172 const G4double thisRMS = positionRMS[Z][
A];
1176 INCL_DEBUG(
"getNuclearRadius: Radius for nucleus A = " <<
A <<
" Z = " << Z <<
" is not available" <<
'\n'
1177 <<
"returning radius for C12");
1178 return positionRMS[6][12];
1180 }
else if(
A <= 19) {
1185 return 1.225*theDiffusenessParameter*
1186 std::sqrt((2.+5.*theRadiusParameter)/(2.+3.*theRadiusParameter));
1188 INCL_ERROR(
"getNuclearRadius: No radius for nucleus A = " <<
A <<
" Z = " << Z <<
'\n');
1202 G4double r0 = (1.128+0.439*std::pow(
A,-2./3.)) * std::pow(
A, 1.0/3.0);
1206 G4double r0 = (2.745e-4 *
A + 1.063) * std::pow(
A, 1.0/3.0);
1210 if(r0hfb>0.)r0 = r0hfb;
1217 if(Z<clusterTableZSize && Z>=0) {
1218 const G4double thisRMS = positionRMS[Z][
A];
1222 INCL_DEBUG(
"getRadiusParameter: Radius for nucleus A = " <<
A <<
" Z = " << Z <<
" is not available" <<
'\n'
1223 <<
"returning radius for C12");
1224 return positionRMS[6][12];
1227 INCL_DEBUG(
"getRadiusParameter: Radius for nucleus A = " <<
A <<
" Z = " << Z <<
" is not available" <<
'\n'
1228 <<
"returning radius for C12");
1229 return positionRMS[6][12];
1233 G4double r0 = (1.128+0.439*std::pow(
A,-2./3.)) * std::pow(
A, 1.0/3.0);
1239 if(r0hfb>0.)
return r0hfb;
1241 return mediumRadius[
A-1];
1244 INCL_ERROR(
"getRadiusParameter: No radius for nucleus A = " <<
A <<
" Z = " << Z <<
'\n');
1254 return 5.5 + 0.3 * (
G4double(
A) - 6.0)/12.0;
1258 INCL_ERROR(
"getMaximumNuclearRadius : No maximum radius for nucleus A = " <<
A <<
" Z = " << Z <<
'\n');
1285 if(ahfb>0.)
return ahfb;
1287 return mediumDiffuseness[
A-1];
1289 INCL_ERROR(
"getSurfaceDiffuseness: was called for A = " <<
A <<
" Z = " << Z <<
'\n');
1292 INCL_ERROR(
"getSurfaceDiffuseness: No diffuseness for nucleus A = " <<
A <<
" Z = " << Z <<
'\n');
1304 return theINCLProtonSeparationEnergy;
1306 return theINCLNeutronSeparationEnergy;
1308 return theINCLLambdaSeparationEnergy;
1310 return theINCLantiProtonSeparationEnergy;
1312 INCL_ERROR(
"ParticleTable::getSeparationEnergyINCL : Unknown particle type." <<
'\n');
1326 INCL_ERROR(
"ParticleTable::getSeparationEnergyReal : Unknown particle type." <<
'\n');
1353 INCL_WARN(
"getElementName called with Z<1" <<
'\n');
1354 return elementTable[0];
1355 }
else if(Z<elementTableSize)
1356 return elementTable[Z];
1362 std::stringstream elementStream;
1364 std::string elementName = elementStream.str();
1365 std::transform(elementName.begin(), elementName.end(), elementName.begin(), intToIUPAC);
1366 elementName[0] = (char)std::toupper(elementName.at(0));
1372 std::transform(pS.begin(), pS.end(), pS.begin(), ::tolower);
1373 pS[0] = (char)std::toupper(pS[0]);
1375 const std::string *iter = std::find(elementTable, elementTable+elementTableSize, pS);
1376 if(iter != elementTable+elementTableSize)
1377 return G4int(iter - elementTable);
1384 std::string elementName(sel);
1385 std::transform(elementName.begin(), elementName.end(), elementName.begin(), ::tolower);
1387 if(elementName.find_first_not_of(elementIUPACDigits)!=std::string::npos)
1389 std::transform(elementName.begin(), elementName.end(), elementName.begin(), iupacToInt);
1390 std::stringstream elementStream(elementName);
1397 return getNaturalIsotopicDistributions()->getIsotopicDistribution(Z);
1405 return constantFermiMomentum;
1419 static const G4double alphaParam = 259.416;
1420 static const G4double betaParam = 152.824;
1421 static const G4double gammaParam = 9.5157E-2;
1422 return alphaParam - betaParam*std::exp(-gammaParam*((
G4double)
A));
1427 return rpCorrelationCoefficient[t];
1447 else if (isosp == 0) {
1470 else if (isosp == -1) {
1473 else if (isosp == 1) {
1486 else if (isosp == 0) {
1519 else if (isosp == 0) {
1562 return piMinusWidth;
1563 }
else if(pt ==
PiZero) {
1565 }
else if(pt ==
Eta) {
1567 }
else if(pt ==
Omega) {
1570 return etaPrimeWidth;
1572 return SigmaPlusWidth;
1574 return SigmaZeroWidth;
1576 return SigmaMinusWidth;
1577 }
else if(pt ==
KPlus) {
1579 }
else if(pt ==
KMinus) {
1581 }
else if(pt ==
KShort) {
1583 }
else if(pt ==
KLong) {
1585 }
else if(pt ==
Lambda) {
1588 return XiMinusWidth;
1589 }
else if(pt ==
XiZero) {
1592 return antiSigmaPlusWidth;
1594 return antiSigmaZeroWidth;
1596 return antiSigmaMinusWidth;
1598 return antiLambdaWidth;
1600 return antiXiMinusWidth;
1602 return antiXiZeroWidth;
1604 INCL_ERROR(
"getWidth : Unknown particle type." <<
'\n');
G4double S(G4double temp)
Functions that encapsulate a mass table.
#define INCL_DEFAULT_SEPARATION_ENERGY
G4double getNeutronHalo() const
Get the neutron-halo size.
FermiMomentumType getFermiMomentumType() const
Get the Fermi-momentum type.
SeparationEnergyType getSeparationEnergyType() const
Get the separation-energy type.
G4double getRPCorrelationCoefficient(const ParticleType t) const
Get the r-p correlation coefficient.
std::string const & getINCLXXDataFilePath() const
Set the ABLAXX datafile path.
G4double getNeutronSkin() const
Get the neutron-skin thickness.
G4double getFermiMomentum() const
Get the Fermi momentum.
G4bool getUseRealMasses() const
Whether to use real masses.
Class that stores isotopic abundances for a given element.
G4int drawRandomIsotope() const
Draw a random isotope based on the abundance vector.
G4double GetPDGMass() const
G4IonTable * GetIonTable() const
G4ParticleDefinition * FindParticle(G4int PDGEncoding)
static G4ParticleTable * GetParticleTable()
G4double getSurfaceDiffusenessHFB(const ParticleType t, const G4int A, const G4int Z)
G4double getRadiusParameterHFB(const ParticleType t, const G4int A, const G4int Z)
Get the radius and diffuseness parameters from HFB calculations.
T max(const T t1, const T t2)
brief Return the largest of the two arguments
const G4double sqrtFiveThirds
const G4double sqrtThreeFifths
G4int getMassNumber(const ParticleType t)
Get mass number from particle type.
G4ThreadLocal FermiMomentumFn getFermiMomentum
const G4double effectiveDeltaWidth
G4int parseElement(std::string pS)
Get the name of the element from the atomic number.
G4ThreadLocal G4double minDeltaMass2
G4double(* FermiMomentumFn)(const G4int, const G4int)
G4ThreadLocal NuclearMassFn getTableMass
Static pointer to the mass function for nuclei.
G4ThreadLocal SeparationEnergyFn getSeparationEnergy
Static pointer to the separation-energy function.
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)
G4ThreadLocal ParticleMassFn getTableParticleMass
Static pointer to the mass function for particles.
void initialize(Config const *const theConfig=0)
Initialize the particle table.
const G4double effectiveDeltaMass
G4double getFermiMomentumMassDependent(const G4int A, const G4int)
Return the value Fermi momentum from a fit.
G4double getTableSpeciesMass(const ParticleSpecies &p)
G4double getLambdaSeparationEnergy()
G4int drawRandomNaturalIsotope(const G4int Z)
G4double getSeparationEnergyReal(const ParticleType t, const G4int A, const G4int Z)
Return the real separation energy.
G4double getNeutronSeparationEnergy()
Getter for neutronSeparationEnergy.
G4ThreadLocal G4double minDeltaMass
const G4int clusterTableZSize
G4double getRadiusParameter(const ParticleType t, const G4int A, const G4int Z)
G4double getLargestNuclearRadius(const G4int A, const G4int Z)
ParticleType getKaonType(const G4int isosp)
Get the type of kaon.
G4double getNeutronHalo()
Get the size of the neutron halo.
G4double getRealMass(const G4INCL::ParticleType t)
Get particle mass (in MeV/c^2)
ParticleType getSigmaType(const G4int isosp)
Get the type of sigma.
G4double getINCLMass(const G4int A, const G4int Z, const G4int S)
Get INCL nuclear mass (in MeV/c^2)
G4double(* ParticleMassFn)(const ParticleType)
G4int getStrangenessNumber(const ParticleType t)
Get strangeness number from particle type.
G4double getMaximumNuclearRadius(const ParticleType t, const G4int A, const G4int Z)
G4double getRPCorrelationCoefficient(const ParticleType t)
Get the value of the r-p correlation coefficient.
G4int parseIUPACElement(std::string const &pS)
Parse a IUPAC element name.
G4double getSeparationEnergyINCL(const ParticleType t, const G4int, const G4int)
Return INCL's default separation energy.
void setNeutronSeparationEnergy(const G4double s)
Setter for protonSeparationEnergy.
G4double getFermiMomentumConstant(const G4int, const G4int)
Return the constant value of the Fermi momentum.
std::string getName(const ParticleType t)
Get the native INCL name of the particle.
G4ThreadLocal G4double minDeltaMassRndm
G4double(* SeparationEnergyFn)(const ParticleType, const G4int, const G4int)
G4double getNeutronSkin()
Get the thickness of the neutron skin.
std::string getIUPACElementName(const G4int Z)
Get the name of an unnamed element from the IUPAC convention.
G4int getIsospin(const ParticleType t)
Get the isospin of a particle.
ParticleType getNucleonType(const G4int isosp)
Get the type of nucleon.
ParticleType getAntiXiType(const G4int isosp)
Get the type of antidelta.
G4double getSurfaceDiffuseness(const ParticleType t, const G4int A, const G4int Z)
const G4int clusterTableASize
G4double getFermiMomentumConstantLight(const G4int A, const G4int Z)
Return the constant value of the Fermi momentum - special for light.
void setProtonSeparationEnergy(const G4double s)
Setter for protonSeparationEnergy.
ParticleType getPionType(const G4int isosp)
Get the type of pion.
ParticleType getDeltaType(const G4int isosp)
Get the type of delta.
void setLambdaSeparationEnergy(const G4double sen)
G4double(* NuclearMassFn)(const G4int, const G4int, const G4int)
G4int getChargeNumber(const ParticleType t)
Get charge number from particle type.
G4double getProtonSeparationEnergy()
Getter for protonSeparationEnergy.
IsotopicDistribution const & getNaturalIsotopicDistribution(const G4int Z)
ParticleType getAntiSigmaType(const G4int isosp)
Get the type of antisigma.
G4double getMomentumRMS(const G4int A, const G4int Z)
Return the RMS of the momentum distribution (light clusters)
ParticleType getAntiKaonType(const G4int isosp)
Get the type of antikaon.
G4double getSeparationEnergyRealForLight(const ParticleType t, const G4int A, const G4int Z)
Return the real separation energy only for light nuclei.
G4double getNuclearRadius(const ParticleType t, const G4int A, const G4int Z)
G4double getWidth(const ParticleType t)
Get particle width (in s)
std::string getShortName(const ParticleType t)
Get the short INCL name of the particle.
std::string getElementName(const G4int Z)
Get the name of the element from the atomic number.
ParticleType getXiType(const G4int isosp)
Get the type of xi.
const G4double Pf
Fermi momentum [MeV/c].
@ MassDependentFermiMomentum
@ ConstantLightFermiMomentum
@ RealForLightSeparationEnergy