~ejungwoo/geant4/G4INCLParticleTable_8cc_source.html

 //

 // ********************************************************************

 // * License and Disclaimer                                           *

 // *                                                                  *

 // * The  Geant4 software  is  copyright of the Copyright Holders  of *

 // * the Geant4 Collaboration.  It is provided  under  the terms  and *

 // * conditions of the Geant4 Software License,  included in the file *

 // * LICENSE and available at  http://cern.ch/geant4/license .  These *

 // * include a list of copyright holders.                             *

 // *                                                                  *

 // * Neither the authors of this software system, nor their employing *

 // * institutes,nor the agencies providing financial support for this *

 // * work  make  any representation or  warranty, express or implied, *

 // * regarding  this  software system or assume any liability for its *

 // * use.  Please see the license in the file  LICENSE  and URL above *

 // * for the full disclaimer and the limitation of liability.         *

 // *                                                                  *

 // * This  code  implementation is the result of  the  scientific and *

 // * technical work of the GEANT4 collaboration.                      *

 // * By using,  copying,  modifying or  distributing the software (or *

 // * any work based  on the software)  you  agree  to acknowledge its *

 // * use  in  resulting  scientific  publications,  and indicate your *

 // * acceptance of all terms of the Geant4 Software license.          *

 // ********************************************************************

 //

 // INCL++ intra-nuclear cascade model

 // Alain Boudard, CEA-Saclay, France

 // Joseph Cugnon, University of Liege, Belgium

 // Jean-Christophe David, CEA-Saclay, France

 // Pekka Kaitaniemi, CEA-Saclay, France, and Helsinki Institute of Physics, Finland

 // Sylvie Leray, CEA-Saclay, France

 // Davide Mancusi, CEA-Saclay, France

 //

 #define INCLXX_IN_GEANT4_MODE 1


 #include "globals.hh"


 #include "G4INCLParticleTable.hh"

 #include "G4INCLNuclearMassTable.hh"

 #include <algorithm>

 // #include <cassert>

 #include <cmath>

 #include <cctype>

 #include <sstream>

 #ifdef INCLXX_IN_GEANT4_MODE

 #include "G4SystemOfUnits.hh"

 #endif


 #ifdef INCLXX_IN_GEANT4_MODE

 #include "G4PhysicalConstants.hh"

 #include "G4SystemOfUnits.hh"

 #endif


 namespace G4INCL {


   namespace ParticleTable {


     namespace {


       const NaturalIsotopicDistributions *theNaturalIsotopicDistributions = NULL;


       const G4double theINCLNucleonMass = 938.2796;

       const G4double theINCLPionMass = 138.0;

       const G4double theINCLLambdaMass = 1115.683;

 //      const G4double theINCLSigmaMass = 1197.45;

 //      const G4double theINCLKaonMass = 497.614;

       const G4double theINCLEtaMass = 547.862;

       const G4double theINCLOmegaMass = 782.65;

       const G4double theINCLEtaPrimeMass = 957.78;

       const G4double theINCLPhotonMass = 0.0;

       G4ThreadLocal G4double protonMass = 0.0;

       G4ThreadLocal G4double neutronMass = 0.0;

       G4ThreadLocal G4double piPlusMass = 0.0;

       G4ThreadLocal G4double piMinusMass = 0.0;

       G4ThreadLocal G4double piZeroMass = 0.0;

       G4ThreadLocal G4double SigmaPlusMass = 0.0;

       G4ThreadLocal G4double SigmaZeroMass = 0.0;

       G4ThreadLocal G4double SigmaMinusMass = 0.0;

       G4ThreadLocal G4double LambdaMass = 0.0;

       G4ThreadLocal G4double KPlusMass = 0.0;

       G4ThreadLocal G4double KZeroMass = 0.0;

       G4ThreadLocal G4double KZeroBarMass = 0.0;

       G4ThreadLocal G4double KShortMass = 0.0;

       G4ThreadLocal G4double KLongMass = 0.0;

       G4ThreadLocal G4double KMinusMass = 0.0;

       G4ThreadLocal G4double etaMass = 0.0;

       G4ThreadLocal G4double omegaMass = 0.0;

       G4ThreadLocal G4double etaPrimeMass = 0.0;

       G4ThreadLocal G4double photonMass = 0.0;


       // Hard-coded values of the real particle masses (MeV/c^2)

       G4ThreadLocal G4double theRealProtonMass = 938.27203;

       G4ThreadLocal G4double theRealNeutronMass = 939.56536;

       G4ThreadLocal G4double theRealChargedPiMass = 139.57018;

       G4ThreadLocal G4double theRealPiZeroMass = 134.9766;

       G4ThreadLocal G4double theRealLambdaMass = 1115.683;

       G4ThreadLocal G4double theRealSigmaPlusMass = 1189.37;

       G4ThreadLocal G4double theRealSigmaZeroMass = 1192.64;

       G4ThreadLocal G4double theRealSigmaMinusMass = 1197.45;

       G4ThreadLocal G4double theRealChargedKaonMass = 493.677;

       G4ThreadLocal G4double theRealNeutralKaonMass = 497.614;

       G4ThreadLocal G4double theRealEtaMass = 547.862;

       G4ThreadLocal G4double theRealOmegaMass = 782.65;

       G4ThreadLocal G4double theRealEtaPrimeMass = 957.78;

       G4ThreadLocal G4double theRealPhotonMass = 0.0;


       // Width (second)

       const G4double theChargedPiWidth = 2.6033e-08;

       const G4double thePiZeroWidth = 8.52e-17;

       const G4double theEtaWidth = 5.025e-19; // 1.31 keV

       const G4double theOmegaWidth = 7.7528e-23; // 8.49 MeV

       const G4double theEtaPrimeWidth = 3.3243e-21; // 0.198 MeV

       const G4double theChargedKaonWidth = 1.238e-08;

       const G4double theKShortWidth = 8.954e-11;

       const G4double theKLongWidth = 5.116e-08;

       const G4double theLambdaWidth = 2.632e-10;

       const G4double theSigmaPlusWidth = 8.018e-11;

       const G4double theSigmaZeroWidth = 7.4e-20;

       const G4double theSigmaMinusWidth = 1.479e-10;

       G4ThreadLocal G4double piPlusWidth = 0.0;

       G4ThreadLocal G4double piMinusWidth = 0.0;

       G4ThreadLocal G4double piZeroWidth = 0.0;

       G4ThreadLocal G4double etaWidth = 0.0;

       G4ThreadLocal G4double omegaWidth = 0.0;

       G4ThreadLocal G4double etaPrimeWidth = 0.0;

       G4ThreadLocal G4double LambdaWidth = 0.0;

       G4ThreadLocal G4double SigmaPlusWidth = 0.0;

       G4ThreadLocal G4double SigmaZeroWidth = 0.0;

       G4ThreadLocal G4double SigmaMinusWidth = 0.0;

       G4ThreadLocal G4double KPlusWidth = 0.0;

       G4ThreadLocal G4double KMinusWidth = 0.0;

       G4ThreadLocal G4double KShortWidth = 0.0;

       G4ThreadLocal G4double KLongWidth = 0.0;


       const G4int mediumNucleiTableSize = 30;


       const G4double mediumDiffuseness[mediumNucleiTableSize] =

       {0.0,0.0,0.0,0.0,0.0,1.78,1.77,1.77,1.77,1.71,

         1.69,1.69,1.635,1.730,1.81,1.833,1.798,

         1.841,0.567,0.571, 0.560,0.549,0.550,0.551,

         0.580,0.575,0.569,0.537,0.0,0.0};

       const G4double mediumRadius[mediumNucleiTableSize] =

       {0.0,0.0,0.0,0.0,0.0,0.334,0.327,0.479,0.631,0.838,

         0.811,1.07,1.403,1.335,1.25,1.544,1.498,1.513,

         2.58,2.77, 2.775,2.78,2.88,2.98,3.22,3.03,2.84,

         3.14,0.0,0.0};


       const G4double positionRMS[clusterTableZSize][clusterTableASize] = {

         /*     A=   0     1     2     3     4     5     6     7     8     9    10    11    12 */

         /* Z=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, -1.0},

         /* Z=1 */ {-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},

         /* Z=2 */ {-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},

         /* Z=3 */ {-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},

         /* Z=4 */ {-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},

         /* Z=5 */ {-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},

         /* Z=6 */ {-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},

         /* Z=7 */ {-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},

         /* Z=8 */ {-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}

       };


       const G4double momentumRMS[clusterTableZSize][clusterTableASize] = {

         /*     A=   0     1     2     3     4     5     6     7     8     9    10    11    12 */

         /* Z=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, -1.0},

         /* Z=1 */ {-1.0, -1.0, 77.0, 110., 153., 100., 100., 100., -1.0, -1.0, -1.0, -1.0, -1.0},

         /* Z=2 */ {-1.0, -1.0, -1.0, 110., 153., 100., 100., 100., 100., 100., 100., -1.0, -1.0},

         /* Z=3 */ {-1.0, -1.0, -1.0, -1.0, 153., 100., 100., 100., 100., 100., 100., 100., 100.},

         /* Z=4 */ {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 100., 100., 100., 100., 100., 100., 100.},

         /* Z=5 */ {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 100., 100., 100., 100., 100., 100., 100.},

         /* Z=6 */ {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 100., 100., 100., 100., 100.},

         /* Z=7 */ {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 100., 100., 100.},

         /* Z=8 */ {-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.}

       };


       const G4int elementTableSize = 113; // up to Cn


       const std::string elementTable[elementTableSize] = {

         "",

         "H",

         "He",

         "Li",

         "Be",

         "B",

         "C",

         "N",

         "O",

         "F",

         "Ne",

         "Na",

         "Mg",

         "Al",

         "Si",

         "P",

         "S",

         "Cl",

         "Ar",

         "K",

         "Ca",

         "Sc",

         "Ti",

         "V",

         "Cr",

         "Mn",

         "Fe",

         "Co",

         "Ni",

         "Cu",

         "Zn",

         "Ga",

         "Ge",

         "As",

         "Se",

         "Br",

         "Kr",

         "Rb",

         "Sr",

         "Y",

         "Zr",

         "Nb",

         "Mo",

         "Tc",

         "Ru",

         "Rh",

         "Pd",

         "Ag",

         "Cd",

         "In",

         "Sn",

         "Sb",

         "Te",

         "I",

         "Xe",

         "Cs",

         "Ba",

         "La",

         "Ce",

         "Pr",

         "Nd",

         "Pm",

         "Sm",

         "Eu",

         "Gd",

         "Tb",

         "Dy",

         "Ho",

         "Er",

         "Tm",

         "Yb",

         "Lu",

         "Hf",

         "Ta",

         "W",

         "Re",

         "Os",

         "Ir",

         "Pt",

         "Au",

         "Hg",

         "Tl",

         "Pb",

         "Bi",

         "Po",

         "At",

         "Rn",

         "Fr",

         "Ra",

         "Ac",

         "Th",

         "Pa",

         "U",

         "Np",

         "Pu",

         "Am",

         "Cm",

         "Bk",

         "Cf",

         "Es",

         "Fm",

         "Md",

         "No",

         "Lr",

         "Rf",

         "Db",

         "Sg",

         "Bh",

         "Hs",

         "Mt",

         "Ds",

         "Rg",

         "Cn"

       };


       const std::string elementIUPACDigits = "nubtqphsoe";


 #define INCL_DEFAULT_SEPARATION_ENERGY 6.83

       const G4double theINCLProtonSeparationEnergy = INCL_DEFAULT_SEPARATION_ENERGY;

       const G4double theINCLNeutronSeparationEnergy = INCL_DEFAULT_SEPARATION_ENERGY;

       G4ThreadLocal G4double protonSeparationEnergy = INCL_DEFAULT_SEPARATION_ENERGY;

       G4ThreadLocal G4double neutronSeparationEnergy = INCL_DEFAULT_SEPARATION_ENERGY;

 #undef INCL_DEFAULT_SEPARATION_ENERGY


       G4ThreadLocal G4double rpCorrelationCoefficient[UnknownParticle];


       G4ThreadLocal G4double neutronSkin = 0.0;

       G4ThreadLocal G4double neutronHalo = 0.0;


 #ifdef INCLXX_IN_GEANT4_MODE

       G4ThreadLocal G4IonTable *theG4IonTable;

 #endif


       G4ThreadLocal G4double constantFermiMomentum = 0.0;


       char iupacToInt(char c) {

         return (char)(((G4int)'0')+elementIUPACDigits.find(c));

       }


       char intToIUPAC(char n) { return elementIUPACDigits.at(n); }


       const NaturalIsotopicDistributions *getNaturalIsotopicDistributions() {

         if(!theNaturalIsotopicDistributions)

           theNaturalIsotopicDistributions = new NaturalIsotopicDistributions;

         return theNaturalIsotopicDistributions;

       }


     } // namespace


     void initialize(Config const * const theConfig /*=0*/) {

       protonMass = theINCLNucleonMass;

       neutronMass = theINCLNucleonMass;

       piPlusMass = theINCLPionMass;

       piMinusMass = theINCLPionMass;

       piZeroMass = theINCLPionMass;

       /*

       SigmaPlusMass = theINCLSigmaMass;

       SigmaMinusMass = theINCLSigmaMass;

       SigmaZeroMass = theINCLSigmaMass;

       LambdaMass = theINCLLambdaMass;

       KPlusMass = theINCLKaonMass;

       KZeroMass = theINCLKaonMass;

       KZeroBarMass = theINCLKaonMass;

       KShortMass = theINCLKaonMass;

       KLongMass = theINCLKaonMass;

       KMinusMass = theINCLKaonMass;

       */

       SigmaPlusMass = theRealSigmaPlusMass;

       SigmaMinusMass = theRealSigmaMinusMass;

       SigmaZeroMass = theRealSigmaZeroMass;

       LambdaMass = theINCLLambdaMass;

       KPlusMass = theRealChargedKaonMass;

       KZeroMass = theRealNeutralKaonMass;

       KZeroBarMass = theRealNeutralKaonMass;

       KShortMass = theRealNeutralKaonMass;

       KLongMass = theRealNeutralKaonMass;

       KMinusMass = theRealChargedKaonMass;


       etaMass = theINCLEtaMass;

       omegaMass = theINCLOmegaMass;

       etaPrimeMass = theINCLEtaPrimeMass;

       photonMass = theINCLPhotonMass;

       if(theConfig && theConfig->getUseRealMasses()) {

         getTableMass = getRealMass;

         getTableParticleMass = getRealMass;

       } else {

         getTableMass = getINCLMass;

         getTableParticleMass = getINCLMass;

       }


 #ifndef INCLXX_IN_GEANT4_MODE

       std::string dataFilePath;

       if(theConfig)

         dataFilePath = theConfig->getINCLXXDataFilePath();

       NuclearMassTable::initialize(dataFilePath, getRealMass(Proton), getRealMass(Neutron));

 #endif


 #ifdef INCLXX_IN_GEANT4_MODE

       G4ParticleTable *theG4ParticleTable = G4ParticleTable::GetParticleTable();

       theG4IonTable = theG4ParticleTable->GetIonTable();

       theRealProtonMass = theG4ParticleTable->FindParticle("proton")->GetPDGMass() / MeV;

       theRealNeutronMass = theG4ParticleTable->FindParticle("neutron")->GetPDGMass() / MeV;

       theRealChargedPiMass = theG4ParticleTable->FindParticle("pi+")->GetPDGMass() / MeV;

       theRealPiZeroMass = theG4ParticleTable->FindParticle("pi0")->GetPDGMass() / MeV;

       theRealEtaMass = theG4ParticleTable->FindParticle("eta")->GetPDGMass() / MeV;

       theRealOmegaMass = theG4ParticleTable->FindParticle("omega")->GetPDGMass() / MeV;

       theRealEtaPrimeMass = theG4ParticleTable->FindParticle("eta_prime")->GetPDGMass() / MeV;

       theRealPhotonMass = theG4ParticleTable->FindParticle("gamma")->GetPDGMass() / MeV;

       theRealSigmaPlusMass = theG4ParticleTable->FindParticle("sigma+")->GetPDGMass() / MeV;

       theRealSigmaZeroMass = theG4ParticleTable->FindParticle("sigma0")->GetPDGMass() / MeV;

       theRealSigmaMinusMass = theG4ParticleTable->FindParticle("sigma-")->GetPDGMass() / MeV;

       theRealLambdaMass = theG4ParticleTable->FindParticle("lambda")->GetPDGMass() / MeV;

       theRealChargedKaonMass = theG4ParticleTable->FindParticle("kaon+")->GetPDGMass() / MeV;

       theRealNeutralKaonMass = theG4ParticleTable->FindParticle("kaon0")->GetPDGMass() / MeV;

 #endif


       minDeltaMass = theRealNeutronMass + theRealChargedPiMass + 0.5;

       minDeltaMass2 = minDeltaMass*minDeltaMass;

       minDeltaMassRndm = std::atan((minDeltaMass-effectiveDeltaMass)*2./effectiveDeltaWidth);


       piPlusWidth   = theChargedPiWidth;

       piMinusWidth  = theChargedPiWidth;

       piZeroWidth   = thePiZeroWidth;

       etaWidth      = theEtaWidth;

       omegaWidth    = theOmegaWidth;

       etaPrimeWidth = theEtaPrimeWidth;


       SigmaMinusWidth = theSigmaMinusWidth;

       SigmaPlusWidth = theSigmaPlusWidth;

       SigmaZeroWidth = theSigmaZeroWidth;

       LambdaWidth = theLambdaWidth;

       KPlusWidth = theChargedKaonWidth;

       KMinusWidth = theChargedKaonWidth;

       KShortWidth = theKShortWidth;

       KLongWidth = theKLongWidth;


       // Initialise the separation-energy function

       if(!theConfig || theConfig->getSeparationEnergyType()==INCLSeparationEnergy)

         getSeparationEnergy = getSeparationEnergyINCL;

       else if(theConfig->getSeparationEnergyType()==RealSeparationEnergy)

         getSeparationEnergy = getSeparationEnergyReal;

       else if(theConfig->getSeparationEnergyType()==RealForLightSeparationEnergy)

         getSeparationEnergy = getSeparationEnergyRealForLight;

       else {

         INCL_FATAL("Unrecognized separation-energy type in ParticleTable initialization: " << theConfig->getSeparationEnergyType() << '\n');

         return;

       }


       // Initialise the Fermi-momentum function

       if(!theConfig || theConfig->getFermiMomentumType()==ConstantFermiMomentum) {

         getFermiMomentum = ParticleTable::getFermiMomentumConstant;

         if(theConfig) {

           const G4double aFermiMomentum = theConfig->getFermiMomentum();

           if(aFermiMomentum>0.)

             constantFermiMomentum = aFermiMomentum;

           else

             constantFermiMomentum = PhysicalConstants::Pf;

         } else {

           constantFermiMomentum = PhysicalConstants::Pf;

         }

       } else if(theConfig->getFermiMomentumType()==ConstantLightFermiMomentum)

         getFermiMomentum = ParticleTable::getFermiMomentumConstantLight;

       else if(theConfig->getFermiMomentumType()==MassDependentFermiMomentum)

         getFermiMomentum = ParticleTable::getFermiMomentumMassDependent;

       else {

         INCL_FATAL("Unrecognized Fermi-momentum type in ParticleTable initialization: " << theConfig->getFermiMomentumType() << '\n');

         return;

       }


       // Initialise the r-p correlation coefficients

       std::fill(rpCorrelationCoefficient, rpCorrelationCoefficient + UnknownParticle, 1.);

       if(theConfig) {

         rpCorrelationCoefficient[Proton] = theConfig->getRPCorrelationCoefficient(Proton);

         rpCorrelationCoefficient[Neutron] = theConfig->getRPCorrelationCoefficient(Neutron);

       }


       // Initialise the neutron-skin parameters

       if(theConfig) {

         neutronSkin = theConfig->getNeutronSkin();

         neutronHalo = theConfig->getNeutronHalo();

       }


     }


     G4int getIsospin(const ParticleType t) {

       // Actually this is the 3rd component of isospin (I_z) multiplied by 2!

       if(t == Proton) {

         return 1;

       } else if(t == Neutron) {

         return -1;

       } else if(t == PiPlus) {

         return 2;

       } else if(t == PiMinus) {

         return -2;

       } else if(t == PiZero) {

         return 0;

       } else if(t == DeltaPlusPlus) {

         return 3;

       } else if(t == DeltaPlus) {

         return 1;

       } else if(t == DeltaZero) {

         return -1;

       } else if(t == DeltaMinus) {

         return -3;

       } else if(t == Lambda) {

         return 0;

       } else if(t == SigmaPlus) {

         return 2;

       } else if(t == SigmaZero) {

         return 0;

       } else if(t == SigmaMinus) {

         return -2;

       } else if(t == KPlus) {

         return 1;

       } else if(t == KZero) {

         return -1;

       } else if(t == KZeroBar) {

         return 1;

       } else if(t == KShort) {

         return -99;

       } else if(t == KLong) {

         return 99;

       } else if(t == KMinus) {

         return -1;

       } else if(t == Eta) {

         return 0;

       } else if(t == Omega) {

         return 0;

       } else if(t == EtaPrime) {

         return 0;

       } else if(t == Photon) {

         return 0;

       }

       INCL_ERROR("Requested isospin of an unknown particle!");

       return -10; // Unknown

     }


     std::string getShortName(const ParticleSpecies &s) {

       if(s.theType==Composite)

         return getShortName(s.theA,s.theZ);

       else

         return getShortName(s.theType);

     }


     std::string getName(const ParticleSpecies &s) {

       if(s.theType==Composite)

         return getName(s.theA,s.theZ);

       else

         return getName(s.theType);

     }


     std::string getName(const G4int A, const G4int Z) {

       std::stringstream stream;

       stream << getElementName(Z) << "-" << A;

       return stream.str();

     }


     std::string getShortName(const G4int A, const G4int Z) {

       std::stringstream stream;

       stream << getElementName(Z);

       if(A>0)

         stream << A;

       return stream.str();

     }


     std::string getName(const ParticleType p) {

       if(p == G4INCL::Proton) {

         return std::string("proton");

       } else if(p == G4INCL::Neutron) {

         return std::string("neutron");

       } else if(p == G4INCL::DeltaPlusPlus) {

         return std::string("delta++");

       } else if(p == G4INCL::DeltaPlus) {

         return std::string("delta+");

       } else if(p == G4INCL::DeltaZero) {

         return std::string("delta0");

       } else if(p == G4INCL::DeltaMinus) {

         return std::string("delta-");

       } else if(p == G4INCL::PiPlus) {

         return std::string("pi+");

       } else if(p == G4INCL::PiZero) {

         return std::string("pi0");

       } else if(p == G4INCL::PiMinus) {

         return std::string("pi-");

       } else if(p == G4INCL::Lambda) {

         return std::string("lambda");

       } else if(p == G4INCL::SigmaPlus) {

         return std::string("sigma+");

       } else if(p == G4INCL::SigmaZero) {

         return std::string("sigma0");

       } else if(p == G4INCL::SigmaMinus) {

         return std::string("sigma-");

       } else if(p == G4INCL::KPlus) {

         return std::string("kaon+");

       } else if(p == G4INCL::KZero) {

         return std::string("kaon0");

       } else if(p == G4INCL::KZeroBar) {

         return std::string("kaon0bar");

       } else if(p == G4INCL::KMinus) {

         return std::string("kaon-");

       } else if(p == G4INCL::KShort) {

         return std::string("kaonshort");

       } else if(p == G4INCL::KLong) {

         return std::string("kaonlong");

       } else if(p == G4INCL::Composite) {

         return std::string("composite");

       } else if(p == G4INCL::Eta) {

         return std::string("eta");

       } else if(p == G4INCL::Omega) {

         return std::string("omega");

       } else if(p == G4INCL::EtaPrime) {

         return std::string("etaprime");

       } else if(p == G4INCL::Photon) {

         return std::string("photon");

       }

       return std::string("unknown");

     }


     std::string getShortName(const ParticleType p) {

       if(p == G4INCL::Proton) {

         return std::string("p");

       } else if(p == G4INCL::Neutron) {

         return std::string("n");

       } else if(p == G4INCL::DeltaPlusPlus) {

         return std::string("d++");

       } else if(p == G4INCL::DeltaPlus) {

         return std::string("d+");

       } else if(p == G4INCL::DeltaZero) {

         return std::string("d0");

       } else if(p == G4INCL::DeltaMinus) {

         return std::string("d-");

       } else if(p == G4INCL::PiPlus) {

         return std::string("pi+");

       } else if(p == G4INCL::PiZero) {

         return std::string("pi0");

       } else if(p == G4INCL::PiMinus) {

         return std::string("pi-");

       } else if(p == G4INCL::Lambda) {

         return std::string("l");

       } else if(p == G4INCL::SigmaPlus) {

         return std::string("s+");

       } else if(p == G4INCL::SigmaZero) {

         return std::string("s0");

       } else if(p == G4INCL::SigmaMinus) {

         return std::string("s-");

       } else if(p == G4INCL::KPlus) {

         return std::string("k+");

       } else if(p == G4INCL::KZero) {

         return std::string("k0");

       } else if(p == G4INCL::KZeroBar) {

         return std::string("k0b");

       } else if(p == G4INCL::KMinus) {

         return std::string("k-");

       } else if(p == G4INCL::KShort) {

         return std::string("ks");

       } else if(p == G4INCL::KLong) {

         return std::string("kl");

       } else if(p == G4INCL::Composite) {

         return std::string("comp");

       } else if(p == G4INCL::Eta) {

         return std::string("eta");

       } else if(p == G4INCL::Omega) {

         return std::string("omega");

       } else if(p == G4INCL::EtaPrime) {

         return std::string("etap");

       } else if(p == G4INCL::Photon) {

         return std::string("photon");

       }

       return std::string("unknown");

     }


     G4double getINCLMass(const ParticleType pt) {

       if(pt == Proton) {

         return protonMass;

       } else if(pt == Neutron) {

         return neutronMass;

       } else if(pt == PiPlus) {

         return piPlusMass;

       } else if(pt == PiMinus) {

         return piMinusMass;

       } else if(pt == PiZero) {

         return piZeroMass;

       } else if(pt == SigmaPlus) {

         return SigmaPlusMass;

       } else if(pt == SigmaMinus) {

         return SigmaMinusMass;

       } else if(pt == SigmaZero) {

         return SigmaZeroMass;

       } else if(pt == Lambda) {

         return LambdaMass;

       } else if(pt == KPlus) {

         return KPlusMass;

       } else if(pt == KZero) {

         return KZeroMass;

       } else if(pt == KZeroBar) {

         return KZeroBarMass;

       } else if(pt == KMinus) {

         return KMinusMass;

       } else if(pt == KShort) {

         return KShortMass;

       } else if(pt == KLong) {

         return KLongMass;

       } else if(pt == Eta) {

         return etaMass;

       } else if(pt == Omega) {

         return omegaMass;

       } else if(pt == EtaPrime) {

         return etaPrimeMass;

       } else if(pt == Photon) {

         return photonMass;

       } else {

         INCL_ERROR("getMass : Unknown particle type." << '\n');

         return 0.0;

       }

     }


     G4double getRealMass(const ParticleType t) {

       switch(t) {

         case Proton:

           return theRealProtonMass;

           break;

         case Neutron:

           return theRealNeutronMass;

           break;

         case PiPlus:

         case PiMinus:

           return theRealChargedPiMass;

           break;

         case PiZero:

           return theRealPiZeroMass;

           break;

         case SigmaPlus:

           return theRealSigmaPlusMass;

           break;

         case SigmaZero:

           return theRealSigmaZeroMass;

           break;

         case SigmaMinus:

           return theRealSigmaMinusMass;

           break;

         case Lambda:

           return theRealLambdaMass;

           break;

         case KPlus:

         case KMinus:

           return theRealChargedKaonMass;

           break;

         case KZero:

         case KZeroBar:

         case KShort:

         case KLong:

           return theRealNeutralKaonMass;

         case Eta:

           return theRealEtaMass;

           break;

         case Omega:

           return theRealOmegaMass;

           break;

         case EtaPrime:

           return theRealEtaPrimeMass;

           break;

         case Photon:

           return theRealPhotonMass;

           break;

         default:

           INCL_ERROR("Particle::getRealMass : Unknown particle type." << '\n');

           return 0.0;

           break;

       }

     }


     G4double getRealMass(const G4int A, const G4int Z) {

 // assert(A>=0);

       // For nuclei with Z<0 or Z>A, assume that the exotic charge state is due to pions

       if(Z<0)

         return A*neutronMass - Z*getRealMass(PiMinus);

       else if(Z>A)

         return A*protonMass + (A-Z)*getRealMass(PiPlus);

       else if(Z==0)

         return A*getRealMass(Neutron);

       else if(A==Z)

         return A*getRealMass(Proton);

       else if(A>1) {

 #ifndef INCLXX_IN_GEANT4_MODE

         return ::G4INCL::NuclearMassTable::getMass(A,Z);

 #else

         return theG4IonTable->GetNucleusMass(Z,A) / MeV;

 #endif

       } else

         return 0.;

     }


     G4double getINCLMass(const G4int A, const G4int Z) {

 // assert(A>=0);

       // For nuclei with Z<0 or Z>A, assume that the exotic charge state is due to pions

       if(Z<0)

         return A*neutronMass - Z*getINCLMass(PiMinus);

       else if(Z>A)

         return A*protonMass + (A-Z)*getINCLMass(PiPlus);

       else if(A>1)

         return Z*(protonMass - protonSeparationEnergy) + (A-Z)*(neutronMass - neutronSeparationEnergy);

       else if(A==1 && Z==0)

         return getINCLMass(Neutron);

       else if(A==1 && Z==1)

         return getINCLMass(Proton);

       else

         return 0.;

     }


     G4double getTableQValue(const G4int A1, const G4int Z1, const G4int A2, const G4int Z2) {

       return getTableMass(A1,Z1) + getTableMass(A2,Z2) - getTableMass(A1+A2,Z1+Z2);

     }


     G4double getTableQValue(const G4int A1, const G4int Z1, const G4int A2, const G4int Z2, const G4int A3, const G4int Z3) {

       return getTableMass(A1,Z1) + getTableMass(A2,Z2) - getTableMass(A3,Z3) - getTableMass(A1+A2-A3,Z1+Z2-Z3);

     }


     G4double getTableSpeciesMass(const ParticleSpecies &p) {

       if(p.theType == Composite)

         return (*getTableMass)(p.theA, p.theZ);

       else

         return (*getTableParticleMass)(p.theType);

     }


     G4int getMassNumber(const ParticleType t) {

       switch(t) {

         case Proton:

         case Neutron:

         case DeltaPlusPlus:

         case DeltaPlus:

         case DeltaZero:

         case DeltaMinus:

         case SigmaPlus:

         case SigmaZero:

         case SigmaMinus:

         case Lambda:

           return 1;

           break;

         case PiPlus:

         case PiMinus:

         case PiZero:

         case KPlus:

         case KZero:

         case KZeroBar:

         case KShort:

         case KLong:

         case KMinus:

         case Eta:

         case Omega:

         case EtaPrime:

         case Photon:

           return 0;

           break;

         default:

           return 0;

           break;

       }

     }


     G4int getChargeNumber(const ParticleType t) {

       switch(t) {

         case DeltaPlusPlus:

           return 2;

           break;

         case Proton:

         case DeltaPlus:

         case PiPlus:

         case SigmaPlus:

         case KPlus:

           return 1;

           break;

         case Neutron:

         case DeltaZero:

         case PiZero:

         case SigmaZero:

         case Lambda:

         case KZero:

         case KZeroBar:

         case KShort:

         case KLong:

         case Eta:

         case Omega:

         case EtaPrime:

         case Photon:

           return 0;

           break;

         case DeltaMinus:

         case PiMinus:

         case SigmaMinus:

         case KMinus:

           return -1;

           break;

         default:

           return 0;

           break;

       }

     }


     G4int getStrangenessNumber(const ParticleType t) {

       switch(t) {

         case DeltaPlusPlus:

         case DeltaPlus:

         case DeltaZero:

         case DeltaMinus:

         case Proton:

         case Neutron:

         case PiPlus:

         case PiZero:

         case PiMinus:

         case Eta:

         case Omega:

         case EtaPrime:

         case Photon:

           return 0;

           break;

         case Lambda:

         case SigmaPlus:

         case SigmaZero:

         case SigmaMinus:

         case KZeroBar:

         case KMinus:

           return -1;

           break;

         case KPlus:

         case KZero:

           return 1;

           break;

         case KShort:

           return -99;

           break;

         case KLong:

           return 99;

           break;

         default:

           return 0;

           break;

       }

     }


     G4double getNuclearRadius(const ParticleType t, const G4int A, const G4int Z) {

 // assert(A>=0);

       if(A >= 19 || (A < 6 && A >= 2)) {

         // For large (Woods-Saxon or Modified Harmonic Oscillator) or small

         // (Gaussian) nuclei, the radius parameter is just the nuclear radius

         return getRadiusParameter(t,A,Z);

       } else if(A < clusterTableASize && Z>=0 && Z < clusterTableZSize && A >= 6) {

         const G4double thisRMS = positionRMS[Z][A];

         if(thisRMS>0.0)

           return thisRMS;

         else {

           INCL_DEBUG("getNuclearRadius: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'

                      << "returning radius for C12");

           return positionRMS[6][12];

         }

       } else if(A < 19) {

         const G4double theRadiusParameter = getRadiusParameter(t, A, Z);

         const G4double theDiffusenessParameter = getSurfaceDiffuseness(t, A, Z);

         // The formula yields the nuclear RMS radius based on the parameters of

         // the nuclear-density function

         return 1.225*theDiffusenessParameter*

           std::sqrt((2.+5.*theRadiusParameter)/(2.+3.*theRadiusParameter));

       } else {

         INCL_ERROR("getNuclearRadius: No radius for nucleus A = " << A << " Z = " << Z << '\n');

         return 0.0;

       }

     }


     G4double getLargestNuclearRadius(const G4int A, const G4int Z) {

       return Math::max(getNuclearRadius(Proton, A, Z), getNuclearRadius(Neutron, A, Z));

     }


     G4double getRadiusParameter(const ParticleType t, const G4int A, const G4int Z) {

 // assert(A>0);

       if(A > 19) {

         // phenomenological radius fit

         G4double r0 = (2.745e-4 * A + 1.063) * std::pow(A, 1.0/3.0);

         // HFB calculations

         if(getRPCorrelationCoefficient(t)<1.){

          G4double r0hfb = HFB::getRadiusParameterHFB(t,A,Z);

          if(r0hfb>0.)r0 = r0hfb;

         }

         //

         if(t==Neutron)

           r0 += neutronSkin;

         return r0;

       } else if(A < 6 && A >= 2) {

         if(Z<clusterTableZSize && Z>=0) {

           const G4double thisRMS = positionRMS[Z][A];

           if(thisRMS>0.0)

             return thisRMS;

           else {

             INCL_DEBUG("getRadiusParameter: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'

                        << "returning radius for C12");

             return positionRMS[6][12];

           }

         } else {

           INCL_DEBUG("getRadiusParameter: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'

                      << "returning radius for C12");

           return positionRMS[6][12];

         }

       } else if(A <= 19 && A >= 6) {

         return mediumRadius[A-1];

         //      return 1.581*mediumDiffuseness[A-1]*(2.+5.*mediumRadius[A-1])/(2.+3.*mediumRadius[A-1]);

       } else {

         INCL_ERROR("getRadiusParameter: No radius for nucleus A = " << A << " Z = " << Z << '\n');

         return 0.0;

       }

     }


     G4double getMaximumNuclearRadius(const ParticleType t, const G4int A, const G4int Z) {

       const G4double XFOISA = 8.0;

       if(A > 19) {

         return getNuclearRadius(t,A,Z) + XFOISA * getSurfaceDiffuseness(t,A,Z);

       } else if(A <= 19 && A >= 6) {

         return 5.5 + 0.3 * (G4double(A) - 6.0)/12.0;

       } else if(A >= 2) {

         return getNuclearRadius(t, A, Z) + 4.5;

       } else {

         INCL_ERROR("getMaximumNuclearRadius : No maximum radius for nucleus A = " << A << " Z = " << Z << '\n');

         return 0.0;

       }

     }


     G4double getSurfaceDiffuseness(const ParticleType t, const G4int A, const G4int Z) {

       if(A > 19) {

         G4double a = 1.63e-4 * A + 0.510;

         // HFB calculations

         if(getRPCorrelationCoefficient(t)<1.){

           G4double ahfb = HFB::getSurfaceDiffusenessHFB(t,A,Z);

           if(ahfb>0.)a=ahfb;

         }

         //

         if(t==Neutron)

           a += neutronHalo;

         return a;

       } else if(A <= 19 && A >= 6) {

         return mediumDiffuseness[A-1];

       } else if(A < 6 && A >= 2) {

         INCL_ERROR("getSurfaceDiffuseness: was called for A = " << A << " Z = " << Z << '\n');

         return 0.0;

       } else {

         INCL_ERROR("getSurfaceDiffuseness: No diffuseness for nucleus A = " << A << " Z = " << Z << '\n');

         return 0.0;

       }

     }


     G4double getMomentumRMS(const G4int A, const G4int Z) {

 // assert(Z>=0 && A>=0 && Z<=A);

       return getFermiMomentum(A,Z) * Math::sqrtThreeFifths;

     }


     G4double getSeparationEnergyINCL(const ParticleType t, const G4int /*A*/, const G4int /*Z*/) {

       if(t==Proton)

         return theINCLProtonSeparationEnergy;

       else if(t==Neutron)

         return theINCLNeutronSeparationEnergy;

       else {

         INCL_ERROR("ParticleTable::getSeparationEnergyINCL : Unknown particle type." << '\n');

         return 0.0;

       }

     }


     G4double getSeparationEnergyReal(const ParticleType t, const G4int A, const G4int Z) {

       // Real separation energies for all nuclei

       if(t==Proton)

         return (*getTableParticleMass)(Proton) + (*getTableMass)(A-1,Z-1) - (*getTableMass)(A,Z);

       else if(t==Neutron)

         return (*getTableParticleMass)(Neutron) + (*getTableMass)(A-1,Z) - (*getTableMass)(A,Z);

       else {

         INCL_ERROR("ParticleTable::getSeparationEnergyReal : Unknown particle type." << '\n');

         return 0.0;

       }

     }


     G4double getSeparationEnergyRealForLight(const ParticleType t, const G4int A, const G4int Z) {

       // Real separation energies for light nuclei, fixed values for heavy nuclei

       if(Z<clusterTableZSize && A<clusterTableASize)

         return getSeparationEnergyReal(t, A, Z);

       else

         return getSeparationEnergyINCL(t, A, Z);

     }


     G4double getProtonSeparationEnergy() { return protonSeparationEnergy; }


     G4double getNeutronSeparationEnergy() { return neutronSeparationEnergy; }


     void setProtonSeparationEnergy(const G4double s) { protonSeparationEnergy = s; }


     void setNeutronSeparationEnergy(const G4double s) { neutronSeparationEnergy  = s; }


     std::string getElementName(const G4int Z) {

       if(Z<1) {

         INCL_WARN("getElementName called with Z<1" << '\n');

         return elementTable[0];

       } else if(Z<elementTableSize)

         return elementTable[Z];

       else

         return getIUPACElementName(Z);

     }


     std::string getIUPACElementName(const G4int Z) {

       std::stringstream elementStream;

       elementStream << Z;

       std::string elementName = elementStream.str();

       std::transform(elementName.begin(), elementName.end(), elementName.begin(), intToIUPAC);

       elementName[0] = std::toupper(elementName.at(0));

       return elementName;

     }


     G4int parseElement(std::string pS) {

       // Normalize the element name

       std::transform(pS.begin(), pS.end(), pS.begin(), ::tolower);

       pS[0] = ::toupper(pS[0]);


       const std::string *iter = std::find(elementTable, elementTable+elementTableSize, pS);

       if(iter != elementTable+elementTableSize)

         return iter - elementTable;

       else

         return ParticleTable::parseIUPACElement(pS);

     }


     G4int parseIUPACElement(std::string const &s) {

       // Normalise to lower case

       std::string elementName(s);

       std::transform(elementName.begin(), elementName.end(), elementName.begin(), ::tolower);

       // Return 0 if the element name contains anything but IUPAC digits

       if(elementName.find_first_not_of(elementIUPACDigits)!=std::string::npos)

         return 0;

       std::transform(elementName.begin(), elementName.end(), elementName.begin(), iupacToInt);

       std::stringstream elementStream(elementName);

       G4int Z;

       elementStream >> Z;

       return Z;

     }


     IsotopicDistribution const &getNaturalIsotopicDistribution(const G4int Z) {

       return getNaturalIsotopicDistributions()->getIsotopicDistribution(Z);

     }


     G4int drawRandomNaturalIsotope(const G4int Z) {

       return getNaturalIsotopicDistributions()->drawRandomIsotope(Z);

     }


     G4double getFermiMomentumConstant(const G4int /*A*/, const G4int /*Z*/) {

       return constantFermiMomentum;

     }


     G4double getFermiMomentumConstantLight(const G4int A, const G4int Z) {

 // assert(Z>0 && A>0 && Z<=A);

       if(Z<clusterTableZSize && A<clusterTableASize) {

         const G4double rms = momentumRMS[Z][A];

         return ((rms>0.) ? rms : momentumRMS[6][12]) * Math::sqrtFiveThirds;

       } else

         return getFermiMomentumConstant(A,Z);

     }


     G4double getFermiMomentumMassDependent(const G4int A, const G4int /*Z*/) {

 // assert(A>0);

       static const G4double alphaParam = 259.416; // MeV/c

       static const G4double betaParam  = 152.824; // MeV/c

       static const G4double gammaParam = 9.5157E-2;

       return alphaParam - betaParam*std::exp(-gammaParam*((G4double)A));

     }


     G4double getRPCorrelationCoefficient(const ParticleType t) {

 // assert(t==Proton || t==Neutron);

       return rpCorrelationCoefficient[t];

     }


     G4double getNeutronSkin() { return neutronSkin; }


     G4double getNeutronHalo() { return neutronHalo; }


     G4ThreadLocal G4double minDeltaMass = 0.;

     G4ThreadLocal G4double minDeltaMass2 = 0.;

     G4ThreadLocal G4double minDeltaMassRndm = 0.;

     G4ThreadLocal NuclearMassFn getTableMass = NULL;

     G4ThreadLocal ParticleMassFn getTableParticleMass = NULL;

     G4ThreadLocal SeparationEnergyFn getSeparationEnergy = NULL;

     G4ThreadLocal FermiMomentumFn getFermiMomentum = NULL;


     ParticleType getPionType(const G4int isosp) {

 // assert(isosp == -2 || isosp == 0 || isosp == 2);

         if (isosp == -2) {

             return PiMinus;

         }

         else if (isosp == 0) {

             return PiZero;

         }

         else {

             return PiPlus;

         }

     }


     ParticleType getNucleonType(const G4int isosp) {

 // assert(isosp == -1 || isosp == 1);

         if (isosp == -1) {

             return Neutron;

         }

         else {

             return Proton;

         }

     }


     ParticleType getDeltaType(const G4int isosp) {

 // assert(isosp == -3 || isosp == -1 || isosp == 1 || isosp == 3);

         if (isosp == -3) {

             return DeltaMinus;

         }

         else if (isosp == -1) {

             return DeltaZero;

         }

         else if (isosp == 1) {

             return DeltaPlus;

         }

         else {

             return DeltaPlusPlus;

         }

     }


     ParticleType getSigmaType(const G4int isosp) {

 // assert(isosp == -2 || isosp == 0 || isosp == 2);

         if (isosp == -2) {

             return SigmaMinus;

         }

         else if (isosp == 0) {

             return SigmaZero;

         }

         else {

             return SigmaPlus;

         }

     }


     ParticleType getKaonType(const G4int isosp) {

 // assert(isosp == -1 || isosp == 1);

         if (isosp == -1) {

             return KZero;

         }

         else {

             return KPlus;

         }

     }


     ParticleType getAntiKaonType(const G4int isosp) {

 // assert(isosp == -1 || isosp == 1);

         if (isosp == -1) {

             return KMinus;

         }

         else {

             return KZeroBar;

         }

     }


     G4double getWidth(const ParticleType pt) {

 // 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);

           if(pt == PiPlus) {

               return piPlusWidth;

           } else if(pt == PiMinus) {

               return piMinusWidth;

           } else if(pt == PiZero) {

               return piZeroWidth;

           } else if(pt == Eta) {

               return etaWidth;

           } else if(pt == Omega) {

               return omegaWidth;

           } else if(pt == EtaPrime) {

               return etaPrimeWidth;

           } else if(pt == SigmaPlus) {

               return SigmaPlusWidth;

           } else if(pt == SigmaZero) {

               return SigmaZeroWidth;

           } else if(pt == SigmaMinus) {

               return SigmaMinusWidth;

           } else if(pt == KPlus) {

               return KPlusWidth;

           } else if(pt == KMinus) {

               return KMinusWidth;

           } else if(pt == KShort) {

               return KShortWidth;

           } else if(pt == KLong) {

               return KLongWidth;

           } else {

               INCL_ERROR("getWidth : Unknown particle type." << '\n');

               return 0.0;

           }

       }


   } // namespace ParticleTable

 } // namespace G4INCL


G4ParticleTable::FindParticle
G4ParticleDefinition * FindParticle(G4int PDGEncoding)
Definition: G4ParticleTable.cc:577

G4INCL::ParticleTable::getSeparationEnergyReal
G4double getSeparationEnergyReal(const ParticleType t, const G4int A, const G4int Z)
Return the real separation energy.
Definition: G4INCLParticleTable.cc:1049

G4INCL::ParticleTable::getLargestNuclearRadius
G4double getLargestNuclearRadius(const G4int A, const G4int Z)
Definition: G4INCLParticleTable.cc:954

G4INCL::ParticleTable::effectiveDeltaMass
const G4double effectiveDeltaMass
Definition: G4INCLParticleTable.hh:70

G4INCL::Math::max
T max(const T t1, const T t2)
brief Return the largest of the two arguments
Definition: G4INCLGlobals.hh:112

G4PhysicalConstants.hh

G4INCL::ParticleTable::getNaturalIsotopicDistribution
IsotopicDistribution const & getNaturalIsotopicDistribution(const G4int Z)
Definition: G4INCLParticleTable.cc:1122

G4INCL::ParticleTable::parseIUPACElement
G4int parseIUPACElement(std::string const &pS)
Parse a IUPAC element name.
Definition: G4INCLParticleTable.cc:1108

G4INCL::ParticleTable::setProtonSeparationEnergy
void setProtonSeparationEnergy(const G4double s)
Setter for protonSeparationEnergy.
Definition: G4INCLParticleTable.cc:1073

G4INCL::ParticleTable::getWidth
G4double getWidth(const ParticleType t)
Get particle width (in s)
Definition: G4INCLParticleTable.cc:1241

G4INCL::Photon
Definition: G4INCLParticleType.hh:64

G4INCL::ParticleTable::getRadiusParameter
G4double getRadiusParameter(const ParticleType t, const G4int A, const G4int Z)
Definition: G4INCLParticleTable.cc:958

G4INCL::Config::getUseRealMasses
G4bool getUseRealMasses() const
Whether to use real masses.
Definition: G4INCLConfig.hh:211

G4INCL::RealForLightSeparationEnergy
Definition: G4INCLConfigEnums.hh:100

a
std::vector< ExP01TrackerHit * > a
Definition: ExP01Classes.hh:33

G4INCL::ParticleTable::setNeutronSeparationEnergy
void setNeutronSeparationEnergy(const G4double s)
Setter for protonSeparationEnergy.
Definition: G4INCLParticleTable.cc:1075

G4INCL::ParticleTable::getElementName
std::string getElementName(const G4int Z)
Get the name of the element from the atomic number.
Definition: G4INCLParticleTable.cc:1077

G4INCL::ParticleTable::getNucleonType
ParticleType getNucleonType(const G4int isosp)
Get the type of nucleon.
Definition: G4INCLParticleTable.cc:1181

G4ParticleTable::GetParticleTable
static G4ParticleTable * GetParticleTable()
Definition: G4ParticleTable.cc:105

MeV
static constexpr double MeV
Definition: G4SIunits.hh:214

G4INCL::ParticleTable::getMomentumRMS
G4double getMomentumRMS(const G4int A, const G4int Z)
Return the RMS of the momentum distribution (light clusters)
Definition: G4INCLParticleTable.cc:1033

G4INCL::ParticleTable::getFermiMomentum
G4ThreadLocal FermiMomentumFn getFermiMomentum
Definition: G4INCLParticleTable.cc:1166

G4INCL::ParticleTable::getFermiMomentumConstantLight
G4double getFermiMomentumConstantLight(const G4int A, const G4int Z)
Return the constant value of the Fermi momentum - special for light.
Definition: G4INCLParticleTable.cc:1134

G4INCL::Neutron
Definition: G4INCLParticleType.hh:52

G4INCL::HFB::getSurfaceDiffusenessHFB
G4double getSurfaceDiffusenessHFB(const ParticleType t, const G4int A, const G4int Z)
Definition: G4INCLHFB.cc:558

INCL_DEFAULT_SEPARATION_ENERGY
#define INCL_DEFAULT_SEPARATION_ENERGY
Definition: G4INCLParticleTable.cc:299

G4INCL::ParticleSpecies::theType
ParticleType theType
Definition: G4INCLParticleSpecies.hh:67

G4INCL::KZero
Definition: G4INCLParticleType.hh:70

G4INCL::ParticleTable::getAntiKaonType
ParticleType getAntiKaonType(const G4int isosp)
Get the type of antikaon.
Definition: G4INCLParticleTable.cc:1231

G4INCL::Proton
Definition: G4INCLParticleType.hh:51

G4INCL::ParticleTable::FermiMomentumFn
G4double(* FermiMomentumFn)(const G4int, const G4int)
Definition: G4INCLParticleTable.hh:229

p
const char * p
Definition: xmltok.h:285

G4INCL::Config::getINCLXXDataFilePath
std::string const & getINCLXXDataFilePath() const
Definition: G4INCLConfig.hh:219

G4INCL::KLong
Definition: G4INCLParticleType.hh:74

G4INCL::ParticleTable::getChargeNumber
G4int getChargeNumber(const ParticleType t)
Get charge number from particle type.
Definition: G4INCLParticleTable.cc:846

G4INCL::ParticleTable::getIUPACElementName
std::string getIUPACElementName(const G4int Z)
Get the name of an unnamed element from the IUPAC convention.
Definition: G4INCLParticleTable.cc:1087

G4INCL::ParticleTable::getNeutronHalo
G4double getNeutronHalo()
Get the size of the neutron halo.
Definition: G4INCLParticleTable.cc:1158

G4ParticleTable::GetIonTable
G4IonTable * GetIonTable() const
Definition: G4ParticleTable.cc:669

G4INCL::KShort
Definition: G4INCLParticleType.hh:73

G4INCLNuclearMassTable.hh
Functions that encapsulate a mass table.

G4INCL::INCLSeparationEnergy
Definition: G4INCLConfigEnums.hh:98

G4INCL::ParticleTable::drawRandomNaturalIsotope
G4int drawRandomNaturalIsotope(const G4int Z)
Definition: G4INCLParticleTable.cc:1126

G4INCL::Omega
Definition: G4INCLParticleType.hh:62

G4INCL::ParticleTable::getRPCorrelationCoefficient
G4double getRPCorrelationCoefficient(const ParticleType t)
Get the value of the r-p correlation coefficient.
Definition: G4INCLParticleTable.cc:1151

G4ThreadLocal
#define G4ThreadLocal
Definition: tls.hh:69

G4INCL::ParticleTable::clusterTableZSize
const G4int clusterTableZSize
Definition: G4INCLParticleTable.hh:65

G4ParticleDefinition::GetPDGMass
G4double GetPDGMass() const
Definition: G4ParticleDefinition.hh:123

G4INCL::KPlus
Definition: G4INCLParticleType.hh:69

G4INCLParticleTable.hh

G4INCL::ParticleTable::getStrangenessNumber
G4int getStrangenessNumber(const ParticleType t)
Get strangeness number from particle type.
Definition: G4INCLParticleTable.cc:885

G4INCL::ParticleTable::getDeltaType
ParticleType getDeltaType(const G4int isosp)
Get the type of delta.
Definition: G4INCLParticleTable.cc:1191

G4INCL::Config
Definition: G4INCLConfig.hh:60

G4INCL::MassDependentFermiMomentum
Definition: G4INCLConfigEnums.hh:107

G4INCL::ParticleTable::getRealMass
G4double getRealMass(const G4INCL::ParticleType t)
Get particle mass (in MeV/c^2)
Definition: G4INCLParticleTable.cc:703

INCL_DEBUG
#define INCL_DEBUG(x)
Definition: G4INCLLogger.hh:240

Z
Float_t Z
Definition: advanced/microbeam/plot.C:38

G4INCL::EtaPrime
Definition: G4INCLParticleType.hh:63

G4INCL::PiMinus
Definition: G4INCLParticleType.hh:54

G4INCL::ParticleTable::getMassNumber
G4int getMassNumber(const ParticleType t)
Get mass number from particle type.
Definition: G4INCLParticleTable.cc:811

G4INCL::PhysicalConstants::Pf
const G4double Pf
Fermi momentum [MeV/c].
Definition: G4INCLGlobals.hh:57

s
const XML_Char * s
Definition: expat.h:262

G4INCL::ParticleTable::getMaximumNuclearRadius
G4double getMaximumNuclearRadius(const ParticleType t, const G4int A, const G4int Z)
Definition: G4INCLParticleTable.cc:996

G4double
double G4double
Definition: G4Types.hh:76

G4INCL::ParticleTable::clusterTableASize
const G4int clusterTableASize
Definition: G4INCLParticleTable.hh:66

G4INCL::SigmaMinus
Definition: G4INCLParticleType.hh:68

G4INCL::IsotopicDistribution
Class that stores isotopic abundances for a given element.
Definition: G4INCLNaturalIsotopicDistributions.hh:64

G4INCL::PiZero
Definition: G4INCLParticleType.hh:55

G4INCL::ParticleTable::SeparationEnergyFn
G4double(* SeparationEnergyFn)(const ParticleType, const G4int, const G4int)
Definition: G4INCLParticleTable.hh:224

G4INCL::ParticleTable::getNeutronSkin
G4double getNeutronSkin()
Get the thickness of the neutron skin.
Definition: G4INCLParticleTable.cc:1156

G4INCL::ParticleTable::getTableMass
G4ThreadLocal NuclearMassFn getTableMass
Static pointer to the mass function for nuclei.
Definition: G4INCLParticleTable.cc:1163

G4INCL::ParticleTable::NuclearMassFn
G4double(* NuclearMassFn)(const G4int, const G4int)
Definition: G4INCLParticleTable.hh:216

G4INCL::Config::getRPCorrelationCoefficient
G4double getRPCorrelationCoefficient(const ParticleType t) const
Get the r-p correlation coefficient.
Definition: G4INCLConfig.hh:276

G4INCL::ConstantFermiMomentum
Definition: G4INCLConfigEnums.hh:105

G4INCL::ParticleTable::getSurfaceDiffuseness
G4double getSurfaceDiffuseness(const ParticleType t, const G4int A, const G4int Z)
Definition: G4INCLParticleTable.cc:1010

INCL_ERROR
#define INCL_ERROR(x)
Definition: G4INCLLogger.hh:225

G4INCL::ParticleTable::getINCLMass
G4double getINCLMass(const G4int A, const G4int Z)
Get INCL nuclear mass (in MeV/c^2)
Definition: G4INCLParticleTable.cc:779

G4INCL::ParticleTable::getTableSpeciesMass
G4double getTableSpeciesMass(const ParticleSpecies &p)
Definition: G4INCLParticleTable.cc:804

G4INCL::ParticleTable::getNeutronSeparationEnergy
G4double getNeutronSeparationEnergy()
Getter for neutronSeparationEnergy.
Definition: G4INCLParticleTable.cc:1071

G4INCL::Clustering::initialize
void initialize(Config const *const theConfig)
Initialize the clustering model based on the Config object.
Definition: G4INCLClustering.cc:83

G4INCL::Composite
Definition: G4INCLParticleType.hh:60

G4INCL::ConstantLightFermiMomentum
Definition: G4INCLConfigEnums.hh:106

G4INCL::ParticleSpecies::theZ
G4int theZ
Definition: G4INCLParticleSpecies.hh:68

pt
TMarker * pt
Definition: egs.C:25

G4SystemOfUnits.hh

A
double A(double temperature)
Definition: G4DNAElectronHoleRecombination.cc:60

G4INCL::ParticleTable::getKaonType
ParticleType getKaonType(const G4int isosp)
Get the type of kaon.
Definition: G4INCLParticleTable.cc:1221

G4INCL::Math::sqrtThreeFifths
const G4double sqrtThreeFifths
Definition: G4INCLGlobals.hh:77

G4INCL::UnknownParticle
Definition: G4INCLParticleType.hh:78

G4INCL::ParticleTable::ParticleMassFn
G4double(* ParticleMassFn)(const ParticleType)
Definition: G4INCLParticleTable.hh:217

G4INCL::Config::getNeutronSkin
G4double getNeutronSkin() const
Get the neutron-skin thickness.
Definition: G4INCLConfig.hh:297

G4INCL::HFB::getRadiusParameterHFB
G4double getRadiusParameterHFB(const ParticleType t, const G4int A, const G4int Z)
Get the radius and diffuseness parameters from HFB calculations.
Definition: G4INCLHFB.cc:548

globals.hh

G4INCL::Eta
Definition: G4INCLParticleType.hh:61

G4INCL::PiPlus
Definition: G4INCLParticleType.hh:53

G4INCL::DeltaZero
Definition: G4INCLParticleType.hh:58

G4INCL::ParticleTable::getSeparationEnergyINCL
G4double getSeparationEnergyINCL(const ParticleType t, const G4int, const G4int)
Return INCL&#39;s default separation energy.
Definition: G4INCLParticleTable.cc:1038

G4INCL::ParticleTable::getName
std::string getName(const ParticleType t)
Get the native INCL name of the particle.
Definition: G4INCLParticleTable.cc:552

Z2
Double_t Z2
Definition: advanced/microbeam/plot.C:264

Z1
Double_t Z1
Definition: advanced/microbeam/plot.C:264

G4INCL::ParticleTable::effectiveDeltaWidth
const G4double effectiveDeltaWidth
Definition: G4INCLParticleTable.hh:71

INCL_WARN
#define INCL_WARN(x)
Definition: G4INCLLogger.hh:232

G4int
int G4int
Definition: G4Types.hh:78

G4INCL::DeltaPlusPlus
Definition: G4INCLParticleType.hh:56

G4INCL::ParticleSpecies
Definition: G4INCLParticleSpecies.hh:53

G4INCL::ParticleTable::getTableQValue
G4double getTableQValue(const G4int A1, const G4int Z1, const G4int A2, const G4int Z2)
Get Q-value (in MeV/c^2)
Definition: G4INCLParticleTable.cc:796

G4INCL::ParticleTable::getShortName
std::string getShortName(const ParticleType t)
Get the short INCL name of the particle.
Definition: G4INCLParticleTable.cc:605

G4INCL::Config::getSeparationEnergyType
SeparationEnergyType getSeparationEnergyType() const
Get the separation-energy type.
Definition: G4INCLConfig.hh:243

INCL_FATAL
#define INCL_FATAL(x)
Definition: G4INCLLogger.hh:216

G4INCL::Config::getNeutronHalo
G4double getNeutronHalo() const
Get the neutron-halo size.
Definition: G4INCLConfig.hh:303

G4INCL::DeltaPlus
Definition: G4INCLParticleType.hh:57

G4INCL::ParticleTable::getIsospin
G4int getIsospin(const ParticleType t)
Get the isospin of a particle.
Definition: G4INCLParticleTable.cc:471

G4INCL::SigmaPlus
Definition: G4INCLParticleType.hh:66

G4INCL::Config::getFermiMomentum
G4double getFermiMomentum() const
Get the Fermi momentum.
Definition: G4INCLConfig.hh:252

G4INCL::ParticleTable::getFermiMomentumConstant
G4double getFermiMomentumConstant(const G4int, const G4int)
Return the constant value of the Fermi momentum.
Definition: G4INCLParticleTable.cc:1130

G4INCL::ParticleTable::getSigmaType
ParticleType getSigmaType(const G4int isosp)
Get the type of sigma.
Definition: G4INCLParticleTable.cc:1208

G4INCL::SigmaZero
Definition: G4INCLParticleType.hh:67

G4INCL::ParticleTable::minDeltaMass2
G4ThreadLocal G4double minDeltaMass2
Definition: G4INCLParticleTable.cc:1161

G4INCL::RealSeparationEnergy
Definition: G4INCLConfigEnums.hh:99

G4INCL::KMinus
Definition: G4INCLParticleType.hh:72

G4INCL::ParticleTable::getSeparationEnergy
G4ThreadLocal SeparationEnergyFn getSeparationEnergy
Static pointer to the separation-energy function.
Definition: G4INCLParticleTable.cc:1165

G4INCL::Math::sqrtFiveThirds
const G4double sqrtFiveThirds
Definition: G4INCLGlobals.hh:76

G4INCL::ParticleTable::getFermiMomentumMassDependent
G4double getFermiMomentumMassDependent(const G4int A, const G4int)
Return the value Fermi momentum from a fit.
Definition: G4INCLParticleTable.cc:1143

G4INCL::ParticleType
ParticleType
Definition: G4INCLParticleType.hh:50

n
Char_t n[5]
Definition: comparison_ascii.C:55

G4INCL::Config::getFermiMomentumType
FermiMomentumType getFermiMomentumType() const
Get the Fermi-momentum type.
Definition: G4INCLConfig.hh:246

G4INCL::ParticleSpecies::theA
G4int theA
Definition: G4INCLParticleSpecies.hh:68

G4ParticleTable
Definition: G4ParticleTable.hh:66

G4INCL::KZeroBar
Definition: G4INCLParticleType.hh:71

G4INCL::ParticleTable::getSeparationEnergyRealForLight
G4double getSeparationEnergyRealForLight(const ParticleType t, const G4int A, const G4int Z)
Return the real separation energy only for light nuclei.
Definition: G4INCLParticleTable.cc:1061

G4INCL::ParticleTable::getTableParticleMass
G4ThreadLocal ParticleMassFn getTableParticleMass
Static pointer to the mass function for particles.
Definition: G4INCLParticleTable.cc:1164

G4INCL::ParticleTable::parseElement
G4int parseElement(std::string pS)
Get the name of the element from the atomic number.
Definition: G4INCLParticleTable.cc:1096

G4INCL::ParticleTable::initialize
void initialize(Config const *const theConfig=0)
Initialize the particle table.
Definition: G4INCLParticleTable.cc:335

G4INCL::ParticleTable::getProtonSeparationEnergy
G4double getProtonSeparationEnergy()
Getter for protonSeparationEnergy.
Definition: G4INCLParticleTable.cc:1069

G4INCL::DeltaMinus
Definition: G4INCLParticleType.hh:59

G4INCL::ParticleTable::getPionType
ParticleType getPionType(const G4int isosp)
Get the type of pion.
Definition: G4INCLParticleTable.cc:1168

G4INCL::ParticleTable::getNuclearRadius
G4double getNuclearRadius(const ParticleType t, const G4int A, const G4int Z)
Definition: G4INCLParticleTable.cc:926

G4INCL::Lambda
Definition: G4INCLParticleType.hh:65

G4IonTable
Definition: G4IonTable.hh:65

G4INCL::ParticleTable::minDeltaMassRndm
G4ThreadLocal G4double minDeltaMassRndm
Definition: G4INCLParticleTable.cc:1162

G4INCL::ParticleTable::minDeltaMass
G4ThreadLocal G4double minDeltaMass
Definition: G4INCLParticleTable.cc:1160