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