Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
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