Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
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

anonymous enum
Enumerator
NMultiplets 

Definition at line 70 of file G4ExcitedMesonConstructor.hh.

70{ NMultiplets = 10 };

◆ anonymous enum

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

anonymous enum
Enumerator
NMesonTypes 

Definition at line 79 of file G4ExcitedMesonConstructor.hh.

79{ NMesonTypes = 5 };

◆ anonymous enum

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

anonymous enum
Enumerator
NumberOfDecayModes 

Definition at line 103 of file G4ExcitedMesonConstructor.hh.

103{ NumberOfDecayModes = 19 };

◆ anonymous enum

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

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::G4ExcitedMesonConstructor ( G4int  nStates = 0,
G4int  isoSpin = 0 
)

Definition at line 48 of file G4ExcitedMesonConstructor.cc.

50 : type("meson"), leptonNumber(0), baryonNumber(0)
51{
52}

◆ ~G4ExcitedMesonConstructor()

G4ExcitedMesonConstructor::~G4ExcitedMesonConstructor ( )
virtual

Definition at line 54 of file G4ExcitedMesonConstructor.cc.

55{
56}

Member Function Documentation

◆ Add2EtaMode()

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

Definition at line 1152 of file G4ExcitedMesonConstructor.cc.

1155{
1156 if (iIso!=0) return decayTable;
1157
1158 G4VDecayChannel* mode;
1159
1160 // eta eta
1161 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
1162 "eta","eta");
1163 decayTable->Insert(mode);
1164 return decayTable;
1165}

Referenced by CreateDecayTable().

◆ Add2KMode()

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

Definition at line 1314 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add2KPiMode()

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

Definition at line 1345 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add2PiEtaMode()

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

Definition at line 1130 of file G4ExcitedMesonConstructor.cc.

1133{
1134 // f1-->eta + pi + pi mode
1135
1136 if (iIso!=0) return decayTable;
1137
1138 G4VDecayChannel* mode;
1139
1140 // eta pi+ pi-
1141 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 3,
1142 "eta","pi+","pi-");
1143 decayTable->Insert(mode);
1144
1145 // eta pi+ pi-
1146 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 3,
1147 "eta","pi0","pi0");
1148 decayTable->Insert(mode);
1149 return decayTable;
1150}

Referenced by CreateDecayTable().

◆ Add2PiMode()

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

Definition at line 810 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add2PiOmegaMode()

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

Definition at line 1167 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add2PiRhoMode()

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

Definition at line 1210 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add3PiMode()

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

Definition at line 1052 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add4PiMode()

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

Definition at line 1093 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKEtaMode()

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

Definition at line 457 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKKStarMode()

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

Definition at line 1280 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKOmegaMode()

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

Definition at line 426 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKPiMode()

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

Definition at line 339 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKRhoMode()

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

Definition at line 488 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKStar2PiMode()

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

Definition at line 576 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKStarPiMode()

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

Definition at line 532 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKTwoPiMode()

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

Definition at line 382 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiA2Mode()

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

Definition at line 961 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiEtaMode()

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

Definition at line 702 of file G4ExcitedMesonConstructor.cc.

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

◆ AddPiF0Mode()

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

Definition at line 783 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiF2Mode()

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

Definition at line 756 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiGammaMode()

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

Definition at line 621 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiOmegaMode()

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

Definition at line 648 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiRhoMode()

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

Definition at line 870 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddRhoEtaMode()

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

Definition at line 729 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddRhoGammaMode()

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

Definition at line 675 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Construct()

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

Definition at line 58 of file G4ExcitedMesonConstructor.cc.

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

Referenced by G4ShortLivedConstructor::ConstructResonances().

◆ ConstructMesons()

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

Definition at line 93 of file G4ExcitedMesonConstructor.cc.

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

Referenced by Construct().

◆ CreateDecayTable()

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

Definition at line 245 of file G4ExcitedMesonConstructor.cc.

250{
251 // create decay table
252 G4DecayTable* decayTable = new G4DecayTable();
253 G4double br;
254
255 if ((iType==TK)||(iType==TAntiK)) {
256
257 if ( (br=bRatio[iState][iType][MKPi]) >0.0) {
258 AddKPiMode( decayTable, parentName, br, iIso3, iType );
259 }
260 if ( (br=bRatio[iState][iType][MKStarPi]) >0.0) {
261 AddKStarPiMode( decayTable, parentName, br, iIso3, iType );
262 }
263 if ( (br=bRatio[iState][iType][MKRho]) >0.0) {
264 AddKRhoMode( decayTable, parentName, br, iIso3, iType );
265 }
266 if ( (br=bRatio[iState][iType][MKOmega]) >0.0) {
267 AddKOmegaMode( decayTable, parentName, br, iIso3, iType );
268 }
269 if ( (br=bRatio[iState][iType][MKStar2Pi]) >0.0) {
270 AddKStar2PiMode( decayTable, parentName, br, iIso3, iType );
271 }
272 if ( (br=bRatio[iState][iType][MKTwoPi]) >0.0) {
273 AddKTwoPiMode( decayTable, parentName, br, iIso3, iType );
274 }
275 if ( (br=bRatio[iState][iType][MKEta]) >0.0) {
276 AddKEtaMode( decayTable, parentName, br, iIso3, iType );
277 }
278
279 } else {
280 if ( (br=bRatio[iState][iType][MPiGamma]) >0.0) {
281 AddPiGammaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
282 }
283 if ( (br=bRatio[iState][iType][MRhoGamma]) >0.0) {
284 AddRhoGammaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
285 }
286 if ( (br=bRatio[iState][iType][M2Pi]) >0.0) {
287 Add2PiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
288 }
289 if ( (br=bRatio[iState][iType][MPiRho]) >0.0) {
290 AddPiRhoMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
291 }
292 if ( (br=bRatio[iState][iType][M3Pi]) >0.0) {
293 Add3PiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
294 }
295 if ( (br=bRatio[iState][iType][M4Pi]) >0.0) {
296 Add4PiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
297 }
298 if ( (br=bRatio[iState][iType][MKKStar]) >0.0) {
299 AddKKStarMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
300 }
301 if ( (br=bRatio[iState][iType][M2PiEta]) >0.0) {
302 Add2PiEtaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
303 }
304 if ( (br=bRatio[iState][iType][MRhoEta]) >0.0) {
305 AddRhoEtaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
306 }
307 if ( (br=bRatio[iState][iType][M2PiRho]) >0.0) {
308 Add2PiRhoMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
309 }
310 if ( (br=bRatio[iState][iType][M2PiOmega]) >0.0) {
311 Add2PiOmegaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
312 }
313 if ( (br=bRatio[iState][iType][M2Eta]) >0.0) {
314 Add2EtaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
315 }
316 if ( (br=bRatio[iState][iType][M2K]) >0.0) {
317 Add2KMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
318 }
319 if ( (br=bRatio[iState][iType][M2KPi]) >0.0) {
320 Add2KPiMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
321 }
322 if ( (br=bRatio[iState][iType][MPiOmega]) >0.0) {
323 AddPiOmegaMode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
324 }
325 if ( (br=bRatio[iState][iType][MPiF2]) >0.0) {
326 AddPiF2Mode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
327 }
328 if ( (br=bRatio[iState][iType][MPiF0]) >0.0) {
329 AddPiF0Mode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
330 }
331 if ( (br=bRatio[iState][iType][MPiA2]) >0.0) {
332 AddPiA2Mode( decayTable, parentName, br, iIso3, iIsoSpin[iType] );
333 }
334 }
335
336 return decayTable;
337}
G4ExcitedMesonConstructor::Add3PiMode
G4DecayTable * Add3PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1052
G4ExcitedMesonConstructor::AddKRhoMode
G4DecayTable * AddKRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:488
G4ExcitedMesonConstructor::AddPiF0Mode
G4DecayTable * AddPiF0Mode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:783
G4ExcitedMesonConstructor::AddPiA2Mode
G4DecayTable * AddPiA2Mode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:961
G4ExcitedMesonConstructor::AddKStarPiMode
G4DecayTable * AddKStarPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:532
G4ExcitedMesonConstructor::AddKOmegaMode
G4DecayTable * AddKOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:426
G4ExcitedMesonConstructor::Add2KPiMode
G4DecayTable * Add2KPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1345
G4ExcitedMesonConstructor::Add2PiMode
G4DecayTable * Add2PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:810
G4ExcitedMesonConstructor::AddKTwoPiMode
G4DecayTable * AddKTwoPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:382
G4ExcitedMesonConstructor::AddPiOmegaMode
G4DecayTable * AddPiOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:648
G4ExcitedMesonConstructor::AddPiF2Mode
G4DecayTable * AddPiF2Mode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:756
G4ExcitedMesonConstructor::AddKPiMode
G4DecayTable * AddKPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:339
G4ExcitedMesonConstructor::AddKStar2PiMode
G4DecayTable * AddKStar2PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:576
G4ExcitedMesonConstructor::AddKEtaMode
G4DecayTable * AddKEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:457
G4ExcitedMesonConstructor::AddRhoEtaMode
G4DecayTable * AddRhoEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:729
G4ExcitedMesonConstructor::Add2PiOmegaMode
G4DecayTable * Add2PiOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1167
G4ExcitedMesonConstructor::Add2PiEtaMode
G4DecayTable * Add2PiEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1130
G4ExcitedMesonConstructor::Add2PiRhoMode
G4DecayTable * Add2PiRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1210
G4ExcitedMesonConstructor::AddRhoGammaMode
G4DecayTable * AddRhoGammaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:675
G4ExcitedMesonConstructor::Add4PiMode
G4DecayTable * Add4PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1093
G4ExcitedMesonConstructor::Add2EtaMode
G4DecayTable * Add2EtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1152
G4ExcitedMesonConstructor::bRatio
static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes]
Definition: G4ExcitedMesonConstructor.hh:114
G4ExcitedMesonConstructor::AddPiGammaMode
G4DecayTable * AddPiGammaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:621
G4ExcitedMesonConstructor::Add2KMode
G4DecayTable * Add2KMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1314
G4ExcitedMesonConstructor::AddKKStarMode
G4DecayTable * AddKKStarMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:1280
G4ExcitedMesonConstructor::AddPiRhoMode
G4DecayTable * AddPiRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition: G4ExcitedMesonConstructor.cc:870

Referenced by ConstructMesons().

◆ Exist()

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

Definition at line 79 of file G4ExcitedMesonConstructor.cc.

80{
81 G4bool value = true;
82 if ( idxType == TEtaPrime ) {
83 if (idxState==N13P0) value = false;
84 if (idxState==N13D1) value = false;
85 } else if ( idxType == TPi ) {
86 if (idxState==N23P2) value = false;
87 }
88 return value;
89}
G4bool
bool G4bool
Definition: G4Types.hh:67

Referenced by ConstructMesons().

◆ GetCharge() [1/2]

G4double G4ExcitedMesonConstructor::GetCharge ( G4int  iIsoSpin3)
protected

Referenced by ConstructMesons().

◆ GetCharge() [2/2]

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

Definition at line 188 of file G4ExcitedMesonConstructor.cc.

189{
190 static G4double quark_charge[7] =
191 {
192 0., -1./3., +2./3., -1./3., +2./3., -1./3., +2./3.
193 };
194
195 G4double charge = quark_charge[GetQuarkContents(0, iIsoSpin3, idxType)]*eplus;
196 charge -= quark_charge[GetQuarkContents(1, iIsoSpin3, idxType)]*eplus;
197 return charge;
198}
G4ExcitedMesonConstructor::GetQuarkContents
G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType)
Definition: G4ExcitedMesonConstructor.cc:143

◆ GetEncoding()

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

Definition at line 200 of file G4ExcitedMesonConstructor.cc.

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

Referenced by ConstructMesons().

◆ GetName()

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}

Referenced by ConstructMesons().

◆ GetQuarkContents()

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

Definition at line 143 of file G4ExcitedMesonConstructor.cc.

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

Referenced by GetCharge(), and GetEncoding().

Member Data Documentation

◆ baryonNumber

const G4int G4ExcitedMesonConstructor::baryonNumber
protected

Definition at line 86 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().

◆ bRatio

const G4double G4ExcitedMesonConstructor::bRatio
staticprotected

Definition at line 114 of file G4ExcitedMesonConstructor.hh.

Referenced by CreateDecayTable().

◆ encodingOffset

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

◆ iChargeConjugation

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

◆ iGParity

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

◆ iIsoSpin

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

◆ iParity

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

◆ iSpin

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

◆ leptonNumber

const G4int G4ExcitedMesonConstructor::leptonNumber
protected

Definition at line 85 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().

◆ mass

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

◆ massKdiff

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

◆ name

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.

Referenced by ConstructMesons(), and GetName().

◆ type

const G4String G4ExcitedMesonConstructor::type
protected

Definition at line 84 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().

◆ width

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

◆ widthKdiff

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: