source: trunk/source/particles/shortlived/src/G4ExcitedNucleonConstructor.cc @ 1202

Last change on this file since 1202 was 1196, checked in by garnier, 15 years ago

update CVS release candidate geant4.9.3.01
File size: 17.4 KB
Line 
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,v 1.11 2006/06/29 19:27:08 gunter Exp $
28// GEANT4 tag $Name: geant4-09-03-cand-01 $
29//
30//
31// --------------------------------------------------------------
32//      GEANT 4 class implementation file
33//      History: first implementation, based on object model of
34//      10 oct 1998  H.Kurashige
35// ---------------------------------------------------------------
36
37
38#include "G4ExcitedNucleonConstructor.hh"
39
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
48G4ExcitedNucleonConstructor::G4ExcitedNucleonConstructor():
49    G4ExcitedBaryonConstructor(NStates, NucleonIsoSpin)
50{
51
52}
53
54G4ExcitedNucleonConstructor::~G4ExcitedNucleonConstructor()
55{
56}
57
58G4int 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
87G4DecayTable* 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
136G4DecayTable*  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
160G4DecayTable*  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
213G4DecayTable*  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
238G4DecayTable*  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
263G4DecayTable*  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
316G4DecayTable*  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
371G4DecayTable*  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
424G4DecayTable*  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
508G4DecayTable*  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
546const 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
552const 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
558const 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
564const G4int G4ExcitedNucleonConstructor::iSpin[] = {
565    1,   3,   1,   1,   5,
566    5,   3,   1,   3,   3,
567    7,   3,   7,   9,   9
568};
569
570const G4int G4ExcitedNucleonConstructor::iParity[] = {
571  +1,  -1,   -1,  -1,  -1,
572  +1,  -1,   +1,  +1,  +1,
573  +1,  -1,   +1,  -1,  -1 
574};
575
576const G4int G4ExcitedNucleonConstructor::encodingOffset[] = {
577   10000,       0,  20000,  30000,       0,
578   10000,   20000,  40000,  30000,   40000, 
579   10000,   50000,       0,     0,   10000
580};
581
582const 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
Note: See TracBrowser for help on using the repository browser.