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