Geant4 11.2.2
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4ExcitedSigmaConstructor.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//
29// History: first implementation, based on object model of
30// 10 oct 1998 H.Kurashige
31//
32// Update mass and width following PDG 2023
33// 4 nov 2023 S.Okada
34// ---------------------------------------------------------------
35
36#include "G4ExcitedSigmaConstructor.hh"
37
38#include "G4DecayTable.hh"
39#include "G4PhaseSpaceDecayChannel.hh"
40#include "G4SystemOfUnits.hh"
41#include "G4VDecayChannel.hh"
42
46
47G4DecayTable* G4ExcitedSigmaConstructor::CreateDecayTable(const G4String& parentName, G4int iIso3,
48 G4int iState, G4bool fAnti)
49{
50 // create decay table
51 auto decayTable = new G4DecayTable();
52
53 G4double br;
54 if ((br = bRatio[iState][NK]) > 0.0) {
55 AddNKMode(decayTable, parentName, br, iIso3, fAnti);
56 }
57
58 if ((br = bRatio[iState][NKStar]) > 0.0) {
59 AddNKStarMode(decayTable, parentName, br, iIso3, fAnti);
60 }
61
62 if ((br = bRatio[iState][SigmaPi]) > 0.0) {
63 AddSigmaPiMode(decayTable, parentName, br, iIso3, fAnti);
64 }
65
66 if ((br = bRatio[iState][SigmaStarPi]) > 0.0) {
67 AddSigmaStarPiMode(decayTable, parentName, br, iIso3, fAnti);
68 }
69
70 if ((br = bRatio[iState][LambdaPi]) > 0.0) {
71 AddLambdaPiMode(decayTable, parentName, br, iIso3, fAnti);
72 }
73
74 if ((br = bRatio[iState][SigmaEta]) > 0.0) {
75 AddSigmaEtaMode(decayTable, parentName, br, iIso3, fAnti);
76 }
77
78 if ((br = bRatio[iState][LambdaStarPi]) > 0.0) {
79 AddLambdaStarPiMode(decayTable, parentName, br, iIso3, fAnti);
80 }
81
82 if ((br = bRatio[iState][DeltaK]) > 0.0) {
83 AddDeltaKMode(decayTable, parentName, br, iIso3, fAnti);
84 }
85
86 return decayTable;
87}
88
89G4DecayTable* G4ExcitedSigmaConstructor::AddSigmaEtaMode(G4DecayTable* decayTable,
90 const G4String& nameParent, G4double br,
91 G4int iIso3, G4bool fAnti)
92{
93 G4VDecayChannel* mode;
94 //
95 G4String daughterH;
96 if (iIso3 == +2) {
97 daughterH = "sigma+";
98 }
99 else if (iIso3 == 0) {
100 daughterH = "sigma0";
101 }
102 else if (iIso3 == -2) {
103 daughterH = "sigma-";
104 }
105 if (fAnti) daughterH = "anti_" + daughterH;
106
107 // create decay channel [parent BR #daughters]
108 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, daughterH, "eta");
109 // add decay table
110 decayTable->Insert(mode);
111
112 return decayTable;
113}
114
115G4DecayTable* G4ExcitedSigmaConstructor::AddNKMode(G4DecayTable* decayTable,
116 const G4String& nameParent, G4double br,
117 G4int iIso3, G4bool fAnti)
118
119{
120 G4VDecayChannel* mode;
121
122 G4String daughterN;
123 G4String daughterK;
124 G4double r = 0.;
125
126 // ------------ N K- ------------
127 // determine daughters
128 if (iIso3 == +2) {
129 r = 0.;
130 }
131 else if (iIso3 == 0) {
132 daughterN = "proton";
133 r = br / 2.;
134 }
135 else if (iIso3 == -2) {
136 daughterN = "neutron";
137 r = br;
138 }
139 if (!fAnti) {
140 daughterK = "kaon-";
141 }
142 else {
143 daughterK = "kaon+";
144 }
145 if (fAnti) daughterN = "anti_" + daughterN;
146 if (r > 0.) {
147 // create decay channel [parent BR #daughters]
148 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterK);
149 // add decay table
150 decayTable->Insert(mode);
151 }
152
153 // ------------ N K0 ------------
154 // determine daughters
155 if (iIso3 == +2) {
156 daughterN = "proton";
157 r = br;
158 }
159 else if (iIso3 == 0) {
160 daughterN = "neutron";
161 r = br / 2.;
162 }
163 else if (iIso3 == -2) {
164 r = 0.;
165 }
166 if (!fAnti) {
167 daughterK = "anti_kaon0";
168 }
169 else {
170 daughterK = "kaon0";
171 }
172 if (fAnti) daughterN = "anti_" + daughterN;
173 if (r > 0.) {
174 // create decay channel [parent BR #daughters]
175 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterK);
176 // add decay table
177 decayTable->Insert(mode);
178 }
179
180 return decayTable;
181}
182
183G4DecayTable* G4ExcitedSigmaConstructor::AddDeltaKMode(G4DecayTable* decayTable,
184 const G4String& nameParent, G4double br,
185 G4int iIso3, G4bool fAnti)
186{
187 G4VDecayChannel* mode;
188
189 G4String daughterN;
190 G4String daughterK;
191 G4double r = 0.;
192
193 // ------------ N K- ------------
194 // determine daughters
195 if (iIso3 == +2) {
196 daughterN = "delta++";
197 r = 0.75 * br;
198 }
199 else if (iIso3 == 0) {
200 daughterN = "delta+";
201 r = br / 2.;
202 }
203 else if (iIso3 == -2) {
204 daughterN = "delta0";
205 r = 0.25 * br;
206 }
207 if (!fAnti) {
208 daughterK = "kaon-";
209 }
210 else {
211 daughterK = "kaon+";
212 }
213 if (fAnti) daughterN = "anti_" + daughterN;
214 if (r > 0.) {
215 // create decay channel [parent BR #daughters]
216 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterK);
217 // add decay table
218 decayTable->Insert(mode);
219 }
220
221 // ------------ N K0 ------------
222 // determine daughters
223 if (iIso3 == +2) {
224 daughterN = "delta+";
225 r = 0.25 * br;
226 }
227 else if (iIso3 == 0) {
228 daughterN = "delta0";
229 r = br / 2.;
230 }
231 else if (iIso3 == -2) {
232 daughterN = "delta-";
233 r = 0.75 * br;
234 }
235 if (!fAnti) {
236 daughterK = "anti_kaon0";
237 }
238 else {
239 daughterK = "kaon0";
240 }
241 if (fAnti) daughterN = "anti_" + daughterN;
242 if (r > 0.) {
243 // create decay channel [parent BR #daughters]
244 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterK);
245 // add decay table
246 decayTable->Insert(mode);
247 }
248
249 return decayTable;
250}
251
252G4DecayTable* G4ExcitedSigmaConstructor::AddNKStarMode(G4DecayTable* decayTable,
253 const G4String& nameParent, G4double br,
254 G4int iIso3, G4bool fAnti)
255{
256 G4VDecayChannel* mode;
257
258 G4String daughterN;
259 G4String daughterK;
260 G4double r = 0.;
261
262 // ------------ N K- ------------
263 // determine daughters
264 if (iIso3 == +2) {
265 r = 0.;
266 }
267 else if (iIso3 == 0) {
268 daughterN = "proton";
269 r = br / 2.;
270 }
271 else if (iIso3 == -2) {
272 daughterN = "neutron";
273 r = br;
274 }
275 if (!fAnti) {
276 daughterK = "k_star-";
277 }
278 else {
279 daughterK = "k_star+";
280 }
281 if (fAnti) daughterN = "anti_" + daughterN;
282 if (r > 0.) {
283 // create decay channel [parent BR #daughters]
284 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterK);
285 // add decay table
286 decayTable->Insert(mode);
287 }
288
289 // ------------ N K0 ------------
290
291 // determine daughters
292 if (iIso3 == +2) {
293 daughterN = "proton";
294 r = br;
295 }
296 else if (iIso3 == 0) {
297 daughterN = "neutron";
298 r = br / 2.;
299 }
300 else if (iIso3 == -2) {
301 r = 0.;
302 }
303 if (!fAnti) {
304 daughterK = "anti_k_star0";
305 }
306 else {
307 daughterK = "k_star0";
308 }
309 if (fAnti) daughterN = "anti_" + daughterN;
310 // create decay channel [parent BR #daughters]
311 if (r > 0.) {
312 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterK);
313 // add decay table
314 decayTable->Insert(mode);
315 }
316
317 return decayTable;
318}
319
320G4DecayTable* G4ExcitedSigmaConstructor::AddSigmaPiMode(G4DecayTable* decayTable,
321 const G4String& nameParent, G4double br,
322 G4int iIso3, G4bool fAnti)
323{
324 G4VDecayChannel* mode;
325
326 G4String daughterSigma;
327 G4String daughterPi;
328 G4double r = 0.;
329
330 // ------------ Sigma+ pi - ------------
331 // determine daughters
332 if (iIso3 == +2) {
333 r = 0.;
334 }
335 else if (iIso3 == 0) {
336 daughterSigma = "sigma+";
337 r = br / 2.;
338 }
339 else if (iIso3 == -2) {
340 daughterSigma = "sigma0";
341 r = br / 2.;
342 }
343 if (!fAnti) {
344 daughterPi = "pi-";
345 }
346 else {
347 daughterPi = "pi+";
348 }
349 if (fAnti) daughterSigma = "anti_" + daughterSigma;
350 if (r > 0.) {
351 // create decay channel [parent BR #daughters]
352 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
353 // add decay table
354 decayTable->Insert(mode);
355 }
356 // ------------ Sigma0 Pi0 ------------
357 // determine daughters
358 if (iIso3 == +2) {
359 daughterSigma = "sigma+";
360 r = br / 2.;
361 }
362 else if (iIso3 == 0) {
363 r = 0.;
364 }
365 else if (iIso3 == -2) {
366 daughterSigma = "sigma-";
367
368 r = br / 2.;
369 }
370 daughterPi = "pi0";
371 if (fAnti) daughterSigma = "anti_" + daughterSigma;
372 if (r > 0.) {
373 // create decay channel [parent BR #daughters]
374 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
375 // add decay table
376 decayTable->Insert(mode);
377 }
378
379 // ------------ Sigma- pi + ------------
380 // determine daughters
381 if (iIso3 == +2) {
382 daughterSigma = "sigma0";
383 r = br / 2.;
384 }
385 else if (iIso3 == 0) {
386 daughterSigma = "sigma-";
387 r = br / 2.;
388 }
389 else if (iIso3 == -2) {
390 r = 0.;
391 }
392 if (!fAnti) {
393 daughterPi = "pi+";
394 }
395 else {
396 daughterPi = "pi-";
397 }
398 if (fAnti) daughterSigma = "anti_" + daughterSigma;
399 if (r > 0.) {
400 // create decay channel [parent BR #daughters]
401 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
402 // add decay table
403 decayTable->Insert(mode);
404 }
405
406 return decayTable;
407}
408
409G4DecayTable* G4ExcitedSigmaConstructor::AddSigmaStarPiMode(G4DecayTable* decayTable,
410 const G4String& nameParent, G4double br,
411 G4int iIso3, G4bool fAnti)
412{
413 G4VDecayChannel* mode;
414
415 G4String daughterSigma;
416 G4String daughterPi;
417 G4double r = 0.;
418
419 // ------------ Sigma+ pi - ------------
420 // determine daughters
421 if (iIso3 == +2) {
422 r = 0.;
423 }
424 else if (iIso3 == 0) {
425 daughterSigma = "sigma(1385)+";
426 r = br / 2.;
427 }
428 else if (iIso3 == -2) {
429 daughterSigma = "sigma(1385)0";
430 r = br / 2.;
431 }
432 if (!fAnti) {
433 daughterPi = "pi-";
434 }
435 else {
436 daughterPi = "pi+";
437 }
438 if (fAnti) daughterSigma = "anti_" + daughterSigma;
439 if (r > 0.) {
440 // create decay channel [parent BR #daughters]
441 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
442 // add decay table
443 decayTable->Insert(mode);
444 }
445 // ------------ Sigma0 Pi0 ------------
446 // determine daughters
447 if (iIso3 == +2) {
448 daughterSigma = "sigma(1385)+";
449 r = br / 2.;
450 }
451 else if (iIso3 == 0) {
452 r = 0.;
453 }
454 else if (iIso3 == -2) {
455 daughterSigma = "sigma(1385)-";
456 r = br / 2.;
457 }
458 daughterPi = "pi0";
459 if (fAnti) daughterSigma = "anti_" + daughterSigma;
460 if (r > 0.) {
461 // create decay channel [parent BR #daughters]
462 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
463
464 // add decay table
465 decayTable->Insert(mode);
466 }
467
468 // ------------ Sigma- pi + ------------
469 // determine daughters
470 if (iIso3 == +2) {
471 daughterSigma = "sigma(1385)0";
472 r = br / 2.;
473 }
474 else if (iIso3 == 0) {
475 daughterSigma = "sigma(1385)-";
476 r = br / 2.;
477 }
478 else if (iIso3 == -2) {
479 r = 0.;
480 }
481 if (!fAnti) {
482 daughterPi = "pi+";
483 }
484 else {
485 daughterPi = "pi-";
486 }
487 if (fAnti) daughterSigma = "anti_" + daughterSigma;
488 if (r > 0.) {
489 // create decay channel [parent BR #daughters]
490
491 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterSigma, daughterPi);
492 // add decay table
493 decayTable->Insert(mode);
494 }
495
496 return decayTable;
497}
498
499G4DecayTable* G4ExcitedSigmaConstructor::AddLambdaPiMode(G4DecayTable* decayTable,
500 const G4String& nameParent, G4double br,
501 G4int iIso3, G4bool fAnti)
502{
503 G4VDecayChannel* mode;
504
505 G4String daughterLambda = "lambda";
506 G4String daughterPi;
507
508 // determine daughters
509 if (iIso3 == +2) {
510 if (!fAnti) {
511 daughterPi = "pi+";
512 }
513 else {
514 daughterPi = "pi-";
515 }
516 }
517 else if (iIso3 == 0) {
518 daughterPi = "pi0";
519 }
520 else if (iIso3 == -2) {
521 if (!fAnti) {
522 daughterPi = "pi-";
523 }
524 else {
525 daughterPi = "pi+";
526 }
527 }
528 if (fAnti) daughterLambda = "anti_" + daughterLambda;
529 // create decay channel [parent BR #daughters]
530 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, daughterLambda, daughterPi);
531 // add decay table
532 decayTable->Insert(mode);
533
534 return decayTable;
535}
536
537G4DecayTable* G4ExcitedSigmaConstructor::AddLambdaStarPiMode(G4DecayTable* decayTable,
538 const G4String& nameParent,
539 G4double br, G4int iIso3, G4bool fAnti)
540{
541 G4VDecayChannel* mode;
542
543 G4String daughterLambda = "lambda(1405)";
544 G4String daughterPi;
545
546 // determine daughters
547 if (iIso3 == +2) {
548 if (!fAnti) {
549 daughterPi = "pi+";
550 }
551 else {
552 daughterPi = "pi-";
553 }
554 }
555 else if (iIso3 == 0) {
556 daughterPi = "pi0";
557 }
558 else if (iIso3 == -2) {
559 if (!fAnti) {
560 daughterPi = "pi-";
561 }
562 else {
563 daughterPi = "pi+";
564 }
565 }
566
567 if (fAnti) daughterLambda = "anti_" + daughterLambda;
568 // create decay channel [parent BR #daughters]
569 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, daughterLambda, daughterPi);
570 // add decay table
571 decayTable->Insert(mode);
572
573 return decayTable;
574}
575
576G4double G4ExcitedSigmaConstructor::GetMass(G4int iState, G4int iso3)
577{
578 G4double fmass = mass[iState];
579 if (iState == 0) {
580 if (iso3 == +2)
581 fmass -= 0.9 * MeV; // sigma+
582 else if (iso3 == -2)
583 fmass += 3.5 * MeV; // sigma-
584 }
585 return fmass;
586}
587
588G4double G4ExcitedSigmaConstructor::GetWidth(G4int iState, G4int iso3)
589{
590 G4double fw = width[iState];
591 if (iState == 0) {
592 if (iso3 == +2)
593 fw = 36.0 * MeV; // sigma+
594 else if (iso3 == -2)
595 fw = 39.4 * MeV; // sigma-
596 }
597 return fw;
598}
599
600// clang-format off
601
602const char* G4ExcitedSigmaConstructor::name[] = {
603 "sigma(1385)","sigma(1660)","sigma(1670)","sigma(1750)","sigma(1775)",
604 "sigma(1915)","sigma(1940)","sigma(2030)"
605};
606
607const G4double G4ExcitedSigmaConstructor::mass[] = {
608 1.3837*GeV, 1.660*GeV, 1.675*GeV, 1.750*GeV, 1.775*GeV,
609 1.915*GeV, 1.940*GeV, 2.030*GeV
610};
611
612const G4double G4ExcitedSigmaConstructor::width[] = {
613 36.0*MeV, 200.0*MeV, 70.0*MeV, 150.0*MeV, 120.0*MeV,
614 120.0*MeV, 250.0*MeV, 180.0*MeV
615};
616
617const G4int G4ExcitedSigmaConstructor::iSpin[] = {
618 3, 1, 3, 1, 5,
619 5, 3, 7
620};
621
622const G4int G4ExcitedSigmaConstructor::iParity[] = {
623 +1, +1, -1, -1, -1,
624 +1, -1, +1
625};
626
627
628const G4int G4ExcitedSigmaConstructor::encodingOffset[] = {
629 0, 10000, 10000, 20000, 0,
630 10000, 20000, 0
631};
632
633const G4double G4ExcitedSigmaConstructor::bRatio[ G4ExcitedSigmaConstructor::NStates ][ G4ExcitedSigmaConstructor::NumberOfDecayModes] =
634{
635 { 0.0, 0.0, 0.12, 0.0, 0.88, 0.0, 0.0, 0.0},
636 { 0.30, 0.0, 0.35, 0.0, 0.35, 0.0, 0.0, 0.0},
637 { 0.15, 0.0, 0.70, 0.0, 0.15, 0.0, 0.0, 0.0},
638 { 0.40, 0.0, 0.05, 0.0, 0.0, 0.55, 0.0, 0.0},
639 { 0.40, 0.0, 0.04, 0.10, 0.23, 0.0, 0.23, 0.0},
640 { 0.15, 0.0, 0.40, 0.05, 0.40, 0.0, 0.0, 0.0},
641 { 0.10, 0.15, 0.15, 0.15, 0.15, 0.0, 0.15, 0.15},
642 { 0.20, 0.04, 0.10, 0.10, 0.20, 0.0, 0.18, 0.18}
643
644};
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
G4ExcitedSigmaConstructor::GetWidth
G4double GetWidth(G4int state, G4int iso) override
Definition G4ExcitedSigmaConstructor.cc:588
G4ExcitedSigmaConstructor::CreateDecayTable
G4DecayTable * CreateDecayTable(const G4String &name, G4int iIso3, G4int iState, G4bool fAnti=false) override
Definition G4ExcitedSigmaConstructor.cc:47
G4ExcitedSigmaConstructor::GetMass
G4double GetMass(G4int state, G4int iso) override
Definition G4ExcitedSigmaConstructor.cc:576