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