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