Geant4 11.4.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
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 ()=default
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)
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)
G4bool Exist (G4int idxState, G4int idxType)
G4double GetCharge (G4int iIsoSpin3, G4int idxType)

Protected Attributes

const G4String type
const G4int leptonNumber {0}
const G4int baryonNumber {0}

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 38 of file G4ExcitedMesonConstructor.hh.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
Enumerator
NumberOfDecayModes 

Definition at line 53 of file G4ExcitedMesonConstructor.hh.

54 {
55 NumberOfDecayModes = 19
56 };

◆ anonymous enum

anonymous enum
protected
Enumerator
TPi 
TEta 
TEtaPrime 
TK 
TAntiK 

Definition at line 146 of file G4ExcitedMesonConstructor.hh.

147 {
148 TPi = 0,
149 TEta = 1,
150 TEtaPrime = 2,
151 TK = 3,
152 TAntiK = 4
153 };

◆ anonymous enum

anonymous enum
protected
Enumerator
MKPi 
MKStarPi 
MKRho 
MKOmega 
MKStar2Pi 
MKTwoPi 
MKEta 

Definition at line 193 of file G4ExcitedMesonConstructor.hh.

194 {
195 MKPi = 0,
196 MKStarPi = 1,
197 MKRho = 2,
198 MKOmega = 3,
199 MKStar2Pi = 4,
200 MKTwoPi = 5,
201 MKEta = 6
202 };

◆ 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 171 of file G4ExcitedMesonConstructor.hh.

172 {
173 MPiGamma = 0,
174 MRhoGamma = 1,
175 M2Pi = 2,
176 MPiRho = 3,
177 M3Pi = 4,
178 MPiEta = 5,
179 M4Pi = 6,
180 MKKStar = 7,
181 M2PiEta = 8,
182 MRhoEta = 9,
183 M2PiRho = 10,
184 M2PiOmega = 11,
185 M2Eta = 12,
186 M2K = 13,
187 M2KPi = 14,
188 MPiOmega = 15,
189 MPiF2 = 16,
190 MPiF0 = 17,
191 MPiA2 = 18
192 };

◆ anonymous enum

anonymous enum
Enumerator
NMultiplets 

Definition at line 43 of file G4ExcitedMesonConstructor.hh.

44 {
45 NMultiplets = 10
46 };

◆ anonymous enum

anonymous enum
Enumerator
NMesonTypes 

Definition at line 48 of file G4ExcitedMesonConstructor.hh.

49 {
50 NMesonTypes = 5
51 };

◆ anonymous enum

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

Definition at line 132 of file G4ExcitedMesonConstructor.hh.

133 {
134 N11P1 = 0,
135 N13P0 = 1,
136 N13P1 = 2,
137 N13P2 = 3,
138 N11D2 = 4,
139 N13D1 = 5,
140 N13D3 = 6,
141 N21S0 = 7,
142 N23S1 = 8,
143 N23P2 = 9
144 };

Constructor & Destructor Documentation

◆ G4ExcitedMesonConstructor()

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

Definition at line 46 of file G4ExcitedMesonConstructor.cc.

46: type("meson") {}

◆ ~G4ExcitedMesonConstructor()

virtual G4ExcitedMesonConstructor::~G4ExcitedMesonConstructor ( )
virtualdefault

Member Function Documentation

◆ Add2EtaMode()

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

Definition at line 1137 of file G4ExcitedMesonConstructor.cc.

1140{
1141 if (iIso != 0) return decayTable;
1142
1143 G4VDecayChannel* mode;
1144
1145 // eta eta
1146 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, "eta", "eta");
1147 decayTable->Insert(mode);
1148 return decayTable;
1149}

Referenced by CreateDecayTable().

◆ Add2KMode()

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

Definition at line 1293 of file G4ExcitedMesonConstructor.cc.

1296{
1297 G4VDecayChannel* mode;
1298
1299 if (iIso3 == 0) {
1300 // K+ + K-
1301 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2., 2, "kaon+", "kaon-");
1302 decayTable->Insert(mode);
1303
1304 // K0 + Anti_K0
1305 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2., 2, "kaon0", "anti_kaon0");
1306 decayTable->Insert(mode);
1307 }
1308 else if (iIso3 == +2) {
1309 // K+ + anti_K0
1310 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, "kaon+", "anti_kaon0");
1311 decayTable->Insert(mode);
1312 }
1313 else if (iIso3 == -2) {
1314 // K- + K0
1315 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, "kaon-", "kaon0");
1316 decayTable->Insert(mode);
1317 }
1318
1319 return decayTable;
1320}

Referenced by CreateDecayTable().

◆ Add2KPiMode()

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

Definition at line 1322 of file G4ExcitedMesonConstructor.cc.

1325{
1326 // X(I=0)-->KKpi
1327 if (iIso != 0) return decayTable;
1328
1329 G4VDecayChannel* mode;
1330
1331 // K+ + K- + pi0
1332 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 6., 3, "kaon+", "kaon-", "pi0");
1333 decayTable->Insert(mode);
1334
1335 // K0 + Anti_K0 + pi0
1336 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 6., 3, "kaon0", "anti_kaon0", "pi0");
1337 decayTable->Insert(mode);
1338
1339 // K+ + anti_K0 + pi-
1340 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3., 3, "kaon+", "anti_kaon0", "pi-");
1341 decayTable->Insert(mode);
1342
1343 // K- + K0 + pi+
1344 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3., 3, "kaon-", "kaon0", "pi+");
1345 decayTable->Insert(mode);
1346
1347 return decayTable;
1348}

Referenced by CreateDecayTable().

◆ Add2PiEtaMode()

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

Definition at line 1117 of file G4ExcitedMesonConstructor.cc.

1120{
1121 // f1-->eta + pi + pi mode
1122
1123 if (iIso != 0) return decayTable;
1124
1125 G4VDecayChannel* mode;
1126
1127 // eta pi+ pi-
1128 mode = new G4PhaseSpaceDecayChannel(nameParent, br * 2. / 3., 3, "eta", "pi+", "pi-");
1129 decayTable->Insert(mode);
1130
1131 // eta pi+ pi-
1132 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3., 3, "eta", "pi0", "pi0");
1133 decayTable->Insert(mode);
1134 return decayTable;
1135}

Referenced by CreateDecayTable().

◆ Add2PiMode()

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

Definition at line 819 of file G4ExcitedMesonConstructor.cc.

822{
823 G4VDecayChannel* mode;
824
825 G4String daughterPi1;
826 G4String daughterPi2;
827 G4double r;
828
829 // I = 0 states
830 if (iIso == 0) {
831 if (iIso3 == 0) {
832 // pi+ + pi-
833 daughterPi1 = "pi+";
834 daughterPi2 = "pi-";
835 r = br * 2. / 3.;
836 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, 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, daughterPi1, daughterPi2);
844 decayTable->Insert(mode);
845 }
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, daughterPi1, daughterPi2);
854 // add decay table
855 decayTable->Insert(mode);
856 }
857 else if (iIso3 == 0) {
858 // pi+ + pi-
859 daughterPi1 = "pi+";
860 daughterPi2 = "pi-";
861 r = br;
862 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterPi1, daughterPi2);
863 decayTable->Insert(mode);
864 }
865 else if (iIso3 == -2) {
866 // pi- + pi0
867 daughterPi1 = "pi-";
868 daughterPi2 = "pi0";
869 r = br;
870 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2, daughterPi1, daughterPi2);
871 decayTable->Insert(mode);
872 }
873 }
874 return decayTable;
875}
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 1151 of file G4ExcitedMesonConstructor.cc.

1154{
1155 G4VDecayChannel* mode;
1156 if (iIso == 0) {
1157 // omega pi+ pi-
1158 mode = new G4PhaseSpaceDecayChannel(nameParent, br * 2. / 3., 3, "omega", "pi+", "pi-");
1159 decayTable->Insert(mode);
1160
1161 // omega pi+ pi-
1162 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3., 3, "omega", "pi0", "pi0");
1163 decayTable->Insert(mode);
1164 }
1165 else if (iIso == 2) {
1166 if (iIso3 == +2) {
1167 // omega pi+ pi0
1168 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 3, "omega", "pi+", "pi0");
1169 decayTable->Insert(mode);
1170 }
1171 else if (iIso3 == 0) {
1172 // omega pi+ pi-
1173 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2., 3, "omega", "pi-", "pi+");
1174 decayTable->Insert(mode);
1175 // omega pi0 pi0
1176 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2., 3, "omega", "pi0", "pi0");
1177 decayTable->Insert(mode);
1178 }
1179 else if (iIso3 == -2) {
1180 // omega pi- pi0
1181 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 3, "omega", "pi-", "pi0");
1182 decayTable->Insert(mode);
1183 }
1184 }
1185 return decayTable;
1186}

Referenced by CreateDecayTable().

◆ Add2PiRhoMode()

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

Definition at line 1188 of file G4ExcitedMesonConstructor.cc.

1191{
1192 G4VDecayChannel* mode;
1193
1194 if (iIso == 0) {
1195 // f1 --> rho0 + pi+ pi-
1196 // rho0 pi+ pi-
1197 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 5., 3, "rho0", "pi+", "pi-");
1198 decayTable->Insert(mode);
1199 }
1200 else if (iIso == 2) {
1201 if (iIso3 == +2) {
1202 // rho+ pi0 pi0
1203 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 5., 3, "rho+", "pi0", "pi0");
1204 decayTable->Insert(mode);
1205 // rho+ pi+ pi-
1206 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 5., 3, "rho+", "pi+", "pi-");
1207 decayTable->Insert(mode);
1208 // rho0 pi+ pi0
1209 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 5., 3, "rho0", "pi+", "pi0");
1210 decayTable->Insert(mode);
1211 // rho- pi+ pi+
1212 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 5., 3, "rho-", "pi+", "pi+");
1213 decayTable->Insert(mode);
1214 }
1215 else if (iIso3 == -2) {
1216 // rho- pi0 pi0
1217 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 5., 3, "rho-", "pi0", "pi0");
1218 decayTable->Insert(mode);
1219 // rho- pi+ pi-
1220 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 5., 3, "rho-", "pi+", "pi-");
1221 decayTable->Insert(mode);
1222 // rho0 pi- pi0
1223 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 5., 3, "rho0", "pi-", "pi0");
1224 decayTable->Insert(mode);
1225 // rho+ pi- pi-
1226 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 5., 3, "rho+", "pi-", "pi-");
1227 decayTable->Insert(mode);
1228 }
1229 else if (iIso3 == 0) {
1230 // rho+ pi- pi0
1231 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 5., 3, "rho+", "pi-", "pi0");
1232 decayTable->Insert(mode);
1233 // rho0 pi+ pi-
1234 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 5., 3, "rho0", "pi+", "pi-");
1235 decayTable->Insert(mode);
1236 // rho0 pi0 pi0
1237 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 5., 3, "rho0", "pi0", "pi0");
1238 decayTable->Insert(mode);
1239 // rho- pi+ pi0
1240 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 5., 3, "rho-", "pi+", "pi-");
1241 decayTable->Insert(mode);
1242 }
1243 }
1244 return decayTable;
1245}

Referenced by CreateDecayTable().

◆ Add3PiMode()

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

Definition at line 1047 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add4PiMode()

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

Definition at line 1084 of file G4ExcitedMesonConstructor.cc.

1087{
1088 G4VDecayChannel* mode;
1089
1090 if (iIso3 == 0) {
1091 // 2pi+ + 2pi-
1092 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2., 4, "pi+", "pi-", "pi+", "pi-");
1093 decayTable->Insert(mode);
1094 // pi+ + pi- + 2pi0
1095 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2., 4, "pi+", "pi-", "pi0", "pi0");
1096 decayTable->Insert(mode);
1097 }
1098 else if (iIso3 == +2) {
1099 // pi+ + 3pi0
1100 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3., 4, "pi+", "pi0", "pi0", "pi0");
1101 decayTable->Insert(mode);
1102 // 2pi+ + pi- + pi0
1103 mode = new G4PhaseSpaceDecayChannel(nameParent, br * 2. / 3., 4, "pi+", "pi+", "pi-", "pi0");
1104 decayTable->Insert(mode);
1105 }
1106 else if (iIso3 == -2) {
1107 // pi- + 3pi0
1108 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3., 4, "pi-", "pi0", "pi0", "pi0");
1109 decayTable->Insert(mode);
1110 // 2pi- + pi+ + pi0
1111 mode = new G4PhaseSpaceDecayChannel(nameParent, br * 2. / 3., 4, "pi-", "pi-", "pi+", "pi0");
1112 decayTable->Insert(mode);
1113 }
1114 return decayTable;
1115}

Referenced by CreateDecayTable().

◆ AddKEtaMode()

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

Definition at line 471 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKKStarMode()

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

Definition at line 1247 of file G4ExcitedMesonConstructor.cc.

1250{
1251 G4VDecayChannel* mode;
1252
1253 if (iIso3 == 0) {
1254 // X(I=0,J=1)-->K + Anti-K*, Anti_K + K* mode
1255 // K+ + K*-
1256 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 4., 2, "kaon+", "k_star-");
1257 decayTable->Insert(mode);
1258
1259 // K- + K*+
1260 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 4., 2, "kaon-", "k_star0");
1261 decayTable->Insert(mode);
1262
1263 // K0 + Anti_K*0
1264 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 4., 2, "kaon0", "anti_k_star0");
1265 decayTable->Insert(mode);
1266
1267 // Anti_K0 + K*0
1268 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 4., 2, "anti_kaon0", "k_star0");
1269 decayTable->Insert(mode);
1270 }
1271 else if (iIso3 == 2) {
1272 // K+ + Anti_K*0
1273 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2., 2, "kaon+", "anti_k_star0");
1274 decayTable->Insert(mode);
1275
1276 // K0 + K*+
1277 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2., 2, "anti_kaon0", "k_star+");
1278 decayTable->Insert(mode);
1279 }
1280 else if (iIso3 == -2) {
1281 // K- + K*0
1282 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2., 2, "kaon-", "k_star0");
1283 decayTable->Insert(mode);
1284
1285 // K0 + K*-
1286 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 2., 2, "kaon0", "k_star-");
1287 decayTable->Insert(mode);
1288 }
1289
1290 return decayTable;
1291}

Referenced by CreateDecayTable().

◆ AddKOmegaMode()

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

Definition at line 441 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKPiMode()

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

Definition at line 365 of file G4ExcitedMesonConstructor.cc.

368{
369 G4VDecayChannel* mode;
370 //
371 if (iIso3 == +1) {
372 if (iType == TK) {
373 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3., 2, "kaon+", "pi0");
374 decayTable->Insert(mode);
375 mode = new G4PhaseSpaceDecayChannel(nameParent, br * 2. / 3., 2, "kaon0", "pi+");
376 decayTable->Insert(mode);
377 }
378 else if (iType == TAntiK) {
379 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3., 2, "anti_kaon0", "pi0");
380 decayTable->Insert(mode);
381 mode = new G4PhaseSpaceDecayChannel(nameParent, br * 2. / 3., 2, "kaon-", "pi+");
382 decayTable->Insert(mode);
383 }
384 }
385 else if (iIso3 == -1) {
386 if (iType == TK) {
387 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3., 2, "kaon0", "pi0");
388 decayTable->Insert(mode);
389 mode = new G4PhaseSpaceDecayChannel(nameParent, br * 2. / 3., 2, "kaon+", "pi-");
390 decayTable->Insert(mode);
391 }
392 else if (iType == TAntiK) {
393 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3., 2, "kaon-", "pi0");
394 decayTable->Insert(mode);
395 mode = new G4PhaseSpaceDecayChannel(nameParent, br * 2. / 3., 2, "anti_kaon0", "pi-");
396 decayTable->Insert(mode);
397 }
398 }
399
400 return decayTable;
401}

Referenced by CreateDecayTable().

◆ AddKRhoMode()

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

Definition at line 501 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKStar2PiMode()

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

Definition at line 577 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKStarPiMode()

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

Definition at line 539 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKTwoPiMode()

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

Definition at line 402 of file G4ExcitedMesonConstructor.cc.

405{
406 G4VDecayChannel* mode;
407 //
408 if (iIso3 == +1) {
409 if (iType == TK) {
410 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3., 2, "k2_star(1430)+", "pi0");
411 decayTable->Insert(mode);
412 mode = new G4PhaseSpaceDecayChannel(nameParent, br * 2. / 3., 2, "k2_star(1430)0", "pi+");
413 decayTable->Insert(mode);
414 }
415 else if (iType == TAntiK) {
416 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3., 2, "anti_k2_star(1430)0", "pi0");
417 decayTable->Insert(mode);
418 mode = new G4PhaseSpaceDecayChannel(nameParent, br * 2. / 3., 2, "k2_star(1430)-", "pi+");
419 decayTable->Insert(mode);
420 }
421 }
422 else if (iIso3 == -1) {
423 if (iType == TK) {
424 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3., 2, "k2_star(1430)0", "pi0");
425 decayTable->Insert(mode);
426 mode = new G4PhaseSpaceDecayChannel(nameParent, br * 2. / 3., 2, "k2_star(1430)+", "pi-");
427 decayTable->Insert(mode);
428 }
429 else if (iType == TAntiK) {
430 mode = new G4PhaseSpaceDecayChannel(nameParent, br / 3., 2, "k2_star(1430)-", "pi0");
431 decayTable->Insert(mode);
432 mode =
433 new G4PhaseSpaceDecayChannel(nameParent, br * 2. / 3., 2, "anti_k2_star(1430)0", "pi-");
434 decayTable->Insert(mode);
435 }
436 }
437
438 return decayTable;
439}

Referenced by CreateDecayTable().

◆ AddPiA2Mode()

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

Definition at line 962 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiEtaMode()

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

Definition at line 704 of file G4ExcitedMesonConstructor.cc.

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

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 }
803 else if (iIso3 == 0) {
804 daughter = "pi0";
805 }
806 else if (iIso3 == -2) {
807 daughter = "pi-";
808 }
809 else {
810 return decayTable;
811 }
812 // create decay channel [parent BR #daughters]
813 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, daughter, "f0(1370)");
814 // add decay table
815 decayTable->Insert(mode);
816 return decayTable;
817}

Referenced by CreateDecayTable().

◆ AddPiF2Mode()

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

Definition at line 762 of file G4ExcitedMesonConstructor.cc.

765{
766 if ((iIso != 2) && (iIso != 0)) return decayTable;
767
768 G4VDecayChannel* mode;
769 //
770 G4String daughter;
771 if (iIso3 == +2) {
772 daughter = "pi+";
773 }
774 else if (iIso3 == 0) {
775 daughter = "pi0";
776 }
777 else if (iIso3 == -2) {
778 daughter = "pi-";
779 }
780 else {
781 return decayTable;
782 }
783 // create decay channel [parent BR #daughters]
784 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, 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 617 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiOmegaMode()

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

Definition at line 646 of file G4ExcitedMesonConstructor.cc.

649{
650 if ((iIso != 2) && (iIso != 0)) return decayTable;
651
652 G4VDecayChannel* mode;
653 //
654 G4String daughter;
655 if (iIso3 == +2) {
656 daughter = "pi+";
657 }
658 else if (iIso3 == 0) {
659 daughter = "pi0";
660 }
661 else if (iIso3 == -2) {
662 daughter = "pi-";
663 }
664 else {
665 return decayTable;
666 }
667 // create decay channel [parent BR #daughters]
668 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, 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 877 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddRhoEtaMode()

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

Definition at line 733 of file G4ExcitedMesonConstructor.cc.

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

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 }
687 else if (iIso3 == 0) {
688 daughter = "rho0";
689 }
690 else if (iIso3 == -2) {
691 daughter = "rho-";
692 }
693 else {
694 return decayTable;
695 }
696 // create decay channel [parent BR #daughters]
697 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2, daughter, "gamma");
698 // add decay table
699 decayTable->Insert(mode);
700
701 return decayTable;
702}

Referenced by CreateDecayTable().

◆ Construct()

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

Definition at line 48 of file G4ExcitedMesonConstructor.cc.

49{
50 G4int iType;
51 if (idx < 0) {
52 for (G4int state = 0; state < NMultiplets; state += 1) {
53 for (iType = 0; iType < NMesonTypes; iType++)
54 ConstructMesons(state, iType);
55 }
56 }
57 else if (idx < NMultiplets) {
58 for (iType = 0; iType < NMesonTypes; iType++)
59 ConstructMesons(idx, iType);
60 }
61 else {
62#ifdef G4VERBOSE
63 if (G4ParticleTable::GetParticleTable()->GetVerboseLevel() > 1) {
64 G4cerr << "G4ExcitedMesonConstructor::Construct()";
65 G4cerr << " illegal index os state = " << idx << G4endl;
66 }
67#endif
68 }
69}
G4int
int G4int
Definition G4Types.hh:85
G4cerr
G4GLOB_DLL std::ostream G4cerr
G4endl
#define G4endl
Definition G4ios.hh:67
G4ExcitedMesonConstructor::ConstructMesons
void ConstructMesons(G4int indexOfState, G4int indexOfType)
Definition G4ExcitedMesonConstructor.cc:84
G4ParticleTable::GetParticleTable
static G4ParticleTable * GetParticleTable()
Definition G4ParticleTable.cc:82

Referenced by G4ShortLivedConstructor::ConstructResonances().

◆ ConstructMesons()

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

Definition at line 84 of file G4ExcitedMesonConstructor.cc.

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

274{
275 // create decay table
276 auto decayTable = new G4DecayTable();
277 G4double br;
278
279 if ((iType == TK) || (iType == TAntiK)) {
280 if ((br = bRatio[iState][iType][MKPi]) > 0.0) {
281 AddKPiMode(decayTable, parentName, br, iIso3, iType);
282 }
283 if ((br = bRatio[iState][iType][MKStarPi]) > 0.0) {
284 AddKStarPiMode(decayTable, parentName, br, iIso3, iType);
285 }
286 if ((br = bRatio[iState][iType][MKRho]) > 0.0) {
287 AddKRhoMode(decayTable, parentName, br, iIso3, iType);
288 }
289 if ((br = bRatio[iState][iType][MKOmega]) > 0.0) {
290 AddKOmegaMode(decayTable, parentName, br, iIso3, iType);
291 }
292 if ((br = bRatio[iState][iType][MKStar2Pi]) > 0.0) {
293 AddKStar2PiMode(decayTable, parentName, br, iIso3, iType);
294 }
295 if ((br = bRatio[iState][iType][MKTwoPi]) > 0.0) {
296 AddKTwoPiMode(decayTable, parentName, br, iIso3, iType);
297 }
298 if ((br = bRatio[iState][iType][MKEta]) > 0.0) {
299 AddKEtaMode(decayTable, parentName, br, iIso3, iType);
300 }
301 }
302 else {
303 if ((br = bRatio[iState][iType][MPiGamma]) > 0.0) {
304 AddPiGammaMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
305 }
306 if ((br = bRatio[iState][iType][MRhoGamma]) > 0.0) {
307 AddRhoGammaMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
308 }
309 if ((br = bRatio[iState][iType][M2Pi]) > 0.0) {
310 Add2PiMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
311 }
312 if ((br = bRatio[iState][iType][MPiRho]) > 0.0) {
313 AddPiRhoMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
314 }
315 if ((br = bRatio[iState][iType][MPiEta]) > 0.0) {
316 AddPiEtaMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
317 }
318 if ((br = bRatio[iState][iType][M3Pi]) > 0.0) {
319 Add3PiMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
320 }
321 if ((br = bRatio[iState][iType][M4Pi]) > 0.0) {
322 Add4PiMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
323 }
324 if ((br = bRatio[iState][iType][MKKStar]) > 0.0) {
325 AddKKStarMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
326 }
327 if ((br = bRatio[iState][iType][M2PiEta]) > 0.0) {
328 Add2PiEtaMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
329 }
330 if ((br = bRatio[iState][iType][MRhoEta]) > 0.0) {
331 AddRhoEtaMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
332 }
333 if ((br = bRatio[iState][iType][M2PiRho]) > 0.0) {
334 Add2PiRhoMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
335 }
336 if ((br = bRatio[iState][iType][M2PiOmega]) > 0.0) {
337 Add2PiOmegaMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
338 }
339 if ((br = bRatio[iState][iType][M2Eta]) > 0.0) {
340 Add2EtaMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
341 }
342 if ((br = bRatio[iState][iType][M2K]) > 0.0) {
343 Add2KMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
344 }
345 if ((br = bRatio[iState][iType][M2KPi]) > 0.0) {
346 Add2KPiMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
347 }
348 if ((br = bRatio[iState][iType][MPiOmega]) > 0.0) {
349 AddPiOmegaMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
350 }
351 if ((br = bRatio[iState][iType][MPiF2]) > 0.0) {
352 AddPiF2Mode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
353 }
354 if ((br = bRatio[iState][iType][MPiF0]) > 0.0) {
355 AddPiF0Mode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
356 }
357 if ((br = bRatio[iState][iType][MPiA2]) > 0.0) {
358 AddPiA2Mode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
359 }
360 }
361
362 return decayTable;
363}
G4ExcitedMesonConstructor::Add3PiMode
G4DecayTable * Add3PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:1047
G4ExcitedMesonConstructor::AddKRhoMode
G4DecayTable * AddKRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition G4ExcitedMesonConstructor.cc:501
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:962
G4ExcitedMesonConstructor::AddKStarPiMode
G4DecayTable * AddKStarPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition G4ExcitedMesonConstructor.cc:539
G4ExcitedMesonConstructor::AddKOmegaMode
G4DecayTable * AddKOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition G4ExcitedMesonConstructor.cc:441
G4ExcitedMesonConstructor::Add2KPiMode
G4DecayTable * Add2KPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:1322
G4ExcitedMesonConstructor::Add2PiMode
G4DecayTable * Add2PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:819
G4ExcitedMesonConstructor::AddKTwoPiMode
G4DecayTable * AddKTwoPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition G4ExcitedMesonConstructor.cc:402
G4ExcitedMesonConstructor::AddPiOmegaMode
G4DecayTable * AddPiOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:646
G4ExcitedMesonConstructor::AddPiF2Mode
G4DecayTable * AddPiF2Mode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:762
G4ExcitedMesonConstructor::AddKPiMode
G4DecayTable * AddKPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition G4ExcitedMesonConstructor.cc:365
G4ExcitedMesonConstructor::AddPiEtaMode
G4DecayTable * AddPiEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:704
G4ExcitedMesonConstructor::AddKStar2PiMode
G4DecayTable * AddKStar2PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition G4ExcitedMesonConstructor.cc:577
G4ExcitedMesonConstructor::AddKEtaMode
G4DecayTable * AddKEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition G4ExcitedMesonConstructor.cc:471
G4ExcitedMesonConstructor::AddRhoEtaMode
G4DecayTable * AddRhoEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:733
G4ExcitedMesonConstructor::Add2PiOmegaMode
G4DecayTable * Add2PiOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:1151
G4ExcitedMesonConstructor::Add2PiEtaMode
G4DecayTable * Add2PiEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:1117
G4ExcitedMesonConstructor::Add2PiRhoMode
G4DecayTable * Add2PiRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:1188
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:1084
G4ExcitedMesonConstructor::Add2EtaMode
G4DecayTable * Add2EtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:1137
G4ExcitedMesonConstructor::bRatio
static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes]
Definition G4ExcitedMesonConstructor.hh:1460
G4ExcitedMesonConstructor::AddPiGammaMode
G4DecayTable * AddPiGammaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:617
G4ExcitedMesonConstructor::Add2KMode
G4DecayTable * Add2KMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:1293
G4ExcitedMesonConstructor::AddKKStarMode
G4DecayTable * AddKKStarMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:1247
G4ExcitedMesonConstructor::AddPiRhoMode
G4DecayTable * AddPiRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:877

Referenced by ConstructMesons().

◆ Exist()

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

Definition at line 71 of file G4ExcitedMesonConstructor.cc.

72{
73 G4bool value = true;
74 if (idxType == TEtaPrime) {
75 if (idxState == N13P0) value = false;
76 if (idxState == N13D1) value = false;
77 }
78 else if (idxType == TPi) {
79 if (idxState == N23P2) value = false;
80 }
81 return value;
82}
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 206 of file G4ExcitedMesonConstructor.cc.

207{
208 // clang-format off
209 static const G4double quark_charge[7] =
210 {
211 0., -1./3., +2./3., -1./3., +2./3., -1./3., +2./3.
212 };
213 // clang-format on
214
215 G4double charge = quark_charge[GetQuarkContents(0, iIsoSpin3, idxType)] * eplus;
216 charge -= quark_charge[GetQuarkContents(1, iIsoSpin3, idxType)] * eplus;
217 return charge;
218}
G4ExcitedMesonConstructor::GetQuarkContents
G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType)
Definition G4ExcitedMesonConstructor.cc:135

◆ GetEncoding()

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

Definition at line 220 of file G4ExcitedMesonConstructor.cc.

221{
222 G4int encoding = encodingOffset[idxState];
223 encoding += iSpin[idxState] + 1;
224 G4int iQ = 0;
225 G4int iQbar = 1;
226
227 if (idxType == TPi) {
228 if (iIsoSpin3 < 0) {
229 iQ = 1;
230 iQbar = 0;
231 }
232 }
233 else if (idxType == TK) {
234 iQ = 1;
235 iQbar = 0;
236 }
237
238 encoding += 100 * GetQuarkContents(iQ, iIsoSpin3, idxType);
239 encoding += 10 * GetQuarkContents(iQbar, iIsoSpin3, idxType);
240 if (idxType == TPi) {
241 if (iIsoSpin3 < 0) {
242 encoding *= -1;
243 }
244 }
245 else if (idxType == TAntiK) {
246 encoding *= -1;
247 }
248
249 // PDG2005
250 //
251 if (idxState == 9) {
252 if (idxType == TEta) {
253 // f2(1810) 9030225
254 encoding = 9030225;
255 }
256 else if (idxType == TEtaPrime) {
257 // f2(2010) 9060225
258 encoding = 9060225;
259 }
260 }
261
262 // PDG2013
263 if (idxState == 1) {
264 if (idxType == TEta) {
265 // f0(1370) 30221
266 encoding = 30221;
267 }
268 }
269 return encoding;
270}
G4ExcitedMesonConstructor::encodingOffset
static const G4int encodingOffset[NMultiplets]
Definition G4ExcitedMesonConstructor.hh:1454

Referenced by ConstructMesons().

◆ GetName()

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

Definition at line 207 of file G4ExcitedMesonConstructor.hh.

208{
209 G4String particle = name[iState][iType];
210 if (iType == TPi) {
211 if (iIso3 == +2) {
212 particle += "+";
213 }
214 else if (iIso3 == -2) {
215 particle += "-";
216 }
217 else {
218 particle += "0";
219 }
220 }
221 else if (iType == TK) {
222 if (iIso3 == +1) {
223 particle += "+";
224 }
225 else if (iIso3 == -1) {
226 particle += "0";
227 }
228 }
229 else if (iType == TAntiK) {
230 if (iIso3 == +1) {
231 particle += "0";
232 particle = "anti_" + particle;
233 }
234 else if (iIso3 == -1) {
235 particle += "-";
236 }
237 }
238 return particle;
239}

Referenced by ConstructMesons().

◆ GetQuarkContents()

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

Definition at line 135 of file G4ExcitedMesonConstructor.cc.

136{
137 // Quark contents
138
139 G4int quark = 0;
140 if (iType == TPi) {
141 if (iIso3 == 2) {
142 if (iQ == 0) {
143 quark = 2;
144 }
145 else {
146 quark = 1;
147 }
148 }
149 else if (iIso3 == 0) {
150 quark = 1;
151 }
152 else if (iIso3 == -2) {
153 if (iQ == 0) {
154 quark = 1;
155 }
156 else {
157 quark = 2;
158 }
159 }
160 }
161 else if (iType == TEta) {
162 quark = 2;
163 }
164 else if (iType == TEtaPrime) {
165 quark = 3;
166 }
167 else if (iType == TAntiK) {
168 if (iIso3 == 1) {
169 if (iQ == 0) {
170 quark = 3;
171 }
172 else {
173 quark = 1;
174 }
175 }
176 else if (iIso3 == -1) {
177 if (iQ == 0) {
178 quark = 3;
179 }
180 else {
181 quark = 2;
182 }
183 }
184 }
185 else if (iType == TK) {
186 if (iIso3 == 1) {
187 if (iQ == 0) {
188 quark = 2;
189 }
190 else {
191 quark = 3;
192 }
193 }
194 else if (iIso3 == -1) {
195 if (iQ == 0) {
196 quark = 1;
197 }
198 else {
199 quark = 3;
200 }
201 }
202 }
203 return quark;
204}

Referenced by GetCharge(), and GetEncoding().

Member Data Documentation

◆ baryonNumber

const G4int G4ExcitedMesonConstructor::baryonNumber {0}
protected

Definition at line 157 of file G4ExcitedMesonConstructor.hh.

157{0};

Referenced by ConstructMesons().

◆ bRatio

const G4double G4ExcitedMesonConstructor::bRatio
staticprotected

Definition at line 1460 of file G4ExcitedMesonConstructor.hh.

1498{
1499 // This class is a utility class for construction
1500 // short lived particles
1501 public:
1502 enum
1503 {
1504 NMultiplets = 10
1505 };
1506
1507 enum
1508 {
1509 NMesonTypes = 5
1510 };
1511
1512 enum
1513 {
1514 NumberOfDecayModes = 19
1515 };
1516
1517 public:
1518 G4ExcitedMesonConstructor(G4int nStates = 0, G4int isoSpin = 0);
1519 virtual ~G4ExcitedMesonConstructor() = default;
1520
1521 virtual void Construct(G4int indexOfState = -1);
1522
1523 protected:
1524 void ConstructMesons(G4int indexOfState, G4int indexOfType);
1525
1526 G4String GetName(G4int iIso3, G4int iState, G4int idxType);
1527 G4double GetCharge(G4int iIsoSpin3);
1528 G4int GetEncoding(G4int iIsoSpin3, G4int idxState, G4int idxType);
1529 G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType);
1530
1531 protected:
1532 G4DecayTable* CreateDecayTable(const G4String&, G4int, G4int, G4int);
1533
1534 G4DecayTable* AddKPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1535 G4int iType);
1536 G4DecayTable* AddKStarPiMode(G4DecayTable* table, const G4String& name, G4double br,
1537 G4int iIso3, G4int iType);
1538 G4DecayTable* AddKStar2PiMode(G4DecayTable* table, const G4String& name, G4double br,
1539 G4int iIso3, G4int iType);
1540 G4DecayTable* AddKRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1541 G4int iType);
1542 G4DecayTable* AddKTwoPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1543 G4int iType);
1544 G4DecayTable* AddKOmegaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1545 G4int iType);
1546 G4DecayTable* AddKEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1547 G4int iType);
1548 G4DecayTable* AddPiGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1549 G4int iIso3, G4int iIso);
1550 G4DecayTable* AddRhoGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1551 G4int iIso3, G4int iIso);
1552 G4DecayTable* Add2PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1553 G4int iIso);
1554 G4DecayTable* AddPiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1555 G4int iIso);
1556 G4DecayTable* AddPiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1557 G4int iIso);
1558 G4DecayTable* AddPiF2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1559 G4int iIso);
1560 G4DecayTable* AddPiF0Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1561 G4int iIso);
1562 G4DecayTable* AddPiA2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1563 G4int iIso);
1564 G4DecayTable* Add3PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1565 G4int iIso);
1566 G4DecayTable* Add4PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1567 G4int iIso);
1568 G4DecayTable* AddKKStarMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1569 G4int iIso);
1570 G4DecayTable* Add2PiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1571 G4int iIso);
1572 G4DecayTable* AddRhoEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1573 G4int iIso);
1574 G4DecayTable* Add2PiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1575 G4int iIso);
1576 G4DecayTable* Add2PiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1577 G4int iIso3, G4int iIso);
1578 G4DecayTable* AddPiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1579 G4int iIso3, G4int iIso);
1580 G4DecayTable* Add2EtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1581 G4int iIso);
1582 G4DecayTable* Add2KMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1583 G4int iIso);
1584 G4DecayTable* Add2KPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1585 G4int iIso);
1586
1587 G4bool Exist(G4int idxState, G4int idxType);
1588 G4double GetCharge(G4int iIsoSpin3, G4int idxType);
1589
1590 protected:
1591 enum
1592 {
1593 N11P1 = 0,
1594 N13P0 = 1,
1595 N13P1 = 2,
1596 N13P2 = 3,
1597 N11D2 = 4,
1598 N13D1 = 5,
1599 N13D3 = 6,
1600 N21S0 = 7,
1601 N23S1 = 8,
1602 N23P2 = 9
1603 };
1604
1605 enum
1606 {
1607 TPi = 0,
1608 TEta = 1,
1609 TEtaPrime = 2,
1610 TK = 3,
1611 TAntiK = 4
1612 };
1613
1614 const G4String type;
1615 const G4int leptonNumber{0};
1616 const G4int baryonNumber{0};
1617
1618 static const char* name[NMultiplets][NMesonTypes];
1619 static const G4double mass[NMultiplets][NMesonTypes];
1620 static const G4double massKdiff[NMultiplets];
1621 static const G4double width[NMultiplets][NMesonTypes];
1622 static const G4double widthKdiff[NMultiplets];
1623 static const G4int iIsoSpin[NMesonTypes];
1624 static const G4int iSpin[NMultiplets];
1625 static const G4int iParity[NMultiplets];
1626 static const G4int iGParity[NMultiplets][NMesonTypes];
1627 static const G4int iChargeConjugation[NMultiplets];
1628 static const G4int encodingOffset[NMultiplets];
1629
1630 enum
1631 {
1632 MPiGamma = 0,
1633 MRhoGamma = 1,
1634 M2Pi = 2,
1635 MPiRho = 3,
1636 M3Pi = 4,
1637 MPiEta = 5,
1638 M4Pi = 6,
1639 MKKStar = 7,
1640 M2PiEta = 8,
1641 MRhoEta = 9,
1642 M2PiRho = 10,
1643 M2PiOmega = 11,
1644 M2Eta = 12,
1645 M2K = 13,
1646 M2KPi = 14,
1647 MPiOmega = 15,
1648 MPiF2 = 16,
1649 MPiF0 = 17,
1650 MPiA2 = 18
1651 };
1652 enum
1653 {
1654 MKPi = 0,
1655 MKStarPi = 1,
1656 MKRho = 2,
1657 MKOmega = 3,
1658 MKStar2Pi = 4,
1659 MKTwoPi = 5,
1660 MKEta = 6
1661 };
1662
1663 static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes];
1664};
1665
1666inline G4String G4ExcitedMesonConstructor::GetName(G4int iIso3, G4int iState, G4int iType)
1667{
1668 G4String particle = name[iState][iType];
1669 if (iType == TPi) {
1670 if (iIso3 == +2) {
1671 particle += "+";
1672 }
1673 else if (iIso3 == -2) {
1674 particle += "-";
1675 }
1676 else {
1677 particle += "0";
1678 }
1679 }
1680 else if (iType == TK) {
1681 if (iIso3 == +1) {
1682 particle += "+";
1683 }
1684 else if (iIso3 == -1) {
1685 particle += "0";
1686 }
1687 }
1688 else if (iType == TAntiK) {
1689 if (iIso3 == +1) {
1690 particle += "0";
1691 particle = "anti_" + particle;
1692 }
1693 else if (iIso3 == -1) {
1694 particle += "-";
1695 }
1696 }
1697 return particle;
1698}
1699
1700#endif
G4ExcitedMesonConstructor::G4ExcitedMesonConstructor
G4ExcitedMesonConstructor(G4int nStates=0, G4int isoSpin=0)
Definition G4ExcitedMesonConstructor.cc:46
G4ExcitedMesonConstructor::~G4ExcitedMesonConstructor
virtual ~G4ExcitedMesonConstructor()=default
G4ExcitedMesonConstructor::Construct
virtual void Construct(G4int indexOfState=-1)
Definition G4ExcitedMesonConstructor.cc:48

Referenced by CreateDecayTable().

◆ encodingOffset

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

Definition at line 1454 of file G4ExcitedMesonConstructor.hh.

1492{
1493 // This class is a utility class for construction
1494 // short lived particles
1495 public:
1496 enum
1497 {
1498 NMultiplets = 10
1499 };
1500
1501 enum
1502 {
1503 NMesonTypes = 5
1504 };
1505
1506 enum
1507 {
1508 NumberOfDecayModes = 19
1509 };
1510
1511 public:
1512 G4ExcitedMesonConstructor(G4int nStates = 0, G4int isoSpin = 0);
1513 virtual ~G4ExcitedMesonConstructor() = default;
1514
1515 virtual void Construct(G4int indexOfState = -1);
1516
1517 protected:
1518 void ConstructMesons(G4int indexOfState, G4int indexOfType);
1519
1520 G4String GetName(G4int iIso3, G4int iState, G4int idxType);
1521 G4double GetCharge(G4int iIsoSpin3);
1522 G4int GetEncoding(G4int iIsoSpin3, G4int idxState, G4int idxType);
1523 G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType);
1524
1525 protected:
1526 G4DecayTable* CreateDecayTable(const G4String&, G4int, G4int, G4int);
1527
1528 G4DecayTable* AddKPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1529 G4int iType);
1530 G4DecayTable* AddKStarPiMode(G4DecayTable* table, const G4String& name, G4double br,
1531 G4int iIso3, G4int iType);
1532 G4DecayTable* AddKStar2PiMode(G4DecayTable* table, const G4String& name, G4double br,
1533 G4int iIso3, G4int iType);
1534 G4DecayTable* AddKRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1535 G4int iType);
1536 G4DecayTable* AddKTwoPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1537 G4int iType);
1538 G4DecayTable* AddKOmegaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1539 G4int iType);
1540 G4DecayTable* AddKEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1541 G4int iType);
1542 G4DecayTable* AddPiGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1543 G4int iIso3, G4int iIso);
1544 G4DecayTable* AddRhoGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1545 G4int iIso3, G4int iIso);
1546 G4DecayTable* Add2PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1547 G4int iIso);
1548 G4DecayTable* AddPiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1549 G4int iIso);
1550 G4DecayTable* AddPiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1551 G4int iIso);
1552 G4DecayTable* AddPiF2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1553 G4int iIso);
1554 G4DecayTable* AddPiF0Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1555 G4int iIso);
1556 G4DecayTable* AddPiA2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1557 G4int iIso);
1558 G4DecayTable* Add3PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1559 G4int iIso);
1560 G4DecayTable* Add4PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1561 G4int iIso);
1562 G4DecayTable* AddKKStarMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1563 G4int iIso);
1564 G4DecayTable* Add2PiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1565 G4int iIso);
1566 G4DecayTable* AddRhoEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1567 G4int iIso);
1568 G4DecayTable* Add2PiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1569 G4int iIso);
1570 G4DecayTable* Add2PiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1571 G4int iIso3, G4int iIso);
1572 G4DecayTable* AddPiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1573 G4int iIso3, G4int iIso);
1574 G4DecayTable* Add2EtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1575 G4int iIso);
1576 G4DecayTable* Add2KMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1577 G4int iIso);
1578 G4DecayTable* Add2KPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1579 G4int iIso);
1580
1581 G4bool Exist(G4int idxState, G4int idxType);
1582 G4double GetCharge(G4int iIsoSpin3, G4int idxType);
1583
1584 protected:
1585 enum
1586 {
1587 N11P1 = 0,
1588 N13P0 = 1,
1589 N13P1 = 2,
1590 N13P2 = 3,
1591 N11D2 = 4,
1592 N13D1 = 5,
1593 N13D3 = 6,
1594 N21S0 = 7,
1595 N23S1 = 8,
1596 N23P2 = 9
1597 };
1598
1599 enum
1600 {
1601 TPi = 0,
1602 TEta = 1,
1603 TEtaPrime = 2,
1604 TK = 3,
1605 TAntiK = 4
1606 };
1607
1608 const G4String type;
1609 const G4int leptonNumber{0};
1610 const G4int baryonNumber{0};
1611
1612 static const char* name[NMultiplets][NMesonTypes];
1613 static const G4double mass[NMultiplets][NMesonTypes];
1614 static const G4double massKdiff[NMultiplets];
1615 static const G4double width[NMultiplets][NMesonTypes];
1616 static const G4double widthKdiff[NMultiplets];
1617 static const G4int iIsoSpin[NMesonTypes];
1618 static const G4int iSpin[NMultiplets];
1619 static const G4int iParity[NMultiplets];
1620 static const G4int iGParity[NMultiplets][NMesonTypes];
1621 static const G4int iChargeConjugation[NMultiplets];
1622 static const G4int encodingOffset[NMultiplets];
1623
1624 enum
1625 {
1626 MPiGamma = 0,
1627 MRhoGamma = 1,
1628 M2Pi = 2,
1629 MPiRho = 3,
1630 M3Pi = 4,
1631 MPiEta = 5,
1632 M4Pi = 6,
1633 MKKStar = 7,
1634 M2PiEta = 8,
1635 MRhoEta = 9,
1636 M2PiRho = 10,
1637 M2PiOmega = 11,
1638 M2Eta = 12,
1639 M2K = 13,
1640 M2KPi = 14,
1641 MPiOmega = 15,
1642 MPiF2 = 16,
1643 MPiF0 = 17,
1644 MPiA2 = 18
1645 };
1646 enum
1647 {
1648 MKPi = 0,
1649 MKStarPi = 1,
1650 MKRho = 2,
1651 MKOmega = 3,
1652 MKStar2Pi = 4,
1653 MKTwoPi = 5,
1654 MKEta = 6
1655 };
1656
1657 static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes];
1658};
1659
1660inline G4String G4ExcitedMesonConstructor::GetName(G4int iIso3, G4int iState, G4int iType)
1661{
1662 G4String particle = name[iState][iType];
1663 if (iType == TPi) {
1664 if (iIso3 == +2) {
1665 particle += "+";
1666 }
1667 else if (iIso3 == -2) {
1668 particle += "-";
1669 }
1670 else {
1671 particle += "0";
1672 }
1673 }
1674 else if (iType == TK) {
1675 if (iIso3 == +1) {
1676 particle += "+";
1677 }
1678 else if (iIso3 == -1) {
1679 particle += "0";
1680 }
1681 }
1682 else if (iType == TAntiK) {
1683 if (iIso3 == +1) {
1684 particle += "0";
1685 particle = "anti_" + particle;
1686 }
1687 else if (iIso3 == -1) {
1688 particle += "-";
1689 }
1690 }
1691 return particle;
1692}
1693
1694#endif

Referenced by GetEncoding().

◆ iChargeConjugation

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

Definition at line 1432 of file G4ExcitedMesonConstructor.hh.

1470{
1471 // This class is a utility class for construction
1472 // short lived particles
1473 public:
1474 enum
1475 {
1476 NMultiplets = 10
1477 };
1478
1479 enum
1480 {
1481 NMesonTypes = 5
1482 };
1483
1484 enum
1485 {
1486 NumberOfDecayModes = 19
1487 };
1488
1489 public:
1490 G4ExcitedMesonConstructor(G4int nStates = 0, G4int isoSpin = 0);
1491 virtual ~G4ExcitedMesonConstructor() = default;
1492
1493 virtual void Construct(G4int indexOfState = -1);
1494
1495 protected:
1496 void ConstructMesons(G4int indexOfState, G4int indexOfType);
1497
1498 G4String GetName(G4int iIso3, G4int iState, G4int idxType);
1499 G4double GetCharge(G4int iIsoSpin3);
1500 G4int GetEncoding(G4int iIsoSpin3, G4int idxState, G4int idxType);
1501 G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType);
1502
1503 protected:
1504 G4DecayTable* CreateDecayTable(const G4String&, G4int, G4int, G4int);
1505
1506 G4DecayTable* AddKPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1507 G4int iType);
1508 G4DecayTable* AddKStarPiMode(G4DecayTable* table, const G4String& name, G4double br,
1509 G4int iIso3, G4int iType);
1510 G4DecayTable* AddKStar2PiMode(G4DecayTable* table, const G4String& name, G4double br,
1511 G4int iIso3, G4int iType);
1512 G4DecayTable* AddKRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1513 G4int iType);
1514 G4DecayTable* AddKTwoPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1515 G4int iType);
1516 G4DecayTable* AddKOmegaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1517 G4int iType);
1518 G4DecayTable* AddKEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1519 G4int iType);
1520 G4DecayTable* AddPiGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1521 G4int iIso3, G4int iIso);
1522 G4DecayTable* AddRhoGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1523 G4int iIso3, G4int iIso);
1524 G4DecayTable* Add2PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1525 G4int iIso);
1526 G4DecayTable* AddPiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1527 G4int iIso);
1528 G4DecayTable* AddPiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1529 G4int iIso);
1530 G4DecayTable* AddPiF2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1531 G4int iIso);
1532 G4DecayTable* AddPiF0Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1533 G4int iIso);
1534 G4DecayTable* AddPiA2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1535 G4int iIso);
1536 G4DecayTable* Add3PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1537 G4int iIso);
1538 G4DecayTable* Add4PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1539 G4int iIso);
1540 G4DecayTable* AddKKStarMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1541 G4int iIso);
1542 G4DecayTable* Add2PiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1543 G4int iIso);
1544 G4DecayTable* AddRhoEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1545 G4int iIso);
1546 G4DecayTable* Add2PiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1547 G4int iIso);
1548 G4DecayTable* Add2PiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1549 G4int iIso3, G4int iIso);
1550 G4DecayTable* AddPiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1551 G4int iIso3, G4int iIso);
1552 G4DecayTable* Add2EtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1553 G4int iIso);
1554 G4DecayTable* Add2KMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1555 G4int iIso);
1556 G4DecayTable* Add2KPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1557 G4int iIso);
1558
1559 G4bool Exist(G4int idxState, G4int idxType);
1560 G4double GetCharge(G4int iIsoSpin3, G4int idxType);
1561
1562 protected:
1563 enum
1564 {
1565 N11P1 = 0,
1566 N13P0 = 1,
1567 N13P1 = 2,
1568 N13P2 = 3,
1569 N11D2 = 4,
1570 N13D1 = 5,
1571 N13D3 = 6,
1572 N21S0 = 7,
1573 N23S1 = 8,
1574 N23P2 = 9
1575 };
1576
1577 enum
1578 {
1579 TPi = 0,
1580 TEta = 1,
1581 TEtaPrime = 2,
1582 TK = 3,
1583 TAntiK = 4
1584 };
1585
1586 const G4String type;
1587 const G4int leptonNumber{0};
1588 const G4int baryonNumber{0};
1589
1590 static const char* name[NMultiplets][NMesonTypes];
1591 static const G4double mass[NMultiplets][NMesonTypes];
1592 static const G4double massKdiff[NMultiplets];
1593 static const G4double width[NMultiplets][NMesonTypes];
1594 static const G4double widthKdiff[NMultiplets];
1595 static const G4int iIsoSpin[NMesonTypes];
1596 static const G4int iSpin[NMultiplets];
1597 static const G4int iParity[NMultiplets];
1598 static const G4int iGParity[NMultiplets][NMesonTypes];
1599 static const G4int iChargeConjugation[NMultiplets];
1600 static const G4int encodingOffset[NMultiplets];
1601
1602 enum
1603 {
1604 MPiGamma = 0,
1605 MRhoGamma = 1,
1606 M2Pi = 2,
1607 MPiRho = 3,
1608 M3Pi = 4,
1609 MPiEta = 5,
1610 M4Pi = 6,
1611 MKKStar = 7,
1612 M2PiEta = 8,
1613 MRhoEta = 9,
1614 M2PiRho = 10,
1615 M2PiOmega = 11,
1616 M2Eta = 12,
1617 M2K = 13,
1618 M2KPi = 14,
1619 MPiOmega = 15,
1620 MPiF2 = 16,
1621 MPiF0 = 17,
1622 MPiA2 = 18
1623 };
1624 enum
1625 {
1626 MKPi = 0,
1627 MKStarPi = 1,
1628 MKRho = 2,
1629 MKOmega = 3,
1630 MKStar2Pi = 4,
1631 MKTwoPi = 5,
1632 MKEta = 6
1633 };
1634
1635 static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes];
1636};
1637
1638inline G4String G4ExcitedMesonConstructor::GetName(G4int iIso3, G4int iState, G4int iType)
1639{
1640 G4String particle = name[iState][iType];
1641 if (iType == TPi) {
1642 if (iIso3 == +2) {
1643 particle += "+";
1644 }
1645 else if (iIso3 == -2) {
1646 particle += "-";
1647 }
1648 else {
1649 particle += "0";
1650 }
1651 }
1652 else if (iType == TK) {
1653 if (iIso3 == +1) {
1654 particle += "+";
1655 }
1656 else if (iIso3 == -1) {
1657 particle += "0";
1658 }
1659 }
1660 else if (iType == TAntiK) {
1661 if (iIso3 == +1) {
1662 particle += "0";
1663 particle = "anti_" + particle;
1664 }
1665 else if (iIso3 == -1) {
1666 particle += "-";
1667 }
1668 }
1669 return particle;
1670}
1671
1672#endif

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 1439 of file G4ExcitedMesonConstructor.hh.

1477{
1478 // This class is a utility class for construction
1479 // short lived particles
1480 public:
1481 enum
1482 {
1483 NMultiplets = 10
1484 };
1485
1486 enum
1487 {
1488 NMesonTypes = 5
1489 };
1490
1491 enum
1492 {
1493 NumberOfDecayModes = 19
1494 };
1495
1496 public:
1497 G4ExcitedMesonConstructor(G4int nStates = 0, G4int isoSpin = 0);
1498 virtual ~G4ExcitedMesonConstructor() = default;
1499
1500 virtual void Construct(G4int indexOfState = -1);
1501
1502 protected:
1503 void ConstructMesons(G4int indexOfState, G4int indexOfType);
1504
1505 G4String GetName(G4int iIso3, G4int iState, G4int idxType);
1506 G4double GetCharge(G4int iIsoSpin3);
1507 G4int GetEncoding(G4int iIsoSpin3, G4int idxState, G4int idxType);
1508 G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType);
1509
1510 protected:
1511 G4DecayTable* CreateDecayTable(const G4String&, G4int, G4int, G4int);
1512
1513 G4DecayTable* AddKPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1514 G4int iType);
1515 G4DecayTable* AddKStarPiMode(G4DecayTable* table, const G4String& name, G4double br,
1516 G4int iIso3, G4int iType);
1517 G4DecayTable* AddKStar2PiMode(G4DecayTable* table, const G4String& name, G4double br,
1518 G4int iIso3, G4int iType);
1519 G4DecayTable* AddKRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1520 G4int iType);
1521 G4DecayTable* AddKTwoPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1522 G4int iType);
1523 G4DecayTable* AddKOmegaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1524 G4int iType);
1525 G4DecayTable* AddKEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1526 G4int iType);
1527 G4DecayTable* AddPiGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1528 G4int iIso3, G4int iIso);
1529 G4DecayTable* AddRhoGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1530 G4int iIso3, G4int iIso);
1531 G4DecayTable* Add2PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1532 G4int iIso);
1533 G4DecayTable* AddPiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1534 G4int iIso);
1535 G4DecayTable* AddPiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1536 G4int iIso);
1537 G4DecayTable* AddPiF2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1538 G4int iIso);
1539 G4DecayTable* AddPiF0Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1540 G4int iIso);
1541 G4DecayTable* AddPiA2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1542 G4int iIso);
1543 G4DecayTable* Add3PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1544 G4int iIso);
1545 G4DecayTable* Add4PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1546 G4int iIso);
1547 G4DecayTable* AddKKStarMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1548 G4int iIso);
1549 G4DecayTable* Add2PiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1550 G4int iIso);
1551 G4DecayTable* AddRhoEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1552 G4int iIso);
1553 G4DecayTable* Add2PiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1554 G4int iIso);
1555 G4DecayTable* Add2PiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1556 G4int iIso3, G4int iIso);
1557 G4DecayTable* AddPiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1558 G4int iIso3, G4int iIso);
1559 G4DecayTable* Add2EtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1560 G4int iIso);
1561 G4DecayTable* Add2KMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1562 G4int iIso);
1563 G4DecayTable* Add2KPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1564 G4int iIso);
1565
1566 G4bool Exist(G4int idxState, G4int idxType);
1567 G4double GetCharge(G4int iIsoSpin3, G4int idxType);
1568
1569 protected:
1570 enum
1571 {
1572 N11P1 = 0,
1573 N13P0 = 1,
1574 N13P1 = 2,
1575 N13P2 = 3,
1576 N11D2 = 4,
1577 N13D1 = 5,
1578 N13D3 = 6,
1579 N21S0 = 7,
1580 N23S1 = 8,
1581 N23P2 = 9
1582 };
1583
1584 enum
1585 {
1586 TPi = 0,
1587 TEta = 1,
1588 TEtaPrime = 2,
1589 TK = 3,
1590 TAntiK = 4
1591 };
1592
1593 const G4String type;
1594 const G4int leptonNumber{0};
1595 const G4int baryonNumber{0};
1596
1597 static const char* name[NMultiplets][NMesonTypes];
1598 static const G4double mass[NMultiplets][NMesonTypes];
1599 static const G4double massKdiff[NMultiplets];
1600 static const G4double width[NMultiplets][NMesonTypes];
1601 static const G4double widthKdiff[NMultiplets];
1602 static const G4int iIsoSpin[NMesonTypes];
1603 static const G4int iSpin[NMultiplets];
1604 static const G4int iParity[NMultiplets];
1605 static const G4int iGParity[NMultiplets][NMesonTypes];
1606 static const G4int iChargeConjugation[NMultiplets];
1607 static const G4int encodingOffset[NMultiplets];
1608
1609 enum
1610 {
1611 MPiGamma = 0,
1612 MRhoGamma = 1,
1613 M2Pi = 2,
1614 MPiRho = 3,
1615 M3Pi = 4,
1616 MPiEta = 5,
1617 M4Pi = 6,
1618 MKKStar = 7,
1619 M2PiEta = 8,
1620 MRhoEta = 9,
1621 M2PiRho = 10,
1622 M2PiOmega = 11,
1623 M2Eta = 12,
1624 M2K = 13,
1625 M2KPi = 14,
1626 MPiOmega = 15,
1627 MPiF2 = 16,
1628 MPiF0 = 17,
1629 MPiA2 = 18
1630 };
1631 enum
1632 {
1633 MKPi = 0,
1634 MKStarPi = 1,
1635 MKRho = 2,
1636 MKOmega = 3,
1637 MKStar2Pi = 4,
1638 MKTwoPi = 5,
1639 MKEta = 6
1640 };
1641
1642 static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes];
1643};
1644
1645inline G4String G4ExcitedMesonConstructor::GetName(G4int iIso3, G4int iState, G4int iType)
1646{
1647 G4String particle = name[iState][iType];
1648 if (iType == TPi) {
1649 if (iIso3 == +2) {
1650 particle += "+";
1651 }
1652 else if (iIso3 == -2) {
1653 particle += "-";
1654 }
1655 else {
1656 particle += "0";
1657 }
1658 }
1659 else if (iType == TK) {
1660 if (iIso3 == +1) {
1661 particle += "+";
1662 }
1663 else if (iIso3 == -1) {
1664 particle += "0";
1665 }
1666 }
1667 else if (iType == TAntiK) {
1668 if (iIso3 == +1) {
1669 particle += "0";
1670 particle = "anti_" + particle;
1671 }
1672 else if (iIso3 == -1) {
1673 particle += "-";
1674 }
1675 }
1676 return particle;
1677}
1678
1679#endif

Referenced by ConstructMesons().

◆ iIsoSpin

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

Definition at line 1412 of file G4ExcitedMesonConstructor.hh.

1450{
1451 // This class is a utility class for construction
1452 // short lived particles
1453 public:
1454 enum
1455 {
1456 NMultiplets = 10
1457 };
1458
1459 enum
1460 {
1461 NMesonTypes = 5
1462 };
1463
1464 enum
1465 {
1466 NumberOfDecayModes = 19
1467 };
1468
1469 public:
1470 G4ExcitedMesonConstructor(G4int nStates = 0, G4int isoSpin = 0);
1471 virtual ~G4ExcitedMesonConstructor() = default;
1472
1473 virtual void Construct(G4int indexOfState = -1);
1474
1475 protected:
1476 void ConstructMesons(G4int indexOfState, G4int indexOfType);
1477
1478 G4String GetName(G4int iIso3, G4int iState, G4int idxType);
1479 G4double GetCharge(G4int iIsoSpin3);
1480 G4int GetEncoding(G4int iIsoSpin3, G4int idxState, G4int idxType);
1481 G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType);
1482
1483 protected:
1484 G4DecayTable* CreateDecayTable(const G4String&, G4int, G4int, G4int);
1485
1486 G4DecayTable* AddKPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1487 G4int iType);
1488 G4DecayTable* AddKStarPiMode(G4DecayTable* table, const G4String& name, G4double br,
1489 G4int iIso3, G4int iType);
1490 G4DecayTable* AddKStar2PiMode(G4DecayTable* table, const G4String& name, G4double br,
1491 G4int iIso3, G4int iType);
1492 G4DecayTable* AddKRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1493 G4int iType);
1494 G4DecayTable* AddKTwoPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1495 G4int iType);
1496 G4DecayTable* AddKOmegaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1497 G4int iType);
1498 G4DecayTable* AddKEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1499 G4int iType);
1500 G4DecayTable* AddPiGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1501 G4int iIso3, G4int iIso);
1502 G4DecayTable* AddRhoGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1503 G4int iIso3, G4int iIso);
1504 G4DecayTable* Add2PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1505 G4int iIso);
1506 G4DecayTable* AddPiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1507 G4int iIso);
1508 G4DecayTable* AddPiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1509 G4int iIso);
1510 G4DecayTable* AddPiF2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1511 G4int iIso);
1512 G4DecayTable* AddPiF0Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1513 G4int iIso);
1514 G4DecayTable* AddPiA2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1515 G4int iIso);
1516 G4DecayTable* Add3PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1517 G4int iIso);
1518 G4DecayTable* Add4PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1519 G4int iIso);
1520 G4DecayTable* AddKKStarMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1521 G4int iIso);
1522 G4DecayTable* Add2PiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1523 G4int iIso);
1524 G4DecayTable* AddRhoEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1525 G4int iIso);
1526 G4DecayTable* Add2PiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1527 G4int iIso);
1528 G4DecayTable* Add2PiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1529 G4int iIso3, G4int iIso);
1530 G4DecayTable* AddPiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1531 G4int iIso3, G4int iIso);
1532 G4DecayTable* Add2EtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1533 G4int iIso);
1534 G4DecayTable* Add2KMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1535 G4int iIso);
1536 G4DecayTable* Add2KPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1537 G4int iIso);
1538
1539 G4bool Exist(G4int idxState, G4int idxType);
1540 G4double GetCharge(G4int iIsoSpin3, G4int idxType);
1541
1542 protected:
1543 enum
1544 {
1545 N11P1 = 0,
1546 N13P0 = 1,
1547 N13P1 = 2,
1548 N13P2 = 3,
1549 N11D2 = 4,
1550 N13D1 = 5,
1551 N13D3 = 6,
1552 N21S0 = 7,
1553 N23S1 = 8,
1554 N23P2 = 9
1555 };
1556
1557 enum
1558 {
1559 TPi = 0,
1560 TEta = 1,
1561 TEtaPrime = 2,
1562 TK = 3,
1563 TAntiK = 4
1564 };
1565
1566 const G4String type;
1567 const G4int leptonNumber{0};
1568 const G4int baryonNumber{0};
1569
1570 static const char* name[NMultiplets][NMesonTypes];
1571 static const G4double mass[NMultiplets][NMesonTypes];
1572 static const G4double massKdiff[NMultiplets];
1573 static const G4double width[NMultiplets][NMesonTypes];
1574 static const G4double widthKdiff[NMultiplets];
1575 static const G4int iIsoSpin[NMesonTypes];
1576 static const G4int iSpin[NMultiplets];
1577 static const G4int iParity[NMultiplets];
1578 static const G4int iGParity[NMultiplets][NMesonTypes];
1579 static const G4int iChargeConjugation[NMultiplets];
1580 static const G4int encodingOffset[NMultiplets];
1581
1582 enum
1583 {
1584 MPiGamma = 0,
1585 MRhoGamma = 1,
1586 M2Pi = 2,
1587 MPiRho = 3,
1588 M3Pi = 4,
1589 MPiEta = 5,
1590 M4Pi = 6,
1591 MKKStar = 7,
1592 M2PiEta = 8,
1593 MRhoEta = 9,
1594 M2PiRho = 10,
1595 M2PiOmega = 11,
1596 M2Eta = 12,
1597 M2K = 13,
1598 M2KPi = 14,
1599 MPiOmega = 15,
1600 MPiF2 = 16,
1601 MPiF0 = 17,
1602 MPiA2 = 18
1603 };
1604 enum
1605 {
1606 MKPi = 0,
1607 MKStarPi = 1,
1608 MKRho = 2,
1609 MKOmega = 3,
1610 MKStar2Pi = 4,
1611 MKTwoPi = 5,
1612 MKEta = 6
1613 };
1614
1615 static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes];
1616};
1617
1618inline G4String G4ExcitedMesonConstructor::GetName(G4int iIso3, G4int iState, G4int iType)
1619{
1620 G4String particle = name[iState][iType];
1621 if (iType == TPi) {
1622 if (iIso3 == +2) {
1623 particle += "+";
1624 }
1625 else if (iIso3 == -2) {
1626 particle += "-";
1627 }
1628 else {
1629 particle += "0";
1630 }
1631 }
1632 else if (iType == TK) {
1633 if (iIso3 == +1) {
1634 particle += "+";
1635 }
1636 else if (iIso3 == -1) {
1637 particle += "0";
1638 }
1639 }
1640 else if (iType == TAntiK) {
1641 if (iIso3 == +1) {
1642 particle += "0";
1643 particle = "anti_" + particle;
1644 }
1645 else if (iIso3 == -1) {
1646 particle += "-";
1647 }
1648 }
1649 return particle;
1650}
1651
1652#endif

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 1425 of file G4ExcitedMesonConstructor.hh.

1463{
1464 // This class is a utility class for construction
1465 // short lived particles
1466 public:
1467 enum
1468 {
1469 NMultiplets = 10
1470 };
1471
1472 enum
1473 {
1474 NMesonTypes = 5
1475 };
1476
1477 enum
1478 {
1479 NumberOfDecayModes = 19
1480 };
1481
1482 public:
1483 G4ExcitedMesonConstructor(G4int nStates = 0, G4int isoSpin = 0);
1484 virtual ~G4ExcitedMesonConstructor() = default;
1485
1486 virtual void Construct(G4int indexOfState = -1);
1487
1488 protected:
1489 void ConstructMesons(G4int indexOfState, G4int indexOfType);
1490
1491 G4String GetName(G4int iIso3, G4int iState, G4int idxType);
1492 G4double GetCharge(G4int iIsoSpin3);
1493 G4int GetEncoding(G4int iIsoSpin3, G4int idxState, G4int idxType);
1494 G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType);
1495
1496 protected:
1497 G4DecayTable* CreateDecayTable(const G4String&, G4int, G4int, G4int);
1498
1499 G4DecayTable* AddKPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1500 G4int iType);
1501 G4DecayTable* AddKStarPiMode(G4DecayTable* table, const G4String& name, G4double br,
1502 G4int iIso3, G4int iType);
1503 G4DecayTable* AddKStar2PiMode(G4DecayTable* table, const G4String& name, G4double br,
1504 G4int iIso3, G4int iType);
1505 G4DecayTable* AddKRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1506 G4int iType);
1507 G4DecayTable* AddKTwoPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1508 G4int iType);
1509 G4DecayTable* AddKOmegaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1510 G4int iType);
1511 G4DecayTable* AddKEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1512 G4int iType);
1513 G4DecayTable* AddPiGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1514 G4int iIso3, G4int iIso);
1515 G4DecayTable* AddRhoGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1516 G4int iIso3, G4int iIso);
1517 G4DecayTable* Add2PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1518 G4int iIso);
1519 G4DecayTable* AddPiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1520 G4int iIso);
1521 G4DecayTable* AddPiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1522 G4int iIso);
1523 G4DecayTable* AddPiF2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1524 G4int iIso);
1525 G4DecayTable* AddPiF0Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1526 G4int iIso);
1527 G4DecayTable* AddPiA2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1528 G4int iIso);
1529 G4DecayTable* Add3PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1530 G4int iIso);
1531 G4DecayTable* Add4PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1532 G4int iIso);
1533 G4DecayTable* AddKKStarMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1534 G4int iIso);
1535 G4DecayTable* Add2PiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1536 G4int iIso);
1537 G4DecayTable* AddRhoEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1538 G4int iIso);
1539 G4DecayTable* Add2PiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1540 G4int iIso);
1541 G4DecayTable* Add2PiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1542 G4int iIso3, G4int iIso);
1543 G4DecayTable* AddPiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1544 G4int iIso3, G4int iIso);
1545 G4DecayTable* Add2EtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1546 G4int iIso);
1547 G4DecayTable* Add2KMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1548 G4int iIso);
1549 G4DecayTable* Add2KPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1550 G4int iIso);
1551
1552 G4bool Exist(G4int idxState, G4int idxType);
1553 G4double GetCharge(G4int iIsoSpin3, G4int idxType);
1554
1555 protected:
1556 enum
1557 {
1558 N11P1 = 0,
1559 N13P0 = 1,
1560 N13P1 = 2,
1561 N13P2 = 3,
1562 N11D2 = 4,
1563 N13D1 = 5,
1564 N13D3 = 6,
1565 N21S0 = 7,
1566 N23S1 = 8,
1567 N23P2 = 9
1568 };
1569
1570 enum
1571 {
1572 TPi = 0,
1573 TEta = 1,
1574 TEtaPrime = 2,
1575 TK = 3,
1576 TAntiK = 4
1577 };
1578
1579 const G4String type;
1580 const G4int leptonNumber{0};
1581 const G4int baryonNumber{0};
1582
1583 static const char* name[NMultiplets][NMesonTypes];
1584 static const G4double mass[NMultiplets][NMesonTypes];
1585 static const G4double massKdiff[NMultiplets];
1586 static const G4double width[NMultiplets][NMesonTypes];
1587 static const G4double widthKdiff[NMultiplets];
1588 static const G4int iIsoSpin[NMesonTypes];
1589 static const G4int iSpin[NMultiplets];
1590 static const G4int iParity[NMultiplets];
1591 static const G4int iGParity[NMultiplets][NMesonTypes];
1592 static const G4int iChargeConjugation[NMultiplets];
1593 static const G4int encodingOffset[NMultiplets];
1594
1595 enum
1596 {
1597 MPiGamma = 0,
1598 MRhoGamma = 1,
1599 M2Pi = 2,
1600 MPiRho = 3,
1601 M3Pi = 4,
1602 MPiEta = 5,
1603 M4Pi = 6,
1604 MKKStar = 7,
1605 M2PiEta = 8,
1606 MRhoEta = 9,
1607 M2PiRho = 10,
1608 M2PiOmega = 11,
1609 M2Eta = 12,
1610 M2K = 13,
1611 M2KPi = 14,
1612 MPiOmega = 15,
1613 MPiF2 = 16,
1614 MPiF0 = 17,
1615 MPiA2 = 18
1616 };
1617 enum
1618 {
1619 MKPi = 0,
1620 MKStarPi = 1,
1621 MKRho = 2,
1622 MKOmega = 3,
1623 MKStar2Pi = 4,
1624 MKTwoPi = 5,
1625 MKEta = 6
1626 };
1627
1628 static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes];
1629};
1630
1631inline G4String G4ExcitedMesonConstructor::GetName(G4int iIso3, G4int iState, G4int iType)
1632{
1633 G4String particle = name[iState][iType];
1634 if (iType == TPi) {
1635 if (iIso3 == +2) {
1636 particle += "+";
1637 }
1638 else if (iIso3 == -2) {
1639 particle += "-";
1640 }
1641 else {
1642 particle += "0";
1643 }
1644 }
1645 else if (iType == TK) {
1646 if (iIso3 == +1) {
1647 particle += "+";
1648 }
1649 else if (iIso3 == -1) {
1650 particle += "0";
1651 }
1652 }
1653 else if (iType == TAntiK) {
1654 if (iIso3 == +1) {
1655 particle += "0";
1656 particle = "anti_" + particle;
1657 }
1658 else if (iIso3 == -1) {
1659 particle += "-";
1660 }
1661 }
1662 return particle;
1663}
1664
1665#endif

Referenced by ConstructMesons().

◆ iSpin

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

Definition at line 1418 of file G4ExcitedMesonConstructor.hh.

1456{
1457 // This class is a utility class for construction
1458 // short lived particles
1459 public:
1460 enum
1461 {
1462 NMultiplets = 10
1463 };
1464
1465 enum
1466 {
1467 NMesonTypes = 5
1468 };
1469
1470 enum
1471 {
1472 NumberOfDecayModes = 19
1473 };
1474
1475 public:
1476 G4ExcitedMesonConstructor(G4int nStates = 0, G4int isoSpin = 0);
1477 virtual ~G4ExcitedMesonConstructor() = default;
1478
1479 virtual void Construct(G4int indexOfState = -1);
1480
1481 protected:
1482 void ConstructMesons(G4int indexOfState, G4int indexOfType);
1483
1484 G4String GetName(G4int iIso3, G4int iState, G4int idxType);
1485 G4double GetCharge(G4int iIsoSpin3);
1486 G4int GetEncoding(G4int iIsoSpin3, G4int idxState, G4int idxType);
1487 G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType);
1488
1489 protected:
1490 G4DecayTable* CreateDecayTable(const G4String&, G4int, G4int, G4int);
1491
1492 G4DecayTable* AddKPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1493 G4int iType);
1494 G4DecayTable* AddKStarPiMode(G4DecayTable* table, const G4String& name, G4double br,
1495 G4int iIso3, G4int iType);
1496 G4DecayTable* AddKStar2PiMode(G4DecayTable* table, const G4String& name, G4double br,
1497 G4int iIso3, G4int iType);
1498 G4DecayTable* AddKRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1499 G4int iType);
1500 G4DecayTable* AddKTwoPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1501 G4int iType);
1502 G4DecayTable* AddKOmegaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1503 G4int iType);
1504 G4DecayTable* AddKEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1505 G4int iType);
1506 G4DecayTable* AddPiGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1507 G4int iIso3, G4int iIso);
1508 G4DecayTable* AddRhoGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1509 G4int iIso3, G4int iIso);
1510 G4DecayTable* Add2PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1511 G4int iIso);
1512 G4DecayTable* AddPiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1513 G4int iIso);
1514 G4DecayTable* AddPiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1515 G4int iIso);
1516 G4DecayTable* AddPiF2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1517 G4int iIso);
1518 G4DecayTable* AddPiF0Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1519 G4int iIso);
1520 G4DecayTable* AddPiA2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1521 G4int iIso);
1522 G4DecayTable* Add3PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1523 G4int iIso);
1524 G4DecayTable* Add4PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1525 G4int iIso);
1526 G4DecayTable* AddKKStarMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1527 G4int iIso);
1528 G4DecayTable* Add2PiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1529 G4int iIso);
1530 G4DecayTable* AddRhoEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1531 G4int iIso);
1532 G4DecayTable* Add2PiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1533 G4int iIso);
1534 G4DecayTable* Add2PiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1535 G4int iIso3, G4int iIso);
1536 G4DecayTable* AddPiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1537 G4int iIso3, G4int iIso);
1538 G4DecayTable* Add2EtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1539 G4int iIso);
1540 G4DecayTable* Add2KMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1541 G4int iIso);
1542 G4DecayTable* Add2KPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1543 G4int iIso);
1544
1545 G4bool Exist(G4int idxState, G4int idxType);
1546 G4double GetCharge(G4int iIsoSpin3, G4int idxType);
1547
1548 protected:
1549 enum
1550 {
1551 N11P1 = 0,
1552 N13P0 = 1,
1553 N13P1 = 2,
1554 N13P2 = 3,
1555 N11D2 = 4,
1556 N13D1 = 5,
1557 N13D3 = 6,
1558 N21S0 = 7,
1559 N23S1 = 8,
1560 N23P2 = 9
1561 };
1562
1563 enum
1564 {
1565 TPi = 0,
1566 TEta = 1,
1567 TEtaPrime = 2,
1568 TK = 3,
1569 TAntiK = 4
1570 };
1571
1572 const G4String type;
1573 const G4int leptonNumber{0};
1574 const G4int baryonNumber{0};
1575
1576 static const char* name[NMultiplets][NMesonTypes];
1577 static const G4double mass[NMultiplets][NMesonTypes];
1578 static const G4double massKdiff[NMultiplets];
1579 static const G4double width[NMultiplets][NMesonTypes];
1580 static const G4double widthKdiff[NMultiplets];
1581 static const G4int iIsoSpin[NMesonTypes];
1582 static const G4int iSpin[NMultiplets];
1583 static const G4int iParity[NMultiplets];
1584 static const G4int iGParity[NMultiplets][NMesonTypes];
1585 static const G4int iChargeConjugation[NMultiplets];
1586 static const G4int encodingOffset[NMultiplets];
1587
1588 enum
1589 {
1590 MPiGamma = 0,
1591 MRhoGamma = 1,
1592 M2Pi = 2,
1593 MPiRho = 3,
1594 M3Pi = 4,
1595 MPiEta = 5,
1596 M4Pi = 6,
1597 MKKStar = 7,
1598 M2PiEta = 8,
1599 MRhoEta = 9,
1600 M2PiRho = 10,
1601 M2PiOmega = 11,
1602 M2Eta = 12,
1603 M2K = 13,
1604 M2KPi = 14,
1605 MPiOmega = 15,
1606 MPiF2 = 16,
1607 MPiF0 = 17,
1608 MPiA2 = 18
1609 };
1610 enum
1611 {
1612 MKPi = 0,
1613 MKStarPi = 1,
1614 MKRho = 2,
1615 MKOmega = 3,
1616 MKStar2Pi = 4,
1617 MKTwoPi = 5,
1618 MKEta = 6
1619 };
1620
1621 static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes];
1622};
1623
1624inline G4String G4ExcitedMesonConstructor::GetName(G4int iIso3, G4int iState, G4int iType)
1625{
1626 G4String particle = name[iState][iType];
1627 if (iType == TPi) {
1628 if (iIso3 == +2) {
1629 particle += "+";
1630 }
1631 else if (iIso3 == -2) {
1632 particle += "-";
1633 }
1634 else {
1635 particle += "0";
1636 }
1637 }
1638 else if (iType == TK) {
1639 if (iIso3 == +1) {
1640 particle += "+";
1641 }
1642 else if (iIso3 == -1) {
1643 particle += "0";
1644 }
1645 }
1646 else if (iType == TAntiK) {
1647 if (iIso3 == +1) {
1648 particle += "0";
1649 particle = "anti_" + particle;
1650 }
1651 else if (iIso3 == -1) {
1652 particle += "-";
1653 }
1654 }
1655 return particle;
1656}
1657
1658#endif

Referenced by ConstructMesons(), and GetEncoding().

◆ leptonNumber

const G4int G4ExcitedMesonConstructor::leptonNumber {0}
protected

Definition at line 156 of file G4ExcitedMesonConstructor.hh.

156{0};

Referenced by ConstructMesons().

◆ mass

const G4double G4ExcitedMesonConstructor::mass
staticprotected
Initial value:
=
{
{ 1.2295*GeV, 1.166*GeV, 1.4091*GeV, 1.2531*GeV, 1.2531*GeV },
{ 1.4387*GeV, 1.350*GeV, 0.0, 1.425*GeV, 1.425*GeV },
{ 1.230*GeV, 1.2818*GeV, 1.4025*GeV, 1.403*GeV, 1.403*GeV },
{ 1.3182*GeV, 1.2754*GeV, 1.5173*GeV, 1.4324*GeV, 1.4324*GeV },
{ 1.6706*GeV, 1.6173*GeV, 1.8417*GeV, 1.773*GeV, 1.773*GeV },
{ 1.720*GeV, 1.670*GeV, 0.0, 1.7176*GeV, 1.7176*GeV },
{ 1.6888*GeV, 1.6672*GeV, 1.8543*GeV, 1.7789*GeV, 1.7789*GeV },
{ 1.300*GeV, 1.2937*GeV, 1.4755*GeV, 1.482*GeV, 1.482*GeV },
{ 1.465*GeV, 1.410*GeV, 1.680*GeV, 1.4137*GeV, 1.4137*GeV },
{ 0.0, 1.8149*GeV, 2.011*GeV, 1.9945*GeV, 1.9945*GeV }
}

Definition at line 1373 of file G4ExcitedMesonConstructor.hh.

1411{
1412 // This class is a utility class for construction
1413 // short lived particles
1414 public:
1415 enum
1416 {
1417 NMultiplets = 10
1418 };
1419
1420 enum
1421 {
1422 NMesonTypes = 5
1423 };
1424
1425 enum
1426 {
1427 NumberOfDecayModes = 19
1428 };
1429
1430 public:
1431 G4ExcitedMesonConstructor(G4int nStates = 0, G4int isoSpin = 0);
1432 virtual ~G4ExcitedMesonConstructor() = default;
1433
1434 virtual void Construct(G4int indexOfState = -1);
1435
1436 protected:
1437 void ConstructMesons(G4int indexOfState, G4int indexOfType);
1438
1439 G4String GetName(G4int iIso3, G4int iState, G4int idxType);
1440 G4double GetCharge(G4int iIsoSpin3);
1441 G4int GetEncoding(G4int iIsoSpin3, G4int idxState, G4int idxType);
1442 G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType);
1443
1444 protected:
1445 G4DecayTable* CreateDecayTable(const G4String&, G4int, G4int, G4int);
1446
1447 G4DecayTable* AddKPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1448 G4int iType);
1449 G4DecayTable* AddKStarPiMode(G4DecayTable* table, const G4String& name, G4double br,
1450 G4int iIso3, G4int iType);
1451 G4DecayTable* AddKStar2PiMode(G4DecayTable* table, const G4String& name, G4double br,
1452 G4int iIso3, G4int iType);
1453 G4DecayTable* AddKRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1454 G4int iType);
1455 G4DecayTable* AddKTwoPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1456 G4int iType);
1457 G4DecayTable* AddKOmegaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1458 G4int iType);
1459 G4DecayTable* AddKEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1460 G4int iType);
1461 G4DecayTable* AddPiGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1462 G4int iIso3, G4int iIso);
1463 G4DecayTable* AddRhoGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1464 G4int iIso3, G4int iIso);
1465 G4DecayTable* Add2PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1466 G4int iIso);
1467 G4DecayTable* AddPiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1468 G4int iIso);
1469 G4DecayTable* AddPiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1470 G4int iIso);
1471 G4DecayTable* AddPiF2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1472 G4int iIso);
1473 G4DecayTable* AddPiF0Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1474 G4int iIso);
1475 G4DecayTable* AddPiA2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1476 G4int iIso);
1477 G4DecayTable* Add3PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1478 G4int iIso);
1479 G4DecayTable* Add4PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1480 G4int iIso);
1481 G4DecayTable* AddKKStarMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1482 G4int iIso);
1483 G4DecayTable* Add2PiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1484 G4int iIso);
1485 G4DecayTable* AddRhoEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1486 G4int iIso);
1487 G4DecayTable* Add2PiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1488 G4int iIso);
1489 G4DecayTable* Add2PiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1490 G4int iIso3, G4int iIso);
1491 G4DecayTable* AddPiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1492 G4int iIso3, G4int iIso);
1493 G4DecayTable* Add2EtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1494 G4int iIso);
1495 G4DecayTable* Add2KMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1496 G4int iIso);
1497 G4DecayTable* Add2KPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1498 G4int iIso);
1499
1500 G4bool Exist(G4int idxState, G4int idxType);
1501 G4double GetCharge(G4int iIsoSpin3, G4int idxType);
1502
1503 protected:
1504 enum
1505 {
1506 N11P1 = 0,
1507 N13P0 = 1,
1508 N13P1 = 2,
1509 N13P2 = 3,
1510 N11D2 = 4,
1511 N13D1 = 5,
1512 N13D3 = 6,
1513 N21S0 = 7,
1514 N23S1 = 8,
1515 N23P2 = 9
1516 };
1517
1518 enum
1519 {
1520 TPi = 0,
1521 TEta = 1,
1522 TEtaPrime = 2,
1523 TK = 3,
1524 TAntiK = 4
1525 };
1526
1527 const G4String type;
1528 const G4int leptonNumber{0};
1529 const G4int baryonNumber{0};
1530
1531 static const char* name[NMultiplets][NMesonTypes];
1532 static const G4double mass[NMultiplets][NMesonTypes];
1533 static const G4double massKdiff[NMultiplets];
1534 static const G4double width[NMultiplets][NMesonTypes];
1535 static const G4double widthKdiff[NMultiplets];
1536 static const G4int iIsoSpin[NMesonTypes];
1537 static const G4int iSpin[NMultiplets];
1538 static const G4int iParity[NMultiplets];
1539 static const G4int iGParity[NMultiplets][NMesonTypes];
1540 static const G4int iChargeConjugation[NMultiplets];
1541 static const G4int encodingOffset[NMultiplets];
1542
1543 enum
1544 {
1545 MPiGamma = 0,
1546 MRhoGamma = 1,
1547 M2Pi = 2,
1548 MPiRho = 3,
1549 M3Pi = 4,
1550 MPiEta = 5,
1551 M4Pi = 6,
1552 MKKStar = 7,
1553 M2PiEta = 8,
1554 MRhoEta = 9,
1555 M2PiRho = 10,
1556 M2PiOmega = 11,
1557 M2Eta = 12,
1558 M2K = 13,
1559 M2KPi = 14,
1560 MPiOmega = 15,
1561 MPiF2 = 16,
1562 MPiF0 = 17,
1563 MPiA2 = 18
1564 };
1565 enum
1566 {
1567 MKPi = 0,
1568 MKStarPi = 1,
1569 MKRho = 2,
1570 MKOmega = 3,
1571 MKStar2Pi = 4,
1572 MKTwoPi = 5,
1573 MKEta = 6
1574 };
1575
1576 static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes];
1577};
1578
1579inline G4String G4ExcitedMesonConstructor::GetName(G4int iIso3, G4int iState, G4int iType)
1580{
1581 G4String particle = name[iState][iType];
1582 if (iType == TPi) {
1583 if (iIso3 == +2) {
1584 particle += "+";
1585 }
1586 else if (iIso3 == -2) {
1587 particle += "-";
1588 }
1589 else {
1590 particle += "0";
1591 }
1592 }
1593 else if (iType == TK) {
1594 if (iIso3 == +1) {
1595 particle += "+";
1596 }
1597 else if (iIso3 == -1) {
1598 particle += "0";
1599 }
1600 }
1601 else if (iType == TAntiK) {
1602 if (iIso3 == +1) {
1603 particle += "0";
1604 particle = "anti_" + particle;
1605 }
1606 else if (iIso3 == -1) {
1607 particle += "-";
1608 }
1609 }
1610 return particle;
1611}
1612
1613#endif

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 1387 of file G4ExcitedMesonConstructor.hh.

1425{
1426 // This class is a utility class for construction
1427 // short lived particles
1428 public:
1429 enum
1430 {
1431 NMultiplets = 10
1432 };
1433
1434 enum
1435 {
1436 NMesonTypes = 5
1437 };
1438
1439 enum
1440 {
1441 NumberOfDecayModes = 19
1442 };
1443
1444 public:
1445 G4ExcitedMesonConstructor(G4int nStates = 0, G4int isoSpin = 0);
1446 virtual ~G4ExcitedMesonConstructor() = default;
1447
1448 virtual void Construct(G4int indexOfState = -1);
1449
1450 protected:
1451 void ConstructMesons(G4int indexOfState, G4int indexOfType);
1452
1453 G4String GetName(G4int iIso3, G4int iState, G4int idxType);
1454 G4double GetCharge(G4int iIsoSpin3);
1455 G4int GetEncoding(G4int iIsoSpin3, G4int idxState, G4int idxType);
1456 G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType);
1457
1458 protected:
1459 G4DecayTable* CreateDecayTable(const G4String&, G4int, G4int, G4int);
1460
1461 G4DecayTable* AddKPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1462 G4int iType);
1463 G4DecayTable* AddKStarPiMode(G4DecayTable* table, const G4String& name, G4double br,
1464 G4int iIso3, G4int iType);
1465 G4DecayTable* AddKStar2PiMode(G4DecayTable* table, const G4String& name, G4double br,
1466 G4int iIso3, G4int iType);
1467 G4DecayTable* AddKRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1468 G4int iType);
1469 G4DecayTable* AddKTwoPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1470 G4int iType);
1471 G4DecayTable* AddKOmegaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1472 G4int iType);
1473 G4DecayTable* AddKEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1474 G4int iType);
1475 G4DecayTable* AddPiGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1476 G4int iIso3, G4int iIso);
1477 G4DecayTable* AddRhoGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1478 G4int iIso3, G4int iIso);
1479 G4DecayTable* Add2PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1480 G4int iIso);
1481 G4DecayTable* AddPiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1482 G4int iIso);
1483 G4DecayTable* AddPiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1484 G4int iIso);
1485 G4DecayTable* AddPiF2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1486 G4int iIso);
1487 G4DecayTable* AddPiF0Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1488 G4int iIso);
1489 G4DecayTable* AddPiA2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1490 G4int iIso);
1491 G4DecayTable* Add3PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1492 G4int iIso);
1493 G4DecayTable* Add4PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1494 G4int iIso);
1495 G4DecayTable* AddKKStarMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1496 G4int iIso);
1497 G4DecayTable* Add2PiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1498 G4int iIso);
1499 G4DecayTable* AddRhoEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1500 G4int iIso);
1501 G4DecayTable* Add2PiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1502 G4int iIso);
1503 G4DecayTable* Add2PiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1504 G4int iIso3, G4int iIso);
1505 G4DecayTable* AddPiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1506 G4int iIso3, G4int iIso);
1507 G4DecayTable* Add2EtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1508 G4int iIso);
1509 G4DecayTable* Add2KMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1510 G4int iIso);
1511 G4DecayTable* Add2KPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1512 G4int iIso);
1513
1514 G4bool Exist(G4int idxState, G4int idxType);
1515 G4double GetCharge(G4int iIsoSpin3, G4int idxType);
1516
1517 protected:
1518 enum
1519 {
1520 N11P1 = 0,
1521 N13P0 = 1,
1522 N13P1 = 2,
1523 N13P2 = 3,
1524 N11D2 = 4,
1525 N13D1 = 5,
1526 N13D3 = 6,
1527 N21S0 = 7,
1528 N23S1 = 8,
1529 N23P2 = 9
1530 };
1531
1532 enum
1533 {
1534 TPi = 0,
1535 TEta = 1,
1536 TEtaPrime = 2,
1537 TK = 3,
1538 TAntiK = 4
1539 };
1540
1541 const G4String type;
1542 const G4int leptonNumber{0};
1543 const G4int baryonNumber{0};
1544
1545 static const char* name[NMultiplets][NMesonTypes];
1546 static const G4double mass[NMultiplets][NMesonTypes];
1547 static const G4double massKdiff[NMultiplets];
1548 static const G4double width[NMultiplets][NMesonTypes];
1549 static const G4double widthKdiff[NMultiplets];
1550 static const G4int iIsoSpin[NMesonTypes];
1551 static const G4int iSpin[NMultiplets];
1552 static const G4int iParity[NMultiplets];
1553 static const G4int iGParity[NMultiplets][NMesonTypes];
1554 static const G4int iChargeConjugation[NMultiplets];
1555 static const G4int encodingOffset[NMultiplets];
1556
1557 enum
1558 {
1559 MPiGamma = 0,
1560 MRhoGamma = 1,
1561 M2Pi = 2,
1562 MPiRho = 3,
1563 M3Pi = 4,
1564 MPiEta = 5,
1565 M4Pi = 6,
1566 MKKStar = 7,
1567 M2PiEta = 8,
1568 MRhoEta = 9,
1569 M2PiRho = 10,
1570 M2PiOmega = 11,
1571 M2Eta = 12,
1572 M2K = 13,
1573 M2KPi = 14,
1574 MPiOmega = 15,
1575 MPiF2 = 16,
1576 MPiF0 = 17,
1577 MPiA2 = 18
1578 };
1579 enum
1580 {
1581 MKPi = 0,
1582 MKStarPi = 1,
1583 MKRho = 2,
1584 MKOmega = 3,
1585 MKStar2Pi = 4,
1586 MKTwoPi = 5,
1587 MKEta = 6
1588 };
1589
1590 static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes];
1591};
1592
1593inline G4String G4ExcitedMesonConstructor::GetName(G4int iIso3, G4int iState, G4int iType)
1594{
1595 G4String particle = name[iState][iType];
1596 if (iType == TPi) {
1597 if (iIso3 == +2) {
1598 particle += "+";
1599 }
1600 else if (iIso3 == -2) {
1601 particle += "-";
1602 }
1603 else {
1604 particle += "0";
1605 }
1606 }
1607 else if (iType == TK) {
1608 if (iIso3 == +1) {
1609 particle += "+";
1610 }
1611 else if (iIso3 == -1) {
1612 particle += "0";
1613 }
1614 }
1615 else if (iType == TAntiK) {
1616 if (iIso3 == +1) {
1617 particle += "0";
1618 particle = "anti_" + particle;
1619 }
1620 else if (iIso3 == -1) {
1621 particle += "-";
1622 }
1623 }
1624 return particle;
1625}
1626
1627#endif

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 1359 of file G4ExcitedMesonConstructor.hh.

1397{
1398 // This class is a utility class for construction
1399 // short lived particles
1400 public:
1401 enum
1402 {
1403 NMultiplets = 10
1404 };
1405
1406 enum
1407 {
1408 NMesonTypes = 5
1409 };
1410
1411 enum
1412 {
1413 NumberOfDecayModes = 19
1414 };
1415
1416 public:
1417 G4ExcitedMesonConstructor(G4int nStates = 0, G4int isoSpin = 0);
1418 virtual ~G4ExcitedMesonConstructor() = default;
1419
1420 virtual void Construct(G4int indexOfState = -1);
1421
1422 protected:
1423 void ConstructMesons(G4int indexOfState, G4int indexOfType);
1424
1425 G4String GetName(G4int iIso3, G4int iState, G4int idxType);
1426 G4double GetCharge(G4int iIsoSpin3);
1427 G4int GetEncoding(G4int iIsoSpin3, G4int idxState, G4int idxType);
1428 G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType);
1429
1430 protected:
1431 G4DecayTable* CreateDecayTable(const G4String&, G4int, G4int, G4int);
1432
1433 G4DecayTable* AddKPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1434 G4int iType);
1435 G4DecayTable* AddKStarPiMode(G4DecayTable* table, const G4String& name, G4double br,
1436 G4int iIso3, G4int iType);
1437 G4DecayTable* AddKStar2PiMode(G4DecayTable* table, const G4String& name, G4double br,
1438 G4int iIso3, G4int iType);
1439 G4DecayTable* AddKRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1440 G4int iType);
1441 G4DecayTable* AddKTwoPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1442 G4int iType);
1443 G4DecayTable* AddKOmegaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1444 G4int iType);
1445 G4DecayTable* AddKEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1446 G4int iType);
1447 G4DecayTable* AddPiGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1448 G4int iIso3, G4int iIso);
1449 G4DecayTable* AddRhoGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1450 G4int iIso3, G4int iIso);
1451 G4DecayTable* Add2PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1452 G4int iIso);
1453 G4DecayTable* AddPiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1454 G4int iIso);
1455 G4DecayTable* AddPiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1456 G4int iIso);
1457 G4DecayTable* AddPiF2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1458 G4int iIso);
1459 G4DecayTable* AddPiF0Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1460 G4int iIso);
1461 G4DecayTable* AddPiA2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1462 G4int iIso);
1463 G4DecayTable* Add3PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1464 G4int iIso);
1465 G4DecayTable* Add4PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1466 G4int iIso);
1467 G4DecayTable* AddKKStarMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1468 G4int iIso);
1469 G4DecayTable* Add2PiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1470 G4int iIso);
1471 G4DecayTable* AddRhoEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1472 G4int iIso);
1473 G4DecayTable* Add2PiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1474 G4int iIso);
1475 G4DecayTable* Add2PiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1476 G4int iIso3, G4int iIso);
1477 G4DecayTable* AddPiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1478 G4int iIso3, G4int iIso);
1479 G4DecayTable* Add2EtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1480 G4int iIso);
1481 G4DecayTable* Add2KMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1482 G4int iIso);
1483 G4DecayTable* Add2KPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1484 G4int iIso);
1485
1486 G4bool Exist(G4int idxState, G4int idxType);
1487 G4double GetCharge(G4int iIsoSpin3, G4int idxType);
1488
1489 protected:
1490 enum
1491 {
1492 N11P1 = 0,
1493 N13P0 = 1,
1494 N13P1 = 2,
1495 N13P2 = 3,
1496 N11D2 = 4,
1497 N13D1 = 5,
1498 N13D3 = 6,
1499 N21S0 = 7,
1500 N23S1 = 8,
1501 N23P2 = 9
1502 };
1503
1504 enum
1505 {
1506 TPi = 0,
1507 TEta = 1,
1508 TEtaPrime = 2,
1509 TK = 3,
1510 TAntiK = 4
1511 };
1512
1513 const G4String type;
1514 const G4int leptonNumber{0};
1515 const G4int baryonNumber{0};
1516
1517 static const char* name[NMultiplets][NMesonTypes];
1518 static const G4double mass[NMultiplets][NMesonTypes];
1519 static const G4double massKdiff[NMultiplets];
1520 static const G4double width[NMultiplets][NMesonTypes];
1521 static const G4double widthKdiff[NMultiplets];
1522 static const G4int iIsoSpin[NMesonTypes];
1523 static const G4int iSpin[NMultiplets];
1524 static const G4int iParity[NMultiplets];
1525 static const G4int iGParity[NMultiplets][NMesonTypes];
1526 static const G4int iChargeConjugation[NMultiplets];
1527 static const G4int encodingOffset[NMultiplets];
1528
1529 enum
1530 {
1531 MPiGamma = 0,
1532 MRhoGamma = 1,
1533 M2Pi = 2,
1534 MPiRho = 3,
1535 M3Pi = 4,
1536 MPiEta = 5,
1537 M4Pi = 6,
1538 MKKStar = 7,
1539 M2PiEta = 8,
1540 MRhoEta = 9,
1541 M2PiRho = 10,
1542 M2PiOmega = 11,
1543 M2Eta = 12,
1544 M2K = 13,
1545 M2KPi = 14,
1546 MPiOmega = 15,
1547 MPiF2 = 16,
1548 MPiF0 = 17,
1549 MPiA2 = 18
1550 };
1551 enum
1552 {
1553 MKPi = 0,
1554 MKStarPi = 1,
1555 MKRho = 2,
1556 MKOmega = 3,
1557 MKStar2Pi = 4,
1558 MKTwoPi = 5,
1559 MKEta = 6
1560 };
1561
1562 static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes];
1563};
1564
1565inline G4String G4ExcitedMesonConstructor::GetName(G4int iIso3, G4int iState, G4int iType)
1566{
1567 G4String particle = name[iState][iType];
1568 if (iType == TPi) {
1569 if (iIso3 == +2) {
1570 particle += "+";
1571 }
1572 else if (iIso3 == -2) {
1573 particle += "-";
1574 }
1575 else {
1576 particle += "0";
1577 }
1578 }
1579 else if (iType == TK) {
1580 if (iIso3 == +1) {
1581 particle += "+";
1582 }
1583 else if (iIso3 == -1) {
1584 particle += "0";
1585 }
1586 }
1587 else if (iType == TAntiK) {
1588 if (iIso3 == +1) {
1589 particle += "0";
1590 particle = "anti_" + particle;
1591 }
1592 else if (iIso3 == -1) {
1593 particle += "-";
1594 }
1595 }
1596 return particle;
1597}
1598
1599#endif

Referenced by ConstructMesons(), GetCharge(), and GetName().

◆ type

const G4String G4ExcitedMesonConstructor::type
protected

Definition at line 155 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons(), and G4ExcitedMesonConstructor().

◆ width

const G4double G4ExcitedMesonConstructor::width
staticprotected
Initial value:
=
{
{ 142.4*MeV, 375.0*MeV, 78.0*MeV, 90.0*MeV, 90.0*MeV },
{ 258.0*MeV, 350.0*MeV, 0.0, 270.0*MeV, 270.0*MeV },
{ 425.0*MeV, 23.0*MeV, 173.9*MeV, 174.0*MeV, 174.0*MeV },
{ 107.0*MeV, 186.6*MeV, 71.9*MeV, 108.9*MeV, 108.9*MeV },
{ 257.5*MeV, 180.9*MeV, 225.2*MeV, 186.1*MeV, 186.1*MeV },
{ 250.0*MeV, 315.0*MeV, 0.0, 322.4*MeV, 322.4*MeV },
{ 160.5*MeV, 167.5*MeV, 86.8*MeV, 161.2*MeV, 161.2*MeV },
{ 400.0*MeV, 55.3*MeV, 95.7*MeV, 335.0*MeV, 335.0*MeV },
{ 400.0*MeV, 290.0*MeV, 150.0*MeV, 231.8*MeV, 231.8*MeV },
{ 0.0, 197.4*MeV, 202.0*MeV, 348.0*MeV, 348.0*MeV }
}

Definition at line 1397 of file G4ExcitedMesonConstructor.hh.

1435{
1436 // This class is a utility class for construction
1437 // short lived particles
1438 public:
1439 enum
1440 {
1441 NMultiplets = 10
1442 };
1443
1444 enum
1445 {
1446 NMesonTypes = 5
1447 };
1448
1449 enum
1450 {
1451 NumberOfDecayModes = 19
1452 };
1453
1454 public:
1455 G4ExcitedMesonConstructor(G4int nStates = 0, G4int isoSpin = 0);
1456 virtual ~G4ExcitedMesonConstructor() = default;
1457
1458 virtual void Construct(G4int indexOfState = -1);
1459
1460 protected:
1461 void ConstructMesons(G4int indexOfState, G4int indexOfType);
1462
1463 G4String GetName(G4int iIso3, G4int iState, G4int idxType);
1464 G4double GetCharge(G4int iIsoSpin3);
1465 G4int GetEncoding(G4int iIsoSpin3, G4int idxState, G4int idxType);
1466 G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType);
1467
1468 protected:
1469 G4DecayTable* CreateDecayTable(const G4String&, G4int, G4int, G4int);
1470
1471 G4DecayTable* AddKPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1472 G4int iType);
1473 G4DecayTable* AddKStarPiMode(G4DecayTable* table, const G4String& name, G4double br,
1474 G4int iIso3, G4int iType);
1475 G4DecayTable* AddKStar2PiMode(G4DecayTable* table, const G4String& name, G4double br,
1476 G4int iIso3, G4int iType);
1477 G4DecayTable* AddKRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1478 G4int iType);
1479 G4DecayTable* AddKTwoPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1480 G4int iType);
1481 G4DecayTable* AddKOmegaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1482 G4int iType);
1483 G4DecayTable* AddKEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1484 G4int iType);
1485 G4DecayTable* AddPiGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1486 G4int iIso3, G4int iIso);
1487 G4DecayTable* AddRhoGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1488 G4int iIso3, G4int iIso);
1489 G4DecayTable* Add2PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1490 G4int iIso);
1491 G4DecayTable* AddPiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1492 G4int iIso);
1493 G4DecayTable* AddPiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1494 G4int iIso);
1495 G4DecayTable* AddPiF2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1496 G4int iIso);
1497 G4DecayTable* AddPiF0Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1498 G4int iIso);
1499 G4DecayTable* AddPiA2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1500 G4int iIso);
1501 G4DecayTable* Add3PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1502 G4int iIso);
1503 G4DecayTable* Add4PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1504 G4int iIso);
1505 G4DecayTable* AddKKStarMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1506 G4int iIso);
1507 G4DecayTable* Add2PiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1508 G4int iIso);
1509 G4DecayTable* AddRhoEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1510 G4int iIso);
1511 G4DecayTable* Add2PiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1512 G4int iIso);
1513 G4DecayTable* Add2PiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1514 G4int iIso3, G4int iIso);
1515 G4DecayTable* AddPiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1516 G4int iIso3, G4int iIso);
1517 G4DecayTable* Add2EtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1518 G4int iIso);
1519 G4DecayTable* Add2KMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1520 G4int iIso);
1521 G4DecayTable* Add2KPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1522 G4int iIso);
1523
1524 G4bool Exist(G4int idxState, G4int idxType);
1525 G4double GetCharge(G4int iIsoSpin3, G4int idxType);
1526
1527 protected:
1528 enum
1529 {
1530 N11P1 = 0,
1531 N13P0 = 1,
1532 N13P1 = 2,
1533 N13P2 = 3,
1534 N11D2 = 4,
1535 N13D1 = 5,
1536 N13D3 = 6,
1537 N21S0 = 7,
1538 N23S1 = 8,
1539 N23P2 = 9
1540 };
1541
1542 enum
1543 {
1544 TPi = 0,
1545 TEta = 1,
1546 TEtaPrime = 2,
1547 TK = 3,
1548 TAntiK = 4
1549 };
1550
1551 const G4String type;
1552 const G4int leptonNumber{0};
1553 const G4int baryonNumber{0};
1554
1555 static const char* name[NMultiplets][NMesonTypes];
1556 static const G4double mass[NMultiplets][NMesonTypes];
1557 static const G4double massKdiff[NMultiplets];
1558 static const G4double width[NMultiplets][NMesonTypes];
1559 static const G4double widthKdiff[NMultiplets];
1560 static const G4int iIsoSpin[NMesonTypes];
1561 static const G4int iSpin[NMultiplets];
1562 static const G4int iParity[NMultiplets];
1563 static const G4int iGParity[NMultiplets][NMesonTypes];
1564 static const G4int iChargeConjugation[NMultiplets];
1565 static const G4int encodingOffset[NMultiplets];
1566
1567 enum
1568 {
1569 MPiGamma = 0,
1570 MRhoGamma = 1,
1571 M2Pi = 2,
1572 MPiRho = 3,
1573 M3Pi = 4,
1574 MPiEta = 5,
1575 M4Pi = 6,
1576 MKKStar = 7,
1577 M2PiEta = 8,
1578 MRhoEta = 9,
1579 M2PiRho = 10,
1580 M2PiOmega = 11,
1581 M2Eta = 12,
1582 M2K = 13,
1583 M2KPi = 14,
1584 MPiOmega = 15,
1585 MPiF2 = 16,
1586 MPiF0 = 17,
1587 MPiA2 = 18
1588 };
1589 enum
1590 {
1591 MKPi = 0,
1592 MKStarPi = 1,
1593 MKRho = 2,
1594 MKOmega = 3,
1595 MKStar2Pi = 4,
1596 MKTwoPi = 5,
1597 MKEta = 6
1598 };
1599
1600 static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes];
1601};
1602
1603inline G4String G4ExcitedMesonConstructor::GetName(G4int iIso3, G4int iState, G4int iType)
1604{
1605 G4String particle = name[iState][iType];
1606 if (iType == TPi) {
1607 if (iIso3 == +2) {
1608 particle += "+";
1609 }
1610 else if (iIso3 == -2) {
1611 particle += "-";
1612 }
1613 else {
1614 particle += "0";
1615 }
1616 }
1617 else if (iType == TK) {
1618 if (iIso3 == +1) {
1619 particle += "+";
1620 }
1621 else if (iIso3 == -1) {
1622 particle += "0";
1623 }
1624 }
1625 else if (iType == TAntiK) {
1626 if (iIso3 == +1) {
1627 particle += "0";
1628 particle = "anti_" + particle;
1629 }
1630 else if (iIso3 == -1) {
1631 particle += "-";
1632 }
1633 }
1634 return particle;
1635}
1636
1637#endif

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 1392 of file G4ExcitedMesonConstructor.hh.

1430{
1431 // This class is a utility class for construction
1432 // short lived particles
1433 public:
1434 enum
1435 {
1436 NMultiplets = 10
1437 };
1438
1439 enum
1440 {
1441 NMesonTypes = 5
1442 };
1443
1444 enum
1445 {
1446 NumberOfDecayModes = 19
1447 };
1448
1449 public:
1450 G4ExcitedMesonConstructor(G4int nStates = 0, G4int isoSpin = 0);
1451 virtual ~G4ExcitedMesonConstructor() = default;
1452
1453 virtual void Construct(G4int indexOfState = -1);
1454
1455 protected:
1456 void ConstructMesons(G4int indexOfState, G4int indexOfType);
1457
1458 G4String GetName(G4int iIso3, G4int iState, G4int idxType);
1459 G4double GetCharge(G4int iIsoSpin3);
1460 G4int GetEncoding(G4int iIsoSpin3, G4int idxState, G4int idxType);
1461 G4int GetQuarkContents(G4int iQ, G4int iIso3, G4int iType);
1462
1463 protected:
1464 G4DecayTable* CreateDecayTable(const G4String&, G4int, G4int, G4int);
1465
1466 G4DecayTable* AddKPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1467 G4int iType);
1468 G4DecayTable* AddKStarPiMode(G4DecayTable* table, const G4String& name, G4double br,
1469 G4int iIso3, G4int iType);
1470 G4DecayTable* AddKStar2PiMode(G4DecayTable* table, const G4String& name, G4double br,
1471 G4int iIso3, G4int iType);
1472 G4DecayTable* AddKRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1473 G4int iType);
1474 G4DecayTable* AddKTwoPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1475 G4int iType);
1476 G4DecayTable* AddKOmegaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1477 G4int iType);
1478 G4DecayTable* AddKEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1479 G4int iType);
1480 G4DecayTable* AddPiGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1481 G4int iIso3, G4int iIso);
1482 G4DecayTable* AddRhoGammaMode(G4DecayTable* table, const G4String& name, G4double br,
1483 G4int iIso3, G4int iIso);
1484 G4DecayTable* Add2PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1485 G4int iIso);
1486 G4DecayTable* AddPiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1487 G4int iIso);
1488 G4DecayTable* AddPiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1489 G4int iIso);
1490 G4DecayTable* AddPiF2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1491 G4int iIso);
1492 G4DecayTable* AddPiF0Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1493 G4int iIso);
1494 G4DecayTable* AddPiA2Mode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1495 G4int iIso);
1496 G4DecayTable* Add3PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1497 G4int iIso);
1498 G4DecayTable* Add4PiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1499 G4int iIso);
1500 G4DecayTable* AddKKStarMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1501 G4int iIso);
1502 G4DecayTable* Add2PiEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1503 G4int iIso);
1504 G4DecayTable* AddRhoEtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1505 G4int iIso);
1506 G4DecayTable* Add2PiRhoMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1507 G4int iIso);
1508 G4DecayTable* Add2PiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1509 G4int iIso3, G4int iIso);
1510 G4DecayTable* AddPiOmegaMode(G4DecayTable* table, const G4String& name, G4double br,
1511 G4int iIso3, G4int iIso);
1512 G4DecayTable* Add2EtaMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1513 G4int iIso);
1514 G4DecayTable* Add2KMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1515 G4int iIso);
1516 G4DecayTable* Add2KPiMode(G4DecayTable* table, const G4String& name, G4double br, G4int iIso3,
1517 G4int iIso);
1518
1519 G4bool Exist(G4int idxState, G4int idxType);
1520 G4double GetCharge(G4int iIsoSpin3, G4int idxType);
1521
1522 protected:
1523 enum
1524 {
1525 N11P1 = 0,
1526 N13P0 = 1,
1527 N13P1 = 2,
1528 N13P2 = 3,
1529 N11D2 = 4,
1530 N13D1 = 5,
1531 N13D3 = 6,
1532 N21S0 = 7,
1533 N23S1 = 8,
1534 N23P2 = 9
1535 };
1536
1537 enum
1538 {
1539 TPi = 0,
1540 TEta = 1,
1541 TEtaPrime = 2,
1542 TK = 3,
1543 TAntiK = 4
1544 };
1545
1546 const G4String type;
1547 const G4int leptonNumber{0};
1548 const G4int baryonNumber{0};
1549
1550 static const char* name[NMultiplets][NMesonTypes];
1551 static const G4double mass[NMultiplets][NMesonTypes];
1552 static const G4double massKdiff[NMultiplets];
1553 static const G4double width[NMultiplets][NMesonTypes];
1554 static const G4double widthKdiff[NMultiplets];
1555 static const G4int iIsoSpin[NMesonTypes];
1556 static const G4int iSpin[NMultiplets];
1557 static const G4int iParity[NMultiplets];
1558 static const G4int iGParity[NMultiplets][NMesonTypes];
1559 static const G4int iChargeConjugation[NMultiplets];
1560 static const G4int encodingOffset[NMultiplets];
1561
1562 enum
1563 {
1564 MPiGamma = 0,
1565 MRhoGamma = 1,
1566 M2Pi = 2,
1567 MPiRho = 3,
1568 M3Pi = 4,
1569 MPiEta = 5,
1570 M4Pi = 6,
1571 MKKStar = 7,
1572 M2PiEta = 8,
1573 MRhoEta = 9,
1574 M2PiRho = 10,
1575 M2PiOmega = 11,
1576 M2Eta = 12,
1577 M2K = 13,
1578 M2KPi = 14,
1579 MPiOmega = 15,
1580 MPiF2 = 16,
1581 MPiF0 = 17,
1582 MPiA2 = 18
1583 };
1584 enum
1585 {
1586 MKPi = 0,
1587 MKStarPi = 1,
1588 MKRho = 2,
1589 MKOmega = 3,
1590 MKStar2Pi = 4,
1591 MKTwoPi = 5,
1592 MKEta = 6
1593 };
1594
1595 static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes];
1596};
1597
1598inline G4String G4ExcitedMesonConstructor::GetName(G4int iIso3, G4int iState, G4int iType)
1599{
1600 G4String particle = name[iState][iType];
1601 if (iType == TPi) {
1602 if (iIso3 == +2) {
1603 particle += "+";
1604 }
1605 else if (iIso3 == -2) {
1606 particle += "-";
1607 }
1608 else {
1609 particle += "0";
1610 }
1611 }
1612 else if (iType == TK) {
1613 if (iIso3 == +1) {
1614 particle += "+";
1615 }
1616 else if (iIso3 == -1) {
1617 particle += "0";
1618 }
1619 }
1620 else if (iType == TAntiK) {
1621 if (iIso3 == +1) {
1622 particle += "0";
1623 particle = "anti_" + particle;
1624 }
1625 else if (iIso3 == -1) {
1626 particle += "-";
1627 }
1628 }
1629 return particle;
1630}
1631
1632#endif

Referenced by ConstructMesons().

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