| 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 // Alain Boudard, CEA-Saclay, France
28 // Joseph Cugnon, University of Liege, Belgium 28 // Joseph Cugnon, University of Liege, Belgium
29 // Jean-Christophe David, CEA-Saclay, France 29 // Jean-Christophe David, CEA-Saclay, France
30 // Pekka Kaitaniemi, CEA-Saclay, France, and H 30 // Pekka Kaitaniemi, CEA-Saclay, France, and Helsinki Institute of Physics, Finland
31 // Sylvie Leray, CEA-Saclay, France 31 // Sylvie Leray, CEA-Saclay, France
32 // Davide Mancusi, CEA-Saclay, France 32 // Davide Mancusi, CEA-Saclay, France
33 // 33 //
34 #define INCLXX_IN_GEANT4_MODE 1 34 #define INCLXX_IN_GEANT4_MODE 1
35 35
36 #include "globals.hh" 36 #include "globals.hh"
37 37
38 #ifndef G4INCLParticleTable_hh 38 #ifndef G4INCLParticleTable_hh
39 #define G4INCLParticleTable_hh 1 39 #define G4INCLParticleTable_hh 1
40 40
41 #include <string> 41 #include <string>
42 #include <vector> 42 #include <vector>
43 // #include <cassert> 43 // #include <cassert>
44 44
45 #include "G4INCLParticleType.hh" 45 #include "G4INCLParticleType.hh"
46 #include "G4INCLParticleSpecies.hh" 46 #include "G4INCLParticleSpecies.hh"
47 #include "G4INCLLogger.hh" 47 #include "G4INCLLogger.hh"
48 #include "G4INCLConfig.hh" 48 #include "G4INCLConfig.hh"
49 #include "G4INCLHFB.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 #endif 54 #endif
55 #include "G4INCLGlobals.hh" 55 #include "G4INCLGlobals.hh"
56 #include "G4INCLNaturalIsotopicDistributions.h 56 #include "G4INCLNaturalIsotopicDistributions.hh"
57 57
58 namespace G4INCL { 58 namespace G4INCL {
59 59
60 namespace ParticleTable { 60 namespace ParticleTable {
61 61
62 const G4int maxClusterMass = 12; 62 const G4int maxClusterMass = 12;
63 const G4int maxClusterCharge = 8; 63 const G4int maxClusterCharge = 8;
64 64
65 const G4int clusterTableZSize = maxCluster 65 const G4int clusterTableZSize = maxClusterCharge+1;
66 const G4int clusterTableASize = maxCluster 66 const G4int clusterTableASize = maxClusterMass+1;
67 const G4int clusterTableSSize = 4; <<
68 67
69 const G4double effectiveNucleonMass = 938. 68 const G4double effectiveNucleonMass = 938.2796;
70 const G4double effectiveNucleonMass2 = 8.8 69 const G4double effectiveNucleonMass2 = 8.8036860777616e5;
71 const G4double effectiveDeltaMass = 1232.0 70 const G4double effectiveDeltaMass = 1232.0;
72 const G4double effectiveDeltaWidth = 130.0 71 const G4double effectiveDeltaWidth = 130.0;
73 const G4double effectivePionMass = 138.0; 72 const G4double effectivePionMass = 138.0;
74 const G4double effectiveLambdaMass = 1115. 73 const G4double effectiveLambdaMass = 1115.683;
75 const G4double effectiveSigmaMass = 1197.4 74 const G4double effectiveSigmaMass = 1197.45; // max value
76 const G4double effectiveXiMass = 1321.71; <<
77 const G4double effectiveKaonMass = 497.614 75 const G4double effectiveKaonMass = 497.614; // max value
78 const G4double effectiveAntiKaonMass = 497 76 const G4double effectiveAntiKaonMass = 497.614; // max value
79 const G4double effectiveEtaMass = 547.862; 77 const G4double effectiveEtaMass = 547.862;
80 const G4double effectiveOmegaMass = 782.65 78 const G4double effectiveOmegaMass = 782.65;
81 const G4double effectiveEtaPrimeMass = 957 79 const G4double effectiveEtaPrimeMass = 957.78;
82 const G4double effectivePhotonMass = 0.0; 80 const G4double effectivePhotonMass = 0.0;
83 extern G4ThreadLocal G4double minDeltaMass 81 extern G4ThreadLocal G4double minDeltaMass;
84 extern G4ThreadLocal G4double minDeltaMass 82 extern G4ThreadLocal G4double minDeltaMass2;
85 extern G4ThreadLocal G4double minDeltaMass 83 extern G4ThreadLocal G4double minDeltaMassRndm;
86 84
87 /// \brief Initialize the particle table 85 /// \brief Initialize the particle table
88 void initialize(Config const * const theCo 86 void initialize(Config const * const theConfig = 0);
89 87
90 /// \brief Get the isospin of a particle 88 /// \brief Get the isospin of a particle
91 G4int getIsospin(const ParticleType t); 89 G4int getIsospin(const ParticleType t);
92 90
93 /// \brief Get the native INCL name of the 91 /// \brief Get the native INCL name of the particle
94 std::string getName(const ParticleType t); 92 std::string getName(const ParticleType t);
95 93
96 /// \brief Get the short INCL name of the 94 /// \brief Get the short INCL name of the particle
97 std::string getShortName(const ParticleTyp 95 std::string getShortName(const ParticleType t);
98 96
99 /// \brief Get the native INCL name of the 97 /// \brief Get the native INCL name of the particle
100 std::string getName(const ParticleSpecies 98 std::string getName(const ParticleSpecies &s);
101 99
102 /// \brief Get the short INCL name of the 100 /// \brief Get the short INCL name of the particle
103 std::string getShortName(const ParticleSpe 101 std::string getShortName(const ParticleSpecies &s);
104 102
105 /// \brief Get the native INCL name of the 103 /// \brief Get the native INCL name of the ion
106 std::string getName(const G4int A, const G 104 std::string getName(const G4int A, const G4int Z);
107 105
108 /// \brief Get the native INCL name of the <<
109 std::string getName(const G4int A, const G <<
110 <<
111 /// \brief Get the short INCL name of the 106 /// \brief Get the short INCL name of the ion
112 std::string getShortName(const G4int A, co 107 std::string getShortName(const G4int A, const G4int Z);
113 108
114 /// \brief Get INCL nuclear mass (in MeV/c 109 /// \brief Get INCL nuclear mass (in MeV/c^2)
115 G4double getINCLMass(const G4int A, const << 110 G4double getINCLMass(const G4int A, const G4int Z);
116 111
117 /// \brief Get INCL particle mass (in MeV/ 112 /// \brief Get INCL particle mass (in MeV/c^2)
118 G4double getINCLMass(const ParticleType t) 113 G4double getINCLMass(const ParticleType t);
119 114
120 #ifndef INCLXX_IN_GEANT4_MODE 115 #ifndef INCLXX_IN_GEANT4_MODE
121 /// \brief Do we have this particle mass? 116 /// \brief Do we have this particle mass?
122 G4double hasMassTable(const unsigned int A 117 G4double hasMassTable(const unsigned int A, const unsigned int Z);
123 118
124 /** \brief Weizsaecker mass formula 119 /** \brief Weizsaecker mass formula
125 * 120 *
126 * Return the nuclear mass, as calculated 121 * Return the nuclear mass, as calculated from Weizsaecker's mass formula.
127 * Adapted from the Geant4 source. 122 * Adapted from the Geant4 source.
128 * 123 *
129 * \param A the mass number 124 * \param A the mass number
130 * \param Z the charge number 125 * \param Z the charge number
131 * \return the nuclear mass [MeV/c^2] 126 * \return the nuclear mass [MeV/c^2]
132 */ 127 */
133 G4double getWeizsaeckerMass(const G4int A, 128 G4double getWeizsaeckerMass(const G4int A, const G4int Z);
134 #endif 129 #endif
135 130
136 ///\brief Get particle mass (in MeV/c^2) 131 ///\brief Get particle mass (in MeV/c^2)
137 G4double getRealMass(const G4INCL::Particl 132 G4double getRealMass(const G4INCL::ParticleType t);
138 ///\brief Get nuclear mass (in MeV/c^2) 133 ///\brief Get nuclear mass (in MeV/c^2)
139 G4double getRealMass(const G4int A, const << 134 G4double getRealMass(const G4int A, const G4int Z);
140 135
141 /**\brief Get Q-value (in MeV/c^2) 136 /**\brief Get Q-value (in MeV/c^2)
142 * 137 *
143 * Uses the getTableMass function to compu 138 * Uses the getTableMass function to compute the Q-value for the
144 * following reaction: 139 * following reaction:
145 * \f[ (A_1,Z_1) + (A_2, Z_2) --> (A_1+A_2 140 * \f[ (A_1,Z_1) + (A_2, Z_2) --> (A_1+A_2,Z_1+Z_2) \f]
146 */ 141 */
147 G4double getTableQValue(const G4int A1, co << 142 G4double getTableQValue(const G4int A1, const G4int Z1, const G4int A2, const G4int Z2);
148 143
149 /**\brief Get Q-value (in MeV/c^2) 144 /**\brief Get Q-value (in MeV/c^2)
150 * 145 *
151 * Uses the getTableMass function to compu 146 * Uses the getTableMass function to compute the Q-value for the
152 * following reaction: 147 * following reaction:
153 * \f[ (A_1,Z_1) + (A_2, Z_2) --> (A_3,Z_3 148 * \f[ (A_1,Z_1) + (A_2, Z_2) --> (A_3,Z_3) + (A1+A2-A3,Z1+Z2-Z3) \f]
154 */ 149 */
155 G4double getTableQValue(const G4int A1, co << 150 G4double getTableQValue(const G4int A1, const G4int Z1, const G4int A2, const G4int Z2, const G4int A3, const G4int Z3);
156 151
157 G4double getTableSpeciesMass(const Particl 152 G4double getTableSpeciesMass(const ParticleSpecies &p);
158 153
159 /// \brief Get mass number from particle t 154 /// \brief Get mass number from particle type
160 G4int getMassNumber(const ParticleType t); 155 G4int getMassNumber(const ParticleType t);
161 156
162 /// \brief Get charge number from particle 157 /// \brief Get charge number from particle type
163 G4int getChargeNumber(const ParticleType t 158 G4int getChargeNumber(const ParticleType t);
164 159
165 /// \brief Get strangeness number from par 160 /// \brief Get strangeness number from particle type
166 G4int getStrangenessNumber(const ParticleT 161 G4int getStrangenessNumber(const ParticleType t);
167 162
168 G4double getNuclearRadius(const ParticleTy 163 G4double getNuclearRadius(const ParticleType t, const G4int A, const G4int Z);
169 G4double getLargestNuclearRadius(const G4i 164 G4double getLargestNuclearRadius(const G4int A, const G4int Z);
170 G4double getRadiusParameter(const Particle 165 G4double getRadiusParameter(const ParticleType t, const G4int A, const G4int Z);
171 G4double getMaximumNuclearRadius(const Par 166 G4double getMaximumNuclearRadius(const ParticleType t, const G4int A, const G4int Z);
172 G4double getSurfaceDiffuseness(const Parti 167 G4double getSurfaceDiffuseness(const ParticleType t, const G4int A, const G4int Z);
173 168
174 /// \brief Return the RMS of the momentum 169 /// \brief Return the RMS of the momentum distribution (light clusters)
175 G4double getMomentumRMS(const G4int A, con 170 G4double getMomentumRMS(const G4int A, const G4int Z);
176 171
177 /// \brief Return INCL's default separatio 172 /// \brief Return INCL's default separation energy
178 G4double getSeparationEnergyINCL(const Par 173 G4double getSeparationEnergyINCL(const ParticleType t, const G4int /*A*/, const G4int /*Z*/);
179 174
180 /// \brief Return the real separation ener 175 /// \brief Return the real separation energy
181 G4double getSeparationEnergyReal(const Par 176 G4double getSeparationEnergyReal(const ParticleType t, const G4int A, const G4int Z);
182 177
183 /// \brief Return the real separation ener 178 /// \brief Return the real separation energy only for light nuclei
184 G4double getSeparationEnergyRealForLight(c 179 G4double getSeparationEnergyRealForLight(const ParticleType t, const G4int A, const G4int Z);
185 180
186 /// \brief Getter for protonSeparationEner 181 /// \brief Getter for protonSeparationEnergy
187 G4double getProtonSeparationEnergy(); 182 G4double getProtonSeparationEnergy();
188 183
189 /// \brief Getter for neutronSeparationEne 184 /// \brief Getter for neutronSeparationEnergy
190 G4double getNeutronSeparationEnergy(); 185 G4double getNeutronSeparationEnergy();
191 186
192 /// \brief Setter for protonSeparationEner 187 /// \brief Setter for protonSeparationEnergy
193 void setProtonSeparationEnergy(const G4dou 188 void setProtonSeparationEnergy(const G4double s);
194 189
195 /// \brief Setter for protonSeparationEner 190 /// \brief Setter for protonSeparationEnergy
196 void setNeutronSeparationEnergy(const G4do 191 void setNeutronSeparationEnergy(const G4double s);
197 192
198 /// \brief Get the name of the element fro 193 /// \brief Get the name of the element from the atomic number
199 std::string getElementName(const G4int Z); 194 std::string getElementName(const G4int Z);
200 195
201 /// \brief Get the name of an unnamed elem 196 /// \brief Get the name of an unnamed element from the IUPAC convention
202 std::string getIUPACElementName(const G4in 197 std::string getIUPACElementName(const G4int Z);
203 198
204 /// \brief Get the name of the element fro 199 /// \brief Get the name of the element from the atomic number
205 G4int parseElement(std::string pS); 200 G4int parseElement(std::string pS);
206 201
207 /** \brief Parse a IUPAC element name 202 /** \brief Parse a IUPAC element name
208 * 203 *
209 * Note: this function is UGLY. Look at it 204 * Note: this function is UGLY. Look at it at your own peril.
210 * 205 *
211 * \param pS a normalised string (lowercas 206 * \param pS a normalised string (lowercase)
212 * \return the charge number of the nuclid 207 * \return the charge number of the nuclide, or zero on fail
213 */ 208 */
214 G4int parseIUPACElement(std::string const 209 G4int parseIUPACElement(std::string const &pS);
215 210
216 IsotopicDistribution const &getNaturalIsot 211 IsotopicDistribution const &getNaturalIsotopicDistribution(const G4int Z);
217 212
218 G4int drawRandomNaturalIsotope(const G4int 213 G4int drawRandomNaturalIsotope(const G4int Z);
219 214
220 // Typedefs and pointers for transparent h 215 // Typedefs and pointers for transparent handling of mass functions
221 //typedef G4double (*NuclearMassFn)(const << 216 typedef G4double (*NuclearMassFn)(const G4int, const G4int);
222 typedef G4double (*NuclearMassFn)(const G4 <<
223 typedef G4double (*ParticleMassFn)(const P 217 typedef G4double (*ParticleMassFn)(const ParticleType);
224 /// \brief Static pointer to the mass func 218 /// \brief Static pointer to the mass function for nuclei
225 extern G4ThreadLocal NuclearMassFn getTabl 219 extern G4ThreadLocal NuclearMassFn getTableMass;
226 /// \brief Static pointer to the mass func 220 /// \brief Static pointer to the mass function for particles
227 extern G4ThreadLocal ParticleMassFn getTab 221 extern G4ThreadLocal ParticleMassFn getTableParticleMass;
228 222
229 // Typedefs and pointers for transparent h 223 // Typedefs and pointers for transparent handling of separation energies
230 typedef G4double (*SeparationEnergyFn)(con 224 typedef G4double (*SeparationEnergyFn)(const ParticleType, const G4int, const G4int);
231 /// \brief Static pointer to the separatio 225 /// \brief Static pointer to the separation-energy function
232 extern G4ThreadLocal SeparationEnergyFn ge 226 extern G4ThreadLocal SeparationEnergyFn getSeparationEnergy;
233 227
234 // Typedefs and pointers for transparent h 228 // Typedefs and pointers for transparent handling of Fermi momentum
235 typedef G4double (*FermiMomentumFn)(const 229 typedef G4double (*FermiMomentumFn)(const G4int, const G4int);
236 extern G4ThreadLocal FermiMomentumFn getFe 230 extern G4ThreadLocal FermiMomentumFn getFermiMomentum;
237 231
238 /// \brief Return the constant value of th 232 /// \brief Return the constant value of the Fermi momentum
239 G4double getFermiMomentumConstant(const G4 233 G4double getFermiMomentumConstant(const G4int /*A*/, const G4int /*Z*/);
240 234
241 /** \brief Return the constant value of th 235 /** \brief Return the constant value of the Fermi momentum - special for light
242 * 236 *
243 * This function should always return Phys 237 * This function should always return PhysicalConstants::Pf for heavy
244 * nuclei, and values from the momentumRMS 238 * nuclei, and values from the momentumRMS table for light nuclei.
245 * 239 *
246 * \param A mass number 240 * \param A mass number
247 * \param Z charge number 241 * \param Z charge number
248 */ 242 */
249 G4double getFermiMomentumConstantLight(con 243 G4double getFermiMomentumConstantLight(const G4int A, const G4int Z);
250 244
251 /** \brief Return the value Fermi momentum 245 /** \brief Return the value Fermi momentum from a fit
252 * 246 *
253 * This function returns a fitted Fermi mo 247 * This function returns a fitted Fermi momentum, based on data from Moniz
254 * et al., Phys. Rev. Lett. 26 (1971) 445. 248 * et al., Phys. Rev. Lett. 26 (1971) 445. The fitted functional form is
255 * \f[ 249 * \f[
256 * p_F(A)=\alpha-\beta\cdot e^{(-A\cdot\ga 250 * p_F(A)=\alpha-\beta\cdot e^{(-A\cdot\gamma)}
257 * \f] 251 * \f]
258 * with \f$\alpha=259.416\f$ MeV/\f$c\f$, 252 * with \f$\alpha=259.416\f$ MeV/\f$c\f$, \f$\beta=152.824\f$ MeV/\f$c\f$
259 * and \f$\gamma=9.5157\cdot10^{-2}\f$. 253 * and \f$\gamma=9.5157\cdot10^{-2}\f$.
260 * 254 *
261 * \param A mass number 255 * \param A mass number
262 */ 256 */
263 G4double getFermiMomentumMassDependent(con 257 G4double getFermiMomentumMassDependent(const G4int A, const G4int /*Z*/);
264 258
265 /** \brief Get the value of the r-p correl 259 /** \brief Get the value of the r-p correlation coefficient
266 * 260 *
267 * \param t the type of the particle (Prot 261 * \param t the type of the particle (Proton or Neutron)
268 * \return the value of the r-p correlatio 262 * \return the value of the r-p correlation coefficient
269 */ 263 */
270 G4double getRPCorrelationCoefficient(const 264 G4double getRPCorrelationCoefficient(const ParticleType t);
271 265
272 /// \brief Get the thickness of the neutro 266 /// \brief Get the thickness of the neutron skin
273 G4double getNeutronSkin(); 267 G4double getNeutronSkin();
274 268
275 /// \brief Get the size of the neutron hal 269 /// \brief Get the size of the neutron halo
276 G4double getNeutronHalo(); 270 G4double getNeutronHalo();
277 271
278 /// \brief Get the type of pion 272 /// \brief Get the type of pion
279 ParticleType getPionType(const G4int isosp 273 ParticleType getPionType(const G4int isosp);
280 274
281 /// \brief Get the type of nucleon 275 /// \brief Get the type of nucleon
282 ParticleType getNucleonType(const G4int is 276 ParticleType getNucleonType(const G4int isosp);
283 277
284 /// \brief Get the type of delta 278 /// \brief Get the type of delta
285 ParticleType getDeltaType(const G4int isos 279 ParticleType getDeltaType(const G4int isosp);
286 280
287 /// \brief Get the type of sigma 281 /// \brief Get the type of sigma
288 ParticleType getSigmaType(const G4int isos 282 ParticleType getSigmaType(const G4int isosp);
289 << 283
290 /// \brief Get the type of kaon 284 /// \brief Get the type of kaon
291 ParticleType getKaonType(const G4int isosp 285 ParticleType getKaonType(const G4int isosp);
292 286
293 /// \brief Get the type of antikaon 287 /// \brief Get the type of antikaon
294 ParticleType getAntiKaonType(const G4int i 288 ParticleType getAntiKaonType(const G4int isosp);
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 <<
302 /// \brief Get the type of antidelta <<
303 ParticleType getAntiXiType(const G4int iso <<
304 <<
305 /// \brief Get the type of antisigma <<
306 ParticleType getAntiSigmaType(const G4int <<
307 289
308 /// \brief Get particle width (in s) 290 /// \brief Get particle width (in s)
309 G4double getWidth(const ParticleType t); 291 G4double getWidth(const ParticleType t);
310 } 292 }
311 } 293 }
312 294
313 #endif 295 #endif
314 296
315 297