Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
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