Geant4.10
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Types | Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes
G4ExcitedMesonConstructor Class Reference

#include <G4ExcitedMesonConstructor.hh>

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)
 
G4DecayTable * CreateDecayTable (const G4String &, G4int, G4int, G4int)
 
G4DecayTable * AddKPiMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
 
G4DecayTable * AddKStarPiMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
 
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 * AddKTwoPiMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
 
G4DecayTable * AddKOmegaMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
 
G4DecayTable * AddKEtaMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
 
G4DecayTable * AddPiGammaMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
 
G4DecayTable * AddRhoGammaMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
 
G4DecayTable * Add2PiMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
 
G4DecayTable * AddPiRhoMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
 
G4DecayTable * AddPiEtaMode (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 * AddPiF0Mode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
 
G4DecayTable * AddPiA2Mode (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 * Add4PiMode (G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
 
G4DecayTable * AddKKStarMode (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 * AddRhoEtaMode (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 * Add2PiOmegaMode (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 * Add2EtaMode (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 * Add2KPiMode (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.

70 { NMultiplets = 10 };
anonymous enum
protected
Enumerator
N11P1 
N13P0 
N13P1 
N13P2 
N11D2 
N13D1 
N13D3 
N21S0 
N23S1 
N23P2 

Definition at line 72 of file G4ExcitedMesonConstructor.hh.

72  {
73  N11P1 = 0, N13P0 = 1, N13P1 = 2, N13P2 = 3,
74  N11D2 = 4, N13D1 = 5, N13D3 = 6,
75  N21S0 = 7, N23S1 = 8, N23P2 = 9
76  };
anonymous enum
Enumerator
NMesonTypes 

Definition at line 79 of file G4ExcitedMesonConstructor.hh.

79 { NMesonTypes = 5 };
anonymous enum
protected
Enumerator
TPi 
TEta 
TEtaPrime 
TK 
TAntiK 

Definition at line 81 of file G4ExcitedMesonConstructor.hh.

81 { TPi=0, TEta=1, TEtaPrime=2, TK=3, TAntiK=4 };
anonymous enum
Enumerator
NumberOfDecayModes 

Definition at line 103 of file G4ExcitedMesonConstructor.hh.

103 { 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.

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 };
anonymous enum
protected
Enumerator
MKPi 
MKStarPi 
MKRho 
MKOmega 
MKStar2Pi 
MKTwoPi 
MKEta 

Definition at line 110 of file G4ExcitedMesonConstructor.hh.

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

Constructor & Destructor Documentation

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

Definition at line 47 of file G4ExcitedMesonConstructor.cc.

49  : type("meson"), leptonNumber(0), baryonNumber(0)
50 {
51 }
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 1151 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

1154 {
1155  if (iIso!=0) return decayTable;
1156 
1157  G4VDecayChannel* mode;
1158 
1159  // eta eta
1160  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
1161  "eta","eta");
1162  decayTable->Insert(mode);
1163  return decayTable;
1164 }
G4DecayTable * G4ExcitedMesonConstructor::Add2KMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iIso 
)
protected

Definition at line 1313 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

1316 {
1317  G4VDecayChannel* mode;
1318 
1319  if (iIso3==0) {
1320  // K+ + K-
1321  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 2,
1322  "kaon+","kaon-");
1323  decayTable->Insert(mode);
1324 
1325  // K0 + Anti_K0
1326  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 2,
1327  "kaon0","anti_kaon0");
1328  decayTable->Insert(mode);
1329  } else if (iIso3==+2) {
1330  // K+ + anti_K0
1331  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
1332  "kaon+","anti_kaon0");
1333  decayTable->Insert(mode);
1334  } else if (iIso3==-2) {
1335  // K- + K0
1336  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
1337  "kaon-","kaon0");
1338  decayTable->Insert(mode);
1339  }
1340 
1341  return decayTable;
1342 }
G4DecayTable * G4ExcitedMesonConstructor::Add2KPiMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iIso 
)
protected

Definition at line 1344 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

1347 {
1348 
1349  // X(I=0)-->KKpi
1350  if (iIso!=0) return decayTable;
1351 
1352  G4VDecayChannel* mode;
1353 
1354  // K+ + K- + pi0
1355  mode = new G4PhaseSpaceDecayChannel(nameParent, br/6., 3,
1356  "kaon+","kaon-","pi0");
1357  decayTable->Insert(mode);
1358 
1359  // K0 + Anti_K0 + pi0
1360  mode = new G4PhaseSpaceDecayChannel(nameParent, br/6., 3,
1361  "kaon0","anti_kaon0","pi0");
1362  decayTable->Insert(mode);
1363 
1364  // K+ + anti_K0 + pi-
1365  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1366  "kaon+","anti_kaon0","pi-");
1367  decayTable->Insert(mode);
1368 
1369  // K- + K0 + pi+
1370  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1371  "kaon-","kaon0","pi+");
1372  decayTable->Insert(mode);
1373 
1374 
1375  return decayTable;
1376 }
G4DecayTable * G4ExcitedMesonConstructor::Add2PiEtaMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iIso 
)
protected

Definition at line 1129 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

1132 {
1133  // f1-->eta + pi + pi mode
1134 
1135  if (iIso!=0) return decayTable;
1136 
1137  G4VDecayChannel* mode;
1138 
1139  // eta pi+ pi-
1140  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
1141  "eta","pi+","pi-");
1142  decayTable->Insert(mode);
1143 
1144  // eta pi+ pi-
1145  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1146  "eta","pi0","pi0");
1147  decayTable->Insert(mode);
1148  return decayTable;
1149 }
G4DecayTable * G4ExcitedMesonConstructor::Add2PiMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iIso 
)
protected

Definition at line 809 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

812 {
813  G4VDecayChannel* mode;
814 
815  G4String daughterPi1;
816  G4String daughterPi2;
817  G4double r;
818 
819  // I = 0 states
820  if (iIso==0) {
821  if (iIso3==0) {
822  // pi+ + pi-
823  daughterPi1 = "pi+";
824  daughterPi2 = "pi-";
825  r = br*2./3.;
826  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
827  daughterPi1,daughterPi2);
828  decayTable->Insert(mode);
829 
830  // pi0 + pi0
831  daughterPi1 = "pi0";
832  daughterPi2 = "pi0";
833  r = br*1./3.;
834  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
835  daughterPi1,daughterPi2);
836  decayTable->Insert(mode);
837  }
838  } else if (iIso==2) {
839  if (iIso3==+2) {
840  // pi+ + pi0
841  daughterPi1 = "pi+";
842  daughterPi2 = "pi0";
843  r = br;
844  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
845  daughterPi1,daughterPi2);
846  // add decay table
847  decayTable->Insert(mode);
848  } else if (iIso3==0) {
849  // pi+ + pi-
850  daughterPi1 = "pi+";
851  daughterPi2 = "pi-";
852  r = br;
853  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
854  daughterPi1,daughterPi2);
855  decayTable->Insert(mode);
856  } else if (iIso3==-2) {
857  // pi- + pi0
858  daughterPi1 = "pi-";
859  daughterPi2 = "pi0";
860  r = br;
861  mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
862  daughterPi1,daughterPi2);
863  decayTable->Insert(mode);
864  }
865  }
866  return decayTable;
867 }
G4double
double G4double
Definition: G4Types.hh:76
G4DecayTable * G4ExcitedMesonConstructor::Add2PiOmegaMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iIso 
)
protected

Definition at line 1166 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

1169 {
1170 
1171  G4VDecayChannel* mode;
1172  if (iIso==0) {
1173  // omega pi+ pi-
1174  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
1175  "omega","pi+","pi-");
1176  decayTable->Insert(mode);
1177 
1178  // omega pi+ pi-
1179  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1180  "omega","pi0","pi0");
1181  decayTable->Insert(mode);
1182  } else if (iIso==2) {
1183  if (iIso3==+2) {
1184  // omega pi+ pi0
1185  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 3,
1186  "omega","pi+","pi0");
1187  decayTable->Insert(mode);
1188  } else if (iIso3==0) {
1189  // omega pi+ pi-
1190  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 3,
1191  "omega","pi-","pi+");
1192  decayTable->Insert(mode);
1193  // omega pi0 pi0
1194  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 3,
1195  "omega","pi0","pi0");
1196  decayTable->Insert(mode);
1197  } else if (iIso3==-2) {
1198  // omega pi- pi0
1199  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 3,
1200  "omega","pi-","pi0");
1201  decayTable->Insert(mode);
1202  }
1203  }
1204  return decayTable;
1205 }
G4DecayTable * G4ExcitedMesonConstructor::Add2PiRhoMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iIso 
)
protected

Definition at line 1209 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

1212 {
1213  G4VDecayChannel* mode;
1214 
1215  if (iIso==0) {
1216  // f1 --> rho0 + pi+ pi-
1217  // rho0 pi+ pi-
1218  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1219  "rho0","pi+","pi-");
1220  decayTable->Insert(mode);
1221  } else if (iIso==2) {
1222  if (iIso3==+2) {
1223  // rho+ pi0 pi0
1224  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1225  "rho+","pi0","pi0");
1226  decayTable->Insert(mode);
1227  // rho+ pi+ pi-
1228  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1229  "rho+","pi+","pi-");
1230  decayTable->Insert(mode);
1231  // rho0 pi+ pi0
1232  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1233  "rho0","pi+","pi0");
1234  decayTable->Insert(mode);
1235  // rho- pi+ pi+
1236  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1237  "rho-","pi+","pi+");
1238  decayTable->Insert(mode);
1239  } else if (iIso3==-2) {
1240  // rho- pi0 pi0
1241  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1242  "rho-","pi0","pi0");
1243  decayTable->Insert(mode);
1244  // rho- pi+ pi-
1245  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1246  "rho-","pi+","pi-");
1247  decayTable->Insert(mode);
1248  // rho0 pi- pi0
1249  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1250  "rho0","pi-","pi0");
1251  decayTable->Insert(mode);
1252  // rho+ pi- pi-
1253  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1254  "rho+","pi-","pi-");
1255  decayTable->Insert(mode);
1256  } else if (iIso3==0) {
1257  // rho+ pi- pi0
1258  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1259  "rho+","pi-","pi0");
1260  decayTable->Insert(mode);
1261  // rho0 pi+ pi-
1262  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1263  "rho0","pi+","pi-");
1264  decayTable->Insert(mode);
1265  // rho0 pi0 pi0
1266  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1267  "rho0","pi0","pi0");
1268  decayTable->Insert(mode);
1269  // rho- pi+ pi0
1270  mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1271  "rho-","pi+","pi-");
1272  decayTable->Insert(mode);
1273  }
1274  }
1275  return decayTable;
1276 }
G4DecayTable * G4ExcitedMesonConstructor::Add3PiMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iIso 
)
protected

Definition at line 1051 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

1054 {
1055  G4VDecayChannel* mode;
1056 
1057  // I =0 state
1058  // This mode is X(I=0,J=1) --> pi+,pi-,pi0 mode
1059  if (iIso==0) {
1060  // pi+ + pi-
1061  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 3,
1062  "pi+","pi-","pi0");
1063  decayTable->Insert(mode);
1064  } else if (iIso==2) {
1065  // This mode is X(I=1) --> pi + pipi(I=0) mode
1066  if (iIso3==+2) {
1067  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1068  "pi+","pi0","pi0");
1069  decayTable->Insert(mode);
1070  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
1071  "pi+","pi+","pi-");
1072  decayTable->Insert(mode);
1073  } else if (iIso3==0) {
1074  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1075  "pi0","pi0","pi0");
1076  decayTable->Insert(mode);
1077  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
1078  "pi0","pi+","pi-");
1079  decayTable->Insert(mode);
1080  } else if (iIso3==-2) {
1081  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1082  "pi-","pi0","pi0");
1083  decayTable->Insert(mode);
1084  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
1085  "pi-","pi+","pi-");
1086  decayTable->Insert(mode);
1087  }
1088  }
1089  return decayTable;
1090 }
G4DecayTable * G4ExcitedMesonConstructor::Add4PiMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iIso 
)
protected

Definition at line 1092 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

1095 {
1096  G4VDecayChannel* mode;
1097 
1098  if (iIso3==0) {
1099  // 2pi+ + 2pi-
1100  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 4,
1101  "pi+","pi-","pi+","pi-");
1102  decayTable->Insert(mode);
1103  // pi+ + pi- + 2pi0
1104  mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 4,
1105  "pi+","pi-","pi0","pi0");
1106  decayTable->Insert(mode);
1107  } else if (iIso3==+2) {
1108  // pi+ + 3pi0
1109  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 4,
1110  "pi+","pi0","pi0","pi0");
1111  decayTable->Insert(mode);
1112  // 2pi+ + pi- + pi0
1113  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 4,
1114  "pi+","pi+","pi-","pi0");
1115  decayTable->Insert(mode);
1116  } else if (iIso3==-2) {
1117  // pi- + 3pi0
1118  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 4,
1119  "pi-","pi0","pi0","pi0");
1120  decayTable->Insert(mode);
1121  // 2pi- + pi+ + pi0
1122  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 4,
1123  "pi-","pi-","pi+","pi0");
1124  decayTable->Insert(mode);
1125  }
1126  return decayTable;
1127 }
G4DecayTable * G4ExcitedMesonConstructor::AddKEtaMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iType 
)
protected

Definition at line 456 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

459 {
460  G4VDecayChannel* mode;
461  //
462  if (iIso3 == +1) {
463  if (iType == TK) {
464  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
465  "kaon+","eta");
466  decayTable->Insert(mode);
467  }else if (iType==TAntiK) {
468  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
469  "anti_kaon0","eta");
470  decayTable->Insert(mode);
471  }
472  } else if (iIso3 == -1) {
473  if (iType == TK) {
474  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
475  "kaon0","eta");
476  decayTable->Insert(mode);
477  }else if (iType==TAntiK) {
478  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
479  "kaon-","eta");
480  decayTable->Insert(mode);
481  }
482  }
483 
484  return decayTable;
485 }
G4DecayTable * G4ExcitedMesonConstructor::AddKKStarMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iIso 
)
protected

Definition at line 1279 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

1282 {
1283  // X(I=0,J=1)-->K + Anti-K*, Anti_K + K* mode
1284 
1285  if (iIso!=0) return decayTable;
1286 
1287  G4VDecayChannel* mode;
1288 
1289  // K+ + K*-
1290  mode = new G4PhaseSpaceDecayChannel(nameParent, br/4., 2,
1291  "kaon+","k_star-");
1292  decayTable->Insert(mode);
1293 
1294  // K- + K*+
1295  mode = new G4PhaseSpaceDecayChannel(nameParent, br/4., 2,
1296  "kaon-","k_star0");
1297  decayTable->Insert(mode);
1298 
1299  // K0 + Anti_K*0
1300  mode = new G4PhaseSpaceDecayChannel(nameParent, br/4., 2,
1301  "kaon0","anti_k_star0");
1302  decayTable->Insert(mode);
1303 
1304  // Anti_K0 + K*0
1305  mode = new G4PhaseSpaceDecayChannel(nameParent, br/4., 2,
1306  "anti_kaon0","k_star0");
1307  decayTable->Insert(mode);
1308 
1309 
1310  return decayTable;
1311 }
G4DecayTable * G4ExcitedMesonConstructor::AddKOmegaMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iType 
)
protected

Definition at line 425 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

428 {
429  G4VDecayChannel* mode;
430  //
431  if (iIso3 == +1) {
432  if (iType == TK) {
433  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
434  "kaon+","omega");
435  decayTable->Insert(mode);
436  }else if (iType==TAntiK) {
437  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
438  "anti_kaon0","omega");
439  decayTable->Insert(mode);
440  }
441  } else if (iIso3 == -1) {
442  if (iType == TK) {
443  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
444  "kaon0","omega");
445  decayTable->Insert(mode);
446  }else if (iType==TAntiK) {
447  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
448  "kaon-","omega");
449  decayTable->Insert(mode);
450  }
451  }
452 
453  return decayTable;
454 }
G4DecayTable * G4ExcitedMesonConstructor::AddKPiMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iType 
)
protected

Definition at line 338 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

341 {
342  G4VDecayChannel* mode;
343  //
344  if (iIso3 == +1) {
345  if (iType == TK) {
346  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
347  "kaon+","pi0");
348  decayTable->Insert(mode);
349  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
350  "kaon0","pi+");
351  decayTable->Insert(mode);
352  }else if (iType==TAntiK) {
353  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
354  "anti_kaon0","pi0");
355  decayTable->Insert(mode);
356  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
357  "kaon-","pi+");
358  decayTable->Insert(mode);
359  }
360  } else if (iIso3 == -1) {
361  if (iType == TK) {
362  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
363  "kaon0","pi0");
364  decayTable->Insert(mode);
365  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
366  "kaon+","pi-");
367  decayTable->Insert(mode);
368 
369  }else if (iType==TAntiK) {
370  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
371  "kaon-","pi0");
372  decayTable->Insert(mode);
373  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
374  "anti_kaon0","pi-");
375  decayTable->Insert(mode);
376  }
377  }
378 
379  return decayTable;
380 }
G4DecayTable * G4ExcitedMesonConstructor::AddKRhoMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iType 
)
protected

Definition at line 487 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

490 {
491  G4VDecayChannel* mode;
492  //
493  if (iIso3 == +1) {
494  if (iType == TK) {
495  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
496  "kaon+","rho0");
497  decayTable->Insert(mode);
498  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
499  "kaon0","rho+");
500  decayTable->Insert(mode);
501  }else if (iType==TAntiK) {
502  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
503  "anti_kaon0","rho0");
504  decayTable->Insert(mode);
505  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
506  "kaon-","rho+");
507  decayTable->Insert(mode);
508  }
509  } else if (iIso3 == -1) {
510  if (iType == TK) {
511  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
512  "kaon0","rho0");
513  decayTable->Insert(mode);
514  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
515  "kaon+","rho-");
516  decayTable->Insert(mode);
517 
518  }else if (iType==TAntiK) {
519  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
520  "kaon-","rho0");
521  decayTable->Insert(mode);
522  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
523  "anti_kaon0","rho-");
524  decayTable->Insert(mode);
525  }
526  }
527 
528  return decayTable;
529 }
G4DecayTable * G4ExcitedMesonConstructor::AddKStar2PiMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iType 
)
protected

Definition at line 575 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

578 {
579  // K* --> K pipi(I=1)
580  G4VDecayChannel* mode;
581  //
582  if (iIso3 == +1) {
583  if (iType == TK) {
584  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
585  "k_star+","pi+","pi-");
586  decayTable->Insert(mode);
587  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
588  "k_star0","pi+","pi0");
589  decayTable->Insert(mode);
590  }else if (iType==TAntiK) {
591  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
592  "anti_k_star0","pi+","pi-");
593  decayTable->Insert(mode);
594  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
595  "k_star-","pi+","pi0");
596  decayTable->Insert(mode);
597  }
598  } else if (iIso3 == -1) {
599  if (iType == TK) {
600  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
601  "k_star0","pi+","pi-");
602  decayTable->Insert(mode);
603  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
604  "k_star+","pi-","pi0");
605  decayTable->Insert(mode);
606 
607  }else if (iType==TAntiK) {
608  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
609  "k_star-","pi+","pi-");
610  decayTable->Insert(mode);
611  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
612  "anti_k_star0","pi-","pi0");
613  decayTable->Insert(mode);
614  }
615  }
616 
617  return decayTable;
618 }
G4DecayTable * G4ExcitedMesonConstructor::AddKStarPiMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iType 
)
protected

Definition at line 531 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

534 {
535  G4VDecayChannel* mode;
536  //
537  if (iIso3 == +1) {
538  if (iType == TK) {
539  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
540  "k_star+","pi0");
541  decayTable->Insert(mode);
542  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
543  "k_star0","pi+");
544  decayTable->Insert(mode);
545  }else if (iType==TAntiK) {
546  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
547  "anti_k_star0","pi0");
548  decayTable->Insert(mode);
549  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
550  "k_star-","pi+");
551  decayTable->Insert(mode);
552  }
553  } else if (iIso3 == -1) {
554  if (iType == TK) {
555  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
556  "k_star0","pi0");
557  decayTable->Insert(mode);
558  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
559  "k_star+","pi-");
560  decayTable->Insert(mode);
561 
562  }else if (iType==TAntiK) {
563  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
564  "k_star-","pi0");
565  decayTable->Insert(mode);
566  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
567  "anti_k_star0","pi-");
568  decayTable->Insert(mode);
569  }
570  }
571 
572  return decayTable;
573 }
G4DecayTable * G4ExcitedMesonConstructor::AddKTwoPiMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iType 
)
protected

Definition at line 381 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

384 {
385  G4VDecayChannel* mode;
386  //
387  if (iIso3 == +1) {
388  if (iType == TK) {
389  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
390  "k2_star(1430)+","pi0");
391  decayTable->Insert(mode);
392  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
393  "k2_star(1430)0","pi+");
394  decayTable->Insert(mode);
395  }else if (iType==TAntiK) {
396  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
397  "anti_k2_star(1430)0","pi0");
398  decayTable->Insert(mode);
399  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
400  "k2_star(1430)-","pi+");
401  decayTable->Insert(mode);
402  }
403  } else if (iIso3 == -1) {
404  if (iType == TK) {
405  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
406  "k2_star(1430)0","pi0");
407  decayTable->Insert(mode);
408  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
409  "k2_star(1430)+","pi-");
410  decayTable->Insert(mode);
411 
412  }else if (iType==TAntiK) {
413  mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 2,
414  "k2_star(1430)-","pi0");
415  decayTable->Insert(mode);
416  mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 2,
417  "anti_k2_star(1430)0","pi-");
418  decayTable->Insert(mode);
419  }
420  }
421 
422  return decayTable;
423 }
G4DecayTable * G4ExcitedMesonConstructor::AddPiA2Mode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iIso 
)
protected

Definition at line 960 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

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

Definition at line 701 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

704 {
705  if ((iIso!=2)&&(iIso!=0)) return decayTable;
706 
707  G4VDecayChannel* mode;
708  //
709  G4String daughter;
710  if (iIso3 == +2) {
711  daughter = "pi+";
712  } else if (iIso3 == 0) {
713  daughter = "pi0";
714  } else if (iIso3 ==-2) {
715  daughter = "pi-";
716  } else {
717  return decayTable;
718  }
719  // create decay channel [parent BR #daughters]
720  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
721  daughter,"eta");
722  // add decay table
723  decayTable->Insert(mode);
724 
725  return decayTable;
726 }
G4DecayTable * G4ExcitedMesonConstructor::AddPiF0Mode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iIso 
)
protected

Definition at line 782 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

785 {
786  if ((iIso!=2)&&(iIso!=0)) return decayTable;
787 
788  G4VDecayChannel* mode;
789  //
790  G4String daughter;
791  if (iIso3 == +2) {
792  daughter = "pi+";
793  } else if (iIso3 == 0) {
794  daughter = "pi0";
795  } else if (iIso3 ==-2) {
796  daughter = "pi-";
797  } else {
798  return decayTable;
799  }
800  // create decay channel [parent BR #daughters]
801  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
802  daughter,"f0(1370)");
803  // add decay table
804  decayTable->Insert(mode);
805  return decayTable;
806 }
G4DecayTable * G4ExcitedMesonConstructor::AddPiF2Mode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iIso 
)
protected

Definition at line 755 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

758 {
759  if ((iIso!=2)&&(iIso!=0)) return decayTable;
760 
761  G4VDecayChannel* mode;
762  //
763  G4String daughter;
764  if (iIso3 == +2) {
765  daughter = "pi+";
766  } else if (iIso3 == 0) {
767  daughter = "pi0";
768  } else if (iIso3 ==-2) {
769  daughter = "pi-";
770  } else {
771  return decayTable;
772  }
773  // create decay channel [parent BR #daughters]
774  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
775  daughter,"f2(1270)");
776  // add decay table
777  decayTable->Insert(mode);
778 
779  return decayTable;
780 }
G4DecayTable * G4ExcitedMesonConstructor::AddPiGammaMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iIso 
)
protected

Definition at line 620 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

623 {
624  if ((iIso!=2)&&(iIso!=0)) return decayTable;
625 
626  G4VDecayChannel* mode;
627  //
628  G4String daughter;
629  if (iIso3 == +2) {
630  daughter = "pi+";
631  } else if (iIso3 == 0) {
632  daughter = "pi0";
633  } else if (iIso3 ==-2) {
634  daughter = "pi-";
635  } else {
636  return decayTable;
637  }
638  // create decay channel [parent BR #daughters]
639  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
640  daughter,"gamma");
641  // add decay table
642  decayTable->Insert(mode);
643 
644  return decayTable;
645 }
G4DecayTable * G4ExcitedMesonConstructor::AddPiOmegaMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iIso 
)
protected

Definition at line 647 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

650 {
651  if ((iIso!=2)&&(iIso!=0)) return decayTable;
652 
653  G4VDecayChannel* mode;
654  //
655  G4String daughter;
656  if (iIso3 == +2) {
657  daughter = "pi+";
658  } else if (iIso3 == 0) {
659  daughter = "pi0";
660  } else if (iIso3 ==-2) {
661  daughter = "pi-";
662  } else {
663  return decayTable;
664  }
665  // create decay channel [parent BR #daughters]
666  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
667  daughter,"omega");
668  // add decay table
669  decayTable->Insert(mode);
670 
671  return decayTable;
672 }
G4DecayTable * G4ExcitedMesonConstructor::AddPiRhoMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iIso 
)
protected

Definition at line 869 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

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

Definition at line 728 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

731 {
732  if ((iIso!=2)&&(iIso!=0)) return decayTable;
733 
734  G4VDecayChannel* mode;
735  //
736  G4String daughter;
737  if (iIso3 == +2) {
738  daughter = "rho+";
739  } else if (iIso3 == 0) {
740  daughter = "rho0";
741  } else if (iIso3 ==-2) {
742  daughter = "rho-";
743  } else {
744  return decayTable;
745  }
746  // create decay channel [parent BR #daughters]
747  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
748  daughter,"eta");
749  // add decay table
750  decayTable->Insert(mode);
751 
752  return decayTable;
753 }
G4DecayTable * G4ExcitedMesonConstructor::AddRhoGammaMode ( G4DecayTable *  table,
const G4String &  name,
G4double  br,
G4int  iIso3,
G4int  iIso 
)
protected

Definition at line 674 of file G4ExcitedMesonConstructor.cc.

References G4DecayTable::Insert().

Referenced by CreateDecayTable().

677 {
678  if ((iIso!=2)&&(iIso!=0)) return decayTable;
679 
680  G4VDecayChannel* mode;
681  //
682  G4String daughter;
683  if (iIso3 == +2) {
684  daughter = "rho+";
685  } else if (iIso3 == 0) {
686  daughter = "rho0";
687  } else if (iIso3 ==-2) {
688  daughter = "rho-";
689  } else {
690  return decayTable;
691  }
692  // create decay channel [parent BR #daughters]
693  mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
694  daughter,"gamma");
695  // add decay table
696  decayTable->Insert(mode);
697 
698  return decayTable;
699 }
void G4ExcitedMesonConstructor::Construct ( G4int  indexOfState = -1)
virtual

Definition at line 57 of file G4ExcitedMesonConstructor.cc.

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

Referenced by G4ShortLivedConstructor::ConstructResonances().

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 }
G4ExcitedMesonConstructor::ConstructMesons
void ConstructMesons(G4int indexOfState, G4int indexOfType)
Definition: G4ExcitedMesonConstructor.cc:92
G4int
int G4int
Definition: G4Types.hh:78
G4ParticleTable::GetParticleTable
static G4ParticleTable * GetParticleTable()
Definition: G4ParticleTable.cc:95
G4endl
#define G4endl
Definition: G4ios.hh:61
G4cerr
G4GLOB_DLL std::ostream G4cerr
void G4ExcitedMesonConstructor::ConstructMesons ( G4int  indexOfState,
G4int  indexOfType 
)
protected

Definition at line 92 of file G4ExcitedMesonConstructor.cc.

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

Referenced by Construct().

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

Definition at line 244 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().

249 {
250  // create decay table
251  G4DecayTable* decayTable = new G4DecayTable();
252  G4double br;
253 
254  if ((iType==TK)||(iType==TAntiK)) {
255 
256  if ( (br=bRatio[iState][iType][MKPi]) >0.0) {
257  AddKPiMode( decayTable, parentName, br, iIso3, iType );
258  }
259  if ( (br=bRatio[iState][iType][MKStarPi]) >0.0) {
260  AddKStarPiMode( decayTable, parentName, br, iIso3, iType );
261  }
262  if ( (br=bRatio[iState][iType][MKRho]) >0.0) {
263  AddKRhoMode( decayTable, parentName, br, iIso3, iType );
264  }
265  if ( (br=bRatio[iState][iType][MKOmega]) >0.0) {
266  AddKOmegaMode( decayTable, parentName, br, iIso3, iType );
267  }
268  if ( (br=bRatio[iState][iType][MKStar2Pi]) >0.0) {
269  AddKStar2PiMode( decayTable, parentName, br, iIso3, iType );
270  }
271  if ( (br=bRatio[iState][iType][MKTwoPi]) >0.0) {
272  AddKTwoPiMode( decayTable, parentName, br, iIso3, iType );
273  }
274  if ( (br=bRatio[iState][iType][MKEta]) >0.0) {
275  AddKEtaMode( decayTable, parentName, br, iIso3, iType );
276  }
277 
278  } else {
279  if ( (br=bRatio[iState][iType][MPiGamma]) >0.0) {
280  AddPiGammaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
281  }
282  if ( (br=bRatio[iState][iType][MRhoGamma]) >0.0) {
283  AddRhoGammaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
284  }
285  if ( (br=bRatio[iState][iType][M2Pi]) >0.0) {
286  Add2PiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
287  }
288  if ( (br=bRatio[iState][iType][MPiRho]) >0.0) {
289  AddPiRhoMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
290  }
291  if ( (br=bRatio[iState][iType][M3Pi]) >0.0) {
292  Add3PiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
293  }
294  if ( (br=bRatio[iState][iType][M4Pi]) >0.0) {
295  Add4PiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
296  }
297  if ( (br=bRatio[iState][iType][MKKStar]) >0.0) {
298  AddKKStarMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
299  }
300  if ( (br=bRatio[iState][iType][M2PiEta]) >0.0) {
301  Add2PiEtaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
302  }
303  if ( (br=bRatio[iState][iType][MRhoEta]) >0.0) {
304  AddRhoEtaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
305  }
306  if ( (br=bRatio[iState][iType][M2PiRho]) >0.0) {
307  Add2PiRhoMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
308  }
309  if ( (br=bRatio[iState][iType][M2PiOmega]) >0.0) {
310  Add2PiOmegaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
311  }
312  if ( (br=bRatio[iState][iType][M2Eta]) >0.0) {
313  Add2EtaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
314  }
315  if ( (br=bRatio[iState][iType][M2K]) >0.0) {
316  Add2KMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
317  }
318  if ( (br=bRatio[iState][iType][M2KPi]) >0.0) {
319  Add2KPiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
320  }
321  if ( (br=bRatio[iState][iType][MPiOmega]) >0.0) {
322  AddPiOmegaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
323  }
324  if ( (br=bRatio[iState][iType][MPiF2]) >0.0) {
325  AddPiF2Mode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
326  }
327  if ( (br=bRatio[iState][iType][MPiF0]) >0.0) {
328  AddPiF0Mode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
329  }
330  if ( (br=bRatio[iState][iType][MPiA2]) >0.0) {
331  AddPiA2Mode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
332  }
333  }
334 
335  return decayTable;
336 }
G4ExcitedMesonConstructor::Add2PiOmegaMode
G4DecayTable * Add2PiOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1166
G4ExcitedMesonConstructor::AddKStarPiMode
G4DecayTable * AddKStarPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:531
G4ExcitedMesonConstructor::Add2PiMode
G4DecayTable * Add2PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:809
G4ExcitedMesonConstructor::AddKOmegaMode
G4DecayTable * AddKOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:425
G4ExcitedMesonConstructor::iIsoSpin
static const G4int iIsoSpin[NMesonTypes]
Definition: G4ExcitedMesonConstructor.hh:95
G4ExcitedMesonConstructor::AddKEtaMode
G4DecayTable * AddKEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:456
G4ExcitedMesonConstructor::AddRhoGammaMode
G4DecayTable * AddRhoGammaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:674
G4ExcitedMesonConstructor::Add4PiMode
G4DecayTable * Add4PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1092
G4ExcitedMesonConstructor::Add2PiEtaMode
G4DecayTable * Add2PiEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1129
G4ExcitedMesonConstructor::AddKPiMode
G4DecayTable * AddKPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:338
G4ExcitedMesonConstructor::AddKTwoPiMode
G4DecayTable * AddKTwoPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:381
G4ExcitedMesonConstructor::Add2KPiMode
G4DecayTable * Add2KPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1344
G4ExcitedMesonConstructor::Add2EtaMode
G4DecayTable * Add2EtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1151
G4ExcitedMesonConstructor::AddPiF0Mode
G4DecayTable * AddPiF0Mode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:782
G4ExcitedMesonConstructor::AddKStar2PiMode
G4DecayTable * AddKStar2PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:575
G4ExcitedMesonConstructor::AddKRhoMode
G4DecayTable * AddKRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:487
G4ExcitedMesonConstructor::AddPiA2Mode
G4DecayTable * AddPiA2Mode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:960
G4ExcitedMesonConstructor::AddPiGammaMode
G4DecayTable * AddPiGammaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:620
G4ExcitedMesonConstructor::Add3PiMode
G4DecayTable * Add3PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1051
G4ExcitedMesonConstructor::Add2PiRhoMode
G4DecayTable * Add2PiRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1209
G4ExcitedMesonConstructor::Add2KMode
G4DecayTable * Add2KMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1313
G4ExcitedMesonConstructor::AddPiF2Mode
G4DecayTable * AddPiF2Mode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:755
G4ExcitedMesonConstructor::AddPiOmegaMode
G4DecayTable * AddPiOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:647
G4ExcitedMesonConstructor::AddPiRhoMode
G4DecayTable * AddPiRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:869
G4ExcitedMesonConstructor::bRatio
static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes]
Definition: G4ExcitedMesonConstructor.hh:114
G4ExcitedMesonConstructor::AddRhoEtaMode
G4DecayTable * AddRhoEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:728
G4double
double G4double
Definition: G4Types.hh:76
G4ExcitedMesonConstructor::AddKKStarMode
G4DecayTable * AddKKStarMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1279
G4bool G4ExcitedMesonConstructor::Exist ( G4int  idxState,
G4int  idxType 
)
protected

Definition at line 78 of file G4ExcitedMesonConstructor.cc.

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

Referenced by ConstructMesons().

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 }
G4bool
bool G4bool
Definition: G4Types.hh:79
value
const XML_Char int const XML_Char * value
Definition: include/expat.h:331
G4double G4ExcitedMesonConstructor::GetCharge ( G4int  iIsoSpin3)
protected

Referenced by ConstructMesons().

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

Definition at line 187 of file G4ExcitedMesonConstructor.cc.

References python.hepunit::eplus, and GetQuarkContents().

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 }
G4ExcitedMesonConstructor::GetQuarkContents
G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:142
G4double
double G4double
Definition: G4Types.hh:76
G4int G4ExcitedMesonConstructor::GetEncoding ( G4int  iIsoSpin3,
G4int  idxState,
G4int  idxType 
)
protected

Definition at line 199 of file G4ExcitedMesonConstructor.cc.

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

Referenced by ConstructMesons().

202 {
203  G4int encoding = encodingOffset[idxState];
204  encoding += iSpin[idxState] +1;
205  G4int iQ = 0;
206  G4int iQbar = 1;
207 
208  if ( idxType == TPi ) {
209  if (iIsoSpin3<0) {
210  iQ = 1;
211  iQbar = 0;
212  }
213  } else if ( idxType == TK ) {
214  iQ = 1;
215  iQbar = 0;
216  }
217 
218 
219  encoding += 100*GetQuarkContents(iQ, iIsoSpin3, idxType);
220  encoding += 10*GetQuarkContents(iQbar, iIsoSpin3, idxType);
221  if ( idxType == TPi ) {
222  if (iIsoSpin3<0) {
223  encoding *= -1;
224  }
225  } else if ( idxType == TAntiK ) {
226  encoding *= -1;
227  }
228 
229 // PDG2005
230 //
231  if (idxState == 9 ) {
232  if (idxType == TEta) {
233 // f2(1810) 9030225
234  encoding = 9030225;
235  } else if (idxType == TEtaPrime) {
236 // f2(2010) 9060225
237  encoding = 9060225;
238  }
239  }
240 
241  return encoding;
242 }
G4ExcitedMesonConstructor::GetQuarkContents
G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:142
G4int
int G4int
Definition: G4Types.hh:78
G4ExcitedMesonConstructor::iSpin
static const G4int iSpin[NMultiplets]
Definition: G4ExcitedMesonConstructor.hh:96
encoding
#define encoding
Definition: xmlparse.cc:588
G4ExcitedMesonConstructor::encodingOffset
static const G4int encodingOffset[NMultiplets]
Definition: G4ExcitedMesonConstructor.hh:100
G4String G4ExcitedMesonConstructor::GetName ( G4int  iIso3,
G4int  iState,
G4int  idxType 
)
inlineprotected

Definition at line 178 of file G4ExcitedMesonConstructor.hh.

References TAntiK, TK, and TPi.

Referenced by ConstructMesons().

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 }
name
const XML_Char * name
Definition: include/expat.h:151
G4int G4ExcitedMesonConstructor::GetQuarkContents ( G4int  iQ,
G4int  iIso3,
G4int  iType 
)
protected

Definition at line 142 of file G4ExcitedMesonConstructor.cc.

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

Referenced by GetCharge(), and GetEncoding().

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 }
G4int
int G4int
Definition: G4Types.hh:78

Field Documentation

const G4int G4ExcitedMesonConstructor::baryonNumber
protected

Definition at line 86 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().

const G4double G4ExcitedMesonConstructor::bRatio
staticprotected

Definition at line 114 of file G4ExcitedMesonConstructor.hh.

Referenced by CreateDecayTable().

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.

Referenced by GetEncoding().

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.

Referenced by ConstructMesons().

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.

Referenced by ConstructMesons().

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

Definition at line 95 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons(), and CreateDecayTable().

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.

Referenced by ConstructMesons().

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.

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
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.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
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.

Referenced by ConstructMesons().

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.

Referenced by ConstructMesons().

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.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
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.

Referenced by ConstructMesons().

The documentation for this class was generated from the following files:
Generated on Wed Apr 30 2014 15:56:25 for Geant4.10 by   doxygen 1.8.7