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