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