| 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 // $Id: G4eIonisationSpectrum.cc,v 1.25 2006/06/29 19:42:04 gunter Exp $
>> 27 // GEANT4 tag $Name: geant4-09-01 $
26 // 28 //
27 // ------------------------------------------- 29 // -------------------------------------------------------------------
28 // 30 //
29 // GEANT4 Class file 31 // GEANT4 Class file
30 // 32 //
31 // 33 //
32 // File name: G4eIonisationSpectrum 34 // File name: G4eIonisationSpectrum
33 // 35 //
34 // Author: V.Ivanchenko (Vladimir.Ivanc 36 // Author: V.Ivanchenko (Vladimir.Ivanchenko@cern.ch)
35 // << 37 //
36 // Creation date: 29 September 2001 38 // Creation date: 29 September 2001
37 // 39 //
38 // Modifications: << 40 // Modifications:
39 // 10.10.2001 MGP Revision to improv << 41 // 10.10.2001 MGP Revision to improve code quality and
40 // consistency with d 42 // consistency with design
41 // 02.11.2001 VI Optimize sampling << 43 // 02.11.2001 VI Optimize sampling of energy
42 // 29.11.2001 VI New parametrisatio << 44 // 29.11.2001 VI New parametrisation
43 // 19.04.2002 VI Add protection in << 45 // 19.04.2002 VI Add protection in case of energy below binding
44 // 30.05.2002 VI Update to 24-param 46 // 30.05.2002 VI Update to 24-parameters data
45 // 11.07.2002 VI Fix in integration 47 // 11.07.2002 VI Fix in integration over spectrum
46 // 23.03.2009 LP Added protection a <<
47 // faulty database fi <<
48 // 48 //
49 // ------------------------------------------- 49 // -------------------------------------------------------------------
50 // 50 //
51 51
52 #include "G4eIonisationSpectrum.hh" 52 #include "G4eIonisationSpectrum.hh"
53 #include "G4AtomicTransitionManager.hh" 53 #include "G4AtomicTransitionManager.hh"
54 #include "G4AtomicShell.hh" 54 #include "G4AtomicShell.hh"
55 #include "G4DataVector.hh" 55 #include "G4DataVector.hh"
56 #include "Randomize.hh" 56 #include "Randomize.hh"
57 #include "G4PhysicalConstants.hh" << 57
58 #include "G4SystemOfUnits.hh" <<
59 #include "G4Exp.hh" <<
60 58
61 G4eIonisationSpectrum::G4eIonisationSpectrum() 59 G4eIonisationSpectrum::G4eIonisationSpectrum():G4VEnergySpectrum(),
62 lowestE(0.1*eV), 60 lowestE(0.1*eV),
63 factor(1.3), 61 factor(1.3),
64 iMax(24), 62 iMax(24),
65 verbose(0) 63 verbose(0)
66 { 64 {
67 theParam = new G4eIonisationParameters(); 65 theParam = new G4eIonisationParameters();
68 } 66 }
69 67
70 68
71 G4eIonisationSpectrum::~G4eIonisationSpectrum( << 69 G4eIonisationSpectrum::~G4eIonisationSpectrum()
72 { 70 {
73 delete theParam; 71 delete theParam;
74 } 72 }
75 73
76 74
77 G4double G4eIonisationSpectrum::Probability(G4 << 75 G4double G4eIonisationSpectrum::Probability(G4int Z,
78 G4double tMin, << 76 G4double tMin,
79 G4double tMax, << 77 G4double tMax,
80 G4double e, 78 G4double e,
81 G4int shell, 79 G4int shell,
82 const G4ParticleDefinition* ) co 80 const G4ParticleDefinition* ) const
83 { 81 {
84 // Please comment what Probability does and << 82 // Please comment what Probability does and what are the three
85 // functions mentioned below 83 // functions mentioned below
86 // Describe the algorithms used 84 // Describe the algorithms used
87 85
88 G4double eMax = MaxEnergyOfSecondaries(e); 86 G4double eMax = MaxEnergyOfSecondaries(e);
89 G4double t0 = std::max(tMin, lowestE); 87 G4double t0 = std::max(tMin, lowestE);
90 G4double tm = std::min(tMax, eMax); 88 G4double tm = std::min(tMax, eMax);
91 if(t0 >= tm) return 0.0; 89 if(t0 >= tm) return 0.0;
92 90
93 G4double bindingEnergy = (G4AtomicTransition 91 G4double bindingEnergy = (G4AtomicTransitionManager::Instance())->
94 Shell(Z, shell)->Bi 92 Shell(Z, shell)->BindingEnergy();
95 93
96 if(e <= bindingEnergy) return 0.0; 94 if(e <= bindingEnergy) return 0.0;
97 95
98 G4double energy = e + bindingEnergy; 96 G4double energy = e + bindingEnergy;
99 97
100 G4double x1 = std::min(0.5,(t0 + bindingEner 98 G4double x1 = std::min(0.5,(t0 + bindingEnergy)/energy);
101 G4double x2 = std::min(0.5,(tm + bindingEner 99 G4double x2 = std::min(0.5,(tm + bindingEnergy)/energy);
102 100
103 if(verbose > 1 || (Z==4 && e>= 1.0 && e<= 0. 101 if(verbose > 1 || (Z==4 && e>= 1.0 && e<= 0.0)) {
104 G4cout << "G4eIonisationSpectrum::Probabil 102 G4cout << "G4eIonisationSpectrum::Probability: Z= " << Z
105 << "; shell= " << shell 103 << "; shell= " << shell
106 << "; E(keV)= " << e/keV 104 << "; E(keV)= " << e/keV
107 << "; Eb(keV)= " << bindingEnergy/k 105 << "; Eb(keV)= " << bindingEnergy/keV
108 << "; x1= " << x1 << 106 << "; x1= " << x1
109 << "; x2= " << x2 << 107 << "; x2= " << x2
110 << G4endl; 108 << G4endl;
111 << 109
112 } 110 }
113 111
114 G4DataVector p; 112 G4DataVector p;
115 113
116 // Access parameters 114 // Access parameters
117 for (G4int i=0; i<iMax; i++) << 115 for (G4int i=0; i<iMax; i++)
118 { 116 {
119 G4double x = theParam->Parameter(Z, shell, 117 G4double x = theParam->Parameter(Z, shell, i, e);
120 if(i<4) x /= energy; << 118 if(i<4) x /= energy;
121 p.push_back(x); << 119 p.push_back(x);
122 } 120 }
123 121
124 if(p[3] > 0.5) p[3] = 0.5; 122 if(p[3] > 0.5) p[3] = 0.5;
125 << 123
126 G4double gLocal = energy/electron_mass_c2 + << 124 G4double g = energy/electron_mass_c2 + 1.;
127 p.push_back((2.0*gLocal - 1.0)/(gLocal*gLoca << 125 p.push_back((2.0*g - 1.0)/(g*g));
128 << 126
129 //Add protection against division by zero: a << 127 p[iMax-1] = Function(p[3], p);
130 //parameter p[3] appears in the denominator. <<
131 if (p[3] > 0) <<
132 p[iMax-1] = Function(p[3], p); <<
133 else <<
134 { <<
135 G4cout << "WARNING: G4eIonisationSpectru <<
136 << "parameter p[3] <= 0. G4LEDATA dabat <<
137 << Z << ". Please check and/or update i <<
138 } <<
139 128
140 if(e >= 1. && e <= 0. && Z == 4) p.push_back 129 if(e >= 1. && e <= 0. && Z == 4) p.push_back(0.0);
141 130
142 << 131
143 G4double val = IntSpectrum(x1, x2, p); 132 G4double val = IntSpectrum(x1, x2, p);
144 G4double x0 = (lowestE + bindingEnergy)/ene 133 G4double x0 = (lowestE + bindingEnergy)/energy;
145 G4double nor = IntSpectrum(x0, 0.5, p); 134 G4double nor = IntSpectrum(x0, 0.5, p);
146 << 135
147 if(verbose > 1 || (Z==4 && e>= 1.0 && e<= 0. 136 if(verbose > 1 || (Z==4 && e>= 1.0 && e<= 0.0)) {
148 G4cout << "tcut= " << tMin << 137 G4cout << "tcut= " << tMin
149 << "; tMax= " << tMax << 138 << "; tMax= " << tMax
150 << "; x0= " << x0 << 139 << "; x0= " << x0
151 << "; x1= " << x1 << 140 << "; x1= " << x1
152 << "; x2= " << x2 << 141 << "; x2= " << x2
153 << "; val= " << val << 142 << "; val= " << val
154 << "; nor= " << nor << 143 << "; nor= " << nor
155 << "; sum= " << p[0] << 144 << "; sum= " << p[0]
156 << "; a= " << p[1] << 145 << "; a= " << p[1]
157 << "; b= " << p[2] << 146 << "; b= " << p[2]
158 << "; c= " << p[3] << 147 << "; c= " << p[3]
159 << G4endl; 148 << G4endl;
160 if(shell == 1) G4cout << "============" << << 149 if(shell == 1) G4cout << "============" << G4endl;
161 } 150 }
162 151
163 p.clear(); 152 p.clear();
164 153
165 if(nor > 0.0) val /= nor; 154 if(nor > 0.0) val /= nor;
166 else val = 0.0; 155 else val = 0.0;
167 156
168 return val; << 157 return val;
169 } 158 }
170 159
171 160
172 G4double G4eIonisationSpectrum::AverageEnergy( 161 G4double G4eIonisationSpectrum::AverageEnergy(G4int Z,
173 G4double tMin, << 162 G4double tMin,
174 G4double tMax, << 163 G4double tMax,
175 G4double e, 164 G4double e,
176 G4int shell, 165 G4int shell,
177 const G4ParticleDefinition* ) 166 const G4ParticleDefinition* ) const
178 { 167 {
179 // Please comment what AverageEnergy does an << 168 // Please comment what AverageEnergy does and what are the three
180 // functions mentioned below 169 // functions mentioned below
181 // Describe the algorithms used 170 // Describe the algorithms used
182 171
183 G4double eMax = MaxEnergyOfSecondaries(e); 172 G4double eMax = MaxEnergyOfSecondaries(e);
184 G4double t0 = std::max(tMin, lowestE); 173 G4double t0 = std::max(tMin, lowestE);
185 G4double tm = std::min(tMax, eMax); 174 G4double tm = std::min(tMax, eMax);
186 if(t0 >= tm) return 0.0; 175 if(t0 >= tm) return 0.0;
187 176
188 G4double bindingEnergy = (G4AtomicTransition 177 G4double bindingEnergy = (G4AtomicTransitionManager::Instance())->
189 Shell(Z, shell)->Bi 178 Shell(Z, shell)->BindingEnergy();
190 179
191 if(e <= bindingEnergy) return 0.0; 180 if(e <= bindingEnergy) return 0.0;
192 181
193 G4double energy = e + bindingEnergy; 182 G4double energy = e + bindingEnergy;
194 183
195 G4double x1 = std::min(0.5,(t0 + bindingEner 184 G4double x1 = std::min(0.5,(t0 + bindingEnergy)/energy);
196 G4double x2 = std::min(0.5,(tm + bindingEner 185 G4double x2 = std::min(0.5,(tm + bindingEnergy)/energy);
197 186
198 if(verbose > 1) { 187 if(verbose > 1) {
199 G4cout << "G4eIonisationSpectrum::AverageE 188 G4cout << "G4eIonisationSpectrum::AverageEnergy: Z= " << Z
200 << "; shell= " << shell 189 << "; shell= " << shell
201 << "; E(keV)= " << e/keV 190 << "; E(keV)= " << e/keV
202 << "; bindingE(keV)= " << bindingEn 191 << "; bindingE(keV)= " << bindingEnergy/keV
203 << "; x1= " << x1 << 192 << "; x1= " << x1
204 << "; x2= " << x2 << 193 << "; x2= " << x2
205 << G4endl; 194 << G4endl;
206 } 195 }
207 196
208 G4DataVector p; 197 G4DataVector p;
209 198
210 // Access parameters 199 // Access parameters
211 for (G4int i=0; i<iMax; i++) << 200 for (G4int i=0; i<iMax; i++)
212 { 201 {
213 G4double x = theParam->Parameter(Z, shell, 202 G4double x = theParam->Parameter(Z, shell, i, e);
214 if(i<4) x /= energy; << 203 if(i<4) x /= energy;
215 p.push_back(x); 204 p.push_back(x);
216 } 205 }
217 206
218 if(p[3] > 0.5) p[3] = 0.5; 207 if(p[3] > 0.5) p[3] = 0.5;
219 208
220 G4double gLocal2 = energy/electron_mass_c2 + << 209 G4double g = energy/electron_mass_c2 + 1.;
221 p.push_back((2.0*gLocal2 - 1.0)/(gLocal2*gLo << 210 p.push_back((2.0*g - 1.0)/(g*g));
222 <<
223 <<
224 //Add protection against division by zero: a <<
225 //parameter p[3] appears in the denominator. <<
226 if (p[3] > 0) <<
227 p[iMax-1] = Function(p[3], p); <<
228 else <<
229 { <<
230 G4cout << "WARNING: G4eIonisationSpectru <<
231 << "parameter p[3] <= 0. G4LEDATA dabat <<
232 << Z << ". Please check and/or update i <<
233 } <<
234 211
>> 212 p[iMax-1] = Function(p[3], p);
>> 213
235 G4double val = AverageValue(x1, x2, p); 214 G4double val = AverageValue(x1, x2, p);
236 G4double x0 = (lowestE + bindingEnergy)/ene 215 G4double x0 = (lowestE + bindingEnergy)/energy;
237 G4double nor = IntSpectrum(x0, 0.5, p); 216 G4double nor = IntSpectrum(x0, 0.5, p);
238 val *= energy; 217 val *= energy;
239 218
240 if(verbose > 1) { 219 if(verbose > 1) {
241 G4cout << "tcut(MeV)= " << tMin/MeV << 220 G4cout << "tcut(MeV)= " << tMin/MeV
242 << "; tMax(MeV)= " << tMax/MeV << 221 << "; tMax(MeV)= " << tMax/MeV
243 << "; x0= " << x0 << 222 << "; x0= " << x0
244 << "; x1= " << x1 << 223 << "; x1= " << x1
245 << "; x2= " << x2 << 224 << "; x2= " << x2
246 << "; val= " << val << 225 << "; val= " << val
247 << "; nor= " << nor << 226 << "; nor= " << nor
248 << "; sum= " << p[0] << 227 << "; sum= " << p[0]
249 << "; a= " << p[1] << 228 << "; a= " << p[1]
250 << "; b= " << p[2] << 229 << "; b= " << p[2]
251 << "; c= " << p[3] << 230 << "; c= " << p[3]
252 << G4endl; 231 << G4endl;
253 } 232 }
254 233
255 p.clear(); 234 p.clear();
256 235
257 if(nor > 0.0) val /= nor; 236 if(nor > 0.0) val /= nor;
258 else val = 0.0; 237 else val = 0.0;
259 238
260 return val; << 239 return val;
261 } 240 }
262 241
263 242
264 G4double G4eIonisationSpectrum::SampleEnergy(G 243 G4double G4eIonisationSpectrum::SampleEnergy(G4int Z,
265 G4double tMin, << 244 G4double tMin,
266 G4double tMax, << 245 G4double tMax,
267 G4double e, 246 G4double e,
268 G4int shell, 247 G4int shell,
269 const G4ParticleDefinition* ) c 248 const G4ParticleDefinition* ) const
270 { 249 {
271 // Please comment what SampleEnergy does 250 // Please comment what SampleEnergy does
272 G4double tDelta = 0.0; 251 G4double tDelta = 0.0;
273 G4double t0 = std::max(tMin, lowestE); 252 G4double t0 = std::max(tMin, lowestE);
274 G4double tm = std::min(tMax, MaxEnergyOfSeco 253 G4double tm = std::min(tMax, MaxEnergyOfSecondaries(e));
275 if(t0 > tm) return tDelta; 254 if(t0 > tm) return tDelta;
276 255
277 G4double bindingEnergy = (G4AtomicTransition 256 G4double bindingEnergy = (G4AtomicTransitionManager::Instance())->
278 Shell(Z, shell)->Bi 257 Shell(Z, shell)->BindingEnergy();
279 258
280 if(e <= bindingEnergy) return 0.0; 259 if(e <= bindingEnergy) return 0.0;
281 260
282 G4double energy = e + bindingEnergy; 261 G4double energy = e + bindingEnergy;
283 262
284 G4double x1 = std::min(0.5,(t0 + bindingEner 263 G4double x1 = std::min(0.5,(t0 + bindingEnergy)/energy);
285 G4double x2 = std::min(0.5,(tm + bindingEner 264 G4double x2 = std::min(0.5,(tm + bindingEnergy)/energy);
286 if(x1 >= x2) return tDelta; 265 if(x1 >= x2) return tDelta;
287 266
288 if(verbose > 1) { 267 if(verbose > 1) {
289 G4cout << "G4eIonisationSpectrum::SampleEn 268 G4cout << "G4eIonisationSpectrum::SampleEnergy: Z= " << Z
290 << "; shell= " << shell 269 << "; shell= " << shell
291 << "; E(keV)= " << e/keV 270 << "; E(keV)= " << e/keV
292 << G4endl; 271 << G4endl;
293 } 272 }
294 273
295 // Access parameters 274 // Access parameters
296 G4DataVector p; 275 G4DataVector p;
297 276
298 // Access parameters 277 // Access parameters
299 for (G4int i=0; i<iMax; i++) << 278 for (G4int i=0; i<iMax; i++)
300 { 279 {
301 G4double x = theParam->Parameter(Z, shell, 280 G4double x = theParam->Parameter(Z, shell, i, e);
302 if(i<4) x /= energy; << 281 if(i<4) x /= energy;
303 p.push_back(x); 282 p.push_back(x);
304 } 283 }
305 284
306 if(p[3] > 0.5) p[3] = 0.5; 285 if(p[3] > 0.5) p[3] = 0.5;
307 286
308 G4double gLocal3 = energy/electron_mass_c2 + << 287 G4double g = energy/electron_mass_c2 + 1.;
309 p.push_back((2.0*gLocal3 - 1.0)/(gLocal3*gLo << 288 p.push_back((2.0*g - 1.0)/(g*g));
310 289
311 << 290 p[iMax-1] = Function(p[3], p);
312 //Add protection against division by zero: a <<
313 //parameter p[3] appears in the denominator. <<
314 if (p[3] > 0) <<
315 p[iMax-1] = Function(p[3], p); <<
316 else <<
317 { <<
318 G4cout << "WARNING: G4eIonisationSpectru <<
319 << "parameter p[3] <= 0. G4LEDATA dabat <<
320 << Z << ". Please check and/or update i <<
321 } <<
322 291
323 G4double aria1 = 0.0; 292 G4double aria1 = 0.0;
324 G4double a1 = std::max(x1,p[1]); 293 G4double a1 = std::max(x1,p[1]);
325 G4double a2 = std::min(x2,p[3]); 294 G4double a2 = std::min(x2,p[3]);
326 if(a1 < a2) aria1 = IntSpectrum(a1, a2, p); 295 if(a1 < a2) aria1 = IntSpectrum(a1, a2, p);
327 G4double aria2 = 0.0; 296 G4double aria2 = 0.0;
328 G4double a3 = std::max(x1,p[3]); 297 G4double a3 = std::max(x1,p[3]);
329 G4double a4 = x2; 298 G4double a4 = x2;
330 if(a3 < a4) aria2 = IntSpectrum(a3, a4, p); 299 if(a3 < a4) aria2 = IntSpectrum(a3, a4, p);
331 300
332 G4double aria = (aria1 + aria2)*G4UniformRan 301 G4double aria = (aria1 + aria2)*G4UniformRand();
333 G4double amaj, fun, q, x, z1, z2, dx, dx1; 302 G4double amaj, fun, q, x, z1, z2, dx, dx1;
334 303
335 //======= First aria to sample ===== 304 //======= First aria to sample =====
336 305
337 if(aria <= aria1) { << 306 if(aria <= aria1) {
338 307
339 amaj = p[4]; 308 amaj = p[4];
340 for (G4int j=5; j<iMax; j++) { 309 for (G4int j=5; j<iMax; j++) {
341 if(p[j] > amaj) amaj = p[j]; 310 if(p[j] > amaj) amaj = p[j];
342 } 311 }
343 312
344 a1 = 1./a1; 313 a1 = 1./a1;
345 a2 = 1./a2; 314 a2 = 1./a2;
346 315
347 G4int i; 316 G4int i;
348 do { 317 do {
349 318
350 x = 1./(a2 + G4UniformRand()*(a1 - a2)); 319 x = 1./(a2 + G4UniformRand()*(a1 - a2));
351 z1 = p[1]; 320 z1 = p[1];
352 z2 = p[3]; 321 z2 = p[3];
353 dx = (p[2] - p[1]) / 3.0; 322 dx = (p[2] - p[1]) / 3.0;
354 dx1= G4Exp(std::log(p[3]/p[2]) / 16.0); << 323 dx1= std::exp(std::log(p[3]/p[2]) / 16.0);
355 for (i=4; i<iMax-1; i++) { 324 for (i=4; i<iMax-1; i++) {
356 325
357 if (i < 7) { 326 if (i < 7) {
358 z2 = z1 + dx; 327 z2 = z1 + dx;
359 } else if(iMax-2 == i) { 328 } else if(iMax-2 == i) {
360 z2 = p[3]; 329 z2 = p[3];
361 break; 330 break;
362 } else { 331 } else {
363 z2 = z1*dx1; 332 z2 = z1*dx1;
364 } 333 }
365 if(x >= z1 && x <= z2) break; 334 if(x >= z1 && x <= z2) break;
366 z1 = z2; 335 z1 = z2;
367 } 336 }
368 fun = p[i] + (x - z1) * (p[i+1] - p[i])/ 337 fun = p[i] + (x - z1) * (p[i+1] - p[i])/(z2 - z1);
369 338
370 if(fun > amaj) { 339 if(fun > amaj) {
371 G4cout << "WARNING in G4eIonisationS << 340 G4cout << "WARNING in G4eIonisationSpectrum::SampleEnergy:"
372 << " Majoranta " << amaj << 341 << " Majoranta " << amaj
373 << " < " << fun 342 << " < " << fun
374 << " in the first aria at x= 343 << " in the first aria at x= " << x
375 << G4endl; 344 << G4endl;
376 } 345 }
377 346
378 q = amaj*G4UniformRand(); 347 q = amaj*G4UniformRand();
379 348
380 } while (q >= fun); 349 } while (q >= fun);
381 350
382 //======= Second aria to sample ===== 351 //======= Second aria to sample =====
383 352
384 } else { 353 } else {
385 354
386 amaj = std::max(p[iMax-1], Function(0.5, p 355 amaj = std::max(p[iMax-1], Function(0.5, p)) * factor;
387 a1 = 1./a3; 356 a1 = 1./a3;
388 a2 = 1./a4; 357 a2 = 1./a4;
389 358
390 do { 359 do {
391 360
392 x = 1./(a2 + G4UniformRand()*(a1 - a2)); 361 x = 1./(a2 + G4UniformRand()*(a1 - a2));
393 fun = Function(x, p); 362 fun = Function(x, p);
394 363
395 if(fun > amaj) { 364 if(fun > amaj) {
396 G4cout << "WARNING in G4eIonisationS << 365 G4cout << "WARNING in G4eIonisationSpectrum::SampleEnergy:"
397 << " Majoranta " << amaj << 366 << " Majoranta " << amaj
398 << " < " << fun 367 << " < " << fun
399 << " in the second aria at x= 368 << " in the second aria at x= " << x
400 << G4endl; 369 << G4endl;
401 } 370 }
402 371
403 q = amaj*G4UniformRand(); 372 q = amaj*G4UniformRand();
404 373
405 } while (q >= fun); 374 } while (q >= fun);
406 375
407 } 376 }
408 377
409 p.clear(); 378 p.clear();
410 379
411 tDelta = x*energy - bindingEnergy; 380 tDelta = x*energy - bindingEnergy;
412 381
413 if(verbose > 1) { 382 if(verbose > 1) {
414 G4cout << "tcut(MeV)= " << tMin/MeV << 383 G4cout << "tcut(MeV)= " << tMin/MeV
415 << "; tMax(MeV)= " << tMax/MeV << 384 << "; tMax(MeV)= " << tMax/MeV
416 << "; x1= " << x1 << 385 << "; x1= " << x1
417 << "; x2= " << x2 << 386 << "; x2= " << x2
418 << "; a1= " << a1 << 387 << "; a1= " << a1
419 << "; a2= " << a2 << 388 << "; a2= " << a2
420 << "; x= " << x << 389 << "; x= " << x
421 << "; be= " << bindingEnergy << 390 << "; be= " << bindingEnergy
422 << "; e= " << e << 391 << "; e= " << e
423 << "; tDelta= " << tDelta << 392 << "; tDelta= " << tDelta
424 << G4endl; 393 << G4endl;
425 } 394 }
426 395
427 396
428 return tDelta; << 397 return tDelta;
429 } 398 }
430 399
431 400
432 G4double G4eIonisationSpectrum::IntSpectrum(G4 << 401 G4double G4eIonisationSpectrum::IntSpectrum(G4double xMin,
433 G4double xMax, 402 G4double xMax,
434 const G4DataVector& p) const 403 const G4DataVector& p) const
435 { 404 {
436 // Please comment what IntSpectrum does 405 // Please comment what IntSpectrum does
437 G4double sum = 0.0; 406 G4double sum = 0.0;
438 if(xMin >= xMax) return sum; 407 if(xMin >= xMax) return sum;
439 408
440 G4double x1, x2, xs1, xs2, y1, y2, ys1, ys2, 409 G4double x1, x2, xs1, xs2, y1, y2, ys1, ys2, q;
441 410
442 // Integral over interpolation aria 411 // Integral over interpolation aria
443 if(xMin < p[3]) { 412 if(xMin < p[3]) {
444 413
445 x1 = p[1]; 414 x1 = p[1];
446 y1 = p[4]; 415 y1 = p[4];
447 416
448 G4double dx = (p[2] - p[1]) / 3.0; 417 G4double dx = (p[2] - p[1]) / 3.0;
449 G4double dx1= G4Exp(std::log(p[3]/p[2]) / << 418 G4double dx1= std::exp(std::log(p[3]/p[2]) / 16.0);
450 419
451 for (size_t i=0; i<19; i++) { 420 for (size_t i=0; i<19; i++) {
452 421
453 q = 0.0; 422 q = 0.0;
454 if (i < 3) { 423 if (i < 3) {
455 x2 = x1 + dx; 424 x2 = x1 + dx;
456 } else if(18 == i) { 425 } else if(18 == i) {
457 x2 = p[3]; 426 x2 = p[3];
458 } else { 427 } else {
459 x2 = x1*dx1; 428 x2 = x1*dx1;
460 } 429 }
461 430
462 y2 = p[5 + i]; 431 y2 = p[5 + i];
463 432
464 if (xMax <= x1) { 433 if (xMax <= x1) {
465 break; 434 break;
466 } else if (xMin < x2) { 435 } else if (xMin < x2) {
467 436
468 xs1 = x1; 437 xs1 = x1;
469 xs2 = x2; 438 xs2 = x2;
470 ys1 = y1; 439 ys1 = y1;
471 ys2 = y2; 440 ys2 = y2;
472 441
473 if (x2 > x1) { 442 if (x2 > x1) {
474 if (xMin > x1) { 443 if (xMin > x1) {
475 xs1 = xMin; 444 xs1 = xMin;
476 ys1 += (xs1 - x1)*(y2 - y1)/(x2 - 445 ys1 += (xs1 - x1)*(y2 - y1)/(x2 - x1);
477 } << 446 }
478 if (xMax < x2) { 447 if (xMax < x2) {
479 xs2 = xMax; 448 xs2 = xMax;
480 ys2 += (xs2 - x2)*(y1 - y2)/(x1 - 449 ys2 += (xs2 - x2)*(y1 - y2)/(x1 - x2);
481 } << 450 }
482 if (xs2 > xs1) { 451 if (xs2 > xs1) {
483 q = (ys1*xs2 - ys2*xs1)/(xs1*xs2) << 452 q = (ys1*xs2 - ys2*xs1)/(xs1*xs2)
484 + std::log(xs2/xs1)*(ys2 - ys1) 453 + std::log(xs2/xs1)*(ys2 - ys1)/(xs2 - xs1);
485 sum += q; 454 sum += q;
486 if(p.size() == 26) G4cout << "i= " 455 if(p.size() == 26) G4cout << "i= " << i << " q= " << q << " sum= " << sum << G4endl;
487 } 456 }
488 } << 457 }
489 } 458 }
490 x1 = x2; 459 x1 = x2;
491 y1 = y2; 460 y1 = y2;
492 } 461 }
493 } 462 }
494 463
495 // Integral over aria with parametrised form << 464 // Integral over aria with parametrised formula
496 465
497 x1 = std::max(xMin, p[3]); 466 x1 = std::max(xMin, p[3]);
498 if(x1 >= xMax) return sum; 467 if(x1 >= xMax) return sum;
499 x2 = xMax; 468 x2 = xMax;
500 469
501 xs1 = 1./x1; 470 xs1 = 1./x1;
502 xs2 = 1./x2; 471 xs2 = 1./x2;
503 q = (xs1 - xs2)*(1.0 - p[0]) << 472 q = (xs1 - xs2)*(1.0 - p[0])
504 - p[iMax]*std::log(x2/x1) << 473 - p[iMax]*std::log(x2/x1)
505 + (1. - p[iMax])*(x2 - x1) 474 + (1. - p[iMax])*(x2 - x1)
506 + 1./(1. - x2) - 1./(1. - x1) << 475 + 1./(1. - x2) - 1./(1. - x1)
507 + p[iMax]*std::log((1. - x2)/(1. - x1)) 476 + p[iMax]*std::log((1. - x2)/(1. - x1))
508 + 0.25*p[0]*(xs1*xs1 - xs2*xs2); 477 + 0.25*p[0]*(xs1*xs1 - xs2*xs2);
509 sum += q; 478 sum += q;
510 if(p.size() == 26) G4cout << "param... q= " 479 if(p.size() == 26) G4cout << "param... q= " << q << " sum= " << sum << G4endl;
511 480
512 return sum; 481 return sum;
513 } << 482 }
514 483
515 484
516 G4double G4eIonisationSpectrum::AverageValue(G << 485 G4double G4eIonisationSpectrum::AverageValue(G4double xMin,
517 G4double xMax, 486 G4double xMax,
518 const G4DataVector& p) const 487 const G4DataVector& p) const
519 { 488 {
520 G4double sum = 0.0; 489 G4double sum = 0.0;
521 if(xMin >= xMax) return sum; 490 if(xMin >= xMax) return sum;
522 491
523 G4double x1, x2, xs1, xs2, y1, y2, ys1, ys2; 492 G4double x1, x2, xs1, xs2, y1, y2, ys1, ys2;
524 493
525 // Integral over interpolation aria 494 // Integral over interpolation aria
526 if(xMin < p[3]) { 495 if(xMin < p[3]) {
527 496
528 x1 = p[1]; 497 x1 = p[1];
529 y1 = p[4]; 498 y1 = p[4];
530 499
531 G4double dx = (p[2] - p[1]) / 3.0; 500 G4double dx = (p[2] - p[1]) / 3.0;
532 G4double dx1= G4Exp(std::log(p[3]/p[2]) / << 501 G4double dx1= std::exp(std::log(p[3]/p[2]) / 16.0);
533 502
534 for (size_t i=0; i<19; i++) { 503 for (size_t i=0; i<19; i++) {
535 504
536 if (i < 3) { 505 if (i < 3) {
537 x2 = x1 + dx; 506 x2 = x1 + dx;
538 } else if(18 == i) { 507 } else if(18 == i) {
539 x2 = p[3]; 508 x2 = p[3];
540 } else { 509 } else {
541 x2 = x1*dx1; 510 x2 = x1*dx1;
542 } 511 }
543 512
544 y2 = p[5 + i]; 513 y2 = p[5 + i];
545 514
546 if (xMax <= x1) { 515 if (xMax <= x1) {
547 break; 516 break;
548 } else if (xMin < x2) { 517 } else if (xMin < x2) {
549 518
550 xs1 = x1; 519 xs1 = x1;
551 xs2 = x2; 520 xs2 = x2;
552 ys1 = y1; 521 ys1 = y1;
553 ys2 = y2; 522 ys2 = y2;
554 523
555 if (x2 > x1) { 524 if (x2 > x1) {
556 if (xMin > x1) { 525 if (xMin > x1) {
557 xs1 = xMin; 526 xs1 = xMin;
558 ys1 += (xs1 - x1)*(y2 - y1)/(x2 - 527 ys1 += (xs1 - x1)*(y2 - y1)/(x2 - x1);
559 } << 528 }
560 if (xMax < x2) { 529 if (xMax < x2) {
561 xs2 = xMax; 530 xs2 = xMax;
562 ys2 += (xs2 - x2)*(y1 - y2)/(x1 - 531 ys2 += (xs2 - x2)*(y1 - y2)/(x1 - x2);
563 } << 532 }
564 if (xs2 > xs1) { 533 if (xs2 > xs1) {
565 sum += std::log(xs2/xs1)*(ys1*xs2 << 534 sum += std::log(xs2/xs1)*(ys1*xs2 - ys2*xs1)/(xs2 - xs1)
566 + ys2 - ys1; 535 + ys2 - ys1;
567 } 536 }
568 } << 537 }
569 } 538 }
570 x1 = x2; 539 x1 = x2;
571 y1 = y2; 540 y1 = y2;
572 541
573 } 542 }
574 } 543 }
575 544
576 // Integral over aria with parametrised form << 545 // Integral over aria with parametrised formula
577 546
578 x1 = std::max(xMin, p[3]); 547 x1 = std::max(xMin, p[3]);
579 if(x1 >= xMax) return sum; 548 if(x1 >= xMax) return sum;
580 x2 = xMax; 549 x2 = xMax;
581 550
582 xs1 = 1./x1; 551 xs1 = 1./x1;
583 xs2 = 1./x2; 552 xs2 = 1./x2;
584 553
585 sum += std::log(x2/x1)*(1.0 - p[0]) << 554 sum += std::log(x2/x1)*(1.0 - p[0])
586 + 0.5*(1. - p[iMax])*(x2*x2 - x1*x1) 555 + 0.5*(1. - p[iMax])*(x2*x2 - x1*x1)
587 + 1./(1. - x2) - 1./(1. - x1) << 556 + 1./(1. - x2) - 1./(1. - x1)
588 + (1. + p[iMax])*std::log((1. - x2)/(1 557 + (1. + p[iMax])*std::log((1. - x2)/(1. - x1))
589 + 0.5*p[0]*(xs1 - xs2); 558 + 0.5*p[0]*(xs1 - xs2);
590 559
591 return sum; 560 return sum;
592 } << 561 }
593 562
594 563
595 void G4eIonisationSpectrum::PrintData() const << 564 void G4eIonisationSpectrum::PrintData() const
596 { 565 {
597 theParam->PrintData(); 566 theParam->PrintData();
598 } 567 }
599 568
600 G4double G4eIonisationSpectrum::MaxEnergyOfSec 569 G4double G4eIonisationSpectrum::MaxEnergyOfSecondaries(G4double kineticEnergy,
601 G4int, // Z = 0, 570 G4int, // Z = 0,
602 const G4ParticleDefinition* 571 const G4ParticleDefinition* ) const
603 { 572 {
604 return 0.5 * kineticEnergy; 573 return 0.5 * kineticEnergy;
605 } 574 }
606 575