| 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: G4ExcitedSigmaConstructor.cc 79342 2014-02-24 11:42:42Z 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 "G4ExcitedSigmaConstructor.hh" 38 #include "G4ExcitedSigmaConstructor.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 G4ExcitedSigmaConstructor::G4ExcitedSigmaConstructor():
>> 48 G4ExcitedBaryonConstructor(NStates, SigmaIsoSpin)
>> 49 {
>> 50
>> 51 }
42 52
43 G4ExcitedSigmaConstructor::G4ExcitedSigmaConst << 53 G4ExcitedSigmaConstructor::~G4ExcitedSigmaConstructor()
44 : G4ExcitedBaryonConstructor(NStates, SigmaI << 54 {
45 {} << 55 }
46 56
47 G4DecayTable* G4ExcitedSigmaConstructor::Creat << 57 G4DecayTable* G4ExcitedSigmaConstructor::CreateDecayTable(
48 << 58 const G4String& parentName,
>> 59 G4int iIso3,
>> 60 G4int iState,
>> 61 G4bool fAnti)
49 { 62 {
>> 63
50 // create decay table 64 // create decay table
51 auto decayTable = new G4DecayTable(); << 65 G4DecayTable* decayTable = new G4DecayTable();
52 66
53 G4double br; 67 G4double br;
54 if ((br = bRatio[iState][NK]) > 0.0) { << 68 if ( (br=bRatio[iState][NK]) >0.0) {
55 AddNKMode(decayTable, parentName, br, iIso << 69 AddNKMode( decayTable, parentName, br, iIso3, fAnti);
56 } 70 }
57 71
58 if ((br = bRatio[iState][NKStar]) > 0.0) { << 72 if ( (br=bRatio[iState][NKStar]) >0.0) {
59 AddNKStarMode(decayTable, parentName, br, << 73 AddNKStarMode( decayTable, parentName, br, iIso3, fAnti);
60 } 74 }
61 75
62 if ((br = bRatio[iState][SigmaPi]) > 0.0) { << 76 if ( (br=bRatio[iState][SigmaPi]) >0.0) {
63 AddSigmaPiMode(decayTable, parentName, br, << 77 AddSigmaPiMode( decayTable, parentName, br, iIso3, fAnti);
64 } 78 }
65 79
66 if ((br = bRatio[iState][SigmaStarPi]) > 0.0 << 80 if ( (br=bRatio[iState][SigmaStarPi]) >0.0) {
67 AddSigmaStarPiMode(decayTable, parentName, << 81 AddSigmaStarPiMode( decayTable, parentName, br, iIso3, fAnti);
68 } 82 }
69 83
70 if ((br = bRatio[iState][LambdaPi]) > 0.0) { << 84 if ( (br=bRatio[iState][LambdaPi]) >0.0) {
71 AddLambdaPiMode(decayTable, parentName, br << 85 AddLambdaPiMode( decayTable, parentName, br, iIso3, fAnti);
72 } 86 }
73 87
74 if ((br = bRatio[iState][SigmaEta]) > 0.0) { << 88 if ( (br=bRatio[iState][SigmaEta]) >0.0) {
75 AddSigmaEtaMode(decayTable, parentName, br << 89 AddSigmaEtaMode( decayTable, parentName, br, iIso3, fAnti);
76 } 90 }
77 91
78 if ((br = bRatio[iState][LambdaStarPi]) > 0. << 92 if ( (br=bRatio[iState][LambdaStarPi]) >0.0) {
79 AddLambdaStarPiMode(decayTable, parentName << 93 AddLambdaStarPiMode( decayTable, parentName, br, iIso3, fAnti);
80 } 94 }
81 95
82 if ((br = bRatio[iState][DeltaK]) > 0.0) { << 96 if ( (br=bRatio[iState][DeltaK]) >0.0) {
83 AddDeltaKMode(decayTable, parentName, br, << 97 AddDeltaKMode( decayTable, parentName, br, iIso3, fAnti);
84 } 98 }
85 99
86 return decayTable; << 100 return decayTable;
87 } 101 }
88 102
89 G4DecayTable* G4ExcitedSigmaConstructor::AddSi << 103 G4DecayTable* G4ExcitedSigmaConstructor::AddSigmaEtaMode(
90 << 104 G4DecayTable* decayTable, const G4String& nameParent,
91 << 105 G4double br, G4int iIso3, G4bool fAnti)
92 { 106 {
93 G4VDecayChannel* mode; 107 G4VDecayChannel* mode;
94 // << 108 //
95 G4String daughterH; << 109 G4String daughterH;
96 if (iIso3 == +2) { << 110 if (iIso3== +2) {
97 daughterH = "sigma+"; << 111 daughterH = "sigma+";
98 } << 112 } else if (iIso3== 0) {
99 else if (iIso3 == 0) { << 113 daughterH = "sigma0";
100 daughterH = "sigma0"; << 114 } else if (iIso3== -2) {
101 } << 115 daughterH = "sigma-";
102 else if (iIso3 == -2) { << 116 }
103 daughterH = "sigma-"; <<
104 } <<
105 if (fAnti) daughterH = "anti_" + daughterH; 117 if (fAnti) daughterH = "anti_" + daughterH;
106 118
107 // create decay channel [parent BR # 119 // create decay channel [parent BR #daughters]
108 mode = new G4PhaseSpaceDecayChannel(namePare << 120 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
>> 121 daughterH,"eta");
109 // add decay table 122 // add decay table
110 decayTable->Insert(mode); 123 decayTable->Insert(mode);
111 124
112 return decayTable; 125 return decayTable;
113 } 126 }
114 127
115 G4DecayTable* G4ExcitedSigmaConstructor::AddNK << 128 G4DecayTable* G4ExcitedSigmaConstructor::AddNKMode(
116 << 129 G4DecayTable* decayTable, const G4String& nameParent,
117 << 130 G4double br, G4int iIso3, G4bool fAnti)
>> 131
118 132
119 { 133 {
120 G4VDecayChannel* mode; 134 G4VDecayChannel* mode;
121 135
122 G4String daughterN; 136 G4String daughterN;
123 G4String daughterK; 137 G4String daughterK;
124 G4double r = 0.; 138 G4double r = 0.;
125 139
126 // ------------ N K- ------------ << 140 // ------------ N K- ------------
127 // determine daughters 141 // determine daughters
128 if (iIso3 == +2) { << 142 if (iIso3== +2) {
129 r = 0.; << 143 r=0.;
130 } << 144 } else if (iIso3== 0) {
131 else if (iIso3 == 0) { << 145 daughterN = "proton";
132 daughterN = "proton"; << 146 r = br/2.;
133 r = br / 2.; << 147 } else if (iIso3== -2) {
134 } << 148 daughterN = "neutron";
135 else if (iIso3 == -2) { <<
136 daughterN = "neutron"; <<
137 r = br; 149 r = br;
138 } 150 }
139 if (!fAnti) { 151 if (!fAnti) {
140 daughterK = "kaon-"; 152 daughterK = "kaon-";
141 } << 153 } else {
142 else { <<
143 daughterK = "kaon+"; 154 daughterK = "kaon+";
144 } << 155 }
145 if (fAnti) daughterN = "anti_" + daughterN; 156 if (fAnti) daughterN = "anti_" + daughterN;
146 if (r > 0.) { << 157 if (r>0.) {
147 // create decay channel [parent BR 158 // create decay channel [parent BR #daughters]
148 mode = new G4PhaseSpaceDecayChannel(namePa << 159 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 160 daughterN,daughterK);
149 // add decay table 161 // add decay table
150 decayTable->Insert(mode); 162 decayTable->Insert(mode);
151 } 163 }
152 164
153 // ------------ N K0 ------------ << 165 // ------------ N K0 ------------
154 // determine daughters 166 // determine daughters
155 if (iIso3 == +2) { << 167 if (iIso3== +2) {
156 daughterN = "proton"; << 168 daughterN = "proton";
157 r = br; << 169 r=br;
158 } << 170 } else if (iIso3== 0) {
159 else if (iIso3 == 0) { << 171 daughterN = "neutron";
160 daughterN = "neutron"; << 172 r = br/2.;
161 r = br / 2.; << 173 } else if (iIso3== -2) {
162 } <<
163 else if (iIso3 == -2) { <<
164 r = 0.; 174 r = 0.;
165 } 175 }
166 if (!fAnti) { 176 if (!fAnti) {
167 daughterK = "anti_kaon0"; 177 daughterK = "anti_kaon0";
168 } << 178 } else {
169 else { << 179
170 daughterK = "kaon0"; 180 daughterK = "kaon0";
171 } 181 }
172 if (fAnti) daughterN = "anti_" + daughterN; 182 if (fAnti) daughterN = "anti_" + daughterN;
173 if (r > 0.) { << 183 if (r>0.) {
174 // create decay channel [parent BR 184 // create decay channel [parent BR #daughters]
175 mode = new G4PhaseSpaceDecayChannel(namePa << 185 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 186 daughterN,daughterK);
176 // add decay table 187 // add decay table
177 decayTable->Insert(mode); 188 decayTable->Insert(mode);
178 } 189 }
179 190
180 return decayTable; 191 return decayTable;
181 } 192 }
182 193
183 G4DecayTable* G4ExcitedSigmaConstructor::AddDe << 194 G4DecayTable* G4ExcitedSigmaConstructor::AddDeltaKMode(
184 << 195 G4DecayTable* decayTable, const G4String& nameParent,
185 << 196 G4double br, G4int iIso3, G4bool fAnti)
186 { 197 {
187 G4VDecayChannel* mode; 198 G4VDecayChannel* mode;
188 199
189 G4String daughterN; 200 G4String daughterN;
190 G4String daughterK; 201 G4String daughterK;
191 G4double r = 0.; 202 G4double r = 0.;
192 203
193 // ------------ N K- ------------ << 204 // ------------ N K- ------------
194 // determine daughters 205 // determine daughters
195 if (iIso3 == +2) { << 206 if (iIso3== +2) {
196 daughterN = "delta++"; << 207 daughterN = "delta++";
197 r = 0.75 * br; << 208 r=0.75*br;
198 } << 209 } else if (iIso3== 0) {
199 else if (iIso3 == 0) { << 210 daughterN = "delta+";
200 daughterN = "delta+"; << 211 r = br/2.;
201 r = br / 2.; << 212 } else if (iIso3== -2) {
202 } << 213 daughterN = "delta0";
203 else if (iIso3 == -2) { << 214 r = 0.25*br;
204 daughterN = "delta0"; <<
205 r = 0.25 * br; <<
206 } 215 }
207 if (!fAnti) { 216 if (!fAnti) {
208 daughterK = "kaon-"; 217 daughterK = "kaon-";
209 } << 218 } else {
210 else { <<
211 daughterK = "kaon+"; 219 daughterK = "kaon+";
212 } 220 }
213 if (fAnti) daughterN = "anti_" + daughterN; 221 if (fAnti) daughterN = "anti_" + daughterN;
214 if (r > 0.) { << 222 if (r>0.) {
215 // create decay channel [parent BR 223 // create decay channel [parent BR #daughters]
216 mode = new G4PhaseSpaceDecayChannel(namePa << 224 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 225 daughterN,daughterK);
217 // add decay table 226 // add decay table
218 decayTable->Insert(mode); 227 decayTable->Insert(mode);
219 } 228 }
220 229
221 // ------------ N K0 ------------ << 230 // ------------ N K0 ------------
222 // determine daughters 231 // determine daughters
223 if (iIso3 == +2) { << 232 if (iIso3== +2) {
224 daughterN = "delta+"; << 233 daughterN = "delta+";
225 r = 0.25 * br; << 234 r=0.25*br;
226 } << 235 } else if (iIso3== 0) {
227 else if (iIso3 == 0) { << 236 daughterN = "delta0";
228 daughterN = "delta0"; << 237 r = br/2.;
229 r = br / 2.; << 238 } else if (iIso3== -2) {
230 } << 239 daughterN = "delta-";
231 else if (iIso3 == -2) { << 240 r=0.75*br;
232 daughterN = "delta-"; <<
233 r = 0.75 * br; <<
234 } 241 }
235 if (!fAnti) { 242 if (!fAnti) {
236 daughterK = "anti_kaon0"; 243 daughterK = "anti_kaon0";
237 } << 244 } else {
238 else { <<
239 daughterK = "kaon0"; 245 daughterK = "kaon0";
240 } 246 }
241 if (fAnti) daughterN = "anti_" + daughterN; 247 if (fAnti) daughterN = "anti_" + daughterN;
242 if (r > 0.) { << 248 if (r>0.) {
>> 249
>> 250
243 // create decay channel [parent BR 251 // create decay channel [parent BR #daughters]
244 mode = new G4PhaseSpaceDecayChannel(namePa << 252 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 253 daughterN,daughterK);
245 // add decay table 254 // add decay table
246 decayTable->Insert(mode); 255 decayTable->Insert(mode);
247 } 256 }
248 257
249 return decayTable; 258 return decayTable;
250 } 259 }
251 260
252 G4DecayTable* G4ExcitedSigmaConstructor::AddNK << 261
253 << 262 G4DecayTable* G4ExcitedSigmaConstructor::AddNKStarMode(
254 << 263 G4DecayTable* decayTable, const G4String& nameParent,
>> 264 G4double br, G4int iIso3, G4bool fAnti)
255 { 265 {
256 G4VDecayChannel* mode; 266 G4VDecayChannel* mode;
257 267
258 G4String daughterN; 268 G4String daughterN;
259 G4String daughterK; 269 G4String daughterK;
260 G4double r = 0.; 270 G4double r = 0.;
261 271
262 // ------------ N K- ------------ << 272 // ------------ N K- ------------
263 // determine daughters 273 // determine daughters
264 if (iIso3 == +2) { << 274 if (iIso3== +2) {
265 r = 0.; << 275
266 } << 276 r=0.;
267 else if (iIso3 == 0) { << 277 } else if (iIso3== 0) {
268 daughterN = "proton"; << 278 daughterN = "proton";
269 r = br / 2.; << 279 r = br/2.;
270 } << 280 } else if (iIso3== -2) {
271 else if (iIso3 == -2) { << 281 daughterN = "neutron";
272 daughterN = "neutron"; <<
273 r = br; 282 r = br;
274 } 283 }
275 if (!fAnti) { 284 if (!fAnti) {
276 daughterK = "k_star-"; 285 daughterK = "k_star-";
277 } << 286 } else {
278 else { <<
279 daughterK = "k_star+"; 287 daughterK = "k_star+";
280 } 288 }
281 if (fAnti) daughterN = "anti_" + daughterN; 289 if (fAnti) daughterN = "anti_" + daughterN;
282 if (r > 0.) { << 290 if (r>0.) {
283 // create decay channel [parent BR 291 // create decay channel [parent BR #daughters]
284 mode = new G4PhaseSpaceDecayChannel(namePa << 292 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 293 daughterN,daughterK);
285 // add decay table 294 // add decay table
286 decayTable->Insert(mode); 295 decayTable->Insert(mode);
287 } 296 }
288 297
289 // ------------ N K0 ------------ << 298 // ------------ N K0 ------------
290 299
291 // determine daughters 300 // determine daughters
292 if (iIso3 == +2) { << 301 if (iIso3== +2) {
293 daughterN = "proton"; << 302 daughterN = "proton";
294 r = br; << 303 r=br;
295 } << 304 } else if (iIso3== 0) {
296 else if (iIso3 == 0) { << 305 daughterN = "neutron";
297 daughterN = "neutron"; << 306 r = br/2.;
298 r = br / 2.; << 307 } else if (iIso3== -2) {
299 } <<
300 else if (iIso3 == -2) { <<
301 r = 0.; 308 r = 0.;
302 } 309 }
303 if (!fAnti) { 310 if (!fAnti) {
304 daughterK = "anti_k_star0"; 311 daughterK = "anti_k_star0";
305 } << 312 } else {
306 else { <<
307 daughterK = "k_star0"; 313 daughterK = "k_star0";
308 } 314 }
309 if (fAnti) daughterN = "anti_" + daughterN; 315 if (fAnti) daughterN = "anti_" + daughterN;
310 // create decay channel [parent BR # 316 // create decay channel [parent BR #daughters]
311 if (r > 0.) { << 317 if (r>0.) {
312 mode = new G4PhaseSpaceDecayChannel(namePa << 318 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 319 daughterN,daughterK);
313 // add decay table 320 // add decay table
314 decayTable->Insert(mode); 321 decayTable->Insert(mode);
315 } 322 }
316 323
317 return decayTable; 324 return decayTable;
318 } 325 }
319 326
320 G4DecayTable* G4ExcitedSigmaConstructor::AddSi << 327 G4DecayTable* G4ExcitedSigmaConstructor::AddSigmaPiMode(
321 << 328 G4DecayTable* decayTable, const G4String& nameParent,
322 << 329 G4double br, G4int iIso3, G4bool fAnti)
323 { 330 {
324 G4VDecayChannel* mode; 331 G4VDecayChannel* mode;
325 332
326 G4String daughterSigma; 333 G4String daughterSigma;
327 G4String daughterPi; 334 G4String daughterPi;
328 G4double r = 0.; 335 G4double r = 0.;
329 336
330 // ------------ Sigma+ pi - ------------ << 337 // ------------ Sigma+ pi - ------------
331 // determine daughters 338 // determine daughters
332 if (iIso3 == +2) { << 339 if (iIso3== +2) {
333 r = 0.; 340 r = 0.;
334 } << 341 } else if (iIso3== 0) {
335 else if (iIso3 == 0) { <<
336 daughterSigma = "sigma+"; 342 daughterSigma = "sigma+";
337 r = br / 2.; << 343 r = br/2.;
338 } << 344 } else if (iIso3== -2) {
339 else if (iIso3 == -2) { <<
340 daughterSigma = "sigma0"; 345 daughterSigma = "sigma0";
341 r = br / 2.; << 346 r = br/2.;
342 } 347 }
343 if (!fAnti) { 348 if (!fAnti) {
344 daughterPi = "pi-"; 349 daughterPi = "pi-";
345 } << 350 } else {
346 else { <<
347 daughterPi = "pi+"; 351 daughterPi = "pi+";
348 } 352 }
349 if (fAnti) daughterSigma = "anti_" + daughte 353 if (fAnti) daughterSigma = "anti_" + daughterSigma;
350 if (r > 0.) { << 354 if (r>0.) {
351 // create decay channel [parent BR 355 // create decay channel [parent BR #daughters]
352 mode = new G4PhaseSpaceDecayChannel(namePa << 356 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 357 daughterSigma,daughterPi);
353 // add decay table 358 // add decay table
354 decayTable->Insert(mode); 359 decayTable->Insert(mode);
355 } 360 }
356 // ------------ Sigma0 Pi0 ------------ << 361 // ------------ Sigma0 Pi0 ------------
357 // determine daughters 362 // determine daughters
358 if (iIso3 == +2) { << 363 if (iIso3== +2) {
359 daughterSigma = "sigma+"; 364 daughterSigma = "sigma+";
360 r = br / 2.; << 365 r = br/2.;
361 } << 366 } else if (iIso3== 0) {
362 else if (iIso3 == 0) { <<
363 r = 0.; 367 r = 0.;
364 } << 368 } else if (iIso3== -2) {
365 else if (iIso3 == -2) { <<
366 daughterSigma = "sigma-"; 369 daughterSigma = "sigma-";
367 370
368 r = br / 2.; << 371
>> 372 r = br/2.;
369 } 373 }
370 daughterPi = "pi0"; 374 daughterPi = "pi0";
371 if (fAnti) daughterSigma = "anti_" + daughte 375 if (fAnti) daughterSigma = "anti_" + daughterSigma;
372 if (r > 0.) { << 376 if (r>0.) {
373 // create decay channel [parent BR 377 // create decay channel [parent BR #daughters]
374 mode = new G4PhaseSpaceDecayChannel(namePa << 378 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 379 daughterSigma,daughterPi);
375 // add decay table 380 // add decay table
376 decayTable->Insert(mode); 381 decayTable->Insert(mode);
377 } 382 }
378 383
379 // ------------ Sigma- pi + ------------ << 384 // ------------ Sigma- pi + ------------
380 // determine daughters 385 // determine daughters
381 if (iIso3 == +2) { << 386 if (iIso3== +2) {
382 daughterSigma = "sigma0"; 387 daughterSigma = "sigma0";
383 r = br / 2.; << 388 r = br/2.;
384 } << 389 } else if (iIso3== 0) {
385 else if (iIso3 == 0) { <<
386 daughterSigma = "sigma-"; 390 daughterSigma = "sigma-";
387 r = br / 2.; << 391 r = br/2.;
388 } << 392 } else if (iIso3== -2) {
389 else if (iIso3 == -2) { <<
390 r = 0.; 393 r = 0.;
391 } 394 }
392 if (!fAnti) { 395 if (!fAnti) {
393 daughterPi = "pi+"; 396 daughterPi = "pi+";
394 } << 397 } else {
395 else { <<
396 daughterPi = "pi-"; 398 daughterPi = "pi-";
397 } 399 }
398 if (fAnti) daughterSigma = "anti_" + daughte 400 if (fAnti) daughterSigma = "anti_" + daughterSigma;
399 if (r > 0.) { << 401 if (r>0.) {
400 // create decay channel [parent BR 402 // create decay channel [parent BR #daughters]
401 mode = new G4PhaseSpaceDecayChannel(namePa << 403 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 404 daughterSigma,daughterPi);
402 // add decay table 405 // add decay table
403 decayTable->Insert(mode); 406 decayTable->Insert(mode);
404 } 407 }
405 408
406 return decayTable; 409 return decayTable;
407 } 410 }
408 411
409 G4DecayTable* G4ExcitedSigmaConstructor::AddSi << 412
410 << 413 G4DecayTable* G4ExcitedSigmaConstructor::AddSigmaStarPiMode(
411 << 414 G4DecayTable* decayTable, const G4String& nameParent,
>> 415 G4double br, G4int iIso3, G4bool fAnti)
412 { 416 {
413 G4VDecayChannel* mode; 417 G4VDecayChannel* mode;
414 418
>> 419
415 G4String daughterSigma; 420 G4String daughterSigma;
416 G4String daughterPi; 421 G4String daughterPi;
417 G4double r = 0.; 422 G4double r = 0.;
418 423
419 // ------------ Sigma+ pi - ------------ << 424 // ------------ Sigma+ pi - ------------
420 // determine daughters 425 // determine daughters
421 if (iIso3 == +2) { << 426 if (iIso3== +2) {
422 r = 0.; 427 r = 0.;
423 } << 428 } else if (iIso3== 0) {
424 else if (iIso3 == 0) { <<
425 daughterSigma = "sigma(1385)+"; 429 daughterSigma = "sigma(1385)+";
426 r = br / 2.; << 430 r = br/2.;
427 } << 431 } else if (iIso3== -2) {
428 else if (iIso3 == -2) { <<
429 daughterSigma = "sigma(1385)0"; 432 daughterSigma = "sigma(1385)0";
430 r = br / 2.; << 433 r = br/2.;
431 } 434 }
432 if (!fAnti) { 435 if (!fAnti) {
433 daughterPi = "pi-"; 436 daughterPi = "pi-";
434 } << 437 } else {
435 else { <<
436 daughterPi = "pi+"; 438 daughterPi = "pi+";
437 } 439 }
438 if (fAnti) daughterSigma = "anti_" + daughte 440 if (fAnti) daughterSigma = "anti_" + daughterSigma;
439 if (r > 0.) { << 441 if (r>0.) {
440 // create decay channel [parent BR 442 // create decay channel [parent BR #daughters]
441 mode = new G4PhaseSpaceDecayChannel(namePa << 443 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 444 daughterSigma,daughterPi);
442 // add decay table 445 // add decay table
443 decayTable->Insert(mode); 446 decayTable->Insert(mode);
444 } 447 }
445 // ------------ Sigma0 Pi0 ------------ << 448 // ------------ Sigma0 Pi0 ------------
446 // determine daughters 449 // determine daughters
447 if (iIso3 == +2) { << 450 if (iIso3== +2) {
448 daughterSigma = "sigma(1385)+"; 451 daughterSigma = "sigma(1385)+";
449 r = br / 2.; << 452 r = br/2.;
450 } << 453 } else if (iIso3== 0) {
451 else if (iIso3 == 0) { <<
452 r = 0.; 454 r = 0.;
453 } << 455 } else if (iIso3== -2) {
454 else if (iIso3 == -2) { <<
455 daughterSigma = "sigma(1385)-"; 456 daughterSigma = "sigma(1385)-";
456 r = br / 2.; << 457 r = br/2.;
457 } 458 }
458 daughterPi = "pi0"; 459 daughterPi = "pi0";
459 if (fAnti) daughterSigma = "anti_" + daughte 460 if (fAnti) daughterSigma = "anti_" + daughterSigma;
460 if (r > 0.) { << 461 if (r>0.) {
461 // create decay channel [parent BR 462 // create decay channel [parent BR #daughters]
462 mode = new G4PhaseSpaceDecayChannel(namePa << 463 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 464 daughterSigma,daughterPi);
463 465
464 // add decay table 466 // add decay table
465 decayTable->Insert(mode); 467 decayTable->Insert(mode);
466 } 468 }
467 469
468 // ------------ Sigma- pi + ------------ << 470 // ------------ Sigma- pi + ------------
469 // determine daughters 471 // determine daughters
470 if (iIso3 == +2) { << 472 if (iIso3== +2) {
471 daughterSigma = "sigma(1385)0"; 473 daughterSigma = "sigma(1385)0";
472 r = br / 2.; << 474 r = br/2.;
473 } << 475 } else if (iIso3== 0) {
474 else if (iIso3 == 0) { <<
475 daughterSigma = "sigma(1385)-"; 476 daughterSigma = "sigma(1385)-";
476 r = br / 2.; << 477 r = br/2.;
477 } << 478 } else if (iIso3== -2) {
478 else if (iIso3 == -2) { <<
479 r = 0.; 479 r = 0.;
480 } 480 }
481 if (!fAnti) { 481 if (!fAnti) {
482 daughterPi = "pi+"; 482 daughterPi = "pi+";
483 } << 483 } else {
484 else { <<
485 daughterPi = "pi-"; 484 daughterPi = "pi-";
486 } 485 }
487 if (fAnti) daughterSigma = "anti_" + daughte 486 if (fAnti) daughterSigma = "anti_" + daughterSigma;
488 if (r > 0.) { << 487 if (r>0.) {
489 // create decay channel [parent BR 488 // create decay channel [parent BR #daughters]
490 489
491 mode = new G4PhaseSpaceDecayChannel(namePa << 490 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 491 daughterSigma,daughterPi);
492 // add decay table 492 // add decay table
493 decayTable->Insert(mode); 493 decayTable->Insert(mode);
494 } 494 }
495 495
496 return decayTable; 496 return decayTable;
497 } 497 }
498 498
499 G4DecayTable* G4ExcitedSigmaConstructor::AddLa << 499 G4DecayTable* G4ExcitedSigmaConstructor::AddLambdaPiMode(
500 << 500 G4DecayTable* decayTable, const G4String& nameParent,
501 << 501 G4double br, G4int iIso3, G4bool fAnti)
502 { 502 {
503 G4VDecayChannel* mode; 503 G4VDecayChannel* mode;
504 504
505 G4String daughterLambda = "lambda"; 505 G4String daughterLambda = "lambda";
506 G4String daughterPi; 506 G4String daughterPi;
507 507
508 // determine daughters 508 // determine daughters
509 if (iIso3 == +2) { << 509 if (iIso3== +2) {
510 if (!fAnti) { 510 if (!fAnti) {
511 daughterPi = "pi+"; 511 daughterPi = "pi+";
512 } << 512 } else {
513 else { <<
514 daughterPi = "pi-"; 513 daughterPi = "pi-";
515 } 514 }
516 } << 515 } else if (iIso3== 0) {
517 else if (iIso3 == 0) { <<
518 daughterPi = "pi0"; 516 daughterPi = "pi0";
519 } << 517 } else if (iIso3== -2) {
520 else if (iIso3 == -2) { <<
521 if (!fAnti) { 518 if (!fAnti) {
522 daughterPi = "pi-"; 519 daughterPi = "pi-";
523 } << 520 } else {
524 else { <<
525 daughterPi = "pi+"; 521 daughterPi = "pi+";
526 } 522 }
527 } 523 }
528 if (fAnti) daughterLambda = "anti_" + daught 524 if (fAnti) daughterLambda = "anti_" + daughterLambda;
529 // create decay channel [parent BR # 525 // create decay channel [parent BR #daughters]
530 mode = new G4PhaseSpaceDecayChannel(namePare << 526 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
>> 527 daughterLambda, daughterPi);
531 // add decay table 528 // add decay table
532 decayTable->Insert(mode); 529 decayTable->Insert(mode);
533 530
534 return decayTable; 531 return decayTable;
535 } 532 }
536 533
537 G4DecayTable* G4ExcitedSigmaConstructor::AddLa << 534 G4DecayTable* G4ExcitedSigmaConstructor::AddLambdaStarPiMode(
538 << 535 G4DecayTable* decayTable, const G4String& nameParent,
539 << 536 G4double br, G4int iIso3, G4bool fAnti)
540 { 537 {
541 G4VDecayChannel* mode; 538 G4VDecayChannel* mode;
542 539
543 G4String daughterLambda = "lambda(1405)"; 540 G4String daughterLambda = "lambda(1405)";
544 G4String daughterPi; 541 G4String daughterPi;
545 542
546 // determine daughters 543 // determine daughters
547 if (iIso3 == +2) { << 544 if (iIso3== +2) {
548 if (!fAnti) { 545 if (!fAnti) {
549 daughterPi = "pi+"; 546 daughterPi = "pi+";
550 } << 547 } else {
551 else { <<
552 daughterPi = "pi-"; 548 daughterPi = "pi-";
553 } 549 }
554 } << 550 } else if (iIso3== 0) {
555 else if (iIso3 == 0) { <<
556 daughterPi = "pi0"; 551 daughterPi = "pi0";
557 } << 552 } else if (iIso3== -2) {
558 else if (iIso3 == -2) { <<
559 if (!fAnti) { 553 if (!fAnti) {
560 daughterPi = "pi-"; 554 daughterPi = "pi-";
561 } << 555 } else {
562 else { <<
563 daughterPi = "pi+"; 556 daughterPi = "pi+";
564 } 557 }
565 } 558 }
566 559
567 if (fAnti) daughterLambda = "anti_" + daught 560 if (fAnti) daughterLambda = "anti_" + daughterLambda;
568 // create decay channel [parent BR # 561 // create decay channel [parent BR #daughters]
569 mode = new G4PhaseSpaceDecayChannel(namePare << 562 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
>> 563 daughterLambda,daughterPi);
570 // add decay table 564 // add decay table
571 decayTable->Insert(mode); 565 decayTable->Insert(mode);
572 566
573 return decayTable; 567 return decayTable;
574 } 568 }
575 569
>> 570
576 G4double G4ExcitedSigmaConstructor::GetMass(G4 571 G4double G4ExcitedSigmaConstructor::GetMass(G4int iState, G4int iso3)
577 { << 572 {
578 G4double fmass = mass[iState]; 573 G4double fmass = mass[iState];
579 if (iState == 0) { << 574 if (iState == 0 ) {
580 if (iso3 == +2) << 575 if (iso3== +2) fmass -= 0.9*MeV; // sigma+
581 fmass -= 0.9 * MeV; // sigma+ << 576 else if (iso3== -2) fmass += 3.5*MeV; // sigma-
582 else if (iso3 == -2) <<
583 fmass += 3.5 * MeV; // sigma- <<
584 } 577 }
585 return fmass; 578 return fmass;
586 } 579 }
587 580
588 G4double G4ExcitedSigmaConstructor::GetWidth(G 581 G4double G4ExcitedSigmaConstructor::GetWidth(G4int iState, G4int iso3)
589 { 582 {
590 G4double fw = width[iState]; << 583 G4double fw=width[iState];
591 if (iState == 0) { << 584 if (iState == 0 ) {
592 if (iso3 == +2) << 585 if (iso3== +2) fw = 36.0*MeV; // sigma+
593 fw = 36.0 * MeV; // sigma+ << 586 else if (iso3== -2) fw = 39.4*MeV; // sigma-
594 else if (iso3 == -2) <<
595 fw = 39.4 * MeV; // sigma- <<
596 } 587 }
597 return fw; 588 return fw;
598 } 589 }
599 590
600 // clang-format off <<
601 <<
602 const char* G4ExcitedSigmaConstructor::name[] 591 const char* G4ExcitedSigmaConstructor::name[] = {
603 "sigma(1385)","sigma(1660)","sigma(1670)","s 592 "sigma(1385)","sigma(1660)","sigma(1670)","sigma(1750)","sigma(1775)",
604 "sigma(1915)","sigma(1940)","sigma(2030)" 593 "sigma(1915)","sigma(1940)","sigma(2030)"
605 }; 594 };
606 595
607 const G4double G4ExcitedSigmaConstructor::mass 596 const G4double G4ExcitedSigmaConstructor::mass[] = {
608 1.3837*GeV, 1.660*GeV, 1.675*GeV, 1.750*GeV, << 597 1.3837*GeV, 1.660*GeV, 1.670*GeV, 1.750*GeV, 1.775*GeV,
609 1.915*GeV, 1.940*GeV, 2.030*GeV 598 1.915*GeV, 1.940*GeV, 2.030*GeV
610 }; 599 };
611 600
612 const G4double G4ExcitedSigmaConstructor::widt 601 const G4double G4ExcitedSigmaConstructor::width[] = {
613 36.0*MeV, 200.0*MeV, 70.0*MeV, 150.0*MeV, << 602 36.0*MeV, 100.0*MeV, 60.0*MeV, 90.0*MeV, 120.0*MeV,
614 120.0*MeV, 250.0*MeV, 180.0*MeV << 603 120.0*MeV, 220.0*MeV, 180.0*MeV
615 }; 604 };
616 605
617 const G4int G4ExcitedSigmaConstructor::iSpin[] 606 const G4int G4ExcitedSigmaConstructor::iSpin[] = {
618 3, 1, 3, 1, 5, 607 3, 1, 3, 1, 5,
619 5, 3, 7 608 5, 3, 7
620 }; 609 };
621 610
622 const G4int G4ExcitedSigmaConstructor::iParity 611 const G4int G4ExcitedSigmaConstructor::iParity[] = {
623 +1, +1, -1, -1, -1, 612 +1, +1, -1, -1, -1,
624 +1, -1, +1 613 +1, -1, +1
625 }; 614 };
626 615
627 616
628 const G4int G4ExcitedSigmaConstructor::encodin 617 const G4int G4ExcitedSigmaConstructor::encodingOffset[] = {
629 0, 10000, 10000, 20000, 0, 618 0, 10000, 10000, 20000, 0,
630 10000, 20000, 0 619 10000, 20000, 0
631 }; 620 };
632 621
633 const G4double G4ExcitedSigmaConstructor::bRat << 622 const G4double G4ExcitedSigmaConstructor::bRatio[ G4ExcitedSigmaConstructor::NStates ][ G4ExcitedSigmaConstructor::NumberOfDecayModes] =
634 { 623 {
635 { 0.0, 0.0, 0.12, 0.0, 0.88, 0.0, 0 << 624 { 0.0, 0.0, 0.12, 0.0, 0.88, 0.0, 0.0, 0.0},
636 { 0.30, 0.0, 0.35, 0.0, 0.35, 0.0, 0 << 625 { 0.30, 0.0, 0.35, 0.0, 0.35, 0.0, 0.0, 0.0},
637 { 0.15, 0.0, 0.70, 0.0, 0.15, 0.0, 0 << 626 { 0.15, 0.0, 0.70, 0.0, 0.15, 0.0, 0.0, 0.0},
638 { 0.40, 0.0, 0.05, 0.0, 0.0, 0.55, 0 << 627 { 0.40, 0.0, 0.05, 0.0, 0.0, 0.55, 0.0, 0.0},
639 { 0.40, 0.0, 0.04, 0.10, 0.23, 0.0, 0. << 628 { 0.40, 0.0, 0.04, 0.10, 0.23, 0.0, 0.23, 0.0},
640 { 0.15, 0.0, 0.40, 0.05, 0.40, 0.0, 0 << 629 { 0.15, 0.0, 0.40, 0.05, 0.40, 0.0, 0.0, 0.0},
641 { 0.10, 0.15, 0.15, 0.15, 0.15, 0.0, 0. << 630 { 0.10, 0.15, 0.15, 0.15, 0.15, 0.0, 0.15, 0.15},
642 { 0.20, 0.04, 0.10, 0.10, 0.20, 0.0, 0. << 631 { 0.20, 0.04, 0.10, 0.10, 0.20, 0.0, 0.18, 0.18}
643 632
644 }; 633 };
>> 634
>> 635
>> 636
>> 637
>> 638
>> 639
>> 640
>> 641
>> 642
>> 643
>> 644
645 645