G4ExcitedMesonConstructor Class Reference

#include <G4ExcitedMesonConstructor.hh>


Public Types

 NMultiplets = 10
 NMesonTypes = 5
 NumberOfDecayModes = 19
enum  { NMultiplets = 10 }
enum  { NMesonTypes = 5 }
enum  { NumberOfDecayModes = 19 }

Public Member Functions

 G4ExcitedMesonConstructor (G4int nStates=0, G4int isoSpin=0)
virtual ~G4ExcitedMesonConstructor ()
virtual void Construct (G4int indexOfState=-1)

Protected Types

 N11P1 = 0
 N13P0 = 1
 N13P1 = 2
 N13P2 = 3
 N11D2 = 4
 N13D1 = 5
 N13D3 = 6
 N21S0 = 7
 N23S1 = 8
 N23P2 = 9
 TPi = 0
 TEta = 1
 TEtaPrime = 2
 TK = 3
 TAntiK = 4
 MPiGamma = 0
 MRhoGamma = 1
 M2Pi = 2
 MPiRho = 3
 M3Pi = 4
 MPiEta = 5
 M4Pi = 6
 MKKStar = 7
 M2PiEta = 8
 MRhoEta = 9
 M2PiRho = 10
 M2PiOmega = 11
 M2Eta = 12
 M2K = 13
 M2KPi = 14
 MPiOmega = 15
 MPiF2 = 16
 MPiF0 = 17
 MPiA2 = 18
 MKPi = 0
 MKStarPi = 1
 MKRho = 2
 MKOmega = 3
 MKStar2Pi = 4
 MKTwoPi = 5
 MKEta = 6
enum  {
  N11P1 = 0, N13P0 = 1, N13P1 = 2, N13P2 = 3,
  N11D2 = 4, N13D1 = 5, N13D3 = 6, N21S0 = 7,
  N23S1 = 8, N23P2 = 9
}
enum  {
  TPi = 0, TEta = 1, TEtaPrime = 2, TK = 3,
  TAntiK = 4
}
enum  {
  MPiGamma = 0, MRhoGamma = 1, M2Pi = 2, MPiRho = 3,
  M3Pi = 4, MPiEta = 5, M4Pi = 6, MKKStar = 7,
  M2PiEta = 8, MRhoEta = 9, M2PiRho = 10, M2PiOmega = 11,
  M2Eta = 12, M2K = 13, M2KPi = 14, MPiOmega = 15,
  MPiF2 = 16, MPiF0 = 17, MPiA2 = 18
}
enum  {
  MKPi = 0, MKStarPi = 1, MKRho = 2, MKOmega = 3,
  MKStar2Pi = 4, MKTwoPi = 5, MKEta = 6
}

Protected Member Functions

void ConstructMesons (G4int indexOfState, G4int indexOfType)
G4String GetName (G4int iIso3, G4int iState, G4int idxType)
G4double GetCharge (G4int iIsoSpin3)
G4int GetEncoding (G4int iIsoSpin3, G4int idxState, G4int idxType)
G4int GetQuarkContents (G4int iQ, G4int iIso3, G4int iType)
G4bool Exist (G4int idxState, G4int idxType)
G4double GetCharge (G4int iIsoSpin3, G4int idxType)
G4DecayTableCreateDecayTable (const G4String &, G4int, G4int, G4int)
G4DecayTableAddKPiMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
G4DecayTableAddKStarPiMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
G4DecayTableAddKStar2PiMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
G4DecayTableAddKRhoMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
G4DecayTableAddKTwoPiMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
G4DecayTableAddKOmegaMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
G4DecayTableAddKEtaMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
G4DecayTableAddPiGammaMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAddRhoGammaMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAdd2PiMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAddPiRhoMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAddPiEtaMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAddPiF2Mode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAddPiF0Mode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAddPiA2Mode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAdd3PiMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAdd4PiMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAddKKStarMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAdd2PiEtaMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAddRhoEtaMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAdd2PiRhoMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAdd2PiOmegaMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAddPiOmegaMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAdd2EtaMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAdd2KMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTableAdd2KPiMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)

Protected Attributes

const G4String type
const G4int leptonNumber
const G4int baryonNumber

Static Protected Attributes

static const char * name [NMultiplets][NMesonTypes]
static const G4double mass [NMultiplets][NMesonTypes]
static const G4double massKdiff [NMultiplets]
static const G4double width [NMultiplets][NMesonTypes]
static const G4double widthKdiff [NMultiplets]
static const G4int iIsoSpin [NMesonTypes]
static const G4int iSpin [NMultiplets]
static const G4int iParity [NMultiplets]
static const G4int iGParity [NMultiplets][NMesonTypes]
static const G4int iChargeConjugation [NMultiplets]
static const G4int encodingOffset [NMultiplets]
static const G4double bRatio [NMultiplets][NMesonTypes][NumberOfDecayModes]


Detailed Description

Definition at line 49 of file G4ExcitedMesonConstructor.hh.


Member Enumeration Documentation

anonymous enum

Enumerator:
NMultiplets 

Definition at line 70 of file G4ExcitedMesonConstructor.hh.

00070 { NMultiplets = 10 };

anonymous enum [protected]

Enumerator:
N11P1 
N13P0 
N13P1 
N13P2 
N11D2 
N13D1 
N13D3 
N21S0 
N23S1 
N23P2 

Definition at line 72 of file G4ExcitedMesonConstructor.hh.

00072          { 
00073       N11P1 = 0, N13P0 = 1, N13P1 = 2, N13P2 = 3,
00074       N11D2 = 4, N13D1 = 5, N13D3 = 6,
00075       N21S0 = 7, N23S1 = 8, N23P2 = 9
00076     };

anonymous enum

Enumerator:
NMesonTypes 

Definition at line 79 of file G4ExcitedMesonConstructor.hh.

00079 { NMesonTypes = 5 };

anonymous enum [protected]

Enumerator:
TPi 
TEta 
TEtaPrime 
TK 
TAntiK 

Definition at line 81 of file G4ExcitedMesonConstructor.hh.

00081 { TPi=0, TEta=1, TEtaPrime=2, TK=3, TAntiK=4 }; 

anonymous enum

Enumerator:
NumberOfDecayModes 

Definition at line 103 of file G4ExcitedMesonConstructor.hh.

00103 { NumberOfDecayModes = 19 };

anonymous enum [protected]

Enumerator:
MPiGamma 
MRhoGamma 
M2Pi 
MPiRho 
M3Pi 
MPiEta 
M4Pi 
MKKStar 
M2PiEta 
MRhoEta 
M2PiRho 
M2PiOmega 
M2Eta 
M2K 
M2KPi 
MPiOmega 
MPiF2 
MPiF0 
MPiA2 

Definition at line 105 of file G4ExcitedMesonConstructor.hh.

00105              { MPiGamma = 0, MRhoGamma=1, M2Pi=2,      MPiRho=3, 
00106                M3Pi= 4,      MPiEta=5,    M4Pi=6,      MKKStar=7,
00107                M2PiEta=8,    MRhoEta=9,   M2PiRho=10,  M2PiOmega=11,
00108                M2Eta=12,     M2K=13,      M2KPi=14,    MPiOmega=15,
00109                MPiF2=16,     MPiF0=17,    MPiA2=18 };

anonymous enum [protected]

Enumerator:
MKPi 
MKStarPi 
MKRho 
MKOmega 
MKStar2Pi 
MKTwoPi 
MKEta 

Definition at line 110 of file G4ExcitedMesonConstructor.hh.

00110              { MKPi = 0,     MKStarPi=1,  MKRho=2,     MKOmega=3,
00111                MKStar2Pi=4,  MKTwoPi=5,   MKEta=6}; 


Constructor & Destructor Documentation

G4ExcitedMesonConstructor::G4ExcitedMesonConstructor ( G4int  nStates = 0,
G4int  isoSpin = 0 
)

Definition at line 48 of file G4ExcitedMesonConstructor.cc.

00050     :   type("meson"), leptonNumber(0), baryonNumber(0)
00051 {
00052 }

G4ExcitedMesonConstructor::~G4ExcitedMesonConstructor (  )  [virtual]

Definition at line 54 of file G4ExcitedMesonConstructor.cc.

00055 {
00056 }


Member Function Documentation

G4DecayTable * G4ExcitedMesonConstructor::Add2EtaMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 1152 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

01155 {
01156   if (iIso!=0) return decayTable;
01157 
01158   G4VDecayChannel* mode;
01159 
01160   // eta eta
01161   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
01162                                           "eta","eta");
01163   decayTable->Insert(mode);
01164   return decayTable;
01165 }

G4DecayTable * G4ExcitedMesonConstructor::Add2KMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 1314 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

01317 {
01318   G4VDecayChannel* mode;
01319 
01320   if (iIso3==0) {
01321     // K+ + K-
01322     mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 2,
01323                                           "kaon+","kaon-");
01324     decayTable->Insert(mode);
01325    
01326     // K0 + Anti_K0
01327     mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 2,
01328                                         "kaon0","anti_kaon0");
01329     decayTable->Insert(mode);
01330   } else if  (iIso3==+2) {
01331     // K+ + anti_K0
01332     mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
01333                                           "kaon+","anti_kaon0");
01334     decayTable->Insert(mode);
01335   } else if  (iIso3==-2) {
01336     // K- + K0
01337     mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
01338                                           "kaon-","kaon0");
01339     decayTable->Insert(mode);
01340   }   
01341    
01342   return decayTable;
01343 }

G4DecayTable * G4ExcitedMesonConstructor::Add2KPiMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 1345 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

01348 {
01349 
01350   // X(I=0)-->KKpi 
01351   if (iIso!=0) return decayTable; 
01352 
01353   G4VDecayChannel* mode;
01354 
01355   // K+ + K- + pi0
01356   mode = new G4PhaseSpaceDecayChannel(nameParent, br/6., 3,
01357                                       "kaon+","kaon-","pi0");
01358   decayTable->Insert(mode);
01359   
01360   // K0 + Anti_K0 + pi0
01361   mode = new G4PhaseSpaceDecayChannel(nameParent, br/6., 3,
01362                                       "kaon0","anti_kaon0","pi0");
01363   decayTable->Insert(mode);
01364   
01365   // K+ + anti_K0 + pi-
01366   mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
01367                                           "kaon+","anti_kaon0","pi-");
01368   decayTable->Insert(mode);
01369   
01370   // K- + K0 + pi+
01371   mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
01372                                           "kaon-","kaon0","pi+");
01373   decayTable->Insert(mode);
01374  
01375    
01376   return decayTable;
01377 }

G4DecayTable * G4ExcitedMesonConstructor::Add2PiEtaMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 1130 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

01133 {
01134   // f1-->eta + pi + pi mode
01135 
01136   if (iIso!=0) return decayTable;
01137 
01138   G4VDecayChannel* mode;
01139 
01140   // eta pi+ pi-
01141   mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
01142                                           "eta","pi+","pi-");
01143   decayTable->Insert(mode);
01144 
01145   // eta pi+ pi-
01146   mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
01147                                           "eta","pi0","pi0");
01148   decayTable->Insert(mode);
01149   return decayTable;
01150 }

G4DecayTable * G4ExcitedMesonConstructor::Add2PiMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 810 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

00813 {
00814   G4VDecayChannel* mode;
00815 
00816   G4String daughterPi1;
00817   G4String daughterPi2;
00818   G4double r; 
00819 
00820   // I = 0 states
00821   if (iIso==0) {
00822     if (iIso3==0) {
00823      // pi+ + pi-
00824       daughterPi1 = "pi+";
00825       daughterPi2 = "pi-";
00826       r = br*2./3.;
00827       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
00828                                           daughterPi1,daughterPi2);
00829       decayTable->Insert(mode);
00830 
00831       // pi0 + pi0
00832       daughterPi1 = "pi0";
00833       daughterPi2 = "pi0";
00834       r = br*1./3.;
00835       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
00836                                           daughterPi1,daughterPi2);
00837       decayTable->Insert(mode);
00838     } 
00839   } else if (iIso==2) {
00840     if (iIso3==+2) {
00841       // pi+ + pi0
00842       daughterPi1 = "pi+";
00843       daughterPi2 = "pi0";
00844       r = br;
00845             mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
00846                                           daughterPi1,daughterPi2);
00847       // add decay table
00848       decayTable->Insert(mode);
00849     } else if (iIso3==0) {
00850        // pi+ + pi-
00851       daughterPi1 = "pi+";
00852       daughterPi2 = "pi-";
00853       r = br;
00854       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
00855                                           daughterPi1,daughterPi2);
00856       decayTable->Insert(mode);
00857      } else if (iIso3==-2) {
00858        // pi- + pi0
00859       daughterPi1 = "pi-";
00860       daughterPi2 = "pi0";
00861       r = br;
00862       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
00863                                           daughterPi1,daughterPi2);
00864       decayTable->Insert(mode);
00865     }
00866   }
00867   return decayTable;
00868 }

G4DecayTable * G4ExcitedMesonConstructor::Add2PiOmegaMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 1167 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

01170 {
01171 
01172   G4VDecayChannel* mode;
01173   if (iIso==0) {
01174     // omega pi+ pi-
01175     mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
01176                                           "omega","pi+","pi-");
01177     decayTable->Insert(mode);
01178 
01179     // omega pi+ pi-
01180     mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
01181                                           "omega","pi0","pi0");
01182     decayTable->Insert(mode);
01183   } else if (iIso==2) {
01184     if (iIso3==+2) {
01185       // omega pi+ pi0
01186       mode = new G4PhaseSpaceDecayChannel(nameParent, br, 3,
01187                                           "omega","pi+","pi0");
01188       decayTable->Insert(mode);
01189     } else if (iIso3==0) {
01190       // omega pi+ pi-
01191       mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 3,
01192                                           "omega","pi-","pi+");
01193       decayTable->Insert(mode);
01194       // omega pi0 pi0
01195       mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 3,
01196                                           "omega","pi0","pi0");
01197       decayTable->Insert(mode);
01198      } else if (iIso3==-2) {
01199       // omega pi- pi0
01200       mode = new G4PhaseSpaceDecayChannel(nameParent, br, 3,
01201                                           "omega","pi-","pi0");
01202       decayTable->Insert(mode);
01203      }
01204   }
01205   return decayTable;
01206 }

G4DecayTable * G4ExcitedMesonConstructor::Add2PiRhoMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 1210 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

01213 {
01214   G4VDecayChannel* mode;
01215 
01216   if (iIso==0) {
01217     // f1 --> rho0 + pi+ pi-
01218     // rho0 pi+ pi-
01219     mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
01220                                           "rho0","pi+","pi-");
01221     decayTable->Insert(mode);
01222   } else if (iIso==2) {
01223     if (iIso3==+2) {
01224       // rho+ pi0 pi0
01225       mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
01226                                           "rho+","pi0","pi0");
01227       decayTable->Insert(mode);
01228       // rho+ pi+ pi-
01229       mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
01230                                           "rho+","pi+","pi-");
01231       decayTable->Insert(mode);
01232       // rho0 pi+ pi0
01233       mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
01234                                           "rho0","pi+","pi0");
01235       decayTable->Insert(mode);
01236       // rho- pi+ pi+
01237       mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
01238                                           "rho-","pi+","pi+");
01239       decayTable->Insert(mode);
01240     } else if (iIso3==-2) {
01241       // rho- pi0 pi0
01242       mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
01243                                           "rho-","pi0","pi0");
01244       decayTable->Insert(mode);
01245       // rho- pi+ pi-
01246       mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
01247                                           "rho-","pi+","pi-");
01248       decayTable->Insert(mode);
01249       // rho0 pi- pi0
01250       mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
01251                                           "rho0","pi-","pi0");
01252       decayTable->Insert(mode);
01253       // rho+ pi- pi-
01254       mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
01255                                           "rho+","pi-","pi-");
01256       decayTable->Insert(mode);
01257     } else if (iIso3==0) {
01258       // rho+ pi- pi0
01259       mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
01260                                           "rho+","pi-","pi0");
01261       decayTable->Insert(mode);
01262       // rho0 pi+ pi-
01263       mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
01264                                           "rho0","pi+","pi-");
01265       decayTable->Insert(mode);
01266       // rho0 pi0 pi0
01267       mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
01268                                           "rho0","pi0","pi0");
01269       decayTable->Insert(mode);
01270       // rho- pi+ pi0
01271       mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
01272                                           "rho-","pi+","pi-");
01273       decayTable->Insert(mode);
01274     }
01275   }
01276   return decayTable;
01277 }

G4DecayTable * G4ExcitedMesonConstructor::Add3PiMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 1052 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

01055 {
01056   G4VDecayChannel* mode;
01057 
01058   // I =0 state
01059   // This mode is X(I=0,J=1) --> pi+,pi-,pi0 mode
01060   if (iIso==0) {
01061     // pi+ + pi-
01062     mode = new G4PhaseSpaceDecayChannel(nameParent, br, 3,
01063                                         "pi+","pi-","pi0");
01064     decayTable->Insert(mode);
01065   } else if (iIso==2) {
01066   // This mode is X(I=1) --> pi + pipi(I=0) mode
01067     if (iIso3==+2) {
01068       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
01069                                         "pi+","pi0","pi0");
01070       decayTable->Insert(mode);
01071       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
01072                                         "pi+","pi+","pi-");
01073       decayTable->Insert(mode);
01074     } else if (iIso3==0) {
01075       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
01076                                         "pi0","pi0","pi0");
01077       decayTable->Insert(mode);
01078       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
01079                                         "pi0","pi+","pi-");
01080       decayTable->Insert(mode);
01081     } else if (iIso3==-2) {
01082       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
01083                                         "pi-","pi0","pi0");
01084       decayTable->Insert(mode);
01085       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
01086                                         "pi-","pi+","pi-");
01087       decayTable->Insert(mode);
01088     }
01089   } 
01090   return decayTable;
01091 }

G4DecayTable * G4ExcitedMesonConstructor::Add4PiMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 1093 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

01096 {
01097   G4VDecayChannel* mode;
01098 
01099   if (iIso3==0) {
01100     // 2pi+ + 2pi-
01101     mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 4,
01102                                         "pi+","pi-","pi+","pi-");
01103     decayTable->Insert(mode);
01104     // pi+ + pi- + 2pi0 
01105     mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 4,
01106                                         "pi+","pi-","pi0","pi0");
01107     decayTable->Insert(mode);
01108   } else if (iIso3==+2) {
01109     // pi+ + 3pi0
01110     mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 4,
01111                                         "pi+","pi0","pi0","pi0");
01112     decayTable->Insert(mode);
01113     // 2pi+ + pi- + pi0
01114     mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 4,
01115                                         "pi+","pi+","pi-","pi0");
01116     decayTable->Insert(mode);
01117   } else if (iIso3==-2) {
01118     // pi- + 3pi0
01119     mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 4,
01120                                         "pi-","pi0","pi0","pi0");
01121     decayTable->Insert(mode);
01122     // 2pi- + pi+ + pi0
01123     mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 4,
01124                                         "pi-","pi-","pi+","pi0");
01125     decayTable->Insert(mode);
01126   }
01127   return decayTable;
01128 }

G4DecayTable * G4ExcitedMesonConstructor::AddKEtaMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iType 
) [protected]

Definition at line 457 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert(), TAntiK, and TK.

Referenced by CreateDecayTable().

00460 {
00461   G4VDecayChannel* mode;
00462   // 
00463   if (iIso3 == +1) {
00464     if (iType == TK) {    
00465       mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
00466                                            "kaon+","eta");
00467       decayTable->Insert(mode);
00468     }else if (iType==TAntiK) {
00469       mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
00470                                            "anti_kaon0","eta");
00471       decayTable->Insert(mode);
00472    }   
00473   } else if (iIso3 == -1) {
00474     if (iType == TK) {    
00475       mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
00476                                            "kaon0","eta");
00477       decayTable->Insert(mode);
00478     }else if (iType==TAntiK) {
00479       mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
00480                                            "kaon-","eta");
00481       decayTable->Insert(mode);
00482     }
00483   }
00484 
00485   return decayTable;
00486 }

G4DecayTable * G4ExcitedMesonConstructor::AddKKStarMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 1280 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

01283 {
01284   // X(I=0,J=1)-->K + Anti-K*, Anti_K + K* mode
01285 
01286   if (iIso!=0) return decayTable;
01287 
01288   G4VDecayChannel* mode;
01289 
01290   // K+ + K*-
01291   mode = new G4PhaseSpaceDecayChannel(nameParent, br/4., 2,
01292                                           "kaon+","k_star-");
01293   decayTable->Insert(mode);
01294 
01295   // K- + K*+
01296   mode = new G4PhaseSpaceDecayChannel(nameParent, br/4., 2,
01297                                           "kaon-","k_star0");
01298   decayTable->Insert(mode);
01299 
01300   // K0 + Anti_K*0
01301   mode = new G4PhaseSpaceDecayChannel(nameParent, br/4., 2,
01302                                           "kaon0","anti_k_star0");
01303   decayTable->Insert(mode);
01304 
01305   // Anti_K0 + K*0
01306   mode = new G4PhaseSpaceDecayChannel(nameParent, br/4., 2,
01307                                           "anti_kaon0","k_star0");
01308   decayTable->Insert(mode);
01309 
01310 
01311   return decayTable;
01312 }

G4DecayTable * G4ExcitedMesonConstructor::AddKOmegaMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iType 
) [protected]

Definition at line 426 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert(), TAntiK, and TK.

Referenced by CreateDecayTable().

00429 {
00430   G4VDecayChannel* mode;
00431   // 
00432   if (iIso3 == +1) {
00433     if (iType == TK) {    
00434       mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
00435                                            "kaon+","omega");
00436       decayTable->Insert(mode);
00437     }else if (iType==TAntiK) {
00438       mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
00439                                            "anti_kaon0","omega");
00440       decayTable->Insert(mode);
00441    } 
00442   } else if (iIso3 == -1) {
00443     if (iType == TK) {    
00444       mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
00445                                            "kaon0","omega");
00446       decayTable->Insert(mode);
00447     }else if (iType==TAntiK) {
00448       mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
00449                                            "kaon-","omega");
00450       decayTable->Insert(mode);
00451     }
00452   }
00453 
00454   return decayTable;
00455 }

G4DecayTable * G4ExcitedMesonConstructor::AddKPiMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iType 
) [protected]

Definition at line 339 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert(), TAntiK, and TK.

Referenced by CreateDecayTable().

00342 {
00343   G4VDecayChannel* mode;
00344   // 
00345   if (iIso3 == +1) {
00346     if (iType == TK) {    
00347       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
00348                                            "kaon+","pi0");
00349       decayTable->Insert(mode);
00350       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
00351                                            "kaon0","pi+");
00352       decayTable->Insert(mode);
00353     }else if (iType==TAntiK) {
00354       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
00355                                            "anti_kaon0","pi0");
00356       decayTable->Insert(mode);
00357       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
00358                                            "kaon-","pi+");
00359       decayTable->Insert(mode);
00360    }
00361   } else if (iIso3 == -1) {
00362     if (iType == TK) {    
00363       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
00364                                            "kaon0","pi0");
00365       decayTable->Insert(mode);
00366       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
00367                                            "kaon+","pi-");
00368       decayTable->Insert(mode);
00369  
00370     }else if (iType==TAntiK) {
00371       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
00372                                            "kaon-","pi0");
00373       decayTable->Insert(mode);
00374       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
00375                                            "anti_kaon0","pi-");
00376       decayTable->Insert(mode);
00377     }
00378   }
00379 
00380   return decayTable;
00381 }

G4DecayTable * G4ExcitedMesonConstructor::AddKRhoMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iType 
) [protected]

Definition at line 488 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert(), TAntiK, and TK.

Referenced by CreateDecayTable().

00491 {
00492   G4VDecayChannel* mode;
00493   // 
00494   if (iIso3 == +1) {
00495     if (iType == TK) {    
00496       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
00497                                            "kaon+","rho0");
00498       decayTable->Insert(mode);
00499       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
00500                                            "kaon0","rho+");
00501       decayTable->Insert(mode);
00502     }else if (iType==TAntiK) {
00503       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
00504                                            "anti_kaon0","rho0");
00505       decayTable->Insert(mode);
00506       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
00507                                            "kaon-","rho+");
00508       decayTable->Insert(mode);
00509    }
00510   } else if (iIso3 == -1) {
00511     if (iType == TK) {    
00512       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
00513                                            "kaon0","rho0");
00514       decayTable->Insert(mode);
00515       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
00516                                            "kaon+","rho-");
00517       decayTable->Insert(mode);
00518  
00519     }else if (iType==TAntiK) {
00520       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
00521                                            "kaon-","rho0");
00522       decayTable->Insert(mode);
00523       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
00524                                            "anti_kaon0","rho-");
00525       decayTable->Insert(mode);
00526     }
00527   }
00528 
00529   return decayTable;
00530 }

G4DecayTable * G4ExcitedMesonConstructor::AddKStar2PiMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iType 
) [protected]

Definition at line 576 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert(), TAntiK, and TK.

Referenced by CreateDecayTable().

00579 {
00580   // K* --> K pipi(I=1)
00581   G4VDecayChannel* mode;
00582   // 
00583   if (iIso3 == +1) {
00584     if (iType == TK) {    
00585       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
00586                                            "k_star+","pi+","pi-");
00587       decayTable->Insert(mode);
00588       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
00589                                            "k_star0","pi+","pi0");
00590       decayTable->Insert(mode);
00591     }else if (iType==TAntiK) {
00592       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
00593                                            "anti_k_star0","pi+","pi-");
00594       decayTable->Insert(mode);
00595       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
00596                                            "k_star-","pi+","pi0");
00597       decayTable->Insert(mode);
00598    }
00599   } else if (iIso3 == -1) {
00600     if (iType == TK) {    
00601       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
00602                                            "k_star0","pi+","pi-");
00603       decayTable->Insert(mode);
00604       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
00605                                            "k_star+","pi-","pi0");
00606       decayTable->Insert(mode);
00607  
00608     }else if (iType==TAntiK) {
00609       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
00610                                            "k_star-","pi+","pi-");
00611       decayTable->Insert(mode);
00612       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
00613                                            "anti_k_star0","pi-","pi0");
00614       decayTable->Insert(mode);
00615     }
00616   }
00617 
00618   return decayTable;
00619 }

G4DecayTable * G4ExcitedMesonConstructor::AddKStarPiMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iType 
) [protected]

Definition at line 532 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert(), TAntiK, and TK.

Referenced by CreateDecayTable().

00535 {
00536   G4VDecayChannel* mode;
00537   // 
00538   if (iIso3 == +1) {
00539     if (iType == TK) {    
00540       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
00541                                            "k_star+","pi0");
00542       decayTable->Insert(mode);
00543       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
00544                                            "k_star0","pi+");
00545       decayTable->Insert(mode);
00546     }else if (iType==TAntiK) {
00547       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
00548                                            "anti_k_star0","pi0");
00549       decayTable->Insert(mode);
00550       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
00551                                            "k_star-","pi+");
00552       decayTable->Insert(mode);
00553    }
00554   } else if (iIso3 == -1) {
00555     if (iType == TK) {    
00556       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
00557                                            "k_star0","pi0");
00558       decayTable->Insert(mode);
00559       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
00560                                            "k_star+","pi-");
00561       decayTable->Insert(mode);
00562  
00563     }else if (iType==TAntiK) {
00564       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
00565                                            "k_star-","pi0");
00566       decayTable->Insert(mode);
00567       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
00568                                            "anti_k_star0","pi-");
00569       decayTable->Insert(mode);
00570     }
00571   }
00572 
00573   return decayTable;
00574 }

G4DecayTable * G4ExcitedMesonConstructor::AddKTwoPiMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iType 
) [protected]

Definition at line 382 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert(), TAntiK, and TK.

Referenced by CreateDecayTable().

00385 {
00386   G4VDecayChannel* mode;
00387   // 
00388   if (iIso3 == +1) {
00389     if (iType == TK) {    
00390       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
00391                                            "k2_star(1430)+","pi0");
00392       decayTable->Insert(mode);
00393       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
00394                                            "k2_star(1430)0","pi+");
00395       decayTable->Insert(mode);
00396     }else if (iType==TAntiK) {
00397       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
00398                                            "anti_k2_star(1430)0","pi0");
00399       decayTable->Insert(mode);
00400       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
00401                                            "k2_star(1430)-","pi+");
00402       decayTable->Insert(mode);
00403    }
00404   } else if (iIso3 == -1) {
00405     if (iType == TK) {    
00406       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
00407                                            "k2_star(1430)0","pi0");
00408       decayTable->Insert(mode);
00409       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
00410                                            "k2_star(1430)+","pi-");
00411       decayTable->Insert(mode);
00412  
00413     }else if (iType==TAntiK) {
00414       mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
00415                                            "k2_star(1430)-","pi0");
00416       decayTable->Insert(mode);
00417       mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
00418                                            "anti_k2_star(1430)0","pi-");
00419       decayTable->Insert(mode);
00420     }
00421   }
00422 
00423   return decayTable;
00424 }

G4DecayTable * G4ExcitedMesonConstructor::AddPiA2Mode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 961 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

00964 {
00965   G4VDecayChannel* mode;
00966 
00967   G4String daughterPi;
00968   G4String daughterA2;
00969   G4double r; 
00970 
00971   // I = 0 states
00972   if (iIso==0) {
00973     if (iIso3==0) {
00974       // pi+ + a2(1320)-
00975       daughterPi = "pi+";
00976       daughterA2 = "a2(1320)-";
00977       r = br/3.;
00978       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
00979                                           daughterPi,daughterA2);
00980       decayTable->Insert(mode);
00981       
00982       // pi0 + a2(1320)0
00983       daughterPi = "pi0";
00984       daughterA2 = "a2(1320)0";
00985       r = br*1./3.;
00986       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
00987                                           daughterPi,daughterA2);
00988       decayTable->Insert(mode);
00989       
00990       // pi- + a2(1320)+
00991       daughterPi = "pi-";
00992       daughterA2 = "a2(1320)+";
00993       r = br*1./3.;
00994       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
00995                                           daughterPi,daughterA2);
00996       decayTable->Insert(mode);
00997     } 
00998   } else if (iIso==2) {
00999     if (iIso3==+2) {
01000       // pi+ + a2(1320)0
01001       daughterPi = "pi+";
01002       daughterA2 = "a2(1320)0";
01003       r = br/2.;
01004       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
01005                                           daughterPi,daughterA2);
01006       decayTable->Insert(mode);
01007  
01008       // pi0 + a2(1320)+
01009       daughterPi = "pi0";
01010       daughterA2 = "a2(1320)+";
01011       r = br/2.;
01012       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
01013                                           daughterPi,daughterA2);
01014       decayTable->Insert(mode);
01015     } else if (iIso3==0) {
01016        // pi+ + a2(1320)-
01017       daughterPi = "pi+";
01018       daughterA2 = "a2(1320)-";
01019       r = br/2.;
01020       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
01021                                           daughterPi,daughterA2);
01022       decayTable->Insert(mode);
01023 
01024        // pi- + a2(1320)+
01025       daughterPi = "pi-";
01026       daughterA2 = "a2(1320)+";
01027       r = br/2.;
01028       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
01029                                           daughterPi,daughterA2);
01030       decayTable->Insert(mode);
01031      } else if (iIso3==-2) {
01032        // pi- + a2(1320)0
01033       daughterPi = "pi-";
01034       daughterA2 = "a2(1320)0";
01035       r = br/2.;
01036       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
01037                                           daughterPi,daughterA2);
01038       decayTable->Insert(mode);
01039     
01040       // pi0 + a2(1320)-
01041       daughterPi = "pi0";
01042       daughterA2 = "a2(1320)-";
01043       r = br/2.;
01044       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
01045                                           daughterPi,daughterA2);
01046       decayTable->Insert(mode);
01047     }
01048   }
01049   return decayTable;
01050 }

G4DecayTable * G4ExcitedMesonConstructor::AddPiEtaMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 702 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

00705 {
00706   if ((iIso!=2)&&(iIso!=0)) return decayTable;
00707 
00708   G4VDecayChannel* mode;
00709   // 
00710   G4String daughter;
00711   if (iIso3 == +2) { 
00712     daughter = "pi+";  
00713   } else if (iIso3 == 0) { 
00714     daughter = "pi0";  
00715   } else if (iIso3 ==-2) { 
00716     daughter = "pi-";  
00717   } else {
00718     return decayTable; 
00719   } 
00720   // create decay channel  [parent    BR     #daughters]
00721   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
00722                                            daughter,"eta");
00723   // add decay table
00724   decayTable->Insert(mode);
00725 
00726   return decayTable;
00727 }

G4DecayTable * G4ExcitedMesonConstructor::AddPiF0Mode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 783 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

00786 {
00787   if ((iIso!=2)&&(iIso!=0)) return decayTable;
00788 
00789   G4VDecayChannel* mode;
00790   // 
00791   G4String daughter;
00792   if (iIso3 == +2) { 
00793     daughter = "pi+";  
00794   } else if (iIso3 == 0) { 
00795     daughter = "pi0";  
00796   } else if (iIso3 ==-2) { 
00797     daughter = "pi-";  
00798   } else {
00799     return decayTable; 
00800   } 
00801   // create decay channel  [parent    BR     #daughters]
00802   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
00803                                            daughter,"f0(1370)");
00804   // add decay table
00805   decayTable->Insert(mode);
00806   return decayTable;
00807 }

G4DecayTable * G4ExcitedMesonConstructor::AddPiF2Mode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 756 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

00759 {
00760   if ((iIso!=2)&&(iIso!=0)) return decayTable;
00761 
00762   G4VDecayChannel* mode;
00763   // 
00764   G4String daughter;
00765   if (iIso3 == +2) { 
00766     daughter = "pi+";  
00767   } else if (iIso3 == 0) { 
00768     daughter = "pi0";  
00769   } else if (iIso3 ==-2) { 
00770     daughter = "pi-";  
00771   } else {
00772     return decayTable; 
00773   } 
00774   // create decay channel  [parent    BR     #daughters]
00775   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
00776                                            daughter,"f2(1270)");
00777   // add decay table
00778   decayTable->Insert(mode);
00779 
00780   return decayTable;
00781 }

G4DecayTable * G4ExcitedMesonConstructor::AddPiGammaMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 621 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

00624 {
00625   if ((iIso!=2)&&(iIso!=0)) return decayTable;
00626 
00627   G4VDecayChannel* mode;
00628   // 
00629   G4String daughter;
00630   if (iIso3 == +2) { 
00631     daughter = "pi+";  
00632   } else if (iIso3 == 0) { 
00633     daughter = "pi0";  
00634   } else if (iIso3 ==-2) { 
00635     daughter = "pi-";  
00636   } else {
00637     return decayTable; 
00638   } 
00639     // create decay channel  [parent    BR     #daughters]
00640   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
00641                                            daughter,"gamma");
00642   // add decay table
00643   decayTable->Insert(mode);
00644 
00645   return decayTable;
00646 }

G4DecayTable * G4ExcitedMesonConstructor::AddPiOmegaMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 648 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

00651 {
00652   if ((iIso!=2)&&(iIso!=0)) return decayTable;
00653 
00654   G4VDecayChannel* mode;
00655   // 
00656   G4String daughter;
00657   if (iIso3 == +2) { 
00658     daughter = "pi+";  
00659   } else if (iIso3 == 0) { 
00660     daughter = "pi0";  
00661   } else if (iIso3 ==-2) { 
00662     daughter = "pi-";  
00663   } else {
00664     return decayTable; 
00665   } 
00666     // create decay channel  [parent    BR     #daughters]
00667   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
00668                                            daughter,"omega");
00669   // add decay table
00670   decayTable->Insert(mode);
00671 
00672   return decayTable;
00673 }

G4DecayTable * G4ExcitedMesonConstructor::AddPiRhoMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 870 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

00873 {
00874   G4VDecayChannel* mode;
00875 
00876   G4String daughterPi;
00877   G4String daughterRho;
00878   G4double r; 
00879 
00880   // I = 0 states
00881   if (iIso==0) {
00882     if (iIso3==0) {
00883       // pi+ + rho-
00884       daughterPi = "pi+";
00885       daughterRho = "rho-";
00886       r = br/3.;
00887       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
00888                                           daughterPi,daughterRho);
00889       decayTable->Insert(mode);
00890       
00891       // pi0 + rho0
00892       daughterPi = "pi0";
00893       daughterRho = "rho0";
00894       r = br*1./3.;
00895       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
00896                                           daughterPi,daughterRho);
00897       decayTable->Insert(mode);
00898       
00899       // pi- + rho+
00900       daughterPi = "pi-";
00901       daughterRho = "rho+";
00902       r = br*1./3.;
00903       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
00904                                           daughterPi,daughterRho);
00905       decayTable->Insert(mode);
00906     } 
00907   } else if (iIso==2) {
00908     if (iIso3==+2) {
00909       // pi+ + rho0
00910       daughterPi = "pi+";
00911       daughterRho = "rho0";
00912       r = br/2.;
00913       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
00914                                           daughterPi,daughterRho);
00915       decayTable->Insert(mode);
00916  
00917       // pi0 + rho+
00918       daughterPi = "pi0";
00919       daughterRho = "rho+";
00920       r = br/2.;
00921       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
00922                                           daughterPi,daughterRho);
00923       decayTable->Insert(mode);
00924     } else if (iIso3==0) {
00925        // pi+ + rho-
00926       daughterPi = "pi+";
00927       daughterRho = "rho-";
00928       r = br/2.;
00929       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
00930                                           daughterPi,daughterRho);
00931       decayTable->Insert(mode);
00932 
00933        // pi- + rho+
00934       daughterPi = "pi-";
00935       daughterRho = "rho+";
00936       r = br/2.;
00937       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
00938                                           daughterPi,daughterRho);
00939       decayTable->Insert(mode);
00940      } else if (iIso3==-2) {
00941        // pi- + rho0
00942       daughterPi = "pi-";
00943       daughterRho = "rho0";
00944       r = br/2.;
00945       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
00946                                           daughterPi,daughterRho);
00947       decayTable->Insert(mode);
00948     
00949       // pi0 + rho-
00950       daughterPi = "pi0";
00951       daughterRho = "rho-";
00952       r = br/2.;
00953       mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
00954                                           daughterPi,daughterRho);
00955       decayTable->Insert(mode);
00956     }
00957   }
00958   return decayTable;
00959 }

G4DecayTable * G4ExcitedMesonConstructor::AddRhoEtaMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 729 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

00732 {
00733   if ((iIso!=2)&&(iIso!=0)) return decayTable;
00734 
00735   G4VDecayChannel* mode;
00736   // 
00737   G4String daughter;
00738   if (iIso3 == +2) { 
00739     daughter = "rho+";  
00740   } else if (iIso3 == 0) { 
00741     daughter = "rho0";  
00742   } else if (iIso3 ==-2) { 
00743     daughter = "rho-";  
00744   } else {
00745     return decayTable; 
00746   } 
00747   // create decay channel  [parent    BR     #daughters]
00748   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
00749                                            daughter,"eta");
00750   // add decay table
00751   decayTable->Insert(mode);
00752 
00753   return decayTable;
00754 }

G4DecayTable * G4ExcitedMesonConstructor::AddRhoGammaMode ( G4DecayTable table,
const G4String name,
G4double  br,
G4int  iIso3,
G4int  iIso 
) [protected]

Definition at line 675 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

00678 {
00679   if ((iIso!=2)&&(iIso!=0)) return decayTable;
00680 
00681   G4VDecayChannel* mode;
00682   // 
00683   G4String daughter;
00684   if (iIso3 == +2) { 
00685     daughter = "rho+";  
00686   } else if (iIso3 == 0) { 
00687     daughter = "rho0";  
00688   } else if (iIso3 ==-2) { 
00689     daughter = "rho-";  
00690   } else {
00691     return decayTable; 
00692   } 
00693   // create decay channel  [parent    BR     #daughters]
00694   mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
00695                                            daughter,"gamma");
00696   // add decay table
00697   decayTable->Insert(mode);
00698 
00699   return decayTable;
00700 }

void G4ExcitedMesonConstructor::Construct ( G4int  indexOfState = -1  )  [virtual]

Definition at line 58 of file G4ExcitedMesonConstructor.cc.

References ConstructMesons(), G4cerr, G4endl, G4ParticleTable::GetParticleTable(), NMesonTypes, and NMultiplets.

Referenced by G4ShortLivedConstructor::ConstructResonances().

00059 {
00060   G4int iType;
00061   if (idx < 0 ) {
00062     for (G4int state=0; state< NMultiplets; state +=1) {
00063       for (iType = 0; iType < NMesonTypes ; iType++) 
00064         ConstructMesons(state, iType);
00065     }
00066   } else if (idx < NMultiplets ) {
00067       for (iType = 0; iType < NMesonTypes ; iType++) 
00068         ConstructMesons(idx, iType);
00069   } else {
00070 #ifdef G4VERBOSE
00071     if (G4ParticleTable::GetParticleTable()->GetVerboseLevel()>1) {
00072       G4cerr << "G4ExcitedMesonConstructor::Construct()";
00073       G4cerr << "   illegal index os state = " << idx << G4endl;
00074     }
00075 #endif
00076   }
00077 }

void G4ExcitedMesonConstructor::ConstructMesons ( G4int  indexOfState,
G4int  indexOfType 
) [protected]

Definition at line 93 of file G4ExcitedMesonConstructor.cc.

References baryonNumber, CreateDecayTable(), Exist(), GetCharge(), GetEncoding(), GetName(), iChargeConjugation, iGParity, iIsoSpin, iParity, iSpin, leptonNumber, mass, massKdiff, name, G4ParticleDefinition::SetAntiPDGEncoding(), G4ParticleDefinition::SetDecayTable(), G4ExcitedMesons::SetMultipletName(), TAntiK, TEta, TEtaPrime, TK, TPi, type, width, and widthKdiff.

Referenced by Construct().

00094 {
00095   if (!Exist(iState, iType) ) return;
00096 
00097   //    Construct Resonace particles as dynamic object
00098   //    Arguments for constructor are as follows
00099   //               name             mass          width        
00100   //             charge           2*spin           
00101   //             parity    C-conjugation
00102   //          2*Isospin       2*Isospin3       
00103   //          G-parity
00104   //               type    lepton number  Baryon number   
00105   //        PDG encoding
00106   //             stable         lifetime    decay table 
00107   
00108   
00109   G4String aName;
00110   G4ExcitedMesons* particle;
00111   
00112   for ( G4int iIso3=(-1)*iIsoSpin[iType]; iIso3<=iIsoSpin[iType]; iIso3+=2) {
00113     aName= GetName(iIso3, iState, iType);
00114     G4double fmass =  mass[iState][iType];
00115     G4double fwidth = width[iState][iType];
00116         if ( (iType== TK) || (iType==TAntiK ) ) {
00117           if ( GetCharge(iIso3,iType) == 0.0) {
00118                 fmass  += massKdiff[iState];
00119             fwidth += widthKdiff[iState];
00120       }
00121    }
00122     particle = new G4ExcitedMesons(            
00123              aName,   fmass,         fwidth,    
00124                  GetCharge(iIso3,iType),                 iSpin[iState],
00125                         iParity[iState],    iChargeConjugation[iState],
00126                         iIsoSpin[iType],                         iIso3,   
00127                 iGParity[iState][iType],
00128                                    type,  leptonNumber,   baryonNumber, 
00129      GetEncoding(iIso3, iState, iType),
00130                                   false,           0.0,            NULL
00131                                     );
00132 
00133     if ( (iType==TEta) || (iType==TEtaPrime) || ((iType==TPi)&&(iIso3==0)) ) {
00134     // set same encoding for AntiParticle
00135       particle->SetAntiPDGEncoding(GetEncoding(iIso3, iState, iType));
00136     }
00137     particle->SetMultipletName(name[iState][iType]);
00138     particle->SetDecayTable(CreateDecayTable( aName, iIso3, iState, iType));
00139   }
00140 }

G4DecayTable * G4ExcitedMesonConstructor::CreateDecayTable ( const G4String ,
G4int  ,
G4int  ,
G4int   
) [protected]

Definition at line 245 of file G4ExcitedMesonConstructor.cc.

References Add2EtaMode(), Add2KMode(), Add2KPiMode(), Add2PiEtaMode(), Add2PiMode(), Add2PiOmegaMode(), Add2PiRhoMode(), Add3PiMode(), Add4PiMode(), AddKEtaMode(), AddKKStarMode(), AddKOmegaMode(), AddKPiMode(), AddKRhoMode(), AddKStar2PiMode(), AddKStarPiMode(), AddKTwoPiMode(), AddPiA2Mode(), AddPiF0Mode(), AddPiF2Mode(), AddPiGammaMode(), AddPiOmegaMode(), AddPiRhoMode(), AddRhoEtaMode(), AddRhoGammaMode(), bRatio, iIsoSpin, M2Eta, M2K, M2KPi, M2Pi, M2PiEta, M2PiOmega, M2PiRho, M3Pi, M4Pi, MKEta, MKKStar, MKOmega, MKPi, MKRho, MKStar2Pi, MKStarPi, MKTwoPi, MPiA2, MPiF0, MPiF2, MPiGamma, MPiOmega, MPiRho, MRhoEta, MRhoGamma, TAntiK, and TK.

Referenced by ConstructMesons().

00250 {
00251    // create decay table
00252   G4DecayTable* decayTable =  new G4DecayTable();
00253   G4double br;
00254  
00255   if ((iType==TK)||(iType==TAntiK)) {
00256     
00257     if ( (br=bRatio[iState][iType][MKPi]) >0.0) {
00258       AddKPiMode( decayTable, parentName, br, iIso3, iType );
00259     }
00260     if ( (br=bRatio[iState][iType][MKStarPi]) >0.0) {
00261       AddKStarPiMode( decayTable, parentName, br, iIso3, iType );
00262     }
00263     if ( (br=bRatio[iState][iType][MKRho]) >0.0) {
00264       AddKRhoMode( decayTable, parentName, br, iIso3, iType );
00265     }
00266     if ( (br=bRatio[iState][iType][MKOmega]) >0.0) {
00267       AddKOmegaMode( decayTable, parentName, br, iIso3, iType );
00268     }
00269     if ( (br=bRatio[iState][iType][MKStar2Pi]) >0.0) {
00270       AddKStar2PiMode( decayTable, parentName, br, iIso3, iType );
00271     }
00272     if ( (br=bRatio[iState][iType][MKTwoPi]) >0.0) {
00273       AddKTwoPiMode( decayTable, parentName, br, iIso3, iType );
00274     }
00275     if ( (br=bRatio[iState][iType][MKEta]) >0.0) {
00276       AddKEtaMode( decayTable, parentName, br, iIso3, iType );
00277     }
00278 
00279   } else {
00280     if ( (br=bRatio[iState][iType][MPiGamma]) >0.0) {
00281       AddPiGammaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00282     }
00283     if ( (br=bRatio[iState][iType][MRhoGamma]) >0.0) {
00284       AddRhoGammaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00285     }
00286     if ( (br=bRatio[iState][iType][M2Pi]) >0.0) {
00287       Add2PiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00288     }
00289     if ( (br=bRatio[iState][iType][MPiRho]) >0.0) {
00290       AddPiRhoMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00291     }
00292     if ( (br=bRatio[iState][iType][M3Pi]) >0.0) {
00293       Add3PiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00294     }
00295     if ( (br=bRatio[iState][iType][M4Pi]) >0.0) {
00296       Add4PiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00297     }
00298     if ( (br=bRatio[iState][iType][MKKStar]) >0.0) {
00299       AddKKStarMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00300     }
00301     if ( (br=bRatio[iState][iType][M2PiEta]) >0.0) {
00302       Add2PiEtaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00303     }
00304     if ( (br=bRatio[iState][iType][MRhoEta]) >0.0) {
00305       AddRhoEtaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00306     }
00307     if ( (br=bRatio[iState][iType][M2PiRho]) >0.0) {
00308       Add2PiRhoMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00309     }
00310     if ( (br=bRatio[iState][iType][M2PiOmega]) >0.0) {
00311       Add2PiOmegaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00312     }
00313     if ( (br=bRatio[iState][iType][M2Eta]) >0.0) {
00314       Add2EtaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00315     }
00316     if ( (br=bRatio[iState][iType][M2K]) >0.0) {
00317       Add2KMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00318     }
00319     if ( (br=bRatio[iState][iType][M2KPi]) >0.0) {
00320       Add2KPiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00321     }
00322    if ( (br=bRatio[iState][iType][MPiOmega]) >0.0) {
00323       AddPiOmegaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00324     }
00325    if ( (br=bRatio[iState][iType][MPiF2]) >0.0) {
00326       AddPiF2Mode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00327     }
00328    if ( (br=bRatio[iState][iType][MPiF0]) >0.0) {
00329       AddPiF0Mode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00330     }
00331    if ( (br=bRatio[iState][iType][MPiA2]) >0.0) {
00332       AddPiA2Mode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
00333     }
00334   }
00335 
00336   return decayTable;
00337 }

G4bool G4ExcitedMesonConstructor::Exist ( G4int  idxState,
G4int  idxType 
) [protected]

Definition at line 79 of file G4ExcitedMesonConstructor.cc.

References N13D1, N13P0, N23P2, TEtaPrime, and TPi.

Referenced by ConstructMesons().

00080 {
00081   G4bool value = true;
00082   if ( idxType == TEtaPrime ) {
00083     if (idxState==N13P0) value = false;      
00084     if (idxState==N13D1) value = false;      
00085   } else if ( idxType == TPi ) {
00086     if (idxState==N23P2) value = false;      
00087   }
00088   return value;
00089 }

G4double G4ExcitedMesonConstructor::GetCharge ( G4int  iIsoSpin3,
G4int  idxType 
) [protected]

Definition at line 188 of file G4ExcitedMesonConstructor.cc.

References GetQuarkContents().

00189 {
00190   static G4double quark_charge[7] = 
00191   {
00192     0., -1./3., +2./3., -1./3., +2./3., -1./3., +2./3.
00193   };
00194   
00195   G4double charge =  quark_charge[GetQuarkContents(0, iIsoSpin3, idxType)]*eplus;
00196   charge -=  quark_charge[GetQuarkContents(1, iIsoSpin3, idxType)]*eplus;
00197   return charge;
00198 }

G4double G4ExcitedMesonConstructor::GetCharge ( G4int  iIsoSpin3  )  [protected]

Referenced by ConstructMesons().

G4int G4ExcitedMesonConstructor::GetEncoding ( G4int  iIsoSpin3,
G4int  idxState,
G4int  idxType 
) [protected]

Definition at line 200 of file G4ExcitedMesonConstructor.cc.

References encoding, encodingOffset, GetQuarkContents(), iSpin, TAntiK, TEta, TEtaPrime, TK, and TPi.

Referenced by ConstructMesons().

00203 {
00204   G4int encoding = encodingOffset[idxState];
00205   encoding +=  iSpin[idxState] +1;
00206   G4int iQ = 0;
00207   G4int iQbar = 1;
00208 
00209   if ( idxType == TPi ) {
00210     if (iIsoSpin3<0) {
00211       iQ = 1;
00212       iQbar = 0; 
00213     }
00214   } else if ( idxType == TK ) {
00215     iQ = 1;
00216     iQbar = 0; 
00217   }
00218 
00219 
00220   encoding +=  100*GetQuarkContents(iQ, iIsoSpin3, idxType);
00221   encoding +=   10*GetQuarkContents(iQbar, iIsoSpin3, idxType);
00222   if ( idxType == TPi ) {
00223     if (iIsoSpin3<0) {
00224       encoding *=  -1;
00225     }
00226   } else if ( idxType == TAntiK ) {
00227     encoding *=  -1;
00228   }
00229 
00230 // PDG2005
00231 //
00232   if (idxState == 9 ) {
00233     if (idxType == TEta) {
00234 //   f2(1810)  9030225
00235       encoding = 9030225;
00236     } else if (idxType == TEtaPrime) {
00237 //   f2(2010)  9060225
00238       encoding = 9060225;
00239     }
00240   }
00241 
00242   return encoding;
00243 }

G4String G4ExcitedMesonConstructor::GetName ( G4int  iIso3,
G4int  iState,
G4int  idxType 
) [inline, protected]

Definition at line 178 of file G4ExcitedMesonConstructor.hh.

References name, TAntiK, TK, and TPi.

Referenced by ConstructMesons().

00181 {
00182   G4String particle = name[iState][iType];
00183   if (iType == TPi) {
00184     if ( iIso3 == +2 ){
00185       particle += "+";
00186     } else if ( iIso3 == -2 ){
00187       particle += "-";
00188     } else {
00189       particle += "0";
00190     }
00191   } else if (iType == TK) {
00192     if ( iIso3 == +1 ){
00193       particle += "+";
00194     } else if ( iIso3 == -1 ){
00195       particle += "0";
00196     }
00197   }  else if (iType == TAntiK) {
00198     if ( iIso3 == +1 ){
00199       particle += "0";
00200       particle = "anti_" + particle;
00201     } else if ( iIso3 == -1 ){
00202       particle += "-";
00203     }
00204   } 
00205   return particle;
00206 }

G4int G4ExcitedMesonConstructor::GetQuarkContents ( G4int  iQ,
G4int  iIso3,
G4int  iType 
) [protected]

Definition at line 143 of file G4ExcitedMesonConstructor.cc.

References TAntiK, TEta, TEtaPrime, TK, and TPi.

Referenced by GetCharge(), and GetEncoding().

00146 {
00147   // Quark contents
00148 
00149   G4int quark=0;
00150   if (iType == TPi) {
00151     if ( iIso3 == 2 ){
00152       if ( iQ == 0 ){ quark = 2; }
00153       else          { quark = 1; }
00154     } else if ( iIso3 == 0 ){
00155       quark = 1;
00156     }  else if ( iIso3 == -2 ){
00157       if ( iQ == 0 ){ quark = 1; }
00158       else          { quark = 2; }
00159     }
00160   } else if (iType == TEta) {
00161     quark = 2;
00162 
00163   } else if (iType == TEtaPrime) {
00164     quark = 3;
00165 
00166   } else if (iType == TAntiK) {
00167     if ( iIso3 == 1 ){
00168       if ( iQ == 0 ){ quark = 3; }
00169       else          { quark = 1; }
00170     } else if ( iIso3 == -1 ){
00171       if ( iQ == 0 ){ quark = 3; }
00172       else          { quark = 2; }
00173     }
00174  
00175   } else if (iType == TK) {
00176     if ( iIso3 == 1 ){
00177       if ( iQ == 0 ){ quark = 2; }
00178       else          { quark = 3; }
00179     } else if ( iIso3 == -1 ){
00180       if ( iQ == 0 ){ quark = 1; }
00181       else          { quark = 3; }
00182     }
00183 
00184   }
00185   return quark;
00186 }


Field Documentation

const G4int G4ExcitedMesonConstructor::baryonNumber [protected]

Definition at line 86 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().

const G4double G4ExcitedMesonConstructor::bRatio [static, protected]

Definition at line 114 of file G4ExcitedMesonConstructor.hh.

Referenced by CreateDecayTable().

const G4int G4ExcitedMesonConstructor::encodingOffset [static, protected]

Initial value:

{ 10000, 10000, 20000,      0, 10000, 30000,     0, 100000,100000,100000}

Definition at line 100 of file G4ExcitedMesonConstructor.hh.

Referenced by GetEncoding().

const G4int G4ExcitedMesonConstructor::iChargeConjugation [static, protected]

Initial value:

{


     -1,   +1,   +1,   +1,   +1,   -1,   -1,   +1,   -1,   +1
}

Definition at line 99 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().

const G4int G4ExcitedMesonConstructor::iGParity [static, protected]

Initial value:

{
  {  +1,  -1,  -1,  0,  0},
  {  -1,  +1,   0,  0,  0},
  {  -1,  +1,  +1,  0,  0},
  {  -1,  +1,  +1,  0,  0},
  {  -1,  +1,  +1,  0,  0},
  {  +1,  -1,   0,  0,  0},
  {  +1,  -1,  -1,  0,  0},
  {  -1,  +1, +1,  0,  0},
  {  +1,  -1,  -1,  0,  0},
  {   0,  +1,  +1,  0,  0}
}

Definition at line 98 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().

const G4int G4ExcitedMesonConstructor::iIsoSpin [static, protected]

Initial value:

{

     2,     0,         0,   1,     1
}

Definition at line 95 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons(), and CreateDecayTable().

const G4int G4ExcitedMesonConstructor::iParity [static, protected]

Initial value:

{


     +1,   +1,   +1,   +1,   -1,   -1,   -1,   -1,   -1,   +1
}

Definition at line 97 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().

const G4int G4ExcitedMesonConstructor::iSpin [static, protected]

Initial value:

{


      2,    0,    2,    4,    4,    2,    6,    0,    2,    4
}

Definition at line 96 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons(), and GetEncoding().

const G4int G4ExcitedMesonConstructor::leptonNumber [protected]

Definition at line 85 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().

const G4double G4ExcitedMesonConstructor::mass [static, protected]

Initial value:

 
{
  {  1.2295*GeV, 1.170*GeV, 1.386*GeV, 1.272*GeV,  1.272*GeV },
  {   1.474*GeV, 1.350*GeV,       0.0, 1.430*GeV,  1.430*GeV },
  {   1.230*GeV,1.2818*GeV,1.4264*GeV, 1.403*GeV,  1.403*GeV },
  {  1.3183*GeV,1.2751*GeV, 1.525*GeV,1.4256*GeV, 1.4256*GeV },
  {  1.6722*GeV, 1.617*GeV, 1.842*GeV, 1.773*GeV,  1.773*GeV },
  {   1.720*GeV, 1.670*GeV,       0.0, 1.717*GeV,  1.717*GeV },
  {  1.6888*GeV, 1.667*GeV, 1.854*GeV, 1.776*GeV,  1.776*GeV },
  {   1.300*GeV, 1.294*GeV, 1.476*GeV, 1.460*GeV,  1.460*GeV },
  {   1.465*GeV, 1.425*GeV, 1.680*GeV, 1.414*GeV,  1.414*GeV },
  {         0.0, 1.815*GeV, 2.010*GeV, 1.973*GeV,  1.973*GeV }
}

Definition at line 91 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().

const G4double G4ExcitedMesonConstructor::massKdiff [static, protected]

Initial value:

 {
        0.0*MeV,  0.0*MeV, 0.0*MeV, 6.8*MeV, 0.0*MeV, 
    0.0*MeV,  0.0*MeV, 0.0*MeV, 0.0*MeV, 0.0*MeV
}

Definition at line 92 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().

const char * G4ExcitedMesonConstructor::name [static, protected]

Initial value:

{
  { "b1(1235)",   "h1(1170)",   "h1(1380)",      "k1(1270)",      "k1(1270)" },
  { "a0(1450)",   "f0(1370)",           "", "k0_star(1430)", "k0_star(1430)" },
  { "a1(1260)",   "f1(1285)",   "f1(1420)",      "k1(1400)",      "k1(1400)" },
  { "a2(1320)",   "f2(1270)","f2_prime(1525)","k2_star(1430)","k2_star(1430)"},
  {"pi2(1670)", "eta2(1645)", "eta2(1870)",      "k2(1770)",      "k2(1770)" },
  {"rho(1700)", "omega(1650)",          "",  "k_star(1680)",  "k_star(1680)" },
 {"rho3(1690)","omega3(1670)","phi3(1850)", "k3_star(1780)", "k3_star(1780)" },
  { "pi(1300)",  "eta(1295)",  "eta(1475)",       "k(1460)",       "k(1460)" },
  {"rho(1450)","omega(1420)",  "phi(1680)",  "k_star(1410)",  "k_star(1410)" },
  {         "",   "f2(1810)",   "f2(2010)", "k2_star(1980)", "k2_star(1980)" }
}

Definition at line 90 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons(), and GetName().

const G4String G4ExcitedMesonConstructor::type [protected]

Definition at line 84 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().

const G4double G4ExcitedMesonConstructor::width [static, protected]

Initial value:

 
{
  {  142.0*MeV, 360.0*MeV,  91.0*MeV,  90.0*MeV,  90.0*MeV },
  {  265.0*MeV, 350.0*MeV,       0.0, 270.0*MeV, 270.0*MeV },
  {  420.0*MeV,  24.3*MeV,  54.9*MeV, 174.0*MeV, 174.0*MeV },
  {  107.0*MeV, 185.1*MeV,  73.0*MeV,  98.5*MeV,  98.5*MeV },
  {  260.0*MeV, 181.0*MeV, 225.0*MeV, 186.0*MeV, 186.0*MeV },
  {  250.0*MeV, 315.0*MeV,       0.0, 320.0*MeV, 320.0*MeV },
  {  161.0*MeV, 168.0*MeV,  87.0*MeV, 159.0*MeV, 159.0*MeV },
  {  400.0*MeV,  55.0*MeV,  85.0*MeV, 260.0*MeV, 260.0*MeV },
  {  400.0*MeV, 215.0*MeV, 150.0*MeV, 232.0*MeV, 232.0*MeV },
  {        0.0, 197.0*MeV, 200.0*MeV, 373.0*MeV, 373.0*MeV }
}

Definition at line 93 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().

const G4double G4ExcitedMesonConstructor::widthKdiff [static, protected]

Initial value:

 {
        0.0*MeV,  0.0*MeV, 0.0*MeV, 10.5*MeV, 0.0*MeV, 
    0.0*MeV,  0.0*MeV, 0.0*MeV, 0.0*MeV, 0.0*MeV
}

Definition at line 94 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().


The documentation for this class was generated from the following files:
Generated on Mon May 27 17:51:57 2013 for Geant4 by  doxygen 1.4.7