source: trunk/source/particles/shortlived/src/G4ExcitedMesonConstructor.cc @ 1340

Last change on this file since 1340 was 1340, checked in by garnier, 14 years ago

update ti head
File size: 53.1 KB
Line 
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,v 1.23 2010/10/01 02:41:44 kurasige Exp $
28// GEANT4 tag $Name: particles-V09-03-15 $
29//
30//
31// --------------------------------------------------------------
32//      GEANT 4 class implementation file
33//      History: first implementation, based on object model of
34//      10 oct 1998  H.Kurashige
35// ---------------------------------------------------------------
36//    01 Oct. 02 Fixed PDG codes for a0(1450), f0(1370), k0_star(1430)
37
38#include "G4ExcitedMesonConstructor.hh"
39
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
48G4ExcitedMesonConstructor::G4ExcitedMesonConstructor(G4int ,
49                                                       G4int )
50    :   type("meson"), leptonNumber(0), baryonNumber(0)
51{
52}
53
54G4ExcitedMesonConstructor::~G4ExcitedMesonConstructor()
55{
56}
57
58void 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
79G4bool 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
93void 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
143G4int  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
188G4double  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
200G4int     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
245G4DecayTable*  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
339G4DecayTable*  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}
382G4DecayTable*  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
426G4DecayTable*  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
457G4DecayTable*  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
488G4DecayTable*  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
532G4DecayTable*  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
576G4DecayTable*  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
621G4DecayTable*  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
648G4DecayTable*  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
675G4DecayTable*  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
702G4DecayTable*  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
729G4DecayTable*  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
756G4DecayTable*  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
783G4DecayTable*  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
810G4DecayTable*  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
870G4DecayTable*  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
961G4DecayTable*  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
1052G4DecayTable*  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
1093G4DecayTable*  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
1130G4DecayTable*  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
1152G4DecayTable*  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
1167G4DecayTable*  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
1210G4DecayTable*  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
1280G4DecayTable*  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
1314G4DecayTable*  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
1345G4DecayTable*  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
1386const 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
1400const 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.6724*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
1414const 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
1419const 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
1424const 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  {  259.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
1439const G4int    G4ExcitedMesonConstructor::iIsoSpin[] =
1440{
1441//  Tpi  TEta  TEtaPrime   TK  TAntiK
1442     2,     0,         0,   1,     1
1443};
1444
1445const 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
1452const 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
1459const 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
1466const 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
1481const G4int    G4ExcitedMesonConstructor::encodingOffset[]=
1482{ 10000, 10000, 20000,      0, 10000, 30000,     0, 100000,100000,100000};
1483
1484
1485
1486
1487const 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
Note: See TracBrowser for help on using the repository browser.