| 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: G4ExcitedNucleonConstructor.cc,v 1.12 2010-10-01 02:41:44 kurasige Exp $
>> 28 // GEANT4 tag $Name: not supported by cvs2svn $
>> 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 "G4ExcitedNucleonConstructor.hh" 38 #include "G4ExcitedNucleonConstructor.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"
>> 46
>> 47
>> 48 G4ExcitedNucleonConstructor::G4ExcitedNucleonConstructor():
>> 49 G4ExcitedBaryonConstructor(NStates, NucleonIsoSpin)
>> 50 {
>> 51
>> 52 }
41 53
42 G4ExcitedNucleonConstructor::G4ExcitedNucleonC << 54 G4ExcitedNucleonConstructor::~G4ExcitedNucleonConstructor()
43 : G4ExcitedBaryonConstructor(NStates, Nucleo << 55 {
44 {} << 56 }
45 57
46 G4int G4ExcitedNucleonConstructor::GetEncoding 58 G4int G4ExcitedNucleonConstructor::GetEncoding(G4int iIsoSpin3, G4int idxState)
47 { 59 {
48 G4int encoding; 60 G4int encoding;
49 // Delta has exceptinal encoding 61 // Delta has exceptinal encoding
50 if ((idxState == 1) // N(1520) << 62 if ((idxState==1)||(idxState==6)||(idxState==8)||(idxState==9)||(idxState==12) ) {
51 || (idxState == 6) // N(1700) <<
52 || (idxState == 8) // N(1720) <<
53 || (idxState == 9) // N(1900) <<
54 || (idxState == 12)) // N(2190) <<
55 { <<
56 encoding = GetEncodingOffset(idxState); 63 encoding = GetEncodingOffset(idxState);
57 if ((iIsoSpin3 == 3) || (iIsoSpin3 == -3)) << 64 if ((iIsoSpin3==3)||(iIsoSpin3==-3)) {
58 // normal encoding << 65 // normal encoding
59 encoding += 1000 * GetQuarkContents(0, i << 66 encoding += 1000*GetQuarkContents(0, iIsoSpin3);
60 encoding += 100 * GetQuarkContents(1, iI << 67 encoding += 100*GetQuarkContents(1, iIsoSpin3);
61 encoding += 10 * GetQuarkContents(2, iIs << 68 encoding += 10*GetQuarkContents(2, iIsoSpin3);
62 } << 69 } else if (iIsoSpin3== +1){
63 else if (iIsoSpin3 == +1) { << 70 // 1st <--> 2nd quark
64 // 1st <--> 2nd quark << 71 encoding += 1000*GetQuarkContents(0, iIsoSpin3);
65 encoding += 1000 * GetQuarkContents(0, i << 72 encoding += 10*GetQuarkContents(1, iIsoSpin3);
66 encoding += 10 * GetQuarkContents(1, iIs << 73 encoding += 100*GetQuarkContents(2, iIsoSpin3);
67 encoding += 100 * GetQuarkContents(2, iI << 74 } else if (iIsoSpin3== -1){
68 } << 75 // 1st <--> 0th quark
69 else if (iIsoSpin3 == -1) { << 76 encoding += 100*GetQuarkContents(0, iIsoSpin3);
70 // 1st <--> 0th quark << 77 encoding += 1000*GetQuarkContents(1, iIsoSpin3);
71 encoding += 100 * GetQuarkContents(0, iI << 78 encoding += 10*GetQuarkContents(2, iIsoSpin3);
72 encoding += 1000 * GetQuarkContents(1, i <<
73 encoding += 10 * GetQuarkContents(2, iIs <<
74 } 79 }
75 encoding += GetiSpin(idxState) + 1; << 80 encoding += GetiSpin(idxState) +1;
76 } << 81 } else {
77 else <<
78 { <<
79 encoding = G4ExcitedBaryonConstructor::Get 82 encoding = G4ExcitedBaryonConstructor::GetEncoding(iIsoSpin3, idxState);
80 } 83 }
81 return encoding; 84 return encoding;
82 } 85 }
83 86
84 G4DecayTable* G4ExcitedNucleonConstructor::Cre << 87 G4DecayTable* G4ExcitedNucleonConstructor::CreateDecayTable(
85 << 88 const G4String& parentName,
>> 89 G4int iIso3,
>> 90 G4int iState,
>> 91 G4bool fAnti)
86 { 92 {
87 // create decay table 93 // create decay table
88 auto decayTable = new G4DecayTable(); << 94 G4DecayTable* decayTable = new G4DecayTable();
89 95
90 G4double br; 96 G4double br;
91 if ((br = bRatio[iState][NGamma]) > 0.0) { << 97 if ( (br=bRatio[iState][NGamma]) >0.0) {
92 AddNGammaMode(decayTable, parentName, br, << 98 AddNGammaMode( decayTable, parentName, br, iIso3, fAnti);
93 } 99 }
94 100
95 if ((br = bRatio[iState][NPi]) > 0.0) { << 101 if ( (br=bRatio[iState][NPi]) >0.0) {
96 AddNPiMode(decayTable, parentName, br, iIs << 102 AddNPiMode( decayTable, parentName, br, iIso3, fAnti);
97 } 103 }
98 104
99 if ((br = bRatio[iState][NEta]) > 0.0) { << 105 if ( (br=bRatio[iState][NEta]) >0.0) {
100 AddNEtaMode(decayTable, parentName, br, iI << 106 AddNEtaMode( decayTable, parentName, br, iIso3, fAnti);
101 } 107 }
102 108
103 if ((br = bRatio[iState][NOmega]) > 0.0) { << 109 if ( (br=bRatio[iState][NOmega]) >0.0) {
104 AddNOmegaMode(decayTable, parentName, br, << 110 AddNOmegaMode( decayTable, parentName, br, iIso3, fAnti);
105 } 111 }
106 112
107 if ((br = bRatio[iState][NRho]) > 0.0) { << 113 if ( (br=bRatio[iState][NRho]) >0.0) {
108 AddNRhoMode(decayTable, parentName, br, iI << 114 AddNRhoMode( decayTable, parentName, br, iIso3, fAnti);
109 } 115 }
110 116
111 if ((br = bRatio[iState][N2Pi]) > 0.0) { << 117 if ( (br=bRatio[iState][N2Pi]) >0.0) {
112 AddN2PiMode(decayTable, parentName, br, iI << 118 AddN2PiMode( decayTable, parentName, br, iIso3, fAnti);
113 } 119 }
114 120
115 if ((br = bRatio[iState][DeltaPi]) > 0.0) { << 121 if ( (br=bRatio[iState][DeltaPi]) >0.0) {
116 AddDeltaPiMode(decayTable, parentName, br, << 122 AddDeltaPiMode( decayTable, parentName, br, iIso3, fAnti);
117 } 123 }
118 124
119 if ((br = bRatio[iState][NStarPi]) > 0.0) { << 125 if ( (br=bRatio[iState][NStarPi]) >0.0) {
120 AddNStarPiMode(decayTable, parentName, br, << 126 AddNStarPiMode( decayTable, parentName, br, iIso3, fAnti);
121 } 127 }
122 128
123 if ((br = bRatio[iState][LambdaK]) > 0.0) { << 129 if ( (br=bRatio[iState][LambdaK]) >0.0) {
124 AddLambdaKMode(decayTable, parentName, br, << 130 AddLambdaKMode( decayTable, parentName, br, iIso3, fAnti);
125 } 131 }
126 132
127 return decayTable; << 133 return decayTable;
128 } 134 }
129 135
130 G4DecayTable* G4ExcitedNucleonConstructor::Add << 136 G4DecayTable* G4ExcitedNucleonConstructor::AddNGammaMode(
131 << 137 G4DecayTable* decayTable, const G4String& nameParent,
132 << 138 G4double br, G4int iIso3, G4bool fAnti)
133 { 139 {
134 G4VDecayChannel* mode; 140 G4VDecayChannel* mode;
135 141
136 // << 142 //
137 G4String daughterN; 143 G4String daughterN;
138 if (iIso3 == +1) { << 144 if (iIso3 == +1) {
139 daughterN = "proton"; << 145 daughterN = "proton";
140 } << 146 } else {
141 else { << 147 daughterN = "neutron";
142 daughterN = "neutron"; << 148 }
143 } <<
144 if (fAnti) daughterN = "anti_" + daughterN; 149 if (fAnti) daughterN = "anti_" + daughterN;
145 150
146 // create decay channel [parent BR # 151 // create decay channel [parent BR #daughters]
147 mode = new G4PhaseSpaceDecayChannel(namePare << 152 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
>> 153 daughterN,"gamma");
148 // add decay table 154 // add decay table
149 decayTable->Insert(mode); 155 decayTable->Insert(mode);
150 156
151 return decayTable; 157 return decayTable;
152 } 158 }
153 159
154 G4DecayTable* G4ExcitedNucleonConstructor::Add << 160 G4DecayTable* G4ExcitedNucleonConstructor::AddNPiMode(
155 << 161 G4DecayTable* decayTable, const G4String& nameParent,
156 << 162 G4double br, G4int iIso3, G4bool fAnti)
157 { 163 {
158 G4VDecayChannel* mode; 164 G4VDecayChannel* mode;
159 165
160 G4String daughterN; 166 G4String daughterN;
161 G4String daughterPi; 167 G4String daughterPi;
162 168
163 // ------------ N pi0 ------------ << 169 // ------------ N pi0 ------------
164 // determine daughters 170 // determine daughters
165 if (iIso3 == +1) { 171 if (iIso3 == +1) {
166 daughterN = "proton"; << 172 daughterN = "proton";
167 daughterPi = "pi0"; 173 daughterPi = "pi0";
168 } << 174 } else {
169 else { << 175 daughterN = "neutron";
170 daughterN = "neutron"; <<
171 daughterPi = "pi0"; 176 daughterPi = "pi0";
172 } 177 }
173 if (fAnti) daughterN = "anti_" + daughterN; 178 if (fAnti) daughterN = "anti_" + daughterN;
174 // create decay channel [parent BR # 179 // create decay channel [parent BR #daughters]
175 mode = new G4PhaseSpaceDecayChannel(namePare << 180 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
>> 181 daughterN,daughterPi);
176 // add decay table 182 // add decay table
177 decayTable->Insert(mode); 183 decayTable->Insert(mode);
178 184
179 // -------------N pi +/- -------------- << 185 // -------------N pi +/- --------------
180 // determine daughters 186 // determine daughters
181 if (iIso3 == +1) { 187 if (iIso3 == +1) {
182 daughterN = "neutron"; << 188 daughterN = "neutron";
183 if (!fAnti) { 189 if (!fAnti) {
184 daughterPi = "pi+"; 190 daughterPi = "pi+";
185 } << 191 } else {
186 else { <<
187 daughterPi = "pi-"; 192 daughterPi = "pi-";
188 } 193 }
189 } << 194 } else {
190 else { << 195 daughterN = "proton";
191 daughterN = "proton"; <<
192 if (!fAnti) { 196 if (!fAnti) {
193 daughterPi = "pi-"; 197 daughterPi = "pi-";
194 } << 198 } else {
195 else { <<
196 daughterPi = "pi+"; 199 daughterPi = "pi+";
197 } 200 }
198 } 201 }
199 if (fAnti) daughterN = "anti_" + daughterN; 202 if (fAnti) daughterN = "anti_" + daughterN;
200 203
201 // create decay channel [parent BR # 204 // create decay channel [parent BR #daughters]
202 mode = new G4PhaseSpaceDecayChannel(namePare << 205 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
>> 206 daughterN,daughterPi);
203 // add decay table 207 // add decay table
204 decayTable->Insert(mode); 208 decayTable->Insert(mode);
205 209
206 return decayTable; 210 return decayTable;
207 } 211 }
208 212
209 G4DecayTable* G4ExcitedNucleonConstructor::Add << 213 G4DecayTable* G4ExcitedNucleonConstructor::AddNEtaMode(
210 << 214 G4DecayTable* decayTable, const G4String& nameParent,
211 << 215 G4double br, G4int iIso3, G4bool fAnti)
212 { 216 {
213 G4VDecayChannel* mode; 217 G4VDecayChannel* mode;
214 218
215 G4String daughterN; 219 G4String daughterN;
216 220
217 // ------------ N eta------------ << 221 // ------------ N eta------------
218 // determine daughters 222 // determine daughters
219 if (iIso3 == +1) { 223 if (iIso3 == +1) {
220 daughterN = "proton"; << 224 daughterN = "proton";
221 } << 225 } else {
222 else { << 226 daughterN = "neutron";
223 daughterN = "neutron"; <<
224 } 227 }
225 if (fAnti) daughterN = "anti_" + daughterN; 228 if (fAnti) daughterN = "anti_" + daughterN;
226 // create decay channel [parent BR # 229 // create decay channel [parent BR #daughters]
227 mode = new G4PhaseSpaceDecayChannel(namePare << 230 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
>> 231 daughterN, "eta");
228 // add decay table 232 // add decay table
229 decayTable->Insert(mode); 233 decayTable->Insert(mode);
230 234
231 return decayTable; 235 return decayTable;
232 } 236 }
233 237
234 G4DecayTable* G4ExcitedNucleonConstructor::Add << 238 G4DecayTable* G4ExcitedNucleonConstructor::AddNOmegaMode(
235 << 239 G4DecayTable* decayTable, const G4String& nameParent,
236 << 240 G4double br, G4int iIso3, G4bool fAnti)
237 { 241 {
238 G4VDecayChannel* mode; 242 G4VDecayChannel* mode;
239 243
240 G4String daughterN; 244 G4String daughterN;
241 245
242 // ------------ N omega------------ << 246 // ------------ N omega------------
243 // determine daughters 247 // determine daughters
244 if (iIso3 == +1) { 248 if (iIso3 == +1) {
245 daughterN = "proton"; << 249 daughterN = "proton";
246 } << 250 } else {
247 else { << 251 daughterN = "neutron";
248 daughterN = "neutron"; <<
249 } 252 }
250 if (fAnti) daughterN = "anti_" + daughterN; 253 if (fAnti) daughterN = "anti_" + daughterN;
251 // create decay channel [parent BR # 254 // create decay channel [parent BR #daughters]
252 mode = new G4PhaseSpaceDecayChannel(namePare << 255 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
>> 256 daughterN, "omega");
253 // add decay table 257 // add decay table
254 decayTable->Insert(mode); 258 decayTable->Insert(mode);
255 259
256 return decayTable; 260 return decayTable;
257 } 261 }
258 262
259 G4DecayTable* G4ExcitedNucleonConstructor::Add << 263 G4DecayTable* G4ExcitedNucleonConstructor::AddNRhoMode(
260 << 264 G4DecayTable* decayTable, const G4String& nameParent,
261 << 265 G4double br, G4int iIso3, G4bool fAnti)
262 { 266 {
263 G4VDecayChannel* mode; 267 G4VDecayChannel* mode;
264 268
265 G4String daughterN; 269 G4String daughterN;
266 G4String daughterRho; 270 G4String daughterRho;
267 271
268 // ------------ N rho0 ------------ << 272 // ------------ N rho0 ------------
269 // determine daughters 273 // determine daughters
270 if (iIso3 == +1) { 274 if (iIso3 == +1) {
271 daughterN = "proton"; << 275 daughterN = "proton";
272 daughterRho = "rho0"; 276 daughterRho = "rho0";
273 } << 277 } else {
274 else { << 278 daughterN = "neutron";
275 daughterN = "neutron"; <<
276 daughterRho = "rho0"; 279 daughterRho = "rho0";
277 } 280 }
278 if (fAnti) daughterN = "anti_" + daughterN; 281 if (fAnti) daughterN = "anti_" + daughterN;
279 // create decay channel [parent BR # 282 // create decay channel [parent BR #daughters]
280 mode = new G4PhaseSpaceDecayChannel(namePare << 283 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
>> 284 daughterN,daughterRho);
281 // add decay table 285 // add decay table
282 decayTable->Insert(mode); 286 decayTable->Insert(mode);
283 287
284 // -------------N rho+/- -------------- << 288 // -------------N rho+/- --------------
285 // determine daughters 289 // determine daughters
286 if (iIso3 == +1) { 290 if (iIso3 == +1) {
287 daughterN = "neutron"; << 291 daughterN = "neutron";
288 if (!fAnti) { 292 if (!fAnti) {
289 daughterRho = "rho+"; 293 daughterRho = "rho+";
290 } << 294 } else {
291 else { <<
292 daughterRho = "rho-"; 295 daughterRho = "rho-";
293 } 296 }
294 } << 297 } else {
295 else { << 298 daughterN = "proton";
296 daughterN = "proton"; <<
297 if (!fAnti) { 299 if (!fAnti) {
298 daughterRho = "rho-"; 300 daughterRho = "rho-";
299 } << 301 } else {
300 else { <<
301 daughterRho = "rho+"; 302 daughterRho = "rho+";
302 } 303 }
303 } 304 }
304 if (fAnti) daughterN = "anti_" + daughterN; 305 if (fAnti) daughterN = "anti_" + daughterN;
305 306
306 // create decay channel [parent BR # 307 // create decay channel [parent BR #daughters]
307 mode = new G4PhaseSpaceDecayChannel(namePare << 308 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
>> 309 daughterN,daughterRho);
308 // add decay table 310 // add decay table
309 decayTable->Insert(mode); 311 decayTable->Insert(mode);
310 312
311 return decayTable; 313 return decayTable;
312 } 314 }
313 315
314 G4DecayTable* G4ExcitedNucleonConstructor::Add << 316 G4DecayTable* G4ExcitedNucleonConstructor::AddN2PiMode(
315 << 317 G4DecayTable* decayTable, const G4String& nameParent,
316 << 318 G4double br, G4int iIso3, G4bool fAnti)
317 { 319 {
318 // Decay Modes 320 // Decay Modes
319 // N* --> N + pi + pi 321 // N* --> N + pi + pi
320 // Only I=0 states are included for 2-pi << 322 // Only I=0 states are included for 2-pi system
321 << 323
322 G4VDecayChannel* mode; 324 G4VDecayChannel* mode;
323 325
324 G4String daughterN; 326 G4String daughterN;
325 G4String daughterPi1; 327 G4String daughterPi1;
326 G4String daughterPi2; 328 G4String daughterPi2;
327 329
328 // -------------N pi+ pi- -------------- << 330 // -------------N pi+ pi- --------------
329 // determine daughters 331 // determine daughters
330 if (iIso3 == +1) { 332 if (iIso3 == +1) {
331 daughterN = "proton"; << 333 daughterN = "proton";
332 daughterPi1 = "pi+"; 334 daughterPi1 = "pi+";
333 daughterPi2 = "pi-"; 335 daughterPi2 = "pi-";
334 } << 336 } else {
335 else { << 337 daughterN = "neutron";
336 daughterN = "neutron"; <<
337 daughterPi1 = "pi+"; 338 daughterPi1 = "pi+";
338 daughterPi2 = "pi-"; 339 daughterPi2 = "pi-";
339 } 340 }
340 if (fAnti) daughterN = "anti_" + daughterN; 341 if (fAnti) daughterN = "anti_" + daughterN;
341 342
342 // create decay channel [parent BR # 343 // create decay channel [parent BR #daughters]
343 mode = new G4PhaseSpaceDecayChannel(namePare << 344 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 3,
>> 345 daughterN,daughterPi1,daughterPi2);
344 // add decay table 346 // add decay table
345 decayTable->Insert(mode); 347 decayTable->Insert(mode);
346 348
347 // -------------N pi0 pi0 -------------- << 349 // -------------N pi0 pi0 --------------
348 // determine daughters 350 // determine daughters
349 if (iIso3 == +1) { 351 if (iIso3 == +1) {
350 daughterN = "proton"; << 352 daughterN = "proton";
351 daughterPi1 = "pi0"; 353 daughterPi1 = "pi0";
352 daughterPi2 = "pi0"; 354 daughterPi2 = "pi0";
353 } << 355 } else {
354 else { << 356 daughterN = "neutron";
355 daughterN = "neutron"; <<
356 daughterPi1 = "pi0"; 357 daughterPi1 = "pi0";
357 daughterPi2 = "pi0"; 358 daughterPi2 = "pi0";
358 } 359 }
359 if (fAnti) daughterN = "anti_" + daughterN; 360 if (fAnti) daughterN = "anti_" + daughterN;
360 361
361 // create decay channel [parent BR # 362 // create decay channel [parent BR #daughters]
362 mode = new G4PhaseSpaceDecayChannel(namePare << 363 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 3,
>> 364 daughterN,daughterPi1,daughterPi2);
363 // add decay table 365 // add decay table
364 decayTable->Insert(mode); 366 decayTable->Insert(mode);
365 367
366 return decayTable; 368 return decayTable;
367 } 369 }
368 370
369 G4DecayTable* G4ExcitedNucleonConstructor::Add << 371 G4DecayTable* G4ExcitedNucleonConstructor::AddNStarPiMode(
370 << 372 G4DecayTable* decayTable, const G4String& nameParent,
371 << 373 G4double br, G4int iIso3, G4bool fAnti)
372 { 374 {
373 G4VDecayChannel* mode; 375 G4VDecayChannel* mode;
374 376
375 G4String daughterN; 377 G4String daughterN;
376 G4String daughterPi; 378 G4String daughterPi;
377 379
378 // ------------ N pi0 ------------ << 380 // ------------ N pi0 ------------
379 // determine daughters 381 // determine daughters
380 if (iIso3 == +1) { 382 if (iIso3 == +1) {
381 daughterN = "N(1440)+"; << 383 daughterN = "N(1440)+";
382 daughterPi = "pi0"; 384 daughterPi = "pi0";
383 } << 385 } else {
384 else { << 386 daughterN = "N(1440)0";
385 daughterN = "N(1440)0"; <<
386 daughterPi = "pi0"; 387 daughterPi = "pi0";
387 } 388 }
388 if (fAnti) daughterN = "anti_" + daughterN; 389 if (fAnti) daughterN = "anti_" + daughterN;
389 // create decay channel [parent BR # 390 // create decay channel [parent BR #daughters]
390 mode = new G4PhaseSpaceDecayChannel(namePare << 391 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
>> 392 daughterN,daughterPi);
391 // add decay table 393 // add decay table
392 decayTable->Insert(mode); 394 decayTable->Insert(mode);
393 395
394 // -------------N pi +/- -------------- << 396 // -------------N pi +/- --------------
395 // determine daughters 397 // determine daughters
396 if (iIso3 == +1) { 398 if (iIso3 == +1) {
397 daughterN = "N(1440)0"; << 399 daughterN = "N(1440)0";
398 if (!fAnti) { 400 if (!fAnti) {
399 daughterPi = "pi+"; 401 daughterPi = "pi+";
400 } << 402 } else {
401 else { <<
402 daughterPi = "pi-"; 403 daughterPi = "pi-";
403 } 404 }
404 } << 405 } else {
405 else { << 406 daughterN = "N(1440)+";
406 daughterN = "N(1440)+"; <<
407 if (!fAnti) { 407 if (!fAnti) {
408 daughterPi = "pi-"; 408 daughterPi = "pi-";
409 } << 409 } else {
410 else { <<
411 daughterPi = "pi+"; 410 daughterPi = "pi+";
412 } 411 }
413 } 412 }
414 if (fAnti) daughterN = "anti_" + daughterN; 413 if (fAnti) daughterN = "anti_" + daughterN;
415 414
416 // create decay channel [parent BR # 415 // create decay channel [parent BR #daughters]
417 mode = new G4PhaseSpaceDecayChannel(namePare << 416 mode = new G4PhaseSpaceDecayChannel(nameParent, br/2.0, 2,
>> 417 daughterN,daughterPi);
418 // add decay table 418 // add decay table
419 decayTable->Insert(mode); 419 decayTable->Insert(mode);
420 420
421 return decayTable; 421 return decayTable;
422 } 422 }
423 423
424 G4DecayTable* G4ExcitedNucleonConstructor::Add << 424 G4DecayTable* G4ExcitedNucleonConstructor::AddDeltaPiMode(
425 << 425 G4DecayTable* decayTable, const G4String& nameParent,
426 << 426 G4double br, G4int iIso3, G4bool fAnti)
427 { 427 {
428 G4VDecayChannel* mode; 428 G4VDecayChannel* mode;
429 429
430 G4String daughterDelta; 430 G4String daughterDelta;
431 G4String daughterPi; 431 G4String daughterPi;
432 G4double r; 432 G4double r;
433 433
434 // ------------ Delta pi+/- ------------ << 434 // ------------ Delta pi+/- ------------
435 // determine daughters 435 // determine daughters
436 if (iIso3 == +1) { 436 if (iIso3 == +1) {
437 daughterDelta = "delta0"; << 437 daughterDelta = "delta0";
438 if (!fAnti) { 438 if (!fAnti) {
439 daughterPi = "pi+"; 439 daughterPi = "pi+";
440 } << 440 } else {
441 else { <<
442 daughterPi = "pi-"; 441 daughterPi = "pi-";
443 } 442 }
444 r = br / 6.0; << 443 r = br/6.0;
445 } << 444 } else {
446 else { << 445 daughterDelta = "delta+";
447 daughterDelta = "delta+"; <<
448 if (!fAnti) { 446 if (!fAnti) {
449 daughterPi = "pi-"; 447 daughterPi = "pi-";
450 } << 448 } else {
451 else { <<
452 daughterPi = "pi+"; 449 daughterPi = "pi+";
453 } 450 }
454 r = br / 6.0; << 451 r = br/6.0;
455 } 452 }
456 if (fAnti) daughterDelta = "anti_" + daughte 453 if (fAnti) daughterDelta = "anti_" + daughterDelta;
457 // create decay channel [parent BR # 454 // create decay channel [parent BR #daughters]
458 mode = new G4PhaseSpaceDecayChannel(namePare << 455 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 456 daughterDelta,daughterPi);
459 // add decay table 457 // add decay table
460 decayTable->Insert(mode); 458 decayTable->Insert(mode);
461 459
462 // ------------ Delta pi+/- ------------ << 460 // ------------ Delta pi+/- ------------
463 // determine daughters 461 // determine daughters
464 if (iIso3 == +1) { 462 if (iIso3 == +1) {
465 daughterDelta = "delta++"; << 463 daughterDelta = "delta++";
466 if (!fAnti) { 464 if (!fAnti) {
467 daughterPi = "pi-"; 465 daughterPi = "pi-";
468 } << 466 } else {
469 else { <<
470 daughterPi = "pi+"; 467 daughterPi = "pi+";
471 } 468 }
472 r = br / 2.0; << 469 r = br/2.0;
473 } << 470 } else {
474 else { << 471 daughterDelta = "delta-";
475 daughterDelta = "delta-"; <<
476 if (!fAnti) { 472 if (!fAnti) {
477 daughterPi = "pi+"; 473 daughterPi = "pi+";
478 } << 474 } else {
479 else { <<
480 daughterPi = "pi-"; 475 daughterPi = "pi-";
481 } 476 }
482 r = br / 2.0; << 477 r = br/2.0;
483 } 478 }
484 if (fAnti) daughterDelta = "anti_" + daughte 479 if (fAnti) daughterDelta = "anti_" + daughterDelta;
485 // create decay channel [parent BR # 480 // create decay channel [parent BR #daughters]
486 mode = new G4PhaseSpaceDecayChannel(namePare << 481 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 482 daughterDelta,daughterPi);
487 // add decay table 483 // add decay table
488 decayTable->Insert(mode); 484 decayTable->Insert(mode);
489 485
490 // ------------ Delta pi0 ------------ << 486 // ------------ Delta pi0 ------------
491 // determine daughters 487 // determine daughters
492 if (iIso3 == +1) { 488 if (iIso3 == +1) {
493 daughterDelta = "delta+"; << 489 daughterDelta = "delta+";
494 daughterPi = "pi0"; 490 daughterPi = "pi0";
495 r = br / 3.0; << 491 r = br/3.0;
496 } << 492 } else {
497 else { << 493 daughterDelta = "delta0";
498 daughterDelta = "delta0"; <<
499 daughterPi = "pi0"; 494 daughterPi = "pi0";
500 r = br / 3.0; << 495 r = br/3.0;
501 } 496 }
502 if (fAnti) daughterDelta = "anti_" + daughte 497 if (fAnti) daughterDelta = "anti_" + daughterDelta;
503 // create decay channel [parent BR # 498 // create decay channel [parent BR #daughters]
504 mode = new G4PhaseSpaceDecayChannel(namePare << 499 mode = new G4PhaseSpaceDecayChannel(nameParent, r, 2,
>> 500 daughterDelta,daughterPi);
505 // add decay table 501 // add decay table
506 decayTable->Insert(mode); 502 decayTable->Insert(mode);
507 503
>> 504
508 return decayTable; 505 return decayTable;
509 } 506 }
510 507
511 G4DecayTable* G4ExcitedNucleonConstructor::Add << 508 G4DecayTable* G4ExcitedNucleonConstructor::AddLambdaKMode(
512 << 509 G4DecayTable* decayTable, const G4String& nameParent,
513 << 510 G4double br, G4int iIso3, G4bool fAnti)
514 { 511 {
515 G4VDecayChannel* mode; 512 G4VDecayChannel* mode;
516 513
517 G4String lambda = "lambda"; 514 G4String lambda = "lambda";
518 G4String daughterK; 515 G4String daughterK;
519 516
520 // ------------ N pi0 ------------ << 517 // ------------ N pi0 ------------
521 // determine daughters 518 // determine daughters
522 if (iIso3 == +1) { 519 if (iIso3 == +1) {
523 if (!fAnti) { 520 if (!fAnti) {
524 daughterK = "kaon+"; 521 daughterK = "kaon+";
525 } << 522 } else {
526 else { <<
527 daughterK = "kaon-"; 523 daughterK = "kaon-";
528 } 524 }
529 } << 525 } else {
530 else { <<
531 if (!fAnti) { 526 if (!fAnti) {
532 daughterK = "kaon0"; 527 daughterK = "kaon0";
533 } << 528 } else {
534 else { <<
535 daughterK = "anti_kaon0"; 529 daughterK = "anti_kaon0";
536 } 530 }
537 } 531 }
538 if (fAnti) lambda = "anti_" + lambda; 532 if (fAnti) lambda = "anti_" + lambda;
539 // create decay channel [parent BR # 533 // create decay channel [parent BR #daughters]
540 mode = new G4PhaseSpaceDecayChannel(namePare << 534 mode = new G4PhaseSpaceDecayChannel(nameParent, br, 2,
>> 535 lambda, daughterK);
541 // add decay table 536 // add decay table
542 decayTable->Insert(mode); 537 decayTable->Insert(mode);
543 538
544 return decayTable; 539 return decayTable;
545 } 540 }
546 541
547 // clang-format off <<
548 <<
549 // PDG2005 542 // PDG2005
550 // N(2090) is renamed to N(2080) << 543 // N(2090) is renamed to N(2080)
551 // but keep unchanged temporalily Apr 06 544 // but keep unchanged temporalily Apr 06
552 // <<
553 // -> PDG2023: N(2090) is removed by S.Okada 4 <<
554 545
555 const char* G4ExcitedNucleonConstructor::name[ 546 const char* G4ExcitedNucleonConstructor::name[] = {
556 "N(1440)", "N(1520)", "N(1535)", "N(1650)", 547 "N(1440)", "N(1520)", "N(1535)", "N(1650)", "N(1675)",
557 "N(1680)", "N(1700)", "N(1710)", "N(1720)", << 548 "N(1680)", "N(1700)", "N(1710)", "N(1720)", "N(1900)",
558 "N(1990)", "N(2090)", "N(2190)", "N(2220)", 549 "N(1990)", "N(2090)", "N(2190)", "N(2220)", "N(2250)"
559 }; 550 };
560 551
561 const G4double G4ExcitedNucleonConstructor::ma 552 const G4double G4ExcitedNucleonConstructor::mass[] = {
562 1.440*GeV, 1.515*GeV, 1.535*GeV, 1.650*GeV, << 553 1.440*GeV, 1.520*GeV, 1.535*GeV, 1.655*GeV, 1.675*GeV,
563 1.685*GeV, 1.720*GeV, 1.710*GeV, 1.720*GeV, << 554 1.685*GeV, 1.700*GeV, 1.710*GeV, 1.720*GeV, 1.900*GeV,
564 2.020*GeV, 2.080*GeV, 2.180*GeV, 2.250*GeV, << 555 1.950*GeV, 2.080*GeV, 2.190*GeV, 2.250*GeV, 2.275*GeV
565 }; 556 };
566 557
567 const G4double G4ExcitedNucleonConstructor::wi 558 const G4double G4ExcitedNucleonConstructor::width[] = {
568 350.0*MeV, 110.0*MeV, 150.0*MeV, 125.0*MeV, << 559 300.0*MeV, 115.0*MeV, 150.0*MeV, 165.0*MeV, 150.0*MeV,
569 120.0*MeV, 200.0*MeV, 140.0*MeV, 250.0*MeV, << 560 130.0*MeV, 100.0*MeV, 100.0*MeV, 200.0*MeV, 500.0*MeV,
570 300.0*MeV, 350.0*MeV, 400.0*MeV, 400.0*MeV, << 561 555.0*MeV, 350.0*MeV, 500.0*MeV, 400.0*MeV, 500.0*MeV
571 }; 562 };
572 563
573 const G4int G4ExcitedNucleonConstructor::iSpin 564 const G4int G4ExcitedNucleonConstructor::iSpin[] = {
574 1, 3, 1, 1, 5, 565 1, 3, 1, 1, 5,
575 5, 3, 1, 3, 3, 566 5, 3, 1, 3, 3,
576 7, 3, 7, 9, 9 567 7, 3, 7, 9, 9
577 }; 568 };
578 569
579 const G4int G4ExcitedNucleonConstructor::iPari 570 const G4int G4ExcitedNucleonConstructor::iParity[] = {
580 +1, -1, -1, -1, -1, 571 +1, -1, -1, -1, -1,
581 +1, -1, +1, +1, +1, 572 +1, -1, +1, +1, +1,
582 +1, -1, +1, -1, -1 << 573 +1, -1, +1, -1, -1
583 }; 574 };
584 575
585 const G4int G4ExcitedNucleonConstructor::encod 576 const G4int G4ExcitedNucleonConstructor::encodingOffset[] = {
586 10000, 0, 20000, 30000, 0, 577 10000, 0, 20000, 30000, 0,
587 10000, 20000, 40000, 30000, 40000, << 578 10000, 20000, 40000, 30000, 40000,
588 10000, 50000, 0, 0, 10000 << 579 10000, 50000, 0, 0, 10000
589 }; 580 };
590 581
591 const G4double G4ExcitedNucleonConstructor::bR << 582 const G4double G4ExcitedNucleonConstructor::bRatio[ G4ExcitedNucleonConstructor::NStates ][ G4ExcitedNucleonConstructor::NumberOfDecayModes] =
592 { 583 {
593 { 0.0, 0.70, 0.0, 0.0, 0.0, 0.05, 0.2 << 584 { 0.0, 0.70, 0.0, 0.0, 0.0, 0.05, 0.25, 0.0, 0.0},
594 { 0.0, 0.60, 0.0, 0.0, 0.0, 0.15, 0.2 << 585 { 0.0, 0.60, 0.0, 0.0, 0.0, 0.15, 0.25, 0.0, 0.0},
595 {0.001, 0.55, 0.35, 0.0, 0.0, 0.05, 0.0 586 {0.001, 0.55, 0.35, 0.0, 0.0, 0.05, 0.00, 0.05, 0.0},
596 { 0.0, 0.65, 0.05, 0.0, 0.0, 0.05, 0.1 587 { 0.0, 0.65, 0.05, 0.0, 0.0, 0.05, 0.10, 0.05, 0.10},
597 { 0.0, 0.45, 0.0, 0.0, 0.0, 0.00, 0.5 588 { 0.0, 0.45, 0.0, 0.0, 0.0, 0.00, 0.55, 0.0, 0.0},
598 { 0.0, 0.65, 0.0, 0.0, 0.0, 0.20, 0.1 589 { 0.0, 0.65, 0.0, 0.0, 0.0, 0.20, 0.15, 0.0, 0.0},
599 { 0.0, 0.10, 0.05, 0.0, 0.05, 0.45, 0.3 590 { 0.0, 0.10, 0.05, 0.0, 0.05, 0.45, 0.35, 0.0, 0.0},
600 { 0.0, 0.15, 0.20, 0.0, 0.05, 0.20, 0.2 591 { 0.0, 0.15, 0.20, 0.0, 0.05, 0.20, 0.20, 0.10, 0.10},
601 { 0.0, 0.15, 0.00, 0.0, 0.25, 0.45, 0.1 592 { 0.0, 0.15, 0.00, 0.0, 0.25, 0.45, 0.10, 0.00, 0.05},
602 { 0.0, 0.35, 0.0, 0.55, 0.05, 0.00, 0.0 593 { 0.0, 0.35, 0.0, 0.55, 0.05, 0.00, 0.05, 0.0, 0.0},
603 { 0.0, 0.05, 0.0, 0.0, 0.15, 0.25, 0.3 594 { 0.0, 0.05, 0.0, 0.0, 0.15, 0.25, 0.30, 0.15, 0.10},
604 { 0.0, 0.60, 0.05, 0.0, 0.25, 0.05, 0.0 595 { 0.0, 0.60, 0.05, 0.0, 0.25, 0.05, 0.05, 0.0, 0.0},
605 { 0.0, 0.35, 0.0, 0.00, 0.30, 0.15, 0.1 596 { 0.0, 0.35, 0.0, 0.00, 0.30, 0.15, 0.15, 0.05, 0.0},
606 { 0.0, 0.35, 0.0, 0.0, 0.25, 0.20, 0.2 597 { 0.0, 0.35, 0.0, 0.0, 0.25, 0.20, 0.20, 0.0, 0.0},
607 { 0.0, 0.30, 0.0, 0.00, 0.25, 0.20, 0.2 598 { 0.0, 0.30, 0.0, 0.00, 0.25, 0.20, 0.20, 0.05, 0.0}
608 }; 599 };
>> 600
>> 601
>> 602
>> 603
>> 604
>> 605
>> 606
>> 607
>> 608
>> 609
>> 610
>> 611
>> 612
>> 613
>> 614
>> 615
609 616