Geant4 10.7.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 48 of file G4ExcitedMesonConstructor.hh.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
Enumerator
NMultiplets 

Definition at line 69 of file G4ExcitedMesonConstructor.hh.

69{ NMultiplets = 10 };

◆ anonymous enum

anonymous enum
protected
Enumerator
N11P1 
N13P0 
N13P1 
N13P2 
N11D2 
N13D1 
N13D3 
N21S0 
N23S1 
N23P2 

Definition at line 71 of file G4ExcitedMesonConstructor.hh.

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

◆ anonymous enum

anonymous enum
Enumerator
NMesonTypes 

Definition at line 78 of file G4ExcitedMesonConstructor.hh.

78{ NMesonTypes = 5 };

◆ anonymous enum

anonymous enum
protected
Enumerator
TPi 
TEta 
TEtaPrime 
TK 
TAntiK 

Definition at line 80 of file G4ExcitedMesonConstructor.hh.

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

◆ anonymous enum

anonymous enum
Enumerator
NumberOfDecayModes 

Definition at line 102 of file G4ExcitedMesonConstructor.hh.

102{ 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 104 of file G4ExcitedMesonConstructor.hh.

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

◆ anonymous enum

anonymous enum
protected
Enumerator
MKPi 
MKStarPi 
MKRho 
MKOmega 
MKStar2Pi 
MKTwoPi 
MKEta 

Definition at line 109 of file G4ExcitedMesonConstructor.hh.

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

Constructor & Destructor Documentation

◆ G4ExcitedMesonConstructor()

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

Definition at line 46 of file G4ExcitedMesonConstructor.cc.

48 : type("meson"), leptonNumber(0), baryonNumber(0)
49{
50}

◆ ~G4ExcitedMesonConstructor()

G4ExcitedMesonConstructor::~G4ExcitedMesonConstructor ( )
virtual

Definition at line 52 of file G4ExcitedMesonConstructor.cc.

53{
54}

Member Function Documentation

◆ Add2EtaMode()

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

Definition at line 1160 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add2KMode()

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

Definition at line 1343 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add2KPiMode()

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

Definition at line 1374 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add2PiEtaMode()

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

Definition at line 1138 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add2PiMode()

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

Definition at line 818 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add2PiOmegaMode()

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

Definition at line 1175 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add2PiRhoMode()

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

Definition at line 1218 of file G4ExcitedMesonConstructor.cc.

1221{
1222 G4VDecayChannel* mode;
1223
1224 if (iIso==0) {
1225 // f1 --> rho0 + pi+ pi-
1226 // rho0 pi+ pi-
1227 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1228 "rho0","pi+","pi-");
1229 decayTable->Insert(mode);
1230 } else if (iIso==2) {
1231 if (iIso3==+2) {
1232 // rho+ pi0 pi0
1233 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1234 "rho+","pi0","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 // rho0 pi+ pi0
1241 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1242 "rho0","pi+","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 } else if (iIso3==-2) {
1249 // rho- pi0 pi0
1250 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1251 "rho-","pi0","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 // rho0 pi- pi0
1258 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1259 "rho0","pi-","pi0");
1260 decayTable->Insert(mode);
1261 // rho+ pi- pi-
1262 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1263 "rho+","pi-","pi-");
1264 decayTable->Insert(mode);
1265 } else if (iIso3==0) {
1266 // rho+ pi- pi0
1267 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1268 "rho+","pi-","pi0");
1269 decayTable->Insert(mode);
1270 // rho0 pi+ pi-
1271 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1272 "rho0","pi+","pi-");
1273 decayTable->Insert(mode);
1274 // rho0 pi0 pi0
1275 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1276 "rho0","pi0","pi0");
1277 decayTable->Insert(mode);
1278 // rho- pi+ pi0
1279 mode = new G4PhaseSpaceDecayChannel(nameParent, br/5., 3,
1280 "rho-","pi+","pi-");
1281 decayTable->Insert(mode);
1282 }
1283 }
1284 return decayTable;
1285}

Referenced by CreateDecayTable().

◆ Add3PiMode()

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

Definition at line 1060 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add4PiMode()

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

Definition at line 1101 of file G4ExcitedMesonConstructor.cc.

1104{
1105 G4VDecayChannel* mode;
1106
1107 if (iIso3==0) {
1108 // 2pi+ + 2pi-
1109 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 4,
1110 "pi+","pi-","pi+","pi-");
1111 decayTable->Insert(mode);
1112 // pi+ + pi- + 2pi0
1113 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2., 4,
1114 "pi+","pi-","pi0","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 } else if (iIso3==-2) {
1126 // pi- + 3pi0
1127 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3., 4,
1128 "pi-","pi0","pi0","pi0");
1129 decayTable->Insert(mode);
1130 // 2pi- + pi+ + pi0
1131 mode = new G4PhaseSpaceDecayChannel(nameParent, br*2./3., 4,
1132 "pi-","pi-","pi+","pi0");
1133 decayTable->Insert(mode);
1134 }
1135 return decayTable;
1136}

Referenced by CreateDecayTable().

◆ AddKEtaMode()

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

Definition at line 465 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKKStarMode()

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

Definition at line 1288 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKOmegaMode()

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

Definition at line 434 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKPiMode()

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

Definition at line 347 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKRhoMode()

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

Definition at line 496 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKStar2PiMode()

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

Definition at line 584 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKStarPiMode()

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

Definition at line 540 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKTwoPiMode()

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

Definition at line 390 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiA2Mode()

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

Definition at line 969 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiEtaMode()

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

Definition at line 710 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiF0Mode()

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

Definition at line 791 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiF2Mode()

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

Definition at line 764 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiGammaMode()

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

Definition at line 629 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiOmegaMode()

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

Definition at line 656 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiRhoMode()

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

Definition at line 878 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddRhoEtaMode()

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

Definition at line 737 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddRhoGammaMode()

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

Definition at line 683 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Construct()

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

Definition at line 56 of file G4ExcitedMesonConstructor.cc.

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

Referenced by G4ShortLivedConstructor::ConstructResonances().

◆ ConstructMesons()

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

Definition at line 91 of file G4ExcitedMesonConstructor.cc.

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

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

Referenced by ConstructMesons().

◆ Exist()

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

Definition at line 77 of file G4ExcitedMesonConstructor.cc.

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

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 186 of file G4ExcitedMesonConstructor.cc.

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

◆ GetEncoding()

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

Definition at line 198 of file G4ExcitedMesonConstructor.cc.

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

Referenced by ConstructMesons().

◆ GetName()

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

Definition at line 177 of file G4ExcitedMesonConstructor.hh.

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

Referenced by ConstructMesons().

◆ GetQuarkContents()

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

Definition at line 141 of file G4ExcitedMesonConstructor.cc.

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

Referenced by GetCharge(), and GetEncoding().

Member Data Documentation

◆ baryonNumber

const G4int G4ExcitedMesonConstructor::baryonNumber
protected

Definition at line 85 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().

◆ bRatio

const G4double G4ExcitedMesonConstructor::bRatio
staticprotected

Definition at line 113 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 99 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 98 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 97 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().

◆ iIsoSpin

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

Definition at line 94 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 96 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 95 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons(), and GetEncoding().

◆ leptonNumber

const G4int G4ExcitedMesonConstructor::leptonNumber
protected

Definition at line 84 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.2819*GeV,1.4264*GeV, 1.403*GeV, 1.403*GeV },
{ 1.3183*GeV,1.2755*GeV, 1.525*GeV,1.4256*GeV, 1.4256*GeV },
{ 1.6722*GeV, 1.617*GeV, 1.842*GeV, 1.773*GeV, 1.773*GeV },
{ 1.720*GeV, 1.670*GeV, 0.0, 1.718*GeV, 1.718*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.421*GeV, 1.421*GeV },
{ 0.0, 1.815*GeV, 2.010*GeV, 1.973*GeV, 1.973*GeV }
}

Definition at line 90 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 91 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 89 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons(), and GetName().

◆ type

const G4String G4ExcitedMesonConstructor::type
protected

Definition at line 83 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, 22.7*MeV, 54.9*MeV, 174.0*MeV, 174.0*MeV },
{ 107.0*MeV, 186.7*MeV, 73.0*MeV, 98.5*MeV, 98.5*MeV },
{ 260.0*MeV, 181.0*MeV, 225.0*MeV, 186.0*MeV, 186.0*MeV },
{ 250.0*MeV, 315.0*MeV, 0.0, 320.0*MeV, 320.0*MeV },
{ 161.0*MeV, 168.0*MeV, 87.0*MeV, 159.0*MeV, 159.0*MeV },
{ 400.0*MeV, 55.0*MeV, 85.0*MeV, 260.0*MeV, 260.0*MeV },
{ 400.0*MeV, 215.0*MeV, 150.0*MeV, 236.0*MeV, 236.0*MeV },
{ 0.0, 197.0*MeV, 200.0*MeV, 373.0*MeV, 373.0*MeV }
}

Definition at line 92 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 93 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().

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