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