GENIEGenerator
Loading...
Searching...
No Matches
NucleonDecayUtils.cxx
Go to the documentation of this file.
1//____________________________________________________________________________
2/*
3 Copyright (c) 2003-2025, The GENIE Collaboration
4 For the full text of the license visit http://copyright.genie-mc.org
5
6 Costas Andreopoulos <c.andreopoulos \at cern.ch>
7 University of Liverpool
8*/
9//____________________________________________________________________________
10
11#include "Framework/Messenger/Messenger.h"
12#include "Framework/GHEP/GHepParticle.h"
13#include "Framework/ParticleData/PDGCodes.h"
14#include "Framework/ParticleData/PDGUtils.h"
15#include "Framework/ParticleData/PDGLibrary.h"
16#include "Framework/Utils/PrintUtils.h"
17#include "Physics/NucleonDecay/NucleonDecayUtils.h"
18#include "Physics/NuclearState/NuclearUtils.h"
19
20using namespace genie;
21//using namespace genie::utils::nucleon_decay;
22
23//____________________________________________________________________________
24string genie::utils::nucleon_decay::AsString(NucleonDecayMode_t ndm,
25 int npdg)
26{
27 switch(ndm) {
28
29 case (kNDNull):
30 return "Invalid nucleon decay mode!";
31 break;
32
33 case (kNDN2eppi):
34 if (npdg == kPdgProton) {
35 return "p --> e+ pi0";
36 } else if (npdg == kPdgNeutron) {
37 return "n --> e+ pi-";
38 } else {
39 return "Invalid nucleon decay mode!";
40 }
41 break;
42
43 case (kNDN2muppi):
44 if (npdg == kPdgProton) {
45 return "p --> mu+ pi0";
46 } else if (npdg == kPdgNeutron) {
47 return "n --> mu+ pi-";
48 } else {
49 return "Invalid nucleon decay mode!";
50 }
51 break;
52
53 case (kNDN2nubarpi):
54 if (npdg == kPdgProton) {
55 return "p --> nubar pi+";
56 } else if (npdg == kPdgNeutron) {
57 return "n --> nubar pi0";
58 } else {
59 return "Invalid nucleon decay mode!";
60 }
61 break;
62
63 case (kNDp2epeta):
64 return "p --> e+ eta";
65 break;
66
67 case (kNDp2mupeta):
68 return "p --> mu+ eta";
69 break;
70
71 case (kNDn2nubareta):
72 return "n --> nubar eta";
73 break;
74
75 case (kNDN2eprho):
76 if (npdg == kPdgProton) {
77 return "p --> e+ rho0";
78 } else if (npdg == kPdgNeutron) {
79 return "n --> e+ rho-";
80 } else {
81 return "Invalid nucleon decay mode!";
82 }
83 break;
84
85 case (kNDN2muprho):
86 if (npdg == kPdgProton) {
87 return "p --> mu+ rho0";
88 } else if (npdg == kPdgNeutron) {
89 return "n --> mu+ rho-";
90 } else {
91 return "Invalid nucleon decay mode!";
92 }
93 break;
94
95 case (kNDN2nubarrho):
96 if (npdg == kPdgProton) {
97 return "p --> nubar rho+";
98 } else if (npdg == kPdgNeutron) {
99 return "n --> nubar rho0";
100 } else {
101 return "Invalid nucleon decay mode!";
102 }
103 break;
104
105 case (kNDp2epomega):
106 return "p --> e+ omega";
107 break;
108
109 case (kNDp2mupomega):
110 return "p --> mu+ omega";
111 break;
112
113 case (kNDn2nubaromega):
114 return "n --> nubar omega";
115 break;
116
117 case (kNDN2epK):
118 if (npdg == kPdgProton) {
119 return "p --> e+ K0";
120 } else if (npdg == kPdgNeutron) {
121 return "n --> e+ K-";
122 } else {
123 return "Invalid nucleon decay mode!";
124 }
125 break;
126
127 case (kNDp2epK0s):
128 return "p --> e+ K0s";
129 break;
130
131 case (kNDp2epK0l):
132 return "p --> e+ K0l";
133 break;
134
135 case (kNDN2mupK):
136 if (npdg == kPdgProton) {
137 return "p --> mu+ K0";
138 } else if (npdg == kPdgNeutron) {
139 return "n --> mu+ K-";
140 } else {
141 return "Invalid nucleon decay mode!";
142 }
143 break;
144
145 case (kNDp2mupK0s):
146 return "p --> mu+ K0s";
147 break;
148
149 case (kNDp2mupK0l):
150 return "p --> mu+ K0l";
151 break;
152
153 case (kNDN2nubarK):
154 if (npdg == kPdgProton) {
155 return "p --> nubar K+";
156 } else if (npdg == kPdgNeutron) {
157 return "n --> nubar K0";
158 } else {
159 return "Invalid nucleon decay mode!";
160 }
161 break;
162
163 case (kNDn2nubarK0s):
164 return "n --> nubar K0s";
165 break;
166
167 case (kNDp2epKstar0):
168 return "p --> e+ K*0";
169 break;
170
171 case (kNDN2nubarKstar):
172 if (npdg == kPdgProton) {
173 return "p --> nubar K*+";
174 } else if (npdg == kPdgNeutron) {
175 return "n --> nubar K*0";
176 } else {
177 return "Invalid nucleon decay mode!";
178 }
179 break;
180
181 case (kNDp2eppippim):
182 return "p --> e+ pi+ pi-";
183 break;
184
185 case (kNDp2eppi0pi0):
186 return "p --> e+ pi0 pi0";
187 break;
188
189 case (kNDn2eppimpi0):
190 return "n --> e+ pi- pi0";
191 break;
192
193 case (kNDp2muppippim):
194 return "p --> mu+ pi+ pi-";
195 break;
196
197 case (kNDp2muppi0pi0):
198 return "p --> mu+ pi0 pi0";
199 break;
200
201 case (kNDn2muppimpi0):
202 return "n --> mu+ pi- pi0";
203 break;
204
205 case (kNDn2epK0pim):
206 return "n --> e+ K0 pi-";
207 break;
208
209 case (kNDn2empip):
210 return "n --> e- pi+";
211 break;
212
213 case (kNDn2mumpip):
214 return "n --> mu- pi+";
215 break;
216
217 case (kNDn2emrhop):
218 return "n --> e- rho+";
219 break;
220
221 case (kNDn2mumrhop):
222 return "n --> mu- rho+";
223 break;
224
225 case (kNDn2emKp):
226 return "n --> e- K+";
227 break;
228
229 case (kNDn2mumKp):
230 return "n --> mu- K+";
231 break;
232
233 case (kNDp2empippip):
234 return "p --> e- pi+ pi+";
235 break;
236
237 case (kNDn2empippi0):
238 return "n --> e- pi+ pi0";
239 break;
240
241 case (kNDp2mumpippip):
242 return "p --> mu- pi+ pi+";
243 break;
244
245 case (kNDn2mumpippi0):
246 return "n --> mu- pi+ pi0";
247 break;
248
249 case (kNDp2empipKp):
250 return "p --> e- pi+ K+";
251 break;
252
253 case (kNDp2mumpipKp):
254 return "p --> mu- pi+ K+";
255 break;
256
257 case (kNDp2epgamma):
258 return "p --> e+ gamma";
259 break;
260
261 case (kNDp2mupgamma):
262 return "p --> mu+ gamma";
263 break;
264
265 case (kNDn2nubargamma):
266 return "n --> nubar gamma";
267 break;
268
269 case (kNDp2epgammagamma):
270 return "p --> e+ gamma gamma";
271 break;
272
273 case (kNDn2nubargammagamma):
274 return "n --> nubar gamma gamma";
275 break;
276
277 case (kNDp2epepem):
278 return "p --> e+ e+ e-";
279 break;
280
281 case (kNDp2epmupmum):
282 return "p --> e+ mu+ mu-";
283 break;
284
285 case (kNDp2epnubarnu):
286 return "p --> e+ nubar nu";
287 break;
288
289 case (kNDn2epemnubar):
290 return "n --> e+ e- nubar";
291 break;
292
293 case (kNDn2mupemnubar):
294 return "n --> mu+ e- nubar";
295 break;
296
297 case (kNDn2mupmumnubar):
298 return "n --> mu+ mu- nubar";
299 break;
300
301 case (kNDp2mupepem):
302 return "p --> mu+ e+ e-";
303 break;
304
305 case (kNDp2mupmupmum):
306 return "p --> mu+ mu+ mu-";
307 break;
308
309 case (kNDp2mupnubarnu):
310 return "p --> mu+ nubar nu";
311 break;
312
313 case (kNDp2emmupmup):
314 return "p --> e- mu+ mu+";
315 break;
316
317 case (kNDn2threenus):
318 return "n --> nubar nubar nu";
319 break;
320
321 case (kNDn2fivenus):
322 return "n --> nubar nubar nubar nu nu";
323 break;
324
325 }
326 return "Invalid nucleon decay mode!";
327}
328//____________________________________________________________________________
329bool genie::utils::nucleon_decay::IsValidMode(NucleonDecayMode_t ndm,
330 int npdg)
331{
332 switch(ndm) {
333
334 case (kNDN2eppi):
335 case (kNDN2muppi):
336 case (kNDN2nubarpi):
337 case (kNDN2eprho):
338 case (kNDN2muprho):
339 case (kNDN2nubarrho):
340 case (kNDN2epK):
341 case (kNDN2mupK):
342 case (kNDN2nubarK):
343 case (kNDN2nubarKstar):
344 if (npdg == kPdgProton || npdg == kPdgNeutron) {
345 return true;
346 } else {
347 return false;
348 }
349 break;
350
351 case (kNDp2epeta):
352 case (kNDp2mupeta):
353 case (kNDp2epomega):
354 case (kNDp2mupomega):
355 case (kNDp2epK0s):
356 case (kNDp2epK0l):
357 case (kNDp2mupK0s):
358 case (kNDp2mupK0l):
359 case (kNDp2epKstar0):
360 case (kNDp2eppippim):
361 case (kNDp2eppi0pi0):
362 case (kNDp2muppippim):
363 case (kNDp2muppi0pi0):
364 case (kNDp2empippip):
365 case (kNDp2mumpippip):
366 case (kNDp2empipKp):
367 case (kNDp2mumpipKp):
368 case (kNDp2epgamma):
369 case (kNDp2mupgamma):
370 case (kNDp2epgammagamma):
371 case (kNDp2epepem):
372 case (kNDp2epmupmum):
373 case (kNDp2epnubarnu):
374 case (kNDp2mupepem):
375 case (kNDp2mupmupmum):
376 case (kNDp2mupnubarnu):
377 case (kNDp2emmupmup):
378
379 if (npdg == kPdgProton || npdg == 0) {
380 return true;
381 } else {
382 return false;
383 }
384 break;
385
386 case (kNDn2nubareta):
387 case (kNDn2nubaromega):
388 case (kNDn2nubarK0s):
389 case (kNDn2eppimpi0):
390 case (kNDn2muppimpi0):
391 case (kNDn2epK0pim):
392 case (kNDn2empip):
393 case (kNDn2mumpip):
394 case (kNDn2emrhop):
395 case (kNDn2mumrhop):
396 case (kNDn2emKp):
397 case (kNDn2mumKp):
398 case (kNDn2empippi0):
399 case (kNDn2mumpippi0):
400 case (kNDn2nubargamma):
401 case (kNDn2nubargammagamma):
402 case (kNDn2epemnubar):
403 case (kNDn2mupemnubar):
404 case (kNDn2mupmumnubar):
405 case (kNDn2threenus):
406 case (kNDn2fivenus):
407
408 if (npdg == kPdgNeutron || npdg == 0) {
409 return true;
410 } else {
411 return false;
412 }
413 break;
414
415 default :
416 return false;
417 break;
418 }
419 return false;
420}
421//____________________________________________________________________________
422
423int genie::utils::nucleon_decay::DecayedNucleonPdgCode(NucleonDecayMode_t ndm)
424{
425 switch(ndm) {
426
427 case (kNDp2epeta) : return kPdgProton; break;
428 case (kNDp2mupeta) : return kPdgProton; break;
429 case (kNDn2nubareta) : return kPdgNeutron; break;
430 case (kNDp2epomega) : return kPdgProton; break;
431 case (kNDp2mupomega) : return kPdgProton; break;
432 case (kNDn2nubaromega) : return kPdgNeutron; break;
433 case (kNDp2epK0s) : return kPdgProton; break;
434 case (kNDp2epK0l) : return kPdgProton; break;
435 case (kNDp2mupK0s) : return kPdgProton; break;
436 case (kNDp2mupK0l) : return kPdgProton; break;
437 case (kNDn2nubarK0s) : return kPdgNeutron; break;
438 case (kNDp2epKstar0) : return kPdgProton; break;
439 case (kNDp2eppippim) : return kPdgProton; break;
440 case (kNDp2eppi0pi0) : return kPdgProton; break;
441 case (kNDn2eppimpi0) : return kPdgNeutron; break;
442 case (kNDp2muppippim) : return kPdgProton; break;
443 case (kNDp2muppi0pi0) : return kPdgProton; break;
444 case (kNDn2muppimpi0) : return kPdgNeutron; break;
445 case (kNDn2epK0pim) : return kPdgNeutron; break;
446 case (kNDn2empip) : return kPdgNeutron; break;
447 case (kNDn2mumpip) : return kPdgNeutron; break;
448 case (kNDn2emrhop) : return kPdgNeutron; break;
449 case (kNDn2mumrhop) : return kPdgNeutron; break;
450 case (kNDn2emKp) : return kPdgNeutron; break;
451 case (kNDn2mumKp) : return kPdgNeutron; break;
452 case (kNDp2empippip) : return kPdgProton; break;
453 case (kNDn2empippi0) : return kPdgNeutron; break;
454 case (kNDp2mumpippip) : return kPdgProton; break;
455 case (kNDn2mumpippi0) : return kPdgNeutron; break;
456 case (kNDp2empipKp) : return kPdgProton; break;
457 case (kNDp2mumpipKp) : return kPdgProton; break;
458 case (kNDp2epgamma) : return kPdgProton; break;
459 case (kNDp2mupgamma) : return kPdgProton; break;
460 case (kNDn2nubargamma) : return kPdgNeutron; break;
461 case (kNDp2epgammagamma) : return kPdgProton; break;
462 case (kNDn2nubargammagamma) : return kPdgNeutron; break;
463 case (kNDp2epepem) : return kPdgProton; break;
464 case (kNDp2epmupmum) : return kPdgProton; break;
465 case (kNDp2epnubarnu) : return kPdgProton; break;
466 case (kNDn2epemnubar) : return kPdgNeutron; break;
467 case (kNDn2mupemnubar) : return kPdgNeutron; break;
468 case (kNDn2mupmumnubar) : return kPdgNeutron; break;
469 case (kNDp2mupepem) : return kPdgProton; break;
470 case (kNDp2mupmupmum) : return kPdgProton; break;
471 case (kNDp2mupnubarnu) : return kPdgProton; break;
472 case (kNDp2emmupmup) : return kPdgProton; break;
473 case (kNDn2threenus) : return kPdgNeutron; break;
474 case (kNDn2fivenus) : return kPdgNeutron; break;
475
476 default : return 0; break;
477 }
478 return 0;
479}
480
481//____________________________________________________________________________
482PDGCodeList genie::utils::nucleon_decay::DecayProductList(NucleonDecayMode_t ndm,
483 int npdg)
484{
485 bool allow_duplicate = true;
486 PDGCodeList decay_products(allow_duplicate);
487
488 switch(ndm) {
489
490 case (kNDN2eppi):
491 if (npdg == kPdgProton) {
492 decay_products.push_back(kPdgPositron);
493 decay_products.push_back(kPdgPi0);
494 } else if (npdg == kPdgNeutron) {
495 decay_products.push_back(kPdgPositron);
496 decay_products.push_back(kPdgPiM);
497 }
498 break;
499
500 case (kNDN2muppi):
501 if (npdg == kPdgProton) {
502 decay_products.push_back(kPdgAntiMuon);
503 decay_products.push_back(kPdgPi0);
504 } else if (npdg == kPdgNeutron) {
505 decay_products.push_back(kPdgAntiMuon);
506 decay_products.push_back(kPdgPiM);
507 }
508 break;
509
510 case (kNDN2nubarpi):
511 if (npdg == kPdgProton) {
512 decay_products.push_back(kPdgAntiNuE);
513 decay_products.push_back(kPdgPiP);
514 } else if (npdg == kPdgNeutron) {
515 decay_products.push_back(kPdgAntiNuE);
516 decay_products.push_back(kPdgPi0);
517 }
518 break;
519
520 case (kNDp2epeta):
521 decay_products.push_back(kPdgPositron);
522 decay_products.push_back(kPdgEta);
523 break;
524
525 case (kNDp2mupeta):
526 decay_products.push_back(kPdgAntiMuon);
527 decay_products.push_back(kPdgEta);
528 break;
529
530 case (kNDn2nubareta):
531 decay_products.push_back(kPdgAntiNuE);
532 decay_products.push_back(kPdgEta);
533 break;
534
535 case (kNDN2eprho):
536 if (npdg == kPdgProton) {
537 decay_products.push_back(kPdgPositron);
538 decay_products.push_back(kPdgRho0);
539 } else if (npdg == kPdgNeutron) {
540 decay_products.push_back(kPdgPositron);
541 decay_products.push_back(kPdgRhoM);
542 }
543 break;
544
545 case (kNDN2muprho):
546 if (npdg == kPdgProton) {
547 decay_products.push_back(kPdgAntiMuon);
548 decay_products.push_back(kPdgRho0);
549 } else if (npdg == kPdgNeutron) {
550 decay_products.push_back(kPdgAntiMuon);
551 decay_products.push_back(kPdgRhoM);
552 }
553 break;
554
555 case (kNDN2nubarrho):
556 if (npdg == kPdgProton) {
557 decay_products.push_back(kPdgAntiNuE);
558 decay_products.push_back(kPdgRhoP);
559 } else if (npdg == kPdgNeutron) {
560 decay_products.push_back(kPdgAntiNuE);
561 decay_products.push_back(kPdgRho0);
562 }
563 break;
564
565 case (kNDp2epomega):
566 decay_products.push_back(kPdgPositron);
567 decay_products.push_back(kPdgomega);
568 break;
569
570 case (kNDp2mupomega):
571 decay_products.push_back(kPdgAntiMuon);
572 decay_products.push_back(kPdgomega);
573 break;
574
575 case (kNDn2nubaromega):
576 decay_products.push_back(kPdgAntiNuE);
577 decay_products.push_back(kPdgomega);
578 break;
579
580 case (kNDN2epK):
581 if (npdg == kPdgProton) {
582 decay_products.push_back(kPdgPositron);
583 decay_products.push_back(kPdgK0);
584 } else if (npdg == kPdgNeutron) {
585 decay_products.push_back(kPdgPositron);
586 decay_products.push_back(kPdgKM);
587 }
588 break;
589
590 case (kNDp2epK0s):
591 decay_products.push_back(kPdgPositron);
592 decay_products.push_back(kPdgK0S);
593 break;
594
595 case (kNDp2epK0l):
596 decay_products.push_back(kPdgPositron);
597 decay_products.push_back(kPdgK0L);
598 break;
599
600 case (kNDN2mupK):
601 if (npdg == kPdgProton) {
602 decay_products.push_back(kPdgAntiMuon);
603 decay_products.push_back(kPdgK0);
604 } else if (npdg == kPdgNeutron) {
605 decay_products.push_back(kPdgAntiMuon);
606 decay_products.push_back(kPdgKM);
607 }
608 break;
609
610 case (kNDp2mupK0s):
611 decay_products.push_back(kPdgAntiMuon);
612 decay_products.push_back(kPdgK0S);
613 break;
614
615 case (kNDp2mupK0l):
616 decay_products.push_back(kPdgAntiMuon);
617 decay_products.push_back(kPdgK0L);
618 break;
619
620 case (kNDN2nubarK):
621 if (npdg == kPdgProton) {
622 decay_products.push_back(kPdgAntiNuE);
623 decay_products.push_back(kPdgKP);
624 } else if (npdg == kPdgNeutron) {
625 decay_products.push_back(kPdgAntiNuE);
626 decay_products.push_back(kPdgK0);
627 }
628 break;
629
630 case (kNDn2nubarK0s):
631 decay_products.push_back(kPdgAntiNuE);
632 decay_products.push_back(kPdgK0S);
633 break;
634
635 case (kNDp2epKstar0):
636 decay_products.push_back(kPdgPositron);
637 decay_products.push_back(kPdgKStar0);
638 break;
639
640 case (kNDN2nubarKstar):
641 if (npdg == kPdgProton) {
642 decay_products.push_back(kPdgAntiNuE);
643 decay_products.push_back(kPdgKStarP);
644 } else if (npdg == kPdgNeutron) {
645 decay_products.push_back(kPdgAntiNuE);
646 decay_products.push_back(kPdgKStar0);
647 }
648 break;
649
650 case (kNDp2eppippim):
651 decay_products.push_back(kPdgPositron);
652 decay_products.push_back(kPdgPiP);
653 decay_products.push_back(kPdgPiM);
654 break;
655
656 case (kNDp2eppi0pi0):
657 decay_products.push_back(kPdgPositron);
658 decay_products.push_back(kPdgPi0);
659 decay_products.push_back(kPdgPi0);
660 break;
661
662 case (kNDn2eppimpi0):
663 decay_products.push_back(kPdgPositron);
664 decay_products.push_back(kPdgPiM);
665 decay_products.push_back(kPdgPi0);
666 break;
667
668 case (kNDp2muppippim):
669 decay_products.push_back(kPdgAntiMuon);
670 decay_products.push_back(kPdgPiP);
671 decay_products.push_back(kPdgPiM);
672 break;
673
674 case (kNDp2muppi0pi0):
675 decay_products.push_back(kPdgAntiMuon);
676 decay_products.push_back(kPdgPi0);
677 decay_products.push_back(kPdgPi0);
678 break;
679
680 case (kNDn2muppimpi0):
681 decay_products.push_back(kPdgAntiMuon);
682 decay_products.push_back(kPdgPiM);
683 decay_products.push_back(kPdgPi0);
684 break;
685
686 case (kNDn2epK0pim):
687 decay_products.push_back(kPdgPositron);
688 decay_products.push_back(kPdgK0);
689 decay_products.push_back(kPdgPiM);
690 break;
691
692 case (kNDn2empip):
693 decay_products.push_back(kPdgElectron);
694 decay_products.push_back(kPdgPiP);
695 break;
696
697 case (kNDn2mumpip):
698 decay_products.push_back(kPdgMuon);
699 decay_products.push_back(kPdgPiP);
700 break;
701
702 case (kNDn2emrhop):
703 decay_products.push_back(kPdgElectron);
704 decay_products.push_back(kPdgRhoP);
705 break;
706
707 case (kNDn2mumrhop):
708 decay_products.push_back(kPdgMuon);
709 decay_products.push_back(kPdgRhoP);
710 break;
711
712 case (kNDn2emKp):
713 decay_products.push_back(kPdgElectron);
714 decay_products.push_back(kPdgKP);
715 break;
716
717 case (kNDn2mumKp):
718 decay_products.push_back(kPdgMuon);
719 decay_products.push_back(kPdgKP);
720 break;
721
722 case (kNDp2empippip):
723 decay_products.push_back(kPdgElectron);
724 decay_products.push_back(kPdgPiP);
725 decay_products.push_back(kPdgPiP);
726 break;
727
728 case (kNDn2empippi0):
729 decay_products.push_back(kPdgElectron);
730 decay_products.push_back(kPdgPiP);
731 decay_products.push_back(kPdgPi0);
732 break;
733
734 case (kNDp2mumpippip):
735 decay_products.push_back(kPdgMuon);
736 decay_products.push_back(kPdgPiP);
737 decay_products.push_back(kPdgPiP);
738 break;
739
740 case (kNDn2mumpippi0):
741 decay_products.push_back(kPdgMuon);
742 decay_products.push_back(kPdgPiP);
743 decay_products.push_back(kPdgPi0);
744 break;
745
746 case (kNDp2empipKp):
747 decay_products.push_back(kPdgElectron);
748 decay_products.push_back(kPdgPiP);
749 decay_products.push_back(kPdgKP);
750 break;
751
752 case (kNDp2mumpipKp):
753 decay_products.push_back(kPdgMuon);
754 decay_products.push_back(kPdgPiP);
755 decay_products.push_back(kPdgKP);
756 break;
757
758 case (kNDp2epgamma):
759 decay_products.push_back(kPdgPositron);
760 decay_products.push_back(kPdgGamma);
761 break;
762
763 case (kNDp2mupgamma):
764 decay_products.push_back(kPdgAntiMuon);
765 decay_products.push_back(kPdgGamma);
766 break;
767
768 case (kNDn2nubargamma):
769 decay_products.push_back(kPdgAntiNuE);
770 decay_products.push_back(kPdgGamma);
771 break;
772
773 case (kNDp2epgammagamma):
774 decay_products.push_back(kPdgPositron);
775 decay_products.push_back(kPdgGamma);
776 decay_products.push_back(kPdgGamma);
777 break;
778
779 case (kNDn2nubargammagamma):
780 decay_products.push_back(kPdgAntiNuE);
781 decay_products.push_back(kPdgGamma);
782 decay_products.push_back(kPdgGamma);
783 break;
784
785 case (kNDp2epepem):
786 decay_products.push_back(kPdgPositron);
787 decay_products.push_back(kPdgPositron);
788 decay_products.push_back(kPdgElectron);
789 break;
790
791 case (kNDp2epmupmum):
792 decay_products.push_back(kPdgPositron);
793 decay_products.push_back(kPdgAntiMuon);
794 decay_products.push_back(kPdgMuon);
795 break;
796
797 case (kNDp2epnubarnu):
798 decay_products.push_back(kPdgPositron);
799 decay_products.push_back(kPdgAntiNuE);
800 decay_products.push_back(kPdgNuE);
801 break;
802
803 case (kNDn2epemnubar):
804 decay_products.push_back(kPdgPositron);
805 decay_products.push_back(kPdgElectron);
806 decay_products.push_back(kPdgAntiNuE);
807 break;
808
809 case (kNDn2mupemnubar):
810 decay_products.push_back(kPdgAntiMuon);
811 decay_products.push_back(kPdgElectron);
812 decay_products.push_back(kPdgAntiNuE);
813 break;
814
815 case (kNDn2mupmumnubar):
816 decay_products.push_back(kPdgAntiMuon);
817 decay_products.push_back(kPdgMuon);
818 decay_products.push_back(kPdgAntiNuE);
819 break;
820
821 case (kNDp2mupepem):
822 decay_products.push_back(kPdgAntiMuon);
823 decay_products.push_back(kPdgPositron);
824 decay_products.push_back(kPdgElectron);
825 break;
826
827 case (kNDp2mupmupmum):
828 decay_products.push_back(kPdgAntiMuon);
829 decay_products.push_back(kPdgAntiMuon);
830 decay_products.push_back(kPdgMuon);
831 break;
832
833 case (kNDp2mupnubarnu):
834 decay_products.push_back(kPdgAntiMuon);
835 decay_products.push_back(kPdgAntiNuE);
836 decay_products.push_back(kPdgNuE);
837 break;
838
839 case (kNDp2emmupmup):
840 decay_products.push_back(kPdgElectron);
841 decay_products.push_back(kPdgAntiMuon);
842 decay_products.push_back(kPdgAntiMuon);
843 break;
844
845 case (kNDn2threenus):
846 decay_products.push_back(kPdgAntiNuE);
847 decay_products.push_back(kPdgAntiNuE);
848 decay_products.push_back(kPdgNuE);
849 break;
850
851 case (kNDn2fivenus):
852 decay_products.push_back(kPdgAntiNuE);
853 decay_products.push_back(kPdgAntiNuE);
854 decay_products.push_back(kPdgAntiNuE);
855 decay_products.push_back(kPdgNuE);
856 decay_products.push_back(kPdgNuE);
857 break;
858
859 default :
860 break;
861 }
862 return decay_products;
863}
864//____________________________________________________________________________
865GHepStatus_t genie::utils::nucleon_decay::DecayProductStatus(
866 bool in_nucleus, int pdgc)
867{
868 if(in_nucleus) {
869 if( pdg::IsHadron(pdgc) )
870 {
871 return kIStHadronInTheNucleus;
872 }
873 }
874
875 return kIStStableFinalState;
876}
877//____________________________________________________________________________
PDGCodes.h
Most commonly used PDG codes. A set of utility functions to handle PDG codes is provided in PDGUtils.
genie::pdg::IsHadron
bool IsHadron(int pdgc)
Definition PDGUtils.cxx:392
genie::utils::nucleon_decay::DecayProductStatus
GHepStatus_t DecayProductStatus(bool in_nucleus, int pdgc)
genie::utils::nucleon_decay::IsValidMode
bool IsValidMode(NucleonDecayMode_t ndm, int npdg=0)
genie::utils::nucleon_decay::AsString
string AsString(NucleonDecayMode_t ndm, int npdg=0)
genie::utils::nucleon_decay::DecayProductList
PDGCodeList DecayProductList(NucleonDecayMode_t ndm, int npdg=0)
genie::utils::nucleon_decay::DecayedNucleonPdgCode
int DecayedNucleonPdgCode(NucleonDecayMode_t ndm)
genie
THE MAIN GENIE PROJECT NAMESPACE
Definition AlgCmp.h:25
genie::kPdgPiM
const int kPdgPiM
Definition PDGCodes.h:159
genie::kIStHadronInTheNucleus
@ kIStHadronInTheNucleus
Definition GHepStatus.h:37
genie::kIStStableFinalState
@ kIStStableFinalState
Definition GHepStatus.h:30
genie::kPdgEta
const int kPdgEta
Definition PDGCodes.h:161
genie::kPdgRho0
const int kPdgRho0
Definition PDGCodes.h:167
genie::kPdgAntiMuon
const int kPdgAntiMuon
Definition PDGCodes.h:38
genie::kPdgK0S
const int kPdgK0S
Definition PDGCodes.h:177
genie::kPdgProton
const int kPdgProton
Definition PDGCodes.h:81
genie::kPdgRhoM
const int kPdgRhoM
Definition PDGCodes.h:166
genie::kPdgPi0
const int kPdgPi0
Definition PDGCodes.h:160
genie::kPdgK0L
const int kPdgK0L
Definition PDGCodes.h:176
genie::kPdgKP
const int kPdgKP
Definition PDGCodes.h:172
genie::kNDn2nubargammagamma
@ kNDn2nubargammagamma
Definition NucleonDecayMode.h:80
genie::kNDp2epgammagamma
@ kNDp2epgammagamma
Definition NucleonDecayMode.h:79
genie::kPdgNeutron
const int kPdgNeutron
Definition PDGCodes.h:83
genie::kPdgAntiNuE
const int kPdgAntiNuE
Definition PDGCodes.h:29
genie::GHepStatus_t
enum genie::EGHepStatus GHepStatus_t
genie::NucleonDecayMode_t
enum genie::ENucleonDecayMode NucleonDecayMode_t
genie::kPdgomega
const int kPdgomega
Definition PDGCodes.h:168
genie::kPdgNuE
const int kPdgNuE
Definition PDGCodes.h:28
genie::kPdgKStar0
const int kPdgKStar0
Definition PDGCodes.h:180
genie::kPdgKM
const int kPdgKM
Definition PDGCodes.h:173
genie::kPdgPiP
const int kPdgPiP
Definition PDGCodes.h:158
genie::kPdgMuon
const int kPdgMuon
Definition PDGCodes.h:37
genie::kPdgPositron
const int kPdgPositron
Definition PDGCodes.h:36
genie::kPdgGamma
const int kPdgGamma
Definition PDGCodes.h:189
genie::kPdgElectron
const int kPdgElectron
Definition PDGCodes.h:35
genie::kPdgK0
const int kPdgK0
Definition PDGCodes.h:174
genie::kPdgKStarP
const int kPdgKStarP
Definition PDGCodes.h:178
genie::kPdgRhoP
const int kPdgRhoP
Definition PDGCodes.h:165
Generated on for GENIEGenerator by doxygen 1.14.0