| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
>> 23 //
>> 24 // $Id: G4ExcitedXiConstructor.cc,v 1.5 2001/07/11 10:02:09 gunter Exp $
>> 25 // GEANT4 tag $Name: geant4-05-00 $
>> 26 //
>> 27 //
26 // ------------------------------------------- 28 // --------------------------------------------------------------
27 // GEANT 4 class implementation file << 29 // GEANT 4 class implementation file
28 // 30 //
29 // History: first implementation, based o 31 // History: first implementation, based on object model of
30 // 10 oct 1998 H.Kurashige 32 // 10 oct 1998 H.Kurashige
31 // <<
32 // Update mass and width following PDG 20 <<
33 // 4 nov 2023 S.Okada <<
34 // ------------------------------------------- 33 // ---------------------------------------------------------------
35 34
>> 35
36 #include "G4ExcitedXiConstructor.hh" 36 #include "G4ExcitedXiConstructor.hh"
37 37
38 #include "G4DecayTable.hh" << 38 #include "G4ParticleDefinition.hh"
>> 39 #include "G4ParticleTable.hh"
>> 40 #include "G4ShortLivedTable.hh"
39 #include "G4PhaseSpaceDecayChannel.hh" 41 #include "G4PhaseSpaceDecayChannel.hh"
40 #include "G4SystemOfUnits.hh" <<
41 #include "G4VDecayChannel.hh" 42 #include "G4VDecayChannel.hh"
>> 43 #include "G4DecayTable.hh"
42 44
43 G4ExcitedXiConstructor::G4ExcitedXiConstructor << 45 G4ExcitedXiConstructor::G4ExcitedXiConstructor():
>> 46 G4ExcitedBaryonConstructor(NStates, XiIsoSpin)
>> 47 {
44 48
45 G4DecayTable* G4ExcitedXiConstructor::CreateDe << 49 }
46 << 50
>> 51 G4ExcitedXiConstructor::~G4ExcitedXiConstructor()
>> 52 {
>> 53 }
>> 54
>> 55 G4DecayTable* G4ExcitedXiConstructor::CreateDecayTable(
>> 56 const G4String& parentName,
>> 57 G4int iIso3,
>> 58 G4int iState,
>> 59 G4bool fAnti)
47 { 60 {
>> 61
48 // create decay table 62 // create decay table
49 auto decayTable = new G4DecayTable(); << 63 G4DecayTable* decayTable = new G4DecayTable();
50 64
51 G4double br; 65 G4double br;
52 if ((br = bRatio[iState][XiPi]) > 0.0) { << 66 if ( (br=bRatio[iState][XiPi]) >0.0) {
53 AddXiPiMode(decayTable, parentName, br, iI << 67 AddXiPiMode( decayTable, parentName, br, iIso3, fAnti);
54 } 68 }
55 69
56 if ((br = bRatio[iState][XiGamma]) > 0.0) { << 70 if ( (br=bRatio[iState][XiGamma]) >0.0) {
57 AddXiGammaMode(decayTable, parentName, br, << 71 AddXiGammaMode( decayTable, parentName, br, iIso3, fAnti);
58 } 72 }
59 73
60 if ((br = bRatio[iState][LambdaK]) > 0.0) { << 74 if ( (br=bRatio[iState][LambdaK]) >0.0) {
61 AddLambdaKMode(decayTable, parentName, br, << 75 AddLambdaKMode( decayTable, parentName, br, iIso3, fAnti);
62 } 76 }
63 77
64 if ((br = bRatio[iState][SigmaK]) > 0.0) { << 78 if ( (br=bRatio[iState][SigmaK]) >0.0) {
65 AddSigmaKMode(decayTable, parentName, br, << 79 AddSigmaKMode( decayTable, parentName, br, iIso3, fAnti);
66 } 80 }
67 81
68 return decayTable; << 82 return decayTable;
69 } 83 }
70 84
71 G4DecayTable* G4ExcitedXiConstructor::AddXiGam << 85 G4DecayTable* G4ExcitedXiConstructor::AddXiGammaMode(
72 << 86 G4DecayTable* decayTable, const G4String& nameParent,
73 << 87 G4double br, G4int iIso3, G4bool fAnti)
74 { 88 {
75 G4VDecayChannel* mode; 89 G4VDecayChannel* mode;
76 G4String daughterH; << 90 //
77 if (iIso3 == +1) { << 91 G4String daughterH;
78 daughterH = "xi0"; << 92 if (iIso3== +1) {
79 } << 93 daughterH = "xi0";
80 else if (iIso3 == -1) { << 94 } else if (iIso3==-1) {
81 daughterH = "xi-"; << 95 daughterH = "xi-";
82 } << 96 }
83 if (fAnti) daughterH = "anti_" + daughterH; 97 if (fAnti) daughterH = "anti_" + daughterH;
84 98
85 // create decay channel [parent BR # 99 // create decay channel [parent BR #daughters]
86 mode = new G4PhaseSpaceDecayChannel(namePare << 100 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
>> 101 daughterH,"gamma");
87 // add decay table 102 // add decay table
88 decayTable->Insert(mode); 103 decayTable->Insert(mode);
89 104
90 return decayTable; 105 return decayTable;
91 } 106 }
92 107
93 G4DecayTable* G4ExcitedXiConstructor::AddLambd << 108 G4DecayTable* G4ExcitedXiConstructor::AddLambdaKMode(
94 << 109 G4DecayTable* decayTable, const G4String& nameParent,
95 << 110 G4double br, G4int iIso3, G4bool fAnti)
>> 111
96 112
97 { 113 {
98 G4VDecayChannel* mode; 114 G4VDecayChannel* mode;
99 115
100 G4String lambda = "lambda"; 116 G4String lambda = "lambda";
101 G4String daughterK; 117 G4String daughterK;
102 G4double r = 0.; 118 G4double r = 0.;
103 119
104 // ------------ Lambda K- ------------ << 120 // ------------ Lambda K- ------------
105 // determine daughters 121 // determine daughters
106 if (iIso3 == +1) { 122 if (iIso3 == +1) {
107 if (!fAnti) { 123 if (!fAnti) {
108 daughterK = "kaon0"; 124 daughterK = "kaon0";
109 } << 125 } else {
110 else { <<
111 daughterK = "anti_kaon0"; 126 daughterK = "anti_kaon0";
112 } << 127 }
113 r = br; 128 r = br;
114 } << 129 } else if (iIso3 == -1) {
115 else if (iIso3 == -1) { <<
116 if (!fAnti) { 130 if (!fAnti) {
117 daughterK = "kaon-"; 131 daughterK = "kaon-";
118 } << 132 } else {
119 else { <<
120 daughterK = "kaon+"; 133 daughterK = "kaon+";
121 } << 134 }
122 r = br; 135 r = br;
123 } 136 }
124 if (fAnti) lambda = "anti_" + lambda; 137 if (fAnti) lambda = "anti_" + lambda;
125 if (r > 0.) { << 138 if (r>0.) {
126 // create decay channel [parent BR 139 // create decay channel [parent BR #daughters]
127 mode = new G4PhaseSpaceDecayChannel(namePa << 140 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 141 lambda,daughterK);
128 // add decay table 142 // add decay table
129 decayTable->Insert(mode); 143 decayTable->Insert(mode);
130 } 144 }
131 145
132 return decayTable; 146 return decayTable;
133 } 147 }
134 148
135 G4DecayTable* G4ExcitedXiConstructor::AddSigma << 149 G4DecayTable* G4ExcitedXiConstructor::AddSigmaKMode(
136 << 150 G4DecayTable* decayTable, const G4String& nameParent,
137 << 151 G4double br, G4int iIso3, G4bool fAnti)
138 { 152 {
139 G4VDecayChannel* mode; 153 G4VDecayChannel* mode;
140 154
141 G4String daughterH; 155 G4String daughterH;
142 G4String daughterK; 156 G4String daughterK;
143 G4double r = 0.; 157 G4double r = 0.;
144 158
145 // ------------ Sigma K- ------------ << 159 // ------------ Sigma K- ------------
146 // determine daughters 160 // determine daughters
147 if (iIso3 == +1) { << 161 if (iIso3== +1) {
148 daughterH = "sigma+"; << 162 daughterH = "sigma+";
149 r = br / 2.; << 163 r= br/2.;
150 } << 164 } else if (iIso3== -1) {
151 else if (iIso3 == -1) { << 165 daughterH = "sigma0";
152 daughterH = "sigma0"; << 166 r = br/2.;
153 r = br / 2.; <<
154 } 167 }
155 if (!fAnti) { 168 if (!fAnti) {
156 daughterK = "kaon-"; 169 daughterK = "kaon-";
157 } << 170 } else {
158 else { <<
159 daughterK = "kaon+"; 171 daughterK = "kaon+";
160 } 172 }
161 if (fAnti) daughterH = "anti_" + daughterH; 173 if (fAnti) daughterH = "anti_" + daughterH;
162 if (r > 0.) { << 174 if (r>0.) {
163 // create decay channel [parent BR 175 // create decay channel [parent BR #daughters]
164 mode = new G4PhaseSpaceDecayChannel(namePa << 176 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 177 daughterH,daughterK);
165 // add decay table 178 // add decay table
166 decayTable->Insert(mode); 179 decayTable->Insert(mode);
167 } 180 }
168 181
169 // ------------ Sigma K0 ------------ << 182 // ------------ Sigma K0 ------------
170 // determine daughters 183 // determine daughters
171 if (iIso3 == +1) { 184 if (iIso3 == +1) {
172 daughterH = "sigma0"; << 185 daughterH = "sigma0";
173 r = br / 2.; << 186 r= br/2.;
174 } << 187 } else if (iIso3 == -1) {
175 else if (iIso3 == -1) { << 188 daughterH = "sigma-";
176 daughterH = "sigma-"; << 189 r = br/2.;
177 r = br / 2.; <<
178 } 190 }
179 if (!fAnti) { 191 if (!fAnti) {
180 daughterK = "anti_kaon0"; 192 daughterK = "anti_kaon0";
181 } << 193 } else {
182 else { <<
183 daughterK = "kaon0"; 194 daughterK = "kaon0";
184 } 195 }
185 if (fAnti) daughterH = "anti_" + daughterH; 196 if (fAnti) daughterH = "anti_" + daughterH;
186 if (r > 0.) { << 197 if (r>0.) {
187 // create decay channel [parent BR 198 // create decay channel [parent BR #daughters]
188 mode = new G4PhaseSpaceDecayChannel(namePa << 199 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 200 daughterH,daughterK);
189 // add decay table 201 // add decay table
190 decayTable->Insert(mode); 202 decayTable->Insert(mode);
191 } 203 }
192 204
193 return decayTable; 205 return decayTable;
194 } 206 }
195 207
196 G4DecayTable* G4ExcitedXiConstructor::AddXiPiM << 208 G4DecayTable* G4ExcitedXiConstructor::AddXiPiMode(
197 << 209 G4DecayTable* decayTable, const G4String& nameParent,
198 << 210 G4double br, G4int iIso3, G4bool fAnti)
199 { 211 {
200 G4VDecayChannel* mode; 212 G4VDecayChannel* mode;
201 213
202 G4String daughterXi; 214 G4String daughterXi;
203 G4String daughterPi; 215 G4String daughterPi;
204 G4double r = 0.; 216 G4double r = 0.;
205 217
206 // ------------ Xi pi- ------------ << 218 // ------------ Xi pi- ------------
207 // determine daughters 219 // determine daughters
208 if (iIso3 == +1) { << 220 if (iIso3== +1) {
209 r = 0.; 221 r = 0.;
210 } << 222 } else if (iIso3 == -1) {
211 else if (iIso3 == -1) { <<
212 daughterXi = "xi0"; 223 daughterXi = "xi0";
213 r = br / 2.; << 224 r = br/2.;
214 } 225 }
215 if (!fAnti) { 226 if (!fAnti) {
216 daughterPi = "pi-"; 227 daughterPi = "pi-";
217 } << 228 } else {
218 else { <<
219 daughterPi = "pi+"; 229 daughterPi = "pi+";
220 } 230 }
221 if (fAnti) daughterXi = "anti_" + daughterXi 231 if (fAnti) daughterXi = "anti_" + daughterXi;
222 if (r > 0.) { << 232 if (r>0.) {
223 // create decay channel [parent BR 233 // create decay channel [parent BR #daughters]
224 mode = new G4PhaseSpaceDecayChannel(namePa << 234 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 235 daughterXi,daughterPi);
225 // add decay table 236 // add decay table
226 decayTable->Insert(mode); 237 decayTable->Insert(mode);
227 } 238 }
228 // ------------ Xi Pi0 ------------ << 239 // ------------ Xi Pi0 ------------
229 // determine daughters 240 // determine daughters
230 if (iIso3 == +1) { << 241 if (iIso3== +1) {
231 daughterXi = "xi0"; 242 daughterXi = "xi0";
232 r = br / 2.; << 243 r = br/2.;
233 } << 244 } else if (iIso3 == -1) {
234 else if (iIso3 == -1) { <<
235 daughterXi = "xi-"; 245 daughterXi = "xi-";
236 r = br / 2.; << 246 r = br/2.;
237 } 247 }
238 daughterPi = "pi0"; 248 daughterPi = "pi0";
239 if (fAnti) daughterXi = "anti_" + daughterXi 249 if (fAnti) daughterXi = "anti_" + daughterXi;
240 if (r > 0.) { << 250 if (r>0.) {
241 // create decay channel [parent BR 251 // create decay channel [parent BR #daughters]
242 mode = new G4PhaseSpaceDecayChannel(namePa << 252 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 253 daughterXi,daughterPi);
243 // add decay table 254 // add decay table
244 decayTable->Insert(mode); 255 decayTable->Insert(mode);
245 } 256 }
246 257
247 // ------------ XI pi + ------------ << 258 // ------------ XI pi + ------------
248 // determine daughters 259 // determine daughters
249 if (iIso3 == +1) { << 260 if (iIso3== +1) {
250 daughterXi = "xi-"; 261 daughterXi = "xi-";
251 r = br / 2.; << 262 r = br/2.;
252 } << 263 } else if (iIso3==-1) {
253 else if (iIso3 == -1) { <<
254 r = 0.; 264 r = 0.;
255 } 265 }
256 if (!fAnti) { 266 if (!fAnti) {
257 daughterPi = "pi+"; 267 daughterPi = "pi+";
258 } << 268 } else {
259 else { <<
260 daughterPi = "pi-"; 269 daughterPi = "pi-";
261 } 270 }
262 if (fAnti) daughterXi = "anti_" + daughterXi 271 if (fAnti) daughterXi = "anti_" + daughterXi;
263 if (r > 0.) { << 272 if (r>0.) {
264 // create decay channel [parent BR 273 // create decay channel [parent BR #daughters]
265 mode = new G4PhaseSpaceDecayChannel(namePa << 274 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 275 daughterXi,daughterPi);
266 // add decay table 276 // add decay table
267 decayTable->Insert(mode); 277 decayTable->Insert(mode);
268 } 278 }
269 279
270 return decayTable; 280 return decayTable;
271 } 281 }
272 282
273 G4double G4ExcitedXiConstructor::GetMass(G4int <<
274 { <<
275 G4double fm = mass[iState]; <<
276 if (iState == 0) { <<
277 if (iso3 == -1) fm = 1.5350 * GeV; // xi- <<
278 } <<
279 return fm; <<
280 } <<
281 <<
282 G4double G4ExcitedXiConstructor::GetWidth(G4in <<
283 { <<
284 G4double fw = width[iState]; <<
285 if (iState == 0) { <<
286 if (iso3 == -1) fw = 9.9 * MeV; // xi- <<
287 } <<
288 return fw; <<
289 } <<
290 <<
291 // clang-format off <<
292 283
293 const char* G4ExcitedXiConstructor::name[] = { 284 const char* G4ExcitedXiConstructor::name[] = {
294 "xi(1530)", "xi(1690)", "xi(1820)", "xi(195 285 "xi(1530)", "xi(1690)", "xi(1820)", "xi(1950)", "xi(2030)"
295 }; 286 };
296 287
297 const G4double G4ExcitedXiConstructor::mass[] 288 const G4double G4ExcitedXiConstructor::mass[] = {
298 1.5318*GeV, 1.690*GeV, 1.823*GeV, 1.950*GeV, << 289 1.532*GeV, 1.700*GeV, 1.823*GeV, 1.950*GeV, 2.025*GeV
299 }; 290 };
300 291
301 const G4double G4ExcitedXiConstructor::width[] 292 const G4double G4ExcitedXiConstructor::width[] = {
302 9.1*MeV, 20.0*MeV, 24.0*MeV, 60.0*MeV, << 293 9.0*MeV, 50.0*MeV, 24.0*MeV, 60.0*MeV, 20.0*MeV
303 }; 294 };
304 295
305 const G4int G4ExcitedXiConstructor::iSpin[] = 296 const G4int G4ExcitedXiConstructor::iSpin[] = {
306 3, 3, 3, 3, 5 297 3, 3, 3, 3, 5
307 }; 298 };
308 299
309 const G4int G4ExcitedXiConstructor::iParity[] 300 const G4int G4ExcitedXiConstructor::iParity[] = {
310 +1, +1, -1, -1, +1 301 +1, +1, -1, -1, +1
311 }; 302 };
312 303
313 304
314 const G4int G4ExcitedXiConstructor::encodingOf 305 const G4int G4ExcitedXiConstructor::encodingOffset[] = {
315 0, 20000, 10000, 30000, 10000 306 0, 20000, 10000, 30000, 10000
316 }; 307 };
317 308
318 const G4double G4ExcitedXiConstructor::bRatio[ << 309 const G4double G4ExcitedXiConstructor::bRatio[ G4ExcitedXiConstructor::NStates ][ G4ExcitedXiConstructor::NumberOfDecayModes] =
319 { 310 {
320 { 0.98, 0.02, 0.0, 0.0}, << 311 { 0.98, 0.02, 0.0, 0.0},
321 { 0.10, 0.0, 0.70, 0.20}, << 312 { 0.10, 0.0, 0.70, 0.20},
322 { 0.15, 0.0, 0.70, 0.15}, << 313 { 0.15, 0.0, 0.70, 0.15},
323 { 0.25, 0.0, 0.50, 0.25}, << 314 { 0.25, 0.0, 0.50, 0.25},
324 { 0.10, 0.0, 0.20, 0.70} 315 { 0.10, 0.0, 0.20, 0.70}
325 }; 316 };
>> 317
>> 318
>> 319
>> 320
>> 321
>> 322
>> 323
>> 324
>> 325
>> 326
>> 327
326 328