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