source: trunk/source/particles/shortlived/src/G4ExcitedDeltaConstructor.cc@ 1305

Last change on this file since 1305 was 1196, checked in by garnier, 16 years ago

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