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