| Geant4 Cross Reference |
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
42 G4ExcitedNucleonConstructor::G4ExcitedNucleonConstructor()
43 : G4ExcitedBaryonConstructor(NStates, NucleonIsoSpin)
44 {}
45
46 G4int 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
84 G4DecayTable* 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
130 G4DecayTable* 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
154 G4DecayTable* 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
209 G4DecayTable* 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
234 G4DecayTable* 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
259 G4DecayTable* 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
314 G4DecayTable* 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
369 G4DecayTable* 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
424 G4DecayTable* 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
511 G4DecayTable* 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
555 const 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
561 const 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
567 const 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
573 const G4int G4ExcitedNucleonConstructor::iSpin[] = {
574 1, 3, 1, 1, 5,
575 5, 3, 1, 3, 3,
576 7, 3, 7, 9, 9
577 };
578
579 const G4int G4ExcitedNucleonConstructor::iParity[] = {
580 +1, -1, -1, -1, -1,
581 +1, -1, +1, +1, +1,
582 +1, -1, +1, -1, -1
583 };
584
585 const G4int G4ExcitedNucleonConstructor::encodingOffset[] = {
586 10000, 0, 20000, 30000, 0,
587 10000, 20000, 40000, 30000, 40000,
588 10000, 50000, 0, 0, 10000
589 };
590
591 const 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 };
609