| 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 //
29 // History: first implementation, based on object model of
30 // 10 oct 1998 H.Kurashige
31 //
32 // Update mass and width following PDG 2023
33 // 4 nov 2023 S.Okada
34 // ---------------------------------------------------------------
35
36 #include "G4ExcitedDeltaConstructor.hh"
37
38 #include "G4DecayTable.hh"
39 #include "G4PhaseSpaceDecayChannel.hh"
40 #include "G4SystemOfUnits.hh"
41 #include "G4VDecayChannel.hh"
42
43 G4ExcitedDeltaConstructor::G4ExcitedDeltaConstructor()
44 : G4ExcitedBaryonConstructor(NStates, DeltaIsoSpin)
45 {}
46
47 G4int G4ExcitedDeltaConstructor::GetEncoding(G4int iIsoSpin3, G4int idxState)
48 {
49 G4int encoding;
50 // Delta has exceptinal encoding
51 if ((idxState == 1) || (idxState == 3) || (idxState == 4) || (idxState == 5) || (idxState == 7)) {
52 encoding = GetEncodingOffset(idxState);
53 if ((iIsoSpin3 == 3) || (iIsoSpin3 == -3)) {
54 // normal encoding
55 encoding += 1000 * GetQuarkContents(0, iIsoSpin3);
56 encoding += 100 * GetQuarkContents(1, iIsoSpin3);
57 encoding += 10 * GetQuarkContents(2, iIsoSpin3);
58 }
59 else if (iIsoSpin3 == +1) {
60 // 1st <--> 2nd quark
61 encoding += 1000 * GetQuarkContents(0, iIsoSpin3);
62 encoding += 10 * GetQuarkContents(1, iIsoSpin3);
63 encoding += 100 * GetQuarkContents(2, iIsoSpin3);
64 }
65 else if (iIsoSpin3 == -1) {
66 // 1st <--> 0th quark
67 encoding += 100 * GetQuarkContents(0, iIsoSpin3);
68 encoding += 1000 * GetQuarkContents(1, iIsoSpin3);
69 encoding += 10 * GetQuarkContents(2, iIsoSpin3);
70 }
71 encoding += GetiSpin(idxState) + 1;
72 }
73 else {
74 encoding = G4ExcitedBaryonConstructor::GetEncoding(iIsoSpin3, idxState);
75 }
76 return encoding;
77 }
78
79 G4DecayTable* G4ExcitedDeltaConstructor::CreateDecayTable(const G4String& parentName, G4int iIso3,
80 G4int iState, G4bool fAnti)
81 {
82 // create decay table
83 auto decayTable = new G4DecayTable();
84
85 G4double br;
86 if ((br = bRatio[iState][NGamma]) > 0.0) {
87 AddNGammaMode(decayTable, parentName, br, iIso3, fAnti);
88 }
89
90 if ((br = bRatio[iState][NPi]) > 0.0) {
91 AddNPiMode(decayTable, parentName, br, iIso3, fAnti);
92 }
93
94 if ((br = bRatio[iState][NRho]) > 0.0) {
95 AddNRhoMode(decayTable, parentName, br, iIso3, fAnti);
96 }
97
98 if ((br = bRatio[iState][DeltaPi]) > 0.0) {
99 AddDeltaPiMode(decayTable, parentName, br, iIso3, fAnti);
100 }
101
102 if ((br = bRatio[iState][NStarPi]) > 0.0) {
103 AddNStarPiMode(decayTable, parentName, br, iIso3, fAnti);
104 }
105
106 return decayTable;
107 }
108
109 G4DecayTable* G4ExcitedDeltaConstructor::AddNGammaMode(G4DecayTable* decayTable,
110 const G4String& nameParent, G4double br,
111 G4int iIso3, G4bool fAnti)
112 {
113 G4VDecayChannel* mode;
114
115 //
116 G4String daughterN;
117 if (iIso3 == +1) {
118 daughterN = "proton";
119 }
120 else if (iIso3 == -1) {
121 daughterN = "neutron";
122 }
123 else {
124 // can not decay into N+gamma
125 return decayTable;
126 }
127
128 if (fAnti) daughterN = "anti_" + daughterN;
129
130 // create decay channel [parent BR #daughters]
131 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, daughterN, "gamma");
132 // add decay table
133 decayTable->Insert(mode);
134
135 return decayTable;
136 }
137
138 G4DecayTable* G4ExcitedDeltaConstructor::AddNPiMode(G4DecayTable* decayTable,
139 const G4String& nameParent, G4double br,
140 G4int iIso3, G4bool fAnti)
141 {
142 G4VDecayChannel* mode;
143
144 G4String daughterN;
145 G4String daughterPi;
146 G4double r = 0.;
147
148 // ------------ N pi0 ------------
149 // determine daughters
150 if ((iIso3 == +1) || (iIso3 == -1)) {
151 if (iIso3 == +1) {
152 daughterN = "proton";
153 daughterPi = "pi0";
154 r = br * 2. / 3.;
155 }
156 else if (iIso3 == -1) {
157 daughterN = "neutron";
158 daughterPi = "pi0";
159 r = br / 3.;
160 }
161 if (fAnti) daughterN = "anti_" + daughterN;
162 // create decay channel [parent BR #daughters]
163 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterPi);
164 // add decay table
165 decayTable->Insert(mode);
166 }
167
168 // -------------N pi +/- --------------
169 // determine daughters
170 if (iIso3 == +3) {
171 daughterN = "proton";
172 if (!fAnti) {
173 daughterPi = "pi+";
174 }
175 else {
176 daughterPi = "pi-";
177 }
178 r = br;
179 }
180 else if (iIso3 == +1) {
181 daughterN = "neutron";
182 if (!fAnti) {
183 daughterPi = "pi+";
184 }
185 else {
186 daughterPi = "pi-";
187 }
188 r = br / 3.;
189 }
190 else if (iIso3 == -1) {
191 daughterN = "proton";
192 if (!fAnti) {
193 daughterPi = "pi-";
194 }
195 else {
196 daughterPi = "pi+";
197 }
198 r = br * 2. / 3.;
199 }
200 else if (iIso3 == -3) {
201 daughterN = "neutron";
202 if (!fAnti) {
203 daughterPi = "pi-";
204 }
205 else {
206 daughterPi = "pi+";
207 }
208 r = br;
209 }
210 if (fAnti) daughterN = "anti_" + daughterN;
211
212 // create decay channel [parent BR #daughters]
213 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterPi);
214 // add decay table
215 decayTable->Insert(mode);
216
217 return decayTable;
218 }
219
220 G4DecayTable* G4ExcitedDeltaConstructor::AddNRhoMode(G4DecayTable* decayTable,
221 const G4String& nameParent, G4double br,
222 G4int iIso3, G4bool fAnti)
223 {
224 G4VDecayChannel* mode;
225
226 G4String daughterN;
227 G4String daughterRho;
228 G4double r = 0.;
229
230 // ------------ N Rho0 ------------
231 // determine daughters
232 if ((iIso3 == +1) || (iIso3 == -1)) {
233 if (iIso3 == +1) {
234 daughterN = "proton";
235 daughterRho = "rho0";
236 r = br * 2. / 3.;
237 }
238 else if (iIso3 == -1) {
239 daughterN = "neutron";
240 daughterRho = "rho0";
241 r = br / 3.;
242 }
243 if (fAnti) daughterN = "anti_" + daughterN;
244 // create decay channel [parent BR #daughters]
245 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterRho);
246 // add decay table
247 decayTable->Insert(mode);
248 }
249
250 // -------------N Rho +/- --------------
251 // determine daughters
252 if (iIso3 == +3) {
253 daughterN = "proton";
254 if (!fAnti) {
255 daughterRho = "rho+";
256 }
257 else {
258 daughterRho = "rho-";
259 }
260 r = br;
261 }
262 else if (iIso3 == +1) {
263 daughterN = "neutron";
264 if (!fAnti) {
265 daughterRho = "rho+";
266 }
267 else {
268 daughterRho = "rho-";
269 }
270 r = br / 3.;
271 }
272 else if (iIso3 == -1) {
273 daughterN = "proton";
274 if (!fAnti) {
275 daughterRho = "rho-";
276 }
277 else {
278 daughterRho = "rho+";
279 }
280 r = br * 2. / 3.;
281 }
282 else if (iIso3 == -3) {
283 daughterN = "neutron";
284 if (!fAnti) {
285 daughterRho = "rho-";
286 }
287 else {
288 daughterRho = "rho+";
289 }
290 r = br;
291 }
292 if (fAnti) daughterN = "anti_" + daughterN;
293
294 // create decay channel [parent BR #daughters]
295 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterRho);
296 // add decay table
297 decayTable->Insert(mode);
298
299 return decayTable;
300 }
301
302 G4DecayTable* G4ExcitedDeltaConstructor::AddNStarPiMode(G4DecayTable* decayTable,
303 const G4String& nameParent, G4double br,
304 G4int iIso3, G4bool fAnti)
305 {
306 G4VDecayChannel* mode;
307
308 G4String daughterN;
309 G4String daughterPi;
310 G4double r = 0.;
311
312 // ------------ N pi0 ------------
313 // determine daughters
314 if ((iIso3 == +1) || (iIso3 == -1)) {
315 if (iIso3 == +1) {
316 daughterN = "N(1440)+";
317 daughterPi = "pi0";
318 r = br * 2. / 3.;
319 }
320 else if (iIso3 == -1) {
321 daughterN = "N(1440)0";
322 daughterPi = "pi0";
323 r = br / 3.;
324 }
325 if (fAnti) daughterN = "anti_" + daughterN;
326 // create decay channel [parent BR #daughters]
327 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterPi);
328 // add decay table
329 decayTable->Insert(mode);
330 }
331
332 // -------------N pi +/- --------------
333 // determine daughters
334 if (iIso3 == +3) {
335 daughterN = "N(1440)+";
336 if (!fAnti) {
337 daughterPi = "pi+";
338 }
339 else {
340 daughterPi = "pi-";
341 }
342 r = br;
343 }
344 else if (iIso3 == +1) {
345 daughterN = "N(1440)0";
346 if (!fAnti) {
347 daughterPi = "pi+";
348 }
349 else {
350 daughterPi = "pi-";
351 }
352 r = br / 3.;
353 }
354 else if (iIso3 == -1) {
355 daughterN = "N(1440)+";
356 if (!fAnti) {
357 daughterPi = "pi-";
358 }
359 else {
360 daughterPi = "pi+";
361 }
362 r = br * 2. / 3.;
363 }
364 else if (iIso3 == -3) {
365 daughterN = "N(1440)0";
366 if (!fAnti) {
367 daughterPi = "pi-";
368 }
369 else {
370 daughterPi = "pi+";
371 }
372 r = br;
373 }
374 if (fAnti) daughterN = "anti_" + daughterN;
375
376 // create decay channel [parent BR #daughters]
377 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterN, daughterPi);
378 // add decay table
379 decayTable->Insert(mode);
380
381 return decayTable;
382 }
383
384 G4DecayTable* G4ExcitedDeltaConstructor::AddDeltaPiMode(G4DecayTable* decayTable,
385 const G4String& nameParent, G4double br,
386 G4int iIso3, G4bool fAnti)
387 {
388 G4VDecayChannel* mode;
389
390 G4String daughterDelta;
391 G4String daughterPi;
392 G4double r;
393
394 // ------------ Delta pi +------------
395 // determine daughters
396 if (iIso3 == +3) {
397 daughterDelta = "delta+";
398 r = br * 0.4;
399 }
400 else if (iIso3 == +1) {
401 daughterDelta = "delta0";
402 r = br * 8. / 15.0;
403 }
404 else if (iIso3 == -1) {
405 daughterDelta = "delta-";
406 r = br * 6. / 15.;
407 }
408 else {
409 r = 0.;
410 }
411 if (!fAnti) {
412 daughterPi = "pi+";
413 }
414 else {
415 daughterPi = "pi-";
416 }
417 if (fAnti) daughterDelta = "anti_" + daughterDelta;
418 if (r > 0.0) {
419 // create decay channel [parent BR #daughters]
420 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterDelta, daughterPi);
421 // add decay table
422 decayTable->Insert(mode);
423 }
424
425 // ------------ Delta pi0 ------------
426 // determine daughters
427 if (iIso3 == +3) {
428 daughterDelta = "delta++";
429 r = br * 0.6;
430 }
431 else if (iIso3 == +1) {
432 daughterDelta = "delta+";
433 r = br * 1. / 15.0;
434 }
435 else if (iIso3 == -1) {
436 daughterDelta = "delta0";
437 r = br * 1. / 15.;
438 }
439 else {
440 daughterDelta = "delta-";
441 r = br * 0.6;
442 }
443 daughterPi = "pi0";
444 if (fAnti) daughterDelta = "anti_" + daughterDelta;
445
446 // create decay channel [parent BR #daughters]
447 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterDelta, daughterPi);
448 // add decay table
449 decayTable->Insert(mode);
450
451 // ------------ Delta pi - -------------
452 // determine daughters
453 if (iIso3 == +3) {
454 r = 0.;
455 }
456 else if (iIso3 == +1) {
457 daughterDelta = "delta++";
458 r = br * 6. / 15.0;
459 }
460 else if (iIso3 == -1) {
461 daughterDelta = "delta+";
462 r = br * 8. / 15.;
463 }
464 else {
465 daughterDelta = "delta0";
466 r = br * 0.4;
467 }
468 if (!fAnti) {
469 daughterPi = "pi-";
470 }
471 else {
472 daughterPi = "pi+";
473 }
474 if (fAnti) daughterDelta = "anti_" + daughterDelta;
475 if (r > 0.0) {
476 // create decay channel [parent BR #daughters]
477 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterDelta, daughterPi);
478 // add decay table
479 decayTable->Insert(mode);
480 }
481
482 return decayTable;
483 }
484
485 // clang-format off
486 const char* G4ExcitedDeltaConstructor::name[] =
487 {
488 "delta(1600)", "delta(1620)", "delta(1700)", "delta(1900)", "delta(1905)",
489 "delta(1910)", "delta(1920)", "delta(1930)", "delta(1950)"
490 };
491
492 const G4double G4ExcitedDeltaConstructor::mass[] =
493 {
494 1.570*GeV, 1.610*GeV, 1.710*GeV, 1.860*GeV, 1.880*GeV,
495 1.900*GeV, 1.920*GeV, 1.950*GeV, 1.930*GeV
496 };
497
498 const G4double G4ExcitedDeltaConstructor::width[] = {
499 250.0*MeV, 130.0*MeV, 300.0*MeV, 250.0*MeV, 330.0*MeV,
500 300.0*MeV, 300.0*MeV, 300.0*MeV, 285.0*MeV
501 };
502
503 const G4int G4ExcitedDeltaConstructor::iSpin[] =
504 {
505 3, 1, 3, 1, 5,
506 1, 3, 5, 7
507 };
508
509 const G4int G4ExcitedDeltaConstructor::iParity[] = {
510 +1, -1, -1, -1, +1,
511 +1, +1, -1, +1
512 };
513
514 const G4int G4ExcitedDeltaConstructor::encodingOffset[] = {
515 30000, 0, 10000, 10000, 0,
516 20000, 20000, 10000, 0
517 };
518
519 const G4double G4ExcitedDeltaConstructor::bRatio[ G4ExcitedDeltaConstructor::NStates ][ G4ExcitedDeltaConstructor::NumberOfDecayModes] =
520 {
521 // NGamma Npi NRho DeltaPi N*Pi
522 { 0.0, 0.15, 0.0, 0.55, 0.30 },
523 { 0.0, 0.25, 0.0, 0.60, 0.15 },
524 { 0.0, 0.20, 0.10, 0.55, 0.15 },
525 { 0.0, 0.30, 0.15, 0.30, 0.25 },
526 { 0.0, 0.20, 0.60, 0.10, 0.10 },
527 { 0.0, 0.35, 0.40, 0.15, 0.10 },
528 { 0.0, 0.15, 0.30, 0.30, 0.25 },
529 { 0.0, 0.20, 0.25, 0.25, 0.30 },
530 { 0.01, 0.44, 0.15, 0.20, 0.20 }
531 };
532