Geant4  v4-10.4-release
 모두 클래스 네임스페이스들 파일들 함수 변수 타입정의 열거형 타입 열거형 멤버 Friends 매크로 그룹들 페이지들
G4INCLParticleTable.cc
이 파일의 문서화 페이지로 가기
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 // INCL++ intra-nuclear cascade model
27 // Alain Boudard, CEA-Saclay, France
28 // Joseph Cugnon, University of Liege, Belgium
29 // Jean-Christophe David, CEA-Saclay, France
30 // Pekka Kaitaniemi, CEA-Saclay, France, and Helsinki Institute of Physics, Finland
31 // Sylvie Leray, CEA-Saclay, France
32 // Davide Mancusi, CEA-Saclay, France
33 //
34 #define INCLXX_IN_GEANT4_MODE 1
35 
36 #include "globals.hh"
37 
38 #include "G4INCLParticleTable.hh"
40 #include <algorithm>
41 // #include <cassert>
42 #include <cmath>
43 #include <cctype>
44 #include <sstream>
45 #ifdef INCLXX_IN_GEANT4_MODE
46 #include "G4SystemOfUnits.hh"
47 #endif
48 
49 #ifdef INCLXX_IN_GEANT4_MODE
50 #include "G4PhysicalConstants.hh"
51 #include "G4SystemOfUnits.hh"
52 #endif
53 
54 namespace G4INCL {
55 
56  namespace ParticleTable {
57 
58  namespace {
59 
61  const NaturalIsotopicDistributions *theNaturalIsotopicDistributions = NULL;
62 
63  const G4double theINCLNucleonMass = 938.2796;
64  const G4double theINCLPionMass = 138.0;
65  const G4double theINCLLambdaMass = 1115.683;
66 // const G4double theINCLSigmaMass = 1197.45;
67 // const G4double theINCLKaonMass = 497.614;
68  const G4double theINCLEtaMass = 547.862;
69  const G4double theINCLOmegaMass = 782.65;
70  const G4double theINCLEtaPrimeMass = 957.78;
71  const G4double theINCLPhotonMass = 0.0;
72  G4ThreadLocal G4double protonMass = 0.0;
73  G4ThreadLocal G4double neutronMass = 0.0;
74  G4ThreadLocal G4double piPlusMass = 0.0;
75  G4ThreadLocal G4double piMinusMass = 0.0;
76  G4ThreadLocal G4double piZeroMass = 0.0;
77  G4ThreadLocal G4double SigmaPlusMass = 0.0;
78  G4ThreadLocal G4double SigmaZeroMass = 0.0;
79  G4ThreadLocal G4double SigmaMinusMass = 0.0;
80  G4ThreadLocal G4double LambdaMass = 0.0;
81  G4ThreadLocal G4double KPlusMass = 0.0;
82  G4ThreadLocal G4double KZeroMass = 0.0;
83  G4ThreadLocal G4double KZeroBarMass = 0.0;
84  G4ThreadLocal G4double KShortMass = 0.0;
85  G4ThreadLocal G4double KLongMass = 0.0;
86  G4ThreadLocal G4double KMinusMass = 0.0;
87  G4ThreadLocal G4double etaMass = 0.0;
88  G4ThreadLocal G4double omegaMass = 0.0;
89  G4ThreadLocal G4double etaPrimeMass = 0.0;
90  G4ThreadLocal G4double photonMass = 0.0;
91 
92  // Hard-coded values of the real particle masses (MeV/c^2)
93  G4ThreadLocal G4double theRealProtonMass = 938.27203;
94  G4ThreadLocal G4double theRealNeutronMass = 939.56536;
95  G4ThreadLocal G4double theRealChargedPiMass = 139.57018;
96  G4ThreadLocal G4double theRealPiZeroMass = 134.9766;
97  G4ThreadLocal G4double theRealLambdaMass = 1115.683;
98  G4ThreadLocal G4double theRealSigmaPlusMass = 1189.37;
99  G4ThreadLocal G4double theRealSigmaZeroMass = 1192.64;
100  G4ThreadLocal G4double theRealSigmaMinusMass = 1197.45;
101  G4ThreadLocal G4double theRealChargedKaonMass = 493.677;
102  G4ThreadLocal G4double theRealNeutralKaonMass = 497.614;
103  G4ThreadLocal G4double theRealEtaMass = 547.862;
104  G4ThreadLocal G4double theRealOmegaMass = 782.65;
105  G4ThreadLocal G4double theRealEtaPrimeMass = 957.78;
106  G4ThreadLocal G4double theRealPhotonMass = 0.0;
107 
108  // Width (second)
109  const G4double theChargedPiWidth = 2.6033e-08;
110  const G4double thePiZeroWidth = 8.52e-17;
111  const G4double theEtaWidth = 5.025e-19; // 1.31 keV
112  const G4double theOmegaWidth = 7.7528e-23; // 8.49 MeV
113  const G4double theEtaPrimeWidth = 3.3243e-21; // 0.198 MeV
114  const G4double theChargedKaonWidth = 1.238e-08;
115  const G4double theKShortWidth = 8.954e-11;
116  const G4double theKLongWidth = 5.116e-08;
117  const G4double theLambdaWidth = 2.632e-10;
118  const G4double theSigmaPlusWidth = 8.018e-11;
119  const G4double theSigmaZeroWidth = 7.4e-20;
120  const G4double theSigmaMinusWidth = 1.479e-10;
121  G4ThreadLocal G4double piPlusWidth = 0.0;
122  G4ThreadLocal G4double piMinusWidth = 0.0;
123  G4ThreadLocal G4double piZeroWidth = 0.0;
124  G4ThreadLocal G4double etaWidth = 0.0;
125  G4ThreadLocal G4double omegaWidth = 0.0;
126  G4ThreadLocal G4double etaPrimeWidth = 0.0;
127  G4ThreadLocal G4double LambdaWidth = 0.0;
128  G4ThreadLocal G4double SigmaPlusWidth = 0.0;
129  G4ThreadLocal G4double SigmaZeroWidth = 0.0;
130  G4ThreadLocal G4double SigmaMinusWidth = 0.0;
131  G4ThreadLocal G4double KPlusWidth = 0.0;
132  G4ThreadLocal G4double KMinusWidth = 0.0;
133  G4ThreadLocal G4double KShortWidth = 0.0;
134  G4ThreadLocal G4double KLongWidth = 0.0;
135 
136 
137  const G4int mediumNucleiTableSize = 30;
138 
139  const G4double mediumDiffuseness[mediumNucleiTableSize] =
140  {0.0,0.0,0.0,0.0,0.0,1.78,1.77,1.77,1.77,1.71,
141  1.69,1.69,1.635,1.730,1.81,1.833,1.798,
142  1.841,0.567,0.571, 0.560,0.549,0.550,0.551,
143  0.580,0.575,0.569,0.537,0.0,0.0};
144  const G4double mediumRadius[mediumNucleiTableSize] =
145  {0.0,0.0,0.0,0.0,0.0,0.334,0.327,0.479,0.631,0.838,
146  0.811,1.07,1.403,1.335,1.25,1.544,1.498,1.513,
147  2.58,2.77, 2.775,2.78,2.88,2.98,3.22,3.03,2.84,
148  3.14,0.0,0.0};
149 
150  const G4double positionRMS[clusterTableZSize][clusterTableASize] = {
151  /* A= 0 1 2 3 4 5 6 7 8 9 10 11 12 */
152  /* 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},
153  /* 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},
154  /* 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},
155  /* 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},
156  /* 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},
157  /* 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},
158  /* 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},
159  /* 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},
160  /* 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}
161  };
162 
163  const G4double momentumRMS[clusterTableZSize][clusterTableASize] = {
164  /* A= 0 1 2 3 4 5 6 7 8 9 10 11 12 */
165  /* 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},
166  /* Z=1 */ {-1.0, -1.0, 77.0, 110., 153., 100., 100., 100., -1.0, -1.0, -1.0, -1.0, -1.0},
167  /* Z=2 */ {-1.0, -1.0, -1.0, 110., 153., 100., 100., 100., 100., 100., 100., -1.0, -1.0},
168  /* Z=3 */ {-1.0, -1.0, -1.0, -1.0, 153., 100., 100., 100., 100., 100., 100., 100., 100.},
169  /* Z=4 */ {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 100., 100., 100., 100., 100., 100., 100.},
170  /* Z=5 */ {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 100., 100., 100., 100., 100., 100., 100.},
171  /* Z=6 */ {-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 100., 100., 100., 100., 100.},
172  /* 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.},
173  /* 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.}
174  };
175 
176 
177  const G4int elementTableSize = 113; // up to Cn
178 
180  const std::string elementTable[elementTableSize] = {
181  "",
182  "H",
183  "He",
184  "Li",
185  "Be",
186  "B",
187  "C",
188  "N",
189  "O",
190  "F",
191  "Ne",
192  "Na",
193  "Mg",
194  "Al",
195  "Si",
196  "P",
197  "S",
198  "Cl",
199  "Ar",
200  "K",
201  "Ca",
202  "Sc",
203  "Ti",
204  "V",
205  "Cr",
206  "Mn",
207  "Fe",
208  "Co",
209  "Ni",
210  "Cu",
211  "Zn",
212  "Ga",
213  "Ge",
214  "As",
215  "Se",
216  "Br",
217  "Kr",
218  "Rb",
219  "Sr",
220  "Y",
221  "Zr",
222  "Nb",
223  "Mo",
224  "Tc",
225  "Ru",
226  "Rh",
227  "Pd",
228  "Ag",
229  "Cd",
230  "In",
231  "Sn",
232  "Sb",
233  "Te",
234  "I",
235  "Xe",
236  "Cs",
237  "Ba",
238  "La",
239  "Ce",
240  "Pr",
241  "Nd",
242  "Pm",
243  "Sm",
244  "Eu",
245  "Gd",
246  "Tb",
247  "Dy",
248  "Ho",
249  "Er",
250  "Tm",
251  "Yb",
252  "Lu",
253  "Hf",
254  "Ta",
255  "W",
256  "Re",
257  "Os",
258  "Ir",
259  "Pt",
260  "Au",
261  "Hg",
262  "Tl",
263  "Pb",
264  "Bi",
265  "Po",
266  "At",
267  "Rn",
268  "Fr",
269  "Ra",
270  "Ac",
271  "Th",
272  "Pa",
273  "U",
274  "Np",
275  "Pu",
276  "Am",
277  "Cm",
278  "Bk",
279  "Cf",
280  "Es",
281  "Fm",
282  "Md",
283  "No",
284  "Lr",
285  "Rf",
286  "Db",
287  "Sg",
288  "Bh",
289  "Hs",
290  "Mt",
291  "Ds",
292  "Rg",
293  "Cn"
294  };
295 
297  const std::string elementIUPACDigits = "nubtqphsoe";
298 
299 #define INCL_DEFAULT_SEPARATION_ENERGY 6.83
300  const G4double theINCLProtonSeparationEnergy = INCL_DEFAULT_SEPARATION_ENERGY;
301  const G4double theINCLNeutronSeparationEnergy = INCL_DEFAULT_SEPARATION_ENERGY;
302  G4ThreadLocal G4double protonSeparationEnergy = INCL_DEFAULT_SEPARATION_ENERGY;
303  G4ThreadLocal G4double neutronSeparationEnergy = INCL_DEFAULT_SEPARATION_ENERGY;
304 #undef INCL_DEFAULT_SEPARATION_ENERGY
305 
306  G4ThreadLocal G4double rpCorrelationCoefficient[UnknownParticle];
307 
308  G4ThreadLocal G4double neutronSkin = 0.0;
309  G4ThreadLocal G4double neutronHalo = 0.0;
310 
311 #ifdef INCLXX_IN_GEANT4_MODE
312  G4ThreadLocal G4IonTable *theG4IonTable;
313 #endif
314 
316  G4ThreadLocal G4double constantFermiMomentum = 0.0;
317 
319  char iupacToInt(char c) {
320  return (char)(((G4int)'0')+elementIUPACDigits.find(c));
321  }
322 
324  char intToIUPAC(char n) { return elementIUPACDigits.at(n); }
325 
327  const NaturalIsotopicDistributions *getNaturalIsotopicDistributions() {
328  if(!theNaturalIsotopicDistributions)
329  theNaturalIsotopicDistributions = new NaturalIsotopicDistributions;
330  return theNaturalIsotopicDistributions;
331  }
332 
333  } // namespace
334 
335  void initialize(Config const * const theConfig /*=0*/) {
336  protonMass = theINCLNucleonMass;
337  neutronMass = theINCLNucleonMass;
338  piPlusMass = theINCLPionMass;
339  piMinusMass = theINCLPionMass;
340  piZeroMass = theINCLPionMass;
341  /*
342  SigmaPlusMass = theINCLSigmaMass;
343  SigmaMinusMass = theINCLSigmaMass;
344  SigmaZeroMass = theINCLSigmaMass;
345  LambdaMass = theINCLLambdaMass;
346  KPlusMass = theINCLKaonMass;
347  KZeroMass = theINCLKaonMass;
348  KZeroBarMass = theINCLKaonMass;
349  KShortMass = theINCLKaonMass;
350  KLongMass = theINCLKaonMass;
351  KMinusMass = theINCLKaonMass;
352  */
353  SigmaPlusMass = theRealSigmaPlusMass;
354  SigmaMinusMass = theRealSigmaMinusMass;
355  SigmaZeroMass = theRealSigmaZeroMass;
356  LambdaMass = theINCLLambdaMass;
357  KPlusMass = theRealChargedKaonMass;
358  KZeroMass = theRealNeutralKaonMass;
359  KZeroBarMass = theRealNeutralKaonMass;
360  KShortMass = theRealNeutralKaonMass;
361  KLongMass = theRealNeutralKaonMass;
362  KMinusMass = theRealChargedKaonMass;
363 
364  etaMass = theINCLEtaMass;
365  omegaMass = theINCLOmegaMass;
366  etaPrimeMass = theINCLEtaPrimeMass;
367  photonMass = theINCLPhotonMass;
368  if(theConfig && theConfig->getUseRealMasses()) {
371  } else {
374  }
375 
376 #ifndef INCLXX_IN_GEANT4_MODE
377  std::string dataFilePath;
378  if(theConfig)
379  dataFilePath = theConfig->getINCLXXDataFilePath();
381 #endif
382 
383 #ifdef INCLXX_IN_GEANT4_MODE
384  G4ParticleTable *theG4ParticleTable = G4ParticleTable::GetParticleTable();
385  theG4IonTable = theG4ParticleTable->GetIonTable();
386  theRealProtonMass = theG4ParticleTable->FindParticle("proton")->GetPDGMass() / MeV;
387  theRealNeutronMass = theG4ParticleTable->FindParticle("neutron")->GetPDGMass() / MeV;
388  theRealChargedPiMass = theG4ParticleTable->FindParticle("pi+")->GetPDGMass() / MeV;
389  theRealPiZeroMass = theG4ParticleTable->FindParticle("pi0")->GetPDGMass() / MeV;
390  theRealEtaMass = theG4ParticleTable->FindParticle("eta")->GetPDGMass() / MeV;
391  theRealOmegaMass = theG4ParticleTable->FindParticle("omega")->GetPDGMass() / MeV;
392  theRealEtaPrimeMass = theG4ParticleTable->FindParticle("eta_prime")->GetPDGMass() / MeV;
393  theRealPhotonMass = theG4ParticleTable->FindParticle("gamma")->GetPDGMass() / MeV;
394  theRealSigmaPlusMass = theG4ParticleTable->FindParticle("sigma+")->GetPDGMass() / MeV;
395  theRealSigmaZeroMass = theG4ParticleTable->FindParticle("sigma0")->GetPDGMass() / MeV;
396  theRealSigmaMinusMass = theG4ParticleTable->FindParticle("sigma-")->GetPDGMass() / MeV;
397  theRealLambdaMass = theG4ParticleTable->FindParticle("lambda")->GetPDGMass() / MeV;
398  theRealChargedKaonMass = theG4ParticleTable->FindParticle("kaon+")->GetPDGMass() / MeV;
399  theRealNeutralKaonMass = theG4ParticleTable->FindParticle("kaon0")->GetPDGMass() / MeV;
400 #endif
401 
402  minDeltaMass = theRealNeutronMass + theRealChargedPiMass + 0.5;
404  minDeltaMassRndm = std::atan((minDeltaMass-effectiveDeltaMass)*2./effectiveDeltaWidth);
405 
406  piPlusWidth = theChargedPiWidth;
407  piMinusWidth = theChargedPiWidth;
408  piZeroWidth = thePiZeroWidth;
409  etaWidth = theEtaWidth;
410  omegaWidth = theOmegaWidth;
411  etaPrimeWidth = theEtaPrimeWidth;
412 
413  SigmaMinusWidth = theSigmaMinusWidth;
414  SigmaPlusWidth = theSigmaPlusWidth;
415  SigmaZeroWidth = theSigmaZeroWidth;
416  LambdaWidth = theLambdaWidth;
417  KPlusWidth = theChargedKaonWidth;
418  KMinusWidth = theChargedKaonWidth;
419  KShortWidth = theKShortWidth;
420  KLongWidth = theKLongWidth;
421 
422 
423  // Initialise the separation-energy function
424  if(!theConfig || theConfig->getSeparationEnergyType()==INCLSeparationEnergy)
426  else if(theConfig->getSeparationEnergyType()==RealSeparationEnergy)
430  else {
431  INCL_FATAL("Unrecognized separation-energy type in ParticleTable initialization: " << theConfig->getSeparationEnergyType() << '\n');
432  return;
433  }
434 
435  // Initialise the Fermi-momentum function
436  if(!theConfig || theConfig->getFermiMomentumType()==ConstantFermiMomentum) {
438  if(theConfig) {
439  const G4double aFermiMomentum = theConfig->getFermiMomentum();
440  if(aFermiMomentum>0.)
441  constantFermiMomentum = aFermiMomentum;
442  else
443  constantFermiMomentum = PhysicalConstants::Pf;
444  } else {
445  constantFermiMomentum = PhysicalConstants::Pf;
446  }
447  } else if(theConfig->getFermiMomentumType()==ConstantLightFermiMomentum)
449  else if(theConfig->getFermiMomentumType()==MassDependentFermiMomentum)
451  else {
452  INCL_FATAL("Unrecognized Fermi-momentum type in ParticleTable initialization: " << theConfig->getFermiMomentumType() << '\n');
453  return;
454  }
455 
456  // Initialise the r-p correlation coefficients
457  std::fill(rpCorrelationCoefficient, rpCorrelationCoefficient + UnknownParticle, 1.);
458  if(theConfig) {
459  rpCorrelationCoefficient[Proton] = theConfig->getRPCorrelationCoefficient(Proton);
460  rpCorrelationCoefficient[Neutron] = theConfig->getRPCorrelationCoefficient(Neutron);
461  }
462 
463  // Initialise the neutron-skin parameters
464  if(theConfig) {
465  neutronSkin = theConfig->getNeutronSkin();
466  neutronHalo = theConfig->getNeutronHalo();
467  }
468 
469  }
470 
472  // Actually this is the 3rd component of isospin (I_z) multiplied by 2!
473  if(t == Proton) {
474  return 1;
475  } else if(t == Neutron) {
476  return -1;
477  } else if(t == PiPlus) {
478  return 2;
479  } else if(t == PiMinus) {
480  return -2;
481  } else if(t == PiZero) {
482  return 0;
483  } else if(t == DeltaPlusPlus) {
484  return 3;
485  } else if(t == DeltaPlus) {
486  return 1;
487  } else if(t == DeltaZero) {
488  return -1;
489  } else if(t == DeltaMinus) {
490  return -3;
491  } else if(t == Lambda) {
492  return 0;
493  } else if(t == SigmaPlus) {
494  return 2;
495  } else if(t == SigmaZero) {
496  return 0;
497  } else if(t == SigmaMinus) {
498  return -2;
499  } else if(t == KPlus) {
500  return 1;
501  } else if(t == KZero) {
502  return -1;
503  } else if(t == KZeroBar) {
504  return 1;
505  } else if(t == KShort) {
506  return -99;
507  } else if(t == KLong) {
508  return 99;
509  } else if(t == KMinus) {
510  return -1;
511  } else if(t == Eta) {
512  return 0;
513  } else if(t == Omega) {
514  return 0;
515  } else if(t == EtaPrime) {
516  return 0;
517  } else if(t == Photon) {
518  return 0;
519  }
520  INCL_ERROR("Requested isospin of an unknown particle!");
521  return -10; // Unknown
522  }
523 
524  std::string getShortName(const ParticleSpecies &s) {
525  if(s.theType==Composite)
526  return getShortName(s.theA,s.theZ);
527  else
528  return getShortName(s.theType);
529  }
530 
531  std::string getName(const ParticleSpecies &s) {
532  if(s.theType==Composite)
533  return getName(s.theA,s.theZ);
534  else
535  return getName(s.theType);
536  }
537 
538  std::string getName(const G4int A, const G4int Z) {
539  std::stringstream stream;
540  stream << getElementName(Z) << "-" << A;
541  return stream.str();
542  }
543 
544  std::string getShortName(const G4int A, const G4int Z) {
545  std::stringstream stream;
546  stream << getElementName(Z);
547  if(A>0)
548  stream << A;
549  return stream.str();
550  }
551 
552  std::string getName(const ParticleType p) {
553  if(p == G4INCL::Proton) {
554  return std::string("proton");
555  } else if(p == G4INCL::Neutron) {
556  return std::string("neutron");
557  } else if(p == G4INCL::DeltaPlusPlus) {
558  return std::string("delta++");
559  } else if(p == G4INCL::DeltaPlus) {
560  return std::string("delta+");
561  } else if(p == G4INCL::DeltaZero) {
562  return std::string("delta0");
563  } else if(p == G4INCL::DeltaMinus) {
564  return std::string("delta-");
565  } else if(p == G4INCL::PiPlus) {
566  return std::string("pi+");
567  } else if(p == G4INCL::PiZero) {
568  return std::string("pi0");
569  } else if(p == G4INCL::PiMinus) {
570  return std::string("pi-");
571  } else if(p == G4INCL::Lambda) {
572  return std::string("lambda");
573  } else if(p == G4INCL::SigmaPlus) {
574  return std::string("sigma+");
575  } else if(p == G4INCL::SigmaZero) {
576  return std::string("sigma0");
577  } else if(p == G4INCL::SigmaMinus) {
578  return std::string("sigma-");
579  } else if(p == G4INCL::KPlus) {
580  return std::string("kaon+");
581  } else if(p == G4INCL::KZero) {
582  return std::string("kaon0");
583  } else if(p == G4INCL::KZeroBar) {
584  return std::string("kaon0bar");
585  } else if(p == G4INCL::KMinus) {
586  return std::string("kaon-");
587  } else if(p == G4INCL::KShort) {
588  return std::string("kaonshort");
589  } else if(p == G4INCL::KLong) {
590  return std::string("kaonlong");
591  } else if(p == G4INCL::Composite) {
592  return std::string("composite");
593  } else if(p == G4INCL::Eta) {
594  return std::string("eta");
595  } else if(p == G4INCL::Omega) {
596  return std::string("omega");
597  } else if(p == G4INCL::EtaPrime) {
598  return std::string("etaprime");
599  } else if(p == G4INCL::Photon) {
600  return std::string("photon");
601  }
602  return std::string("unknown");
603  }
604 
605  std::string getShortName(const ParticleType p) {
606  if(p == G4INCL::Proton) {
607  return std::string("p");
608  } else if(p == G4INCL::Neutron) {
609  return std::string("n");
610  } else if(p == G4INCL::DeltaPlusPlus) {
611  return std::string("d++");
612  } else if(p == G4INCL::DeltaPlus) {
613  return std::string("d+");
614  } else if(p == G4INCL::DeltaZero) {
615  return std::string("d0");
616  } else if(p == G4INCL::DeltaMinus) {
617  return std::string("d-");
618  } else if(p == G4INCL::PiPlus) {
619  return std::string("pi+");
620  } else if(p == G4INCL::PiZero) {
621  return std::string("pi0");
622  } else if(p == G4INCL::PiMinus) {
623  return std::string("pi-");
624  } else if(p == G4INCL::Lambda) {
625  return std::string("l");
626  } else if(p == G4INCL::SigmaPlus) {
627  return std::string("s+");
628  } else if(p == G4INCL::SigmaZero) {
629  return std::string("s0");
630  } else if(p == G4INCL::SigmaMinus) {
631  return std::string("s-");
632  } else if(p == G4INCL::KPlus) {
633  return std::string("k+");
634  } else if(p == G4INCL::KZero) {
635  return std::string("k0");
636  } else if(p == G4INCL::KZeroBar) {
637  return std::string("k0b");
638  } else if(p == G4INCL::KMinus) {
639  return std::string("k-");
640  } else if(p == G4INCL::KShort) {
641  return std::string("ks");
642  } else if(p == G4INCL::KLong) {
643  return std::string("kl");
644  } else if(p == G4INCL::Composite) {
645  return std::string("comp");
646  } else if(p == G4INCL::Eta) {
647  return std::string("eta");
648  } else if(p == G4INCL::Omega) {
649  return std::string("omega");
650  } else if(p == G4INCL::EtaPrime) {
651  return std::string("etap");
652  } else if(p == G4INCL::Photon) {
653  return std::string("photon");
654  }
655  return std::string("unknown");
656  }
657 
659  if(pt == Proton) {
660  return protonMass;
661  } else if(pt == Neutron) {
662  return neutronMass;
663  } else if(pt == PiPlus) {
664  return piPlusMass;
665  } else if(pt == PiMinus) {
666  return piMinusMass;
667  } else if(pt == PiZero) {
668  return piZeroMass;
669  } else if(pt == SigmaPlus) {
670  return SigmaPlusMass;
671  } else if(pt == SigmaMinus) {
672  return SigmaMinusMass;
673  } else if(pt == SigmaZero) {
674  return SigmaZeroMass;
675  } else if(pt == Lambda) {
676  return LambdaMass;
677  } else if(pt == KPlus) {
678  return KPlusMass;
679  } else if(pt == KZero) {
680  return KZeroMass;
681  } else if(pt == KZeroBar) {
682  return KZeroBarMass;
683  } else if(pt == KMinus) {
684  return KMinusMass;
685  } else if(pt == KShort) {
686  return KShortMass;
687  } else if(pt == KLong) {
688  return KLongMass;
689  } else if(pt == Eta) {
690  return etaMass;
691  } else if(pt == Omega) {
692  return omegaMass;
693  } else if(pt == EtaPrime) {
694  return etaPrimeMass;
695  } else if(pt == Photon) {
696  return photonMass;
697  } else {
698  INCL_ERROR("getMass : Unknown particle type." << '\n');
699  return 0.0;
700  }
701  }
702 
704  switch(t) {
705  case Proton:
706  return theRealProtonMass;
707  break;
708  case Neutron:
709  return theRealNeutronMass;
710  break;
711  case PiPlus:
712  case PiMinus:
713  return theRealChargedPiMass;
714  break;
715  case PiZero:
716  return theRealPiZeroMass;
717  break;
718  case SigmaPlus:
719  return theRealSigmaPlusMass;
720  break;
721  case SigmaZero:
722  return theRealSigmaZeroMass;
723  break;
724  case SigmaMinus:
725  return theRealSigmaMinusMass;
726  break;
727  case Lambda:
728  return theRealLambdaMass;
729  break;
730  case KPlus:
731  case KMinus:
732  return theRealChargedKaonMass;
733  break;
734  case KZero:
735  case KZeroBar:
736  case KShort:
737  case KLong:
738  return theRealNeutralKaonMass;
739  case Eta:
740  return theRealEtaMass;
741  break;
742  case Omega:
743  return theRealOmegaMass;
744  break;
745  case EtaPrime:
746  return theRealEtaPrimeMass;
747  break;
748  case Photon:
749  return theRealPhotonMass;
750  break;
751  default:
752  INCL_ERROR("Particle::getRealMass : Unknown particle type." << '\n');
753  return 0.0;
754  break;
755  }
756  }
757 
758  G4double getRealMass(const G4int A, const G4int Z) {
759 // assert(A>=0);
760  // For nuclei with Z<0 or Z>A, assume that the exotic charge state is due to pions
761  if(Z<0)
762  return A*neutronMass - Z*getRealMass(PiMinus);
763  else if(Z>A)
764  return A*protonMass + (A-Z)*getRealMass(PiPlus);
765  else if(Z==0)
766  return A*getRealMass(Neutron);
767  else if(A==Z)
768  return A*getRealMass(Proton);
769  else if(A>1) {
770 #ifndef INCLXX_IN_GEANT4_MODE
771  return ::G4INCL::NuclearMassTable::getMass(A,Z);
772 #else
773  return theG4IonTable->GetNucleusMass(Z,A) / MeV;
774 #endif
775  } else
776  return 0.;
777  }
778 
779  G4double getINCLMass(const G4int A, const G4int Z) {
780 // assert(A>=0);
781  // For nuclei with Z<0 or Z>A, assume that the exotic charge state is due to pions
782  if(Z<0)
783  return A*neutronMass - Z*getINCLMass(PiMinus);
784  else if(Z>A)
785  return A*protonMass + (A-Z)*getINCLMass(PiPlus);
786  else if(A>1)
787  return Z*(protonMass - protonSeparationEnergy) + (A-Z)*(neutronMass - neutronSeparationEnergy);
788  else if(A==1 && Z==0)
789  return getINCLMass(Neutron);
790  else if(A==1 && Z==1)
791  return getINCLMass(Proton);
792  else
793  return 0.;
794  }
795 
796  G4double getTableQValue(const G4int A1, const G4int Z1, const G4int A2, const G4int Z2) {
797  return getTableMass(A1,Z1) + getTableMass(A2,Z2) - getTableMass(A1+A2,Z1+Z2);
798  }
799 
800  G4double getTableQValue(const G4int A1, const G4int Z1, const G4int A2, const G4int Z2, const G4int A3, const G4int Z3) {
801  return getTableMass(A1,Z1) + getTableMass(A2,Z2) - getTableMass(A3,Z3) - getTableMass(A1+A2-A3,Z1+Z2-Z3);
802  }
803 
805  if(p.theType == Composite)
806  return (*getTableMass)(p.theA, p.theZ);
807  else
808  return (*getTableParticleMass)(p.theType);
809  }
810 
812  switch(t) {
813  case Proton:
814  case Neutron:
815  case DeltaPlusPlus:
816  case DeltaPlus:
817  case DeltaZero:
818  case DeltaMinus:
819  case SigmaPlus:
820  case SigmaZero:
821  case SigmaMinus:
822  case Lambda:
823  return 1;
824  break;
825  case PiPlus:
826  case PiMinus:
827  case PiZero:
828  case KPlus:
829  case KZero:
830  case KZeroBar:
831  case KShort:
832  case KLong:
833  case KMinus:
834  case Eta:
835  case Omega:
836  case EtaPrime:
837  case Photon:
838  return 0;
839  break;
840  default:
841  return 0;
842  break;
843  }
844  }
845 
847  switch(t) {
848  case DeltaPlusPlus:
849  return 2;
850  break;
851  case Proton:
852  case DeltaPlus:
853  case PiPlus:
854  case SigmaPlus:
855  case KPlus:
856  return 1;
857  break;
858  case Neutron:
859  case DeltaZero:
860  case PiZero:
861  case SigmaZero:
862  case Lambda:
863  case KZero:
864  case KZeroBar:
865  case KShort:
866  case KLong:
867  case Eta:
868  case Omega:
869  case EtaPrime:
870  case Photon:
871  return 0;
872  break;
873  case DeltaMinus:
874  case PiMinus:
875  case SigmaMinus:
876  case KMinus:
877  return -1;
878  break;
879  default:
880  return 0;
881  break;
882  }
883  }
884 
886  switch(t) {
887  case DeltaPlusPlus:
888  case DeltaPlus:
889  case DeltaZero:
890  case DeltaMinus:
891  case Proton:
892  case Neutron:
893  case PiPlus:
894  case PiZero:
895  case PiMinus:
896  case Eta:
897  case Omega:
898  case EtaPrime:
899  case Photon:
900  return 0;
901  break;
902  case Lambda:
903  case SigmaPlus:
904  case SigmaZero:
905  case SigmaMinus:
906  case KZeroBar:
907  case KMinus:
908  return -1;
909  break;
910  case KPlus:
911  case KZero:
912  return 1;
913  break;
914  case KShort:
915  return -99;
916  break;
917  case KLong:
918  return 99;
919  break;
920  default:
921  return 0;
922  break;
923  }
924  }
925 
927 // assert(A>=0);
928  if(A >= 19 || (A < 6 && A >= 2)) {
929  // For large (Woods-Saxon or Modified Harmonic Oscillator) or small
930  // (Gaussian) nuclei, the radius parameter is just the nuclear radius
931  return getRadiusParameter(t,A,Z);
932  } else if(A < clusterTableASize && Z>=0 && Z < clusterTableZSize && A >= 6) {
933  const G4double thisRMS = positionRMS[Z][A];
934  if(thisRMS>0.0)
935  return thisRMS;
936  else {
937  INCL_DEBUG("getNuclearRadius: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'
938  << "returning radius for C12");
939  return positionRMS[6][12];
940  }
941  } else if(A < 19) {
942  const G4double theRadiusParameter = getRadiusParameter(t, A, Z);
943  const G4double theDiffusenessParameter = getSurfaceDiffuseness(t, A, Z);
944  // The formula yields the nuclear RMS radius based on the parameters of
945  // the nuclear-density function
946  return 1.225*theDiffusenessParameter*
947  std::sqrt((2.+5.*theRadiusParameter)/(2.+3.*theRadiusParameter));
948  } else {
949  INCL_ERROR("getNuclearRadius: No radius for nucleus A = " << A << " Z = " << Z << '\n');
950  return 0.0;
951  }
952  }
953 
956  }
957 
959 // assert(A>0);
960  if(A > 19) {
961  // phenomenological radius fit
962  G4double r0 = (2.745e-4 * A + 1.063) * std::pow(A, 1.0/3.0);
963  // HFB calculations
964  if(getRPCorrelationCoefficient(t)<1.){
965  G4double r0hfb = HFB::getRadiusParameterHFB(t,A,Z);
966  if(r0hfb>0.)r0 = r0hfb;
967  }
968  //
969  if(t==Neutron)
970  r0 += neutronSkin;
971  return r0;
972  } else if(A < 6 && A >= 2) {
973  if(Z<clusterTableZSize && Z>=0) {
974  const G4double thisRMS = positionRMS[Z][A];
975  if(thisRMS>0.0)
976  return thisRMS;
977  else {
978  INCL_DEBUG("getRadiusParameter: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'
979  << "returning radius for C12");
980  return positionRMS[6][12];
981  }
982  } else {
983  INCL_DEBUG("getRadiusParameter: Radius for nucleus A = " << A << " Z = " << Z << " is not available" << '\n'
984  << "returning radius for C12");
985  return positionRMS[6][12];
986  }
987  } else if(A <= 19 && A >= 6) {
988  return mediumRadius[A-1];
989  // return 1.581*mediumDiffuseness[A-1]*(2.+5.*mediumRadius[A-1])/(2.+3.*mediumRadius[A-1]);
990  } else {
991  INCL_ERROR("getRadiusParameter: No radius for nucleus A = " << A << " Z = " << Z << '\n');
992  return 0.0;
993  }
994  }
995 
997  const G4double XFOISA = 8.0;
998  if(A > 19) {
999  return getNuclearRadius(t,A,Z) + XFOISA * getSurfaceDiffuseness(t,A,Z);
1000  } else if(A <= 19 && A >= 6) {
1001  return 5.5 + 0.3 * (G4double(A) - 6.0)/12.0;
1002  } else if(A >= 2) {
1003  return getNuclearRadius(t, A, Z) + 4.5;
1004  } else {
1005  INCL_ERROR("getMaximumNuclearRadius : No maximum radius for nucleus A = " << A << " Z = " << Z << '\n');
1006  return 0.0;
1007  }
1008  }
1009 
1011  if(A > 19) {
1012  G4double a = 1.63e-4 * A + 0.510;
1013  // HFB calculations
1014  if(getRPCorrelationCoefficient(t)<1.){
1016  if(ahfb>0.)a=ahfb;
1017  }
1018  //
1019  if(t==Neutron)
1020  a += neutronHalo;
1021  return a;
1022  } else if(A <= 19 && A >= 6) {
1023  return mediumDiffuseness[A-1];
1024  } else if(A < 6 && A >= 2) {
1025  INCL_ERROR("getSurfaceDiffuseness: was called for A = " << A << " Z = " << Z << '\n');
1026  return 0.0;
1027  } else {
1028  INCL_ERROR("getSurfaceDiffuseness: No diffuseness for nucleus A = " << A << " Z = " << Z << '\n');
1029  return 0.0;
1030  }
1031  }
1032 
1034 // assert(Z>=0 && A>=0 && Z<=A);
1036  }
1037 
1038  G4double getSeparationEnergyINCL(const ParticleType t, const G4int /*A*/, const G4int /*Z*/) {
1039  if(t==Proton)
1040  return theINCLProtonSeparationEnergy;
1041  else if(t==Neutron)
1042  return theINCLNeutronSeparationEnergy;
1043  else {
1044  INCL_ERROR("ParticleTable::getSeparationEnergyINCL : Unknown particle type." << '\n');
1045  return 0.0;
1046  }
1047  }
1048 
1050  // Real separation energies for all nuclei
1051  if(t==Proton)
1052  return (*getTableParticleMass)(Proton) + (*getTableMass)(A-1,Z-1) - (*getTableMass)(A,Z);
1053  else if(t==Neutron)
1054  return (*getTableParticleMass)(Neutron) + (*getTableMass)(A-1,Z) - (*getTableMass)(A,Z);
1055  else {
1056  INCL_ERROR("ParticleTable::getSeparationEnergyReal : Unknown particle type." << '\n');
1057  return 0.0;
1058  }
1059  }
1060 
1062  // Real separation energies for light nuclei, fixed values for heavy nuclei
1064  return getSeparationEnergyReal(t, A, Z);
1065  else
1066  return getSeparationEnergyINCL(t, A, Z);
1067  }
1068 
1069  G4double getProtonSeparationEnergy() { return protonSeparationEnergy; }
1070 
1071  G4double getNeutronSeparationEnergy() { return neutronSeparationEnergy; }
1072 
1073  void setProtonSeparationEnergy(const G4double s) { protonSeparationEnergy = s; }
1074 
1075  void setNeutronSeparationEnergy(const G4double s) { neutronSeparationEnergy = s; }
1076 
1077  std::string getElementName(const G4int Z) {
1078  if(Z<1) {
1079  INCL_WARN("getElementName called with Z<1" << '\n');
1080  return elementTable[0];
1081  } else if(Z<elementTableSize)
1082  return elementTable[Z];
1083  else
1084  return getIUPACElementName(Z);
1085  }
1086 
1087  std::string getIUPACElementName(const G4int Z) {
1088  std::stringstream elementStream;
1089  elementStream << Z;
1090  std::string elementName = elementStream.str();
1091  std::transform(elementName.begin(), elementName.end(), elementName.begin(), intToIUPAC);
1092  elementName[0] = std::toupper(elementName.at(0));
1093  return elementName;
1094  }
1095 
1096  G4int parseElement(std::string pS) {
1097  // Normalize the element name
1098  std::transform(pS.begin(), pS.end(), pS.begin(), ::tolower);
1099  pS[0] = ::toupper(pS[0]);
1100 
1101  const std::string *iter = std::find(elementTable, elementTable+elementTableSize, pS);
1102  if(iter != elementTable+elementTableSize)
1103  return iter - elementTable;
1104  else
1106  }
1107 
1108  G4int parseIUPACElement(std::string const &s) {
1109  // Normalise to lower case
1110  std::string elementName(s);
1111  std::transform(elementName.begin(), elementName.end(), elementName.begin(), ::tolower);
1112  // Return 0 if the element name contains anything but IUPAC digits
1113  if(elementName.find_first_not_of(elementIUPACDigits)!=std::string::npos)
1114  return 0;
1115  std::transform(elementName.begin(), elementName.end(), elementName.begin(), iupacToInt);
1116  std::stringstream elementStream(elementName);
1117  G4int Z;
1118  elementStream >> Z;
1119  return Z;
1120  }
1121 
1123  return getNaturalIsotopicDistributions()->getIsotopicDistribution(Z);
1124  }
1125 
1127  return getNaturalIsotopicDistributions()->drawRandomIsotope(Z);
1128  }
1129 
1130  G4double getFermiMomentumConstant(const G4int /*A*/, const G4int /*Z*/) {
1131  return constantFermiMomentum;
1132  }
1133 
1135 // assert(Z>0 && A>0 && Z<=A);
1137  const G4double rms = momentumRMS[Z][A];
1138  return ((rms>0.) ? rms : momentumRMS[6][12]) * Math::sqrtFiveThirds;
1139  } else
1140  return getFermiMomentumConstant(A,Z);
1141  }
1142 
1144 // assert(A>0);
1145  static const G4double alphaParam = 259.416; // MeV/c
1146  static const G4double betaParam = 152.824; // MeV/c
1147  static const G4double gammaParam = 9.5157E-2;
1148  return alphaParam - betaParam*std::exp(-gammaParam*((G4double)A));
1149  }
1150 
1152 // assert(t==Proton || t==Neutron);
1153  return rpCorrelationCoefficient[t];
1154  }
1155 
1156  G4double getNeutronSkin() { return neutronSkin; }
1157 
1158  G4double getNeutronHalo() { return neutronHalo; }
1159 
1167 
1169 // assert(isosp == -2 || isosp == 0 || isosp == 2);
1170  if (isosp == -2) {
1171  return PiMinus;
1172  }
1173  else if (isosp == 0) {
1174  return PiZero;
1175  }
1176  else {
1177  return PiPlus;
1178  }
1179  }
1180 
1182 // assert(isosp == -1 || isosp == 1);
1183  if (isosp == -1) {
1184  return Neutron;
1185  }
1186  else {
1187  return Proton;
1188  }
1189  }
1190 
1192 // assert(isosp == -3 || isosp == -1 || isosp == 1 || isosp == 3);
1193  if (isosp == -3) {
1194  return DeltaMinus;
1195  }
1196  else if (isosp == -1) {
1197  return DeltaZero;
1198  }
1199  else if (isosp == 1) {
1200  return DeltaPlus;
1201  }
1202  else {
1203  return DeltaPlusPlus;
1204  }
1205  }
1206 
1207 
1209 // assert(isosp == -2 || isosp == 0 || isosp == 2);
1210  if (isosp == -2) {
1211  return SigmaMinus;
1212  }
1213  else if (isosp == 0) {
1214  return SigmaZero;
1215  }
1216  else {
1217  return SigmaPlus;
1218  }
1219  }
1220 
1222 // assert(isosp == -1 || isosp == 1);
1223  if (isosp == -1) {
1224  return KZero;
1225  }
1226  else {
1227  return KPlus;
1228  }
1229  }
1230 
1232 // assert(isosp == -1 || isosp == 1);
1233  if (isosp == -1) {
1234  return KMinus;
1235  }
1236  else {
1237  return KZeroBar;
1238  }
1239  }
1240 
1242 // 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);
1243  if(pt == PiPlus) {
1244  return piPlusWidth;
1245  } else if(pt == PiMinus) {
1246  return piMinusWidth;
1247  } else if(pt == PiZero) {
1248  return piZeroWidth;
1249  } else if(pt == Eta) {
1250  return etaWidth;
1251  } else if(pt == Omega) {
1252  return omegaWidth;
1253  } else if(pt == EtaPrime) {
1254  return etaPrimeWidth;
1255  } else if(pt == SigmaPlus) {
1256  return SigmaPlusWidth;
1257  } else if(pt == SigmaZero) {
1258  return SigmaZeroWidth;
1259  } else if(pt == SigmaMinus) {
1260  return SigmaMinusWidth;
1261  } else if(pt == KPlus) {
1262  return KPlusWidth;
1263  } else if(pt == KMinus) {
1264  return KMinusWidth;
1265  } else if(pt == KShort) {
1266  return KShortWidth;
1267  } else if(pt == KLong) {
1268  return KLongWidth;
1269  } else {
1270  INCL_ERROR("getWidth : Unknown particle type." << '\n');
1271  return 0.0;
1272  }
1273  }
1274 
1275  } // namespace ParticleTable
1276 } // namespace G4INCL
1277 
G4ParticleDefinition * FindParticle(G4int PDGEncoding)
G4double getSeparationEnergyReal(const ParticleType t, const G4int A, const G4int Z)
Return the real separation energy.
G4double getLargestNuclearRadius(const G4int A, const G4int Z)
const G4double effectiveDeltaMass
T max(const T t1, const T t2)
brief Return the largest of the two arguments
IsotopicDistribution const & getNaturalIsotopicDistribution(const G4int Z)
G4int parseIUPACElement(std::string const &pS)
Parse a IUPAC element name.
void setProtonSeparationEnergy(const G4double s)
Setter for protonSeparationEnergy.
G4double getWidth(const ParticleType t)
Get particle width (in s)
G4double getRadiusParameter(const ParticleType t, const G4int A, const G4int Z)
G4bool getUseRealMasses() const
Whether to use real masses.
std::vector< ExP01TrackerHit * > a
Definition: ExP01Classes.hh:33
void setNeutronSeparationEnergy(const G4double s)
Setter for protonSeparationEnergy.
std::string getElementName(const G4int Z)
Get the name of the element from the atomic number.
ParticleType getNucleonType(const G4int isosp)
Get the type of nucleon.
static G4ParticleTable * GetParticleTable()
static constexpr double MeV
Definition: G4SIunits.hh:214
G4double getMomentumRMS(const G4int A, const G4int Z)
Return the RMS of the momentum distribution (light clusters)
G4ThreadLocal FermiMomentumFn getFermiMomentum
G4double getFermiMomentumConstantLight(const G4int A, const G4int Z)
Return the constant value of the Fermi momentum - special for light.
G4double getSurfaceDiffusenessHFB(const ParticleType t, const G4int A, const G4int Z)
Definition: G4INCLHFB.cc:558
#define INCL_DEFAULT_SEPARATION_ENERGY
ParticleType getAntiKaonType(const G4int isosp)
Get the type of antikaon.
G4double(* FermiMomentumFn)(const G4int, const G4int)
const char * p
Definition: xmltok.h:285
std::string const & getINCLXXDataFilePath() const
G4int getChargeNumber(const ParticleType t)
Get charge number from particle type.
std::string getIUPACElementName(const G4int Z)
Get the name of an unnamed element from the IUPAC convention.
G4double getNeutronHalo()
Get the size of the neutron halo.
G4IonTable * GetIonTable() const
Functions that encapsulate a mass table.
G4int drawRandomNaturalIsotope(const G4int Z)
G4double getRPCorrelationCoefficient(const ParticleType t)
Get the value of the r-p correlation coefficient.
#define G4ThreadLocal
Definition: tls.hh:69
G4double GetPDGMass() const
G4int getStrangenessNumber(const ParticleType t)
Get strangeness number from particle type.
ParticleType getDeltaType(const G4int isosp)
Get the type of delta.
G4double getRealMass(const G4INCL::ParticleType t)
Get particle mass (in MeV/c^2)
#define INCL_DEBUG(x)
Float_t Z
G4int getMassNumber(const ParticleType t)
Get mass number from particle type.
const G4double Pf
Fermi momentum [MeV/c].
const XML_Char * s
Definition: expat.h:262
G4double getMaximumNuclearRadius(const ParticleType t, const G4int A, const G4int Z)
double G4double
Definition: G4Types.hh:76
Class that stores isotopic abundances for a given element.
G4double(* SeparationEnergyFn)(const ParticleType, const G4int, const G4int)
G4double getNeutronSkin()
Get the thickness of the neutron skin.
G4ThreadLocal NuclearMassFn getTableMass
Static pointer to the mass function for nuclei.
G4double(* NuclearMassFn)(const G4int, const G4int)
G4double getRPCorrelationCoefficient(const ParticleType t) const
Get the r-p correlation coefficient.
G4double getSurfaceDiffuseness(const ParticleType t, const G4int A, const G4int Z)
#define INCL_ERROR(x)
G4double getINCLMass(const G4int A, const G4int Z)
Get INCL nuclear mass (in MeV/c^2)
G4double getTableSpeciesMass(const ParticleSpecies &p)
G4double getNeutronSeparationEnergy()
Getter for neutronSeparationEnergy.
void initialize(Config const *const theConfig)
Initialize the clustering model based on the Config object.
TMarker * pt
Definition: egs.C:25
double A(double temperature)
ParticleType getKaonType(const G4int isosp)
Get the type of kaon.
const G4double sqrtThreeFifths
G4double(* ParticleMassFn)(const ParticleType)
G4double getNeutronSkin() const
Get the neutron-skin thickness.
G4double getRadiusParameterHFB(const ParticleType t, const G4int A, const G4int Z)
Get the radius and diffuseness parameters from HFB calculations.
Definition: G4INCLHFB.cc:548
G4double getSeparationEnergyINCL(const ParticleType t, const G4int, const G4int)
Return INCL&#39;s default separation energy.
std::string getName(const ParticleType t)
Get the native INCL name of the particle.
Double_t Z2
Double_t Z1
const G4double effectiveDeltaWidth
#define INCL_WARN(x)
int G4int
Definition: G4Types.hh:78
G4double getTableQValue(const G4int A1, const G4int Z1, const G4int A2, const G4int Z2)
Get Q-value (in MeV/c^2)
std::string getShortName(const ParticleType t)
Get the short INCL name of the particle.
SeparationEnergyType getSeparationEnergyType() const
Get the separation-energy type.
#define INCL_FATAL(x)
G4double getNeutronHalo() const
Get the neutron-halo size.
G4int getIsospin(const ParticleType t)
Get the isospin of a particle.
G4double getFermiMomentum() const
Get the Fermi momentum.
G4double getFermiMomentumConstant(const G4int, const G4int)
Return the constant value of the Fermi momentum.
ParticleType getSigmaType(const G4int isosp)
Get the type of sigma.
G4ThreadLocal G4double minDeltaMass2
G4ThreadLocal SeparationEnergyFn getSeparationEnergy
Static pointer to the separation-energy function.
const G4double sqrtFiveThirds
G4double getFermiMomentumMassDependent(const G4int A, const G4int)
Return the value Fermi momentum from a fit.
Char_t n[5]
FermiMomentumType getFermiMomentumType() const
Get the Fermi-momentum type.
G4double getSeparationEnergyRealForLight(const ParticleType t, const G4int A, const G4int Z)
Return the real separation energy only for light nuclei.
G4ThreadLocal ParticleMassFn getTableParticleMass
Static pointer to the mass function for particles.
G4int parseElement(std::string pS)
Get the name of the element from the atomic number.
void initialize(Config const *const theConfig=0)
Initialize the particle table.
G4double getProtonSeparationEnergy()
Getter for protonSeparationEnergy.
ParticleType getPionType(const G4int isosp)
Get the type of pion.
G4double getNuclearRadius(const ParticleType t, const G4int A, const G4int Z)
G4ThreadLocal G4double minDeltaMassRndm
G4ThreadLocal G4double minDeltaMass