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