Geant4  10.01.p03
G4ExcitedDeltaConstructor.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: G4ExcitedDeltaConstructor.cc 79342 2014-02-24 11:42:42Z gcosmo $
28 //
29 //
30 // --------------------------------------------------------------
31 // GEANT 4 class implementation file
32 //
33 // History: first implementation, based on object model of
34 // 10 oct 1998 H.Kurashige
35 // ---------------------------------------------------------------
36 
37 
39 
40 #include "G4SystemOfUnits.hh"
41 #include "G4ParticleDefinition.hh"
42 #include "G4ParticleTable.hh"
44 #include "G4VDecayChannel.hh"
45 #include "G4DecayTable.hh"
46 
47 
49  G4ExcitedBaryonConstructor(NStates, DeltaIsoSpin)
50 {
51 
52 }
53 
55 {
56 }
57 
59 {
61  // Delta has exceptinal encoding
62  if ((idxState==1)||(idxState==3)||(idxState==4)||(idxState==5)||(idxState==7)) {
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 }
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][NRho]) >0.0) {
105  AddNRhoMode( decayTable, parentName, br, iIso3, fAnti);
106  }
107 
108  if ( (br=bRatio[iState][DeltaPi]) >0.0) {
109  AddDeltaPiMode( decayTable, parentName, br, iIso3, fAnti);
110  }
111 
112  if ( (br=bRatio[iState][NStarPi]) >0.0) {
113  AddNStarPiMode( decayTable, parentName, br, iIso3, fAnti);
114  }
115 
116  return decayTable;
117 }
118 
120  G4DecayTable* decayTable, const G4String& nameParent,
121  G4double br, G4int iIso3, G4bool fAnti)
122 {
123  G4VDecayChannel* mode;
124 
125  //
126  G4String daughterN;
127  if (iIso3 == +1) {
128  daughterN = "proton";
129  } else if (iIso3 == -1) {
130  daughterN = "neutron";
131  } else {
132  // can not decay into N+gamma
133  return decayTable;
134  }
135 
136  if (fAnti) daughterN = "anti_" + daughterN;
137 
138  // create decay channel [parent BR #daughters]
139  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
140  daughterN,"gamma");
141  // add decay table
142  decayTable->Insert(mode);
143 
144  return decayTable;
145 }
146 
148  G4DecayTable* decayTable, const G4String& nameParent,
149  G4double br, G4int iIso3, G4bool fAnti)
150 {
151  G4VDecayChannel* mode;
152 
153  G4String daughterN;
154  G4String daughterPi;
155  G4double r = 0.;
156 
157  // ------------ N pi0 ------------
158  // determine daughters
159  if ((iIso3 == +1)||(iIso3 == -1)) {
160  if (iIso3 == +1) {
161  daughterN = "proton";
162  daughterPi = "pi0";
163  r = br*2./3.;
164  } else if (iIso3 == -1) {
165  daughterN = "neutron";
166  daughterPi = "pi0";
167  r = br/3.;
168  }
169  if (fAnti) daughterN = "anti_" + daughterN;
170  // create decay channel [parent BR #daughters]
171  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
172  daughterN,daughterPi);
173  // add decay table
174  decayTable->Insert(mode);
175  }
176 
177  // -------------N pi +/- --------------
178  // determine daughters
179  if (iIso3 == +3) {
180  daughterN = "proton";
181  if (!fAnti) {
182  daughterPi = "pi+";
183  } else {
184  daughterPi = "pi-";
185  }
186  r = br;
187  } else if (iIso3 == +1) {
188  daughterN = "neutron";
189  if (!fAnti) {
190  daughterPi = "pi+";
191  } else {
192  daughterPi = "pi-";
193  }
194  r = br/3.;
195  } else if (iIso3 == -1) {
196  daughterN = "proton";
197  if (!fAnti) {
198  daughterPi = "pi-";
199  } else {
200  daughterPi = "pi+";
201  }
202  r = br*2./3.;
203  } else if (iIso3 == -3) {
204  daughterN = "neutron";
205  if (!fAnti) {
206  daughterPi = "pi-";
207  } else {
208  daughterPi = "pi+";
209  }
210  r = br;
211  }
212  if (fAnti) daughterN = "anti_" + daughterN;
213 
214  // create decay channel [parent BR #daughters]
215  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
216  daughterN,daughterPi);
217  // add decay table
218  decayTable->Insert(mode);
219 
220  return decayTable;
221 }
222 
223 
225  G4DecayTable* decayTable, const G4String& nameParent,
226  G4double br, G4int iIso3, G4bool fAnti)
227 {
228  G4VDecayChannel* mode;
229 
230  G4String daughterN;
231  G4String daughterRho;
232  G4double r = 0.;
233 
234  // ------------ N Rho0 ------------
235  // determine daughters
236  if ((iIso3 == +1)||(iIso3 == -1)) {
237  if (iIso3 == +1) {
238  daughterN = "proton";
239  daughterRho = "rho0";
240  r = br*2./3.;
241  } else if (iIso3 == -1) {
242  daughterN = "neutron";
243  daughterRho = "rho0";
244  r = br/3.;
245  }
246  if (fAnti) daughterN = "anti_" + daughterN;
247  // create decay channel [parent BR #daughters]
248  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
249  daughterN,daughterRho);
250  // add decay table
251  decayTable->Insert(mode);
252  }
253 
254  // -------------N Rho +/- --------------
255  // determine daughters
256  if (iIso3 == +3) {
257  daughterN = "proton";
258  if (!fAnti) {
259  daughterRho = "rho+";
260  } else {
261  daughterRho = "rho-";
262  }
263  r = br;
264  } else if (iIso3 == +1) {
265  daughterN = "neutron";
266  if (!fAnti) {
267  daughterRho = "rho+";
268  } else {
269  daughterRho = "rho-";
270  }
271  r = br/3.;
272  } else if (iIso3 == -1) {
273  daughterN = "proton";
274  if (!fAnti) {
275  daughterRho = "rho-";
276  } else {
277  daughterRho = "rho+";
278  }
279  r = br*2./3.;
280  } else if (iIso3 == -3) {
281  daughterN = "neutron";
282  if (!fAnti) {
283  daughterRho = "rho-";
284  } else {
285  daughterRho = "rho+";
286  }
287  r = br;
288  }
289  if (fAnti) daughterN = "anti_" + daughterN;
290 
291  // create decay channel [parent BR #daughters]
292  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
293  daughterN,daughterRho);
294  // add decay table
295  decayTable->Insert(mode);
296 
297  return decayTable;
298 }
299 
301  G4DecayTable* decayTable, const G4String& nameParent,
302  G4double br, G4int iIso3, G4bool fAnti)
303 {
304  G4VDecayChannel* mode;
305 
306  G4String daughterN;
307  G4String daughterPi;
308  G4double r = 0.;
309 
310  // ------------ N pi0 ------------
311  // determine daughters
312  if ((iIso3 == +1)||(iIso3 == -1)) {
313  if (iIso3 == +1) {
314  daughterN = "N(1440)+";
315  daughterPi = "pi0";
316  r = br*2./3.;
317  } else if (iIso3 == -1) {
318  daughterN = "N(1440)0";
319  daughterPi = "pi0";
320  r = br/3.;
321  }
322  if (fAnti) daughterN = "anti_" + daughterN;
323  // create decay channel [parent BR #daughters]
324  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
325  daughterN,daughterPi);
326  // add decay table
327  decayTable->Insert(mode);
328  }
329 
330  // -------------N pi +/- --------------
331  // determine daughters
332  if (iIso3 == +3) {
333  daughterN = "N(1440)+";
334  if (!fAnti) {
335  daughterPi = "pi+";
336  } else {
337  daughterPi = "pi-";
338  }
339  r = br;
340  } else if (iIso3 == +1) {
341  daughterN = "N(1440)0";
342  if (!fAnti) {
343  daughterPi = "pi+";
344  } else {
345  daughterPi = "pi-";
346  }
347  r = br/3.;
348  } else if (iIso3 == -1) {
349  daughterN = "N(1440)+";
350  if (!fAnti) {
351  daughterPi = "pi-";
352  } else {
353  daughterPi = "pi+";
354  }
355  r = br*2./3.;
356  } else if (iIso3 == -3) {
357  daughterN = "N(1440)0";
358  if (!fAnti) {
359  daughterPi = "pi-";
360  } else {
361  daughterPi = "pi+";
362  }
363  r = br;
364  }
365  if (fAnti) daughterN = "anti_" + daughterN;
366 
367  // create decay channel [parent BR #daughters]
368  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
369  daughterN,daughterPi);
370  // add decay table
371  decayTable->Insert(mode);
372 
373  return decayTable;
374 }
375 
377  G4DecayTable* decayTable, const G4String& nameParent,
378  G4double br, G4int iIso3, G4bool fAnti)
379 {
380  G4VDecayChannel* mode;
381 
382  G4String daughterDelta;
383  G4String daughterPi;
384  G4double r;
385 
386  // ------------ Delta pi +------------
387  // determine daughters
388  if (iIso3 == +3) {
389  daughterDelta = "delta+";
390  r = br*0.4;
391  } else if (iIso3 == +1) {
392  daughterDelta = "delta0";
393  r = br*8./15.0;
394  } else if (iIso3 == -1) {
395  daughterDelta = "delta-";
396  r = br*6./15.;
397  } else {
398  r = 0.;
399  }
400  if (!fAnti) {
401  daughterPi = "pi+";
402  } else {
403  daughterPi = "pi-";
404  }
405  if (fAnti) daughterDelta = "anti_" + daughterDelta;
406  if (r>0.0) {
407  // create decay channel [parent BR #daughters]
408  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
409  daughterDelta,daughterPi);
410  // add decay table
411  decayTable->Insert(mode);
412  }
413 
414  // ------------ Delta pi0 ------------
415  // determine daughters
416  if (iIso3 == +3) {
417  daughterDelta = "delta++";
418  r = br*0.6;
419  } else if (iIso3 == +1) {
420  daughterDelta = "delta+";
421  r = br*1./15.0;
422  } else if (iIso3 == -1) {
423  daughterDelta = "delta0";
424  r = br*1./15.;
425  } else {
426  daughterDelta = "delta-";
427  r = br*0.6;
428  }
429  daughterPi = "pi0";
430  if (fAnti) daughterDelta = "anti_" + daughterDelta;
431 
432  // create decay channel [parent BR #daughters]
433  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
434  daughterDelta,daughterPi);
435  // add decay table
436  decayTable->Insert(mode);
437 
438  // ------------ Delta pi - -------------
439  // determine daughters
440  if (iIso3 == +3) {
441  r= 0.;
442  } else if (iIso3 == +1) {
443  daughterDelta = "delta++";
444  r = br*6./15.0;
445  } else if (iIso3 == -1) {
446  daughterDelta = "delta+";
447  r = br*8./15.;
448  } else {
449  daughterDelta = "delta0";
450  r = br*0.4;
451  }
452  if (!fAnti) {
453  daughterPi = "pi-";
454  } else {
455  daughterPi = "pi+";
456  }
457  if (fAnti) daughterDelta = "anti_" + daughterDelta;
458  if (r>0.0) {
459  // create decay channel [parent BR #daughters]
460  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
461  daughterDelta,daughterPi);
462  // add decay table
463  decayTable->Insert(mode);
464  }
465 
466  return decayTable;
467 }
468 
469 const char* G4ExcitedDeltaConstructor::name[] =
470 {
471  "delta(1600)", "delta(1620)", "delta(1700)", "delta(1900)", "delta(1905)",
472  "delta(1910)", "delta(1920)", "delta(1930)", "delta(1950)"
473 };
474 
476 {
477  1.600*GeV, 1.630*GeV, 1.700*GeV, 1.900*GeV, 1.880*GeV,
478  1.890*GeV, 1.920*GeV, 1.950*GeV, 1.930*GeV
479 };
480 
482  320.0*MeV, 140.0*MeV, 300.0*MeV, 200.0*MeV, 330.0*MeV,
483  280.0*MeV, 260.0*MeV, 360.0*MeV, 280.0*MeV
484 };
485 
487 {
488  3, 1, 3, 1, 5,
489  1, 3, 5, 7
490 };
491 
493  +1, -1, -1, -1, +1,
494  +1, +1, -1, +1
495 };
496 
498  30000, 0, 10000, 10000, 0,
499  20000, 20000, 10000, 0
500 };
501 
503 {
504 // NGamma Npi NRho DeltaPi N*Pi
505  { 0.0, 0.15, 0.0, 0.55, 0.30 },
506  { 0.0, 0.25, 0.0, 0.60, 0.15 },
507  { 0.0, 0.20, 0.10, 0.55, 0.15 },
508  { 0.0, 0.30, 0.15, 0.30, 0.25 },
509  { 0.0, 0.20, 0.60, 0.10, 0.10 },
510  { 0.0, 0.35, 0.40, 0.15, 0.10 },
511  { 0.0, 0.15, 0.30, 0.30, 0.25 },
512  { 0.0, 0.20, 0.25, 0.25, 0.30 },
513  { 0.01, 0.44, 0.15, 0.20, 0.20 }
514 };
515 
516 
517 
518 
519 
520 
521 
522 
523 
524 
525 
526 
527 
528 
529 
530 
static const double MeV
Definition: G4SIunits.hh:193
virtual G4int GetiSpin(G4int iState)
static const G4double mass[NStates]
G4DecayTable * AddNPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
static const G4double bRatio[NStates][NumberOfDecayModes]
G4DecayTable * AddNGammaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
static const char * name[NStates]
G4DecayTable * AddDeltaPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
int G4int
Definition: G4Types.hh:78
G4DecayTable * AddNStarPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
virtual G4int GetEncoding(G4int iIsoSpin3, G4int idxState)
virtual G4DecayTable * CreateDecayTable(const G4String &name, G4int iIso3, G4int iState, G4bool fAnti=false)
bool G4bool
Definition: G4Types.hh:79
static const double GeV
Definition: G4SIunits.hh:196
virtual G4int GetEncodingOffset(G4int iState)
#define encoding
Definition: xmlparse.cc:588
void Insert(G4VDecayChannel *aChannel)
Definition: G4DecayTable.cc:60
static const G4double width[NStates]
G4DecayTable * AddNRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
static const G4int encodingOffset[NStates]
virtual G4int GetEncoding(G4int iIsoSpin3, G4int idxState)
static const G4int iParity[NStates]
double G4double
Definition: G4Types.hh:76
virtual G4int GetQuarkContents(G4int, G4int)
static const G4int iSpin[NStates]