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