Geant4  10.00.p03
G4ExcitedLambdaConstructor.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: G4ExcitedLambdaConstructor.cc 72955 2013-08-14 14:23:14Z 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 
38 
39 #include "G4SystemOfUnits.hh"
40 #include "G4ParticleDefinition.hh"
41 #include "G4ParticleTable.hh"
43 #include "G4VDecayChannel.hh"
44 #include "G4DecayTable.hh"
45 
46 
48  G4ExcitedBaryonConstructor(NStates, LambdaIsoSpin)
49 {
50 
51 }
52 
54 {
55 }
56 
58  const G4String& parentName,
59  G4int iIso3,
60  G4int iState,
61  G4bool fAnti)
62 {
63  // create decay table
64  G4DecayTable* decayTable = new G4DecayTable();
65 
66  G4double br;
67  if ( (br=bRatio[iState][NK]) >0.0) {
68  AddNKMode( decayTable, parentName, br, iIso3, fAnti);
69  }
70 
71  if ( (br=bRatio[iState][NKStar]) >0.0) {
72  AddNKStarMode( decayTable, parentName, br, iIso3, fAnti);
73  }
74 
75  if ( (br=bRatio[iState][SigmaPi]) >0.0) {
76  AddSigmaPiMode( decayTable, parentName, br, iIso3, fAnti);
77  }
78 
79  if ( (br=bRatio[iState][SigmaStarPi]) >0.0) {
80  AddSigmaStarPiMode( decayTable, parentName, br, iIso3, fAnti);
81  }
82 
83  if ( (br=bRatio[iState][LambdaGamma]) >0.0) {
84  AddLambdaGammaMode( decayTable, parentName, br, iIso3, fAnti);
85  }
86 
87  if ( (br=bRatio[iState][LambdaEta]) >0.0) {
88  AddLambdaEtaMode( decayTable, parentName, br, iIso3, fAnti);
89  }
90 
91  if ( (br=bRatio[iState][LambdaOmega]) >0.0) {
92  AddLambdaOmegaMode( decayTable, parentName, br, iIso3, fAnti);
93  }
94 
95  return decayTable;
96 }
97 
99  G4DecayTable* decayTable, const G4String& nameParent,
100  G4double br, G4int , G4bool fAnti)
101 {
102  G4VDecayChannel* mode;
103 
104  //
105  G4String lambda = "lambda";
106  if (fAnti) lambda = "anti_" + lambda;
107 
108  // create decay channel [parent BR #daughters]
109  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
110  lambda,"gamma");
111  // add decay table
112  decayTable->Insert(mode);
113 
114  return decayTable;
115 }
117  G4DecayTable* decayTable, const G4String& nameParent,
118  G4double br, G4int , G4bool fAnti)
119 {
120  G4VDecayChannel* mode;
121 
122  //
123  G4String lambda = "lambda";
124  if (fAnti) lambda = "anti_" + lambda;
125 
126  // create decay channel [parent BR #daughters]
127  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
128  lambda,"eta");
129  // add decay table
130  decayTable->Insert(mode);
131 
132  return decayTable;
133 }
134 
136  G4DecayTable* decayTable, const G4String& nameParent,
137  G4double br, G4int , G4bool fAnti)
138 {
139  G4VDecayChannel* mode;
140 
141  //
142  G4String lambda = "lambda";
143  if (fAnti) lambda = "anti_" + lambda;
144 
145  // create decay channel [parent BR #daughters]
146  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
147  lambda,"omega");
148  // add decay table
149  decayTable->Insert(mode);
150 
151  return decayTable;
152 }
153 
155  G4DecayTable* decayTable, const G4String& nameParent,
156  G4double br, G4int , G4bool fAnti)
157 {
158  G4VDecayChannel* mode;
159 
160  G4String daughterN;
161  G4String daughterK;
162 
163  // ------------ N K- ------------
164  // determine daughters
165  daughterN = "proton";
166  if (!fAnti) {
167  daughterK = "kaon-";
168  } else {
169  daughterK = "kaon+";
170  }
171  if (fAnti) daughterN = "anti_" + daughterN;
172  // create decay channel [parent BR #daughters]
173  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
174  daughterN,daughterK);
175  // add decay table
176  decayTable->Insert(mode);
177 
178  // ------------ N K0 ------------
179  // determine daughters
180  daughterN = "neutron";
181  if (!fAnti) {
182  daughterK = "anti_kaon0";
183  } else {
184  daughterK = "kaon0";
185  }
186  if (fAnti) daughterN = "anti_" + daughterN;
187  // create decay channel [parent BR #daughters]
188  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
189  daughterN,daughterK);
190  // add decay table
191  decayTable->Insert(mode);
192 
193 
194  return decayTable;
195 }
196 
198  G4DecayTable* decayTable, const G4String& nameParent,
199  G4double br, G4int , G4bool fAnti)
200 {
201  G4VDecayChannel* mode;
202 
203  G4String daughterN;
204  G4String daughterK;
205 
206  // ------------ N K- ------------
207  // determine daughters
208  daughterN = "proton";
209  if (!fAnti) {
210  daughterK = "k_star-";
211  } else {
212  daughterK = "k_star+";
213  }
214  if (fAnti) daughterN = "anti_" + daughterN;
215  // create decay channel [parent BR #daughters]
216  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
217  daughterN,daughterK);
218  // add decay table
219  decayTable->Insert(mode);
220 
221  // ------------ N K0 ------------
222  // determine daughters
223  daughterN = "neutron";
224  if (!fAnti) {
225  daughterK = "anti_k_star0";
226  } else {
227  daughterK = "k_star0";
228  }
229  if (fAnti) daughterN = "anti_" + daughterN;
230  // create decay channel [parent BR #daughters]
231  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
232  daughterN,daughterK);
233  // add decay table
234  decayTable->Insert(mode);
235 
236 
237  return decayTable;
238 }
239 
241  G4DecayTable* decayTable, const G4String& nameParent,
242  G4double br, G4int , G4bool fAnti)
243 {
244  G4VDecayChannel* mode;
245 
246  G4String daughterSigma;
247  G4String daughterPi;
248 
249  // ------------ Sigma+ pi - ------------
250  // determine daughters
251  daughterSigma = "sigma+";
252  if (!fAnti) {
253  daughterPi = "pi-";
254  } else {
255  daughterPi = "pi+";
256  }
257  if (fAnti) daughterSigma = "anti_" + daughterSigma;
258  // create decay channel [parent BR #daughters]
259  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
260  daughterSigma,daughterPi);
261  // add decay table
262  decayTable->Insert(mode);
263 
264  // ------------ Sigma0 Pi0 ------------
265  // determine daughters
266  daughterSigma = "sigma0";
267  daughterPi = "pi0";
268 
269  if (fAnti) daughterSigma = "anti_" + daughterSigma;
270  // create decay channel [parent BR #daughters]
271  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
272  daughterSigma,daughterPi);
273 
274  // add decay table
275  decayTable->Insert(mode);
276 
277  // ------------ Sigma- pi + ------------
278  // determine daughters
279  daughterSigma = "sigma-";
280  if (!fAnti) {
281  daughterPi = "pi+";
282  } else {
283  daughterPi = "pi-";
284  }
285  if (fAnti) daughterSigma = "anti_" + daughterSigma;
286  // create decay channel [parent BR #daughters]
287  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
288  daughterSigma,daughterPi);
289  // add decay table
290  decayTable->Insert(mode);
291 
292  return decayTable;
293 }
294 
295 
297  G4DecayTable* decayTable, const G4String& nameParent,
298  G4double br, G4int , G4bool fAnti)
299 {
300  G4VDecayChannel* mode;
301 
302  G4String daughterSigma;
303  G4String daughterPi;
304 
305  // ------------ Sigma+ pi - ------------
306  // determine daughters
307  daughterSigma = "sigma(1385)+";
308  if (!fAnti) {
309  daughterPi = "pi-";
310  } else {
311  daughterPi = "pi+";
312  }
313  if (fAnti) daughterSigma = "anti_" + daughterSigma;
314  // create decay channel [parent BR #daughters]
315  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
316  daughterSigma,daughterPi);
317  // add decay table
318  decayTable->Insert(mode);
319 
320  // ------------ Sigma0 Pi0 ------------
321  // determine daughters
322  daughterSigma = "sigma(1385)0";
323  daughterPi = "pi0";
324 
325  if (fAnti) daughterSigma = "anti_" + daughterSigma;
326  // create decay channel [parent BR #daughters]
327  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
328  daughterSigma,daughterPi);
329 
330  // add decay table
331  decayTable->Insert(mode);
332 
333  // ------------ Sigma- pi + ------------
334  // determine daughters
335  daughterSigma = "sigma(1385)-";
336  if (!fAnti) {
337  daughterPi = "pi+";
338  } else {
339  daughterPi = "pi-";
340  }
341  if (fAnti) daughterSigma = "anti_" + daughterSigma;
342  // create decay channel [parent BR #daughters]
343  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
344  daughterSigma,daughterPi);
345  // add decay table
346  decayTable->Insert(mode);
347 
348  return decayTable;
349 }
350 
351 const char* G4ExcitedLambdaConstructor::name[] = {
352  "lambda(1405)","lambda(1520)","lambda(1600)","lambda(1670)","lambda(1690)",
353  "lambda(1800)","lambda(1810)","lambda(1820)","lambda(1830)","lambda(1890)",
354  "lambda(2100)","lambda(2110)"
355 };
356 
358  1.4051*GeV,1.5195*GeV, 1.600*GeV, 1.670*GeV, 1.690*GeV,
359  1.800*GeV, 1.810*GeV, 1.820*GeV, 1.830*GeV, 1.890*GeV,
360  2.100*GeV, 2.110*GeV
361 };
362 
364  50.0*MeV, 15.6*MeV, 150.0*MeV, 35.0*MeV, 60.0*MeV,
365  300.0*MeV, 150.0*MeV, 80.0*MeV, 95.0*MeV, 100.0*MeV,
366  200.0*MeV, 200.0*MeV
367 };
368 
370  1, 3, 1, 1, 3,
371  1, 1, 5, 5, 3,
372  7, 5
373 };
374 
376  -1, -1, +1, -1, -1,
377  -1, +1, +1, -1, +1,
378  -1, +1
379 };
380 
382  10000, 0, 20000, 30000, 10000,
383  40000, 50000, 0, 10000, 20000,
384  0, 20000
385 };
386 
388 {
389  { 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0},
390  { 0.45, 0.0, 0.43, 0.11, 0.01, 0.0, 0.0},
391  { 0.35, 0.0, 0.65, 0.0, 0.0, 0.0, 0.0},
392  { 0.20, 0.0, 0.50, 0.0, 0.0, 0.30, 0.0},
393  { 0.25, 0.0, 0.45, 0.30, 0.0, 0.0, 0.0},
394  { 0.40, 0.20, 0.20, 0.20, 0.0, 0.0, 0.0},
395  { 0.35, 0.45, 0.15, 0.05, 0.0, 0.0, 0.0},
396  { 0.73, 0.0, 0.16, 0.11, 0.0, 0.0, 0.0},
397  { 0.10, 0.0, 0.70, 0.20, 0.0, 0.0, 0.0},
398  { 0.37, 0.21, 0.11, 0.31, 0.0, 0.0, 0.0},
399  { 0.35, 0.20, 0.05, 0.30, 0.0, 0.02, 0.08},
400  { 0.25, 0.45, 0.30, 0.0, 0.0, 0.0, 0.0}
401 };
402 
403 
404 
405 
406 
407 
408 
409 
410 
411 
412 
413 
414 
415 
416 
417 
G4DecayTable * AddNKStarMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
static const double MeV
Definition: G4SIunits.hh:193
static const G4int encodingOffset[NStates]
static const G4double width[NStates]
G4DecayTable * AddSigmaStarPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
G4DecayTable * AddSigmaPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
virtual G4DecayTable * CreateDecayTable(const G4String &name, G4int iIso3, G4int iState, G4bool fAnti=false)
int G4int
Definition: G4Types.hh:78
static const G4double mass[NStates]
static const G4int iParity[NStates]
bool G4bool
Definition: G4Types.hh:79
static const double GeV
Definition: G4SIunits.hh:196
static const G4int iSpin[NStates]
void Insert(G4VDecayChannel *aChannel)
Definition: G4DecayTable.cc:60
G4DecayTable * AddNKMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
static const char * name[NStates]
G4DecayTable * AddLambdaEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
static const G4double bRatio[NStates][NumberOfDecayModes]
G4DecayTable * AddLambdaGammaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
G4DecayTable * AddLambdaOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4bool fAnti)
double G4double
Definition: G4Types.hh:76