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