Geant4 11.2.2
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
G4ExcitedMesonConstructor Class Reference

#include <G4ExcitedMesonConstructor.hh>

Public Types

enum  { NMultiplets = 10 }
 
enum  { NMesonTypes = 5 }
 
enum  { NumberOfDecayModes = 19 }
 

Public Member Functions

 G4ExcitedMesonConstructor (G4int nStates=0, G4int isoSpin=0)
 
virtual ~G4ExcitedMesonConstructor ()=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
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
Enumerator
NumberOfDecayModes 

Definition at line 53 of file G4ExcitedMesonConstructor.hh.

54 {
55 NumberOfDecayModes = 19
56 };

◆ 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 };

◆ 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
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
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 };

Constructor & Destructor Documentation

◆ G4ExcitedMesonConstructor()

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

Definition at line 44 of file G4ExcitedMesonConstructor.cc.

44: 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 1135 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add2KMode()

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

Definition at line 1291 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add2KPiMode()

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

Definition at line 1320 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add2PiEtaMode()

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

Definition at line 1115 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add2PiMode()

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

Definition at line 817 of file G4ExcitedMesonConstructor.cc.

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

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

Referenced by CreateDecayTable().

◆ Add2PiRhoMode()

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

Definition at line 1186 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add3PiMode()

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

Definition at line 1045 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Add4PiMode()

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

Definition at line 1082 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKEtaMode()

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

Definition at line 469 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKKStarMode()

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

Definition at line 1245 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKOmegaMode()

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

Definition at line 439 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKPiMode()

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

Definition at line 363 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKRhoMode()

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

Definition at line 499 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKStar2PiMode()

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

Definition at line 575 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKStarPiMode()

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

Definition at line 537 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddKTwoPiMode()

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

Definition at line 400 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiA2Mode()

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

Definition at line 960 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiEtaMode()

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

Definition at line 702 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiF0Mode()

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

Definition at line 789 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiF2Mode()

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

Definition at line 760 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiGammaMode()

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

Definition at line 615 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiOmegaMode()

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

Definition at line 644 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddPiRhoMode()

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

Definition at line 875 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddRhoEtaMode()

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

Definition at line 731 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ AddRhoGammaMode()

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

Definition at line 673 of file G4ExcitedMesonConstructor.cc.

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

Referenced by CreateDecayTable().

◆ Construct()

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

Definition at line 46 of file G4ExcitedMesonConstructor.cc.

47{
48 G4int iType;
49 if (idx < 0) {
50 for (G4int state = 0; state < NMultiplets; state += 1) {
51 for (iType = 0; iType < NMesonTypes; iType++)
52 ConstructMesons(state, iType);
53 }
54 }
55 else if (idx < NMultiplets) {
56 for (iType = 0; iType < NMesonTypes; iType++)
57 ConstructMesons(idx, iType);
58 }
59 else {
60#ifdef G4VERBOSE
61 if (G4ParticleTable::GetParticleTable()->GetVerboseLevel() > 1) {
62 G4cerr << "G4ExcitedMesonConstructor::Construct()";
63 G4cerr << " illegal index os state = " << idx << G4endl;
64 }
65#endif
66 }
67}
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:82
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 82 of file G4ExcitedMesonConstructor.cc.

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

272{
273 // create decay table
274 auto decayTable = new G4DecayTable();
275 G4double br;
276
277 if ((iType == TK) || (iType == TAntiK)) {
278 if ((br = bRatio[iState][iType][MKPi]) > 0.0) {
279 AddKPiMode(decayTable, parentName, br, iIso3, iType);
280 }
281 if ((br = bRatio[iState][iType][MKStarPi]) > 0.0) {
282 AddKStarPiMode(decayTable, parentName, br, iIso3, iType);
283 }
284 if ((br = bRatio[iState][iType][MKRho]) > 0.0) {
285 AddKRhoMode(decayTable, parentName, br, iIso3, iType);
286 }
287 if ((br = bRatio[iState][iType][MKOmega]) > 0.0) {
288 AddKOmegaMode(decayTable, parentName, br, iIso3, iType);
289 }
290 if ((br = bRatio[iState][iType][MKStar2Pi]) > 0.0) {
291 AddKStar2PiMode(decayTable, parentName, br, iIso3, iType);
292 }
293 if ((br = bRatio[iState][iType][MKTwoPi]) > 0.0) {
294 AddKTwoPiMode(decayTable, parentName, br, iIso3, iType);
295 }
296 if ((br = bRatio[iState][iType][MKEta]) > 0.0) {
297 AddKEtaMode(decayTable, parentName, br, iIso3, iType);
298 }
299 }
300 else {
301 if ((br = bRatio[iState][iType][MPiGamma]) > 0.0) {
302 AddPiGammaMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
303 }
304 if ((br = bRatio[iState][iType][MRhoGamma]) > 0.0) {
305 AddRhoGammaMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
306 }
307 if ((br = bRatio[iState][iType][M2Pi]) > 0.0) {
308 Add2PiMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
309 }
310 if ((br = bRatio[iState][iType][MPiRho]) > 0.0) {
311 AddPiRhoMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
312 }
313 if ((br = bRatio[iState][iType][MPiEta]) > 0.0) {
314 AddPiEtaMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
315 }
316 if ((br = bRatio[iState][iType][M3Pi]) > 0.0) {
317 Add3PiMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
318 }
319 if ((br = bRatio[iState][iType][M4Pi]) > 0.0) {
320 Add4PiMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
321 }
322 if ((br = bRatio[iState][iType][MKKStar]) > 0.0) {
323 AddKKStarMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
324 }
325 if ((br = bRatio[iState][iType][M2PiEta]) > 0.0) {
326 Add2PiEtaMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
327 }
328 if ((br = bRatio[iState][iType][MRhoEta]) > 0.0) {
329 AddRhoEtaMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
330 }
331 if ((br = bRatio[iState][iType][M2PiRho]) > 0.0) {
332 Add2PiRhoMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
333 }
334 if ((br = bRatio[iState][iType][M2PiOmega]) > 0.0) {
335 Add2PiOmegaMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
336 }
337 if ((br = bRatio[iState][iType][M2Eta]) > 0.0) {
338 Add2EtaMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
339 }
340 if ((br = bRatio[iState][iType][M2K]) > 0.0) {
341 Add2KMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
342 }
343 if ((br = bRatio[iState][iType][M2KPi]) > 0.0) {
344 Add2KPiMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
345 }
346 if ((br = bRatio[iState][iType][MPiOmega]) > 0.0) {
347 AddPiOmegaMode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
348 }
349 if ((br = bRatio[iState][iType][MPiF2]) > 0.0) {
350 AddPiF2Mode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
351 }
352 if ((br = bRatio[iState][iType][MPiF0]) > 0.0) {
353 AddPiF0Mode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
354 }
355 if ((br = bRatio[iState][iType][MPiA2]) > 0.0) {
356 AddPiA2Mode(decayTable, parentName, br, iIso3, iIsoSpin[iType]);
357 }
358 }
359
360 return decayTable;
361}
G4ExcitedMesonConstructor::Add3PiMode
G4DecayTable * Add3PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:1045
G4ExcitedMesonConstructor::AddKRhoMode
G4DecayTable * AddKRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition G4ExcitedMesonConstructor.cc:499
G4ExcitedMesonConstructor::AddPiF0Mode
G4DecayTable * AddPiF0Mode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:789
G4ExcitedMesonConstructor::AddPiA2Mode
G4DecayTable * AddPiA2Mode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:960
G4ExcitedMesonConstructor::AddKStarPiMode
G4DecayTable * AddKStarPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition G4ExcitedMesonConstructor.cc:537
G4ExcitedMesonConstructor::AddKOmegaMode
G4DecayTable * AddKOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition G4ExcitedMesonConstructor.cc:439
G4ExcitedMesonConstructor::Add2KPiMode
G4DecayTable * Add2KPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:1320
G4ExcitedMesonConstructor::Add2PiMode
G4DecayTable * Add2PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:817
G4ExcitedMesonConstructor::AddKTwoPiMode
G4DecayTable * AddKTwoPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition G4ExcitedMesonConstructor.cc:400
G4ExcitedMesonConstructor::AddPiOmegaMode
G4DecayTable * AddPiOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:644
G4ExcitedMesonConstructor::AddPiF2Mode
G4DecayTable * AddPiF2Mode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:760
G4ExcitedMesonConstructor::AddKPiMode
G4DecayTable * AddKPiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition G4ExcitedMesonConstructor.cc:363
G4ExcitedMesonConstructor::AddPiEtaMode
G4DecayTable * AddPiEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:702
G4ExcitedMesonConstructor::AddKStar2PiMode
G4DecayTable * AddKStar2PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition G4ExcitedMesonConstructor.cc:575
G4ExcitedMesonConstructor::AddKEtaMode
G4DecayTable * AddKEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iType)
Definition G4ExcitedMesonConstructor.cc:469
G4ExcitedMesonConstructor::AddRhoEtaMode
G4DecayTable * AddRhoEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:731
G4ExcitedMesonConstructor::Add2PiOmegaMode
G4DecayTable * Add2PiOmegaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:1149
G4ExcitedMesonConstructor::Add2PiEtaMode
G4DecayTable * Add2PiEtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:1115
G4ExcitedMesonConstructor::Add2PiRhoMode
G4DecayTable * Add2PiRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:1186
G4ExcitedMesonConstructor::AddRhoGammaMode
G4DecayTable * AddRhoGammaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:673
G4ExcitedMesonConstructor::Add4PiMode
G4DecayTable * Add4PiMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:1082
G4ExcitedMesonConstructor::Add2EtaMode
G4DecayTable * Add2EtaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:1135
G4ExcitedMesonConstructor::bRatio
static const G4double bRatio[NMultiplets][NMesonTypes][NumberOfDecayModes]
Definition G4ExcitedMesonConstructor.hh:1458
G4ExcitedMesonConstructor::AddPiGammaMode
G4DecayTable * AddPiGammaMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:615
G4ExcitedMesonConstructor::Add2KMode
G4DecayTable * Add2KMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:1291
G4ExcitedMesonConstructor::AddKKStarMode
G4DecayTable * AddKKStarMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:1245
G4ExcitedMesonConstructor::AddPiRhoMode
G4DecayTable * AddPiRhoMode(G4DecayTable *table, const G4String &name, G4double br, G4int iIso3, G4int iIso)
Definition G4ExcitedMesonConstructor.cc:875

Referenced by ConstructMesons().

◆ Exist()

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

Definition at line 69 of file G4ExcitedMesonConstructor.cc.

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

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

◆ GetEncoding()

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

Definition at line 218 of file G4ExcitedMesonConstructor.cc.

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

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

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

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

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

Referenced by CreateDecayTable().

◆ encodingOffset

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

Definition at line 1452 of file G4ExcitedMesonConstructor.hh.

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

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

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

Referenced by ConstructMesons().

◆ iIsoSpin

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

Definition at line 1410 of file G4ExcitedMesonConstructor.hh.

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

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

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

Definition at line 1371 of file G4ExcitedMesonConstructor.hh.

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

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

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

Referenced by ConstructMesons(), and GetName().

◆ type

const G4String G4ExcitedMesonConstructor::type
protected

Definition at line 155 of file G4ExcitedMesonConstructor.hh.

Referenced by ConstructMesons().

◆ width

const G4double G4ExcitedMesonConstructor::width
staticprotected
Initial value:
=
{
{ 142.0*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 },
{ 420.0*MeV, 22.7*MeV, 54.5*MeV, 174.0*MeV, 174.0*MeV },
{ 107.0*MeV, 186.6*MeV, 86.0*MeV, 100.0*MeV, 100.0*MeV },
{ 258.0*MeV, 181.0*MeV, 225.0*MeV, 186.0*MeV, 186.0*MeV },
{ 250.0*MeV, 315.0*MeV, 0.0, 322.0*MeV, 322.0*MeV },
{ 161.0*MeV, 168.0*MeV, 87.0*MeV, 161.0*MeV, 161.0*MeV },
{ 400.0*MeV, 55.0*MeV, 90.0*MeV, 335.0*MeV, 335.0*MeV },
{ 400.0*MeV, 290.0*MeV, 150.0*MeV, 232.0*MeV, 232.0*MeV },
{ 0.0, 197.0*MeV, 202.0*MeV, 348.0*MeV, 348.0*MeV }
}

Definition at line 1395 of file G4ExcitedMesonConstructor.hh.

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

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

Referenced by ConstructMesons().

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