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