ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4ExcitedNucleonConstructor.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file G4ExcitedNucleonConstructor.cc
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 //
27 //
28 //
29 // --------------------------------------------------------------
30 // GEANT 4 class implementation file
31 // History: first implementation, based on object model of
32 // 10 oct 1998 H.Kurashige
33 // ---------------------------------------------------------------
34 
35 
36 #include "G4ExcitedNucleonConstructor.hh"
37 
38 #include "G4SystemOfUnits.hh"
39 #include "G4ParticleDefinition.hh"
40 #include "G4ParticleTable.hh"
41 #include "G4PhaseSpaceDecayChannel.hh"
42 #include "G4VDecayChannel.hh"
43 #include "G4DecayTable.hh"
44 
45 
46 G4ExcitedNucleonConstructor::G4ExcitedNucleonConstructor():
47  G4ExcitedBaryonConstructor(NStates, NucleonIsoSpin)
48 {
49 
50 }
51 
52 G4ExcitedNucleonConstructor::~G4ExcitedNucleonConstructor()
53 {
54 }
55 
56 G4int G4ExcitedNucleonConstructor::GetEncoding(G4int iIsoSpin3, G4int idxState)
57 {
58  G4int encoding;
59  // Delta has exceptinal encoding
60  if ((idxState==1)||(idxState==6)||(idxState==8)||(idxState==9)||(idxState==12) ) {
61  encoding = GetEncodingOffset(idxState);
62  if ((iIsoSpin3==3)||(iIsoSpin3==-3)) {
63  // normal encoding
64  encoding += 1000*GetQuarkContents(0, iIsoSpin3);
65  encoding += 100*GetQuarkContents(1, iIsoSpin3);
66  encoding += 10*GetQuarkContents(2, iIsoSpin3);
67  } else if (iIsoSpin3== +1){
68  // 1st <--> 2nd quark
69  encoding += 1000*GetQuarkContents(0, iIsoSpin3);
70  encoding += 10*GetQuarkContents(1, iIsoSpin3);
71  encoding += 100*GetQuarkContents(2, iIsoSpin3);
72  } else if (iIsoSpin3== -1){
73  // 1st <--> 0th quark
74  encoding += 100*GetQuarkContents(0, iIsoSpin3);
75  encoding += 1000*GetQuarkContents(1, iIsoSpin3);
76  encoding += 10*GetQuarkContents(2, iIsoSpin3);
77  }
78  encoding += GetiSpin(idxState) +1;
79  } else {
80  encoding = G4ExcitedBaryonConstructor::GetEncoding(iIsoSpin3, idxState);
81  }
82  return encoding;
83 }
84 
85 G4DecayTable* G4ExcitedNucleonConstructor::CreateDecayTable(
86  const G4String& parentName,
87  G4int iIso3,
88  G4int iState,
89  G4bool fAnti)
90 {
91  // create decay table
92  G4DecayTable* decayTable = new G4DecayTable();
93 
94  G4double br;
95  if ( (br=bRatio[iState][NGamma]) >0.0) {
96  AddNGammaMode( decayTable, parentName, br, iIso3, fAnti);
97  }
98 
99  if ( (br=bRatio[iState][NPi]) >0.0) {
100  AddNPiMode( decayTable, parentName, br, iIso3, fAnti);
101  }
102 
103  if ( (br=bRatio[iState][NEta]) >0.0) {
104  AddNEtaMode( decayTable, parentName, br, iIso3, fAnti);
105  }
106 
107  if ( (br=bRatio[iState][NOmega]) >0.0) {
108  AddNOmegaMode( decayTable, parentName, br, iIso3, fAnti);
109  }
110 
111  if ( (br=bRatio[iState][NRho]) >0.0) {
112  AddNRhoMode( decayTable, parentName, br, iIso3, fAnti);
113  }
114 
115  if ( (br=bRatio[iState][N2Pi]) >0.0) {
116  AddN2PiMode( decayTable, parentName, br, iIso3, fAnti);
117  }
118 
119  if ( (br=bRatio[iState][DeltaPi]) >0.0) {
120  AddDeltaPiMode( decayTable, parentName, br, iIso3, fAnti);
121  }
122 
123  if ( (br=bRatio[iState][NStarPi]) >0.0) {
124  AddNStarPiMode( decayTable, parentName, br, iIso3, fAnti);
125  }
126 
127  if ( (br=bRatio[iState][LambdaK]) >0.0) {
128  AddLambdaKMode( decayTable, parentName, br, iIso3, fAnti);
129  }
130 
131  return decayTable;
132 }
133 
134 G4DecayTable* G4ExcitedNucleonConstructor::AddNGammaMode(
135  G4DecayTable* decayTable, const G4String& nameParent,
136  G4double br, G4int iIso3, G4bool fAnti)
137 {
138  G4VDecayChannel* mode;
139 
140  //
141  G4String daughterN;
142  if (iIso3 == +1) {
143  daughterN = "proton";
144  } else {
145  daughterN = "neutron";
146  }
147  if (fAnti) daughterN = "anti_" + daughterN;
148 
149  // create decay channel [parent BR #daughters]
150  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
151  daughterN,"gamma");
152  // add decay table
153  decayTable->Insert(mode);
154 
155  return decayTable;
156 }
157 
158 G4DecayTable* G4ExcitedNucleonConstructor::AddNPiMode(
159  G4DecayTable* decayTable, const G4String& nameParent,
160  G4double br, G4int iIso3, G4bool fAnti)
161 {
162  G4VDecayChannel* mode;
163 
164  G4String daughterN;
165  G4String daughterPi;
166 
167  // ------------ N pi0 ------------
168  // determine daughters
169  if (iIso3 == +1) {
170  daughterN = "proton";
171  daughterPi = "pi0";
172  } else {
173  daughterN = "neutron";
174  daughterPi = "pi0";
175  }
176  if (fAnti) daughterN = "anti_" + daughterN;
177  // create decay channel [parent BR #daughters]
178  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
179  daughterN,daughterPi);
180  // add decay table
181  decayTable->Insert(mode);
182 
183  // -------------N pi +/- --------------
184  // determine daughters
185  if (iIso3 == +1) {
186  daughterN = "neutron";
187  if (!fAnti) {
188  daughterPi = "pi+";
189  } else {
190  daughterPi = "pi-";
191  }
192  } else {
193  daughterN = "proton";
194  if (!fAnti) {
195  daughterPi = "pi-";
196  } else {
197  daughterPi = "pi+";
198  }
199  }
200  if (fAnti) daughterN = "anti_" + daughterN;
201 
202  // create decay channel [parent BR #daughters]
203  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
204  daughterN,daughterPi);
205  // add decay table
206  decayTable->Insert(mode);
207 
208  return decayTable;
209 }
210 
211 G4DecayTable* G4ExcitedNucleonConstructor::AddNEtaMode(
212  G4DecayTable* decayTable, const G4String& nameParent,
213  G4double br, G4int iIso3, G4bool fAnti)
214 {
215  G4VDecayChannel* mode;
216 
217  G4String daughterN;
218 
219  // ------------ N eta------------
220  // determine daughters
221  if (iIso3 == +1) {
222  daughterN = "proton";
223  } else {
224  daughterN = "neutron";
225  }
226  if (fAnti) daughterN = "anti_" + daughterN;
227  // create decay channel [parent BR #daughters]
228  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
229  daughterN, "eta");
230  // add decay table
231  decayTable->Insert(mode);
232 
233  return decayTable;
234 }
235 
236 G4DecayTable* G4ExcitedNucleonConstructor::AddNOmegaMode(
237  G4DecayTable* decayTable, const G4String& nameParent,
238  G4double br, G4int iIso3, G4bool fAnti)
239 {
240  G4VDecayChannel* mode;
241 
242  G4String daughterN;
243 
244  // ------------ N omega------------
245  // determine daughters
246  if (iIso3 == +1) {
247  daughterN = "proton";
248  } else {
249  daughterN = "neutron";
250  }
251  if (fAnti) daughterN = "anti_" + daughterN;
252  // create decay channel [parent BR #daughters]
253  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
254  daughterN, "omega");
255  // add decay table
256  decayTable->Insert(mode);
257 
258  return decayTable;
259 }
260 
261 G4DecayTable* G4ExcitedNucleonConstructor::AddNRhoMode(
262  G4DecayTable* decayTable, const G4String& nameParent,
263  G4double br, G4int iIso3, G4bool fAnti)
264 {
265  G4VDecayChannel* mode;
266 
267  G4String daughterN;
268  G4String daughterRho;
269 
270  // ------------ N rho0 ------------
271  // determine daughters
272  if (iIso3 == +1) {
273  daughterN = "proton";
274  daughterRho = "rho0";
275  } else {
276  daughterN = "neutron";
277  daughterRho = "rho0";
278  }
279  if (fAnti) daughterN = "anti_" + daughterN;
280  // create decay channel [parent BR #daughters]
281  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
282  daughterN,daughterRho);
283  // add decay table
284  decayTable->Insert(mode);
285 
286  // -------------N rho+/- --------------
287  // determine daughters
288  if (iIso3 == +1) {
289  daughterN = "neutron";
290  if (!fAnti) {
291  daughterRho = "rho+";
292  } else {
293  daughterRho = "rho-";
294  }
295  } else {
296  daughterN = "proton";
297  if (!fAnti) {
298  daughterRho = "rho-";
299  } else {
300  daughterRho = "rho+";
301  }
302  }
303  if (fAnti) daughterN = "anti_" + daughterN;
304 
305  // create decay channel [parent BR #daughters]
306  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
307  daughterN,daughterRho);
308  // add decay table
309  decayTable->Insert(mode);
310 
311  return decayTable;
312 }
313 
314 G4DecayTable* G4ExcitedNucleonConstructor::AddN2PiMode(
315  G4DecayTable* decayTable, const G4String& nameParent,
316  G4double br, G4int iIso3, G4bool fAnti)
317 {
318  // Decay Modes
319  // N* --> N + pi + pi
320  // Only I=0 states are included for 2-pi system
321 
322  G4VDecayChannel* mode;
323 
324  G4String daughterN;
325  G4String daughterPi1;
326  G4String daughterPi2;
327 
328  // -------------N pi+ pi- --------------
329  // determine daughters
330  if (iIso3 == +1) {
331  daughterN = "proton";
332  daughterPi1 = "pi+";
333  daughterPi2 = "pi-";
334  } else {
335  daughterN = "neutron";
336  daughterPi1 = "pi+";
337  daughterPi2 = "pi-";
338  }
339  if (fAnti) daughterN = "anti_" + daughterN;
340 
341  // create decay channel [parent BR #daughters]
342  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 3,
343  daughterN,daughterPi1,daughterPi2);
344  // add decay table
345  decayTable->Insert(mode);
346 
347  // -------------N pi0 pi0 --------------
348  // determine daughters
349  if (iIso3 == +1) {
350  daughterN = "proton";
351  daughterPi1 = "pi0";
352  daughterPi2 = "pi0";
353  } else {
354  daughterN = "neutron";
355  daughterPi1 = "pi0";
356  daughterPi2 = "pi0";
357  }
358  if (fAnti) daughterN = "anti_" + daughterN;
359 
360  // create decay channel [parent BR #daughters]
361  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 3,
362  daughterN,daughterPi1,daughterPi2);
363  // add decay table
364  decayTable->Insert(mode);
365 
366  return decayTable;
367 }
368 
369 G4DecayTable* G4ExcitedNucleonConstructor::AddNStarPiMode(
370  G4DecayTable* decayTable, const G4String& nameParent,
371  G4double br, G4int iIso3, G4bool fAnti)
372 {
373  G4VDecayChannel* mode;
374 
375  G4String daughterN;
376  G4String daughterPi;
377 
378  // ------------ N pi0 ------------
379  // determine daughters
380  if (iIso3 == +1) {
381  daughterN = "N(1440)+";
382  daughterPi = "pi0";
383  } else {
384  daughterN = "N(1440)0";
385  daughterPi = "pi0";
386  }
387  if (fAnti) daughterN = "anti_" + daughterN;
388  // create decay channel [parent BR #daughters]
389  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
390  daughterN,daughterPi);
391  // add decay table
392  decayTable->Insert(mode);
393 
394  // -------------N pi +/- --------------
395  // determine daughters
396  if (iIso3 == +1) {
397  daughterN = "N(1440)0";
398  if (!fAnti) {
399  daughterPi = "pi+";
400  } else {
401  daughterPi = "pi-";
402  }
403  } else {
404  daughterN = "N(1440)+";
405  if (!fAnti) {
406  daughterPi = "pi-";
407  } else {
408  daughterPi = "pi+";
409  }
410  }
411  if (fAnti) daughterN = "anti_" + daughterN;
412 
413  // create decay channel [parent BR #daughters]
414  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
415  daughterN,daughterPi);
416  // add decay table
417  decayTable->Insert(mode);
418 
419  return decayTable;
420 }
421 
422 G4DecayTable* G4ExcitedNucleonConstructor::AddDeltaPiMode(
423  G4DecayTable* decayTable, const G4String& nameParent,
424  G4double br, G4int iIso3, G4bool fAnti)
425 {
426  G4VDecayChannel* mode;
427 
428  G4String daughterDelta;
429  G4String daughterPi;
430  G4double r;
431 
432  // ------------ Delta pi+/- ------------
433  // determine daughters
434  if (iIso3 == +1) {
435  daughterDelta = "delta0";
436  if (!fAnti) {
437  daughterPi = "pi+";
438  } else {
439  daughterPi = "pi-";
440  }
441  r = br/6.0;
442  } else {
443  daughterDelta = "delta+";
444  if (!fAnti) {
445  daughterPi = "pi-";
446  } else {
447  daughterPi = "pi+";
448  }
449  r = br/6.0;
450  }
451  if (fAnti) daughterDelta = "anti_" + daughterDelta;
452  // create decay channel [parent BR #daughters]
453  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
454  daughterDelta,daughterPi);
455  // add decay table
456  decayTable->Insert(mode);
457 
458  // ------------ Delta pi+/- ------------
459  // determine daughters
460  if (iIso3 == +1) {
461  daughterDelta = "delta++";
462  if (!fAnti) {
463  daughterPi = "pi-";
464  } else {
465  daughterPi = "pi+";
466  }
467  r = br/2.0;
468  } else {
469  daughterDelta = "delta-";
470  if (!fAnti) {
471  daughterPi = "pi+";
472  } else {
473  daughterPi = "pi-";
474  }
475  r = br/2.0;
476  }
477  if (fAnti) daughterDelta = "anti_" + daughterDelta;
478  // create decay channel [parent BR #daughters]
479  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
480  daughterDelta,daughterPi);
481  // add decay table
482  decayTable->Insert(mode);
483 
484  // ------------ Delta pi0 ------------
485  // determine daughters
486  if (iIso3 == +1) {
487  daughterDelta = "delta+";
488  daughterPi = "pi0";
489  r = br/3.0;
490  } else {
491  daughterDelta = "delta0";
492  daughterPi = "pi0";
493  r = br/3.0;
494  }
495  if (fAnti) daughterDelta = "anti_" + daughterDelta;
496  // create decay channel [parent BR #daughters]
497  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
498  daughterDelta,daughterPi);
499  // add decay table
500  decayTable->Insert(mode);
501 
502 
503  return decayTable;
504 }
505 
506 G4DecayTable* G4ExcitedNucleonConstructor::AddLambdaKMode(
507  G4DecayTable* decayTable, const G4String& nameParent,
508  G4double br, G4int iIso3, G4bool fAnti)
509 {
510  G4VDecayChannel* mode;
511 
512  G4String lambda = "lambda";
513  G4String daughterK;
514 
515  // ------------ N pi0 ------------
516  // determine daughters
517  if (iIso3 == +1) {
518  if (!fAnti) {
519  daughterK = "kaon+";
520  } else {
521  daughterK = "kaon-";
522  }
523  } else {
524  if (!fAnti) {
525  daughterK = "kaon0";
526  } else {
527  daughterK = "anti_kaon0";
528  }
529  }
530  if (fAnti) lambda = "anti_" + lambda;
531  // create decay channel [parent BR #daughters]
532  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
533  lambda, daughterK);
534  // add decay table
535  decayTable->Insert(mode);
536 
537  return decayTable;
538 }
539 
540 // PDG2005
541 // N(2090) is renamed to N(2080)
542 // but keep unchanged temporalily Apr 06
543 
544 const char* G4ExcitedNucleonConstructor::name[] = {
545  "N(1440)", "N(1520)", "N(1535)", "N(1650)", "N(1675)",
546  "N(1680)", "N(1700)", "N(1710)", "N(1720)", "N(1900)",
547  "N(1990)", "N(2090)", "N(2190)", "N(2220)", "N(2250)"
548 };
549 
550 const G4double G4ExcitedNucleonConstructor::mass[] = {
551  1.430*GeV, 1.515*GeV, 1.535*GeV, 1.655*GeV, 1.675*GeV,
552  1.685*GeV, 1.700*GeV, 1.710*GeV, 1.720*GeV, 1.900*GeV,
553  1.950*GeV, 2.080*GeV, 2.190*GeV, 2.250*GeV, 2.275*GeV
554 };
555 
556 const G4double G4ExcitedNucleonConstructor::width[] = {
557  350.0*MeV, 115.0*MeV, 150.0*MeV, 140.0*MeV, 150.0*MeV,
558  130.0*MeV, 150.0*MeV, 100.0*MeV, 250.0*MeV, 500.0*MeV,
559  555.0*MeV, 350.0*MeV, 500.0*MeV, 400.0*MeV, 500.0*MeV
560 };
561 
562 const G4int G4ExcitedNucleonConstructor::iSpin[] = {
563  1, 3, 1, 1, 5,
564  5, 3, 1, 3, 3,
565  7, 3, 7, 9, 9
566 };
567 
568 const G4int G4ExcitedNucleonConstructor::iParity[] = {
569  +1, -1, -1, -1, -1,
570  +1, -1, +1, +1, +1,
571  +1, -1, +1, -1, -1
572 };
573 
574 const G4int G4ExcitedNucleonConstructor::encodingOffset[] = {
575  10000, 0, 20000, 30000, 0,
576  10000, 20000, 40000, 30000, 40000,
577  10000, 50000, 0, 0, 10000
578 };
579 
580 const G4double G4ExcitedNucleonConstructor::bRatio[ G4ExcitedNucleonConstructor::NStates ][ G4ExcitedNucleonConstructor::NumberOfDecayModes] =
581 {
582  { 0.0, 0.70, 0.0, 0.0, 0.0, 0.05, 0.25, 0.0, 0.0},
583  { 0.0, 0.60, 0.0, 0.0, 0.0, 0.15, 0.25, 0.0, 0.0},
584  {0.001, 0.55, 0.35, 0.0, 0.0, 0.05, 0.00, 0.05, 0.0},
585  { 0.0, 0.65, 0.05, 0.0, 0.0, 0.05, 0.10, 0.05, 0.10},
586  { 0.0, 0.45, 0.0, 0.0, 0.0, 0.00, 0.55, 0.0, 0.0},
587  { 0.0, 0.65, 0.0, 0.0, 0.0, 0.20, 0.15, 0.0, 0.0},
588  { 0.0, 0.10, 0.05, 0.0, 0.05, 0.45, 0.35, 0.0, 0.0},
589  { 0.0, 0.15, 0.20, 0.0, 0.05, 0.20, 0.20, 0.10, 0.10},
590  { 0.0, 0.15, 0.00, 0.0, 0.25, 0.45, 0.10, 0.00, 0.05},
591  { 0.0, 0.35, 0.0, 0.55, 0.05, 0.00, 0.05, 0.0, 0.0},
592  { 0.0, 0.05, 0.0, 0.0, 0.15, 0.25, 0.30, 0.15, 0.10},
593  { 0.0, 0.60, 0.05, 0.0, 0.25, 0.05, 0.05, 0.0, 0.0},
594  { 0.0, 0.35, 0.0, 0.00, 0.30, 0.15, 0.15, 0.05, 0.0},
595  { 0.0, 0.35, 0.0, 0.0, 0.25, 0.20, 0.20, 0.0, 0.0},
596  { 0.0, 0.30, 0.0, 0.00, 0.25, 0.20, 0.20, 0.05, 0.0}
597 };
598 
599 
600 
601 
602 
603 
604 
605 
606 
607 
608 
609 
610 
611 
612 
613