Geant4 11.1.1
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//
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
46G4ExcitedLambdaConstructor::G4ExcitedLambdaConstructor():
47 G4ExcitedBaryonConstructor(NStates, LambdaIsoSpin)
48{
49
50}
51
52G4ExcitedLambdaConstructor::~G4ExcitedLambdaConstructor()
53{
54}
55
56G4DecayTable* 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
97G4DecayTable* 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}
115G4DecayTable* 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
134G4DecayTable* 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
153G4DecayTable* 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
196G4DecayTable* 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
239G4DecayTable* 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
295G4DecayTable* 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
350const 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
356const 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
362const 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
368const G4int G4ExcitedLambdaConstructor::iSpin[] = {
369 1, 3, 1, 1, 3,
370 1, 1, 5, 5, 3,
371 7, 5
372};
373
374const G4int G4ExcitedLambdaConstructor::iParity[] = {
375 -1, -1, +1, -1, -1,
376 -1, +1, +1, -1, +1,
377 -1, +1
378};
379
380const G4int G4ExcitedLambdaConstructor::encodingOffset[] = {
381 10000, 0, 20000, 30000, 10000,
382 40000, 50000, 0, 10000, 20000,
383 0, 20000
384};
385
386const 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
G4double
double G4double
Definition: G4Types.hh:83
G4bool
bool G4bool
Definition: G4Types.hh:86
G4int
int G4int
Definition: G4Types.hh:85
G4DecayTable::Insert
void Insert(G4VDecayChannel *aChannel)
Definition: G4DecayTable.cc:53
G4ExcitedLambdaConstructor::CreateDecayTable
virtual G4DecayTable * CreateDecayTable(const G4String &name, G4int iIso3, G4int iState, G4bool fAnti=false)
Definition: G4ExcitedLambdaConstructor.cc:56