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;
109 const G4double theChargedPiWidth = 2.6033e-08;
110 const G4double thePiZeroWidth = 8.52e-17;
111 const G4double theEtaWidth = 5.025e-19;
112 const G4double theOmegaWidth = 7.7528e-23;
113 const G4double theEtaPrimeWidth = 3.3243e-21;
114 const G4double theChargedKaonWidth = 1.238e-08;
115 const G4double theKShortWidth = 8.954e-11;
116 const G4double theKLongWidth = 5.116e-08;
117 const G4double theLambdaWidth = 2.632e-10;
118 const G4double theSigmaPlusWidth = 8.018e-11;
119 const G4double theSigmaZeroWidth = 7.4e-20;
120 const G4double theSigmaMinusWidth = 1.479e-10;
137 const G4int mediumNucleiTableSize = 30;
139 const G4double mediumDiffuseness[mediumNucleiTableSize] =
140 {0.0,0.0,0.0,0.0,0.0,1.78,1.77,1.77,1.77,1.71,
141 1.69,1.69,1.635,1.730,1.81,1.833,1.798,
142 1.841,0.567,0.571, 0.560,0.549,0.550,0.551,
143 0.580,0.575,0.569,0.537,0.0,0.0};
144 const G4double mediumRadius[mediumNucleiTableSize] =
145 {0.0,0.0,0.0,0.0,0.0,0.334,0.327,0.479,0.631,0.838,
146 0.811,1.07,1.403,1.335,1.25,1.544,1.498,1.513,
147 2.58,2.77, 2.775,2.78,2.88,2.98,3.22,3.03,2.84,
152 {-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},
153 {-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},
154 {-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},
155 {-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},
156 {-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},
157 {-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},
158 {-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},
159 {-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},
160 {-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}
165 {-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},
166 {-1.0, -1.0, 77.0, 110., 153., 100., 100., 100., -1.0, -1.0, -1.0, -1.0, -1.0},
167 {-1.0, -1.0, -1.0, 110., 153., 100., 100., 100., 100., 100., 100., -1.0, -1.0},
168 {-1.0, -1.0, -1.0, -1.0, 153., 100., 100., 100., 100., 100., 100., 100., 100.},
169 {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 100., 100., 100., 100., 100., 100., 100.},
170 {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 100., 100., 100., 100., 100., 100., 100.},
171 {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 100., 100., 100., 100., 100.},
172 {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 100., 100., 100.},
173 {-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.}
177 const G4int elementTableSize = 113;
180 const std::string elementTable[elementTableSize] = {
297 const std::string elementIUPACDigits =
"nubtqphsoe";
299 #define INCL_DEFAULT_SEPARATION_ENERGY 6.83
304 #undef INCL_DEFAULT_SEPARATION_ENERGY
311 #ifdef INCLXX_IN_GEANT4_MODE
319 char iupacToInt(
char c) {
320 return (
char)(((
G4int)
'0')+elementIUPACDigits.find(c));
324 char intToIUPAC(
char n) {
return elementIUPACDigits.at(n); }
327 const NaturalIsotopicDistributions *getNaturalIsotopicDistributions() {
328 if(!theNaturalIsotopicDistributions)
329 theNaturalIsotopicDistributions =
new NaturalIsotopicDistributions;
330 return theNaturalIsotopicDistributions;
336 protonMass = theINCLNucleonMass;
337 neutronMass = theINCLNucleonMass;
338 piPlusMass = theINCLPionMass;
339 piMinusMass = theINCLPionMass;
340 piZeroMass = theINCLPionMass;
353 SigmaPlusMass = theRealSigmaPlusMass;
354 SigmaMinusMass = theRealSigmaMinusMass;
355 SigmaZeroMass = theRealSigmaZeroMass;
356 LambdaMass = theINCLLambdaMass;
357 KPlusMass = theRealChargedKaonMass;
358 KZeroMass = theRealNeutralKaonMass;
359 KZeroBarMass = theRealNeutralKaonMass;
360 KShortMass = theRealNeutralKaonMass;
361 KLongMass = theRealNeutralKaonMass;
362 KMinusMass = theRealChargedKaonMass;
364 etaMass = theINCLEtaMass;
365 omegaMass = theINCLOmegaMass;
366 etaPrimeMass = theINCLEtaPrimeMass;
367 photonMass = theINCLPhotonMass;
376 #ifndef INCLXX_IN_GEANT4_MODE
377 std::string dataFilePath;
383 #ifdef INCLXX_IN_GEANT4_MODE
402 minDeltaMass = theRealNeutronMass + theRealChargedPiMass + 0.5;
406 piPlusWidth = theChargedPiWidth;
407 piMinusWidth = theChargedPiWidth;
408 piZeroWidth = thePiZeroWidth;
409 etaWidth = theEtaWidth;
410 omegaWidth = theOmegaWidth;
411 etaPrimeWidth = theEtaPrimeWidth;
413 SigmaMinusWidth = theSigmaMinusWidth;
414 SigmaPlusWidth = theSigmaPlusWidth;
415 SigmaZeroWidth = theSigmaZeroWidth;
416 LambdaWidth = theLambdaWidth;
417 KPlusWidth = theChargedKaonWidth;
418 KMinusWidth = theChargedKaonWidth;
419 KShortWidth = theKShortWidth;
420 KLongWidth = theKLongWidth;
440 if(aFermiMomentum>0.)
441 constantFermiMomentum = aFermiMomentum;
457 std::fill(rpCorrelationCoefficient, rpCorrelationCoefficient +
UnknownParticle, 1.);
499 }
else if(t ==
KPlus) {
501 }
else if(t ==
KZero) {
507 }
else if(t ==
KLong) {
511 }
else if(t ==
Eta) {
513 }
else if(t ==
Omega) {
520 INCL_ERROR(
"Requested isospin of an unknown particle!");
539 std::stringstream stream;
545 std::stringstream stream;
554 return std::string(
"proton");
556 return std::string(
"neutron");
558 return std::string(
"delta++");
560 return std::string(
"delta+");
562 return std::string(
"delta0");
564 return std::string(
"delta-");
566 return std::string(
"pi+");
568 return std::string(
"pi0");
570 return std::string(
"pi-");
572 return std::string(
"lambda");
574 return std::string(
"sigma+");
576 return std::string(
"sigma0");
578 return std::string(
"sigma-");
580 return std::string(
"kaon+");
582 return std::string(
"kaon0");
584 return std::string(
"kaon0bar");
586 return std::string(
"kaon-");
588 return std::string(
"kaonshort");
590 return std::string(
"kaonlong");
592 return std::string(
"composite");
594 return std::string(
"eta");
596 return std::string(
"omega");
598 return std::string(
"etaprime");
600 return std::string(
"photon");
602 return std::string(
"unknown");
607 return std::string(
"p");
609 return std::string(
"n");
611 return std::string(
"d++");
613 return std::string(
"d+");
615 return std::string(
"d0");
617 return std::string(
"d-");
619 return std::string(
"pi+");
621 return std::string(
"pi0");
623 return std::string(
"pi-");
625 return std::string(
"l");
627 return std::string(
"s+");
629 return std::string(
"s0");
631 return std::string(
"s-");
633 return std::string(
"k+");
635 return std::string(
"k0");
637 return std::string(
"k0b");
639 return std::string(
"k-");
641 return std::string(
"ks");
643 return std::string(
"kl");
645 return std::string(
"comp");
647 return std::string(
"eta");
649 return std::string(
"omega");
651 return std::string(
"etap");
653 return std::string(
"photon");
655 return std::string(
"unknown");
670 return SigmaPlusMass;
672 return SigmaMinusMass;
674 return SigmaZeroMass;
677 }
else if(pt ==
KPlus) {
679 }
else if(pt ==
KZero) {
687 }
else if(pt ==
KLong) {
689 }
else if(pt ==
Eta) {
691 }
else if(pt ==
Omega) {
698 INCL_ERROR(
"getMass : Unknown particle type." <<
'\n');
706 return theRealProtonMass;
709 return theRealNeutronMass;
713 return theRealChargedPiMass;
716 return theRealPiZeroMass;
719 return theRealSigmaPlusMass;
722 return theRealSigmaZeroMass;
725 return theRealSigmaMinusMass;
728 return theRealLambdaMass;
732 return theRealChargedKaonMass;
738 return theRealNeutralKaonMass;
740 return theRealEtaMass;
743 return theRealOmegaMass;
746 return theRealEtaPrimeMass;
749 return theRealPhotonMass;
752 INCL_ERROR(
"Particle::getRealMass : Unknown particle type." <<
'\n');
770 #ifndef INCLXX_IN_GEANT4_MODE
771 return ::G4INCL::NuclearMassTable::getMass(A,Z);
773 return theG4IonTable->GetNucleusMass(Z,A) /
MeV;
787 return Z*(protonMass - protonSeparationEnergy) + (A-Z)*(neutronMass - neutronSeparationEnergy);
788 else if(A==1 && Z==0)
790 else if(A==1 && Z==1)
928 if(A >= 19 || (A < 6 && A >= 2)) {
932 }
else if(A < clusterTableASize && Z>=0 && Z < clusterTableZSize && A >= 6) {
937 INCL_DEBUG(
"getNuclearRadius: Radius for nucleus A = " << A <<
" Z = " << Z <<
" is not available" <<
'\n'
938 <<
"returning radius for C12");
939 return positionRMS[6][12];
946 return 1.225*theDiffusenessParameter*
947 std::sqrt((2.+5.*theRadiusParameter)/(2.+3.*theRadiusParameter));
949 INCL_ERROR(
"getNuclearRadius: No radius for nucleus A = " << A <<
" Z = " << Z <<
'\n');
962 G4double r0 = (2.745e-4 * A + 1.063) * std::pow(A, 1.0/3.0);
966 if(r0hfb>0.)r0 = r0hfb;
972 }
else if(A < 6 && A >= 2) {
973 if(Z<clusterTableZSize && Z>=0) {
978 INCL_DEBUG(
"getRadiusParameter: Radius for nucleus A = " << A <<
" Z = " << Z <<
" is not available" <<
'\n'
979 <<
"returning radius for C12");
980 return positionRMS[6][12];
983 INCL_DEBUG(
"getRadiusParameter: Radius for nucleus A = " << A <<
" Z = " << Z <<
" is not available" <<
'\n'
984 <<
"returning radius for C12");
985 return positionRMS[6][12];
987 }
else if(A <= 19 && A >= 6) {
988 return mediumRadius[A-1];
991 INCL_ERROR(
"getRadiusParameter: No radius for nucleus A = " << A <<
" Z = " << Z <<
'\n');
1000 }
else if(A <= 19 && A >= 6) {
1001 return 5.5 + 0.3 * (
G4double(A) - 6.0)/12.0;
1005 INCL_ERROR(
"getMaximumNuclearRadius : No maximum radius for nucleus A = " << A <<
" Z = " << Z <<
'\n');
1022 }
else if(A <= 19 && A >= 6) {
1023 return mediumDiffuseness[A-1];
1024 }
else if(A < 6 && A >= 2) {
1025 INCL_ERROR(
"getSurfaceDiffuseness: was called for A = " << A <<
" Z = " << Z <<
'\n');
1028 INCL_ERROR(
"getSurfaceDiffuseness: No diffuseness for nucleus A = " << A <<
" Z = " << Z <<
'\n');
1040 return theINCLProtonSeparationEnergy;
1042 return theINCLNeutronSeparationEnergy;
1044 INCL_ERROR(
"ParticleTable::getSeparationEnergyINCL : Unknown particle type." <<
'\n');
1056 INCL_ERROR(
"ParticleTable::getSeparationEnergyReal : Unknown particle type." <<
'\n');
1079 INCL_WARN(
"getElementName called with Z<1" <<
'\n');
1080 return elementTable[0];
1081 }
else if(Z<elementTableSize)
1082 return elementTable[
Z];
1088 std::stringstream elementStream;
1090 std::string elementName = elementStream.str();
1091 std::transform(elementName.begin(), elementName.end(), elementName.begin(), intToIUPAC);
1092 elementName[0] = std::toupper(elementName.at(0));
1098 std::transform(pS.begin(), pS.end(), pS.begin(), ::tolower);
1099 pS[0] = ::toupper(pS[0]);
1101 const std::string *iter = std::find(elementTable, elementTable+elementTableSize, pS);
1102 if(iter != elementTable+elementTableSize)
1103 return iter - elementTable;
1110 std::string elementName(s);
1111 std::transform(elementName.begin(), elementName.end(), elementName.begin(), ::tolower);
1113 if(elementName.find_first_not_of(elementIUPACDigits)!=std::string::npos)
1115 std::transform(elementName.begin(), elementName.end(), elementName.begin(), iupacToInt);
1116 std::stringstream elementStream(elementName);
1123 return getNaturalIsotopicDistributions()->getIsotopicDistribution(Z);
1127 return getNaturalIsotopicDistributions()->drawRandomIsotope(Z);
1131 return constantFermiMomentum;
1145 static const G4double alphaParam = 259.416;
1146 static const G4double betaParam = 152.824;
1147 static const G4double gammaParam = 9.5157E-2;
1148 return alphaParam - betaParam*std::exp(-gammaParam*((
G4double)A));
1153 return rpCorrelationCoefficient[t];
1173 else if (isosp == 0) {
1196 else if (isosp == -1) {
1199 else if (isosp == 1) {
1213 else if (isosp == 0) {
1246 return piMinusWidth;
1247 }
else if(pt ==
PiZero) {
1249 }
else if(pt ==
Eta) {
1251 }
else if(pt ==
Omega) {
1254 return etaPrimeWidth;
1256 return SigmaPlusWidth;
1258 return SigmaZeroWidth;
1260 return SigmaMinusWidth;
1261 }
else if(pt ==
KPlus) {
1263 }
else if(pt ==
KMinus) {
1265 }
else if(pt ==
KShort) {
1267 }
else if(pt ==
KLong) {
1270 INCL_ERROR(
"getWidth : Unknown particle type." <<
'\n');
G4ParticleDefinition * FindParticle(G4int PDGEncoding)
G4double getSeparationEnergyReal(const ParticleType t, const G4int A, const G4int Z)
Return the real separation energy.
G4double getLargestNuclearRadius(const G4int A, const G4int Z)
const G4double effectiveDeltaMass
T max(const T t1, const T t2)
brief Return the largest of the two arguments
IsotopicDistribution const & getNaturalIsotopicDistribution(const G4int Z)
G4int parseIUPACElement(std::string const &pS)
Parse a IUPAC element name.
void setProtonSeparationEnergy(const G4double s)
Setter for protonSeparationEnergy.
G4double getWidth(const ParticleType t)
Get particle width (in s)
G4double getRadiusParameter(const ParticleType t, const G4int A, const G4int Z)
G4bool getUseRealMasses() const
Whether to use real masses.
std::vector< ExP01TrackerHit * > a
void setNeutronSeparationEnergy(const G4double s)
Setter for protonSeparationEnergy.
std::string getElementName(const G4int Z)
Get the name of the element from the atomic number.
ParticleType getNucleonType(const G4int isosp)
Get the type of nucleon.
static G4ParticleTable * GetParticleTable()
static constexpr double MeV
G4double getMomentumRMS(const G4int A, const G4int Z)
Return the RMS of the momentum distribution (light clusters)
G4ThreadLocal FermiMomentumFn getFermiMomentum
G4double getFermiMomentumConstantLight(const G4int A, const G4int Z)
Return the constant value of the Fermi momentum - special for light.
G4double getSurfaceDiffusenessHFB(const ParticleType t, const G4int A, const G4int Z)
#define INCL_DEFAULT_SEPARATION_ENERGY
ParticleType getAntiKaonType(const G4int isosp)
Get the type of antikaon.
G4double(* FermiMomentumFn)(const G4int, const G4int)
std::string const & getINCLXXDataFilePath() const
G4int getChargeNumber(const ParticleType t)
Get charge number from particle type.
std::string getIUPACElementName(const G4int Z)
Get the name of an unnamed element from the IUPAC convention.
G4double getNeutronHalo()
Get the size of the neutron halo.
G4IonTable * GetIonTable() const
Functions that encapsulate a mass table.
G4int drawRandomNaturalIsotope(const G4int Z)
G4double getRPCorrelationCoefficient(const ParticleType t)
Get the value of the r-p correlation coefficient.
const G4int clusterTableZSize
G4double GetPDGMass() const
G4int getStrangenessNumber(const ParticleType t)
Get strangeness number from particle type.
ParticleType getDeltaType(const G4int isosp)
Get the type of delta.
G4double getRealMass(const G4INCL::ParticleType t)
Get particle mass (in MeV/c^2)
G4int getMassNumber(const ParticleType t)
Get mass number from particle type.
const G4double Pf
Fermi momentum [MeV/c].
G4double getMaximumNuclearRadius(const ParticleType t, const G4int A, const G4int Z)
const G4int clusterTableASize
Class that stores isotopic abundances for a given element.
G4double(* SeparationEnergyFn)(const ParticleType, const G4int, const G4int)
G4double getNeutronSkin()
Get the thickness of the neutron skin.
G4ThreadLocal NuclearMassFn getTableMass
Static pointer to the mass function for nuclei.
G4double(* NuclearMassFn)(const G4int, const G4int)
G4double getRPCorrelationCoefficient(const ParticleType t) const
Get the r-p correlation coefficient.
G4double getSurfaceDiffuseness(const ParticleType t, const G4int A, const G4int Z)
G4double getINCLMass(const G4int A, const G4int Z)
Get INCL nuclear mass (in MeV/c^2)
G4double getTableSpeciesMass(const ParticleSpecies &p)
G4double getNeutronSeparationEnergy()
Getter for neutronSeparationEnergy.
void initialize(Config const *const theConfig)
Initialize the clustering model based on the Config object.
double A(double temperature)
ParticleType getKaonType(const G4int isosp)
Get the type of kaon.
const G4double sqrtThreeFifths
G4double(* ParticleMassFn)(const ParticleType)
G4double getNeutronSkin() const
Get the neutron-skin thickness.
G4double getRadiusParameterHFB(const ParticleType t, const G4int A, const G4int Z)
Get the radius and diffuseness parameters from HFB calculations.
G4double getSeparationEnergyINCL(const ParticleType t, const G4int, const G4int)
Return INCL's default separation energy.
std::string getName(const ParticleType t)
Get the native INCL name of the particle.
const G4double effectiveDeltaWidth
G4double getTableQValue(const G4int A1, const G4int Z1, const G4int A2, const G4int Z2)
Get Q-value (in MeV/c^2)
std::string getShortName(const ParticleType t)
Get the short INCL name of the particle.
SeparationEnergyType getSeparationEnergyType() const
Get the separation-energy type.
G4double getNeutronHalo() const
Get the neutron-halo size.
G4int getIsospin(const ParticleType t)
Get the isospin of a particle.
G4double getFermiMomentum() const
Get the Fermi momentum.
G4double getFermiMomentumConstant(const G4int, const G4int)
Return the constant value of the Fermi momentum.
ParticleType getSigmaType(const G4int isosp)
Get the type of sigma.
G4ThreadLocal G4double minDeltaMass2
G4ThreadLocal SeparationEnergyFn getSeparationEnergy
Static pointer to the separation-energy function.
const G4double sqrtFiveThirds
G4double getFermiMomentumMassDependent(const G4int A, const G4int)
Return the value Fermi momentum from a fit.
FermiMomentumType getFermiMomentumType() const
Get the Fermi-momentum type.
G4double getSeparationEnergyRealForLight(const ParticleType t, const G4int A, const G4int Z)
Return the real separation energy only for light nuclei.
G4ThreadLocal ParticleMassFn getTableParticleMass
Static pointer to the mass function for particles.
G4int parseElement(std::string pS)
Get the name of the element from the atomic number.
void initialize(Config const *const theConfig=0)
Initialize the particle table.
G4double getProtonSeparationEnergy()
Getter for protonSeparationEnergy.
ParticleType getPionType(const G4int isosp)
Get the type of pion.
G4double getNuclearRadius(const ParticleType t, const G4int A, const G4int Z)
G4ThreadLocal G4double minDeltaMassRndm
G4ThreadLocal G4double minDeltaMass