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