Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
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
48G4ExcitedLambdaConstructor::G4ExcitedLambdaConstructor():
49 G4ExcitedBaryonConstructor(NStates, LambdaIsoSpin)
50{
51
52}
53
54G4ExcitedLambdaConstructor::~G4ExcitedLambdaConstructor()
55{
56}
57
58G4DecayTable* 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
99G4DecayTable* 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}
117G4DecayTable* 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
136G4DecayTable* 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
155G4DecayTable* 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
198G4DecayTable* 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
241G4DecayTable* 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
297G4DecayTable* 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
352const 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
358const 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
364const 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
370const G4int G4ExcitedLambdaConstructor::iSpin[] = {
371 1, 3, 1, 1, 3,
372 1, 1, 5, 5, 3,
373 7, 5
374};
375
376const G4int G4ExcitedLambdaConstructor::iParity[] = {
377 -1, -1, +1, -1, -1,
378 -1, +1, +1, -1, +1,
379 -1, +1
380};
381
382const G4int G4ExcitedLambdaConstructor::encodingOffset[] = {
383 10000, 0, 20000, 30000, 10000,
384 40000, 50000, 0, 10000, 20000,
385 0, 20000
386};
387
388const 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
G4double
double G4double
Definition: G4Types.hh:64
G4int
int G4int
Definition: G4Types.hh:66
G4bool
bool G4bool
Definition: G4Types.hh:67
G4DecayTable::Insert
void Insert(G4VDecayChannel *aChannel)
Definition: G4DecayTable.cc:60
G4ExcitedLambdaConstructor::CreateDecayTable
virtual G4DecayTable * CreateDecayTable(const G4String &name, G4int iIso3, G4int iState, G4bool fAnti=false)
Definition: G4ExcitedLambdaConstructor.cc:58