Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4QPDGCode.cc
Go to the documentation of this file.
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//
27// $Id$
28//
29// ---------------- G4QPDGCode ----------------
30// by Mikhail Kossov, Sept 1999.
31// class for Hadron definitions in CHIPS Model
32// -------------------------------------------------------------------
33// Short description: The PDG Code is made on the basis of the Quark
34// Content (G4QuarkContent) of the hadronic state (including nuclear
35// fragments). The PDG code of the ground state (e.g. pi, N, etc.) is
36// calculated. It includes a complicated algortithm of the G.S. mass
37// calculation for nuclear fragments (now it is synchronised with the
38// G4 nuclear massess).
39// -------------------------------------------------------------------
40
41//#define debug
42//#define pdebug
43//#define qdebug
44//#define idebug
45//#define sdebug
46
47#include <cmath>
48#include <cstdlib>
49
50#include "G4QPDGCodeVector.hh"
51
52using namespace std;
53
54G4QPDGCode::G4QPDGCode(G4int PDGCode): thePDGCode(PDGCode)
55{
56#ifdef sdebug
57 G4cout<<"G4QPDGCode:Constructer is called with PDGCode="<<PDGCode<<G4endl;
58#endif
59 if(PDGCode==130) PDGCode= 311; // Safety. Should not happen.
60 if(PDGCode==310) PDGCode=-311; // Safety. Should not happen.
61 if(PDGCode==90000000)
62 {
63 thePDGCode=22;
64 theQCode=6;
65 }
66 else if(PDGCode) theQCode=MakeQCode(PDGCode);
67 else
68 {
69#ifdef sdebug
70 G4cout<<"***G4QPDGCode: Constructed with PDGCode=0, QCode=-2"<<G4endl;
71#endif
72 theQCode=-2;
73 }
74#ifdef debug
75 if(PDGCode==3222)G4cout<<"G4QPDGCd:Con(PDG) PDG="<<PDGCode<<", QCode="<<theQCode<<G4endl;
76#endif
77}
78
79G4QPDGCode::G4QPDGCode(G4bool f, G4int QCode): theQCode(QCode)
80{
81 if(f&&QCode<0)G4cerr<<"***G4QPDGCode::Constr. QCode="<<QCode<<G4endl;
82 thePDGCode = MakePDGCode(QCode);
83#ifdef debug
84 G4cout<<"G4QPDGCode::Constr: PDGCode="<<thePDGCode<<G4endl;
85#endif
86}
87
88G4QPDGCode::G4QPDGCode(G4QContent QCont)
89{
90 InitByQCont(QCont);
91}
92
93G4QPDGCode::G4QPDGCode(const G4QPDGCode& rhs)
94{
95 thePDGCode =rhs.thePDGCode;
96 theQCode =rhs.theQCode;
97}
98
99G4QPDGCode::G4QPDGCode(G4QPDGCode* rhs)
100{
101 thePDGCode =rhs->thePDGCode;
102 theQCode =rhs->theQCode;
103}
104
105const G4QPDGCode& G4QPDGCode::operator=(const G4QPDGCode& rhs)
106{
107 if(this != &rhs) // Beware of self assignment
108 {
109 thePDGCode =rhs.thePDGCode;
110 theQCode =rhs.theQCode;
111 }
112 return *this;
113}
114
115G4QPDGCode::~G4QPDGCode() {}
116
117// Standard output for QPDGCode
118ostream& operator<<(ostream& lhs, G4QPDGCode& rhs)
119{
120 lhs << "[ PDG=" << rhs.GetPDGCode() << ", Q=" << rhs.GetQCode() << "]";
121 return lhs;
122}
123
124// Standard output for const QPDGCode
125ostream& operator<<(ostream& lhs, const G4QPDGCode& rhs)
126{
127 lhs << "[ PDG=" << rhs.GetPDGCode() << ", Q=" << rhs.GetQCode() << "]";
128 return lhs;
129}
130
131// Overloading of QPDGCode addition
132G4int operator+(const G4QPDGCode& lhs, const G4QPDGCode& rhs)
133{
134 G4int s_value = lhs.GetPDGCode();
135 return s_value += rhs.GetPDGCode();
136}
137G4int operator+(const G4QPDGCode& lhs, const G4int& rhs)
138{
139 G4int s_value = lhs.GetPDGCode();
140 return s_value += rhs;
141}
142G4int operator+(const G4int& lhs, const G4QPDGCode& rhs)
143{
144 G4int s_value = lhs;
145 return s_value += rhs.GetPDGCode();
146}
147
148// Overloading of QPDGCode subtraction
149G4int operator-(const G4QPDGCode& lhs, const G4QPDGCode& rhs)
150{
151 G4int s_value = lhs.GetPDGCode();
152 return s_value -= rhs.GetPDGCode();
153}
154G4int operator-(const G4QPDGCode& lhs, const G4int& rhs)
155{
156 G4int s_value = lhs.GetPDGCode();
157 return s_value -= rhs;
158}
159G4int operator-(const G4int& lhs, const G4QPDGCode& rhs)
160{
161 G4int s_value = lhs;
162 return s_value -= rhs.GetPDGCode();
163}
164
165// Overloading of QPDGCode multiplication
166G4int operator*(const G4QPDGCode& lhs, const G4QPDGCode& rhs)
167{
168 G4int s_value = lhs.GetPDGCode();
169 return s_value *= rhs.GetPDGCode();
170}
171
172G4int operator*(const G4QPDGCode& lhs, const G4int& rhs)
173{
174 G4int s_value = lhs.GetPDGCode();
175 return s_value *= rhs;
176}
177
178G4int operator*(const G4int& lhs, const G4QPDGCode& rhs)
179{
180 G4int s_value = lhs;
181 return s_value *= rhs.GetPDGCode();
182}
183
184// Overloading of QPDGCode division
185G4int operator/(const G4QPDGCode& lhs, const G4QPDGCode& rhs)
186{
187 G4int s_value = lhs.GetPDGCode();
188 return s_value /= rhs.GetPDGCode();
189}
190
191G4int operator/(const G4QPDGCode& lhs, const G4int& rhs)
192{
193 G4int s_value = lhs.GetPDGCode();
194 return s_value /= rhs;
195}
196
197G4int operator/(const G4int& lhs, const G4QPDGCode& rhs)
198{
199 G4int s_value = lhs;
200 return s_value /= rhs.GetPDGCode();
201}
202
203// Overloading of QPDGCode residual
204G4int operator%(const G4QPDGCode& lhs, const G4int& rhs)
205{
206 G4int s_value = lhs.GetPDGCode();
207 return s_value %= rhs;
208}
209
210// TRUE if it is not RealNeutral (111,221,331 etc), FALSE if it is.
211G4bool G4QPDGCode::TestRealNeutral(const G4int& PDGCode)
212{
213 if(PDGCode>0 && PDGCode<999) // RealNeutral are always positive && mesons
214 {
215 if(PDGCode==22) return false; // Photon
216 G4int p=PDGCode/10;
217 if(p/10==p%10) return false; // This is a RealNeutral
218 }
219 return true;
220}
221
222// Make a Q Code out of the PDG Code
223G4int G4QPDGCode::MakePDGCode(const G4int& QCode)
224{
225 //static const G4int modi = 81; // Q Codes for more than di-baryon nuclei
226 //static const G4int modi = 89; // Q Codes for more than di-baryon nuclei "IsoNuclei"
227 //static const G4int modi = 122; // Q Codes: more than quarta-baryon nuclei "Lept/Hyper"
228 static const G4int modi = 85; // Reduced Q Codes: > quarta-baryon nuclei "Lept/Hyper"
229 //static G4int qC[modi]={ 11, 12, 13, 14, 15, 16, 22, 23, 24, 25, // 10
230 // 37, 110, 220, 330, 111, 211, 221, 311, 321, 331, // 20
231 // 2112, 2212, 3122, 3112, 3212, 3222, 3312, 3322, 113, 213, // 30
232 // 223, 313, 323, 333, 1114, 2114, 2214, 2224, 3124, 3114, // 40
233 // 3214, 3224, 3314, 3324, 3334, 115, 215, 225, 315, 325, // 50
234 // 335, 2116, 2216, 3126, 3116, 3216, 3226, 3316, 3326, 117, // 60
235 // 217, 227, 317, 327, 337, 1118, 2118, 2218, 2228, 3128, // 70
236 // 3118, 3218, 3228, 3318, 3328, 3338, 119, 219, 229, 319, // 80
237 // 329, 339, 90002999 , 89999003 , 90003998 ,
238 // 89998004 , 90003999 , 89999004 , 90004998 , 89998005 , // 90
239 // 90000001 , 90001000 , 91000000 , 90999001 , 91000999 ,
240 // 91999000 , 91999999 , 92999000 , 90000002 , 90001001 , //100
241 // 90002000 , 91000001 , 91001000 , 92000000 , 90999002 ,
242 // 91001999 , 90001002 , 90002001 , 91000002 , 91001001 , //110
243 // 91002000 , 92000001 , 92001000 , 90999003 , 90001003 ,
244 // 90002002 , 90003001 , 91001002 , 91002001 , 92000002 , //120
245 // 92001001 , 92002000}; //122
246 static G4int qC[modi] ={ 11, 12, 13, 14, 15, 16, 22, 23, 24, 25, // 10
247 37, 110, 220, 330, 111, 211, 221, 311, 321, 331, // 20
248 2112, 2212, 3122, 3112, 3212, 3222, 3312, 3322, 113, 213, // 30
249 223, 313, 323, 333, 1114, 2114, 2214, 2224, 3124, 3114, // 40
250 3214, 3224, 3314, 3324, 3334, // 45
251 90002999 , 89999003 , 90003998 , 89998004 , 90003999 , // 50
252 89999004 , 90004998 , 89998005 , 90000001 , 90001000 , // 55
253 91000000 , 90999001 , 91000999 , 91999000 , 91999999 , // 60
254 92999000 , 90000002 , 90001001 , 90002000 , 91000001 , // 65
255 91001000 , 92000000 , 90999002 , 91001999 , 90001002 , // 70
256 90002001 , 91000002 , 91001001 , 91002000 , 92000001 , // 75
257 92001000 , 90999003 , 90001003 , 90002002 , 90003001 , // 80
258 91001002 , 91002001 , 92000002 , 92001001 , 92002000}; // 85
259 static G4int aC[15] = {1,1000,999001,1000000,1000999,1999000,1999999, // sum 1
260 2,1001,2000,1000001,1001000,1999001,2000000,2000999}; // sum 2
261 if (QCode<0)
262 {
263 G4cerr<<"***G4QPDGCode::MakePDGCode: negative Q Code ="<<QCode<<G4endl;
264 return 0;
265 }
266 else if (QCode>=modi)
267 {
268 //G4int q=QCode-modi; // Starting BarNum=3
269 //G4int a=q/15+1; // BarNum/2
270 //G4int b=q%15;
271 G4int q=QCode-modi; // Starting BarNum=5
272 G4int a=q/15+2; // BarNum/2
273 G4int b=q%15;
274 return 90000000+a*1001+aC[b];
275 }
276 return qC[theQCode];
277}
278
279// Hadronic masses synhronized with the Geant4 hadronic masses
280G4double G4QPDGCode:: QHaM(G4int nQ)
281{
282 static G4bool iniFlag=true;
283 //static G4double mass[nQHM]={.511,0.,105.65837, 0., 1777., 0., 0., 91188., 80403., 140.00
284 //,120.000, 800., 980., 1370., 134.98, 139.57, 547.51, 497.65, 493.68, 957.78
285 //,939.5654,938.272, 1115.683, 1197.45, 1192.64, 1189.37,1321.31,1314.83, 775.5, 775.5
286 //, 782.65, 896.0, 891.66, 1019.46, 1232., 1232., 1232., 1232., 1519.5, 1387.2
287 //, 1383.7, 1382.8, 1535., 1531.8, 1672.45, 1318.3, 1318.3, 1275.4, 1432.4, 1425.6
288 //, 1525., 1680., 1680., 1820., 1915., 1915., 1915., 2025., 2025., 1691.
289 //, 1691., 1667., 1776., 1776., 1854., 1950., 1950., 1950., 1950., 2100.
290 //, 2030., 2030., 2030., 2127., 2127., 2252., 2020., 2020., 2044., 2045.
291 //, 2045., 2297., 2170.272, 2171.565, 2464., 2464., 3108.544, 3111.13,3402.272,3403.565};
292 // Reduced:
293 static G4double mass[nQHM]={.511, 0., 105.65837, 0., 1777., 0., 0., 91188., 80403., 140.00
294 ,120.000, 800., 980., 1370., 134.98, 139.57, 547.51, 497.65, 493.68, 957.78
295 ,939.5654,938.272, 1115.683, 1197.45, 1192.64, 1189.37,1321.31,1314.83, 775.5, 775.5
296 , 782.65, 896.0, 891.66, 1019.46, 1232., 1232., 1232., 1232., 1519.5, 1387.2
297 , 1383.7, 1382.8, 1535., 1531.8, 1672.45,2170.272,2171.565, 2464., 2464.,3108.544
298 ,3111.13,3402.272, 3403.565};
299 if(iniFlag) // Initialization of the Geant4 hadronic masses
300 {
301 mass[ 0]= G4Electron::Electron()->GetPDGMass();
302 mass[ 1]= G4NeutrinoE::NeutrinoE()->GetPDGMass();
303 mass[ 2]= G4MuonMinus::MuonMinus()->GetPDGMass();
304 mass[ 3]= G4NeutrinoMu::NeutrinoMu()->GetPDGMass();
305 mass[ 4]= G4TauMinus::TauMinus()->GetPDGMass();
306 mass[ 5]=G4NeutrinoTau::NeutrinoTau()->GetPDGMass();
307 mass[14]= G4PionZero::PionZero()->GetPDGMass();
308 mass[15]= G4PionMinus::PionMinus()->GetPDGMass();
309 mass[16]= G4Eta::Eta()->GetPDGMass();
310 mass[17]= G4KaonZero::KaonZero()->GetPDGMass();
311 mass[18]= G4KaonMinus::KaonMinus()->GetPDGMass();
312 mass[19]= G4EtaPrime::EtaPrime()->GetPDGMass();
313 mass[20]= G4Neutron::Neutron()->GetPDGMass();
314 mass[21]= G4Proton::Proton()->GetPDGMass();
315 mass[22]= G4Lambda::Lambda()->GetPDGMass();
316 mass[23]= G4SigmaMinus::SigmaMinus()->GetPDGMass();
317 mass[24]= G4SigmaZero::SigmaZero()->GetPDGMass();
318 mass[25]= G4SigmaPlus::SigmaPlus()->GetPDGMass();
319 mass[26]= G4XiMinus::XiMinus()->GetPDGMass();
320 mass[27]= G4XiZero::XiZero()->GetPDGMass();
321 mass[44]= G4OmegaMinus::OmegaMinus()->GetPDGMass();
322 iniFlag=false;
323 }
324 if(nQ<0 || nQ>=nQHM)
325 {
326 G4cout<<"***G4QPDGCode::QHaM: negative Q-code or Q="<<nQ<<" >= nQmax = "<<nQHM<<G4endl;
327 return 0.;
328 }
329 return mass[nQ];
330}
331
332// Make a Q Code out of the PDG Code
333G4int G4QPDGCode::MakeQCode(const G4int& PDGCode)
334{
335 static const G4int qr[10]={0,13,19,27,33,44,50,58,64,75};
336 G4int PDGC=abs(PDGCode); // Qcode is always not negative
337 G4int s_value=0;
338 G4int z=0;
339 G4int n=0;
340 if (PDGC>100000000) // Not supported
341 {
342#ifdef debug
343 G4cout<<"***G4QPDGCode::MakeQCode: Unknown in Q-System code: "<<PDGCode<<G4endl;
344#endif
345 return -2;
346 }
347 else if (PDGC>80000000 && PDGC<100000000) // Try to convert the NUCCoding to PDGCoding
348 {
349 //if(PDGC==90000000) return 6; // @@ already done in the constructor
350 ConvertPDGToZNS(PDGC, z, n, s_value);
351 G4int b=n+z+s_value; // Baryon number
352#ifdef debug
353 G4cout<<"***G4QPDGCode::Z="<<z<<",N="<<n<<",S="<<s_value<<G4endl;
354#endif
355 if(b<0) // ---> Baryons & Fragments
356 {
357 b=-b;
358 n=-n;
359 z=-z;
360 s_value=-s_value;
361 PDGC=90000000+s_value*1000000+z*1000+n; // New PDGC for anti-baryons
362 }
363 else if(!b) // --> Mesons
364 {
365 //G4bool anti=false; // For the PDG conversion
366 if(z<0) // --> Mesons conversion
367 {
368 n=-n;
369 z=-z;
370 s_value=-s_value;
371 //anti=true; // For the PDG conversion
372 }
373 if(!z)
374 {
375 if(s_value>0)
376 {
377 n=-n;
378 s_value=-s_value;
379 //anti=true; // For the PDG conversion
380 }
381 if (s_value==-1) return 17; // K0
382 else if(s_value==-2) return -1; // K0+K0 chipolino
383 else return -2; // Not supported by Q Code
384 }
385 else // --> z>0
386 {
387 if(z==1)
388 {
389 if (s_value==-1) return 18; // K+
390 else return 15; // pi+
391 }
392 else if(z==2) return -1; // Chipolino
393 else return -2; // Not supported by Q Code
394 }
395 } // End of meson case
396 if(b>0) // --> Baryoniums case
397 {
398 if(b==1) // --> Baryons+Hyperons
399 {
400 if(PDGC>80000000)
401 {
402 if(!s_value) // --> Baryons
403 {
404 if (!z) return 53; // neutron
405 else if(z==1)return 54; // proton
406 else return -2; // Not supported by Q Code
407 }
408 else if(s_value==1) // --> Hyperons
409 {
410 if(z==-1) return 56; // Sigma-
411 else if(!z) return 55; // Lambda
412 else if(z==1)return 57; // Sigma+
413 else return -2; // Not supported by Q Code
414 }
415 else if(s_value==2) // --> Xi Hyperons
416 {
417 if(z==-1) return 58; // Xi-
418 else if(!z) return 59; // Xi0
419 else return -2; // Not supported by Q Code
420 }
421 else if(s_value==3) // --> Xi Hyperons
422 {
423 if(z==-1) return 60; // Omega-
424 else return -2; // Not supported by Q Code
425 }
426 }
427 else
428 {
429 if(!s_value) // --> Baryons
430 {
431 if(z==-1) return 34; // Delta-
432 else if(!z) return 20; // neutron
433 else if(z==1)return 21; // proton
434 else if(z==2)return 37; // Delta++
435 else if(z==3||z==-2)return -1; // Delta+pi Chipolino
436 else return -2; // Not supported by Q Code
437 }
438 else if(s_value==1) // --> Hyperons
439 {
440 if(z==-1) return 23; // Sigma-
441 else if(!z) return 22; // Lambda (@@ 24->Sigma0)
442 else if(z==1)return 25; // Sigma+
443 else if(z==2||z==-2) return -1; // Sigma+pi Chipolino
444 else return -2; // Not supported by Q Code
445 }
446 else if(s_value==2) // --> Xi Hyperons
447 {
448 if(z==-1) return 26; // Xi-
449 else if(!z) return 27; // Xi0
450 else if(z==1||z==-2)return -1; // Xi+pi Chipolino
451 else return -2; // Not supported by Q Code
452 }
453 else if(s_value==3) // --> Xi Hyperons
454 {
455 if(z==-1) return 44; // Omega-
456 else if(!z||z==-2) return -1; // Omega+pi Chipolino
457 else return -2; // Not supported by Q Code
458 }
459 }
460 }
461 else
462 {
463 if(b==2)
464 {
465 if (PDGC==90002999) return 45; // p DEL++
466 else if(PDGC==89999003) return 46; // n DEL-
467 else if(PDGC==90003998) return 47; // DEL++ DEL++
468 else if(PDGC==89998004) return 48; // DEL- DEL-
469 else if(PDGC==90999002) return 67; // n Sigma-
470 else if(PDGC==91001999) return 68; // p Sigma+
471 }
472 if(b==3)
473 {
474 if (PDGC==90003999) return 49; // p p DEL++
475 else if(PDGC==89999004) return 50; // n n DEL-
476 else if(PDGC==90004998) return 51; // p DEL++ DEL++
477 else if(PDGC==89998005) return 52; // n DEL- DEL-
478 else if(PDGC==90999003) return 76; // n n Sigma-
479 }
480 }
481 }
482 }
483 if (PDGC<80000000) // ----> Direct Baryons & Mesons
484 {
485 if (PDGC<100) // => Leptons and field bosons
486 {
487 if (PDGC==10) return -1; // Chipolino
488 else if(PDGC==11) return 0; // e-
489 else if(PDGC==12) return 1; // nu_e
490 else if(PDGC==13) return 2; // mu-
491 else if(PDGC==14) return 3; // nu_mu
492 else if(PDGC==15) return 4; // tau-
493 else if(PDGC==16) return 5; // nu_tau
494 else if(PDGC==22) return 6; // Photon
495 else if(PDGC==23) return 7; // Z0 boson
496 else if(PDGC==24) return 8; // W- boson
497 else if(PDGC==25) return 9; // H0 (neutral Higs boson)
498 else if(PDGC==37) return 10; // H- (charged Higs boson)
499 }
500 G4int r=PDGC%10; // 2s+1
501 G4int Q= 0;
502 if (!r)
503 {
504 // Internal CHIPS codes for the wide f_0 states must be 9000221, 9010221, 10221
505 if (PDGC==110) return 11; // Low R-P: Sigma (pi,pi S-wave)
506 else if(PDGC==220) return 12; // Midle Regeon-Pomeron
507 else if(PDGC==330) return 13; // High Regeon-Pomeron
508#ifdef debug
509 G4cout<<"***G4QPDGCode::MakeQCode: (0) Unknown in Q-System code: "<<PDGCode<<G4endl;
510#endif
511 return -2;
512 }
513 else Q=qr[r];
514 G4int p=PDGC/10; // Quark Content
515 if(r%2) // (2s+1 is odd) Mesons
516 {
517 if (p==11) return Q+=1;
518 else if(p==21) return Q+=2;
519 else if(p==22) return Q+=3;
520 else if(p==31) return Q+=4;
521 else if(p==32) return Q+=5;
522 else if(p==33) return Q+=6;
523 else
524 {
525#ifdef debug
526 G4cout<<"*Warning*G4QPDGCode::MakeQCode:(1)UnknownQCode for PDG="<<PDGCode<<G4endl;
527#endif
528 return -2;
529 }
530 }
531 else // (2s+1 is even) Baryons
532 {
533 s_value=r/2;
534 if(s_value%2) // ((2s+1)/2 is odd) N Family
535 {
536 if (p==211) return Q+=1;
537 else if(p==221) return Q+=2;
538 else if(p==312) return Q+=3;
539 else if(p==311) return Q+=4;
540 else if(p==321) return Q+=5;
541 else if(p==322) return Q+=6;
542 else if(p==331) return Q+=7;
543 else if(p==332) return Q+=8;
544 else
545 {
546#ifdef debug
547 G4cout<<"*Warning*G4QPDGCode::MakeQCode:(2) UnknownQCode, PDG="<<PDGCode<<G4endl;
548#endif
549 return -2;
550 }
551 }
552 else // ((2s+1)/2 is odd) Delta Family
553 {
554 if (p==111) return Q+= 1;
555 else if(p==211) return Q+= 2;
556 else if(p==221) return Q+= 3;
557 else if(p==222) return Q+= 4;
558 else if(p==312) return Q+= 5;
559 else if(p==311) return Q+= 6;
560 else if(p==321) return Q+= 7;
561 else if(p==322) return Q+= 8;
562 else if(p==331) return Q+= 9;
563 else if(p==332) return Q+=10;
564 else if(p==333) return Q+=11;
565 else
566 {
567#ifdef debug
568 G4cout<<"**G4QPDGCode::MakeQCode:(3) Unknown in Q-System code:"<<PDGCode<<G4endl;
569#endif
570 return -2;
571 }
572 }
573 }
574 }
575 else // Nuclear Fragments
576 {
577 G4int d=n+n+z+s_value; // a#of d quarks
578 G4int u=n+z+z+s_value; // a#of u quarks
579 G4int t=d+u+s_value; // tot#of quarks
580 if(t%3 || abs(t)<3) // b=0 are in mesons
581 {
582#ifdef debug
583 G4cout<<"***G4QPDGCode::MakeQCode: Unknown PDGCode="<<PDGCode<<", t="<<t<<G4endl;
584#endif
585 return -2;
586 }
587 else
588 {
589 G4int b=t/3; // baryon number
590 if(b==1) // baryons
591 {
592 if (s_value==0&&u==1&&d==2) return 53; // n
593 else if(s_value==0&&u==2&&d==1) return 54; // p
594 else if(s_value==1&&u==1&&d==1) return 55; // Lambda
595 else if(s_value==1&&u==0&&d==2) return 56; // Sigma-
596 else if(s_value==1&&u==2&&d==0) return 57; // Sigma+
597 else if(s_value==2&&u==0&&d==1) return 58; // Xi-
598 else if(s_value==2&&u==1&&d==0) return 59; // Xi0
599 else if(s_value==3&&u==0&&d==0) return 60; // Omega-
600 else
601 {
602#ifdef debug
603 G4cout<<"**G4QPDGCode::MakeQCode:(5) Unknown in Q-System code:"<<PDGCode<<G4endl;
604#endif
605 return -2;
606 }
607 }
608 else if(b==2) // di-baryons
609 {
610 if (s_value==0&&u==2&&d==4) return 61; // nn
611 else if(s_value==0&&u==3&&d==3) return 62; // np
612 else if(s_value==0&&u==4&&d==2) return 63; // pp
613 else if(s_value==1&&u==2&&d==3) return 64; // nLambda
614 else if(s_value==1&&u==3&&d==2) return 65; // pLambda
615 else if(s_value==2&&u==2&&d==2) return 66; // LambdaLambda
616 else
617 {
618#ifdef debug
619 G4cout<<"**G4QPDGCode::MakeQCode:(6) Unknown in Q-System code:"<<PDGCode<<G4endl;
620#endif
621 return -2;
622 }
623 }
624 else if(b==3) // tri-baryons
625 {
626 if (s_value==0&&u==4&&d==5) return 69; // pnn
627 else if(s_value==0&&u==5&&d==4) return 70; // npp
628 else if(s_value==1&&u==3&&d==5) return 71; // Lnn
629 else if(s_value==1&&u==4&&d==4) return 72; // Lnp
630 else if(s_value==1&&u==5&&d==3) return 73; // Lpp
631 else if(s_value==2&&u==3&&d==4) return 74; // LLn
632 else if(s_value==2&&u==4&&d==3) return 75; // LLp
633 else if(s_value==1&&u==2&&d==6) return 76; // nnSigma-
634 else
635 {
636#ifdef debug
637 G4cout<<"**G4QPDGCode::MakeQCode:(7) Unknown in Q-System code:"<<PDGCode<<G4endl;
638#endif
639 return -2;
640 }
641 }
642 G4int c=b/2; // From here b>3: (4,5):c=2,g=0,1; (6,7):c=3,g=0,1; ...
643 G4int g_value=b%2;
644 G4int h=c*3;
645 //G4int Q=57+c*15;
646 //G4int Q=65+c*15; // "IsoNuclei"
647 //G4int Q=83+c*15; // "Leptons/Hyperons"
648 G4int Q=46+c*15; // Reduced "Leptons/Hyperons"
649 u-=h;
650 d-=h;
651 if(g_value)
652 {
653 if (s_value==0&&u==1&&d==2) return Q+= 9;
654 else if(s_value==0&&u==2&&d==1) return Q+=10;
655 else if(s_value==1&&u==0&&d==2) return Q+=11;
656 else if(s_value==1&&u==1&&d==1) return Q+=12;
657 else if(s_value==1&&u==2&&d==0) return Q+=13;
658 else if(s_value==2&&u==0&&d==1) return Q+=14;
659 else if(s_value==2&&u==1&&d==0) return Q+=15;
660 else
661 {
662#ifdef debug
663 G4cout<<"**G4QPDGCode::MakeQCode:(8) Unknown in Q-System code:"<<PDGCode<<G4endl;
664#endif
665 return -2;
666 }
667 }
668 else
669 {
670 if (s_value==0&&u==-1&&d== 1) return Q+=1;
671 else if(s_value==0&&u== 0&&d== 0) return Q+=2;
672 else if(s_value==0&&u== 1&&d==-1) return Q+=3;
673 else if(s_value==1&&u==-1&&d== 0) return Q+=4;
674 else if(s_value==1&&u== 0&&d==-1) return Q+=5;
675 else if(s_value==2&&u==-2&&d== 0) return Q+=6;
676 else if(s_value==2&&u==-1&&d==-1) return Q+=7;
677 else if(s_value==2&&u== 0&&d==-2) return Q+=8;
678 else
679 {
680#ifdef debug
681 G4cout<<"**G4QPDGCode::MakeQCode:(9) Unknown in Q-System code:"<<PDGCode<<G4endl;
682#endif
683 return -2;
684 }
685 }
686 }
687 }
688 G4cout<<"*Warning*G4QPDGCode::MakeQCode:() Unknown Q Code for PDG = "<<PDGCode<<G4endl;
689 return -2; //not reachable statement (fake, only for compiler)
690}
691
692// Get the mean mass value for the PDG
693G4double G4QPDGCode::GetMass()
694{
695 G4int ab=theQCode;
696#ifdef pdebug
697 G4bool pPrint = thePDGCode == 3222 || ab == 25;
698 if(pPrint)
699 G4cout<<"G4QPDGCode::GetMass: Mass for Q="<<ab<<",PDG="<<thePDGCode<<",N="<<nQHM<<G4endl;
700#endif
701 if ( (ab < 0 && thePDGCode < 80000000) || !thePDGCode) {
702#ifdef pdebug
703 if(thePDGCode!=10 && pPrint)
704 G4cout<<"**G4QPDGCode::GetMass:m=100000.,QC="<<theQCode<<",PDG="<<thePDGCode<<G4endl;
705#endif
706 return 100000.;
707 }
708 else if(ab>-1 && ab<nQHM)
709 {
710 G4double mass = QHaM(ab);
711#ifdef pdebug
712 //if(pPrint)
713 if(thePDGCode == 3222 || ab == 25)
714 G4cout<<"G4QPDGCode::GetMa:m="<<mass<<",Q="<<theQCode<<",PDG="<<thePDGCode<<G4endl;
715#endif
716 return mass; // Get mass from the table
717 }
718 //if(szn==0) return m[15]; // @@ mPi0 @@ MK ?
719 if(thePDGCode==90000000)
720 {
721#ifdef pdebug
722 if(pPrint)
723 G4cout<<"G4QPDGCode::GetMass:***m=0, QC="<<theQCode<<",PDG="<<thePDGCode<<G4endl;
724#endif
725 return 0.;
726 }
727 G4int s_value=0;
728 G4int z=0;
729 G4int n=0;
730 ConvertPDGToZNS(thePDGCode, z, n, s_value);
731 G4double m_value=GetNuclMass(z,n,s_value);
732#ifdef pdebug
733 if(pPrint)
734 G4cout<<"G4QPDG::GetM:PDG="<<thePDGCode<<"=>Z="<<z<<",N="<<n<<",S="<<s_value<<",M="<<m_value<<G4endl;
735#endif
736 return m_value;
737}
738
739// Get the width value for the PDG
740G4double G4QPDGCode::GetWidth()
741{
742 //static const int nW = 72;
743 //static const int nW = 80; // "Isobars"
744 //static G4double width[nQHM] = {0.,0.,0.,0.,0.,0.,0.,2.495,2.118,10.
745 // , 10., 800., 75., 350., 0., 0., .00118, 0., 0., .203
746 // , 0., 0., 0., 0., 0., 0., 0., 0., 160., 160.
747 // , 8.41, 50.5, 50.8, 4.43, 120., 120., 120., 120., 15.6, 39.
748 // , 36., 35.8, 10., 9., 0., 107., 107., 185.5, 109., 98.5
749 // , 76., 130., 130., 80., 120., 120., 120., 20., 20., 160.
750 // , 160., 168., 159., 159., 87., 300., 300., 300., 300., 200.
751 // , 180., 180., 180., 99., 99., 55., 387., 387., 208., 198.
752 // , 198., 149., 120., 120., 170., 170., 120., 120., 170., 170.};
753 // Reduced:
754 static G4double width[nQHM] = {0.,0.,0.,0.,0.,0.,0.,2.495,2.118,10.
755 , 10., 800., 75., 350., 0., 0., .00118, 0., 0., .203
756 , 0., 0., 0., 0., 0., 0., 0., 0., 160., 160.
757 , 8.41, 50.5, 50.8, 4.43, 120., 120., 120., 120., 15.6, 39.
758 , 36., 35.8, 10., 9., 0., 120., 120., 170., 170., 120.
759 , 120., 170., 170.};
760 G4int ab=abs(theQCode);
761 if(ab<nQHM) return width[ab];
762 return 0.; // @@ May be real width should be implemented for nuclei e.g. pp
763}
764
765// Get a nuclear mass for Z (a#of protons), N (a#of neutrons), & S (a#of lambdas)
766G4double G4QPDGCode::GetNuclMass(G4int z, G4int n, G4int s_value)
767{
768 static const G4double anb = .01; // Antibinding for Ksi-n,Sig-n,Sig+p,Sig-nn,
769 static const G4double mNeut= QHaM(20);
770 static const G4double mProt= QHaM(21);
771 static const G4double mLamb= QHaM(22);
772 static const G4double mPiC = QHaM(15);
773 static const G4double mKZ = QHaM(17);
774 static const G4double mKM = QHaM(18);
775 static const G4double mSiM = QHaM(23);
776 static const G4double mSiP = QHaM(25);
777 static const G4double mKsZ = QHaM(27);
778 static const G4double mKsM = QHaM(26);
779 static const G4double mOmM = QHaM(44);
780 static const G4double mKZa = mKZ +anb;
781 static const G4double mKMa = mKM +anb;
782 static const G4double mSigM= mSiM+anb;
783 static const G4double mSigP= mSiP+anb;
784 static const G4double mKsiZ= mKsZ+anb;
785 static const G4double mKsiM= mKsM+anb;
786 static const G4double mOmeg= mOmM+anb;
787 static const G4double mDiPi= mPiC+mPiC+anb;
788 static const G4double mDiKZ= mKZa+mKZ;
789 static const G4double mDiKM= mKMa+mKM;
790 static const G4double mDiPr= mProt+mProt;
791 static const G4double mDiNt= mNeut+mNeut;
792 static const G4double mSmPi= mSiM+mDiPi;
793 static const G4double mSpPi= mSiP+mDiPi;
794 static const G4double mOmN = mOmeg+mNeut;
795 static const G4double mSpP = mSigP+mProt;
796 static const G4double mSpPP= mSpP +mProt;
797 static const G4double mSmN = mSigM+mNeut;
798 static const G4double mSmNN= mSmN +mNeut;
799 // -------------- DAM Arrays ----------------------
800 static const G4int iNR=76; // Neutron maximum range for each Z
801 static const G4int nEl = 105; // Maximum Z of the associative memory is "nEl-1=104"
802 static const G4int iNF[nEl]={0,0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 14
803 1 , 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, // 29
804 16 , 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, // 44
805 31 , 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 53, 54, 55, // 59
806 56 , 56, 57, 57, 58, 60, 61, 63, 64, 65, 66, 67, 68, 69, 70, // 74
807 71 , 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, // 89
808 86 , 87, 88, 89, 91, 94, 98,103,109,115,122,128,134,140,146};//104
809#ifdef qdebug
810 static G4int iNmin[nEl]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 14
811 1 , 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, // 29
812 16 , 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, // 44
813 31 , 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 53, 54, 55, // 59
814 56 , 56, 57, 57, 58, 60, 61, 63, 64, 65, 66, 67, 68, 69, 70, // 74
815 71 , 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, // 89
816 86 , 87, 88, 89, 91, 94, 98,103,109,115,122,128,134,140,146};//104
817 static G4int iNmax=iNR;
818 static G4int iNran[nEl]={19,20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, // 14
819 34 , 35, 36, 37, 38, 39, 40, 48, 48, 48, 48, 50, 50, 50, 52, // 29
820 53 , 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, // 44
821 68 , 69, 70, 70, 70, 71, 71, 71, 71, 71, 72, 72, 72, 72, 72, // 59
822 73 , 73, 73, 73, 74, 74, 74, 74, 74, 74, 74, 74, 74, 75, 76, // 74
823 76 , 76, 76, 76, 76, 75, 74, 73, 72, 71, 70, 70, 69, 69, 69, // 89
824 68 , 68, 68, 67, 63, 59, 55, 51, 47, 43, 39, 35, 31, 27, 23};//104
825#endif
826 static const G4int iNL[nEl]={19,20,21,22,23,24, 25, 26, 27, 28, 29, 30, 31, 32, 33, // 14
827 34 , 35, 36, 37, 38, 39, 40, 48, 48, 48, 48, 50, 50, 50, 52, // 29
828 53 , 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, // 44
829 68 , 69, 70, 70, 70, 71, 71, 71, 71, 71, 72, 72, 72, 72, 72, // 59
830 73 , 73, 73, 73, 74, 74, 74, 74, 74, 74, 74, 74, 74, 75, 76, // 74
831 76 , 76, 76, 76, 76, 75, 74, 73, 72, 71, 70, 70, 69, 69, 69, // 89
832 68 , 68, 68, 67, 63, 59, 55, 51, 47, 43, 39, 35, 31, 27, 23};//104
833 // ********* S=-4 vectors *************
834 static G4bool iNin6[nEl]={false,false,false,false,false,false,false,
835 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
836 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
837 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
838 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
839 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
840 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
841 false,false,false,false,false,false,false,false,false,false,false,false,false,false};
842 static G4double VZ6[nEl][iNR];
843 //********* S=-3 vectors *************
844 static G4bool iNin7[nEl]={false,false,false,false,false,false,false,
845 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
846 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
847 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
848 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
849 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
850 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
851 false,false,false,false,false,false,false,false,false,false,false,false,false,false};
852 static G4double VZ7[nEl][iNR];
853 // ********* S=-2 vectors *************
854 static G4bool iNin8[nEl]={false,false,false,false,false,false,false,
855 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
856 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
857 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
858 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
859 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
860 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
861 false,false,false,false,false,false,false,false,false,false,false,false,false,false};
862 static G4double VZ8[nEl][iNR];
863 // ********* S=-1 vectors *************
864 static G4bool iNin9[nEl]={false,false,false,false,false,false,false,
865 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
866 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
867 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
868 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
869 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
870 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
871 false,false,false,false,false,false,false,false,false,false,false,false,false,false};
872 static G4double VZ9[nEl][iNR];
873 // ********* S=0 vectors *************
874 static G4bool iNin0[nEl]={false,false,false,false,false,false,false,
875 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
876 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
877 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
878 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
879 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
880 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
881 false,false,false,false,false,false,false,false,false,false,false,false,false,false};
882 static G4double VZ0[nEl][iNR];
883 // ********* S=1 vectors *************
884 static G4bool iNin1[nEl]={false,false,false,false,false,false,false,
885 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
886 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
887 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
888 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
889 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
890 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
891 false,false,false,false,false,false,false,false,false,false,false,false,false,false};
892 static G4double VZ1[nEl][iNR];
893 // ********* S=2 vectors *************
894 static G4bool iNin2[nEl]={false,false,false,false,false,false,false,
895 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
896 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
897 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
898 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
899 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
900 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
901 false,false,false,false,false,false,false,false,false,false,false,false,false,false};
902 static G4double VZ2[nEl][iNR];
903 // ********* S=3 vectors *************
904 static G4bool iNin3[nEl]={false,false,false,false,false,false,false,
905 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
906 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
907 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
908 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
909 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
910 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
911 false,false,false,false,false,false,false,false,false,false,false,false,false,false};
912 static G4double VZ3[nEl][iNR];
913 // ********* S=2 vectors *************
914 static G4bool iNin4[nEl]={false,false,false,false,false,false,false,
915 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
916 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
917 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
918 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
919 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
920 false,false,false,false,false,false,false,false,false,false,false,false,false,false,
921 false,false,false,false,false,false,false,false,false,false,false,false,false,false};
922 static G4double VZ4[nEl][iNR];
923 //
924#ifdef qdebug
925 static G4int Smin=-1; // Dynamic Associated memory is implemented for S>-2 nuclei
926 static G4int Smax= 2; // Dynamic Associated memory is implemented for S< 3 nuclei
927 static G4int NZmin= 0; // Dynamic Associated memory is implemented for Z>-1 nuclei
928 static G4int NNmin= 0; // Dynamic Associated memory is implemented for N>-1 nuclei
929 static G4int NZS1max= 0; // Dynamic Associated memory is implemented for S<3, Z=-1, N<2
930 static G4int NNS1max= 0; // Dynamic Associated memory is implemented for S<3, Z=-1, N<2
931#endif
932 // -------------------------------------------------------------------------------------
933 G4double rm=0.;
934 G4int nz=n+z;
935 G4int zns=nz+s_value;
936 if(nz+s_value<0)
937 {
938 z=-z;
939 n=-n;
940 s_value=-s_value;
941 nz=-nz;
942 zns=-zns;
943 }
944 if(z<0)
945 {
946 if(z==-1)
947 {
948 if(!s_value)
949 {
950 if(n==1) return mPiC; // pi-
951 else return mPiC+(n-1)*mNeut; // Delta- + (N-1)*n
952 }
953 else if(s_value==1) // Strange negative hadron
954 {
955 if(!n) return mKM; // K-
956 else if(n==1) return mSiM; // Sigma-
957 else if(n==2) return mSmN ; // Sigma- + n DiBaryon
958 else if(n==3) return mSmNN; // Sigma- +2n TriBaryon
959 else return mSigM+mNeut*(n-1); // Sigma- + (N-1)*n
960 }
961 else if(s_value==2) // --> Double-strange negative hadrons
962 {
963 if(!n) return mKsM; // Ksi-
964 else if(n==1) return mKsiM+mNeut; // Ksi- + n
965 else if(n==2) return mKsiM+mNeut+mNeut; // Ksi- + 2n
966 else return mKsiM+mNeut*n; // Ksi- + Z*n
967 }
968 else if(s_value==-2)
969 {
970 if (nz==2) return mDiKZ+mPiC; // 2K0 + Pi-
971 else return mDiKZ+mPiC+(nz-2)*mProt;
972 }
973 else if(s_value==3) // --> Triple-strange negative hadrons
974 {
975 if (n==-1) return mOmM; // Triple-strange Omega minus
976 else if(!n ) return mOmN; // Triple-strange (Omega-) + n DiBaryon
977 else if(n==-2) return mDiKZ+mKM; // Triple-strange K- + 2*K0
978 else return mOmeg+mNeut*(n+2);
979 }
980 else if(s_value==4)
981 {
982 if(n==-2) return mOmeg+mKM; // Omega- + K-
983 else if(n==-1) return mOmeg+mLamb;// Omega- + Lambda
984 else return mOmeg+mLamb+(n+1)*mNeut; // Omega- + Lambda + (n+1)*Neutrons
985 }
986 else if(!n) return mOmeg+(s_value-2)*mLamb; // Multy-Lambda + Omega minus
987 else
988 {
989#ifdef qdebug
990 if(s_value>NZS1max)
991 {
992 NZS1max=s_value;
993 G4cout<<"-------->>G4QPDGCode::GetNucMass: Z=-1, S="<<s_value<<">2 with N="<<n<<G4endl;
994 }
995#endif
996 return CalculateNuclMass(z,n,s_value);
997 }
998 }
999 else if(!s_value)
1000 {
1001 if(!nz)
1002 {
1003 if(n==2) return mDiPi;
1004 else return mDiPi+(n-2)*mPiC;
1005 }
1006 else return mNeut*nz-z*mPiC+anb;
1007 }
1008 else if(!zns) // !!! s=0 is treated above !!
1009 {
1010 if(s_value>0) return anb+s_value*mKM+n*mPiC; // s*K- + n*Pi-
1011 else return anb-s_value*mKZ-z*mPiC; // (-s)*aK0 + (-z)*Pi-
1012 }
1013 else if(s_value==1)
1014 {
1015 if(!nz)
1016 {
1017 if(n==2) return mSmPi;
1018 else return mSmPi+(n-2)*mPiC;
1019 }
1020 else return mSigM+nz*mNeut-(z+1)*mPiC;
1021 }
1022 else if(s_value==-1) return mKZa-z*mPiC+(nz-1)*mNeut; // aK0+(nz-1)n+(-z)*Pi-
1023 else if(s_value==2)
1024 {
1025 if (nz==-1) return mKsiM+n*mPiC;
1026 else if(!nz) return mKsiM+mNeut-(z+1)*mPiC;
1027 else return mKsiM+(nz+1)*mNeut-(z+1)*mPiC;
1028 }
1029 else if(s_value==-2) return mDiKZ-z*mPiC+(nz-2)*mNeut;
1030 else if(s_value==3)
1031 {
1032 if (nz==-2) return mOmeg+(n+1)*mPiC; // Omega- + (n+1)* Pi-
1033 else if(nz==-1) return mOmeg+mNeut+n*mPiC; // Omega- + n * Pi-
1034 else if(!nz) return mOmeg+mDiNt+(n-1)*mPiC; // Omega- + 2N + (n-1)*Pi-
1035 else return mOmeg+(nz+2)*mProt-(z+1)*mPiC;
1036 }
1037 else if(s_value<-2) return anb-s_value*mKZ-z*mPiC+(nz+s_value)*mNeut;
1038 else if(s_value==4)
1039 {
1040 if (nz==-3) return mOmeg+mKM+(n+1)*mPiC; // Om- + K- + (n+1)*Pi-
1041 else if(nz==-2) return mOmeg+mSigM+n*mPiC; // Om- + Sig- + n*Pi-
1042 else if(nz==-1) return mOmeg+mSigM+mNeut+(n-1)*mPiC;//Om- + Sig- +N +(n-1)*Pi-
1043 else if(!nz) return mOmeg+mSigM+mDiNt+(n-2)*mPiC;//Om- +Sig- +2N +(n-2)*Pi-
1044 else return mOmeg+mSigM+(nz+2)*mDiNt-(z+2)*mPiC;//+(nz+2)N-(z+2)Pi-
1045 }
1046 // s=5: 2*K-, Ksi-; s=6: 3*K-, Omega-; s>6 adds K- and Sigma- instead of Protons
1047 else // !!All s<0 are done and s>4 can be easy extended if appear!!
1048 {
1049#ifdef qdebug
1050 if(z<NZmin)
1051 {
1052 NZmin=z;
1053 G4cout<<"---->>G4QPDGCode::GetNucMass: Z="<<z<<"<-1 with N="<<n<<", S="<<s_value<<G4endl;
1054 }
1055#endif
1056 return CalculateNuclMass(z,n,s_value);
1057 }
1058 }
1059 else if(n<0)
1060 {
1061 if(n==-1)
1062 {
1063 if(!s_value)
1064 {
1065 if(z==1) return mPiC; // pi+
1066 else return mPiC+(z-1)*mProt; // Delta++ + (Z-1)*p
1067 }
1068 else if(s_value==1) // --> Strange neutral hadrons
1069 {
1070 if(!z) return mKZ; // K0
1071 else if(z==1) return mSiP; // Sigma+
1072 else if(z==2) return mSpP ; // Sigma+ + p DiBaryon
1073 else if(z==3) return mSpPP; // Sigma+ +2p TriBaryon
1074 else return mSigP+mProt*(z-1); // Sigma+ + (Z-1)*p
1075 }
1076 else if(s_value==2) // --> Double-strange negative hadrons
1077 {
1078 if(!z) return mKsZ; // Ksi0
1079 else if(z==1) return mKsiZ+mProt; // Ksi- + p
1080 else if(z==2) return mKsiZ+mProt+mProt; // Ksi- + 2p
1081 else return mKsiZ+mProt*z; // Ksi- + Z*p
1082 }
1083 else if(s_value==-2)
1084 {
1085 if (nz==2) return mDiKM+mPiC; // 2K+ + Pi+
1086 else return mDiKM+mPiC+(nz-2)*mProt;
1087 }
1088 else if(s_value==3)
1089 {
1090 if(z==1) return mOmeg+mDiPr;
1091 else return mOmeg+(z+1)*mProt;
1092 }
1093 else if(s_value==4) return mOmeg+mLamb+(z+1)*mProt;
1094 else if(!z) return mKZa+(s_value-1)*mLamb; // Multy-Lambda + K0
1095 else
1096 {
1097#ifdef qdebug
1098 if(s_value>NNS1max)
1099 {
1100 NNS1max=s_value;
1101 G4cout<<"-------->>G4QPDGCode::GetNucMass: N=-1, S="<<s_value<<">2 with Z="<<z<<G4endl;
1102 }
1103#endif
1104 return CalculateNuclMass(z,n,s_value);
1105 }
1106 }
1107 else if(!s_value)
1108 {
1109 if(!nz)
1110 {
1111 if(z==2) return mDiPi;
1112 else return mDiPi+(z-2)*mPiC;
1113 }
1114 else return mProt*nz-n*mPiC+anb;
1115 }
1116 else if(!zns) // !!! s=0 is treated above !!
1117 {
1118 if(s_value>0) return anb+s_value*mKZ+z*mPiC; // s*K0 + n*Pi+
1119 else return anb-s_value*mKM-n*mPiC; // (-s)*aK+ + (-n)*Pi+
1120 }
1121 else if(s_value==1)
1122 {
1123 if(!nz)
1124 {
1125 if(z==2) return mSpPi;
1126 else return mSpPi+(z-2)*mPiC;
1127 }
1128 else return mSigP+nz*mProt-(n+1)*mPiC;
1129 }
1130 else if(s_value==-1) return mKMa-n*mPiC+(nz-1)*mProt; // K+ + (nz-1)*P + (-n)*Pi+
1131 else if(s_value==2)
1132 {
1133 if (nz==-1) return mKsiZ+z*mPiC;
1134 else if(!nz) return mKsiZ+mProt-(n+1)*mPiC;
1135 else return mKsiZ+(nz+1)*mProt-(n+1)*mPiC;
1136 }
1137 else if(s_value==-2) return mDiKM-n*mPiC+(nz-2)*mProt;
1138 else if(s_value==3)
1139 {
1140 if (nz==-2) return mOmeg+(z+1)*mPiC; // Omega + (z+1)*Pi+
1141 else if(nz==-1) return mOmeg+mProt+z*mPiC; // Omega- + P +z*Pi+
1142 else if(!nz) return mOmeg+mDiPr+(z-1)*mPiC; // Omega- + 2P + (z-1)* Pi+
1143 else return mOmeg+(nz+2)*mProt-(n+1)*mPiC;
1144 }
1145 else if(s_value<-2) return anb-s_value*mKM-n*mPiC+(nz+s_value)*mProt;
1146 else if(s_value==4)
1147 {
1148 if (nz==-3) return mOmeg+mKZ+(z+1)*mPiC; // Om- + K0 + (z+1)*Pi+
1149 else if(nz==-2) return mOmeg+mSigP+z*mPiC; // Om- + Sig+ + z*Pi+
1150 else if(nz==-1) return mOmeg+mSigP+mProt+(z-1)*mPiC;// Om- +Sig+ +P +(z-1)*Pi+
1151 else if(!nz) return mOmeg+mSigP+mDiPr+(z-2)*mPiC;//Om- +Sig+ +2P +(z-2)*Pi+
1152 else return mOmeg+mSigP+(nz+2)*mProt-(n+2)*mPiC;//+(nz+2)P-(n+2)Pi+
1153 }
1154 // s=5: 2*KZ, Ksi0; s=6: 3*KZ, Omega-; s>6 adds K0 and Sigma+ instead of Protons
1155 else // !!All s<0 are done and s>4 can be easy extended if appear!!
1156 {
1157#ifdef qdebug
1158 if(n<NNmin)
1159 {
1160 NNmin=n;
1161 G4cout<<"---->>G4QPDGCode::GetNucMass: N="<<n<<"<-1 with Z="<<z<<", S="<<s_value<<G4endl;
1162 }
1163#endif
1164 return CalculateNuclMass(z,n,s_value);
1165 }
1166 }
1167 //return CalculateNuclMass(z,n,s_value); // @@ This is just to compare the calculation time @@
1168 if(nz >= 256 || z >= nEl) return 256000.;
1169 if(!s_value) // **************> S=0 nucleus
1170 {
1171 G4int Nmin=iNF[z]; // Minimun N(Z) for the Dynamic Associative Memory (DAM)
1172 if(!iNin0[z]) // =--=> This element is already initialized
1173 {
1174#ifdef idebug
1175 G4cout<<"**>G4QPDGCode::GetNucM:Z="<<z<<", S=0 is initialized. F="<<iNin0[z]<<G4endl;
1176#endif
1177 G4int iNfin=iNL[z];
1178 if(iNfin>iNR) iNfin=iNR;
1179 for (G4int in=0; in<iNfin; in++) VZ0[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
1180 iNin0[z]=true;
1181 }
1182 G4int dNn=n-Nmin;
1183 if(dNn<0) // --> The minimum N must be reduced
1184 {
1185#ifdef qdebug
1186 if(n<iNmin[z])
1187 {
1188 G4cout<<"-->>G4QPDGCode::GetNucM:Z="<<z<<", S=0 with N="<<n<<"<"<<iNmin[z]<<G4endl;
1189 iNmin[z]=n;
1190 }
1191#endif
1192 return CalculateNuclMass(z,n,s_value);
1193 }
1194 else if(dNn<iNL[z]) return VZ0[z][dNn]; // Found in DAM
1195 else // --> The maximum N must be increased
1196 {
1197#ifdef qdebug
1198 if(dNn>iNmax)
1199 {
1200 G4cout<<"**>>G4QPDGCode::GetNucM:Z="<<z<<", S=0 with dN="<<dNn<<">"<<iNmax<<G4endl;
1201 iNmax=dNn;
1202 }
1203 if(dNn>iNran[z])
1204 {
1205 G4cout<<">G4QPDGCode::GetNucM:Z="<<z<<", S=0 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
1206 iNran[z]=dNn;
1207 }
1208#endif
1209 return CalculateNuclMass(z,n,s_value);
1210 }
1211 }
1212 else if(s_value==1) // ******************> S=1 nucleus
1213 {
1214 G4int Nmin=iNF[z]; // Minimun N(Z) for the Dynamic Associative Memory (DAM)
1215#ifdef pdebug
1216 G4bool pPrint = !z && !n;
1217 if(pPrint)
1218 G4cout<<"G4QPDGC::GetNucM:Nmin="<<Nmin<<",iNin1="<<iNin1[0]<<",iNL="<<iNL[0]<<G4endl;
1219#endif
1220 if(!iNin1[z]) // =--=> This element is already initialized
1221 {
1222#ifdef pdebug
1223 if(pPrint)
1224 G4cout<<"**>G4QPDGCode::GetNucM:Z="<<z<<", S=1 is initialized. F="<<iNin1[z]<<G4endl;
1225#endif
1226 G4int iNfin=iNL[z];
1227 if(iNfin>iNR) iNfin=iNR;
1228 for (G4int in=0; in<iNfin; in++) VZ1[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
1229 iNin1[z]=true;
1230 }
1231 G4int dNn=n-Nmin;
1232 if(dNn<0) // --> The minimum N must be reduced
1233 {
1234#ifdef qdebug
1235 if(n<iNmin[z])
1236 {
1237 G4cout<<"-->>G4QPDGCode::GetNucM:Z="<<z<<", S=1 with N="<<n<<"<"<<iNmin[z]<<G4endl;
1238 iNmin[z]=n;
1239 }
1240#endif
1241 return CalculateNuclMass(z,n,s_value);
1242 }
1243 else if(dNn<iNL[z]) return VZ1[z][dNn]; // Found in DAM
1244 else // --> The maximum N must be increased
1245 {
1246#ifdef qdebug
1247 if(dNn>iNmax)
1248 {
1249 G4cout<<"**>>G4QPDGCode::GetNucM:Z="<<z<<", S=1 with dN="<<dNn<<">"<<iNmax<<G4endl;
1250 iNmax=dNn;
1251 }
1252 if(dNn>iNran[z])
1253 {
1254 G4cout<<">G4QPDGCode::GetNucM:Z="<<z<<", S=1 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
1255 iNran[z]=dNn;
1256 }
1257#endif
1258 return CalculateNuclMass(z,n,s_value);
1259 }
1260 }
1261 else if(s_value==-1) // ******************> S=-1 nucleus
1262 {
1263 G4int Nmin=iNF[z]; // Minimun N(Z) for the Dynamic Associative Memory (DAM)
1264 if(!iNin9[z]) // =--=> This element is already initialized
1265 {
1266#ifdef idebug
1267 G4cout<<"*>G4QPDGCode::GetNucM:Z="<<z<<", S=-1 is initialized. F="<<iNin9[z]<<G4endl;
1268#endif
1269 G4int iNfin=iNL[z];
1270 if(iNfin>iNR) iNfin=iNR;
1271 for (G4int in=0; in<iNfin; in++) VZ9[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
1272 iNin9[z]=true;
1273 }
1274 G4int dNn=n-Nmin;
1275 if(dNn<0) // --> The minimum N must be reduced
1276 {
1277#ifdef qdebug
1278 if(n<iNmin[z])
1279 {
1280 G4cout<<"->>G4QPDGCode::GetNucM:Z="<<z<<" ,S=-1 with N="<<n<<"<"<<iNmin[z]<<G4endl;
1281 iNmin[z]=n;
1282 }
1283#endif
1284 return CalculateNuclMass(z,n,s_value);
1285 }
1286 else if(dNn<iNL[z]) return VZ9[z][dNn]; // Found in DAM
1287 else // --> The maximum N must be increased
1288 {
1289#ifdef qdebug
1290 if(dNn>iNmax)
1291 {
1292 G4cout<<"**>G4QPDGCode::GetNucM:Z="<<z<<", S=-1 with dN="<<dNn<<">"<<iNmax<<G4endl;
1293 iNmax=dNn;
1294 }
1295 if(dNn>iNran[z])
1296 {
1297 G4cout<<"G4QPDGCode::GetNucM:Z="<<z<<", S=-1 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
1298 iNran[z]=dNn;
1299 }
1300#endif
1301 return CalculateNuclMass(z,n,s_value);
1302 }
1303 }
1304 else if(s_value==2) // ******************> S=2 nucleus
1305 {
1306 G4int Nmin=iNF[z]; // Minimun N(Z) for the Dynamic Associative Memory (DAM)
1307 if(!iNin2[z]) // =--=> This element is already initialized
1308 {
1309#ifdef idebug
1310 G4cout<<"**>G4QPDGCode::GetNucM:Z="<<z<<", S=2 is initialized. F="<<iNin2[z]<<G4endl;
1311#endif
1312 G4int iNfin=iNL[z];
1313 if(iNfin>iNR) iNfin=iNR;
1314 for (G4int in=0; in<iNfin; in++) VZ2[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
1315 iNin2[z]=true;
1316 }
1317 G4int dNn=n-Nmin;
1318 if(dNn<0) // --> The minimum N must be reduced
1319 {
1320#ifdef qdebug
1321 if(n<iNmin[z])
1322 {
1323 G4cout<<"-->>G4QPDGCode::GetNucM:Z="<<z<<", S=2 with N="<<n<<"<"<<iNmin[z]<<G4endl;
1324 iNmin[z]=n;
1325 }
1326#endif
1327 return CalculateNuclMass(z,n,s_value);
1328 }
1329 else if(dNn<iNL[z]) return VZ2[z][dNn]; // Found in DAM
1330 else // --> The maximum N must be increased
1331 {
1332#ifdef qdebug
1333 if(dNn>iNmax)
1334 {
1335 G4cout<<"**>>G4QPDGCode::GetNucM:Z="<<z<<", S=2 with dN="<<dNn<<">"<<iNmax<<G4endl;
1336 iNmax=dNn;
1337 }
1338 if(dNn>iNran[z])
1339 {
1340 G4cout<<">G4QPDGCode::GetNucM:Z="<<z<<", S=2 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
1341 iNran[z]=dNn;
1342 }
1343#endif
1344 return CalculateNuclMass(z,n,s_value);
1345 }
1346 }
1347 else if(s_value==-2) // ******************> S=-2 nucleus
1348 {
1349 G4int Nmin=iNF[z]; // Minimun N(Z) for the Dynamic Associative Memory (DAM)
1350 if(!iNin8[z]) // =--=> This element is already initialized
1351 {
1352#ifdef idebug
1353 G4cout<<"*>G4QPDGCode::GetNucM:Z="<<z<<", S=-2 is initialized. F="<<iNin8[z]<<G4endl;
1354#endif
1355 G4int iNfin=iNL[z];
1356 if(iNfin>iNR) iNfin=iNR;
1357 for (G4int in=0; in<iNfin; in++) VZ8[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
1358 iNin8[z]=true;
1359 }
1360 G4int dNn=n-Nmin;
1361 if(dNn<0) // --> The minimum N must be reduced
1362 {
1363#ifdef qdebug
1364 if(n<iNmin[z])
1365 {
1366 G4cout<<"->>G4QPDGCode::GetNucM:Z="<<z<<", S=-2 with N="<<n<<"<"<<iNmin[z]<<G4endl;
1367 iNmin[z]=n;
1368 }
1369#endif
1370 return CalculateNuclMass(z,n,s_value);
1371 }
1372 else if(dNn<iNL[z]) return VZ8[z][dNn]; // Found in DAM
1373 else // --> The maximum N must be increased
1374 {
1375#ifdef qdebug
1376 if(dNn>iNmax)
1377 {
1378 G4cout<<"**>G4QPDGCode::GetNucM:Z="<<z<<", S=-2 with dN="<<dNn<<">"<<iNmax<<G4endl;
1379 iNmax=dNn;
1380 }
1381 if(dNn>iNran[z])
1382 {
1383 G4cout<<"G4QPDGCode::GetNucM:Z="<<z<<", S=-2 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
1384 iNran[z]=dNn;
1385 }
1386#endif
1387 return CalculateNuclMass(z,n,s_value);
1388 }
1389 }
1390 else if(s_value==-3) // ******************> S=-3 nucleus
1391 {
1392 G4int Nmin=iNF[z]; // Minimun N(Z) for the Dynamic Associative Memory (DAM)
1393 if(!iNin7[z]) // =--=> This element is already initialized
1394 {
1395#ifdef idebug
1396 G4cout<<"*>G4QPDGCode::GetNucM:Z="<<z<<", S=-3 is initialized. F="<<iNin7[z]<<G4endl;
1397#endif
1398 G4int iNfin=iNL[z];
1399 if(iNfin>iNR) iNfin=iNR;
1400 for (G4int in=0; in<iNfin; in++) VZ7[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
1401 iNin7[z]=true;
1402 }
1403 G4int dNn=n-Nmin;
1404 if(dNn<0) // --> The minimum N must be reduced
1405 {
1406#ifdef qdebug
1407 if(n<iNmin[z])
1408 {
1409 G4cout<<"->>G4QPDGCode::GetNucM:Z="<<z<<", S=-3 with N="<<n<<"<"<<iNmin[z]<<G4endl;
1410 iNmin[z]=n;
1411 }
1412#endif
1413 return CalculateNuclMass(z,n,s_value);
1414 }
1415 else if(dNn<iNL[z]) return VZ7[z][dNn]; // Found in DAM
1416 else // --> The maximum N must be increased
1417 {
1418#ifdef qdebug
1419 if(dNn>iNmax)
1420 {
1421 G4cout<<"**>G4QPDGCode::GetNucM:Z="<<z<<", S=-3 with dN="<<dNn<<">"<<iNmax<<G4endl;
1422 iNmax=dNn;
1423 }
1424 if(dNn>iNran[z])
1425 {
1426 G4cout<<"G4QPDGCode::GetNucM:Z="<<z<<", S=-3 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
1427 iNran[z]=dNn;
1428 }
1429#endif
1430 return CalculateNuclMass(z,n,s_value);
1431 }
1432 }
1433 else if(s_value==3) // ******************> S=3 nucleus
1434 {
1435 G4int Nmin=iNF[z]; // Minimun N(Z) for the Dynamic Associative Memory (DAM)
1436 if(!iNin3[z]) // =--=> This element is already initialized
1437 {
1438#ifdef idebug
1439 G4cout<<"**>G4QPDGCode::GetNucM:Z="<<z<<", S=3 is initialized. F="<<iNin3[z]<<G4endl;
1440#endif
1441 G4int iNfin=iNL[z];
1442 if(iNfin>iNR) iNfin=iNR;
1443 for (G4int in=0; in<iNfin; in++) VZ3[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
1444 iNin3[z]=true;
1445 }
1446 G4int dNn=n-Nmin;
1447 if(dNn<0) // --> The minimum N must be reduced
1448 {
1449#ifdef qdebug
1450 if(n<iNmin[z])
1451 {
1452 G4cout<<"-->>G4QPDGCode::GetNucM:Z="<<z<<", S=3 with N="<<n<<"<"<<iNmin[z]<<G4endl;
1453 iNmin[z]=n;
1454 }
1455#endif
1456 return CalculateNuclMass(z,n,s_value);
1457 }
1458 else if(dNn<iNL[z]) return VZ3[z][dNn]; // Found in DAM
1459 else // --> The maximum N must be increased
1460 {
1461#ifdef qdebug
1462 if(dNn>iNmax)
1463 {
1464 G4cout<<"**>>G4QPDGCode::GetNucM:Z="<<z<<", S=3 with dN="<<dNn<<">"<<iNmax<<G4endl;
1465 iNmax=dNn;
1466 }
1467 if(dNn>iNran[z])
1468 {
1469 G4cout<<">G4QPDGCode::GetNucM:Z="<<z<<", S=3 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
1470 iNran[z]=dNn;
1471 }
1472#endif
1473 return CalculateNuclMass(z,n,s_value);
1474 }
1475 }
1476 else if(s_value==-4) // ******************> S=-4 nucleus
1477 {
1478 G4int Nmin=iNF[z]; // Minimun N(Z) for the Dynamic Associative Memory (DAM)
1479 if(!iNin6[z]) // =--=> This element is already initialized
1480 {
1481#ifdef idebug
1482 G4cout<<"*>G4QPDGCode::GetNucM:Z="<<z<<", S=-4 is initialized. F="<<iNin6[z]<<G4endl;
1483#endif
1484 G4int iNfin=iNL[z];
1485 if(iNfin>iNR) iNfin=iNR;
1486 for (G4int in=0; in<iNfin; in++) VZ6[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
1487 iNin6[z]=true;
1488 }
1489 G4int dNn=n-Nmin;
1490 if(dNn<0) // --> The minimum N must be reduced
1491 {
1492#ifdef qdebug
1493 if(n<iNmin[z])
1494 {
1495 G4cout<<"->>G4QPDGCode::GetNucM:Z="<<z<<", S=-4 with N="<<n<<"<"<<iNmin[z]<<G4endl;
1496 iNmin[z]=n;
1497 }
1498#endif
1499 return CalculateNuclMass(z,n,s_value);
1500 }
1501 else if(dNn<iNL[z]) return VZ6[z][dNn]; // Found in DAM
1502 else // --> The maximum N must be increased
1503 {
1504#ifdef qdebug
1505 if(dNn>iNmax)
1506 {
1507 G4cout<<"**>G4QPDGCode::GetNucM:Z="<<z<<", S=-4 with dN="<<dNn<<">"<<iNmax<<G4endl;
1508 iNmax=dNn;
1509 }
1510 if(dNn>iNran[z])
1511 {
1512 G4cout<<"G4QPDGCode::GetNucM:Z="<<z<<", S=-4 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
1513 iNran[z]=dNn;
1514 }
1515#endif
1516 return CalculateNuclMass(z,n,s_value);
1517 }
1518 }
1519 else if(s_value==4) // ******************> S=4 nucleus
1520 {
1521 G4int Nmin=iNF[z]; // Minimun N(Z) for the Dynamic Associative Memory (DAM)
1522 if(!iNin4[z]) // =--=> This element is already initialized
1523 {
1524#ifdef idebug
1525 G4cout<<"*>G4QPDGCode::GetNucM:Z="<<z<<", S=4 is initialized. F="<<iNin4[z]<<G4endl;
1526#endif
1527 G4int iNfin=iNL[z];
1528 if(iNfin>iNR) iNfin=iNR;
1529 for (G4int in=0; in<iNfin; in++) VZ4[z][in] = CalculateNuclMass(z,in+Nmin,s_value);
1530 iNin4[z]=true;
1531 }
1532 G4int dNn=n-Nmin;
1533 if(dNn<0) // --> The minimum N must be reduced
1534 {
1535#ifdef qdebug
1536 if(n<iNmin[z])
1537 {
1538 G4cout<<"-->>G4QPDGCode::GetNucM:Z="<<z<<", S=4 with N="<<n<<"<"<<iNmin[z]<<G4endl;
1539 iNmin[z]=n;
1540 }
1541#endif
1542 return CalculateNuclMass(z,n,s_value);
1543 }
1544 else if(dNn<iNL[z]) return VZ4[z][dNn]; // Found in DAM
1545 else // --> The maximum N must be increased
1546 {
1547#ifdef qdebug
1548 if(dNn>iNmax)
1549 {
1550 G4cout<<"**>>G4QPDGCode::GetNucM:Z="<<z<<", S=4 with dN="<<dNn<<">"<<iNmax<<G4endl;
1551 iNmax=dNn;
1552 }
1553 if(dNn>iNran[z])
1554 {
1555 G4cout<<">G4QPDGCode::GetNucM:Z="<<z<<", S=4 with dN="<<dNn<<">"<<iNran[z]<<G4endl;
1556 iNran[z]=dNn;
1557 }
1558#endif
1559 return CalculateNuclMass(z,n,s_value);
1560 }
1561 }
1562 else
1563 {
1564#ifdef qdebug
1565 if(s_value<Smin || s_value>Smax)
1566 {
1567 if(s_value<Smin) Smin=s_value;
1568 if(s_value>Smax) Smax=s_value;
1569 G4cout<<">>G4QPDGCode::GetNucM:Z="<<z<<" with S="<<s_value<<",N="<<n<<" (Improve)"<<G4endl;
1570 }
1571#endif
1572 rm=CalculateNuclMass(z,n,s_value);
1573 }
1574#ifdef debug
1575 G4cout<<"G4QPDGCode::GetMass:GetNuclMass="<<rm<<",Z="<<z<<",N="<<n<<",S="<<s_value<<G4endl;
1576#endif
1577 return rm;
1578} // End of GetNuclearMass
1579
1580// Calculate a nuclear mass for Z (a#of protons), N (a#of neutrons), & S (a#of lambdas)
1581G4double G4QPDGCode::CalculateNuclMass(G4int z, G4int n, G4int s_value)
1582{
1583 static const G4double mP = QHaM(21); // Proton
1584 static const G4double mN = QHaM(20); // Neutron
1585 static const G4double mL = QHaM(22); // Lambda
1586 static const G4double mD = G4Deuteron::Deuteron()->GetPDGMass(); // Deuteron (H-2)
1587 static const G4double mT = G4Triton::Triton()->GetPDGMass(); // Triton (H-3)
1588 static const G4double mHe3= G4He3::He3()->GetPDGMass(); // Hetrium (He-3)
1589 static const G4double mAl = G4Alpha::Alpha()->GetPDGMass(); // Alpha (He-4)
1590 static const G4double dmP = mP+mP; // DiProton
1591 static const G4double dmN = mN+mN; // DiNeutron
1592 static const G4double dmL = mL+mL; // DiLambda
1593 static const G4double dLN = mL+mN; // LambdaNeutron
1594 static const G4double dLP = mL+mP; // LambdaProton
1595 static const G4double mSm = QHaM(23); // Sigma-
1596 static const G4double mSp = QHaM(25); // Sigma+
1597 static const G4double dSP = mSp+mP; // ProtonSigma+
1598 static const G4double dSN = mSm+mN; // NeutronSigma-
1599 static const G4double dnS = dSN+mN; // 2NeutronsSigma-
1600 static const G4double dpS = dSP+mP; // 2ProtonsSigma+
1601 static const G4double mXm = QHaM(26); // Ksi-
1602 static const G4double mXz = QHaM(27); // Ksi0
1603 static const G4double mOm = QHaM(44); // Omega-
1604 static const G4double dXN = mXm+mN; // NeutronKsi-
1605 static const G4double dXP = mXz+mP; // ProtonKsi0
1606 static const G4double dOP = mOm+mP; // ProtonOmega-
1607 static const G4double dON = mOm+mN; // NeutronOmega-
1608 static const G4double mK = QHaM(18); // Charged Kaon
1609 static const G4double mK0 = QHaM(17); // Neutral Kaon
1610 static const G4double mPi = QHaM(15); // Charged Pion
1611 //////////static const G4double mPi0= QHaM(14);
1612 //static const G4int nSh = 164;
1613 //static G4double sh[nSh] = {0., // Fake element for C++ N=Z=0
1614 // -4.315548, 2.435504, -1.170501, 3.950887, 5.425238,
1615 // 13.342524, 15.547586, 22.583129, 23.983480, 30.561036,
1616 // 33.761971, 41.471027, 45.532156, 53.835880, 58.495514,
1617 // 65.693445, 69.903344, 76.899581, 81.329361, 88.979438,
1618 // 92.908703, 100.316636, 105.013393, 113.081686, 118.622601,
1619 // 126.979113, 132.714435, 141.413182, 146.433488, 153.746754,
1620 // 158.665225, 165.988967, 170.952395, 178.473011, 183.471531,
1621 // 191.231310, 196.504414, 204.617158, 210.251108, 218.373984,
1622 // 223.969281, 232.168660, 237.925619, 246.400505, 252.392471,
1623 // 260.938644, 267.191321, 276.107788, 282.722682, 291.881502,
1624 // 296.998590, 304.236025, 309.562296, 316.928655, 322.240263,
1625 // 329.927236, 335.480630, 343.233705, 348.923475, 356.911659,
1626 // 362.785757, 370.920926, 376.929998, 385.130316, 391.197741,
1627 // 399.451554, 405.679971, 414.101869, 420.346260, 428.832412,
1628 // 435.067445, 443.526983, 449.880034, 458.348602, 464.822352,
1629 // 473.313779, 479.744524, 488.320887, 495.025069, 503.841579,
1630 // 510.716379, 519.451976, 525.036156, 532.388151, 537.899017,
1631 // 545.252264, 550.802469, 558.402181, 564.101100, 571.963429,
1632 // 577.980340, 586.063802, 592.451334, 600.518525, 606.832027,
1633 // 614.831626, 621.205330, 629.237413, 635.489106, 643.434167,
1634 // 649.691284, 657.516479, 663.812101, 671.715021, 678.061128,
1635 // 686.002970, 692.343712, 700.360477, 706.624091, 714.617848,
1636 // 721.100390, 729.294717, 735.887170, 744.216084, 751.017094,
1637 // 759.551764, 766.377807, 775.080204, 781.965673, 790.552795,
1638 // 797.572494, 806.088030, 813.158751, 821.655631, 828.867137,
1639 // 836.860955, 842.183292, 849.195302, 854.731798, 861.898839,
1640 // 867.783606, 875.313342, 881.443441, 889.189065, 895.680189,
1641 // 903.679729, 910.368085, 918.579876, 925.543547, 933.790028,
1642 // 940.811396, 949.122548, 956.170201, 964.466810, 971.516490,
1643 // 979.766905, 986.844659, 995.113552,1002.212760,1010.418770,
1644 // 1018.302560,1025.781870,1033.263560,1040.747880,1048.234460,
1645 // 1055.723430,1063.214780,1070.708750,1078.204870,1085.703370,
1646 // 1093.204260,1100.707530,1108.213070};
1647 //static const G4double b1=8.09748564; // MeV
1648 //static const G4double b2=-0.76277387;
1649 //static const G4double b3=83.487332; // MeV
1650 //static const G4double b4=0.090578206;// 2*b4
1651 //static const G4double b5=0.676377211;// MeV
1652 //static const G4double b6=5.55231981; // MeV
1653 static const G4double b7=25.; // MeV (Lambda binding energy predexponent)
1654 // --- even-odd difference is 3.7(MeV)/X
1655 // --- S(X>151)=-57.56-5.542*X**1.05
1656 static const G4double b8=10.5; // (Lambda binding energy exponent)
1657 //static const G4double b9=-1./3.;
1658 static const G4double a2=0.13; // LambdaBindingEnergy for deutron+LambdaSystem(MeV)
1659 static const G4double a3=2.2; // LambdaBindingEnergy for (t/He3)+LambdaSystem(MeV)
1660 static const G4double um_value=931.49432; // Umified atomic mass unit (MeV)
1661 //static const G4double me =0.511; // electron mass (MeV) :: n:8.071, p:7.289
1662 static const G4double eps =0.0001; // security addition for multybaryons
1663 //static G4double c[9][9]={// z=1 =2 =3 =4 =5 =6 =7 =8 =9
1664 // {13.136,14.931,25.320,38.000,45.000,55.000,65.000,75.000,85.000},//n=1
1665 // {14.950, 2.425,11.680,18.374,27.870,35.094,48.000,60.000,72.000}, //n=2
1666 // {25.930,11.390,14.086,15.770,22.921,28.914,39.700,49.000,60.000}, //n=3
1667 // {36.830,17.594,14.908, 4.942,12.416,15.699,24.960,32.048,45.000}, //n=4
1668 // {41.860,26.110,20.946,11.348,12.051,10.650,17.338,23.111,33.610}, //n=5
1669 // {45.000,31.598,24.954,12.607, 8.668, 0.000, 5.345, 8.006,16.780}, //n=6
1670 // {50.000,40.820,33.050,20.174,13.369, 3.125, 2.863, 2.855,10.680}, //n=7
1671 // {55.000,48.810,40.796,25.076,16.562, 3.020, 0.101,-4.737,1.9520}, //n=8
1672 // {60.000,55.000,50.100,33.660,23.664, 9.873, 5.683,-0.809,0.8730}}; //n=9
1673 if(z>107)
1674 {
1675#ifdef debug
1676 G4cout<<"***G4QPDGCode::CalcNuclMass: Z="<<z<<">107, N="<<n<<", S="<<s_value<<G4endl;
1677#endif
1678 return 256000.;
1679 }
1680 G4int Z=z;
1681 G4int N=n;
1682 G4int S=s_value;
1683#ifdef debug
1684 G4cout<<"G4QPDGCode::CalcNuclMass called with Z="<<Z<<",N="<<N<<", S="<<S<<G4endl;
1685#endif
1686 if(!N&&!Z&&!S)
1687 {
1688#ifdef debug
1689 //G4cout<<"G4QPDGCode::GetNuclMass(0,0,0)="<<mPi0<<"#0"<<G4endl;
1690#endif
1691 //return mPi0; // Pi0 mass (dangerose)
1692 return 0.; // Photon mass
1693 }
1694 else if(!N&&!Z&&S==1) return mL;
1695 else if(!N&&Z==1&&!S) return mP;
1696 else if(N==1&&!Z&&!S) return mN;
1697 else if(!N&&!Z&&S>1) return mL*S+eps;
1698 else if(!N&&Z>1&&!S) return mP*Z+eps;
1699 else if(N>1&&!Z&&!S) return mN*N+eps;
1700 G4int A=Z+N;
1701 G4int Bn=A+S;
1702 //if((Z<0||N<0)&&!Bn)
1703 //{
1704 // if (N<0) return Bn*mL-Z*mK - N*mK0+eps* S ;
1705 // else return Bn*mL+N*mPi-A*mK +eps*(N+S);
1706 //}
1707 //if(A<0&&Bn>=0) // Bn*LAMBDA's + (-(N+Z))*antiKaons
1708 //{
1709 // if (N<0&&Z<0) return Bn*mL-Z*mK -N*mK0+eps* S ;
1710 // else if(N<0) return Bn*mL+Z*mPi-A*mK0+eps*(Z+S);
1711 // else return Bn*mL+N*mPi-A*mK +eps*(N+S);
1712 //}
1713 if(!Bn) // => "GS Mesons - octet" case (without eta&pi0)
1714 {
1715 if (!S&&Z<0) return mPi*N;
1716 else if(!S&&N<0) return mPi*Z;
1717 else if ( (N == 1 && S == -1) || (N == -1 && S == 1) )
1718 return mK0; // Simple decision
1719 else if ( (S == 1 && Z == -1) || (S == -1 && Z == 1) )
1720 return mK; // Simple decision
1721 else if(S>0) // General decision
1722 {
1723 if (-Z>S) return S*mK-(S+Z)*mPi+eps;
1724 else if(Z>=0) return S*mK0+Z*mPi+eps;
1725 else return (S+Z)*mK0-Z*mK+eps;
1726 }
1727 else if(S<0) // General decision
1728 {
1729 if (Z>-S) return -S*mK+(S+Z)*mPi+eps;
1730 else if(Z<=0) return -S*mK0-Z*mPi+eps;
1731 else return -(S+Z)*mK0+Z*mK+eps;
1732 }
1733 }
1734 else if(Bn==1) // => "GS Baryons - octet" case (withoutSigma0)
1735 {
1736 if (Z== 1 && N== 0 && S== 0) return mP;
1737 else if(Z== 0 && N== 1 && S== 0) return mN;
1738 else if(Z== 0 && N== 0 && S== 1) return mL;
1739 else if(Z== 1 && N==-1 && S== 1) return mSp; // Lower than Sigma+ (Simp.Decis)
1740 else if(Z==-1 && N== 1 && S== 1) return mSm; // Lower than Sigma- (Simp.Decis)
1741 else if(Z== 0 && N==-1 && S== 2) return mXz; // Lower than Xi0 (Simp.Decis)
1742 else if(Z==-1 && N== 0 && S== 2) return mXm; // Lower than Xi- (Simp.Decis)
1743 else if(Z==-1 && N==-1 && S== 3) return mOm; // Lower than Omega- (Simp.Decis)
1744 else if(!S&&Z<0) return mN-mPi*Z+eps; // Negative Isonuclei
1745 else if(!S&&N<0) return mP-mPi*N+eps; // Positive Isonuclei
1746 else if(S==1) // --> General decision
1747 {
1748 if (N>1) return mSm+(N-1)*mPi+eps; // (Sigma-)+(n*PI-)
1749 else if(Z>1) return mSp+(Z-1)*mPi+eps; // (Sigma+)+(n*PI+)
1750 }
1751 else if(S==2) // --> General decision
1752 {
1753 if (N>0) return mXm+N*mPi+eps; // (Xi-)+(n*PI-)
1754 else if(Z>0) return mXz+Z*mPi+eps; // (Xi0)+(n*PI+)
1755 }
1756 else if(S==3) // --> General decision
1757 {
1758 if (N>-1) return mOm+(N+1)*mPi+eps; // (Omega-)+(n*PI-)
1759 else if(Z>-1) return mOm+(Z+1)*mPi+eps; // (Omega-)+(n*PI+)
1760 }
1761 else if(S>3) // --> General Omega- decision
1762 {
1763 if (-Z>S-2) return mOm+(S-3)*mK +(2-Z-S)*mPi+eps;
1764 else if(Z>-1) return mOm+(S-3)*mK0+(Z+1)+mPi+eps;
1765 else return mOm+(S+Z-2)*mK0-(Z+1)*mK+eps;
1766 }
1767 }
1768 else if(Bn==2) // => "GS Baryons - decuplet" case (NP,LP, and LN are made below)
1769 {
1770 if (Z== 2 && N== 0 && S== 0) return dmP;
1771 //else if(Z== 1 && N== 1 && S== 0) return 1875.61282; // Exact deuteron PDG Mass
1772 else if(Z== 1 && N== 1 && S== 0) return mD; // Exact deuteron PDG Mass
1773 else if(Z== 0 && N== 2 && S== 0) return dmN;
1774 else if(Z== 2 && N==-1 && S== 1) return dSP;
1775 else if(Z== 1 && N== 0 && S== 1) return dLP;
1776 else if(Z== 0 && N== 1 && S== 1) return dLN;
1777 else if(Z==-1 && N== 2 && S== 1) return dSN;
1778 else if(Z== 1 && N==-1 && S== 2) return dXP;
1779 else if(Z== 0 && N== 0 && S== 2) return dmL;
1780 else if(Z==-1 && N== 1 && S== 2) return dXN;
1781 else if(Z== 0 && N==-1 && S== 3) return dOP;
1782 else if(Z==-1 && N== 0 && S== 3) return dON;
1783 else if(!S&&Z<0) return dmN-mPi*Z+eps; // Negative Isonuclei
1784 else if(!S&&N<0) return dmP-mPi*N+eps; // Positive Isonuclei
1785 else if(S==1) // --> General decision
1786 {
1787 if (N>2) return dSP+(N-2)*mPi+eps; // (nSigma-)+(n*PI-)
1788 else if(Z>2) return dSN+(Z-1)*mPi+eps; // (pSigma+)+(n*PI+)
1789 }
1790 else if(S==2) // --> General decision
1791 {
1792 if (N>1) return dXN+(N-1)*mPi+eps; // (nXi-)+(n*PI-)
1793 else if(Z>1) return dXP+(Z-1)*mPi+eps; // (pXi0)+(n*PI+)
1794 }
1795 else if(S==3) // --> General decision
1796 {
1797 if (N>0) return dON+N*mPi+eps; // (nOmega-)+(n*PI-)
1798 else if(Z>0) return dOP+Z*mPi+eps; // (pOmega-)+(n*PI+)
1799 }
1800 else if(S>3) // --> General Omega- decision
1801 {
1802 if (-Z>S-2) return dON+(S-3)*mK +(2-Z-S)*mPi+eps;
1803 else if(Z>0) return dOP+(S-3)*mK0+Z+mPi+eps;
1804 else return dOP+(S+Z-3)*mK0-Z*mK+eps;
1805 }
1806 //else if(S>0) // @@ Implement General Decision
1807 //{
1808 // //#ifdef debug
1809 // G4cout<<"***G4QPDGCode::GetNuclMass:B=2, Z="<<Z<<",N="<<N<<",S="<<S<<G4endl;
1810 // //#endif
1811 // return bigM; // Exotic dibaryons (?)
1812 //}
1813 }
1814 else if(Bn==3)
1815 {
1816 if(!S) // Bn=3
1817 {
1818 if (Z==1 && N== 2) return mT; // tritium
1819 else if(Z==2 && N== 1) return mHe3; // hetrium
1820 }
1821 if(S== 1 && Z==-1 && N== 3) // nnSig-
1822 {
1823 if (Z==-1 && N== 3) return dnS; // nnSig-
1824 else if(Z== 3 && N==-1) return dpS; // ppSig+
1825 }
1826 }
1827 else if(!S)
1828 {
1829 if(Z==2 && N==2) return mAl; // Alpha
1830 else if(Z<0) return A*mN-Z*mPi+eps; // Multybaryon Negative Isonuclei
1831 else if(Z>A) return A*mP+(Z-A)*mPi+eps; // Multybaryon Positive Isonuclei
1832 }
1833 // === Start mesonic extraction ===
1834 G4double km_value=0.; // Mass Sum of K mesons (G4E::DecayAntiStrang.)
1835 G4int Zm=Z;
1836 G4int Nm=N;
1837 G4int Sm=S;
1838 if(S<0&&Bn>0) // NEW: the free mass minimum
1839 {
1840 if(Zm>=-S) // Enough charge for K+'s
1841 {
1842 km_value=-S*mK; // Anti-Lambdas are compensated by protons
1843 Zm+=S;
1844 }
1845 else if(Zm>0)
1846 {
1847 km_value=Zm*mK-(S+Zm)*mK0; // Anti-Lambdas are partially compensated by neutrons
1848 Zm=0;
1849 Nm+=S+Zm;
1850 }
1851 }
1852 else Sm=0; // No alternative calculations
1853 // Old algorithm
1854 G4double k=0.; // Mass Sum of K mesons
1855 if(S<0&&Bn>0) // OLD @@ Can be improved by K0/K+ search of minimum
1856 {
1857 G4int sH=(-S)/2; // SmallHalfS || The algorithm must be the same
1858 G4int bH=-S-sH; // BigHalhS || as in G4QE::DecayAntiStrange
1859 if(Z>0 && Z>N)
1860 {
1861 if(Z>=bH) // => "Enough protons in nucleus" case
1862 {
1863 if(N>=sH)
1864 {
1865 k=bH*mK+sH*mK0;
1866 Z-=bH;
1867 N-=sH;
1868 }
1869 else
1870 {
1871 G4int dN=Z-N;
1872 if(dN>=-S)
1873 {
1874 k=-S*mK;
1875 Z+=S;
1876 }
1877 else
1878 {
1879 G4int sS=(-S-dN)/2;
1880 G4int bS=-S-dN-sS;
1881 sS+=dN;
1882 if(Z>=sS&&N>=bS)
1883 {
1884 k=sS*mK+bS*mK0;
1885 Z-=sS;
1886 N-=bS;
1887 }
1888 else if(Z<sS)
1889 {
1890 G4int dS=-S-Z;
1891 k=Z*mK+dS*mK0;
1892 N-=dS;
1893 Z=0;
1894 }
1895 else
1896 {
1897 G4int dS=-S-N;
1898 k=dS*mK+N*mK0;
1899 Z-=dS;
1900 N=0;
1901 }
1902 }
1903 }
1904 }
1905 else // Must not be here
1906 {
1907#ifdef debug
1908 G4cout<<"***G4QPDGC::CalcNuclMass:Antimatter? Z="<<Z<<",N="<<N<<",S="<<S<<G4endl;
1909#endif
1910 return 0.; // @@ Antiparticles aren't implemented @@
1911 }
1912 }
1913 else if(N>=bH)
1914 {
1915 if(Z>=sH)
1916 {
1917 k=sH*mK+bH*mK0;
1918 Z-=sH;
1919 N-=bH;
1920 }
1921 else
1922 {
1923 G4int dN=N-Z;
1924 if(dN>=-S)
1925 {
1926 k=-S*mK0;
1927 N+=S;
1928 }
1929 else
1930 {
1931 G4int sS=(-S-dN)/2;
1932 G4int bS=-S-dN-sS;
1933 bS+=dN;
1934 if(N>=bS&&Z>=sS)
1935 {
1936 k=sS*mK+bS*mK0;
1937 Z-=sS;
1938 N-=bS;
1939 }
1940 else if(N<bS)
1941 {
1942 G4int dS=-S-N;
1943 k=dS*mK+N*mK0;
1944 Z-=dS;
1945 N=0;
1946 }
1947 else
1948 {
1949 G4int dS=-S-Z;
1950 k=Z*mK+dS*mK0;
1951 N-=dS;
1952 Z=0;
1953 }
1954 }
1955 }
1956 }
1957 else // Must not be here
1958 {
1959 return 0.; // @@ Antiparticles aren't implemented @@
1960#ifdef debug
1961 G4cout<<"***G4QPDGC::CalcNuclMass:Antimatter? N="<<N<<",Z="<<Z<<",S="<<S<<G4endl;
1962#endif
1963 }
1964 S=0;
1965 }
1966 if(N<0)
1967 {
1968 k+=-N*mPi;
1969 Z+=N;
1970 N=0;
1971 }
1972 if(Z<0)
1973 {
1974 k+=-Z*mPi;
1975 N+=Z;
1976 Z=0;
1977 }
1978 A=Z+N;
1979 if (!A) return k+S*mL+S*eps; // @@ multy LAMBDA states are not implemented
1980 G4double m_value=k+A*um_value; // Expected mass in atomic units
1981 //G4double D=N-Z; // Isotopic shift of the nucleus
1982 if ( (A+S < 1 && k==0.) || Z < 0 || N < 0 )
1983 { // @@ Can be generalized to anti-nuclei
1984#ifdef debug
1985 G4cout<<"**G4QPDGCode::CalcNuclMass:A="<<A<<"<1 || Z="<<Z<<"<0 || N="<<N<<"<0"<<G4endl;
1986 //@@throw G4QException("***G4QPDGCode::GetNuclMass: Impossible nucleus");
1987#endif
1988 return 0.; // @@ Temporary
1989 }
1990 if (!Z) return k+N*(mN+.1)+S*(mL+.1); // @@ n+LAMBDA states are not implemented
1991 else if(!N) return k+Z*(mP+1.)+S*(mL+.1); // @@ p+LAMBDA states are not implemented
1992 //else if(N<=9&&Z<=9) m_value+=1.433e-5*pow(double(Z),2.39)-Z*me+c[N-1][Z-1];// Geant4 Comp.now
1993 else
1994 {
1995 //G4double fA=A;
1996 // IsInTable is inside G4NucleiProperties::GetNuclearMass
1997 // G4ParticleTable::GetParticleTable()->FindIon(Zm,Am,0,Zm) creates new Ion!
1998 if(A==256 && Z==128) m_value=256000.;
1999 else m_value=k+G4NucleiProperties::GetNuclearMass(A,Z);
2000 }
2001 //@@//G4double maxM= k+Z*mP+N*mN+S*mL+eps; // @@ eps -- Wings of the Mass parabola
2002 //@@//if(m_value>maxM) m_value=maxM;
2003 G4double mm_value=m_value;
2004 if(Sm<0) // For the new algorithm of calculation
2005 {
2006 if(Nm<0)
2007 {
2008 km_value+=-Nm*mPi;
2009 Zm+=Nm;
2010 Nm=0;
2011 }
2012 if(Zm<0)
2013 {
2014 km_value+=-Zm*mPi;
2015 Nm+=Zm;
2016 Zm=0;
2017 }
2018 G4int Am=Zm+Nm;
2019 if(!Am) return km_value+eps;
2020 mm_value=km_value+Am*um_value; // Expected mass in atomic units
2021 //G4double Dm=Nm-Zm; // Isotopic shift of the nucleus
2022 if ( (Am < 1 && km_value==0.) || Zm < 0 || Nm < 0 )
2023 { // @@ Can be generalized to anti-nuclei
2024#ifdef debug
2025 G4cerr<<"*G4QPDGCode::CalcNucM:A="<<Am<<"<1 || Z="<<Zm<<"<0 || N="<<Nm<<"<0"<<G4endl;
2026#endif
2027 }
2028 if (!Zm) return km_value+Nm*(mN+.1);
2029 else if(!Nm) return km_value+Zm*(mP+1.);
2030 //else if(Nm<=9&&Zm<=9) mm_value+=1.433e-5*pow(double(Zm),2.39)-Zm*me+c[Nm-1][Zm-1];// Geant4
2031 else
2032 {
2033 // IsInTable is inside G4NucleiProperties::GetNuclearMass
2034 // G4ParticleTable::GetParticleTable()->FindIon(Zm,Am,0,Zm) creates new Ion!
2035 mm_value=km_value+G4NucleiProperties::GetNuclearMass(Am,Zm);
2036 }
2037 //@@//G4double mM= km_value+Zm*mP+Nm*mN+eps;
2038 //@@//if(mm_value>mM) mm_value=mM;
2039 }
2040 if(m_value>mm_value) m_value=mm_value;
2041 if(S>0)
2042 {
2043 G4double bs=0.;
2044 if (A==2) bs=a2;
2045 else if(A==3) bs=a3;
2046 else if(A>3) bs=b7*exp(-b8/(A+1.));
2047 m_value+=S*(mL-bs);
2048 }
2049#ifdef debug
2050 G4cout<<"G4QPDGCode::CalcNuclMass: >->-> OUT <-<-< m="<<m_value<<G4endl;
2051#endif
2052 //if(z==8&&n==9&&!s_value) G4cout<<"G4QPDGC::GetNucM:m="<<m_value<<",mm="<<mm_value<<G4endl;
2053 return m_value;
2054}
2055
2056// Get a Quark Content {d,u,s,ad,au,as} for the PDG
2057G4QContent G4QPDGCode::GetQuarkContent() const
2058{
2059 G4int a=0; // particle
2060 if(thePDGCode<0) a=1; // anti-particle
2061 G4int d=0;
2062 G4int u=0;
2063 G4int s_value=0;
2064 G4int ad=0;
2065 G4int au=0;
2066 G4int as=0;
2067 G4int ab=abs(thePDGCode);
2068 if (!ab)
2069 {
2070 G4cerr<<"***G4QPDGCode::GetQuarkContent: PDG=0, return (0,0,0,0,0,0)"<<G4endl;
2071 return G4QContent(0,0,0,0,0,0);
2072 }
2073 else if(ab<4) // @@ for SU(6) : ab<7
2074 {
2075 if (thePDGCode== 1) return G4QContent(1,0,0,0,0,0);
2076 else if(thePDGCode== 2) return G4QContent(0,1,0,0,0,0);
2077 else if(thePDGCode== 3) return G4QContent(0,0,1,0,0,0);
2078 else if(thePDGCode==-1) return G4QContent(0,0,0,1,0,0);
2079 else if(thePDGCode==-2) return G4QContent(0,0,0,0,1,0);
2080 else if(thePDGCode==-3) return G4QContent(0,0,0,0,0,1);
2081 }
2082 else if(ab<99)
2083 {
2084 if (thePDGCode== 11) return G4QContent(1,0,0,0,1,0);
2085 else if(thePDGCode==-11) return G4QContent(0,1,0,1,0,0);
2086 else if(thePDGCode== 13) return G4QContent(1,0,0,0,1,0);
2087 else if(thePDGCode==-13) return G4QContent(0,1,0,1,0,0);
2088 else if(thePDGCode== 15) return G4QContent(1,0,0,0,1,0);
2089 else if(thePDGCode==-15) return G4QContent(0,1,0,1,0,0);
2090#ifdef debug
2091 if (ab==22) G4cout<<"-W-G4QPDGC::GetQuarkCont: For the Photon? - Return 0"<<G4endl;
2092 else if(ab==10) G4cout<<"-W-G4QPDGC::GetQuarkCont: For Chipolino? - Return 0"<<G4endl;
2093 else G4cout<<"-W-G4QPDGCode::GetQuarkCont: For PDG="<<thePDGCode<<" Return 0"<<G4endl;
2094#endif
2095 return G4QContent(0,0,0,0,0,0); // Photon, bosons, leptons
2096 }
2097 else if(ab<80000000) // Baryons & Mesons
2098 {
2099 G4int c=ab/10; // temporary (quarks)
2100 G4int f=c%10; // (1) low quark
2101 G4int v=c/10; // (2,3) temporary(B) or (2) final(M) (high quarks, high quark)
2102 G4int t=0; // (3)prototype of highest quark (B)
2103#ifdef sdebug
2104 G4cout<<"G4QPDGCode::GetQuarkContent: a="<<ab<<", c="<<c<<", f="<<f<<", v="<<v<<G4endl;
2105#endif
2106 if(v>10) // Baryons
2107 {
2108 t=v/10; // (3) highest quark
2109 v%=10; // (2) high quark
2110 if (f==1)
2111 {
2112 if(a) ad++;
2113 else d++;
2114 }
2115 else if(f==2)
2116 {
2117 if(a) au++;
2118 else u++;
2119 }
2120 else if(f==3)
2121 {
2122 if(a) as++;
2123 else s_value++;
2124 }
2125 else G4cerr<<"*G4QPDGC::GetQCont:1 PDG="<<thePDGCode<<","<<f<<","<<v<<","<<t<<G4endl;
2126 if (v==1)
2127 {
2128 if(a) ad++;
2129 else d++;
2130 }
2131 else if(v==2)
2132 {
2133 if(a) au++;
2134 else u++;
2135 }
2136 else if(v==3)
2137 {
2138 if(a) as++;
2139 else s_value++;
2140 }
2141 else G4cerr<<"*G4QPDGC::GetQCont:2 PDG="<<thePDGCode<<","<<f<<","<<v<<","<<t<<G4endl;
2142 if (t==1)
2143 {
2144 if(a) ad++;
2145 else d++;
2146 }
2147 else if(t==2)
2148 {
2149 if(a) au++;
2150 else u++;
2151 }
2152 else if(t==3)
2153 {
2154 if(a) as++;
2155 else s_value++;
2156 }
2157 else G4cerr<<"*G4QPDGC::GetQCont:3 PDG="<<thePDGCode<<","<<f<<","<<v<<","<<t<<G4endl;
2158 return G4QContent(d,u,s_value,ad,au,as);
2159 }
2160 else // Mesons
2161 {
2162 if(f==v)
2163 {
2164 if (f==1) return G4QContent(1,0,0,1,0,0);
2165 else if(f==2) return G4QContent(0,1,0,0,1,0);
2166 else if(f==3) return G4QContent(0,0,1,0,0,1);
2167 else G4cerr<<"*G4QPDGC::GetQC:4 PDG="<<thePDGCode<<","<<f<<","<<v<<","<<t<<G4endl;
2168 }
2169 else
2170 {
2171 if (f==1 && v==2)
2172 {
2173 if(a)return G4QContent(1,0,0,0,1,0);
2174 else return G4QContent(0,1,0,1,0,0);
2175 }
2176 else if(f==1 && v==3)
2177 {
2178 if(a)return G4QContent(0,0,1,1,0,0);
2179 else return G4QContent(1,0,0,0,0,1);
2180 }
2181 else if(f==2 && v==3)
2182 {
2183 if(a)return G4QContent(0,0,1,0,1,0);
2184 else return G4QContent(0,1,0,0,0,1);
2185 }
2186 else G4cerr<<"*G4QPDGC::GetQC:5 PDG="<<thePDGCode<<","<<f<<","<<v<<","<<t<<G4endl;
2187 }
2188 }
2189 }
2190 else
2191 {
2192 G4int szn=ab-90000000;
2193 G4int ds=0;
2194 G4int dz=0;
2195 G4int dn=0;
2196 if(szn<-100000)
2197 {
2198 G4int ns_value=(-szn)/1000000+1;
2199 szn+=ns_value*1000000;
2200 ds+=ns_value;
2201 }
2202 else if(szn<-100)
2203 {
2204 G4int nz=(-szn)/1000+1;
2205 szn+=nz*1000;
2206 dz+=nz;
2207 }
2208 else if(szn<0)
2209 {
2210 G4int nn=-szn;
2211 szn=0;
2212 dn+=nn;
2213 }
2214 G4int sz =szn/1000;
2215 G4int n =szn%1000;
2216 if(n>700)
2217 {
2218 n-=1000;
2219 dz--;
2220 }
2221 G4int z =sz%1000-dz;
2222 if(z>700)
2223 {
2224 z-=1000;
2225 ds--;
2226 }
2227 s_value =sz/1000-ds;
2228 G4int b=z+n+s_value;
2229 d=n+b;
2230 u=z+b;
2231 if (d<0&&u<0&&s_value<0) return G4QContent(0,0,0,-d,-u,-s_value);
2232 else if (u<0&&s_value<0) return G4QContent(d,0,0,0,-u,-s_value);
2233 else if (d<0&&s_value<0) return G4QContent(0,u,0,-d,0,-s_value);
2234 else if (d<0&&u<0) return G4QContent(0,0,s_value,-d,-u,0);
2235 else if (u<0) return G4QContent(d,0,s_value,0,-u,0);
2236 else if (s_value<0) return G4QContent(d,u,0,0,0,-s_value);
2237 else if (d<0) return G4QContent(0,u,s_value,-d,0,0);
2238 else return G4QContent(d,u,s_value,0,0,0);
2239 }
2240 return G4QContent(0,0,0,0,0,0);
2241}
2242
2243// Quark Content of pseudo-meson for q_i->q_o Quark Exchange
2244G4QContent G4QPDGCode::GetExQContent(G4int i, G4int o) const
2245{
2246 G4QContent cQC(0,0,0,0,0,0);
2247 if (!i) cQC.IncAD();
2248 else if(i==1) cQC.IncAU();
2249 else if(i==2) cQC.IncAS();
2250 else G4cerr<<"***G4QPDGCode::GetExQContent: strange entering quark i="<<i<<G4endl;
2251 if (!o) cQC.IncD();
2252 else if(o==1) cQC.IncU();
2253 else if(o==2) cQC.IncS();
2254 else G4cerr<<"***G4QPDGCode::GetExQContent: strange exiting quark o="<<o<<G4endl;
2255 return cQC;
2256}
2257
2258// Relative Cross Index for q_i->q_o (q=0(d),1(u),2(s), 7 means there is no such cluster)
2259G4int G4QPDGCode::GetRelCrossIndex(G4int i, G4int o) const
2260{
2261 // pD,nD,DD,DD,ppDnnDpDDnDD n, p, L,S-,S+,X-,X0,O-
2262 static const G4int b01[16]={ 7,15, 7, 7, 7, 7, 7, 7, 1, 7, 7,-1, 7, 7, 7, 7};
2263 static const G4int b02[16]={ 7, 7, 7, 7, 7, 7, 7, 7, 2, 7, 7, 7, 7, 7, 7, 7};
2264 static const G4int b10[16]={18, 7, 7, 7, 7, 7, 7, 7, 7,-1, 7, 7,-2, 7, 7, 7}; // Iso+Bary
2265 static const G4int b12[16]={ 7, 7, 7, 7, 7, 7, 7, 7, 7, 1, 7, 7, 7, 7, 7, 7};
2266 static const G4int b20[16]={ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,-2, 7,-3, 7,-4, 7};
2267 static const G4int b21[16]={ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,-1,-3, 7,-3, 7, 7};
2268 // nn,np,pp,Ln,Lp,LL,nS,pS,nnpnppLnnLpnLppLLnLLpnnS
2269 static const G4int d01[16]={ 1, 1, 7, 1, 7, 7,-3, 7, 1, 7, 1, 1, 7, 1, 7,-5};
2270 static const G4int d02[16]={ 3, 3, 7, 2, 7, 7, 7, 7, 3, 3, 3, 3, 7, 7, 7, 7};
2271 static const G4int d10[16]={ 7,-1,-1, 7,-1, 7, 7,-4, 7,-1, 7,-1,-1, 7,-1, 7}; //B=2,3
2272 static const G4int d12[16]={ 7, 2, 2, 7, 1, 7, 7, 7, 2, 2, 7, 2, 2, 7, 7, 7};
2273 static const G4int d20[16]={ 7, 7, 7,-3,-3,-2, 7,-5, 7, 7, 7,-3,-3,-3,-3, 7};
2274 static const G4int d21[16]={ 7, 7, 7,-2,-2,-1,-6, 7, 7, 7,-2,-2, 7,-2,-2, 7};
2275 // nn,np,pp,Ln,Lp,nn,np,pp! n, p,nn,np,pp,Ln,Lp
2276 static const G4int m01[15]={ 1, 1, 7, 1, 7, 1, 1, 7, 1, 7, 1, 1, 7, 1, 7};// Multibaryons
2277 static const G4int m02[15]={ 3, 3, 7, 3, 3, 7, 7, 7, 3, 3, 3, 3, 7, 7, 7};// @@ Regular !
2278 static const G4int m10[15]={ 7,-1,-1, 7,-1, 7,-1,-1, 7,-1, 7,-1,-1, 7,-1};// 01->1,10->-1
2279 static const G4int m12[15]={ 7, 2, 2, 2, 2, 7, 7, 7, 2, 2, 7, 2, 2, 7, 7};// 12->2,21->-2
2280 static const G4int m20[15]={ 7, 7, 7,-3,-3, 7,-3,-3, 7, 7, 7,-3,-3,-3,-3};// 02->3,20->-3
2281 static const G4int m21[15]={ 7, 7, 7,-2,-2,-2,-2, 7, 7, 7,-2,-2, 7,-2,-2};
2282 //static const G4int fragmStart = 82; // "Isonuclei are added & Leptons are added"
2283 static const G4int fragmStart = 45; // "Isonuclei & Leptons are added, Reduced"
2284
2285 if(theQCode<fragmStart) return 7;
2286 G4int sub=theQCode-fragmStart;
2287 if ( (sub > 1 && sub < 8) || (sub > 12 && sub <16)) return 7; // SuperIso & SuperStrange
2288 G4int rel=sub; // case of nuclear baryons and isonuclei
2289 if (sub>31) rel =(sub-32)%15; // case of heavy fragments (BaryNum>3)
2290 else if(sub>15) rel = sub-16; // case of nuclear di-baryon & tri-baryons
2291#ifdef debug
2292 G4cout<<"G4QPDGCode::RelGetCrossIndex:i="<<i<<",o="<<o<<",su="<<sub<<",re="<<rel<<G4endl;
2293#endif
2294 //if ( (rel > 5 && rel < 9) || (rel > 13 && rel <16)) return 7; // SuperStrange're closed
2295 if (!i) // ==> input quark = 0(d) (d=-1/3)
2296 {
2297 if (!o) return 0; // -> output quark = 0(d) => 0 = the same cluster
2298 else if(o==1) // -> output quark = 1(u) (ch--)
2299 {
2300 if (sub<16) return b01[rel];
2301 else if(sub<32) return d01[rel];
2302 else return m01[rel];
2303 }
2304 else if(o==2)
2305 {
2306 if (sub<16) return b02[rel];
2307 else if(sub<32) return d02[rel];
2308 else return m02[rel];
2309 }
2310 }
2311 else if(i==1) // ==> input quark = 1(u) (u=2/3)
2312 {
2313 if (!o) // -> output quark = 0(d) (ch++)
2314 {
2315 if (sub<16) return b10[rel];
2316 else if(sub<32) return d10[rel];
2317 else return m10[rel];
2318 }
2319 else if(o==1) return 0; // -> output quark = 1(u) => 0 = the same cluster
2320 else if(o==2)
2321 {
2322 if (sub<16) return b12[rel];
2323 else if(sub<32) return d12[rel];
2324 else return m12[rel];
2325 }
2326 }
2327 else if(i==2)
2328 {
2329 if (!o)
2330 {
2331 if (sub<16) return b20[rel];
2332 else if(sub<32) return d20[rel];
2333 else return m20[rel];
2334 }
2335 else if(o==1)
2336 {
2337 if (sub<16) return b21[rel];
2338 else if(sub<32) return d21[rel];
2339 else return m21[rel];
2340 }
2341 else if(o==2) return 0;
2342 }
2343 return 7;
2344}
2345
2346// Get number of Combinations for q_i->q_o
2347G4int G4QPDGCode::GetNumOfComb(G4int i, G4int o) const
2348{
2349 if(i>-1&&i<3)
2350 {
2351 G4int shiftQ=GetRelCrossIndex(i, o);
2352 G4int sQCode=theQCode; // QCode of the parent cluster
2353 if (shiftQ==7) return 0; // A parent cluster doesn't exist
2354 else if(!shiftQ) sQCode+=shiftQ; // Shift QCode of son to QCode of his parent
2355 G4QPDGCode parent; // Create a temporary (fake) parent cluster
2356 parent.InitByQCode(sQCode); // Initialize it by Q-Code
2357 G4QContent parentQC=parent.GetQuarkContent();// Quark Content of the parent cluster
2358 if (!o) return parentQC.GetD();
2359 else if(o==1) return parentQC.GetU();
2360 else if(o==2) return parentQC.GetS();
2361 else G4cerr<<"***G4QPDGCode:::GetNumOfComb: strange exiting quark o="<<o<<G4endl;
2362 }
2363 else G4cerr<<"***G4QPDGCode:::GetNumOfComb: strange entering quark i="<<i<<G4endl;
2364 return 0;
2365}
2366
2367// Get a total number of Combinations for q_i
2368G4int G4QPDGCode::GetTotNumOfComb(G4int i) const
2369{
2370 G4int tot=0;
2371 if(i>-1&&i<3) for(int j=0; j<3; j++) tot+=GetNumOfComb(i, j);
2372 else G4cerr<<"***G4QPDGCode:::GetTotNumOfComb: strange entering quark i="<<i<<G4endl;
2373 return tot;
2374}
2375
2376// Converts nuclear PDGCode to Z(#of protons), N(#of neutrons), S(#of lambdas) values
2377void G4QPDGCode::ConvertPDGToZNS(G4int nucPDG, G4int& z, G4int& n, G4int& s_value)
2378{
2379 if(nucPDG>80000000&&nucPDG<100000000) // Condition of conversion
2380 {
2381 z=0;
2382 n=0;
2383 s_value=0;
2384 G4int r=nucPDG;
2385 if(r==90000000) return;
2386 G4int cn =r%1000; // candidate to #of neutrons
2387 if(cn)
2388 {
2389 if(cn>500) cn-=1000; // AntiNeutrons
2390 n=cn; // Increment neutrons
2391 r-=cn; // Subtract them from the residual
2392 if(r==90000000) return;
2393 }
2394 G4int cz =r%1000000; // candidate to #of neutrons
2395 if(cz)
2396 {
2397 if(cz>500000) cz-=1000000; // AntiProtons
2398 z=cz/1000; // Number of protons
2399 r-=cz; // Subtract them from the residual
2400 if(r==90000000) return;
2401 }
2402 G4int cs =r%10000000; // candidate to #of neutrons
2403 if(cs)
2404 {
2405 if(cs>5000000) cs-=10000000; // AntiLambda
2406 s_value=cs/1000000; // Number of Lambdas
2407 }
2408 }
2409 return;
2410}
2411
2412// Only for irreducable DiQaDiQ! L1!=R1 && L1!=R2 && L2!=R1 && L2!=R2
2413std::pair<G4int,G4int> G4QPDGCode::MakeTwoBaryons(G4int L1, G4int L2, G4int R1, G4int R2)
2414{
2415 G4int dl=0;
2416 G4int ul=0;
2417 //G4int sl=0;
2418 if (L1==1) ++dl;
2419 else if(L1==2) ++ul;
2420 //else if(L1==3) ++sl;
2421 if (L2==1) ++dl;
2422 else if(L2==2) ++ul;
2423 //else if(L2==3) ++sl;
2424 if (R1==1) ++dl;
2425 else if(R1==2) ++ul;
2426 //else if(R1==3) ++sl;
2427 if (R2==1) ++dl;
2428 else if(R2==2) ++ul;
2429 //else if(R2==3) ++sl;
2430 if (dl==2 && ul==2) return make_pair(1114,2212); // @@ can be (2112,2224)
2431 else if(dl==1 && ul==2) return make_pair(3112,2212);
2432 else if(dl==0 && ul==2) return make_pair(3212,3212); // @@ can be (3312,2212)
2433 else if(dl==2 && ul==1) return make_pair(3222,2112);
2434 else if(dl==1 && ul==1) return make_pair(3312,2112); // @@ can be (3322,2212)
2435 else if(dl==2 && ul==0) return make_pair(3112,3112); // @@ can be (3322,1122)
2436 //#ifdef debug
2437 else G4cout<<"-Warning-G4QPDGCode::MakeTwoBaryons: Irreduceble? L1="<<L1<<",L2="<<L2
2438 <<",R1="<<R1<<",R2="<<R2<<G4endl;
2439 //#endif
2440 return make_pair(2212,2112); // @@ Just theMinimum, makeException
2441}
operator-
G4int operator-(const G4QPDGCode &lhs, const G4QPDGCode &rhs)
Definition: G4QPDGCode.cc:149
operator+
G4int operator+(const G4QPDGCode &lhs, const G4QPDGCode &rhs)
Definition: G4QPDGCode.cc:132
operator%
G4int operator%(const G4QPDGCode &lhs, const G4int &rhs)
Definition: G4QPDGCode.cc:204
operator*
G4int operator*(const G4QPDGCode &lhs, const G4QPDGCode &rhs)
Definition: G4QPDGCode.cc:166
operator<<
ostream & operator<<(ostream &lhs, G4QPDGCode &rhs)
Definition: G4QPDGCode.cc:118
operator/
G4int operator/(const G4QPDGCode &lhs, const G4QPDGCode &rhs)
Definition: G4QPDGCode.cc:185
G4double
double G4double
Definition: G4Types.hh:64
G4int
int G4int
Definition: G4Types.hh:66
G4bool
bool G4bool
Definition: G4Types.hh:67
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cerr
G4DLLIMPORT std::ostream G4cerr
G4cout
G4DLLIMPORT std::ostream G4cout
G4Alpha::Alpha
static G4Alpha * Alpha()
Definition: G4Alpha.cc:89
G4Deuteron::Deuteron
static G4Deuteron * Deuteron()
Definition: G4Deuteron.cc:94
G4Electron::Electron
static G4Electron * Electron()
Definition: G4Electron.cc:94
G4EtaPrime::EtaPrime
static G4EtaPrime * EtaPrime()
Definition: G4EtaPrime.cc:105
G4Eta::Eta
static G4Eta * Eta()
Definition: G4Eta.cc:109
G4He3::He3
static G4He3 * He3()
Definition: G4He3.cc:94
G4KaonMinus::KaonMinus
static G4KaonMinus * KaonMinus()
Definition: G4KaonMinus.cc:113
G4KaonZero::KaonZero
static G4KaonZero * KaonZero()
Definition: G4KaonZero.cc:104
G4Lambda::Lambda
static G4Lambda * Lambda()
Definition: G4Lambda.cc:108
G4MuonMinus::MuonMinus
static G4MuonMinus * MuonMinus()
Definition: G4MuonMinus.cc:100
G4NeutrinoE::NeutrinoE
static G4NeutrinoE * NeutrinoE()
Definition: G4NeutrinoE.cc:85
G4NeutrinoMu::NeutrinoMu
static G4NeutrinoMu * NeutrinoMu()
Definition: G4NeutrinoMu.cc:85
G4NeutrinoTau::NeutrinoTau
static G4NeutrinoTau * NeutrinoTau()
Definition: G4NeutrinoTau.cc:85
G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104
G4NucleiProperties::GetNuclearMass
static G4double GetNuclearMass(const G4double A, const G4double Z)
Definition: G4NucleiProperties.cc:53
G4OmegaMinus::OmegaMinus
static G4OmegaMinus * OmegaMinus()
Definition: G4OmegaMinus.cc:110
G4PionMinus::PionMinus
static G4PionMinus * PionMinus()
Definition: G4PionMinus.cc:98
G4PionZero::PionZero
static G4PionZero * PionZero()
Definition: G4PionZero.cc:104
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93
G4QContent::IncAS
void IncAS(G4int n=1)
Definition: G4QContent.hh:321
G4QContent::IncAD
void IncAD(G4int n=1)
Definition: G4QContent.hh:320
G4QContent::GetU
G4int GetU() const
Definition: G4QContent.hh:189
G4QContent::GetS
G4int GetS() const
Definition: G4QContent.hh:191
G4QContent::IncS
void IncS(G4int n=1)
Definition: G4QContent.hh:318
G4QContent::IncD
void IncD(G4int n=1)
Definition: G4QContent.hh:317
G4QContent::GetD
G4int GetD() const
Definition: G4QContent.hh:190
G4QContent::IncAU
void IncAU(G4int n=1)
Definition: G4QContent.hh:319
G4QContent::IncU
void IncU(G4int n=1)
Definition: G4QContent.hh:316
G4QPDGCode::GetQuarkContent
G4QContent GetQuarkContent() const
Definition: G4QPDGCode.cc:2057
G4QPDGCode::GetWidth
G4double GetWidth()
Definition: G4QPDGCode.cc:740
G4QPDGCode::GetExQContent
G4QContent GetExQContent(G4int i, G4int o) const
Definition: G4QPDGCode.cc:2244
G4QPDGCode::GetPDGCode
G4int GetPDGCode() const
Definition: G4QPDGCode.hh:326
G4QPDGCode::InitByQCont
void InitByQCont(G4QContent QCont)
Definition: G4QPDGCode.hh:348
G4QPDGCode::GetNumOfComb
G4int GetNumOfComb(G4int i, G4int o) const
Definition: G4QPDGCode.cc:2347
G4QPDGCode::G4QPDGCode
G4QPDGCode(G4int PDGCode=0)
Definition: G4QPDGCode.cc:54
G4QPDGCode::InitByQCode
void InitByQCode(G4int QCode)
Definition: G4QPDGCode.hh:356
G4QPDGCode::TestRealNeutral
G4bool TestRealNeutral()
Definition: G4QPDGCode.hh:337
G4QPDGCode::operator=
const G4QPDGCode & operator=(const G4QPDGCode &rhs)
Definition: G4QPDGCode.cc:105
G4QPDGCode::GetMass
G4double GetMass()
Definition: G4QPDGCode.cc:693
G4QPDGCode::GetNuclMass
G4double GetNuclMass(G4int Z, G4int N, G4int S)
Definition: G4QPDGCode.cc:766
G4QPDGCode::ConvertPDGToZNS
void ConvertPDGToZNS(G4int PDG, G4int &z, G4int &n, G4int &s)
Definition: G4QPDGCode.cc:2377
G4QPDGCode::GetRelCrossIndex
G4int GetRelCrossIndex(G4int i, G4int o) const
Definition: G4QPDGCode.cc:2259
G4QPDGCode::GetQCode
G4int GetQCode() const
Definition: G4QPDGCode.hh:327
G4QPDGCode::GetTotNumOfComb
G4int GetTotNumOfComb(G4int i) const
Definition: G4QPDGCode.cc:2368
G4QPDGCode::MakeTwoBaryons
std::pair< G4int, G4int > MakeTwoBaryons(G4int L1, G4int L2, G4int R1, G4int R2)
Definition: G4QPDGCode.cc:2413
G4SigmaMinus::SigmaMinus
static G4SigmaMinus * SigmaMinus()
Definition: G4SigmaMinus.cc:106
G4SigmaPlus::SigmaPlus
static G4SigmaPlus * SigmaPlus()
Definition: G4SigmaPlus.cc:108
G4SigmaZero::SigmaZero
static G4SigmaZero * SigmaZero()
Definition: G4SigmaZero.cc:99
G4TauMinus::TauMinus
static G4TauMinus * TauMinus()
Definition: G4TauMinus.cc:135
G4Triton::Triton
static G4Triton * Triton()
Definition: G4Triton.cc:95
G4XiMinus::XiMinus
static G4XiMinus * XiMinus()
Definition: G4XiMinus.cc:106
G4XiZero::XiZero
static G4XiZero * XiZero()
Definition: G4XiZero.cc:106