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