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