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