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