| 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: G4ExcitedLambdaConstructor.cc,v 1.12 2008/09/18 08:37:27 kurasige Exp $
>> 28 // GEANT4 tag $Name: geant4-09-02-patch-04 $
>> 29 //
>> 30 //
26 // ------------------------------------------- 31 // --------------------------------------------------------------
27 // GEANT 4 class implementation file << 32 // GEANT 4 class implementation file
28 // History: first implementation, based o 33 // History: first implementation, based on object model of
29 // 10 oct 1998 H.Kurashige 34 // 10 oct 1998 H.Kurashige
30 // <<
31 // Update mass and width following PDG 20 <<
32 // 4 nov 2023 S.Okada <<
33 // ------------------------------------------- 35 // ---------------------------------------------------------------
34 36
>> 37
35 #include "G4ExcitedLambdaConstructor.hh" 38 #include "G4ExcitedLambdaConstructor.hh"
36 39
37 #include "G4DecayTable.hh" << 40 #include "G4ParticleDefinition.hh"
>> 41 #include "G4ParticleTable.hh"
>> 42 #include "G4ShortLivedTable.hh"
38 #include "G4PhaseSpaceDecayChannel.hh" 43 #include "G4PhaseSpaceDecayChannel.hh"
39 #include "G4SystemOfUnits.hh" <<
40 #include "G4VDecayChannel.hh" 44 #include "G4VDecayChannel.hh"
>> 45 #include "G4DecayTable.hh"
41 46
42 G4ExcitedLambdaConstructor::G4ExcitedLambdaCon <<
43 : G4ExcitedBaryonConstructor(NStates, Lambda <<
44 {} <<
45 47
46 G4DecayTable* G4ExcitedLambdaConstructor::Crea << 48 G4ExcitedLambdaConstructor::G4ExcitedLambdaConstructor():
47 << 49 G4ExcitedBaryonConstructor(NStates, LambdaIsoSpin)
>> 50 {
>> 51
>> 52 }
>> 53
>> 54 G4ExcitedLambdaConstructor::~G4ExcitedLambdaConstructor()
>> 55 {
>> 56 }
>> 57
>> 58 G4DecayTable* G4ExcitedLambdaConstructor::CreateDecayTable(
>> 59 const G4String& parentName,
>> 60 G4int iIso3,
>> 61 G4int iState,
>> 62 G4bool fAnti)
48 { 63 {
49 // create decay table 64 // create decay table
50 auto decayTable = new G4DecayTable(); << 65 G4DecayTable* decayTable = new G4DecayTable();
51 66
52 G4double br; 67 G4double br;
53 if ((br = bRatio[iState][NK]) > 0.0) { << 68 if ( (br=bRatio[iState][NK]) >0.0) {
54 AddNKMode(decayTable, parentName, br, iIso << 69 AddNKMode( decayTable, parentName, br, iIso3, fAnti);
55 } 70 }
56 71
57 if ((br = bRatio[iState][NKStar]) > 0.0) { << 72 if ( (br=bRatio[iState][NKStar]) >0.0) {
58 AddNKStarMode(decayTable, parentName, br, << 73 AddNKStarMode( decayTable, parentName, br, iIso3, fAnti);
59 } 74 }
60 75
61 if ((br = bRatio[iState][SigmaPi]) > 0.0) { << 76 if ( (br=bRatio[iState][SigmaPi]) >0.0) {
62 AddSigmaPiMode(decayTable, parentName, br, << 77 AddSigmaPiMode( decayTable, parentName, br, iIso3, fAnti);
63 } 78 }
64 79
65 if ((br = bRatio[iState][SigmaStarPi]) > 0.0 << 80 if ( (br=bRatio[iState][SigmaStarPi]) >0.0) {
66 AddSigmaStarPiMode(decayTable, parentName, << 81 AddSigmaStarPiMode( decayTable, parentName, br, iIso3, fAnti);
67 } 82 }
68 83
69 if ((br = bRatio[iState][LambdaGamma]) > 0.0 << 84 if ( (br=bRatio[iState][LambdaGamma]) >0.0) {
70 AddLambdaGammaMode(decayTable, parentName, << 85 AddLambdaGammaMode( decayTable, parentName, br, iIso3, fAnti);
71 } 86 }
72 87
73 if ((br = bRatio[iState][LambdaEta]) > 0.0) << 88 if ( (br=bRatio[iState][LambdaEta]) >0.0) {
74 AddLambdaEtaMode(decayTable, parentName, b << 89 AddLambdaEtaMode( decayTable, parentName, br, iIso3, fAnti);
75 } 90 }
76 91
77 if ((br = bRatio[iState][LambdaOmega]) > 0.0 << 92 if ( (br=bRatio[iState][LambdaOmega]) >0.0) {
78 AddLambdaOmegaMode(decayTable, parentName, << 93 AddLambdaOmegaMode( decayTable, parentName, br, iIso3, fAnti);
79 } 94 }
80 95
81 return decayTable; << 96 return decayTable;
82 } 97 }
83 98
84 G4DecayTable* G4ExcitedLambdaConstructor::AddL << 99 G4DecayTable* G4ExcitedLambdaConstructor::AddLambdaGammaMode(
85 << 100 G4DecayTable* decayTable, const G4String& nameParent,
86 << 101 G4double br, G4int , G4bool fAnti)
87 { 102 {
88 G4VDecayChannel* mode; 103 G4VDecayChannel* mode;
89 104
90 // << 105 //
91 G4String lambda = "lambda"; << 106 G4String lambda = "lambda";
92 if (fAnti) lambda = "anti_" + lambda; 107 if (fAnti) lambda = "anti_" + lambda;
93 108
94 // create decay channel [parent BR # 109 // create decay channel [parent BR #daughters]
95 mode = new G4PhaseSpaceDecayChannel(namePare << 110 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
>> 111 lambda,"gamma");
96 // add decay table 112 // add decay table
97 decayTable->Insert(mode); 113 decayTable->Insert(mode);
98 114
99 return decayTable; 115 return decayTable;
100 } 116 }
101 G4DecayTable* G4ExcitedLambdaConstructor::AddL << 117 G4DecayTable* G4ExcitedLambdaConstructor::AddLambdaEtaMode(
102 << 118 G4DecayTable* decayTable, const G4String& nameParent,
103 << 119 G4double br, G4int , G4bool fAnti)
104 { 120 {
105 G4VDecayChannel* mode; 121 G4VDecayChannel* mode;
106 122
107 // << 123 //
108 G4String lambda = "lambda"; << 124 G4String lambda = "lambda";
109 if (fAnti) lambda = "anti_" + lambda; 125 if (fAnti) lambda = "anti_" + lambda;
110 126
111 // create decay channel [parent BR # 127 // create decay channel [parent BR #daughters]
112 mode = new G4PhaseSpaceDecayChannel(namePare << 128 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
>> 129 lambda,"eta");
113 // add decay table 130 // add decay table
114 decayTable->Insert(mode); 131 decayTable->Insert(mode);
115 132
116 return decayTable; 133 return decayTable;
117 } 134 }
118 135
119 G4DecayTable* G4ExcitedLambdaConstructor::AddL << 136 G4DecayTable* G4ExcitedLambdaConstructor::AddLambdaOmegaMode(
120 << 137 G4DecayTable* decayTable, const G4String& nameParent,
121 << 138 G4double br, G4int , G4bool fAnti)
122 { 139 {
123 G4VDecayChannel* mode; 140 G4VDecayChannel* mode;
124 141
125 // << 142 //
126 G4String lambda = "lambda"; << 143 G4String lambda = "lambda";
127 if (fAnti) lambda = "anti_" + lambda; 144 if (fAnti) lambda = "anti_" + lambda;
128 145
129 // create decay channel [parent BR # 146 // create decay channel [parent BR #daughters]
130 mode = new G4PhaseSpaceDecayChannel(namePare << 147 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
>> 148 lambda,"omega");
131 // add decay table 149 // add decay table
132 decayTable->Insert(mode); 150 decayTable->Insert(mode);
133 151
134 return decayTable; 152 return decayTable;
135 } 153 }
136 154
137 G4DecayTable* G4ExcitedLambdaConstructor::AddN << 155 G4DecayTable* G4ExcitedLambdaConstructor::AddNKMode(
138 << 156 G4DecayTable* decayTable, const G4String& nameParent,
139 << 157 G4double br, G4int , G4bool fAnti)
140 { 158 {
141 G4VDecayChannel* mode; 159 G4VDecayChannel* mode;
142 160
143 G4String daughterN; 161 G4String daughterN;
144 G4String daughterK; 162 G4String daughterK;
145 163
146 // ------------ N K- ------------ << 164 // ------------ N K- ------------
147 // determine daughters 165 // determine daughters
148 daughterN = "proton"; << 166 daughterN = "proton";
149 if (!fAnti) { 167 if (!fAnti) {
150 daughterK = "kaon-"; 168 daughterK = "kaon-";
151 } << 169 } else {
152 else { <<
153 daughterK = "kaon+"; 170 daughterK = "kaon+";
154 } 171 }
155 if (fAnti) daughterN = "anti_" + daughterN; 172 if (fAnti) daughterN = "anti_" + daughterN;
156 // create decay channel [parent BR # 173 // create decay channel [parent BR #daughters]
157 mode = new G4PhaseSpaceDecayChannel(namePare << 174 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
>> 175 daughterN,daughterK);
158 // add decay table 176 // add decay table
159 decayTable->Insert(mode); 177 decayTable->Insert(mode);
160 178
161 // ------------ N K0 ------------ << 179 // ------------ N K0 ------------
162 // determine daughters 180 // determine daughters
163 daughterN = "neutron"; << 181 daughterN = "neutron";
164 if (!fAnti) { 182 if (!fAnti) {
165 daughterK = "anti_kaon0"; 183 daughterK = "anti_kaon0";
166 } << 184 } else {
167 else { <<
168 daughterK = "kaon0"; 185 daughterK = "kaon0";
169 } 186 }
170 if (fAnti) daughterN = "anti_" + daughterN; 187 if (fAnti) daughterN = "anti_" + daughterN;
171 // create decay channel [parent BR # 188 // create decay channel [parent BR #daughters]
172 mode = new G4PhaseSpaceDecayChannel(namePare << 189 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
>> 190 daughterN,daughterK);
173 // add decay table 191 // add decay table
174 decayTable->Insert(mode); 192 decayTable->Insert(mode);
175 193
>> 194
176 return decayTable; 195 return decayTable;
177 } 196 }
178 197
179 G4DecayTable* G4ExcitedLambdaConstructor::AddN << 198 G4DecayTable* G4ExcitedLambdaConstructor::AddNKStarMode(
180 << 199 G4DecayTable* decayTable, const G4String& nameParent,
181 << 200 G4double br, G4int , G4bool fAnti)
182 { 201 {
183 G4VDecayChannel* mode; 202 G4VDecayChannel* mode;
184 203
185 G4String daughterN; 204 G4String daughterN;
186 G4String daughterK; 205 G4String daughterK;
187 206
188 // ------------ N K- ------------ << 207 // ------------ N K- ------------
189 // determine daughters 208 // determine daughters
190 daughterN = "proton"; << 209 daughterN = "proton";
191 if (!fAnti) { 210 if (!fAnti) {
192 daughterK = "k_star-"; 211 daughterK = "k_star-";
193 } << 212 } else {
194 else { <<
195 daughterK = "k_star+"; 213 daughterK = "k_star+";
196 } 214 }
197 if (fAnti) daughterN = "anti_" + daughterN; 215 if (fAnti) daughterN = "anti_" + daughterN;
198 // create decay channel [parent BR # 216 // create decay channel [parent BR #daughters]
199 mode = new G4PhaseSpaceDecayChannel(namePare << 217 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
>> 218 daughterN,daughterK);
200 // add decay table 219 // add decay table
201 decayTable->Insert(mode); 220 decayTable->Insert(mode);
202 221
203 // ------------ N K0 ------------ << 222 // ------------ N K0 ------------
204 // determine daughters 223 // determine daughters
205 daughterN = "neutron"; << 224 daughterN = "neutron";
206 if (!fAnti) { 225 if (!fAnti) {
207 daughterK = "anti_k_star0"; 226 daughterK = "anti_k_star0";
208 } << 227 } else {
209 else { <<
210 daughterK = "k_star0"; 228 daughterK = "k_star0";
211 } 229 }
212 if (fAnti) daughterN = "anti_" + daughterN; 230 if (fAnti) daughterN = "anti_" + daughterN;
213 // create decay channel [parent BR # 231 // create decay channel [parent BR #daughters]
214 mode = new G4PhaseSpaceDecayChannel(namePare << 232 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
>> 233 daughterN,daughterK);
215 // add decay table 234 // add decay table
216 decayTable->Insert(mode); 235 decayTable->Insert(mode);
217 236
>> 237
218 return decayTable; 238 return decayTable;
219 } 239 }
220 240
221 G4DecayTable* G4ExcitedLambdaConstructor::AddS << 241 G4DecayTable* G4ExcitedLambdaConstructor::AddSigmaPiMode(
222 << 242 G4DecayTable* decayTable, const G4String& nameParent,
223 << 243 G4double br, G4int , G4bool fAnti)
224 { 244 {
225 G4VDecayChannel* mode; 245 G4VDecayChannel* mode;
226 246
227 G4String daughterSigma; 247 G4String daughterSigma;
228 G4String daughterPi; 248 G4String daughterPi;
229 249
230 // ------------ Sigma+ pi - ------------ << 250 // ------------ Sigma+ pi - ------------
231 // determine daughters 251 // determine daughters
232 daughterSigma = "sigma+"; 252 daughterSigma = "sigma+";
233 if (!fAnti) { 253 if (!fAnti) {
234 daughterPi = "pi-"; 254 daughterPi = "pi-";
235 } << 255 } else {
236 else { <<
237 daughterPi = "pi+"; 256 daughterPi = "pi+";
238 } 257 }
239 if (fAnti) daughterSigma = "anti_" + daughte 258 if (fAnti) daughterSigma = "anti_" + daughterSigma;
240 // create decay channel [parent BR # 259 // create decay channel [parent BR #daughters]
241 mode = new G4PhaseSpaceDecayChannel(namePare << 260 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
>> 261 daughterSigma,daughterPi);
242 // add decay table 262 // add decay table
243 decayTable->Insert(mode); 263 decayTable->Insert(mode);
244 264
245 // ------------ Sigma0 Pi0 ------------ << 265 // ------------ Sigma0 Pi0 ------------
246 // determine daughters 266 // determine daughters
247 daughterSigma = "sigma0"; << 267 daughterSigma = "sigma0";
248 daughterPi = "pi0"; 268 daughterPi = "pi0";
249 269
250 if (fAnti) daughterSigma = "anti_" + daughte 270 if (fAnti) daughterSigma = "anti_" + daughterSigma;
251 // create decay channel [parent BR # 271 // create decay channel [parent BR #daughters]
252 mode = new G4PhaseSpaceDecayChannel(namePare << 272 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
>> 273 daughterSigma,daughterPi);
253 274
254 // add decay table 275 // add decay table
255 decayTable->Insert(mode); 276 decayTable->Insert(mode);
256 277
257 // ------------ Sigma- pi + ------------ << 278 // ------------ Sigma- pi + ------------
258 // determine daughters 279 // determine daughters
259 daughterSigma = "sigma-"; 280 daughterSigma = "sigma-";
260 if (!fAnti) { 281 if (!fAnti) {
261 daughterPi = "pi+"; 282 daughterPi = "pi+";
262 } << 283 } else {
263 else { <<
264 daughterPi = "pi-"; 284 daughterPi = "pi-";
265 } 285 }
266 if (fAnti) daughterSigma = "anti_" + daughte 286 if (fAnti) daughterSigma = "anti_" + daughterSigma;
267 // create decay channel [parent BR # 287 // create decay channel [parent BR #daughters]
268 mode = new G4PhaseSpaceDecayChannel(namePare << 288 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
>> 289 daughterSigma,daughterPi);
269 // add decay table 290 // add decay table
270 decayTable->Insert(mode); 291 decayTable->Insert(mode);
271 292
272 return decayTable; 293 return decayTable;
273 } 294 }
274 295
275 G4DecayTable* G4ExcitedLambdaConstructor::AddS << 296
276 << 297 G4DecayTable* G4ExcitedLambdaConstructor::AddSigmaStarPiMode(
277 << 298 G4DecayTable* decayTable, const G4String& nameParent,
>> 299 G4double br, G4int , G4bool fAnti)
278 { 300 {
279 G4VDecayChannel* mode; 301 G4VDecayChannel* mode;
280 302
281 G4String daughterSigma; 303 G4String daughterSigma;
282 G4String daughterPi; 304 G4String daughterPi;
283 305
284 // ------------ Sigma+ pi - ------------ << 306 // ------------ Sigma+ pi - ------------
285 // determine daughters 307 // determine daughters
286 daughterSigma = "sigma(1385)+"; 308 daughterSigma = "sigma(1385)+";
287 if (!fAnti) { 309 if (!fAnti) {
288 daughterPi = "pi-"; 310 daughterPi = "pi-";
289 } << 311 } else {
290 else { <<
291 daughterPi = "pi+"; 312 daughterPi = "pi+";
292 } 313 }
293 if (fAnti) daughterSigma = "anti_" + daughte 314 if (fAnti) daughterSigma = "anti_" + daughterSigma;
294 // create decay channel [parent BR # 315 // create decay channel [parent BR #daughters]
295 mode = new G4PhaseSpaceDecayChannel(namePare << 316 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
>> 317 daughterSigma,daughterPi);
296 // add decay table 318 // add decay table
297 decayTable->Insert(mode); 319 decayTable->Insert(mode);
298 320
299 // ------------ Sigma0 Pi0 ------------ << 321 // ------------ Sigma0 Pi0 ------------
300 // determine daughters 322 // determine daughters
301 daughterSigma = "sigma(1385)0"; << 323 daughterSigma = "sigma(1385)0";
302 daughterPi = "pi0"; 324 daughterPi = "pi0";
303 325
304 if (fAnti) daughterSigma = "anti_" + daughte 326 if (fAnti) daughterSigma = "anti_" + daughterSigma;
305 // create decay channel [parent BR # 327 // create decay channel [parent BR #daughters]
306 mode = new G4PhaseSpaceDecayChannel(namePare << 328 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
>> 329 daughterSigma,daughterPi);
307 330
308 // add decay table 331 // add decay table
309 decayTable->Insert(mode); 332 decayTable->Insert(mode);
310 333
311 // ------------ Sigma- pi + ------------ << 334 // ------------ Sigma- pi + ------------
312 // determine daughters 335 // determine daughters
313 daughterSigma = "sigma(1385)-"; 336 daughterSigma = "sigma(1385)-";
314 if (!fAnti) { 337 if (!fAnti) {
315 daughterPi = "pi+"; 338 daughterPi = "pi+";
316 } << 339 } else {
317 else { <<
318 daughterPi = "pi-"; 340 daughterPi = "pi-";
319 } 341 }
320 if (fAnti) daughterSigma = "anti_" + daughte 342 if (fAnti) daughterSigma = "anti_" + daughterSigma;
321 // create decay channel [parent BR # 343 // create decay channel [parent BR #daughters]
322 mode = new G4PhaseSpaceDecayChannel(namePare << 344 mode = new G4PhaseSpaceDecayChannel(nameParent, br/3.0, 2,
>> 345 daughterSigma,daughterPi);
323 // add decay table 346 // add decay table
324 decayTable->Insert(mode); 347 decayTable->Insert(mode);
325 348
326 return decayTable; 349 return decayTable;
327 } 350 }
328 351
329 // clang-format off <<
330 <<
331 const char* G4ExcitedLambdaConstructor::name[] 352 const char* G4ExcitedLambdaConstructor::name[] = {
332 "lambda(1405)","lambda(1520)","lambda(1600)" << 353 "lambda(1405)","lambda(1520)","lambda(1600)","lambda(1670)","lambda(1690)",
333 "lambda(1800)","lambda(1810)","lambda(1820)" 354 "lambda(1800)","lambda(1810)","lambda(1820)","lambda(1830)","lambda(1890)",
334 "lambda(2100)","lambda(2110)" 355 "lambda(2100)","lambda(2110)"
335 }; 356 };
336 357
337 const G4double G4ExcitedLambdaConstructor::mas 358 const G4double G4ExcitedLambdaConstructor::mass[] = {
338 1.4051*GeV,1.5194*GeV, 1.600*GeV, 1.674*GeV, << 359 1.406*GeV,1.5195*GeV, 1.600*GeV, 1.670*GeV, 1.690*GeV,
339 1.800*GeV, 1.790*GeV, 1.820*GeV, 1.825*GeV, << 360 1.800*GeV, 1.810*GeV, 1.820*GeV, 1.830*GeV, 1.890*GeV,
340 2.100*GeV, 2.090*GeV << 361 2.100*GeV, 2.110*GeV
341 }; 362 };
342 363
343 const G4double G4ExcitedLambdaConstructor::wid 364 const G4double G4ExcitedLambdaConstructor::width[] = {
344 50.5*MeV, 15.7*MeV, 2000.0*MeV, 30.0*MeV, << 365 50.0*MeV, 15.6*MeV, 150.0*MeV, 35.0*MeV, 60.0*MeV,
345 200.0*MeV, 110.0*MeV, 80.0*MeV, 90.0*MeV, << 366 300.0*MeV, 150.0*MeV, 80.0*MeV, 95.0*MeV, 100.0*MeV,
346 200.0*MeV, 250.0*MeV << 367 200.0*MeV, 200.0*MeV
347 }; 368 };
348 369
349 const G4int G4ExcitedLambdaConstructor::iSpin[ 370 const G4int G4ExcitedLambdaConstructor::iSpin[] = {
350 1, 3, 1, 1, 3, 371 1, 3, 1, 1, 3,
351 1, 1, 5, 5, 3, 372 1, 1, 5, 5, 3,
352 7, 5 373 7, 5
353 }; 374 };
354 375
355 const G4int G4ExcitedLambdaConstructor::iParit 376 const G4int G4ExcitedLambdaConstructor::iParity[] = {
356 -1, -1, +1, -1, -1, 377 -1, -1, +1, -1, -1,
357 -1, +1, +1, -1, +1, 378 -1, +1, +1, -1, +1,
358 -1, +1 << 379 -1, +1
359 }; 380 };
360 381
361 const G4int G4ExcitedLambdaConstructor::encodi 382 const G4int G4ExcitedLambdaConstructor::encodingOffset[] = {
362 10000, 0, 20000, 30000, 10000, 383 10000, 0, 20000, 30000, 10000,
363 40000, 50000, 0, 10000, 20000, << 384 40000, 50000, 0, 10000, 20000,
364 0, 20000 385 0, 20000
365 }; 386 };
366 387
367 const G4double G4ExcitedLambdaConstructor::bRa << 388 const G4double G4ExcitedLambdaConstructor::bRatio[ G4ExcitedLambdaConstructor::NStates ][ G4ExcitedLambdaConstructor::NumberOfDecayModes] =
368 { 389 {
369 { 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0 << 390 { 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0},
370 { 0.45, 0.0, 0.43, 0.11, 0.01, 0.0, 0 << 391 { 0.45, 0.0, 0.43, 0.11, 0.01, 0.0, 0.0},
371 { 0.35, 0.0, 0.65, 0.0, 0.0, 0.0, 0 << 392 { 0.35, 0.0, 0.65, 0.0, 0.0, 0.0, 0.0},
372 { 0.20, 0.0, 0.50, 0.0, 0.0, 0.30, 0 << 393 { 0.20, 0.0, 0.50, 0.0, 0.0, 0.30, 0.0},
373 { 0.25, 0.0, 0.45, 0.30, 0.0, 0.0, 0 << 394 { 0.25, 0.0, 0.45, 0.30, 0.0, 0.0, 0.0},
374 { 0.40, 0.20, 0.20, 0.20, 0.0, 0.0, 0 << 395 { 0.40, 0.20, 0.20, 0.20, 0.0, 0.0, 0.0},
375 { 0.35, 0.45, 0.15, 0.05, 0.0, 0.0, 0 << 396 { 0.35, 0.45, 0.15, 0.05, 0.0, 0.0, 0.0},
376 { 0.73, 0.0, 0.16, 0.11, 0.0, 0.0, 0 << 397 { 0.73, 0.0, 0.16, 0.11, 0.0, 0.0, 0.0},
377 { 0.10, 0.0, 0.70, 0.20, 0.0, 0.0, 0 << 398 { 0.10, 0.0, 0.70, 0.20, 0.0, 0.0, 0.0},
378 { 0.37, 0.21, 0.11, 0.31, 0.0, 0.0, 0 << 399 { 0.37, 0.21, 0.11, 0.31, 0.0, 0.0, 0.0},
379 { 0.35, 0.20, 0.05, 0.30, 0.0, 0.02, 0. << 400 { 0.35, 0.20, 0.05, 0.30, 0.0, 0.02, 0.08},
380 { 0.25, 0.45, 0.30, 0.0, 0.0, 0.0, 0 401 { 0.25, 0.45, 0.30, 0.0, 0.0, 0.0, 0.0}
381 }; 402 };
>> 403
>> 404
>> 405
>> 406
>> 407
>> 408
>> 409
>> 410
>> 411
>> 412
>> 413
>> 414
>> 415
>> 416
>> 417
>> 418
382 419