| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // INCL++ intra-nuclear cascade model 26 // INCL++ intra-nuclear cascade model
27 // Alain Boudard, CEA-Saclay, France << 27 // Pekka Kaitaniemi, CEA and Helsinki Institute of Physics
28 // Joseph Cugnon, University of Liege, Belgium << 28 // Davide Mancusi, CEA
29 // Jean-Christophe David, CEA-Saclay, France << 29 // Alain Boudard, CEA
30 // Pekka Kaitaniemi, CEA-Saclay, France, and H << 30 // Sylvie Leray, CEA
31 // Sylvie Leray, CEA-Saclay, France << 31 // Joseph Cugnon, University of Liege
32 // Davide Mancusi, CEA-Saclay, France << 32 //
>> 33 // INCL++ revision: v5.1.8
33 // 34 //
34 #define INCLXX_IN_GEANT4_MODE 1 35 #define INCLXX_IN_GEANT4_MODE 1
35 36
36 #include "globals.hh" 37 #include "globals.hh"
37 38
38 #ifndef G4INCLParticleTable_hh 39 #ifndef G4INCLParticleTable_hh
39 #define G4INCLParticleTable_hh 1 40 #define G4INCLParticleTable_hh 1
40 41
41 #include <string> 42 #include <string>
42 #include <vector> 43 #include <vector>
43 // #include <cassert> 44 // #include <cassert>
44 45
45 #include "G4INCLParticleType.hh" 46 #include "G4INCLParticleType.hh"
46 #include "G4INCLParticleSpecies.hh" 47 #include "G4INCLParticleSpecies.hh"
47 #include "G4INCLLogger.hh" 48 #include "G4INCLLogger.hh"
48 #include "G4INCLConfig.hh" 49 #include "G4INCLConfig.hh"
49 #include "G4INCLHFB.hh" <<
50 50
51 #ifdef INCLXX_IN_GEANT4_MODE 51 #ifdef INCLXX_IN_GEANT4_MODE
52 #include "G4IonTable.hh" 52 #include "G4IonTable.hh"
53 #include "G4ParticleTable.hh" 53 #include "G4ParticleTable.hh"
>> 54 #include "globals.hh"
54 #endif 55 #endif
55 #include "G4INCLGlobals.hh" 56 #include "G4INCLGlobals.hh"
56 #include "G4INCLNaturalIsotopicDistributions.h 57 #include "G4INCLNaturalIsotopicDistributions.hh"
57 58
58 namespace G4INCL { 59 namespace G4INCL {
59 << 60 class ParticleTable {
60 namespace ParticleTable { << 61 public:
61 <<
62 const G4int maxClusterMass = 12; <<
63 const G4int maxClusterCharge = 8; <<
64 <<
65 const G4int clusterTableZSize = maxCluster <<
66 const G4int clusterTableASize = maxCluster <<
67 const G4int clusterTableSSize = 4; <<
68 <<
69 const G4double effectiveNucleonMass = 938. <<
70 const G4double effectiveNucleonMass2 = 8.8 <<
71 const G4double effectiveDeltaMass = 1232.0 <<
72 const G4double effectiveDeltaWidth = 130.0 <<
73 const G4double effectivePionMass = 138.0; <<
74 const G4double effectiveLambdaMass = 1115. <<
75 const G4double effectiveSigmaMass = 1197.4 <<
76 const G4double effectiveXiMass = 1321.71; <<
77 const G4double effectiveKaonMass = 497.614 <<
78 const G4double effectiveAntiKaonMass = 497 <<
79 const G4double effectiveEtaMass = 547.862; <<
80 const G4double effectiveOmegaMass = 782.65 <<
81 const G4double effectiveEtaPrimeMass = 957 <<
82 const G4double effectivePhotonMass = 0.0; <<
83 extern G4ThreadLocal G4double minDeltaMass <<
84 extern G4ThreadLocal G4double minDeltaMass <<
85 extern G4ThreadLocal G4double minDeltaMass <<
86 <<
87 /// \brief Initialize the particle table 62 /// \brief Initialize the particle table
88 void initialize(Config const * const theCo << 63 static void initialize(Config const * const theConfig = 0);
89 64
90 /// \brief Get the isospin of a particle << 65 /// Get the isospin of a particle
91 G4int getIsospin(const ParticleType t); << 66 static G4int getIsospin(const ParticleType t);
92 67
93 /// \brief Get the native INCL name of the << 68 /// Get the native INCL name of the particle
94 std::string getName(const ParticleType t); << 69 static std::string getName(const ParticleType t);
95 70
96 /// \brief Get the short INCL name of the << 71 /// Get the short INCL name of the particle
97 std::string getShortName(const ParticleTyp << 72 static std::string getShortName(const ParticleType t);
98 73
99 /// \brief Get the native INCL name of the << 74 /// Get the native INCL name of the particle
100 std::string getName(const ParticleSpecies << 75 static std::string getName(const ParticleSpecies s);
101 76
102 /// \brief Get the short INCL name of the << 77 /// Get the short INCL name of the particle
103 std::string getShortName(const ParticleSpe << 78 static std::string getShortName(const ParticleSpecies s);
104 79
105 /// \brief Get the native INCL name of the << 80 /// Get the native INCL name of the ion
106 std::string getName(const G4int A, const G << 81 static std::string getName(const G4int A, const G4int Z);
107 82
108 /// \brief Get the native INCL name of the << 83 /// Get the short INCL name of the ion
109 std::string getName(const G4int A, const G << 84 static std::string getShortName(const G4int A, const G4int Z);
110 85
111 /// \brief Get the short INCL name of the << 86 ///\brief Get INCL nuclear mass (in MeV/c^2)
112 std::string getShortName(const G4int A, co << 87 static G4double getINCLMass(const G4int A, const G4int Z);
113 88
114 /// \brief Get INCL nuclear mass (in MeV/c << 89 ///\brief Get INCL particle mass (in MeV/c^2)
115 G4double getINCLMass(const G4int A, const << 90 static G4double getINCLMass(const ParticleType t);
116 <<
117 /// \brief Get INCL particle mass (in MeV/ <<
118 G4double getINCLMass(const ParticleType t) <<
119 91
120 #ifndef INCLXX_IN_GEANT4_MODE 92 #ifndef INCLXX_IN_GEANT4_MODE
121 /// \brief Do we have this particle mass? << 93 ///\brief Do we have this particle mass?
122 G4double hasMassTable(const unsigned int A << 94 static G4double hasMassTable(const unsigned int A, const unsigned int Z) {
>> 95 return ( Z > 0 && A > 0
>> 96 && Z < massTableMask.size() && A < massTableMask.at(Z).size()
>> 97 && massTableMask.at(Z).at(A));
>> 98 }
123 99
124 /** \brief Weizsaecker mass formula 100 /** \brief Weizsaecker mass formula
125 * 101 *
126 * Return the nuclear mass, as calculated 102 * Return the nuclear mass, as calculated from Weizsaecker's mass formula.
127 * Adapted from the Geant4 source. 103 * Adapted from the Geant4 source.
128 * 104 *
129 * \param A the mass number 105 * \param A the mass number
130 * \param Z the charge number 106 * \param Z the charge number
131 * \return the nuclear mass [MeV/c^2] 107 * \return the nuclear mass [MeV/c^2]
132 */ 108 */
133 G4double getWeizsaeckerMass(const G4int A, << 109 static G4double getWeizsaeckerMass(const G4int A, const G4int Z) {
>> 110 const G4int Npairing = (A-Z)%2; // pairing
>> 111 const G4int Zpairing = Z%2;
>> 112 const G4double fA = (G4double) A;
>> 113 const G4double fZ = (G4double) Z;
>> 114 G4double binding =
>> 115 - 15.67*fA // nuclear volume
>> 116 + 17.23*Math::pow23(fA) // surface energy
>> 117 + 93.15*((fA/2.-fZ)*(fA/2.-fZ))/fA // asymmetry
>> 118 + 0.6984523*fZ*fZ*Math::powMinus13(fA); // coulomb
>> 119 if( Npairing == Zpairing ) binding += (Npairing+Zpairing-1) * 12.0 / std::sqrt(fA); // pairing
>> 120
>> 121 return fZ*getRealMass(Proton)+((G4double)(A-Z))*getRealMass(Neutron)+binding;
>> 122 }
134 #endif 123 #endif
135 124
136 ///\brief Get particle mass (in MeV/c^2) 125 ///\brief Get particle mass (in MeV/c^2)
137 G4double getRealMass(const G4INCL::Particl << 126 static G4double getRealMass(const G4INCL::ParticleType t);
138 ///\brief Get nuclear mass (in MeV/c^2) 127 ///\brief Get nuclear mass (in MeV/c^2)
139 G4double getRealMass(const G4int A, const << 128 static G4double getRealMass(const G4int A, const G4int Z);
140 129
141 /**\brief Get Q-value (in MeV/c^2) 130 /**\brief Get Q-value (in MeV/c^2)
142 * 131 *
143 * Uses the getTableMass function to compu 132 * Uses the getTableMass function to compute the Q-value for the
144 * following reaction: 133 * following reaction:
145 * \f[ (A_1,Z_1) + (A_2, Z_2) --> (A_1+A_2 134 * \f[ (A_1,Z_1) + (A_2, Z_2) --> (A_1+A_2,Z_1+Z_2) \f]
146 */ 135 */
147 G4double getTableQValue(const G4int A1, co << 136 static G4double getTableQValue(const G4int A1, const G4int Z1, const G4int A2, const G4int Z2) {
>> 137 return getTableMass(A1,Z1) + getTableMass(A2,Z2) - getTableMass(A1+A2,Z1+Z2);
>> 138 }
148 139
149 /**\brief Get Q-value (in MeV/c^2) 140 /**\brief Get Q-value (in MeV/c^2)
150 * 141 *
151 * Uses the getTableMass function to compu 142 * Uses the getTableMass function to compute the Q-value for the
152 * following reaction: 143 * following reaction:
153 * \f[ (A_1,Z_1) + (A_2, Z_2) --> (A_3,Z_3 144 * \f[ (A_1,Z_1) + (A_2, Z_2) --> (A_3,Z_3) + (A1+A2-A3,Z1+Z2-Z3) \f]
154 */ 145 */
155 G4double getTableQValue(const G4int A1, co << 146 static G4double getTableQValue(const G4int A1, const G4int Z1, const G4int A2, const G4int Z2, const G4int A3, const G4int Z3) {
>> 147 return getTableMass(A1,Z1) + getTableMass(A2,Z2) - getTableMass(A3,Z3) - getTableMass(A1+A2-A3,Z1+Z2-Z3);
>> 148 }
>> 149
>> 150 // Typedefs and pointers for transparent handling of mass functions
>> 151 typedef G4double (*NuclearMassFn)(const G4int, const G4int);
>> 152 typedef G4double (*ParticleMassFn)(const ParticleType);
>> 153 static NuclearMassFn getTableMass;
>> 154 static ParticleMassFn getTableParticleMass;
156 155
157 G4double getTableSpeciesMass(const Particl << 156 static G4double getTableSpeciesMass(const ParticleSpecies &p) {
>> 157 if(p.theType == Composite)
>> 158 return (*getTableMass)(p.theA, p.theZ);
>> 159 else
>> 160 return (*getTableParticleMass)(p.theType);
>> 161 }
>> 162
>> 163 // Typedefs and pointers for transparent handling of separation energies
>> 164 typedef G4double (*SeparationEnergyFn)(const ParticleType, const G4int, const G4int);
>> 165 static SeparationEnergyFn getSeparationEnergy;
158 166
159 /// \brief Get mass number from particle t 167 /// \brief Get mass number from particle type
160 G4int getMassNumber(const ParticleType t); << 168 static G4int getMassNumber(const ParticleType t) {
>> 169 switch(t) {
>> 170 case Proton:
>> 171 case Neutron:
>> 172 case DeltaPlusPlus:
>> 173 case DeltaPlus:
>> 174 case DeltaZero:
>> 175 case DeltaMinus:
>> 176 return 1;
>> 177 break;
>> 178 case PiPlus:
>> 179 case PiMinus:
>> 180 case PiZero:
>> 181 return 0;
>> 182 break;
>> 183 default:
>> 184 /* FATAL("Can't determine mass number for particle type " << t << std::endl);
>> 185 std::abort();*/
>> 186 return 0;
>> 187 break;
>> 188 }
>> 189 }
161 190
162 /// \brief Get charge number from particle 191 /// \brief Get charge number from particle type
163 G4int getChargeNumber(const ParticleType t << 192 static G4int getChargeNumber(const ParticleType t) {
164 << 193 switch(t) {
165 /// \brief Get strangeness number from par << 194 case DeltaPlusPlus:
166 G4int getStrangenessNumber(const ParticleT << 195 return 2;
167 << 196 break;
168 G4double getNuclearRadius(const ParticleTy << 197 case Proton:
169 G4double getLargestNuclearRadius(const G4i << 198 case DeltaPlus:
170 G4double getRadiusParameter(const Particle << 199 case PiPlus:
171 G4double getMaximumNuclearRadius(const Par << 200 return 1;
172 G4double getSurfaceDiffuseness(const Parti << 201 break;
>> 202 case Neutron:
>> 203 case DeltaZero:
>> 204 case PiZero:
>> 205 return 0;
>> 206 break;
>> 207 case DeltaMinus:
>> 208 case PiMinus:
>> 209 return -1;
>> 210 break;
>> 211 default:
>> 212 /* FATAL("Can't determine charge number for particle type " << t << std::endl);
>> 213 std::abort();*/
>> 214 return 0;
>> 215 break;
>> 216 }
>> 217 }
>> 218
>> 219 static G4double getNuclearRadius(const G4int A, const G4int Z);
>> 220 static G4double getRadiusParameter(const G4int A, const G4int Z);
>> 221 static G4double getMaximumNuclearRadius(const G4int A, const G4int Z);
>> 222 static G4double getSurfaceDiffuseness(const G4int A, const G4int Z);
173 223
174 /// \brief Return the RMS of the momentum 224 /// \brief Return the RMS of the momentum distribution (light clusters)
175 G4double getMomentumRMS(const G4int A, con << 225 static G4double getMomentumRMS(const G4int A, const G4int Z) {
>> 226 // assert(Z>=0 && A>=0 && Z<=A);
>> 227 if(Z<clusterTableZSize && A<clusterTableASize)
>> 228 return momentumRMS[Z][A];
>> 229 else
>> 230 return Math::sqrtThreeFifths * PhysicalConstants::Pf;
>> 231 }
176 232
177 /// \brief Return INCL's default separatio 233 /// \brief Return INCL's default separation energy
178 G4double getSeparationEnergyINCL(const Par << 234 static G4double getSeparationEnergyINCL(const ParticleType t, const G4int /*A*/, const G4int /*Z*/) {
>> 235 if(t==Proton)
>> 236 return theINCLProtonSeparationEnergy;
>> 237 else if(t==Neutron)
>> 238 return theINCLNeutronSeparationEnergy;
>> 239 else {
>> 240 ERROR("ParticleTable::getSeparationEnergyINCL : Unknown particle type." << std::endl);
>> 241 return 0.0;
>> 242 }
>> 243 }
179 244
180 /// \brief Return the real separation ener 245 /// \brief Return the real separation energy
181 G4double getSeparationEnergyReal(const Par << 246 static G4double getSeparationEnergyReal(const ParticleType t, const G4int A, const G4int Z) {
>> 247 // Real separation energies for all nuclei
>> 248 if(t==Proton)
>> 249 return (*getTableParticleMass)(Proton) + (*getTableMass)(A-1,Z-1) - (*getTableMass)(A,Z);
>> 250 else if(t==Neutron)
>> 251 return (*getTableParticleMass)(Neutron) + (*getTableMass)(A-1,Z) - (*getTableMass)(A,Z);
>> 252 else {
>> 253 ERROR("ParticleTable::getSeparationEnergyReal : Unknown particle type." << std::endl);
>> 254 return 0.0;
>> 255 }
>> 256 }
182 257
183 /// \brief Return the real separation ener 258 /// \brief Return the real separation energy only for light nuclei
184 G4double getSeparationEnergyRealForLight(c << 259 static G4double getSeparationEnergyRealForLight(const ParticleType t, const G4int A, const G4int Z) {
>> 260 // Real separation energies for light nuclei, fixed values for heavy nuclei
>> 261 if(Z<clusterTableZSize && A<clusterTableASize)
>> 262 return getSeparationEnergyReal(t, A, Z);
>> 263 else
>> 264 return getSeparationEnergyINCL(t, A, Z);
>> 265 }
185 266
186 /// \brief Getter for protonSeparationEner 267 /// \brief Getter for protonSeparationEnergy
187 G4double getProtonSeparationEnergy(); << 268 static G4double getProtonSeparationEnergy() { return protonSeparationEnergy; }
188 269
189 /// \brief Getter for neutronSeparationEne 270 /// \brief Getter for neutronSeparationEnergy
190 G4double getNeutronSeparationEnergy(); << 271 static G4double getNeutronSeparationEnergy() { return neutronSeparationEnergy; }
191 272
192 /// \brief Setter for protonSeparationEner 273 /// \brief Setter for protonSeparationEnergy
193 void setProtonSeparationEnergy(const G4dou << 274 static void setProtonSeparationEnergy(const G4double s) { protonSeparationEnergy = s; }
194 275
195 /// \brief Setter for protonSeparationEner 276 /// \brief Setter for protonSeparationEnergy
196 void setNeutronSeparationEnergy(const G4do << 277 static void setNeutronSeparationEnergy(const G4double s) { neutronSeparationEnergy = s; }
197 278
198 /// \brief Get the name of the element fro 279 /// \brief Get the name of the element from the atomic number
199 std::string getElementName(const G4int Z); << 280 static std::string getElementName(const G4int Z);
200 <<
201 /// \brief Get the name of an unnamed elem 281 /// \brief Get the name of an unnamed element from the IUPAC convention
202 std::string getIUPACElementName(const G4in << 282 static std::string getIUPACElementName(const G4int Z);
203 <<
204 /// \brief Get the name of the element fro <<
205 G4int parseElement(std::string pS); <<
206 283
207 /** \brief Parse a IUPAC element name 284 /** \brief Parse a IUPAC element name
208 * 285 *
209 * Note: this function is UGLY. Look at it 286 * Note: this function is UGLY. Look at it at your own peril.
210 * 287 *
211 * \param pS a normalised string (lowercas 288 * \param pS a normalised string (lowercase)
212 * \return the charge number of the nuclid 289 * \return the charge number of the nuclide, or zero on fail
213 */ 290 */
214 G4int parseIUPACElement(std::string const << 291 static G4int parseIUPACElement(std::string const &pS);
215 <<
216 IsotopicDistribution const &getNaturalIsot <<
217 <<
218 G4int drawRandomNaturalIsotope(const G4int <<
219 <<
220 // Typedefs and pointers for transparent h <<
221 //typedef G4double (*NuclearMassFn)(const <<
222 typedef G4double (*NuclearMassFn)(const G4 <<
223 typedef G4double (*ParticleMassFn)(const P <<
224 /// \brief Static pointer to the mass func <<
225 extern G4ThreadLocal NuclearMassFn getTabl <<
226 /// \brief Static pointer to the mass func <<
227 extern G4ThreadLocal ParticleMassFn getTab <<
228 <<
229 // Typedefs and pointers for transparent h <<
230 typedef G4double (*SeparationEnergyFn)(con <<
231 /// \brief Static pointer to the separatio <<
232 extern G4ThreadLocal SeparationEnergyFn ge <<
233 292
234 // Typedefs and pointers for transparent h << 293 const static G4int elementTableSize = 113; // up to Cn
235 typedef G4double (*FermiMomentumFn)(const <<
236 extern G4ThreadLocal FermiMomentumFn getFe <<
237 294
238 /// \brief Return the constant value of th << 295 const static G4double effectiveNucleonMass;
239 G4double getFermiMomentumConstant(const G4 << 296 const static G4double effectiveNucleonMass2;
>> 297 const static G4double effectiveDeltaMass;
>> 298 const static G4double effectivePionMass;
>> 299 const static G4double effectiveDeltaDecayThreshold;
>> 300
>> 301 static const G4int maxClusterMass = 12;
>> 302 static const G4int maxClusterCharge = 8;
>> 303
>> 304 const static G4int clusterTableZSize = ParticleTable::maxClusterCharge+1;
>> 305 const static G4int clusterTableASize = ParticleTable::maxClusterMass+1;
>> 306 const static G4double clusterPosFact[maxClusterMass+1];
>> 307 const static G4double clusterPosFact2[maxClusterMass+1];
>> 308 const static G4int clusterZMin[maxClusterMass+1]; // Lower limit of Z for cluster of mass A
>> 309 const static G4int clusterZMax[maxClusterMass+1]; // Upper limit of Z for cluster of mass A
>> 310 const static G4double clusterPhaseSpaceCut[maxClusterMass+1];
240 311
241 /** \brief Return the constant value of th << 312 #ifdef INCLXX_IN_GEANT4_MODE
242 * << 313 static G4IonTable *theG4IonTable;
243 * This function should always return Phys << 314 #else
244 * nuclei, and values from the momentumRMS << 315 static std::vector< std::vector <G4bool> > massTableMask;
245 * << 316 static std::vector< std::vector <G4double> > massTable;
246 * \param A mass number << 317 #endif
247 * \param Z charge number <<
248 */ <<
249 G4double getFermiMomentumConstantLight(con <<
250 318
251 /** \brief Return the value Fermi momentum << 319 // Enumerator for cluster-decay channels
252 * << 320 enum ClusterDecayType {
253 * This function returns a fitted Fermi mo << 321 StableCluster,
254 * et al., Phys. Rev. Lett. 26 (1971) 445. << 322 NeutronDecay,
255 * \f[ << 323 ProtonDecay,
256 * p_F(A)=\alpha-\beta\cdot e^{(-A\cdot\ga << 324 AlphaDecay,
257 * \f] << 325 TwoProtonDecay,
258 * with \f$\alpha=259.416\f$ MeV/\f$c\f$, << 326 TwoNeutronDecay,
259 * and \f$\gamma=9.5157\cdot10^{-2}\f$. << 327 ProtonUnbound,
260 * << 328 NeutronUnbound
261 * \param A mass number << 329 };
262 */ << 330 const static ClusterDecayType clusterDecayMode[clusterTableZSize][clusterTableASize];
263 G4double getFermiMomentumMassDependent(con <<
264 331
265 /** \brief Get the value of the r-p correl << 332 /** \brief Coulomb conversion factor, in MeV*fm.
266 * 333 *
267 * \param t the type of the particle (Prot << 334 * \f[ e^2/(4 pi epsilon_0) \f]
268 * \return the value of the r-p correlatio <<
269 */ 335 */
270 G4double getRPCorrelationCoefficient(const << 336 static const G4double eSquared;
271 <<
272 /// \brief Get the thickness of the neutro <<
273 G4double getNeutronSkin(); <<
274 <<
275 /// \brief Get the size of the neutron hal <<
276 G4double getNeutronHalo(); <<
277 <<
278 /// \brief Get the type of pion <<
279 ParticleType getPionType(const G4int isosp <<
280 <<
281 /// \brief Get the type of nucleon <<
282 ParticleType getNucleonType(const G4int is <<
283 337
284 /// \brief Get the type of delta << 338 static IsotopicDistribution const &getNaturalIsotopicDistribution(const G4int Z) {
285 ParticleType getDeltaType(const G4int isos << 339 return getNaturalIsotopicDistributions()->getIsotopicDistribution(Z);
>> 340 }
>> 341
>> 342 static G4int drawRandomNaturalIsotope(const G4int Z) {
>> 343 return getNaturalIsotopicDistributions()->drawRandomIsotope(Z);
>> 344 }
>> 345
>> 346 protected:
>> 347 ParticleTable() {};
>> 348 ~ParticleTable() {};
>> 349
>> 350 private:
>> 351 static const G4double theINCLNucleonMass;
>> 352 static const G4double theINCLPionMass;
>> 353 static const G4double theINCLNeutronSeparationEnergy;
>> 354 static const G4double theINCLProtonSeparationEnergy;
>> 355 static G4double protonMass;
>> 356 static G4double neutronMass;
>> 357 static G4double neutronSeparationEnergy;
>> 358 static G4double protonSeparationEnergy;
>> 359 static G4double piPlusMass, piMinusMass, piZeroMass;
>> 360 static G4double theRealProtonMass;
>> 361 static G4double theRealNeutronMass;
>> 362 static G4double theRealChargedPiMass;
>> 363 static G4double theRealPiZeroMass;
>> 364
>> 365 const static G4int mediumNucleiTableSize = 30;
>> 366 const static G4double mediumDiffuseness[mediumNucleiTableSize];
>> 367 const static G4double mediumRadius[mediumNucleiTableSize];
>> 368 const static G4double positionRMS[clusterTableZSize][clusterTableASize];
>> 369 const static G4double momentumRMS[clusterTableZSize][clusterTableASize];
286 370
287 /// \brief Get the type of sigma << 371 const static std::string elementTable[elementTableSize];
288 ParticleType getSigmaType(const G4int isos <<
289 372
290 /// \brief Get the type of kaon << 373 #ifndef INCLXX_IN_GEANT4_MODE
291 ParticleType getKaonType(const G4int isosp << 374 /// \brief Read nuclear masses from a data file
292 << 375 static void readRealMasses(std::string const &path);
293 /// \brief Get the type of antikaon << 376 #endif
294 ParticleType getAntiKaonType(const G4int i <<
295 <<
296 /// \brief Get the type of xi <<
297 ParticleType getXiType(const G4int isosp); <<
298 <<
299 /// \brief Get the type of antinucleon <<
300 ParticleType getAntiNucleonType(const G4in <<
301 377
302 /// \brief Get the type of antidelta << 378 const static std::string elementIUPACDigits;
303 ParticleType getAntiXiType(const G4int iso <<
304 379
305 /// \brief Get the type of antisigma << 380 /// \brief Transform a IUPAC char to an char representing an integer digit
306 ParticleType getAntiSigmaType(const G4int << 381 static char iupacToInt(char c) {
>> 382 return (char)(((G4int)'0')+elementIUPACDigits.find(c));
>> 383 }
>> 384
>> 385 /// \brief Transform an integer digit (represented by a char) to a IUPAC char
>> 386 static char intToIUPAC(char n) { return elementIUPACDigits.at(n); }
>> 387
>> 388 /// \brief Array of natural isotopic distributions
>> 389 static const NaturalIsotopicDistributions *theNaturalIsotopicDistributions;
>> 390
>> 391 /// \brief Get the singleton instance of the natural isotopic distributions
>> 392 static const NaturalIsotopicDistributions *getNaturalIsotopicDistributions() {
>> 393 if(!theNaturalIsotopicDistributions)
>> 394 theNaturalIsotopicDistributions = new NaturalIsotopicDistributions;
>> 395 return theNaturalIsotopicDistributions;
>> 396 }
307 397
308 /// \brief Get particle width (in s) << 398 };
309 G4double getWidth(const ParticleType t); <<
310 } <<
311 } 399 }
312 400
313 #endif 401 #endif
314 <<
315 402