Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4ExcitedMesonConstructor Class Reference

#include <G4ExcitedMesonConstructor.hh>

Collaboration diagram for G4ExcitedMesonConstructor:

Public Types

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

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.

anonymous enum
Enumerator
NMesonTypes 

Definition at line 79 of file G4ExcitedMesonConstructor.hh.

anonymous enum
Enumerator
NumberOfDecayModes 

Definition at line 103 of file G4ExcitedMesonConstructor.hh.

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.

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

Constructor & Destructor Documentation

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

Definition at line 47 of file G4ExcitedMesonConstructor.cc.

G4ExcitedMesonConstructor::~G4ExcitedMesonConstructor ( )
virtual

Definition at line 53 of file G4ExcitedMesonConstructor.cc.

54 {
55 }

Member Function Documentation

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

Definition at line 1161 of file G4ExcitedMesonConstructor.cc.

1164 {
1165  if (iIso!=0) return decayTable;
1166 
1167  G4VDecayChannel* mode;
1168 
1169  // eta eta
1170  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
1171  "eta","eta");
1172  decayTable->Insert(mode);
1173  return decayTable;
1174 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1344 of file G4ExcitedMesonConstructor.cc.

1347 {
1348  G4VDecayChannel* mode;
1349 
1350  if (iIso3==0) {
1351  // K+ + K-
1352  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 2,
1353  "kaon+","kaon-");
1354  decayTable->Insert(mode);
1355 
1356  // K0 + Anti_K0
1357  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 2,
1358  "kaon0","anti_kaon0");
1359  decayTable->Insert(mode);
1360  } else if (iIso3==+2) {
1361  // K+ + anti_K0
1362  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
1363  "kaon+","anti_kaon0");
1364  decayTable->Insert(mode);
1365  } else if (iIso3==-2) {
1366  // K- + K0
1367  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
1368  "kaon-","kaon0");
1369  decayTable->Insert(mode);
1370  }
1371 
1372  return decayTable;
1373 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1375 of file G4ExcitedMesonConstructor.cc.

1378 {
1379 
1380  // X(I=0)-->KKpi
1381  if (iIso!=0) return decayTable;
1382 
1383  G4VDecayChannel* mode;
1384 
1385  // K+ + K- + pi0
1386  mode = new G4PhaseSpaceDecayChannel(nameParent, br/6., 3,
1387  "kaon+","kaon-","pi0");
1388  decayTable->Insert(mode);
1389 
1390  // K0 + Anti_K0 + pi0
1391  mode = new G4PhaseSpaceDecayChannel(nameParent, br/6., 3,
1392  "kaon0","anti_kaon0","pi0");
1393  decayTable->Insert(mode);
1394 
1395  // K+ + anti_K0 + pi-
1396  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1397  "kaon+","anti_kaon0","pi-");
1398  decayTable->Insert(mode);
1399 
1400  // K- + K0 + pi+
1401  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1402  "kaon-","kaon0","pi+");
1403  decayTable->Insert(mode);
1404 
1405 
1406  return decayTable;
1407 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1139 of file G4ExcitedMesonConstructor.cc.

1142 {
1143  // f1-->eta + pi + pi mode
1144 
1145  if (iIso!=0) return decayTable;
1146 
1147  G4VDecayChannel* mode;
1148 
1149  // eta pi+ pi-
1150  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
1151  "eta","pi+","pi-");
1152  decayTable->Insert(mode);
1153 
1154  // eta pi+ pi-
1155  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1156  "eta","pi0","pi0");
1157  decayTable->Insert(mode);
1158  return decayTable;
1159 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 819 of file G4ExcitedMesonConstructor.cc.

822 {
823  G4VDecayChannel* mode;
824 
825  G4String daughterPi1;
826  G4String daughterPi2;
827  G4double r;
828 
829  // I = 0 states
830  if (iIso==0) {
831  if (iIso3==0) {
832  // pi+ + pi-
833  daughterPi1 = "pi+";
834  daughterPi2 = "pi-";
835  r = br*2./3.;
836  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
837  daughterPi1,daughterPi2);
838  decayTable->Insert(mode);
839 
840  // pi0 + pi0
841  daughterPi1 = "pi0";
842  daughterPi2 = "pi0";
843  r = br*1./3.;
844  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
845  daughterPi1,daughterPi2);
846  decayTable->Insert(mode);
847  }
848  } else if (iIso==2) {
849  if (iIso3==+2) {
850  // pi+ + pi0
851  daughterPi1 = "pi+";
852  daughterPi2 = "pi0";
853  r = br;
854  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
855  daughterPi1,daughterPi2);
856  // add decay table
857  decayTable->Insert(mode);
858  } else if (iIso3==0) {
859  // pi+ + pi-
860  daughterPi1 = "pi+";
861  daughterPi2 = "pi-";
862  r = br;
863  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
864  daughterPi1,daughterPi2);
865  decayTable->Insert(mode);
866  } else if (iIso3==-2) {
867  // pi- + pi0
868  daughterPi1 = "pi-";
869  daughterPi2 = "pi0";
870  r = br;
871  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
872  daughterPi1,daughterPi2);
873  decayTable->Insert(mode);
874  }
875  }
876  return decayTable;
877 }
double G4double
Definition: G4Types.hh:76

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1176 of file G4ExcitedMesonConstructor.cc.

1179 {
1180 
1181  G4VDecayChannel* mode;
1182  if (iIso==0) {
1183  // omega pi+ pi-
1184  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
1185  "omega","pi+","pi-");
1186  decayTable->Insert(mode);
1187 
1188  // omega pi+ pi-
1189  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1190  "omega","pi0","pi0");
1191  decayTable->Insert(mode);
1192  } else if (iIso==2) {
1193  if (iIso3==+2) {
1194  // omega pi+ pi0
1195  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 3,
1196  "omega","pi+","pi0");
1197  decayTable->Insert(mode);
1198  } else if (iIso3==0) {
1199  // omega pi+ pi-
1200  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 3,
1201  "omega","pi-","pi+");
1202  decayTable->Insert(mode);
1203  // omega pi0 pi0
1204  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 3,
1205  "omega","pi0","pi0");
1206  decayTable->Insert(mode);
1207  } else if (iIso3==-2) {
1208  // omega pi- pi0
1209  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 3,
1210  "omega","pi-","pi0");
1211  decayTable->Insert(mode);
1212  }
1213  }
1214  return decayTable;
1215 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1219 of file G4ExcitedMesonConstructor.cc.

1222 {
1223  G4VDecayChannel* mode;
1224 
1225  if (iIso==0) {
1226  // f1 --> rho0 + pi+ pi-
1227  // rho0 pi+ pi-
1228  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1229  "rho0","pi+","pi-");
1230  decayTable->Insert(mode);
1231  } else if (iIso==2) {
1232  if (iIso3==+2) {
1233  // rho+ pi0 pi0
1234  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1235  "rho+","pi0","pi0");
1236  decayTable->Insert(mode);
1237  // rho+ pi+ pi-
1238  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1239  "rho+","pi+","pi-");
1240  decayTable->Insert(mode);
1241  // rho0 pi+ pi0
1242  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1243  "rho0","pi+","pi0");
1244  decayTable->Insert(mode);
1245  // rho- pi+ pi+
1246  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1247  "rho-","pi+","pi+");
1248  decayTable->Insert(mode);
1249  } else if (iIso3==-2) {
1250  // rho- pi0 pi0
1251  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1252  "rho-","pi0","pi0");
1253  decayTable->Insert(mode);
1254  // rho- pi+ pi-
1255  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1256  "rho-","pi+","pi-");
1257  decayTable->Insert(mode);
1258  // rho0 pi- pi0
1259  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1260  "rho0","pi-","pi0");
1261  decayTable->Insert(mode);
1262  // rho+ pi- pi-
1263  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1264  "rho+","pi-","pi-");
1265  decayTable->Insert(mode);
1266  } else if (iIso3==0) {
1267  // rho+ pi- pi0
1268  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1269  "rho+","pi-","pi0");
1270  decayTable->Insert(mode);
1271  // rho0 pi+ pi-
1272  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1273  "rho0","pi+","pi-");
1274  decayTable->Insert(mode);
1275  // rho0 pi0 pi0
1276  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1277  "rho0","pi0","pi0");
1278  decayTable->Insert(mode);
1279  // rho- pi+ pi0
1280  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1281  "rho-","pi+","pi-");
1282  decayTable->Insert(mode);
1283  }
1284  }
1285  return decayTable;
1286 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1061 of file G4ExcitedMesonConstructor.cc.

1064 {
1065  G4VDecayChannel* mode;
1066 
1067  // I =0 state
1068  // This mode is X(I=0,J=1) --> pi+,pi-,pi0 mode
1069  if (iIso==0) {
1070  // pi+ + pi-
1071  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 3,
1072  "pi+","pi-","pi0");
1073  decayTable->Insert(mode);
1074  } else if (iIso==2) {
1075  // This mode is X(I=1) --> pi + pipi(I=0) mode
1076  if (iIso3==+2) {
1077  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1078  "pi+","pi0","pi0");
1079  decayTable->Insert(mode);
1080  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
1081  "pi+","pi+","pi-");
1082  decayTable->Insert(mode);
1083  } else if (iIso3==0) {
1084  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1085  "pi0","pi0","pi0");
1086  decayTable->Insert(mode);
1087  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
1088  "pi0","pi+","pi-");
1089  decayTable->Insert(mode);
1090  } else if (iIso3==-2) {
1091  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1092  "pi-","pi0","pi0");
1093  decayTable->Insert(mode);
1094  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
1095  "pi-","pi+","pi-");
1096  decayTable->Insert(mode);
1097  }
1098  }
1099  return decayTable;
1100 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1102 of file G4ExcitedMesonConstructor.cc.

1105 {
1106  G4VDecayChannel* mode;
1107 
1108  if (iIso3==0) {
1109  // 2pi+ + 2pi-
1110  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 4,
1111  "pi+","pi-","pi+","pi-");
1112  decayTable->Insert(mode);
1113  // pi+ + pi- + 2pi0
1114  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 4,
1115  "pi+","pi-","pi0","pi0");
1116  decayTable->Insert(mode);
1117  } else if (iIso3==+2) {
1118  // pi+ + 3pi0
1119  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 4,
1120  "pi+","pi0","pi0","pi0");
1121  decayTable->Insert(mode);
1122  // 2pi+ + pi- + pi0
1123  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 4,
1124  "pi+","pi+","pi-","pi0");
1125  decayTable->Insert(mode);
1126  } else if (iIso3==-2) {
1127  // pi- + 3pi0
1128  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 4,
1129  "pi-","pi0","pi0","pi0");
1130  decayTable->Insert(mode);
1131  // 2pi- + pi+ + pi0
1132  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 4,
1133  "pi-","pi-","pi+","pi0");
1134  decayTable->Insert(mode);
1135  }
1136  return decayTable;
1137 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 466 of file G4ExcitedMesonConstructor.cc.

469 {
470  G4VDecayChannel* mode;
471  //
472  if (iIso3 == +1) {
473  if (iType == TK) {
474  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
475  "kaon+","eta");
476  decayTable->Insert(mode);
477  }else if (iType==TAntiK) {
478  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
479  "anti_kaon0","eta");
480  decayTable->Insert(mode);
481  }
482  } else if (iIso3 == -1) {
483  if (iType == TK) {
484  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
485  "kaon0","eta");
486  decayTable->Insert(mode);
487  }else if (iType==TAntiK) {
488  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
489  "kaon-","eta");
490  decayTable->Insert(mode);
491  }
492  }
493 
494  return decayTable;
495 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1289 of file G4ExcitedMesonConstructor.cc.

1292 {
1293  G4VDecayChannel* mode;
1294 
1295  if (iIso3==0) {
1296  // X(I=0,J=1)-->K + Anti-K*, Anti_K + K* mode
1297  // K+ + K*-
1298  mode = new G4PhaseSpaceDecayChannel(nameParent, br/4., 2,
1299  "kaon+","k_star-");
1300  decayTable->Insert(mode);
1301 
1302  // K- + K*+
1303  mode = new G4PhaseSpaceDecayChannel(nameParent, br/4., 2,
1304  "kaon-","k_star0");
1305  decayTable->Insert(mode);
1306 
1307  // K0 + Anti_K*0
1308  mode = new G4PhaseSpaceDecayChannel(nameParent, br/4., 2,
1309  "kaon0","anti_k_star0");
1310  decayTable->Insert(mode);
1311 
1312  // Anti_K0 + K*0
1313  mode = new G4PhaseSpaceDecayChannel(nameParent, br/4., 2,
1314  "anti_kaon0","k_star0");
1315  decayTable->Insert(mode);
1316 
1317  } else if (iIso3==2) {
1318  // K+ + Anti_K*0
1319  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 2,
1320  "kaon+","anti_k_star0");
1321  decayTable->Insert(mode);
1322 
1323  // K0 + K*+
1324  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 2,
1325  "anti_kaon0","k_star+");
1326  decayTable->Insert(mode);
1327 
1328  } else if (iIso3==-2) {
1329  // K- + K*0
1330  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 2,
1331  "kaon-","k_star0");
1332  decayTable->Insert(mode);
1333 
1334  // K0 + K*-
1335  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 2,
1336  "kaon0","k_star-");
1337  decayTable->Insert(mode);
1338 
1339  }
1340 
1341  return decayTable;
1342 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 435 of file G4ExcitedMesonConstructor.cc.

438 {
439  G4VDecayChannel* mode;
440  //
441  if (iIso3 == +1) {
442  if (iType == TK) {
443  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
444  "kaon+","omega");
445  decayTable->Insert(mode);
446  }else if (iType==TAntiK) {
447  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
448  "anti_kaon0","omega");
449  decayTable->Insert(mode);
450  }
451  } else if (iIso3 == -1) {
452  if (iType == TK) {
453  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
454  "kaon0","omega");
455  decayTable->Insert(mode);
456  }else if (iType==TAntiK) {
457  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
458  "kaon-","omega");
459  decayTable->Insert(mode);
460  }
461  }
462 
463  return decayTable;
464 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 348 of file G4ExcitedMesonConstructor.cc.

351 {
352  G4VDecayChannel* mode;
353  //
354  if (iIso3 == +1) {
355  if (iType == TK) {
356  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
357  "kaon+","pi0");
358  decayTable->Insert(mode);
359  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
360  "kaon0","pi+");
361  decayTable->Insert(mode);
362  }else if (iType==TAntiK) {
363  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
364  "anti_kaon0","pi0");
365  decayTable->Insert(mode);
366  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
367  "kaon-","pi+");
368  decayTable->Insert(mode);
369  }
370  } else if (iIso3 == -1) {
371  if (iType == TK) {
372  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
373  "kaon0","pi0");
374  decayTable->Insert(mode);
375  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
376  "kaon+","pi-");
377  decayTable->Insert(mode);
378 
379  }else if (iType==TAntiK) {
380  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
381  "kaon-","pi0");
382  decayTable->Insert(mode);
383  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
384  "anti_kaon0","pi-");
385  decayTable->Insert(mode);
386  }
387  }
388 
389  return decayTable;
390 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 497 of file G4ExcitedMesonConstructor.cc.

500 {
501  G4VDecayChannel* mode;
502  //
503  if (iIso3 == +1) {
504  if (iType == TK) {
505  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
506  "kaon+","rho0");
507  decayTable->Insert(mode);
508  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
509  "kaon0","rho+");
510  decayTable->Insert(mode);
511  }else if (iType==TAntiK) {
512  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
513  "anti_kaon0","rho0");
514  decayTable->Insert(mode);
515  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
516  "kaon-","rho+");
517  decayTable->Insert(mode);
518  }
519  } else if (iIso3 == -1) {
520  if (iType == TK) {
521  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
522  "kaon0","rho0");
523  decayTable->Insert(mode);
524  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
525  "kaon+","rho-");
526  decayTable->Insert(mode);
527 
528  }else if (iType==TAntiK) {
529  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
530  "kaon-","rho0");
531  decayTable->Insert(mode);
532  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
533  "anti_kaon0","rho-");
534  decayTable->Insert(mode);
535  }
536  }
537 
538  return decayTable;
539 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 585 of file G4ExcitedMesonConstructor.cc.

588 {
589  // K* --> K pipi(I=1)
590  G4VDecayChannel* mode;
591  //
592  if (iIso3 == +1) {
593  if (iType == TK) {
594  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
595  "k_star+","pi+","pi-");
596  decayTable->Insert(mode);
597  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
598  "k_star0","pi+","pi0");
599  decayTable->Insert(mode);
600  }else if (iType==TAntiK) {
601  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
602  "anti_k_star0","pi+","pi-");
603  decayTable->Insert(mode);
604  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
605  "k_star-","pi+","pi0");
606  decayTable->Insert(mode);
607  }
608  } else if (iIso3 == -1) {
609  if (iType == TK) {
610  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
611  "k_star0","pi+","pi-");
612  decayTable->Insert(mode);
613  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
614  "k_star+","pi-","pi0");
615  decayTable->Insert(mode);
616 
617  }else if (iType==TAntiK) {
618  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
619  "k_star-","pi+","pi-");
620  decayTable->Insert(mode);
621  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
622  "anti_k_star0","pi-","pi0");
623  decayTable->Insert(mode);
624  }
625  }
626 
627  return decayTable;
628 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 541 of file G4ExcitedMesonConstructor.cc.

544 {
545  G4VDecayChannel* mode;
546  //
547  if (iIso3 == +1) {
548  if (iType == TK) {
549  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
550  "k_star+","pi0");
551  decayTable->Insert(mode);
552  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
553  "k_star0","pi+");
554  decayTable->Insert(mode);
555  }else if (iType==TAntiK) {
556  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
557  "anti_k_star0","pi0");
558  decayTable->Insert(mode);
559  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
560  "k_star-","pi+");
561  decayTable->Insert(mode);
562  }
563  } else if (iIso3 == -1) {
564  if (iType == TK) {
565  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
566  "k_star0","pi0");
567  decayTable->Insert(mode);
568  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
569  "k_star+","pi-");
570  decayTable->Insert(mode);
571 
572  }else if (iType==TAntiK) {
573  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
574  "k_star-","pi0");
575  decayTable->Insert(mode);
576  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
577  "anti_k_star0","pi-");
578  decayTable->Insert(mode);
579  }
580  }
581 
582  return decayTable;
583 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 391 of file G4ExcitedMesonConstructor.cc.

394 {
395  G4VDecayChannel* mode;
396  //
397  if (iIso3 == +1) {
398  if (iType == TK) {
399  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
400  "k2_star(1430)+","pi0");
401  decayTable->Insert(mode);
402  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
403  "k2_star(1430)0","pi+");
404  decayTable->Insert(mode);
405  }else if (iType==TAntiK) {
406  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
407  "anti_k2_star(1430)0","pi0");
408  decayTable->Insert(mode);
409  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
410  "k2_star(1430)-","pi+");
411  decayTable->Insert(mode);
412  }
413  } else if (iIso3 == -1) {
414  if (iType == TK) {
415  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
416  "k2_star(1430)0","pi0");
417  decayTable->Insert(mode);
418  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
419  "k2_star(1430)+","pi-");
420  decayTable->Insert(mode);
421 
422  }else if (iType==TAntiK) {
423  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
424  "k2_star(1430)-","pi0");
425  decayTable->Insert(mode);
426  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
427  "anti_k2_star(1430)0","pi-");
428  decayTable->Insert(mode);
429  }
430  }
431 
432  return decayTable;
433 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 970 of file G4ExcitedMesonConstructor.cc.

973 {
974  G4VDecayChannel* mode;
975 
976  G4String daughterPi;
977  G4String daughterA2;
978  G4double r;
979 
980  // I = 0 states
981  if (iIso==0) {
982  if (iIso3==0) {
983  // pi+ + a2(1320)-
984  daughterPi = "pi+";
985  daughterA2 = "a2(1320)-";
986  r = br/3.;
987  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
988  daughterPi,daughterA2);
989  decayTable->Insert(mode);
990 
991  // pi0 + a2(1320)0
992  daughterPi = "pi0";
993  daughterA2 = "a2(1320)0";
994  r = br*1./3.;
995  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
996  daughterPi,daughterA2);
997  decayTable->Insert(mode);
998 
999  // pi- + a2(1320)+
1000  daughterPi = "pi-";
1001  daughterA2 = "a2(1320)+";
1002  r = br*1./3.;
1003  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
1004  daughterPi,daughterA2);
1005  decayTable->Insert(mode);
1006  }
1007  } else if (iIso==2) {
1008  if (iIso3==+2) {
1009  // pi+ + a2(1320)0
1010  daughterPi = "pi+";
1011  daughterA2 = "a2(1320)0";
1012  r = br/2.;
1013  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
1014  daughterPi,daughterA2);
1015  decayTable->Insert(mode);
1016 
1017  // pi0 + a2(1320)+
1018  daughterPi = "pi0";
1019  daughterA2 = "a2(1320)+";
1020  r = br/2.;
1021  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
1022  daughterPi,daughterA2);
1023  decayTable->Insert(mode);
1024  } else if (iIso3==0) {
1025  // pi+ + a2(1320)-
1026  daughterPi = "pi+";
1027  daughterA2 = "a2(1320)-";
1028  r = br/2.;
1029  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
1030  daughterPi,daughterA2);
1031  decayTable->Insert(mode);
1032 
1033  // pi- + a2(1320)+
1034  daughterPi = "pi-";
1035  daughterA2 = "a2(1320)+";
1036  r = br/2.;
1037  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
1038  daughterPi,daughterA2);
1039  decayTable->Insert(mode);
1040  } else if (iIso3==-2) {
1041  // pi- + a2(1320)0
1042  daughterPi = "pi-";
1043  daughterA2 = "a2(1320)0";
1044  r = br/2.;
1045  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
1046  daughterPi,daughterA2);
1047  decayTable->Insert(mode);
1048 
1049  // pi0 + a2(1320)-
1050  daughterPi = "pi0";
1051  daughterA2 = "a2(1320)-";
1052  r = br/2.;
1053  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
1054  daughterPi,daughterA2);
1055  decayTable->Insert(mode);
1056  }
1057  }
1058  return decayTable;
1059 }
double G4double
Definition: G4Types.hh:76

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 711 of file G4ExcitedMesonConstructor.cc.

714 {
715  if ((iIso!=2)&&(iIso!=0)) return decayTable;
716 
717  G4VDecayChannel* mode;
718  //
719  G4String daughter;
720  if (iIso3 == +2) {
721  daughter = "pi+";
722  } else if (iIso3 == 0) {
723  daughter = "pi0";
724  } else if (iIso3 ==-2) {
725  daughter = "pi-";
726  } else {
727  return decayTable;
728  }
729  // create decay channel [parent BR #daughters]
730  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
731  daughter,"eta");
732  // add decay table
733  decayTable->Insert(mode);
734 
735  return decayTable;
736 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 792 of file G4ExcitedMesonConstructor.cc.

795 {
796  if ((iIso!=2)&&(iIso!=0)) return decayTable;
797 
798  G4VDecayChannel* mode;
799  //
800  G4String daughter;
801  if (iIso3 == +2) {
802  daughter = "pi+";
803  } else if (iIso3 == 0) {
804  daughter = "pi0";
805  } else if (iIso3 ==-2) {
806  daughter = "pi-";
807  } else {
808  return decayTable;
809  }
810  // create decay channel [parent BR #daughters]
811  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
812  daughter,"f0(1370)");
813  // add decay table
814  decayTable->Insert(mode);
815  return decayTable;
816 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 765 of file G4ExcitedMesonConstructor.cc.

768 {
769  if ((iIso!=2)&&(iIso!=0)) return decayTable;
770 
771  G4VDecayChannel* mode;
772  //
773  G4String daughter;
774  if (iIso3 == +2) {
775  daughter = "pi+";
776  } else if (iIso3 == 0) {
777  daughter = "pi0";
778  } else if (iIso3 ==-2) {
779  daughter = "pi-";
780  } else {
781  return decayTable;
782  }
783  // create decay channel [parent BR #daughters]
784  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
785  daughter,"f2(1270)");
786  // add decay table
787  decayTable->Insert(mode);
788 
789  return decayTable;
790 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 630 of file G4ExcitedMesonConstructor.cc.

633 {
634  if ((iIso!=2)&&(iIso!=0)) return decayTable;
635 
636  G4VDecayChannel* mode;
637  //
638  G4String daughter;
639  if (iIso3 == +2) {
640  daughter = "pi+";
641  } else if (iIso3 == 0) {
642  daughter = "pi0";
643  } else if (iIso3 ==-2) {
644  daughter = "pi-";
645  } else {
646  return decayTable;
647  }
648  // create decay channel [parent BR #daughters]
649  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
650  daughter,"gamma");
651  // add decay table
652  decayTable->Insert(mode);
653 
654  return decayTable;
655 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 657 of file G4ExcitedMesonConstructor.cc.

660 {
661  if ((iIso!=2)&&(iIso!=0)) return decayTable;
662 
663  G4VDecayChannel* mode;
664  //
665  G4String daughter;
666  if (iIso3 == +2) {
667  daughter = "pi+";
668  } else if (iIso3 == 0) {
669  daughter = "pi0";
670  } else if (iIso3 ==-2) {
671  daughter = "pi-";
672  } else {
673  return decayTable;
674  }
675  // create decay channel [parent BR #daughters]
676  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
677  daughter,"omega");
678  // add decay table
679  decayTable->Insert(mode);
680 
681  return decayTable;
682 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 879 of file G4ExcitedMesonConstructor.cc.

882 {
883  G4VDecayChannel* mode;
884 
885  G4String daughterPi;
886  G4String daughterRho;
887  G4double r;
888 
889  // I = 0 states
890  if (iIso==0) {
891  if (iIso3==0) {
892  // pi+ + rho-
893  daughterPi = "pi+";
894  daughterRho = "rho-";
895  r = br/3.;
896  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
897  daughterPi,daughterRho);
898  decayTable->Insert(mode);
899 
900  // pi0 + rho0
901  daughterPi = "pi0";
902  daughterRho = "rho0";
903  r = br*1./3.;
904  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
905  daughterPi,daughterRho);
906  decayTable->Insert(mode);
907 
908  // pi- + rho+
909  daughterPi = "pi-";
910  daughterRho = "rho+";
911  r = br*1./3.;
912  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
913  daughterPi,daughterRho);
914  decayTable->Insert(mode);
915  }
916  } else if (iIso==2) {
917  if (iIso3==+2) {
918  // pi+ + rho0
919  daughterPi = "pi+";
920  daughterRho = "rho0";
921  r = br/2.;
922  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
923  daughterPi,daughterRho);
924  decayTable->Insert(mode);
925 
926  // pi0 + rho+
927  daughterPi = "pi0";
928  daughterRho = "rho+";
929  r = br/2.;
930  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
931  daughterPi,daughterRho);
932  decayTable->Insert(mode);
933  } else if (iIso3==0) {
934  // pi+ + rho-
935  daughterPi = "pi+";
936  daughterRho = "rho-";
937  r = br/2.;
938  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
939  daughterPi,daughterRho);
940  decayTable->Insert(mode);
941 
942  // pi- + rho+
943  daughterPi = "pi-";
944  daughterRho = "rho+";
945  r = br/2.;
946  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
947  daughterPi,daughterRho);
948  decayTable->Insert(mode);
949  } else if (iIso3==-2) {
950  // pi- + rho0
951  daughterPi = "pi-";
952  daughterRho = "rho0";
953  r = br/2.;
954  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
955  daughterPi,daughterRho);
956  decayTable->Insert(mode);
957 
958  // pi0 + rho-
959  daughterPi = "pi0";
960  daughterRho = "rho-";
961  r = br/2.;
962  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
963  daughterPi,daughterRho);
964  decayTable->Insert(mode);
965  }
966  }
967  return decayTable;
968 }
double G4double
Definition: G4Types.hh:76

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 738 of file G4ExcitedMesonConstructor.cc.

741 {
742  if ((iIso!=2)&&(iIso!=0)) return decayTable;
743 
744  G4VDecayChannel* mode;
745  //
746  G4String daughter;
747  if (iIso3 == +2) {
748  daughter = "rho+";
749  } else if (iIso3 == 0) {
750  daughter = "rho0";
751  } else if (iIso3 ==-2) {
752  daughter = "rho-";
753  } else {
754  return decayTable;
755  }
756  // create decay channel [parent BR #daughters]
757  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
758  daughter,"eta");
759  // add decay table
760  decayTable->Insert(mode);
761 
762  return decayTable;
763 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 684 of file G4ExcitedMesonConstructor.cc.

687 {
688  if ((iIso!=2)&&(iIso!=0)) return decayTable;
689 
690  G4VDecayChannel* mode;
691  //
692  G4String daughter;
693  if (iIso3 == +2) {
694  daughter = "rho+";
695  } else if (iIso3 == 0) {
696  daughter = "rho0";
697  } else if (iIso3 ==-2) {
698  daughter = "rho-";
699  } else {
700  return decayTable;
701  }
702  // create decay channel [parent BR #daughters]
703  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
704  daughter,"gamma");
705  // add decay table
706  decayTable->Insert(mode);
707 
708  return decayTable;
709 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 57 of file G4ExcitedMesonConstructor.cc.

58 {
59  G4int iType;
60  if (idx < 0 ) {
61  for (G4int state=0; state< NMultiplets; state +=1) {
62  for (iType = 0; iType < NMesonTypes ; iType++)
63  ConstructMesons(state, iType);
64  }
65  } else if (idx < NMultiplets ) {
66  for (iType = 0; iType < NMesonTypes ; iType++)
67  ConstructMesons(idx, iType);
68  } else {
69 #ifdef G4VERBOSE
70  if (G4ParticleTable::GetParticleTable()->GetVerboseLevel()>1) {
71  G4cerr << "G4ExcitedMesonConstructor::Construct()";
72  G4cerr << " illegal index os state = " << idx << G4endl;
73  }
74 #endif
75  }
76 }
void ConstructMesons(G4int indexOfState, G4int indexOfType)
int G4int
Definition: G4Types.hh:78
static G4ParticleTable * GetParticleTable()
#define G4endl
Definition: G4ios.hh:61
G4GLOB_DLL std::ostream G4cerr

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 92 of file G4ExcitedMesonConstructor.cc.

93 {
94  if (!Exist(iState, iType) ) return;
95 
96  // Construct Resonace particles as dynamic object
97  // Arguments for constructor are as follows
98  // name mass width
99  // charge 2*spin
100  // parity C-conjugation
101  // 2*Isospin 2*Isospin3
102  // G-parity
103  // type lepton number Baryon number
104  // PDG encoding
105  // stable lifetime decay table
106 
107 
108  G4String aName;
109  G4ExcitedMesons* particle;
110 
111  for ( G4int iIso3=(-1)*iIsoSpin[iType]; iIso3<=iIsoSpin[iType]; iIso3+=2) {
112  aName= GetName(iIso3, iState, iType);
113  G4double fmass = mass[iState][iType];
114  G4double fwidth = width[iState][iType];
115  if ( (iType== TK) || (iType==TAntiK ) ) {
116  if ( GetCharge(iIso3,iType) == 0.0) {
117  fmass += massKdiff[iState];
118  fwidth += widthKdiff[iState];
119  }
120  }
121  particle = new G4ExcitedMesons(
122  aName, fmass, fwidth,
123  GetCharge(iIso3,iType), iSpin[iState],
124  iParity[iState], iChargeConjugation[iState],
125  iIsoSpin[iType], iIso3,
126  iGParity[iState][iType],
128  GetEncoding(iIso3, iState, iType),
129  false, 0.0, NULL
130  );
131 
132  if ( (iType==TEta) || (iType==TEtaPrime) || ((iType==TPi)&&(iIso3==0)) ) {
133  // set same encoding for AntiParticle
134  particle->SetAntiPDGEncoding(GetEncoding(iIso3, iState, iType));
135  }
136  particle->SetMultipletName(name[iState][iType]);
137  particle->SetDecayTable(CreateDecayTable( aName, iIso3, iState, iType));
138  }
139 }
G4int GetEncoding(G4int iIsoSpin3, G4int idxState, G4int idxType)
void SetDecayTable(G4DecayTable *aDecayTable)
const XML_Char * name
Definition: expat.h:151
void SetAntiPDGEncoding(G4int aEncoding)
void SetMultipletName(const G4String &)
G4DecayTable * CreateDecayTable(const G4String &, G4int, G4int, G4int)
static const G4double mass[NMultiplets][NMesonTypes]
static const G4int iIsoSpin[NMesonTypes]
G4String GetName(G4int iIso3, G4int iState, G4int idxType)
int G4int
Definition: G4Types.hh:78
G4double GetCharge(G4int iIsoSpin3)
static const G4int iParity[NMultiplets]
static const G4double massKdiff[NMultiplets]
static const G4int iGParity[NMultiplets][NMesonTypes]
static const G4int iSpin[NMultiplets]
G4bool Exist(G4int idxState, G4int idxType)
double G4double
Definition: G4Types.hh:76
static const G4int iChargeConjugation[NMultiplets]
static const G4double width[NMultiplets][NMesonTypes]
static const G4double widthKdiff[NMultiplets]

Here is the call graph for this function:

Here is the caller graph for this function:

G4DecayTable * G4ExcitedMesonConstructor::CreateDecayTable ( const G4String parentName,
G4int  iIso3,
G4int  iState,
G4int  iType 
)
protected

Definition at line 251 of file G4ExcitedMesonConstructor.cc.

256 {
257  // create decay table
258  G4DecayTable* decayTable = new G4DecayTable();
259  G4double br;
260 
261  if ((iType==TK)||(iType==TAntiK)) {
262 
263  if ( (br=bRatio[iState][iType][MKPi]) >0.0) {
264  AddKPiMode( decayTable, parentName, br, iIso3, iType );
265  }
266  if ( (br=bRatio[iState][iType][MKStarPi]) >0.0) {
267  AddKStarPiMode( decayTable, parentName, br, iIso3, iType );
268  }
269  if ( (br=bRatio[iState][iType][MKRho]) >0.0) {
270  AddKRhoMode( decayTable, parentName, br, iIso3, iType );
271  }
272  if ( (br=bRatio[iState][iType][MKOmega]) >0.0) {
273  AddKOmegaMode( decayTable, parentName, br, iIso3, iType );
274  }
275  if ( (br=bRatio[iState][iType][MKStar2Pi]) >0.0) {
276  AddKStar2PiMode( decayTable, parentName, br, iIso3, iType );
277  }
278  if ( (br=bRatio[iState][iType][MKTwoPi]) >0.0) {
279  AddKTwoPiMode( decayTable, parentName, br, iIso3, iType );
280  }
281  if ( (br=bRatio[iState][iType][MKEta]) >0.0) {
282  AddKEtaMode( decayTable, parentName, br, iIso3, iType );
283  }
284 
285  } else {
286  if ( (br=bRatio[iState][iType][MPiGamma]) >0.0) {
287  AddPiGammaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
288  }
289  if ( (br=bRatio[iState][iType][MRhoGamma]) >0.0) {
290  AddRhoGammaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
291  }
292  if ( (br=bRatio[iState][iType][M2Pi]) >0.0) {
293  Add2PiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
294  }
295  if ( (br=bRatio[iState][iType][MPiRho]) >0.0) {
296  AddPiRhoMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
297  }
298  if ( (br=bRatio[iState][iType][MPiEta]) >0.0) {
299  AddPiEtaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
300  }
301  if ( (br=bRatio[iState][iType][M3Pi]) >0.0) {
302  Add3PiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
303  }
304  if ( (br=bRatio[iState][iType][M4Pi]) >0.0) {
305  Add4PiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
306  }
307  if ( (br=bRatio[iState][iType][MKKStar]) >0.0) {
308  AddKKStarMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
309  }
310  if ( (br=bRatio[iState][iType][M2PiEta]) >0.0) {
311  Add2PiEtaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
312  }
313  if ( (br=bRatio[iState][iType][MRhoEta]) >0.0) {
314  AddRhoEtaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
315  }
316  if ( (br=bRatio[iState][iType][M2PiRho]) >0.0) {
317  Add2PiRhoMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
318  }
319  if ( (br=bRatio[iState][iType][M2PiOmega]) >0.0) {
320  Add2PiOmegaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
321  }
322  if ( (br=bRatio[iState][iType][M2Eta]) >0.0) {
323  Add2EtaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
324  }
325  if ( (br=bRatio[iState][iType][M2K]) >0.0) {
326  Add2KMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
327  }
328  if ( (br=bRatio[iState][iType][M2KPi]) >0.0) {
329  Add2KPiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
330  }
331  if ( (br=bRatio[iState][iType][MPiOmega]) >0.0) {
332  AddPiOmegaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
333  }
334  if ( (br=bRatio[iState][iType][MPiF2]) >0.0) {
335  AddPiF2Mode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
336  }
337  if ( (br=bRatio[iState][iType][MPiF0]) >0.0) {
338  AddPiF0Mode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
339  }
340  if ( (br=bRatio[iState][iType][MPiA2]) >0.0) {
341  AddPiA2Mode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
342  }
343  }
344 
345  return decayTable;
346 }
G4DecayTable * Add2PiOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTable * AddKStarPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
G4DecayTable * Add2PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTable * AddKOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
G4DecayTable * AddPiEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
static const G4int iIsoSpin[NMesonTypes]
G4DecayTable * AddKEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
G4DecayTable * AddRhoGammaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTable * Add4PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTable * Add2PiEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTable * AddKPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
G4DecayTable * AddKTwoPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
G4DecayTable * Add2KPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTable * Add2EtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTable * AddPiF0Mode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTable * AddKStar2PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
G4DecayTable * AddKRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
G4DecayTable * AddPiA2Mode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTable * AddPiGammaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTable * Add3PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTable * Add2PiRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTable * Add2KMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTable * AddPiF2Mode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTable * AddPiOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
G4DecayTable * AddPiRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes]
G4DecayTable * AddRhoEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
double G4double
Definition: G4Types.hh:76
G4DecayTable * AddKKStarMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 78 of file G4ExcitedMesonConstructor.cc.

79 {
80  G4bool value = true;
81  if ( idxType == TEtaPrime ) {
82  if (idxState==N13P0) value = false;
83  if (idxState==N13D1) value = false;
84  } else if ( idxType == TPi ) {
85  if (idxState==N23P2) value = false;
86  }
87  return value;
88 }
const XML_Char int const XML_Char * value
Definition: expat.h:331
bool G4bool
Definition: G4Types.hh:79

Here is the caller graph for this function:

G4double G4ExcitedMesonConstructor::GetCharge ( G4int  iIsoSpin3)
protected

Here is the caller graph for this function:

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

Definition at line 187 of file G4ExcitedMesonConstructor.cc.

188 {
189  static const G4double quark_charge[7] =
190  {
191  0., -1./3., +2./3., -1./3., +2./3., -1./3., +2./3.
192  };
193 
194  G4double charge = quark_charge[GetQuarkContents(0, iIsoSpin3, idxType)]*eplus;
195  charge -= quark_charge[GetQuarkContents(1, iIsoSpin3, idxType)]*eplus;
196  return charge;
197 }
G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType)
static constexpr double eplus
Definition: G4SIunits.hh:199
double G4double
Definition: G4Types.hh:76

Here is the call graph for this function:

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

Definition at line 199 of file G4ExcitedMesonConstructor.cc.

202 {
203  G4int encoding = encodingOffset[idxState];
204  encoding += iSpin[idxState] +1;
205  G4int iQ = 0;
206  G4int iQbar = 1;
207 
208  if ( idxType == TPi ) {
209  if (iIsoSpin3<0) {
210  iQ = 1;
211  iQbar = 0;
212  }
213  } else if ( idxType == TK ) {
214  iQ = 1;
215  iQbar = 0;
216  }
217 
218 
219  encoding += 100*GetQuarkContents(iQ, iIsoSpin3, idxType);
220  encoding += 10*GetQuarkContents(iQbar, iIsoSpin3, idxType);
221  if ( idxType == TPi ) {
222  if (iIsoSpin3<0) {
223  encoding *= -1;
224  }
225  } else if ( idxType == TAntiK ) {
226  encoding *= -1;
227  }
228 
229 // PDG2005
230 //
231  if (idxState == 9 ) {
232  if (idxType == TEta) {
233 // f2(1810) 9030225
234  encoding = 9030225;
235  } else if (idxType == TEtaPrime) {
236 // f2(2010) 9060225
237  encoding = 9060225;
238  }
239  }
240 
241 // PDG2013
242  if (idxState == 1 ) {
243  if (idxType == TEta) {
244 // f0(1370) 30221
245  encoding = 30221;
246  }
247  }
248  return encoding;
249 }
G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType)
const XML_Char const XML_Char * encoding
Definition: expat.h:187
int G4int
Definition: G4Types.hh:78
static const G4int iSpin[NMultiplets]
static const G4int encodingOffset[NMultiplets]

Here is the call graph for this function:

Here is the caller graph for this function:

G4String G4ExcitedMesonConstructor::GetName ( G4int  iIso3,
G4int  iState,
G4int  idxType 
)
inlineprotected

Definition at line 178 of file G4ExcitedMesonConstructor.hh.

181 {
182  G4String particle = name[iState][iType];
183  if (iType == TPi) {
184  if ( iIso3 == +2 ){
185  particle += "+";
186  } else if ( iIso3 == -2 ){
187  particle += "-";
188  } else {
189  particle += "0";
190  }
191  } else if (iType == TK) {
192  if ( iIso3 == +1 ){
193  particle += "+";
194  } else if ( iIso3 == -1 ){
195  particle += "0";
196  }
197  } else if (iType == TAntiK) {
198  if ( iIso3 == +1 ){
199  particle += "0";
200  particle = "anti_" + particle;
201  } else if ( iIso3 == -1 ){
202  particle += "-";
203  }
204  }
205  return particle;
206 }
const XML_Char * name
Definition: expat.h:151

Here is the caller graph for this function:

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

Definition at line 142 of file G4ExcitedMesonConstructor.cc.

145 {
146  // Quark contents
147 
148  G4int quark=0;
149  if (iType == TPi) {
150  if ( iIso3 == 2 ){
151  if ( iQ == 0 ){ quark = 2; }
152  else { quark = 1; }
153  } else if ( iIso3 == 0 ){
154  quark = 1;
155  } else if ( iIso3 == -2 ){
156  if ( iQ == 0 ){ quark = 1; }
157  else { quark = 2; }
158  }
159  } else if (iType == TEta) {
160  quark = 2;
161 
162  } else if (iType == TEtaPrime) {
163  quark = 3;
164 
165  } else if (iType == TAntiK) {
166  if ( iIso3 == 1 ){
167  if ( iQ == 0 ){ quark = 3; }
168  else { quark = 1; }
169  } else if ( iIso3 == -1 ){
170  if ( iQ == 0 ){ quark = 3; }
171  else { quark = 2; }
172  }
173 
174  } else if (iType == TK) {
175  if ( iIso3 == 1 ){
176  if ( iQ == 0 ){ quark = 2; }
177  else { quark = 3; }
178  } else if ( iIso3 == -1 ){
179  if ( iQ == 0 ){ quark = 1; }
180  else { quark = 3; }
181  }
182 
183  }
184  return quark;
185 }
int G4int
Definition: G4Types.hh:78

Here is the caller graph for this function:

Member Data Documentation

const G4int G4ExcitedMesonConstructor::baryonNumber
protected

Definition at line 86 of file G4ExcitedMesonConstructor.hh.

const G4double G4ExcitedMesonConstructor::bRatio
staticprotected

Definition at line 114 of file G4ExcitedMesonConstructor.hh.

const G4int G4ExcitedMesonConstructor::encodingOffset
staticprotected
Initial value:
=
{ 10000, 10000, 20000, 0, 10000, 30000, 0, 100000,100000,100000}

Definition at line 100 of file G4ExcitedMesonConstructor.hh.

const G4int G4ExcitedMesonConstructor::iChargeConjugation
staticprotected
Initial value:
=
{
-1, +1, +1, +1, +1, -1, -1, +1, -1, +1
}

Definition at line 99 of file G4ExcitedMesonConstructor.hh.

const G4int G4ExcitedMesonConstructor::iGParity
staticprotected
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.

const G4int G4ExcitedMesonConstructor::iIsoSpin
staticprotected
Initial value:
=
{
2, 0, 0, 1, 1
}

Definition at line 95 of file G4ExcitedMesonConstructor.hh.

const G4int G4ExcitedMesonConstructor::iParity
staticprotected
Initial value:
=
{
+1, +1, +1, +1, -1, -1, -1, -1, -1, +1
}

Definition at line 97 of file G4ExcitedMesonConstructor.hh.

const G4int G4ExcitedMesonConstructor::iSpin
staticprotected
Initial value:
=
{
2, 0, 2, 4, 4, 2, 6, 0, 2, 4
}

Definition at line 96 of file G4ExcitedMesonConstructor.hh.

const G4int G4ExcitedMesonConstructor::leptonNumber
protected

Definition at line 85 of file G4ExcitedMesonConstructor.hh.

const G4double G4ExcitedMesonConstructor::mass
staticprotected
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.2819*GeV,1.4264*GeV, 1.403*GeV, 1.403*GeV },
{ 1.3183*GeV,1.2755*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.

const G4double G4ExcitedMesonConstructor::massKdiff
staticprotected
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.

const char * G4ExcitedMesonConstructor::name
staticprotected
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.

const G4String G4ExcitedMesonConstructor::type
protected

Definition at line 84 of file G4ExcitedMesonConstructor.hh.

const G4double G4ExcitedMesonConstructor::width
staticprotected
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.2*MeV, 54.9*MeV, 174.0*MeV, 174.0*MeV },
{ 107.0*MeV, 186.7*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.

const G4double G4ExcitedMesonConstructor::widthKdiff
staticprotected
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.


The documentation for this class was generated from the following files: