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
G4ExcitedMesonConstructor.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// 01 Oct. 02 Fixed PDG codes for a0(1450), f0(1370), k0_star(1430)
36
37#include "G4ExcitedMesonConstructor.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
48G4ExcitedMesonConstructor::G4ExcitedMesonConstructor(G4int ,
49 G4int )
50 : type("meson"), leptonNumber(0), baryonNumber(0)
51{
52}
53
54G4ExcitedMesonConstructor::~G4ExcitedMesonConstructor()
55{
56}
57
58void G4ExcitedMesonConstructor::Construct(G4int idx)
59{
60 G4int iType;
61 if (idx < 0 ) {
62 for (G4int state=0; state< NMultiplets; state +=1) {
63 for (iType = 0; iType < NMesonTypes ; iType++)
64 ConstructMesons(state, iType);
65 }
66 } else if (idx < NMultiplets ) {
67 for (iType = 0; iType < NMesonTypes ; iType++)
68 ConstructMesons(idx, iType);
69 } else {
70#ifdef G4VERBOSE
71 if (G4ParticleTable::GetParticleTable()->GetVerboseLevel()>1) {
72 G4cerr << "G4ExcitedMesonConstructor::Construct()";
73 G4cerr << " illegal index os state = " << idx << G4endl;
74 }
75#endif
76 }
77}
78
79G4bool G4ExcitedMesonConstructor::Exist(G4int idxState, G4int idxType)
80{
81 G4bool value = true;
82 if ( idxType == TEtaPrime ) {
83 if (idxState==N13P0) value = false;
84 if (idxState==N13D1) value = false;
85 } else if ( idxType == TPi ) {
86 if (idxState==N23P2) value = false;
87 }
88 return value;
89}
90
91#include "G4ExcitedMesons.hh"
92
93void G4ExcitedMesonConstructor::ConstructMesons(G4int iState, G4int iType)
94{
95 if (!Exist(iState, iType) ) return;
96
97 // Construct Resonace particles as dynamic object
98 // Arguments for constructor are as follows
99 // name mass width
100 // charge 2*spin
101 // parity C-conjugation
102 // 2*Isospin 2*Isospin3
103 // G-parity
104 // type lepton number Baryon number
105 // PDG encoding
106 // stable lifetime decay table
107
108
109 G4String aName;
110 G4ExcitedMesons* particle;
111
112 for ( G4int iIso3=(-1)*iIsoSpin[iType]; iIso3<=iIsoSpin[iType]; iIso3+=2) {
113 aName= GetName(iIso3, iState, iType);
114 G4double fmass = mass[iState][iType];
115 G4double fwidth = width[iState][iType];
116 if ( (iType== TK) || (iType==TAntiK ) ) {
117 if ( GetCharge(iIso3,iType) == 0.0) {
118 fmass += massKdiff[iState];
119 fwidth += widthKdiff[iState];
120 }
121 }
122 particle = new G4ExcitedMesons(
123 aName, fmass, fwidth,
124 GetCharge(iIso3,iType), iSpin[iState],
125 iParity[iState], iChargeConjugation[iState],
126 iIsoSpin[iType], iIso3,
127 iGParity[iState][iType],
128 type, leptonNumber, baryonNumber,
129 GetEncoding(iIso3, iState, iType),
130 false, 0.0, NULL
131 );
132
133 if ( (iType==TEta) || (iType==TEtaPrime) || ((iType==TPi)&&(iIso3==0)) ) {
134 // set same encoding for AntiParticle
135 particle->SetAntiPDGEncoding(GetEncoding(iIso3, iState, iType));
136 }
137 particle->SetMultipletName(name[iState][iType]);
138 particle->SetDecayTable(CreateDecayTable( aName, iIso3, iState, iType));
139 }
140}
141
142
143G4int G4ExcitedMesonConstructor::GetQuarkContents(G4int iQ,
144 G4int iIso3,
145 G4int iType)
146{
147 // Quark contents
148
149 G4int quark=0;
150 if (iType == TPi) {
151 if ( iIso3 == 2 ){
152 if ( iQ == 0 ){ quark = 2; }
153 else { quark = 1; }
154 } else if ( iIso3 == 0 ){
155 quark = 1;
156 } else if ( iIso3 == -2 ){
157 if ( iQ == 0 ){ quark = 1; }
158 else { quark = 2; }
159 }
160 } else if (iType == TEta) {
161 quark = 2;
162
163 } else if (iType == TEtaPrime) {
164 quark = 3;
165
166 } else if (iType == TAntiK) {
167 if ( iIso3 == 1 ){
168 if ( iQ == 0 ){ quark = 3; }
169 else { quark = 1; }
170 } else if ( iIso3 == -1 ){
171 if ( iQ == 0 ){ quark = 3; }
172 else { quark = 2; }
173 }
174
175 } else if (iType == TK) {
176 if ( iIso3 == 1 ){
177 if ( iQ == 0 ){ quark = 2; }
178 else { quark = 3; }
179 } else if ( iIso3 == -1 ){
180 if ( iQ == 0 ){ quark = 1; }
181 else { quark = 3; }
182 }
183
184 }
185 return quark;
186}
187
188G4double G4ExcitedMesonConstructor::GetCharge(G4int iIsoSpin3, G4int idxType )
189{
190 static G4double quark_charge[7] =
191 {
192 0., -1./3., +2./3., -1./3., +2./3., -1./3., +2./3.
193 };
194
195 G4double charge = quark_charge[GetQuarkContents(0, iIsoSpin3, idxType)]*eplus;
196 charge -= quark_charge[GetQuarkContents(1, iIsoSpin3, idxType)]*eplus;
197 return charge;
198}
199
200G4int G4ExcitedMesonConstructor::GetEncoding(G4int iIsoSpin3,
201 G4int idxState,
202 G4int idxType )
203{
204 G4int encoding = encodingOffset[idxState];
205 encoding += iSpin[idxState] +1;
206 G4int iQ = 0;
207 G4int iQbar = 1;
208
209 if ( idxType == TPi ) {
210 if (iIsoSpin3<0) {
211 iQ = 1;
212 iQbar = 0;
213 }
214 } else if ( idxType == TK ) {
215 iQ = 1;
216 iQbar = 0;
217 }
218
219
220 encoding += 100*GetQuarkContents(iQ, iIsoSpin3, idxType);
221 encoding += 10*GetQuarkContents(iQbar, iIsoSpin3, idxType);
222 if ( idxType == TPi ) {
223 if (iIsoSpin3<0) {
224 encoding *= -1;
225 }
226 } else if ( idxType == TAntiK ) {
227 encoding *= -1;
228 }
229
230// PDG2005
231//
232 if (idxState == 9 ) {
233 if (idxType == TEta) {
234// f2(1810) 9030225
235 encoding = 9030225;
236 } else if (idxType == TEtaPrime) {
237// f2(2010) 9060225
238 encoding = 9060225;
239 }
240 }
241
242 return encoding;
243}
244
245G4DecayTable* G4ExcitedMesonConstructor::CreateDecayTable(
246 const G4String& parentName,
247 G4int iIso3,
248 G4int iState,
249 G4int iType)
250{
251 // create decay table
252 G4DecayTable* decayTable = new G4DecayTable();
253 G4double br;
254
255 if ((iType==TK)||(iType==TAntiK)) {
256
257 if ( (br=bRatio[iState][iType][MKPi]) >0.0) {
258 AddKPiMode( decayTable, parentName, br, iIso3, iType );
259 }
260 if ( (br=bRatio[iState][iType][MKStarPi]) >0.0) {
261 AddKStarPiMode( decayTable, parentName, br, iIso3, iType );
262 }
263 if ( (br=bRatio[iState][iType][MKRho]) >0.0) {
264 AddKRhoMode( decayTable, parentName, br, iIso3, iType );
265 }
266 if ( (br=bRatio[iState][iType][MKOmega]) >0.0) {
267 AddKOmegaMode( decayTable, parentName, br, iIso3, iType );
268 }
269 if ( (br=bRatio[iState][iType][MKStar2Pi]) >0.0) {
270 AddKStar2PiMode( decayTable, parentName, br, iIso3, iType );
271 }
272 if ( (br=bRatio[iState][iType][MKTwoPi]) >0.0) {
273 AddKTwoPiMode( decayTable, parentName, br, iIso3, iType );
274 }
275 if ( (br=bRatio[iState][iType][MKEta]) >0.0) {
276 AddKEtaMode( decayTable, parentName, br, iIso3, iType );
277 }
278
279 } else {
280 if ( (br=bRatio[iState][iType][MPiGamma]) >0.0) {
281 AddPiGammaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
282 }
283 if ( (br=bRatio[iState][iType][MRhoGamma]) >0.0) {
284 AddRhoGammaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
285 }
286 if ( (br=bRatio[iState][iType][M2Pi]) >0.0) {
287 Add2PiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
288 }
289 if ( (br=bRatio[iState][iType][MPiRho]) >0.0) {
290 AddPiRhoMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
291 }
292 if ( (br=bRatio[iState][iType][M3Pi]) >0.0) {
293 Add3PiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
294 }
295 if ( (br=bRatio[iState][iType][M4Pi]) >0.0) {
296 Add4PiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
297 }
298 if ( (br=bRatio[iState][iType][MKKStar]) >0.0) {
299 AddKKStarMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
300 }
301 if ( (br=bRatio[iState][iType][M2PiEta]) >0.0) {
302 Add2PiEtaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
303 }
304 if ( (br=bRatio[iState][iType][MRhoEta]) >0.0) {
305 AddRhoEtaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
306 }
307 if ( (br=bRatio[iState][iType][M2PiRho]) >0.0) {
308 Add2PiRhoMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
309 }
310 if ( (br=bRatio[iState][iType][M2PiOmega]) >0.0) {
311 Add2PiOmegaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
312 }
313 if ( (br=bRatio[iState][iType][M2Eta]) >0.0) {
314 Add2EtaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
315 }
316 if ( (br=bRatio[iState][iType][M2K]) >0.0) {
317 Add2KMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
318 }
319 if ( (br=bRatio[iState][iType][M2KPi]) >0.0) {
320 Add2KPiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
321 }
322 if ( (br=bRatio[iState][iType][MPiOmega]) >0.0) {
323 AddPiOmegaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
324 }
325 if ( (br=bRatio[iState][iType][MPiF2]) >0.0) {
326 AddPiF2Mode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
327 }
328 if ( (br=bRatio[iState][iType][MPiF0]) >0.0) {
329 AddPiF0Mode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
330 }
331 if ( (br=bRatio[iState][iType][MPiA2]) >0.0) {
332 AddPiA2Mode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
333 }
334 }
335
336 return decayTable;
337}
338
339G4DecayTable* G4ExcitedMesonConstructor::AddKPiMode(
340 G4DecayTable* decayTable, const G4String& nameParent,
341 G4double br, G4int iIso3, G4int iType)
342{
343 G4VDecayChannel* mode;
344 //
345 if (iIso3 == +1) {
346 if (iType == TK) {
347 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
348 "kaon+","pi0");
349 decayTable->Insert(mode);
350 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
351 "kaon0","pi+");
352 decayTable->Insert(mode);
353 }else if (iType==TAntiK) {
354 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
355 "anti_kaon0","pi0");
356 decayTable->Insert(mode);
357 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
358 "kaon-","pi+");
359 decayTable->Insert(mode);
360 }
361 } else if (iIso3 == -1) {
362 if (iType == TK) {
363 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
364 "kaon0","pi0");
365 decayTable->Insert(mode);
366 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
367 "kaon+","pi-");
368 decayTable->Insert(mode);
369
370 }else if (iType==TAntiK) {
371 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
372 "kaon-","pi0");
373 decayTable->Insert(mode);
374 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
375 "anti_kaon0","pi-");
376 decayTable->Insert(mode);
377 }
378 }
379
380 return decayTable;
381}
382G4DecayTable* G4ExcitedMesonConstructor::AddKTwoPiMode(
383 G4DecayTable* decayTable, const G4String& nameParent,
384 G4double br, G4int iIso3, G4int iType)
385{
386 G4VDecayChannel* mode;
387 //
388 if (iIso3 == +1) {
389 if (iType == TK) {
390 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
391 "k2_star(1430)+","pi0");
392 decayTable->Insert(mode);
393 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
394 "k2_star(1430)0","pi+");
395 decayTable->Insert(mode);
396 }else if (iType==TAntiK) {
397 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
398 "anti_k2_star(1430)0","pi0");
399 decayTable->Insert(mode);
400 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
401 "k2_star(1430)-","pi+");
402 decayTable->Insert(mode);
403 }
404 } else if (iIso3 == -1) {
405 if (iType == TK) {
406 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
407 "k2_star(1430)0","pi0");
408 decayTable->Insert(mode);
409 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
410 "k2_star(1430)+","pi-");
411 decayTable->Insert(mode);
412
413 }else if (iType==TAntiK) {
414 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
415 "k2_star(1430)-","pi0");
416 decayTable->Insert(mode);
417 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
418 "anti_k2_star(1430)0","pi-");
419 decayTable->Insert(mode);
420 }
421 }
422
423 return decayTable;
424}
425
426G4DecayTable* G4ExcitedMesonConstructor::AddKOmegaMode(
427 G4DecayTable* decayTable, const G4String& nameParent,
428 G4double br, G4int iIso3, G4int iType)
429{
430 G4VDecayChannel* mode;
431 //
432 if (iIso3 == +1) {
433 if (iType == TK) {
434 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
435 "kaon+","omega");
436 decayTable->Insert(mode);
437 }else if (iType==TAntiK) {
438 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
439 "anti_kaon0","omega");
440 decayTable->Insert(mode);
441 }
442 } else if (iIso3 == -1) {
443 if (iType == TK) {
444 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
445 "kaon0","omega");
446 decayTable->Insert(mode);
447 }else if (iType==TAntiK) {
448 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
449 "kaon-","omega");
450 decayTable->Insert(mode);
451 }
452 }
453
454 return decayTable;
455}
456
457G4DecayTable* G4ExcitedMesonConstructor::AddKEtaMode(
458 G4DecayTable* decayTable, const G4String& nameParent,
459 G4double br, G4int iIso3, G4int iType)
460{
461 G4VDecayChannel* mode;
462 //
463 if (iIso3 == +1) {
464 if (iType == TK) {
465 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
466 "kaon+","eta");
467 decayTable->Insert(mode);
468 }else if (iType==TAntiK) {
469 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
470 "anti_kaon0","eta");
471 decayTable->Insert(mode);
472 }
473 } else if (iIso3 == -1) {
474 if (iType == TK) {
475 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
476 "kaon0","eta");
477 decayTable->Insert(mode);
478 }else if (iType==TAntiK) {
479 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
480 "kaon-","eta");
481 decayTable->Insert(mode);
482 }
483 }
484
485 return decayTable;
486}
487
488G4DecayTable* G4ExcitedMesonConstructor::AddKRhoMode(
489 G4DecayTable* decayTable, const G4String& nameParent,
490 G4double br, G4int iIso3, G4int iType)
491{
492 G4VDecayChannel* mode;
493 //
494 if (iIso3 == +1) {
495 if (iType == TK) {
496 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
497 "kaon+","rho0");
498 decayTable->Insert(mode);
499 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
500 "kaon0","rho+");
501 decayTable->Insert(mode);
502 }else if (iType==TAntiK) {
503 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
504 "anti_kaon0","rho0");
505 decayTable->Insert(mode);
506 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
507 "kaon-","rho+");
508 decayTable->Insert(mode);
509 }
510 } else if (iIso3 == -1) {
511 if (iType == TK) {
512 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
513 "kaon0","rho0");
514 decayTable->Insert(mode);
515 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
516 "kaon+","rho-");
517 decayTable->Insert(mode);
518
519 }else if (iType==TAntiK) {
520 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
521 "kaon-","rho0");
522 decayTable->Insert(mode);
523 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
524 "anti_kaon0","rho-");
525 decayTable->Insert(mode);
526 }
527 }
528
529 return decayTable;
530}
531
532G4DecayTable* G4ExcitedMesonConstructor::AddKStarPiMode(
533 G4DecayTable* decayTable, const G4String& nameParent,
534 G4double br, G4int iIso3, G4int iType)
535{
536 G4VDecayChannel* mode;
537 //
538 if (iIso3 == +1) {
539 if (iType == TK) {
540 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
541 "k_star+","pi0");
542 decayTable->Insert(mode);
543 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
544 "k_star0","pi+");
545 decayTable->Insert(mode);
546 }else if (iType==TAntiK) {
547 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
548 "anti_k_star0","pi0");
549 decayTable->Insert(mode);
550 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
551 "k_star-","pi+");
552 decayTable->Insert(mode);
553 }
554 } else if (iIso3 == -1) {
555 if (iType == TK) {
556 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
557 "k_star0","pi0");
558 decayTable->Insert(mode);
559 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
560 "k_star+","pi-");
561 decayTable->Insert(mode);
562
563 }else if (iType==TAntiK) {
564 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
565 "k_star-","pi0");
566 decayTable->Insert(mode);
567 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
568 "anti_k_star0","pi-");
569 decayTable->Insert(mode);
570 }
571 }
572
573 return decayTable;
574}
575
576G4DecayTable* G4ExcitedMesonConstructor::AddKStar2PiMode(
577 G4DecayTable* decayTable, const G4String& nameParent,
578 G4double br, G4int iIso3, G4int iType)
579{
580 // K* --> K pipi(I=1)
581 G4VDecayChannel* mode;
582 //
583 if (iIso3 == +1) {
584 if (iType == TK) {
585 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
586 "k_star+","pi+","pi-");
587 decayTable->Insert(mode);
588 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
589 "k_star0","pi+","pi0");
590 decayTable->Insert(mode);
591 }else if (iType==TAntiK) {
592 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
593 "anti_k_star0","pi+","pi-");
594 decayTable->Insert(mode);
595 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
596 "k_star-","pi+","pi0");
597 decayTable->Insert(mode);
598 }
599 } else if (iIso3 == -1) {
600 if (iType == TK) {
601 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
602 "k_star0","pi+","pi-");
603 decayTable->Insert(mode);
604 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
605 "k_star+","pi-","pi0");
606 decayTable->Insert(mode);
607
608 }else if (iType==TAntiK) {
609 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
610 "k_star-","pi+","pi-");
611 decayTable->Insert(mode);
612 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
613 "anti_k_star0","pi-","pi0");
614 decayTable->Insert(mode);
615 }
616 }
617
618 return decayTable;
619}
620
621G4DecayTable* G4ExcitedMesonConstructor::AddPiGammaMode(
622 G4DecayTable* decayTable, const G4String& nameParent,
623 G4double br, G4int iIso3, G4int iIso)
624{
625 if ((iIso!=2)&&(iIso!=0)) return decayTable;
626
627 G4VDecayChannel* mode;
628 //
629 G4String daughter;
630 if (iIso3 == +2) {
631 daughter = "pi+";
632 } else if (iIso3 == 0) {
633 daughter = "pi0";
634 } else if (iIso3 ==-2) {
635 daughter = "pi-";
636 } else {
637 return decayTable;
638 }
639 // create decay channel [parent BR #daughters]
640 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
641 daughter,"gamma");
642 // add decay table
643 decayTable->Insert(mode);
644
645 return decayTable;
646}
647
648G4DecayTable* G4ExcitedMesonConstructor::AddPiOmegaMode(
649 G4DecayTable* decayTable, const G4String& nameParent,
650 G4double br, G4int iIso3, G4int iIso)
651{
652 if ((iIso!=2)&&(iIso!=0)) return decayTable;
653
654 G4VDecayChannel* mode;
655 //
656 G4String daughter;
657 if (iIso3 == +2) {
658 daughter = "pi+";
659 } else if (iIso3 == 0) {
660 daughter = "pi0";
661 } else if (iIso3 ==-2) {
662 daughter = "pi-";
663 } else {
664 return decayTable;
665 }
666 // create decay channel [parent BR #daughters]
667 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
668 daughter,"omega");
669 // add decay table
670 decayTable->Insert(mode);
671
672 return decayTable;
673}
674
675G4DecayTable* G4ExcitedMesonConstructor::AddRhoGammaMode(
676 G4DecayTable* decayTable, const G4String& nameParent,
677 G4double br, G4int iIso3, G4int iIso)
678{
679 if ((iIso!=2)&&(iIso!=0)) return decayTable;
680
681 G4VDecayChannel* mode;
682 //
683 G4String daughter;
684 if (iIso3 == +2) {
685 daughter = "rho+";
686 } else if (iIso3 == 0) {
687 daughter = "rho0";
688 } else if (iIso3 ==-2) {
689 daughter = "rho-";
690 } else {
691 return decayTable;
692 }
693 // create decay channel [parent BR #daughters]
694 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
695 daughter,"gamma");
696 // add decay table
697 decayTable->Insert(mode);
698
699 return decayTable;
700}
701
702G4DecayTable* G4ExcitedMesonConstructor::AddPiEtaMode(
703 G4DecayTable* decayTable, const G4String& nameParent,
704 G4double br, G4int iIso3, G4int iIso)
705{
706 if ((iIso!=2)&&(iIso!=0)) return decayTable;
707
708 G4VDecayChannel* mode;
709 //
710 G4String daughter;
711 if (iIso3 == +2) {
712 daughter = "pi+";
713 } else if (iIso3 == 0) {
714 daughter = "pi0";
715 } else if (iIso3 ==-2) {
716 daughter = "pi-";
717 } else {
718 return decayTable;
719 }
720 // create decay channel [parent BR #daughters]
721 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
722 daughter,"eta");
723 // add decay table
724 decayTable->Insert(mode);
725
726 return decayTable;
727}
728
729G4DecayTable* G4ExcitedMesonConstructor::AddRhoEtaMode(
730 G4DecayTable* decayTable, const G4String& nameParent,
731 G4double br, G4int iIso3, G4int iIso)
732{
733 if ((iIso!=2)&&(iIso!=0)) return decayTable;
734
735 G4VDecayChannel* mode;
736 //
737 G4String daughter;
738 if (iIso3 == +2) {
739 daughter = "rho+";
740 } else if (iIso3 == 0) {
741 daughter = "rho0";
742 } else if (iIso3 ==-2) {
743 daughter = "rho-";
744 } else {
745 return decayTable;
746 }
747 // create decay channel [parent BR #daughters]
748 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
749 daughter,"eta");
750 // add decay table
751 decayTable->Insert(mode);
752
753 return decayTable;
754}
755
756G4DecayTable* G4ExcitedMesonConstructor::AddPiF2Mode(
757 G4DecayTable* decayTable, const G4String& nameParent,
758 G4double br, G4int iIso3, G4int iIso)
759{
760 if ((iIso!=2)&&(iIso!=0)) return decayTable;
761
762 G4VDecayChannel* mode;
763 //
764 G4String daughter;
765 if (iIso3 == +2) {
766 daughter = "pi+";
767 } else if (iIso3 == 0) {
768 daughter = "pi0";
769 } else if (iIso3 ==-2) {
770 daughter = "pi-";
771 } else {
772 return decayTable;
773 }
774 // create decay channel [parent BR #daughters]
775 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
776 daughter,"f2(1270)");
777 // add decay table
778 decayTable->Insert(mode);
779
780 return decayTable;
781}
782
783G4DecayTable* G4ExcitedMesonConstructor::AddPiF0Mode(
784 G4DecayTable* decayTable, const G4String& nameParent,
785 G4double br, G4int iIso3, G4int iIso)
786{
787 if ((iIso!=2)&&(iIso!=0)) return decayTable;
788
789 G4VDecayChannel* mode;
790 //
791 G4String daughter;
792 if (iIso3 == +2) {
793 daughter = "pi+";
794 } else if (iIso3 == 0) {
795 daughter = "pi0";
796 } else if (iIso3 ==-2) {
797 daughter = "pi-";
798 } else {
799 return decayTable;
800 }
801 // create decay channel [parent BR #daughters]
802 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
803 daughter,"f0(1370)");
804 // add decay table
805 decayTable->Insert(mode);
806 return decayTable;
807}
808
809
810G4DecayTable* G4ExcitedMesonConstructor::Add2PiMode(
811 G4DecayTable* decayTable, const G4String& nameParent,
812 G4double br, G4int iIso3, G4int iIso)
813{
814 G4VDecayChannel* mode;
815
816 G4String daughterPi1;
817 G4String daughterPi2;
818 G4double r;
819
820 // I = 0 states
821 if (iIso==0) {
822 if (iIso3==0) {
823 // pi+ + pi-
824 daughterPi1 = "pi+";
825 daughterPi2 = "pi-";
826 r = br*2./3.;
827 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
828 daughterPi1,daughterPi2);
829 decayTable->Insert(mode);
830
831 // pi0 + pi0
832 daughterPi1 = "pi0";
833 daughterPi2 = "pi0";
834 r = br*1./3.;
835 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
836 daughterPi1,daughterPi2);
837 decayTable->Insert(mode);
838 }
839 } else if (iIso==2) {
840 if (iIso3==+2) {
841 // pi+ + pi0
842 daughterPi1 = "pi+";
843 daughterPi2 = "pi0";
844 r = br;
845 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
846 daughterPi1,daughterPi2);
847 // add decay table
848 decayTable->Insert(mode);
849 } else if (iIso3==0) {
850 // pi+ + pi-
851 daughterPi1 = "pi+";
852 daughterPi2 = "pi-";
853 r = br;
854 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
855 daughterPi1,daughterPi2);
856 decayTable->Insert(mode);
857 } else if (iIso3==-2) {
858 // pi- + pi0
859 daughterPi1 = "pi-";
860 daughterPi2 = "pi0";
861 r = br;
862 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
863 daughterPi1,daughterPi2);
864 decayTable->Insert(mode);
865 }
866 }
867 return decayTable;
868}
869
870G4DecayTable* G4ExcitedMesonConstructor::AddPiRhoMode(
871 G4DecayTable* decayTable, const G4String& nameParent,
872 G4double br, G4int iIso3, G4int iIso)
873{
874 G4VDecayChannel* mode;
875
876 G4String daughterPi;
877 G4String daughterRho;
878 G4double r;
879
880 // I = 0 states
881 if (iIso==0) {
882 if (iIso3==0) {
883 // pi+ + rho-
884 daughterPi = "pi+";
885 daughterRho = "rho-";
886 r = br/3.;
887 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
888 daughterPi,daughterRho);
889 decayTable->Insert(mode);
890
891 // pi0 + rho0
892 daughterPi = "pi0";
893 daughterRho = "rho0";
894 r = br*1./3.;
895 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
896 daughterPi,daughterRho);
897 decayTable->Insert(mode);
898
899 // pi- + rho+
900 daughterPi = "pi-";
901 daughterRho = "rho+";
902 r = br*1./3.;
903 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
904 daughterPi,daughterRho);
905 decayTable->Insert(mode);
906 }
907 } else if (iIso==2) {
908 if (iIso3==+2) {
909 // pi+ + rho0
910 daughterPi = "pi+";
911 daughterRho = "rho0";
912 r = br/2.;
913 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
914 daughterPi,daughterRho);
915 decayTable->Insert(mode);
916
917 // pi0 + rho+
918 daughterPi = "pi0";
919 daughterRho = "rho+";
920 r = br/2.;
921 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
922 daughterPi,daughterRho);
923 decayTable->Insert(mode);
924 } else if (iIso3==0) {
925 // pi+ + rho-
926 daughterPi = "pi+";
927 daughterRho = "rho-";
928 r = br/2.;
929 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
930 daughterPi,daughterRho);
931 decayTable->Insert(mode);
932
933 // pi- + rho+
934 daughterPi = "pi-";
935 daughterRho = "rho+";
936 r = br/2.;
937 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
938 daughterPi,daughterRho);
939 decayTable->Insert(mode);
940 } else if (iIso3==-2) {
941 // pi- + rho0
942 daughterPi = "pi-";
943 daughterRho = "rho0";
944 r = br/2.;
945 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
946 daughterPi,daughterRho);
947 decayTable->Insert(mode);
948
949 // pi0 + rho-
950 daughterPi = "pi0";
951 daughterRho = "rho-";
952 r = br/2.;
953 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
954 daughterPi,daughterRho);
955 decayTable->Insert(mode);
956 }
957 }
958 return decayTable;
959}
960
961G4DecayTable* G4ExcitedMesonConstructor::AddPiA2Mode(
962 G4DecayTable* decayTable, const G4String& nameParent,
963 G4double br, G4int iIso3, G4int iIso)
964{
965 G4VDecayChannel* mode;
966
967 G4String daughterPi;
968 G4String daughterA2;
969 G4double r;
970
971 // I = 0 states
972 if (iIso==0) {
973 if (iIso3==0) {
974 // pi+ + a2(1320)-
975 daughterPi = "pi+";
976 daughterA2 = "a2(1320)-";
977 r = br/3.;
978 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
979 daughterPi,daughterA2);
980 decayTable->Insert(mode);
981
982 // pi0 + a2(1320)0
983 daughterPi = "pi0";
984 daughterA2 = "a2(1320)0";
985 r = br*1./3.;
986 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
987 daughterPi,daughterA2);
988 decayTable->Insert(mode);
989
990 // pi- + a2(1320)+
991 daughterPi = "pi-";
992 daughterA2 = "a2(1320)+";
993 r = br*1./3.;
994 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
995 daughterPi,daughterA2);
996 decayTable->Insert(mode);
997 }
998 } else if (iIso==2) {
999 if (iIso3==+2) {
1000 // pi+ + a2(1320)0
1001 daughterPi = "pi+";
1002 daughterA2 = "a2(1320)0";
1003 r = br/2.;
1004 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
1005 daughterPi,daughterA2);
1006 decayTable->Insert(mode);
1007
1008 // pi0 + a2(1320)+
1009 daughterPi = "pi0";
1010 daughterA2 = "a2(1320)+";
1011 r = br/2.;
1012 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
1013 daughterPi,daughterA2);
1014 decayTable->Insert(mode);
1015 } else if (iIso3==0) {
1016 // pi+ + a2(1320)-
1017 daughterPi = "pi+";
1018 daughterA2 = "a2(1320)-";
1019 r = br/2.;
1020 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
1021 daughterPi,daughterA2);
1022 decayTable->Insert(mode);
1023
1024 // pi- + a2(1320)+
1025 daughterPi = "pi-";
1026 daughterA2 = "a2(1320)+";
1027 r = br/2.;
1028 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
1029 daughterPi,daughterA2);
1030 decayTable->Insert(mode);
1031 } else if (iIso3==-2) {
1032 // pi- + a2(1320)0
1033 daughterPi = "pi-";
1034 daughterA2 = "a2(1320)0";
1035 r = br/2.;
1036 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
1037 daughterPi,daughterA2);
1038 decayTable->Insert(mode);
1039
1040 // pi0 + a2(1320)-
1041 daughterPi = "pi0";
1042 daughterA2 = "a2(1320)-";
1043 r = br/2.;
1044 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
1045 daughterPi,daughterA2);
1046 decayTable->Insert(mode);
1047 }
1048 }
1049 return decayTable;
1050}
1051
1052G4DecayTable* G4ExcitedMesonConstructor::Add3PiMode(
1053 G4DecayTable* decayTable, const G4String& nameParent,
1054 G4double br, G4int iIso3, G4int iIso)
1055{
1056 G4VDecayChannel* mode;
1057
1058 // I =0 state
1059 // This mode is X(I=0,J=1) --> pi+,pi-,pi0 mode
1060 if (iIso==0) {
1061 // pi+ + pi-
1062 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 3,
1063 "pi+","pi-","pi0");
1064 decayTable->Insert(mode);
1065 } else if (iIso==2) {
1066 // This mode is X(I=1) --> pi + pipi(I=0) mode
1067 if (iIso3==+2) {
1068 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1069 "pi+","pi0","pi0");
1070 decayTable->Insert(mode);
1071 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
1072 "pi+","pi+","pi-");
1073 decayTable->Insert(mode);
1074 } else if (iIso3==0) {
1075 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1076 "pi0","pi0","pi0");
1077 decayTable->Insert(mode);
1078 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
1079 "pi0","pi+","pi-");
1080 decayTable->Insert(mode);
1081 } else if (iIso3==-2) {
1082 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1083 "pi-","pi0","pi0");
1084 decayTable->Insert(mode);
1085 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
1086 "pi-","pi+","pi-");
1087 decayTable->Insert(mode);
1088 }
1089 }
1090 return decayTable;
1091}
1092
1093G4DecayTable* G4ExcitedMesonConstructor::Add4PiMode(
1094 G4DecayTable* decayTable, const G4String& nameParent,
1095 G4double br, G4int iIso3, G4int )
1096{
1097 G4VDecayChannel* mode;
1098
1099 if (iIso3==0) {
1100 // 2pi+ + 2pi-
1101 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 4,
1102 "pi+","pi-","pi+","pi-");
1103 decayTable->Insert(mode);
1104 // pi+ + pi- + 2pi0
1105 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 4,
1106 "pi+","pi-","pi0","pi0");
1107 decayTable->Insert(mode);
1108 } else if (iIso3==+2) {
1109 // pi+ + 3pi0
1110 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 4,
1111 "pi+","pi0","pi0","pi0");
1112 decayTable->Insert(mode);
1113 // 2pi+ + pi- + pi0
1114 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 4,
1115 "pi+","pi+","pi-","pi0");
1116 decayTable->Insert(mode);
1117 } else if (iIso3==-2) {
1118 // pi- + 3pi0
1119 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 4,
1120 "pi-","pi0","pi0","pi0");
1121 decayTable->Insert(mode);
1122 // 2pi- + pi+ + pi0
1123 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 4,
1124 "pi-","pi-","pi+","pi0");
1125 decayTable->Insert(mode);
1126 }
1127 return decayTable;
1128}
1129
1130G4DecayTable* G4ExcitedMesonConstructor::Add2PiEtaMode(
1131 G4DecayTable* decayTable, const G4String& nameParent,
1132 G4double br, G4int , G4int iIso)
1133{
1134 // f1-->eta + pi + pi mode
1135
1136 if (iIso!=0) return decayTable;
1137
1138 G4VDecayChannel* mode;
1139
1140 // eta pi+ pi-
1141 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
1142 "eta","pi+","pi-");
1143 decayTable->Insert(mode);
1144
1145 // eta pi+ pi-
1146 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1147 "eta","pi0","pi0");
1148 decayTable->Insert(mode);
1149 return decayTable;
1150}
1151
1152G4DecayTable* G4ExcitedMesonConstructor::Add2EtaMode(
1153 G4DecayTable* decayTable, const G4String& nameParent,
1154 G4double br, G4int , G4int iIso)
1155{
1156 if (iIso!=0) return decayTable;
1157
1158 G4VDecayChannel* mode;
1159
1160 // eta eta
1161 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
1162 "eta","eta");
1163 decayTable->Insert(mode);
1164 return decayTable;
1165}
1166
1167G4DecayTable* G4ExcitedMesonConstructor::Add2PiOmegaMode(
1168 G4DecayTable* decayTable, const G4String& nameParent,
1169 G4double br, G4int iIso3, G4int iIso)
1170{
1171
1172 G4VDecayChannel* mode;
1173 if (iIso==0) {
1174 // omega pi+ pi-
1175 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
1176 "omega","pi+","pi-");
1177 decayTable->Insert(mode);
1178
1179 // omega pi+ pi-
1180 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1181 "omega","pi0","pi0");
1182 decayTable->Insert(mode);
1183 } else if (iIso==2) {
1184 if (iIso3==+2) {
1185 // omega pi+ pi0
1186 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 3,
1187 "omega","pi+","pi0");
1188 decayTable->Insert(mode);
1189 } else if (iIso3==0) {
1190 // omega pi+ pi-
1191 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 3,
1192 "omega","pi-","pi+");
1193 decayTable->Insert(mode);
1194 // omega pi0 pi0
1195 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 3,
1196 "omega","pi0","pi0");
1197 decayTable->Insert(mode);
1198 } else if (iIso3==-2) {
1199 // omega pi- pi0
1200 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 3,
1201 "omega","pi-","pi0");
1202 decayTable->Insert(mode);
1203 }
1204 }
1205 return decayTable;
1206}
1207
1208
1209
1210G4DecayTable* G4ExcitedMesonConstructor::Add2PiRhoMode(
1211 G4DecayTable* decayTable, const G4String& nameParent,
1212 G4double br, G4int iIso3, G4int iIso)
1213{
1214 G4VDecayChannel* mode;
1215
1216 if (iIso==0) {
1217 // f1 --> rho0 + pi+ pi-
1218 // rho0 pi+ pi-
1219 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1220 "rho0","pi+","pi-");
1221 decayTable->Insert(mode);
1222 } else if (iIso==2) {
1223 if (iIso3==+2) {
1224 // rho+ pi0 pi0
1225 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1226 "rho+","pi0","pi0");
1227 decayTable->Insert(mode);
1228 // rho+ pi+ pi-
1229 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1230 "rho+","pi+","pi-");
1231 decayTable->Insert(mode);
1232 // rho0 pi+ pi0
1233 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1234 "rho0","pi+","pi0");
1235 decayTable->Insert(mode);
1236 // rho- pi+ pi+
1237 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1238 "rho-","pi+","pi+");
1239 decayTable->Insert(mode);
1240 } else if (iIso3==-2) {
1241 // rho- pi0 pi0
1242 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1243 "rho-","pi0","pi0");
1244 decayTable->Insert(mode);
1245 // rho- pi+ pi-
1246 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1247 "rho-","pi+","pi-");
1248 decayTable->Insert(mode);
1249 // rho0 pi- pi0
1250 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1251 "rho0","pi-","pi0");
1252 decayTable->Insert(mode);
1253 // rho+ pi- pi-
1254 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1255 "rho+","pi-","pi-");
1256 decayTable->Insert(mode);
1257 } else if (iIso3==0) {
1258 // rho+ pi- pi0
1259 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1260 "rho+","pi-","pi0");
1261 decayTable->Insert(mode);
1262 // rho0 pi+ pi-
1263 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1264 "rho0","pi+","pi-");
1265 decayTable->Insert(mode);
1266 // rho0 pi0 pi0
1267 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1268 "rho0","pi0","pi0");
1269 decayTable->Insert(mode);
1270 // rho- pi+ pi0
1271 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1272 "rho-","pi+","pi-");
1273 decayTable->Insert(mode);
1274 }
1275 }
1276 return decayTable;
1277}
1278
1279
1280G4DecayTable* G4ExcitedMesonConstructor::AddKKStarMode(
1281 G4DecayTable* decayTable, const G4String& nameParent,
1282 G4double br, G4int , G4int iIso)
1283{
1284 // X(I=0,J=1)-->K + Anti-K*, Anti_K + K* mode
1285
1286 if (iIso!=0) return decayTable;
1287
1288 G4VDecayChannel* mode;
1289
1290 // K+ + K*-
1291 mode = new G4PhaseSpaceDecayChannel(nameParent, br/4., 2,
1292 "kaon+","k_star-");
1293 decayTable->Insert(mode);
1294
1295 // K- + K*+
1296 mode = new G4PhaseSpaceDecayChannel(nameParent, br/4., 2,
1297 "kaon-","k_star0");
1298 decayTable->Insert(mode);
1299
1300 // K0 + Anti_K*0
1301 mode = new G4PhaseSpaceDecayChannel(nameParent, br/4., 2,
1302 "kaon0","anti_k_star0");
1303 decayTable->Insert(mode);
1304
1305 // Anti_K0 + K*0
1306 mode = new G4PhaseSpaceDecayChannel(nameParent, br/4., 2,
1307 "anti_kaon0","k_star0");
1308 decayTable->Insert(mode);
1309
1310
1311 return decayTable;
1312}
1313
1314G4DecayTable* G4ExcitedMesonConstructor::Add2KMode(
1315 G4DecayTable* decayTable, const G4String& nameParent,
1316 G4double br, G4int iIso3, G4int )
1317{
1318 G4VDecayChannel* mode;
1319
1320 if (iIso3==0) {
1321 // K+ + K-
1322 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 2,
1323 "kaon+","kaon-");
1324 decayTable->Insert(mode);
1325
1326 // K0 + Anti_K0
1327 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 2,
1328 "kaon0","anti_kaon0");
1329 decayTable->Insert(mode);
1330 } else if (iIso3==+2) {
1331 // K+ + anti_K0
1332 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
1333 "kaon+","anti_kaon0");
1334 decayTable->Insert(mode);
1335 } else if (iIso3==-2) {
1336 // K- + K0
1337 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
1338 "kaon-","kaon0");
1339 decayTable->Insert(mode);
1340 }
1341
1342 return decayTable;
1343}
1344
1345G4DecayTable* G4ExcitedMesonConstructor::Add2KPiMode(
1346 G4DecayTable* decayTable, const G4String& nameParent,
1347 G4double br, G4int , G4int iIso)
1348{
1349
1350 // X(I=0)-->KKpi
1351 if (iIso!=0) return decayTable;
1352
1353 G4VDecayChannel* mode;
1354
1355 // K+ + K- + pi0
1356 mode = new G4PhaseSpaceDecayChannel(nameParent, br/6., 3,
1357 "kaon+","kaon-","pi0");
1358 decayTable->Insert(mode);
1359
1360 // K0 + Anti_K0 + pi0
1361 mode = new G4PhaseSpaceDecayChannel(nameParent, br/6., 3,
1362 "kaon0","anti_kaon0","pi0");
1363 decayTable->Insert(mode);
1364
1365 // K+ + anti_K0 + pi-
1366 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1367 "kaon+","anti_kaon0","pi-");
1368 decayTable->Insert(mode);
1369
1370 // K- + K0 + pi+
1371 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1372 "kaon-","kaon0","pi+");
1373 decayTable->Insert(mode);
1374
1375
1376 return decayTable;
1377}
1378
1379// PDG2005
1380// eta(1440) is renamed to eta(1475)
1381// omega(1600) is renamed to omega(1650)
1382//
1383//
1384
1385
1386const char* G4ExcitedMesonConstructor::name[G4ExcitedMesonConstructor::NMultiplets ][ G4ExcitedMesonConstructor::NMesonTypes ] =
1387{
1388 { "b1(1235)", "h1(1170)", "h1(1380)", "k1(1270)", "k1(1270)" },
1389 { "a0(1450)", "f0(1370)", "", "k0_star(1430)", "k0_star(1430)" },
1390 { "a1(1260)", "f1(1285)", "f1(1420)", "k1(1400)", "k1(1400)" },
1391 { "a2(1320)", "f2(1270)","f2_prime(1525)","k2_star(1430)","k2_star(1430)"},
1392 {"pi2(1670)", "eta2(1645)", "eta2(1870)", "k2(1770)", "k2(1770)" },
1393 {"rho(1700)", "omega(1650)", "", "k_star(1680)", "k_star(1680)" },
1394 {"rho3(1690)","omega3(1670)","phi3(1850)", "k3_star(1780)", "k3_star(1780)" },
1395 { "pi(1300)", "eta(1295)", "eta(1475)", "k(1460)", "k(1460)" },
1396 {"rho(1450)","omega(1420)", "phi(1680)", "k_star(1410)", "k_star(1410)" },
1397 { "", "f2(1810)", "f2(2010)", "k2_star(1980)", "k2_star(1980)" }
1398};
1399
1400const G4double G4ExcitedMesonConstructor::mass[G4ExcitedMesonConstructor::NMultiplets ][ G4ExcitedMesonConstructor::NMesonTypes ] =
1401{
1402 { 1.2295*GeV, 1.170*GeV, 1.386*GeV, 1.272*GeV, 1.272*GeV },
1403 { 1.474*GeV, 1.350*GeV, 0.0, 1.430*GeV, 1.430*GeV },
1404 { 1.230*GeV,1.2818*GeV,1.4264*GeV, 1.403*GeV, 1.403*GeV },
1405 { 1.3183*GeV,1.2751*GeV, 1.525*GeV,1.4256*GeV, 1.4256*GeV },
1406 { 1.6722*GeV, 1.617*GeV, 1.842*GeV, 1.773*GeV, 1.773*GeV },
1407 { 1.720*GeV, 1.670*GeV, 0.0, 1.717*GeV, 1.717*GeV },
1408 { 1.6888*GeV, 1.667*GeV, 1.854*GeV, 1.776*GeV, 1.776*GeV },
1409 { 1.300*GeV, 1.294*GeV, 1.476*GeV, 1.460*GeV, 1.460*GeV },
1410 { 1.465*GeV, 1.425*GeV, 1.680*GeV, 1.414*GeV, 1.414*GeV },
1411 { 0.0, 1.815*GeV, 2.010*GeV, 1.973*GeV, 1.973*GeV }
1412};
1413
1414const G4double G4ExcitedMesonConstructor::massKdiff[ G4ExcitedMesonConstructor::NMultiplets ] = {
1415 0.0*MeV, 0.0*MeV, 0.0*MeV, 6.8*MeV, 0.0*MeV,
1416 0.0*MeV, 0.0*MeV, 0.0*MeV, 0.0*MeV, 0.0*MeV
1417};
1418
1419const G4double G4ExcitedMesonConstructor::widthKdiff[ G4ExcitedMesonConstructor::NMultiplets ] = {
1420 0.0*MeV, 0.0*MeV, 0.0*MeV, 10.5*MeV, 0.0*MeV,
1421 0.0*MeV, 0.0*MeV, 0.0*MeV, 0.0*MeV, 0.0*MeV
1422};
1423
1424const G4double G4ExcitedMesonConstructor::width[G4ExcitedMesonConstructor::NMultiplets ][ G4ExcitedMesonConstructor::NMesonTypes ] =
1425{
1426 { 142.0*MeV, 360.0*MeV, 91.0*MeV, 90.0*MeV, 90.0*MeV },
1427 { 265.0*MeV, 350.0*MeV, 0.0, 270.0*MeV, 270.0*MeV },
1428 { 420.0*MeV, 24.3*MeV, 54.9*MeV, 174.0*MeV, 174.0*MeV },
1429 { 107.0*MeV, 185.1*MeV, 73.0*MeV, 98.5*MeV, 98.5*MeV },
1430 { 260.0*MeV, 181.0*MeV, 225.0*MeV, 186.0*MeV, 186.0*MeV },
1431 { 250.0*MeV, 315.0*MeV, 0.0, 320.0*MeV, 320.0*MeV },
1432 { 161.0*MeV, 168.0*MeV, 87.0*MeV, 159.0*MeV, 159.0*MeV },
1433 { 400.0*MeV, 55.0*MeV, 85.0*MeV, 260.0*MeV, 260.0*MeV },
1434 { 400.0*MeV, 215.0*MeV, 150.0*MeV, 232.0*MeV, 232.0*MeV },
1435 { 0.0, 197.0*MeV, 200.0*MeV, 373.0*MeV, 373.0*MeV }
1436};
1437
1438
1439const G4int G4ExcitedMesonConstructor::iIsoSpin[] =
1440{
1441// Tpi TEta TEtaPrime TK TAntiK
1442 2, 0, 0, 1, 1
1443};
1444
1445const G4int G4ExcitedMesonConstructor::iSpin[] =
1446{
1447//N 1 1 1 1 1 1 1 2 2 2
1448// 1P1 3P0 3P1 3P2 1D2 3D1 3D3 1S0 3S1 3P2
1449 2, 0, 2, 4, 4, 2, 6, 0, 2, 4
1450};
1451
1452const G4int G4ExcitedMesonConstructor::iParity[] =
1453{
1454//N 1 1 1 1 1 1 1 2 2 2
1455// 1P1 3P0 3P1 3P2 1D2 3D1 3D3 1S0 3S1 3P2
1456 +1, +1, +1, +1, -1, -1, -1, -1, -1, +1
1457};
1458
1459const G4int G4ExcitedMesonConstructor::iChargeConjugation[] =
1460{
1461//N 1 1 1 1 1 1 1 2 2 2
1462// 1P1 3P0 3P1 3P2 1D2 3D1 3D3 1S0 3S1 3P2
1463 -1, +1, +1, +1, +1, -1, -1, +1, -1, +1
1464};
1465
1466const G4int G4ExcitedMesonConstructor::iGParity[G4ExcitedMesonConstructor::NMultiplets ][ G4ExcitedMesonConstructor::NMesonTypes ]=
1467{
1468 { +1, -1, -1, 0, 0},
1469 { -1, +1, 0, 0, 0},
1470 { -1, +1, +1, 0, 0},
1471 { -1, +1, +1, 0, 0},
1472 { -1, +1, +1, 0, 0},
1473 { +1, -1, 0, 0, 0},
1474 { +1, -1, -1, 0, 0},
1475 { -1, +1, +1, 0, 0},
1476 { +1, -1, -1, 0, 0},
1477 { 0, +1, +1, 0, 0}
1478};
1479
1480
1481const G4int G4ExcitedMesonConstructor::encodingOffset[]=
1482{ 10000, 10000, 20000, 0, 10000, 30000, 0, 100000,100000,100000};
1483
1484
1485
1486
1487const G4double G4ExcitedMesonConstructor::bRatio[G4ExcitedMesonConstructor::NMultiplets][G4ExcitedMesonConstructor::NMesonTypes][G4ExcitedMesonConstructor::NumberOfDecayModes]=
1488{
1489 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1490 {
1491 { 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 1.00, 0.00, 0.00, 0.00 },
1492 { 0.00, 0.00, 0.00, 0.90, 0.10, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1493 { 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 1.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1494 { 0.00, 0.47, 0.42, 0.11, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1495 { 0.00, 0.47, 0.42, 0.11, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 }
1496 },
1497 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1498 {
1499 { 0.00, 0.00, 0.00, 0.00, 0.00, 0.90, 0.00, 0.00, 0.00, 0.10, 0.00, 0.00, 0.00, 0.10, 0.00, 0.00, 0.00, 0.00, 0.00 },
1500 { 0.00, 0.00, 0.10, 0.00, 0.00, 0.00, 0.70, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.20, 0.00, 0.00, 0.00, 0.00, 0.00 },
1501 { 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1502 { 1.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1503 { 1.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 }
1504 },
1505 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1506 {
1507 { 0.10, 0.00, 0.00, 0.90, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1508 { 0.00, 0.07, 0.00, 0.00, 0.00, 0.00, 0.20, 0.00, 0.54, 0.00, 0.10, 0.00, 0.00, 0.00, 0.09, 0.00, 0.00, 0.00, 0.00 },
1509 { 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.50, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.50, 0.00, 0.00, 0.00, 0.00 },
1510 { 0.00, 0.96, 0.03, 0.01, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1511 { 0.00, 0.96, 0.03, 0.01, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 }
1512 },
1513 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1514 {
1515 { 0.00, 0.00, 0.00, 0.70, 0.00, 0.14, 0.00, 0.00, 0.00, 0.00, 0.00, 0.11, 0.00, 0.05, 0.00, 0.00, 0.00, 0.00, 0.00 },
1516 { 0.00, 0.00, 0.50, 0.00, 0.00, 0.00, 0.30, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.20, 0.00, 0.00, 0.00, 0.00, 0.00 },
1517 { 0.00, 0.00, 0.01, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.10, 0.89, 0.00, 0.00, 0.00, 0.00, 0.00 },
1518 { 0.50, 0.25, 0.09, 0.03, 0.13, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1519 { 0.50, 0.25, 0.09, 0.03, 0.13, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 }
1520 },
1521 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1522 {
1523 { 0.00, 0.00, 0.00, 0.30, 0.00, 0.00, 0.00, 0.04, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.56, 0.10, 0.00 },
1524 { 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.10, 0.00, 0.00, 0.00, 0.90 },
1525 { 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.50, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.50 },
1526 { 0.00, 0.00, 0.00, 0.00, 0.00, 1.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1527 { 0.00, 0.00, 0.00, 0.00, 0.00, 1.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 }
1528 },
1529 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1530 {
1531 { 0.00, 0.00, 0.10, 0.00, 0.00, 0.20, 0.00, 0.00, 0.00, 0.00, 0.70, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1532 { 0.00, 0.00, 0.00, 0.50, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.50, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1533 { 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1534 { 0.00, 0.40, 0.30, 0.30, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1535 { 0.00, 0.40, 0.30, 0.30, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 }
1536 },
1537 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1538 {
1539 { 0.00, 0.00, 0.24, 0.00, 0.00, 0.00, 0.60, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.01, 0.04, 0.11, 0.00, 0.00, 0.00 },
1540 { 0.00, 0.00, 0.00, 0.50, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.50, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1541 { 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.40, 0.00, 0.00, 0.00, 0.00, 0.00, 0.60, 0.00, 0.00, 0.00, 0.00, 0.00 },
1542 { 0.19, 0.20, 0.31, 0.00, 0.00, 0.00, 0.30, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1543 { 0.19, 0.20, 0.31, 0.00, 0.00, 0.00, 0.30, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 }
1544 },
1545 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1546 {
1547 { 0.00, 0.00, 0.00, 0.50, 0.50, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1548 { 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 1.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1549 { 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.20, 0.20, 0.00, 0.00, 0.00, 0.00, 0.00, 0.60, 0.00, 0.00, 0.00, 0.00 },
1550 { 0.00, 0.50, 0.50, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1551 { 0.00, 0.50, 0.50, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 }
1552 },
1553 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1554 {
1555 { 0.00, 0.00, 0.50, 0.00, 0.00, 0.00, 0.50, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1556 { 0.00, 0.00, 0.00, 1.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1557 { 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.80, 0.00, 0.00, 0.00, 0.00, 0.00, 0.10, 0.10, 0.00, 0.00, 0.00, 0.00 },
1558 { 0.30, 0.65, 0.05, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1559 { 0.30, 0.65, 0.05, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 }
1560 },
1561 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1562 {
1563 { 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1564 { 0.00, 0.00, 0.50, 0.00, 0.00, 0.00, 0.00, 0.00, 0.30, 0.00, 0.00, 0.00, 0.00, 0.20, 0.00, 0.00, 0.00, 0.00, 0.00 },
1565 { 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 1.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1566 { 0.00, 0.00, 0.60, 0.40, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 },
1567 { 0.00, 0.00, 0.60, 0.40, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 }
1568 }
1569};
1570
1571
1572
1573
1574
1575
G4double
double G4double
Definition: G4Types.hh:64
G4int
int G4int
Definition: G4Types.hh:66
G4bool
bool G4bool
Definition: G4Types.hh:67
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cerr
G4DLLIMPORT std::ostream G4cerr
G4DecayTable::Insert
void Insert(G4VDecayChannel *aChannel)
Definition: G4DecayTable.cc:60
G4ExcitedMesonConstructor::Add3PiMode
G4DecayTable * Add3PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1052
G4ExcitedMesonConstructor::AddKRhoMode
G4DecayTable * AddKRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:488
G4ExcitedMesonConstructor::iChargeConjugation
static const G4int iChargeConjugation[NMultiplets]
Definition: G4ExcitedMesonConstructor.hh:99
G4ExcitedMesonConstructor::mass
static const G4double mass[NMultiplets][NMesonTypes]
Definition: G4ExcitedMesonConstructor.hh:91
G4ExcitedMesonConstructor::AddPiF0Mode
G4DecayTable * AddPiF0Mode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:783
G4ExcitedMesonConstructor::G4ExcitedMesonConstructor
G4ExcitedMesonConstructor(G4int nStates=0, G4int isoSpin=0)
Definition: G4ExcitedMesonConstructor.cc:48
G4ExcitedMesonConstructor::AddPiA2Mode
G4DecayTable * AddPiA2Mode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:961
G4ExcitedMesonConstructor::AddKStarPiMode
G4DecayTable * AddKStarPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:532
G4ExcitedMesonConstructor::width
static const G4double width[NMultiplets][NMesonTypes]
Definition: G4ExcitedMesonConstructor.hh:93
G4ExcitedMesonConstructor::iSpin
static const G4int iSpin[NMultiplets]
Definition: G4ExcitedMesonConstructor.hh:96
G4ExcitedMesonConstructor::massKdiff
static const G4double massKdiff[NMultiplets]
Definition: G4ExcitedMesonConstructor.hh:92
G4ExcitedMesonConstructor::AddKOmegaMode
G4DecayTable * AddKOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:426
G4ExcitedMesonConstructor::GetEncoding
G4int GetEncoding(G4int iIsoSpin3, G4int idxState, G4int idxType)
Definition: G4ExcitedMesonConstructor.cc:200
G4ExcitedMesonConstructor::GetName
G4String GetName(G4int iIso3, G4int iState, G4int idxType)
Definition: G4ExcitedMesonConstructor.hh:178
G4ExcitedMesonConstructor::Add2KPiMode
G4DecayTable * Add2KPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1345
G4ExcitedMesonConstructor::Add2PiMode
G4DecayTable * Add2PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:810
G4ExcitedMesonConstructor::AddKTwoPiMode
G4DecayTable * AddKTwoPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:382
G4ExcitedMesonConstructor::CreateDecayTable
G4DecayTable * CreateDecayTable(const G4String &, G4int, G4int, G4int)
Definition: G4ExcitedMesonConstructor.cc:245
G4ExcitedMesonConstructor::GetQuarkContents
G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:143
G4ExcitedMesonConstructor::encodingOffset
static const G4int encodingOffset[NMultiplets]
Definition: G4ExcitedMesonConstructor.hh:100
G4ExcitedMesonConstructor::AddPiOmegaMode
G4DecayTable * AddPiOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:648
G4ExcitedMesonConstructor::AddPiF2Mode
G4DecayTable * AddPiF2Mode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:756
G4ExcitedMesonConstructor::widthKdiff
static const G4double widthKdiff[NMultiplets]
Definition: G4ExcitedMesonConstructor.hh:94
G4ExcitedMesonConstructor::ConstructMesons
void ConstructMesons(G4int indexOfState, G4int indexOfType)
Definition: G4ExcitedMesonConstructor.cc:93
G4ExcitedMesonConstructor::AddKPiMode
G4DecayTable * AddKPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:339
G4ExcitedMesonConstructor::GetCharge
G4double GetCharge(G4int iIsoSpin3)
G4ExcitedMesonConstructor::AddPiEtaMode
G4DecayTable * AddPiEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:702
G4ExcitedMesonConstructor::AddKStar2PiMode
G4DecayTable * AddKStar2PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:576
G4ExcitedMesonConstructor::AddKEtaMode
G4DecayTable * AddKEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:457
G4ExcitedMesonConstructor::AddRhoEtaMode
G4DecayTable * AddRhoEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:729
G4ExcitedMesonConstructor::Add2PiOmegaMode
G4DecayTable * Add2PiOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1167
G4ExcitedMesonConstructor::Add2PiEtaMode
G4DecayTable * Add2PiEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1130
G4ExcitedMesonConstructor::Add2PiRhoMode
G4DecayTable * Add2PiRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1210
G4ExcitedMesonConstructor::AddRhoGammaMode
G4DecayTable * AddRhoGammaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:675
G4ExcitedMesonConstructor::Add4PiMode
G4DecayTable * Add4PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1093
G4ExcitedMesonConstructor::iIsoSpin
static const G4int iIsoSpin[NMesonTypes]
Definition: G4ExcitedMesonConstructor.hh:95
G4ExcitedMesonConstructor::name
static const char * name[NMultiplets][NMesonTypes]
Definition: G4ExcitedMesonConstructor.hh:90
G4ExcitedMesonConstructor::Construct
virtual void Construct(G4int indexOfState=-1)
Definition: G4ExcitedMesonConstructor.cc:58
G4ExcitedMesonConstructor::iParity
static const G4int iParity[NMultiplets]
Definition: G4ExcitedMesonConstructor.hh:97
G4ExcitedMesonConstructor::Add2EtaMode
G4DecayTable * Add2EtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1152
G4ExcitedMesonConstructor::iGParity
static const G4int iGParity[NMultiplets][NMesonTypes]
Definition: G4ExcitedMesonConstructor.hh:98
G4ExcitedMesonConstructor::bRatio
static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes]
Definition: G4ExcitedMesonConstructor.hh:114
G4ExcitedMesonConstructor::AddPiGammaMode
G4DecayTable * AddPiGammaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:621
G4ExcitedMesonConstructor::Add2KMode
G4DecayTable * Add2KMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1314
G4ExcitedMesonConstructor::Exist
G4bool Exist(G4int idxState, G4int idxType)
Definition: G4ExcitedMesonConstructor.cc:79
G4ExcitedMesonConstructor::AddKKStarMode
G4DecayTable * AddKKStarMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1280
G4ExcitedMesonConstructor::AddPiRhoMode
G4DecayTable * AddPiRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:870
G4ExcitedMesons::SetMultipletName
void SetMultipletName(const G4String &)
Definition: G4ExcitedMesons.hh:68
G4ParticleDefinition::SetAntiPDGEncoding
void SetAntiPDGEncoding(G4int aEncoding)
G4ParticleDefinition::SetDecayTable
void SetDecayTable(G4DecayTable *aDecayTable)
G4ParticleTable::GetParticleTable
static G4ParticleTable * GetParticleTable()
Definition: G4ParticleTable.cc:63
encoding
#define encoding
Definition: xmlparse.cc:588