| 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: G4ExcitedDeltaConstructor.cc,v 1.8 2004/02/13 05:54:07 kurasige Exp $
>> 25 // GEANT4 tag $Name: geant4-07-01 $
>> 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 "G4ExcitedDeltaConstructor.hh" 36 #include "G4ExcitedDeltaConstructor.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"
>> 44
>> 45
>> 46 G4ExcitedDeltaConstructor::G4ExcitedDeltaConstructor():
>> 47 G4ExcitedBaryonConstructor(NStates, DeltaIsoSpin)
>> 48 {
42 49
43 G4ExcitedDeltaConstructor::G4ExcitedDeltaConst << 50 }
44 : G4ExcitedBaryonConstructor(NStates, DeltaI << 51
45 {} << 52 G4ExcitedDeltaConstructor::~G4ExcitedDeltaConstructor()
>> 53 {
>> 54 }
46 55
47 G4int G4ExcitedDeltaConstructor::GetEncoding(G 56 G4int G4ExcitedDeltaConstructor::GetEncoding(G4int iIsoSpin3, G4int idxState)
48 { 57 {
49 G4int encoding; 58 G4int encoding;
50 // Delta has exceptinal encoding 59 // Delta has exceptinal encoding
51 if ((idxState == 1) || (idxState == 3) || (i << 60 if ((idxState==1)||(idxState==3)||(idxState==4)||(idxState==5)||(idxState==7)) {
52 encoding = GetEncodingOffset(idxState); 61 encoding = GetEncodingOffset(idxState);
53 if ((iIsoSpin3 == 3) || (iIsoSpin3 == -3)) << 62 if ((iIsoSpin3==3)||(iIsoSpin3==-3)) {
54 // normal encoding << 63 // normal encoding
55 encoding += 1000 * GetQuarkContents(0, i << 64 encoding += 1000*GetQuarkContents(0, iIsoSpin3);
56 encoding += 100 * GetQuarkContents(1, iI << 65 encoding += 100*GetQuarkContents(1, iIsoSpin3);
57 encoding += 10 * GetQuarkContents(2, iIs << 66 encoding += 10*GetQuarkContents(2, iIsoSpin3);
58 } << 67 } else if (iIsoSpin3== +1){
59 else if (iIsoSpin3 == +1) { << 68 // 1st <--> 2nd quark
60 // 1st <--> 2nd quark << 69 encoding += 1000*GetQuarkContents(0, iIsoSpin3);
61 encoding += 1000 * GetQuarkContents(0, i << 70 encoding += 10*GetQuarkContents(1, iIsoSpin3);
62 encoding += 10 * GetQuarkContents(1, iIs << 71 encoding += 100*GetQuarkContents(2, iIsoSpin3);
63 encoding += 100 * GetQuarkContents(2, iI << 72 } else if (iIsoSpin3== -1){
64 } << 73 // 1st <--> 0th quark
65 else if (iIsoSpin3 == -1) { << 74 encoding += 100*GetQuarkContents(0, iIsoSpin3);
66 // 1st <--> 0th quark << 75 encoding += 1000*GetQuarkContents(1, iIsoSpin3);
67 encoding += 100 * GetQuarkContents(0, iI << 76 encoding += 10*GetQuarkContents(2, iIsoSpin3);
68 encoding += 1000 * GetQuarkContents(1, i <<
69 encoding += 10 * GetQuarkContents(2, iIs <<
70 } 77 }
71 encoding += GetiSpin(idxState) + 1; << 78 encoding += GetiSpin(idxState) +1;
72 } << 79 } else {
73 else { <<
74 encoding = G4ExcitedBaryonConstructor::Get 80 encoding = G4ExcitedBaryonConstructor::GetEncoding(iIsoSpin3, idxState);
75 } 81 }
76 return encoding; 82 return encoding;
77 } 83 }
78 << 84 G4DecayTable* G4ExcitedDeltaConstructor::CreateDecayTable(
79 G4DecayTable* G4ExcitedDeltaConstructor::Creat << 85 const G4String& parentName,
80 << 86 G4int iIso3,
>> 87 G4int iState,
>> 88 G4bool fAnti)
81 { 89 {
82 // create decay table 90 // create decay table
83 auto decayTable = new G4DecayTable(); << 91 G4DecayTable* decayTable = new G4DecayTable();
84 92
85 G4double br; 93 G4double br;
86 if ((br = bRatio[iState][NGamma]) > 0.0) { << 94 if ( (br=bRatio[iState][NGamma]) >0.0) {
87 AddNGammaMode(decayTable, parentName, br, << 95 AddNGammaMode( decayTable, parentName, br, iIso3, fAnti);
88 } 96 }
89 97
90 if ((br = bRatio[iState][NPi]) > 0.0) { << 98 if ( (br=bRatio[iState][NPi]) >0.0) {
91 AddNPiMode(decayTable, parentName, br, iIs << 99 AddNPiMode( decayTable, parentName, br, iIso3, fAnti);
92 } 100 }
93 101
94 if ((br = bRatio[iState][NRho]) > 0.0) { << 102 if ( (br=bRatio[iState][NRho]) >0.0) {
95 AddNRhoMode(decayTable, parentName, br, iI << 103 AddNRhoMode( decayTable, parentName, br, iIso3, fAnti);
96 } 104 }
97 105
98 if ((br = bRatio[iState][DeltaPi]) > 0.0) { << 106 if ( (br=bRatio[iState][DeltaPi]) >0.0) {
99 AddDeltaPiMode(decayTable, parentName, br, << 107 AddDeltaPiMode( decayTable, parentName, br, iIso3, fAnti);
100 } 108 }
101 109
102 if ((br = bRatio[iState][NStarPi]) > 0.0) { << 110 if ( (br=bRatio[iState][NStarPi]) >0.0) {
103 AddNStarPiMode(decayTable, parentName, br, << 111 AddNStarPiMode( decayTable, parentName, br, iIso3, fAnti);
104 } 112 }
105 113
106 return decayTable; << 114 return decayTable;
107 } 115 }
108 116
109 G4DecayTable* G4ExcitedDeltaConstructor::AddNG << 117 G4DecayTable* G4ExcitedDeltaConstructor::AddNGammaMode(
110 << 118 G4DecayTable* decayTable, const G4String& nameParent,
111 << 119 G4double br, G4int iIso3, G4bool fAnti)
112 { 120 {
113 G4VDecayChannel* mode; 121 G4VDecayChannel* mode;
114 122
115 // << 123 //
116 G4String daughterN; 124 G4String daughterN;
117 if (iIso3 == +1) { << 125 if (iIso3 == +1) {
118 daughterN = "proton"; << 126 daughterN = "proton";
119 } << 127 } else if (iIso3 == -1) {
120 else if (iIso3 == -1) { << 128 daughterN = "neutron";
121 daughterN = "neutron"; << 129 } else {
122 } <<
123 else { <<
124 // can not decay into N+gamma 130 // can not decay into N+gamma
125 return decayTable; 131 return decayTable;
126 } 132 }
127 133
128 if (fAnti) daughterN = "anti_" + daughterN; 134 if (fAnti) daughterN = "anti_" + daughterN;
129 135
130 // create decay channel [parent BR # 136 // create decay channel [parent BR #daughters]
131 mode = new G4PhaseSpaceDecayChannel(namePare << 137 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
>> 138 daughterN,"gamma");
132 // add decay table 139 // add decay table
133 decayTable->Insert(mode); 140 decayTable->Insert(mode);
134 141
135 return decayTable; 142 return decayTable;
136 } 143 }
137 144
138 G4DecayTable* G4ExcitedDeltaConstructor::AddNP << 145 G4DecayTable* G4ExcitedDeltaConstructor::AddNPiMode(
139 << 146 G4DecayTable* decayTable, const G4String& nameParent,
140 << 147 G4double br, G4int iIso3, G4bool fAnti)
141 { 148 {
142 G4VDecayChannel* mode; 149 G4VDecayChannel* mode;
143 150
144 G4String daughterN; 151 G4String daughterN;
145 G4String daughterPi; 152 G4String daughterPi;
146 G4double r = 0.; 153 G4double r = 0.;
147 154
148 // ------------ N pi0 ------------ << 155 // ------------ N pi0 ------------
149 // determine daughters 156 // determine daughters
150 if ((iIso3 == +1) || (iIso3 == -1)) { << 157 if ((iIso3 == +1)||(iIso3 == -1)) {
151 if (iIso3 == +1) { 158 if (iIso3 == +1) {
152 daughterN = "proton"; << 159 daughterN = "proton";
153 daughterPi = "pi0"; 160 daughterPi = "pi0";
154 r = br * 2. / 3.; << 161 r = br*2./3.;
155 } << 162 } else if (iIso3 == -1) {
156 else if (iIso3 == -1) { << 163 daughterN = "neutron";
157 daughterN = "neutron"; <<
158 daughterPi = "pi0"; 164 daughterPi = "pi0";
159 r = br / 3.; << 165 r = br/3.;
160 } << 166 }
161 if (fAnti) daughterN = "anti_" + daughterN 167 if (fAnti) daughterN = "anti_" + daughterN;
162 // create decay channel [parent BR 168 // create decay channel [parent BR #daughters]
163 mode = new G4PhaseSpaceDecayChannel(namePa << 169 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 170 daughterN,daughterPi);
164 // add decay table 171 // add decay table
165 decayTable->Insert(mode); 172 decayTable->Insert(mode);
166 } 173 }
167 174
168 // -------------N pi +/- -------------- << 175 // -------------N pi +/- --------------
169 // determine daughters 176 // determine daughters
170 if (iIso3 == +3) { 177 if (iIso3 == +3) {
171 daughterN = "proton"; << 178 daughterN = "proton";
172 if (!fAnti) { 179 if (!fAnti) {
173 daughterPi = "pi+"; 180 daughterPi = "pi+";
174 } << 181 } else {
175 else { <<
176 daughterPi = "pi-"; 182 daughterPi = "pi-";
177 } 183 }
178 r = br; 184 r = br;
179 } << 185 } else if (iIso3 == +1) {
180 else if (iIso3 == +1) { << 186 daughterN = "neutron";
181 daughterN = "neutron"; <<
182 if (!fAnti) { 187 if (!fAnti) {
183 daughterPi = "pi+"; 188 daughterPi = "pi+";
184 } << 189 } else {
185 else { <<
186 daughterPi = "pi-"; 190 daughterPi = "pi-";
187 } 191 }
188 r = br / 3.; << 192 r = br/3.;
189 } << 193 } else if (iIso3 == -1) {
190 else if (iIso3 == -1) { << 194 daughterN = "proton";
191 daughterN = "proton"; <<
192 if (!fAnti) { 195 if (!fAnti) {
193 daughterPi = "pi-"; 196 daughterPi = "pi-";
194 } << 197 } else {
195 else { <<
196 daughterPi = "pi+"; 198 daughterPi = "pi+";
197 } 199 }
198 r = br * 2. / 3.; << 200 r = br*2./3.;
199 } << 201 } else if (iIso3 == -3) {
200 else if (iIso3 == -3) { << 202 daughterN = "neutron";
201 daughterN = "neutron"; <<
202 if (!fAnti) { 203 if (!fAnti) {
203 daughterPi = "pi-"; 204 daughterPi = "pi-";
204 } << 205 } else {
205 else { <<
206 daughterPi = "pi+"; 206 daughterPi = "pi+";
207 } 207 }
208 r = br; 208 r = br;
209 } 209 }
210 if (fAnti) daughterN = "anti_" + daughterN; 210 if (fAnti) daughterN = "anti_" + daughterN;
211 211
212 // create decay channel [parent BR # 212 // create decay channel [parent BR #daughters]
213 mode = new G4PhaseSpaceDecayChannel(namePare << 213 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 214 daughterN,daughterPi);
214 // add decay table 215 // add decay table
215 decayTable->Insert(mode); 216 decayTable->Insert(mode);
216 217
217 return decayTable; 218 return decayTable;
218 } 219 }
219 220
220 G4DecayTable* G4ExcitedDeltaConstructor::AddNR << 221
221 << 222 G4DecayTable* G4ExcitedDeltaConstructor::AddNRhoMode(
222 << 223 G4DecayTable* decayTable, const G4String& nameParent,
>> 224 G4double br, G4int iIso3, G4bool fAnti)
223 { 225 {
224 G4VDecayChannel* mode; 226 G4VDecayChannel* mode;
225 227
226 G4String daughterN; 228 G4String daughterN;
227 G4String daughterRho; 229 G4String daughterRho;
228 G4double r = 0.; 230 G4double r = 0.;
229 231
230 // ------------ N Rho0 ------------ << 232 // ------------ N Rho0 ------------
231 // determine daughters 233 // determine daughters
232 if ((iIso3 == +1) || (iIso3 == -1)) { << 234 if ((iIso3 == +1)||(iIso3 == -1)) {
233 if (iIso3 == +1) { 235 if (iIso3 == +1) {
234 daughterN = "proton"; << 236 daughterN = "proton";
235 daughterRho = "rho0"; 237 daughterRho = "rho0";
236 r = br * 2. / 3.; << 238 r = br*2./3.;
237 } << 239 } else if (iIso3 == -1) {
238 else if (iIso3 == -1) { << 240 daughterN = "neutron";
239 daughterN = "neutron"; <<
240 daughterRho = "rho0"; 241 daughterRho = "rho0";
241 r = br / 3.; << 242 r = br/3.;
242 } << 243 }
243 if (fAnti) daughterN = "anti_" + daughterN 244 if (fAnti) daughterN = "anti_" + daughterN;
244 // create decay channel [parent BR 245 // create decay channel [parent BR #daughters]
245 mode = new G4PhaseSpaceDecayChannel(namePa << 246 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 247 daughterN,daughterRho);
246 // add decay table 248 // add decay table
247 decayTable->Insert(mode); 249 decayTable->Insert(mode);
248 } 250 }
249 251
250 // -------------N Rho +/- -------------- << 252 // -------------N Rho +/- --------------
251 // determine daughters 253 // determine daughters
252 if (iIso3 == +3) { 254 if (iIso3 == +3) {
253 daughterN = "proton"; << 255 daughterN = "proton";
254 if (!fAnti) { 256 if (!fAnti) {
255 daughterRho = "rho+"; 257 daughterRho = "rho+";
256 } << 258 } else {
257 else { <<
258 daughterRho = "rho-"; 259 daughterRho = "rho-";
259 } 260 }
260 r = br; 261 r = br;
261 } << 262 } else if (iIso3 == +1) {
262 else if (iIso3 == +1) { << 263 daughterN = "neutron";
263 daughterN = "neutron"; <<
264 if (!fAnti) { 264 if (!fAnti) {
265 daughterRho = "rho+"; 265 daughterRho = "rho+";
266 } << 266 } else {
267 else { <<
268 daughterRho = "rho-"; 267 daughterRho = "rho-";
269 } 268 }
270 r = br / 3.; << 269 r = br/3.;
271 } << 270 } else if (iIso3 == -1) {
272 else if (iIso3 == -1) { << 271 daughterN = "proton";
273 daughterN = "proton"; <<
274 if (!fAnti) { 272 if (!fAnti) {
275 daughterRho = "rho-"; 273 daughterRho = "rho-";
276 } << 274 } else {
277 else { <<
278 daughterRho = "rho+"; 275 daughterRho = "rho+";
279 } 276 }
280 r = br * 2. / 3.; << 277 r = br*2./3.;
281 } << 278 } else if (iIso3 == -3) {
282 else if (iIso3 == -3) { << 279 daughterN = "neutron";
283 daughterN = "neutron"; <<
284 if (!fAnti) { 280 if (!fAnti) {
285 daughterRho = "rho-"; 281 daughterRho = "rho-";
286 } << 282 } else {
287 else { <<
288 daughterRho = "rho+"; 283 daughterRho = "rho+";
289 } 284 }
290 r = br; 285 r = br;
291 } 286 }
292 if (fAnti) daughterN = "anti_" + daughterN; 287 if (fAnti) daughterN = "anti_" + daughterN;
293 288
294 // create decay channel [parent BR # 289 // create decay channel [parent BR #daughters]
295 mode = new G4PhaseSpaceDecayChannel(namePare << 290 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 291 daughterN,daughterRho);
296 // add decay table 292 // add decay table
297 decayTable->Insert(mode); 293 decayTable->Insert(mode);
298 294
299 return decayTable; 295 return decayTable;
300 } 296 }
301 297
302 G4DecayTable* G4ExcitedDeltaConstructor::AddNS << 298 G4DecayTable* G4ExcitedDeltaConstructor::AddNStarPiMode(
303 << 299 G4DecayTable* decayTable, const G4String& nameParent,
304 << 300 G4double br, G4int iIso3, G4bool fAnti)
305 { 301 {
306 G4VDecayChannel* mode; 302 G4VDecayChannel* mode;
307 303
308 G4String daughterN; 304 G4String daughterN;
309 G4String daughterPi; 305 G4String daughterPi;
310 G4double r = 0.; 306 G4double r = 0.;
311 307
312 // ------------ N pi0 ------------ << 308 // ------------ N pi0 ------------
313 // determine daughters 309 // determine daughters
314 if ((iIso3 == +1) || (iIso3 == -1)) { << 310 if ((iIso3 == +1)||(iIso3 == -1)) {
315 if (iIso3 == +1) { 311 if (iIso3 == +1) {
316 daughterN = "N(1440)+"; << 312 daughterN = "N(1440)+";
317 daughterPi = "pi0"; 313 daughterPi = "pi0";
318 r = br * 2. / 3.; << 314 r = br*2./3.;
319 } << 315 } else if (iIso3 == -1) {
320 else if (iIso3 == -1) { << 316 daughterN = "N(1440)0";
321 daughterN = "N(1440)0"; <<
322 daughterPi = "pi0"; 317 daughterPi = "pi0";
323 r = br / 3.; << 318 r = br/3.;
324 } << 319 }
325 if (fAnti) daughterN = "anti_" + daughterN 320 if (fAnti) daughterN = "anti_" + daughterN;
326 // create decay channel [parent BR 321 // create decay channel [parent BR #daughters]
327 mode = new G4PhaseSpaceDecayChannel(namePa << 322 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 323 daughterN,daughterPi);
328 // add decay table 324 // add decay table
329 decayTable->Insert(mode); 325 decayTable->Insert(mode);
330 } 326 }
331 327
332 // -------------N pi +/- -------------- << 328 // -------------N pi +/- --------------
333 // determine daughters 329 // determine daughters
334 if (iIso3 == +3) { 330 if (iIso3 == +3) {
335 daughterN = "N(1440)+"; << 331 daughterN = "N(1440)+";
336 if (!fAnti) { 332 if (!fAnti) {
337 daughterPi = "pi+"; 333 daughterPi = "pi+";
338 } << 334 } else {
339 else { <<
340 daughterPi = "pi-"; 335 daughterPi = "pi-";
341 } 336 }
342 r = br; 337 r = br;
343 } << 338 } else if (iIso3 == +1) {
344 else if (iIso3 == +1) { << 339 daughterN = "N(1440)0";
345 daughterN = "N(1440)0"; <<
346 if (!fAnti) { 340 if (!fAnti) {
347 daughterPi = "pi+"; 341 daughterPi = "pi+";
348 } << 342 } else {
349 else { <<
350 daughterPi = "pi-"; 343 daughterPi = "pi-";
351 } 344 }
352 r = br / 3.; << 345 r = br/3.;
353 } << 346 } else if (iIso3 == -1) {
354 else if (iIso3 == -1) { << 347 daughterN = "N(1440)+";
355 daughterN = "N(1440)+"; <<
356 if (!fAnti) { 348 if (!fAnti) {
357 daughterPi = "pi-"; 349 daughterPi = "pi-";
358 } << 350 } else {
359 else { <<
360 daughterPi = "pi+"; 351 daughterPi = "pi+";
361 } 352 }
362 r = br * 2. / 3.; << 353 r = br*2./3.;
363 } << 354 } else if (iIso3 == -3) {
364 else if (iIso3 == -3) { << 355 daughterN = "N(1440)0";
365 daughterN = "N(1440)0"; <<
366 if (!fAnti) { 356 if (!fAnti) {
367 daughterPi = "pi-"; 357 daughterPi = "pi-";
368 } << 358 } else {
369 else { <<
370 daughterPi = "pi+"; 359 daughterPi = "pi+";
371 } 360 }
372 r = br; 361 r = br;
373 } 362 }
374 if (fAnti) daughterN = "anti_" + daughterN; 363 if (fAnti) daughterN = "anti_" + daughterN;
375 364
376 // create decay channel [parent BR # 365 // create decay channel [parent BR #daughters]
377 mode = new G4PhaseSpaceDecayChannel(namePare << 366 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 367 daughterN,daughterPi);
378 // add decay table 368 // add decay table
379 decayTable->Insert(mode); 369 decayTable->Insert(mode);
380 370
381 return decayTable; 371 return decayTable;
382 } 372 }
383 373
384 G4DecayTable* G4ExcitedDeltaConstructor::AddDe << 374 G4DecayTable* G4ExcitedDeltaConstructor::AddDeltaPiMode(
385 << 375 G4DecayTable* decayTable, const G4String& nameParent,
386 << 376 G4double br, G4int iIso3, G4bool fAnti)
387 { 377 {
388 G4VDecayChannel* mode; 378 G4VDecayChannel* mode;
389 379
390 G4String daughterDelta; 380 G4String daughterDelta;
391 G4String daughterPi; 381 G4String daughterPi;
392 G4double r; 382 G4double r;
393 383
394 // ------------ Delta pi +------------ << 384 // ------------ Delta pi +------------
395 // determine daughters 385 // determine daughters
396 if (iIso3 == +3) { 386 if (iIso3 == +3) {
397 daughterDelta = "delta+"; << 387 daughterDelta = "delta+";
398 r = br * 0.4; << 388 r = br*0.4;
399 } << 389 } else if (iIso3 == +1) {
400 else if (iIso3 == +1) { << 390 daughterDelta = "delta0";
401 daughterDelta = "delta0"; << 391 r = br*8./15.0;
402 r = br * 8. / 15.0; << 392 } else if (iIso3 == -1) {
403 } << 393 daughterDelta = "delta-";
404 else if (iIso3 == -1) { << 394 r = br*6./15.;
405 daughterDelta = "delta-"; << 395 } else {
406 r = br * 6. / 15.; << 396 r = 0.;
407 } <<
408 else { <<
409 r = 0.; <<
410 } 397 }
411 if (!fAnti) { 398 if (!fAnti) {
412 daughterPi = "pi+"; 399 daughterPi = "pi+";
413 } << 400 } else {
414 else { <<
415 daughterPi = "pi-"; 401 daughterPi = "pi-";
416 } 402 }
417 if (fAnti) daughterDelta = "anti_" + daughte << 403 if (fAnti) daughterDelta = "anti_" + daughterDelta;
418 if (r > 0.0) { << 404 if (r>0.0) {
419 // create decay channel [parent BR 405 // create decay channel [parent BR #daughters]
420 mode = new G4PhaseSpaceDecayChannel(namePa << 406 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 407 daughterDelta,daughterPi);
421 // add decay table 408 // add decay table
422 decayTable->Insert(mode); 409 decayTable->Insert(mode);
423 } 410 }
424 411
425 // ------------ Delta pi0 ------------ << 412 // ------------ Delta pi0 ------------
426 // determine daughters 413 // determine daughters
427 if (iIso3 == +3) { 414 if (iIso3 == +3) {
428 daughterDelta = "delta++"; << 415 daughterDelta = "delta++";
429 r = br * 0.6; << 416 r = br*0.6;
430 } << 417 } else if (iIso3 == +1) {
431 else if (iIso3 == +1) { << 418 daughterDelta = "delta+";
432 daughterDelta = "delta+"; << 419 r = br*1./15.0;
433 r = br * 1. / 15.0; << 420 } else if (iIso3 == -1) {
434 } << 421 daughterDelta = "delta0";
435 else if (iIso3 == -1) { << 422 r = br*1./15.;
436 daughterDelta = "delta0"; << 423 } else {
437 r = br * 1. / 15.; << 424 daughterDelta = "delta-";
438 } << 425 r = br*0.6;
439 else { <<
440 daughterDelta = "delta-"; <<
441 r = br * 0.6; <<
442 } 426 }
443 daughterPi = "pi0"; 427 daughterPi = "pi0";
444 if (fAnti) daughterDelta = "anti_" + daughte 428 if (fAnti) daughterDelta = "anti_" + daughterDelta;
445 << 429
446 // create decay channel [parent BR # 430 // create decay channel [parent BR #daughters]
447 mode = new G4PhaseSpaceDecayChannel(namePare << 431 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 432 daughterDelta,daughterPi);
448 // add decay table 433 // add decay table
449 decayTable->Insert(mode); 434 decayTable->Insert(mode);
450 435
451 // ------------ Delta pi - ------------- << 436 // ------------ Delta pi - -------------
452 // determine daughters 437 // determine daughters
453 if (iIso3 == +3) { 438 if (iIso3 == +3) {
454 r = 0.; << 439 r= 0.;
455 } << 440 } else if (iIso3 == +1) {
456 else if (iIso3 == +1) { << 441 daughterDelta = "delta++";
457 daughterDelta = "delta++"; << 442 r = br*6./15.0;
458 r = br * 6. / 15.0; << 443 } else if (iIso3 == -1) {
459 } << 444 daughterDelta = "delta+";
460 else if (iIso3 == -1) { << 445 r = br*8./15.;
461 daughterDelta = "delta+"; << 446 } else {
462 r = br * 8. / 15.; << 447 daughterDelta = "delta0";
463 } << 448 r = br*0.4;
464 else { <<
465 daughterDelta = "delta0"; <<
466 r = br * 0.4; <<
467 } 449 }
468 if (!fAnti) { 450 if (!fAnti) {
469 daughterPi = "pi-"; 451 daughterPi = "pi-";
470 } << 452 } else {
471 else { <<
472 daughterPi = "pi+"; 453 daughterPi = "pi+";
473 } 454 }
474 if (fAnti) daughterDelta = "anti_" + daughte << 455 if (fAnti) daughterDelta = "anti_" + daughterDelta;
475 if (r > 0.0) { << 456 if (r>0.0) {
476 // create decay channel [parent BR 457 // create decay channel [parent BR #daughters]
477 mode = new G4PhaseSpaceDecayChannel(namePa << 458 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 459 daughterDelta,daughterPi);
478 // add decay table 460 // add decay table
479 decayTable->Insert(mode); 461 decayTable->Insert(mode);
480 } 462 }
481 463
482 return decayTable; 464 return decayTable;
483 } 465 }
484 466
485 // clang-format off << 467 const char* G4ExcitedDeltaConstructor::name[] =
486 const char* G4ExcitedDeltaConstructor::name[] <<
487 { 468 {
488 "delta(1600)", "delta(1620)", "delta(1700)", 469 "delta(1600)", "delta(1620)", "delta(1700)", "delta(1900)", "delta(1905)",
489 "delta(1910)", "delta(1920)", "delta(1930)", 470 "delta(1910)", "delta(1920)", "delta(1930)", "delta(1950)"
490 }; 471 };
491 472
492 const G4double G4ExcitedDeltaConstructor::mass << 473 const G4double G4ExcitedDeltaConstructor::mass[] =
493 { 474 {
494 1.570*GeV, 1.610*GeV, 1.710*GeV, 1.860*GeV, << 475 1.600*GeV, 1.620*GeV, 1.700*GeV, 1.840*GeV, 1.905*GeV,
495 1.900*GeV, 1.920*GeV, 1.950*GeV, 1.930*GeV << 476 1.910*GeV, 1.920*GeV, 1.930*GeV, 1.950*GeV
496 }; 477 };
497 478
498 const G4double G4ExcitedDeltaConstructor::widt 479 const G4double G4ExcitedDeltaConstructor::width[] = {
499 250.0*MeV, 130.0*MeV, 300.0*MeV, 250.0*MeV, << 480 350.0*MeV, 150.0*MeV, 300.0*MeV, 260.0*MeV, 350.0*MeV,
500 300.0*MeV, 300.0*MeV, 300.0*MeV, 285.0*MeV << 481 250.0*MeV, 200.0*MeV, 350.0*MeV, 300.0*MeV
501 }; 482 };
502 483
503 const G4int G4ExcitedDeltaConstructor::iSpin[] << 484 const G4int G4ExcitedDeltaConstructor::iSpin[] =
504 { 485 {
505 3, 1, 3, 1, 5, 486 3, 1, 3, 1, 5,
506 1, 3, 5, 7 487 1, 3, 5, 7
507 }; 488 };
508 489
509 const G4int G4ExcitedDeltaConstructor::iParity 490 const G4int G4ExcitedDeltaConstructor::iParity[] = {
510 +1, -1, -1, -1, +1, 491 +1, -1, -1, -1, +1,
511 +1, +1, -1, +1 492 +1, +1, -1, +1
512 }; 493 };
513 494
514 const G4int G4ExcitedDeltaConstructor::encodin 495 const G4int G4ExcitedDeltaConstructor::encodingOffset[] = {
515 30000, 0, 10000, 10000, 0, 496 30000, 0, 10000, 10000, 0,
516 20000, 20000, 10000, 0 497 20000, 20000, 10000, 0
517 }; 498 };
518 499
519 const G4double G4ExcitedDeltaConstructor::bRat << 500 const G4double G4ExcitedDeltaConstructor::bRatio[ G4ExcitedDeltaConstructor::NStates ][ G4ExcitedDeltaConstructor::NumberOfDecayModes] =
520 { 501 {
521 // NGamma Npi NRho DeltaPi N*Pi 502 // NGamma Npi NRho DeltaPi N*Pi
522 { 0.0, 0.15, 0.0, 0.55, 0.30 }, 503 { 0.0, 0.15, 0.0, 0.55, 0.30 },
523 { 0.0, 0.25, 0.0, 0.60, 0.15 }, 504 { 0.0, 0.25, 0.0, 0.60, 0.15 },
524 { 0.0, 0.20, 0.10, 0.55, 0.15 }, 505 { 0.0, 0.20, 0.10, 0.55, 0.15 },
525 { 0.0, 0.30, 0.15, 0.30, 0.25 }, 506 { 0.0, 0.30, 0.15, 0.30, 0.25 },
526 { 0.0, 0.20, 0.60, 0.10, 0.10 }, 507 { 0.0, 0.20, 0.60, 0.10, 0.10 },
527 { 0.0, 0.35, 0.40, 0.15, 0.10 }, 508 { 0.0, 0.35, 0.40, 0.15, 0.10 },
528 { 0.0, 0.15, 0.30, 0.30, 0.25 }, 509 { 0.0, 0.15, 0.30, 0.30, 0.25 },
529 { 0.0, 0.20, 0.25, 0.25, 0.30 }, 510 { 0.0, 0.20, 0.25, 0.25, 0.30 },
530 { 0.01, 0.44, 0.15, 0.20, 0.20 } 511 { 0.01, 0.44, 0.15, 0.20, 0.20 }
531 }; 512 };
>> 513
>> 514
>> 515
>> 516
>> 517
>> 518
>> 519
>> 520
>> 521
>> 522
>> 523
>> 524
>> 525
>> 526
>> 527
>> 528
532 529