Geant4 11.2.2
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4ExcitedNucleonConstructor.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 "G4ExcitedNucleonConstructor.hh"
36
37#include "G4DecayTable.hh"
38#include "G4PhaseSpaceDecayChannel.hh"
39#include "G4SystemOfUnits.hh"
40#include "G4VDecayChannel.hh"
41
45
46G4int G4ExcitedNucleonConstructor::GetEncoding(G4int iIsoSpin3, G4int idxState)
47{
48 G4int encoding;
49 // Delta has exceptinal encoding
50 if ((idxState == 1) // N(1520)
51 || (idxState == 6) // N(1700)
52 || (idxState == 8) // N(1720)
53 || (idxState == 9) // N(1900)
54 || (idxState == 12)) // N(2190)
55 {
56 encoding = GetEncodingOffset(idxState);
57 if ((iIsoSpin3 == 3) || (iIsoSpin3 == -3)) {
58 // normal encoding
59 encoding += 1000 * GetQuarkContents(0, iIsoSpin3);
60 encoding += 100 * GetQuarkContents(1, iIsoSpin3);
61 encoding += 10 * GetQuarkContents(2, iIsoSpin3);
62 }
63 else if (iIsoSpin3 == +1) {
64 // 1st <--> 2nd quark
65 encoding += 1000 * GetQuarkContents(0, iIsoSpin3);
66 encoding += 10 * GetQuarkContents(1, iIsoSpin3);
67 encoding += 100 * GetQuarkContents(2, iIsoSpin3);
68 }
69 else if (iIsoSpin3 == -1) {
70 // 1st <--> 0th quark
71 encoding += 100 * GetQuarkContents(0, iIsoSpin3);
72 encoding += 1000 * GetQuarkContents(1, iIsoSpin3);
73 encoding += 10 * GetQuarkContents(2, iIsoSpin3);
74 }
75 encoding += GetiSpin(idxState) + 1;
76 }
77 else
78 {
79 encoding = G4ExcitedBaryonConstructor::GetEncoding(iIsoSpin3, idxState);
80 }
81 return encoding;
82}
83
84G4DecayTable* G4ExcitedNucleonConstructor::CreateDecayTable(const G4String& parentName, G4int iIso3,
85 G4int iState, G4bool fAnti)
86{
87 // create decay table
88 auto decayTable = new G4DecayTable();
89
90 G4double br;
91 if ((br = bRatio[iState][NGamma]) > 0.0) {
92 AddNGammaMode(decayTable, parentName, br, iIso3, fAnti);
93 }
94
95 if ((br = bRatio[iState][NPi]) > 0.0) {
96 AddNPiMode(decayTable, parentName, br, iIso3, fAnti);
97 }
98
99 if ((br = bRatio[iState][NEta]) > 0.0) {
100 AddNEtaMode(decayTable, parentName, br, iIso3, fAnti);
101 }
102
103 if ((br = bRatio[iState][NOmega]) > 0.0) {
104 AddNOmegaMode(decayTable, parentName, br, iIso3, fAnti);
105 }
106
107 if ((br = bRatio[iState][NRho]) > 0.0) {
108 AddNRhoMode(decayTable, parentName, br, iIso3, fAnti);
109 }
110
111 if ((br = bRatio[iState][N2Pi]) > 0.0) {
112 AddN2PiMode(decayTable, parentName, br, iIso3, fAnti);
113 }
114
115 if ((br = bRatio[iState][DeltaPi]) > 0.0) {
116 AddDeltaPiMode(decayTable, parentName, br, iIso3, fAnti);
117 }
118
119 if ((br = bRatio[iState][NStarPi]) > 0.0) {
120 AddNStarPiMode(decayTable, parentName, br, iIso3, fAnti);
121 }
122
123 if ((br = bRatio[iState][LambdaK]) > 0.0) {
124 AddLambdaKMode(decayTable, parentName, br, iIso3, fAnti);
125 }
126
127 return decayTable;
128}
129
130G4DecayTable* G4ExcitedNucleonConstructor::AddNGammaMode(G4DecayTable* decayTable,
131 const G4String& nameParent, G4double br,
132 G4int iIso3, G4bool fAnti)
133{
134 G4VDecayChannel* mode;
135
136 //
137 G4String daughterN;
138 if (iIso3 == +1) {
139 daughterN = "proton";
140 }
141 else {
142 daughterN = "neutron";
143 }
144 if (fAnti) daughterN = "anti_" + daughterN;
145
146 // create decay channel [parent BR #daughters]
147 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, daughterN, "gamma");
148 // add decay table
149 decayTable->Insert(mode);
150
151 return decayTable;
152}
153
154G4DecayTable* G4ExcitedNucleonConstructor::AddNPiMode(G4DecayTable* decayTable,
155 const G4String& nameParent, G4double br,
156 G4int iIso3, G4bool fAnti)
157{
158 G4VDecayChannel* mode;
159
160 G4String daughterN;
161 G4String daughterPi;
162
163 // ------------ N pi0 ------------
164 // determine daughters
165 if (iIso3 == +1) {
166 daughterN = "proton";
167 daughterPi = "pi0";
168 }
169 else {
170 daughterN = "neutron";
171 daughterPi = "pi0";
172 }
173 if (fAnti) daughterN = "anti_" + daughterN;
174 // create decay channel [parent BR #daughters]
175 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 2, daughterN, daughterPi);
176 // add decay table
177 decayTable->Insert(mode);
178
179 // -------------N pi +/- --------------
180 // determine daughters
181 if (iIso3 == +1) {
182 daughterN = "neutron";
183 if (!fAnti) {
184 daughterPi = "pi+";
185 }
186 else {
187 daughterPi = "pi-";
188 }
189 }
190 else {
191 daughterN = "proton";
192 if (!fAnti) {
193 daughterPi = "pi-";
194 }
195 else {
196 daughterPi = "pi+";
197 }
198 }
199 if (fAnti) daughterN = "anti_" + daughterN;
200
201 // create decay channel [parent BR #daughters]
202 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 2, daughterN, daughterPi);
203 // add decay table
204 decayTable->Insert(mode);
205
206 return decayTable;
207}
208
209G4DecayTable* G4ExcitedNucleonConstructor::AddNEtaMode(G4DecayTable* decayTable,
210 const G4String& nameParent, G4double br,
211 G4int iIso3, G4bool fAnti)
212{
213 G4VDecayChannel* mode;
214
215 G4String daughterN;
216
217 // ------------ N eta------------
218 // determine daughters
219 if (iIso3 == +1) {
220 daughterN = "proton";
221 }
222 else {
223 daughterN = "neutron";
224 }
225 if (fAnti) daughterN = "anti_" + daughterN;
226 // create decay channel [parent BR #daughters]
227 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, daughterN, "eta");
228 // add decay table
229 decayTable->Insert(mode);
230
231 return decayTable;
232}
233
234G4DecayTable* G4ExcitedNucleonConstructor::AddNOmegaMode(G4DecayTable* decayTable,
235 const G4String& nameParent, G4double br,
236 G4int iIso3, G4bool fAnti)
237{
238 G4VDecayChannel* mode;
239
240 G4String daughterN;
241
242 // ------------ N omega------------
243 // determine daughters
244 if (iIso3 == +1) {
245 daughterN = "proton";
246 }
247 else {
248 daughterN = "neutron";
249 }
250 if (fAnti) daughterN = "anti_" + daughterN;
251 // create decay channel [parent BR #daughters]
252 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, daughterN, "omega");
253 // add decay table
254 decayTable->Insert(mode);
255
256 return decayTable;
257}
258
259G4DecayTable* G4ExcitedNucleonConstructor::AddNRhoMode(G4DecayTable* decayTable,
260 const G4String& nameParent, G4double br,
261 G4int iIso3, G4bool fAnti)
262{
263 G4VDecayChannel* mode;
264
265 G4String daughterN;
266 G4String daughterRho;
267
268 // ------------ N rho0 ------------
269 // determine daughters
270 if (iIso3 == +1) {
271 daughterN = "proton";
272 daughterRho = "rho0";
273 }
274 else {
275 daughterN = "neutron";
276 daughterRho = "rho0";
277 }
278 if (fAnti) daughterN = "anti_" + daughterN;
279 // create decay channel [parent BR #daughters]
280 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 2, daughterN, daughterRho);
281 // add decay table
282 decayTable->Insert(mode);
283
284 // -------------N rho+/- --------------
285 // determine daughters
286 if (iIso3 == +1) {
287 daughterN = "neutron";
288 if (!fAnti) {
289 daughterRho = "rho+";
290 }
291 else {
292 daughterRho = "rho-";
293 }
294 }
295 else {
296 daughterN = "proton";
297 if (!fAnti) {
298 daughterRho = "rho-";
299 }
300 else {
301 daughterRho = "rho+";
302 }
303 }
304 if (fAnti) daughterN = "anti_" + daughterN;
305
306 // create decay channel [parent BR #daughters]
307 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 2, daughterN, daughterRho);
308 // add decay table
309 decayTable->Insert(mode);
310
311 return decayTable;
312}
313
314G4DecayTable* G4ExcitedNucleonConstructor::AddN2PiMode(G4DecayTable* decayTable,
315 const G4String& nameParent, G4double br,
316 G4int iIso3, G4bool fAnti)
317{
318 // Decay Modes
319 // N* --> N + pi + pi
320 // Only I=0 states are included for 2-pi system
321
322 G4VDecayChannel* mode;
323
324 G4String daughterN;
325 G4String daughterPi1;
326 G4String daughterPi2;
327
328 // -------------N pi+ pi- --------------
329 // determine daughters
330 if (iIso3 == +1) {
331 daughterN = "proton";
332 daughterPi1 = "pi+";
333 daughterPi2 = "pi-";
334 }
335 else {
336 daughterN = "neutron";
337 daughterPi1 = "pi+";
338 daughterPi2 = "pi-";
339 }
340 if (fAnti) daughterN = "anti_" + daughterN;
341
342 // create decay channel [parent BR #daughters]
343 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 3, daughterN, daughterPi1, daughterPi2);
344 // add decay table
345 decayTable->Insert(mode);
346
347 // -------------N pi0 pi0 --------------
348 // determine daughters
349 if (iIso3 == +1) {
350 daughterN = "proton";
351 daughterPi1 = "pi0";
352 daughterPi2 = "pi0";
353 }
354 else {
355 daughterN = "neutron";
356 daughterPi1 = "pi0";
357 daughterPi2 = "pi0";
358 }
359 if (fAnti) daughterN = "anti_" + daughterN;
360
361 // create decay channel [parent BR #daughters]
362 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 3, daughterN, daughterPi1, daughterPi2);
363 // add decay table
364 decayTable->Insert(mode);
365
366 return decayTable;
367}
368
369G4DecayTable* G4ExcitedNucleonConstructor::AddNStarPiMode(G4DecayTable* decayTable,
370 const G4String& nameParent, G4double br,
371 G4int iIso3, G4bool fAnti)
372{
373 G4VDecayChannel* mode;
374
375 G4String daughterN;
376 G4String daughterPi;
377
378 // ------------ N pi0 ------------
379 // determine daughters
380 if (iIso3 == +1) {
381 daughterN = "N(1440)+";
382 daughterPi = "pi0";
383 }
384 else {
385 daughterN = "N(1440)0";
386 daughterPi = "pi0";
387 }
388 if (fAnti) daughterN = "anti_" + daughterN;
389 // create decay channel [parent BR #daughters]
390 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 2, daughterN, daughterPi);
391 // add decay table
392 decayTable->Insert(mode);
393
394 // -------------N pi +/- --------------
395 // determine daughters
396 if (iIso3 == +1) {
397 daughterN = "N(1440)0";
398 if (!fAnti) {
399 daughterPi = "pi+";
400 }
401 else {
402 daughterPi = "pi-";
403 }
404 }
405 else {
406 daughterN = "N(1440)+";
407 if (!fAnti) {
408 daughterPi = "pi-";
409 }
410 else {
411 daughterPi = "pi+";
412 }
413 }
414 if (fAnti) daughterN = "anti_" + daughterN;
415
416 // create decay channel [parent BR #daughters]
417 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2.0, 2, daughterN, daughterPi);
418 // add decay table
419 decayTable->Insert(mode);
420
421 return decayTable;
422}
423
424G4DecayTable* G4ExcitedNucleonConstructor::AddDeltaPiMode(G4DecayTable* decayTable,
425 const G4String& nameParent, G4double br,
426 G4int iIso3, G4bool fAnti)
427{
428 G4VDecayChannel* mode;
429
430 G4String daughterDelta;
431 G4String daughterPi;
432 G4double r;
433
434 // ------------ Delta pi+/- ------------
435 // determine daughters
436 if (iIso3 == +1) {
437 daughterDelta = "delta0";
438 if (!fAnti) {
439 daughterPi = "pi+";
440 }
441 else {
442 daughterPi = "pi-";
443 }
444 r = br / 6.0;
445 }
446 else {
447 daughterDelta = "delta+";
448 if (!fAnti) {
449 daughterPi = "pi-";
450 }
451 else {
452 daughterPi = "pi+";
453 }
454 r = br / 6.0;
455 }
456 if (fAnti) daughterDelta = "anti_" + daughterDelta;
457 // create decay channel [parent BR #daughters]
458 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterDelta, daughterPi);
459 // add decay table
460 decayTable->Insert(mode);
461
462 // ------------ Delta pi+/- ------------
463 // determine daughters
464 if (iIso3 == +1) {
465 daughterDelta = "delta++";
466 if (!fAnti) {
467 daughterPi = "pi-";
468 }
469 else {
470 daughterPi = "pi+";
471 }
472 r = br / 2.0;
473 }
474 else {
475 daughterDelta = "delta-";
476 if (!fAnti) {
477 daughterPi = "pi+";
478 }
479 else {
480 daughterPi = "pi-";
481 }
482 r = br / 2.0;
483 }
484 if (fAnti) daughterDelta = "anti_" + daughterDelta;
485 // create decay channel [parent BR #daughters]
486 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterDelta, daughterPi);
487 // add decay table
488 decayTable->Insert(mode);
489
490 // ------------ Delta pi0 ------------
491 // determine daughters
492 if (iIso3 == +1) {
493 daughterDelta = "delta+";
494 daughterPi = "pi0";
495 r = br / 3.0;
496 }
497 else {
498 daughterDelta = "delta0";
499 daughterPi = "pi0";
500 r = br / 3.0;
501 }
502 if (fAnti) daughterDelta = "anti_" + daughterDelta;
503 // create decay channel [parent BR #daughters]
504 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterDelta, daughterPi);
505 // add decay table
506 decayTable->Insert(mode);
507
508 return decayTable;
509}
510
511G4DecayTable* G4ExcitedNucleonConstructor::AddLambdaKMode(G4DecayTable* decayTable,
512 const G4String& nameParent, G4double br,
513 G4int iIso3, G4bool fAnti)
514{
515 G4VDecayChannel* mode;
516
517 G4String lambda = "lambda";
518 G4String daughterK;
519
520 // ------------ N pi0 ------------
521 // determine daughters
522 if (iIso3 == +1) {
523 if (!fAnti) {
524 daughterK = "kaon+";
525 }
526 else {
527 daughterK = "kaon-";
528 }
529 }
530 else {
531 if (!fAnti) {
532 daughterK = "kaon0";
533 }
534 else {
535 daughterK = "anti_kaon0";
536 }
537 }
538 if (fAnti) lambda = "anti_" + lambda;
539 // create decay channel [parent BR #daughters]
540 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, lambda, daughterK);
541 // add decay table
542 decayTable->Insert(mode);
543
544 return decayTable;
545}
546
547// clang-format off
548
549// PDG2005
550// N(2090) is renamed to N(2080)
551// but keep unchanged temporalily Apr 06
552//
553// -> PDG2023: N(2090) is removed by S.Okada 4 Nov. 2023.
554
555const char* G4ExcitedNucleonConstructor::name[] = {
556 "N(1440)", "N(1520)", "N(1535)", "N(1650)", "N(1675)",
557 "N(1680)", "N(1700)", "N(1710)", "N(1720)", "N(1900)",
558 "N(1990)", "N(2090)", "N(2190)", "N(2220)", "N(2250)"
559};
560
561const G4double G4ExcitedNucleonConstructor::mass[] = {
562 1.440*GeV, 1.515*GeV, 1.535*GeV, 1.650*GeV, 1.675*GeV,
563 1.685*GeV, 1.720*GeV, 1.710*GeV, 1.720*GeV, 1.920*GeV,
564 2.020*GeV, 2.080*GeV, 2.180*GeV, 2.250*GeV, 2.280*GeV
565};
566
567const G4double G4ExcitedNucleonConstructor::width[] = {
568 350.0*MeV, 110.0*MeV, 150.0*MeV, 125.0*MeV, 145.0*MeV,
569 120.0*MeV, 200.0*MeV, 140.0*MeV, 250.0*MeV, 200.0*MeV,
570 300.0*MeV, 350.0*MeV, 400.0*MeV, 400.0*MeV, 500.0*MeV
571};
572
573const G4int G4ExcitedNucleonConstructor::iSpin[] = {
574 1, 3, 1, 1, 5,
575 5, 3, 1, 3, 3,
576 7, 3, 7, 9, 9
577};
578
579const G4int G4ExcitedNucleonConstructor::iParity[] = {
580 +1, -1, -1, -1, -1,
581 +1, -1, +1, +1, +1,
582 +1, -1, +1, -1, -1
583};
584
585const G4int G4ExcitedNucleonConstructor::encodingOffset[] = {
586 10000, 0, 20000, 30000, 0,
587 10000, 20000, 40000, 30000, 40000,
588 10000, 50000, 0, 0, 10000
589};
590
591const G4double G4ExcitedNucleonConstructor::bRatio[ G4ExcitedNucleonConstructor::NStates ][ G4ExcitedNucleonConstructor::NumberOfDecayModes] =
592{
593 { 0.0, 0.70, 0.0, 0.0, 0.0, 0.05, 0.25, 0.0, 0.0},
594 { 0.0, 0.60, 0.0, 0.0, 0.0, 0.15, 0.25, 0.0, 0.0},
595 {0.001, 0.55, 0.35, 0.0, 0.0, 0.05, 0.00, 0.05, 0.0},
596 { 0.0, 0.65, 0.05, 0.0, 0.0, 0.05, 0.10, 0.05, 0.10},
597 { 0.0, 0.45, 0.0, 0.0, 0.0, 0.00, 0.55, 0.0, 0.0},
598 { 0.0, 0.65, 0.0, 0.0, 0.0, 0.20, 0.15, 0.0, 0.0},
599 { 0.0, 0.10, 0.05, 0.0, 0.05, 0.45, 0.35, 0.0, 0.0},
600 { 0.0, 0.15, 0.20, 0.0, 0.05, 0.20, 0.20, 0.10, 0.10},
601 { 0.0, 0.15, 0.00, 0.0, 0.25, 0.45, 0.10, 0.00, 0.05},
602 { 0.0, 0.35, 0.0, 0.55, 0.05, 0.00, 0.05, 0.0, 0.0},
603 { 0.0, 0.05, 0.0, 0.0, 0.15, 0.25, 0.30, 0.15, 0.10},
604 { 0.0, 0.60, 0.05, 0.0, 0.25, 0.05, 0.05, 0.0, 0.0},
605 { 0.0, 0.35, 0.0, 0.00, 0.30, 0.15, 0.15, 0.05, 0.0},
606 { 0.0, 0.35, 0.0, 0.0, 0.25, 0.20, 0.20, 0.0, 0.0},
607 { 0.0, 0.30, 0.0, 0.00, 0.25, 0.20, 0.20, 0.05, 0.0}
608};
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::GetEncoding
virtual G4int GetEncoding(G4int iIsoSpin3, G4int idxState)
Definition G4ExcitedBaryonConstructor.cc:151
G4ExcitedNucleonConstructor::GetQuarkContents
G4int GetQuarkContents(G4int, G4int) override
Definition G4ExcitedNucleonConstructor.hh:148
G4ExcitedNucleonConstructor::GetiSpin
G4int GetiSpin(G4int iState) override
Definition G4ExcitedNucleonConstructor.hh:133
G4ExcitedNucleonConstructor::CreateDecayTable
G4DecayTable * CreateDecayTable(const G4String &name, G4int iIso3, G4int iState, G4bool fAnti=false) override
Definition G4ExcitedNucleonConstructor.cc:84
G4ExcitedNucleonConstructor::GetEncodingOffset
G4int GetEncodingOffset(G4int iState) override
Definition G4ExcitedNucleonConstructor.hh:143
G4ExcitedNucleonConstructor::GetEncoding
G4int GetEncoding(G4int iIsoSpin3, G4int idxState) override
Definition G4ExcitedNucleonConstructor.cc:46