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