| 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: G4EmParameters.cc 69320 2013-04-30 15:59:36Z vnivanch $
>> 27 //
26 // ------------------------------------------- 28 // -------------------------------------------------------------------
27 // 29 //
28 // GEANT4 Class file 30 // GEANT4 Class file
29 // 31 //
>> 32 //
30 // File name: G4EmParameters 33 // File name: G4EmParameters
31 // 34 //
32 // Author: Vladimir Ivanchenko 35 // Author: Vladimir Ivanchenko
33 // 36 //
34 // Creation date: 18.05.2013 37 // Creation date: 18.05.2013
35 // 38 //
36 // Modifications: 39 // Modifications:
37 // 40 //
>> 41 //
>> 42 //
38 // ------------------------------------------- 43 // -------------------------------------------------------------------
39 // 44 //
40 //....oooOO0OOooo........oooOO0OOooo........oo 45 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
41 //....oooOO0OOooo........oooOO0OOooo........oo 46 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
42 47
43 #include "G4EmParameters.hh" 48 #include "G4EmParameters.hh"
44 #include "G4PhysicalConstants.hh" 49 #include "G4PhysicalConstants.hh"
45 #include "G4UnitsTable.hh" <<
46 #include "G4SystemOfUnits.hh" 50 #include "G4SystemOfUnits.hh"
47 #include "G4VEmProcess.hh" <<
48 #include "G4VEnergyLossProcess.hh" <<
49 #include "G4VAtomDeexcitation.hh" <<
50 #include "G4EmExtraParameters.hh" <<
51 #include "G4EmLowEParameters.hh" <<
52 #include "G4EmParametersMessenger.hh" 51 #include "G4EmParametersMessenger.hh"
53 #include "G4NistManager.hh" 52 #include "G4NistManager.hh"
54 #include "G4RegionStore.hh" <<
55 #include "G4Region.hh" <<
56 #include "G4ApplicationState.hh" <<
57 #include "G4StateManager.hh" <<
58 #include "G4Threading.hh" <<
59 #include "G4AutoLock.hh" <<
60 <<
61 G4EmParameters* G4EmParameters::theInstance = <<
62 53
63 namespace << 54 G4EmParameters* G4EmParameters::theInstance = 0;
64 { <<
65 G4Mutex emParametersMutex = G4MUTEX_INITIALI <<
66 } <<
67 55
68 //....oooOO0OOooo........oooOO0OOooo........oo 56 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
69 57
70 G4EmParameters* G4EmParameters::Instance() 58 G4EmParameters* G4EmParameters::Instance()
71 { 59 {
72 if(nullptr == theInstance) { << 60 if(0 == theInstance) {
73 G4AutoLock l(&emParametersMutex); << 61 static G4EmParameters manager;
74 if(nullptr == theInstance) { << 62 theInstance = &manager;
75 static G4EmParameters manager; <<
76 theInstance = &manager; <<
77 } <<
78 l.unlock(); <<
79 } 63 }
80 return theInstance; 64 return theInstance;
81 } 65 }
82 66
83 //....oooOO0OOooo........oooOO0OOooo........oo 67 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
84 68
85 G4EmParameters::~G4EmParameters() 69 G4EmParameters::~G4EmParameters()
86 { 70 {
87 delete theMessenger; 71 delete theMessenger;
88 delete fBParameters; <<
89 delete fCParameters; <<
90 delete emSaturation; <<
91 } 72 }
92 73
93 //....oooOO0OOooo........oooOO0OOooo........oo 74 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
94 75
95 G4EmParameters::G4EmParameters() 76 G4EmParameters::G4EmParameters()
96 { 77 {
97 G4NistManager::Instance(); 78 G4NistManager::Instance();
98 theMessenger = new G4EmParametersMessenger(t 79 theMessenger = new G4EmParametersMessenger(this);
99 Initialise(); <<
100 <<
101 fBParameters = new G4EmExtraParameters(); <<
102 fCParameters = new G4EmLowEParameters(); <<
103 <<
104 fStateManager = G4StateManager::GetStateMana <<
105 emSaturation = nullptr; <<
106 } <<
107 <<
108 void G4EmParameters::SetDefaults() <<
109 { <<
110 if(!IsLocked()) { <<
111 Initialise(); <<
112 fBParameters->Initialise(); <<
113 fCParameters->Initialise(); <<
114 } <<
115 } <<
116 80
117 void G4EmParameters::Initialise() <<
118 { <<
119 lossFluctuation = true; 81 lossFluctuation = true;
120 buildCSDARange = false; 82 buildCSDARange = false;
121 flagLPM = true; 83 flagLPM = true;
122 cutAsFinalRange = false; << 84 spline = true;
>> 85 finalRange = false;
123 applyCuts = false; 86 applyCuts = false;
>> 87 fluo = false;
>> 88 auger = false;
>> 89 pixe = false;
>> 90 deexIgnoreCut = false;
124 lateralDisplacement = true; 91 lateralDisplacement = true;
125 lateralDisplacementAlg96 = true; << 92 muhadLateralDisplacement = true;
126 muhadLateralDisplacement = false; << 93 latDisplacementBeyondSafety = false;
127 useAngGeneratorForIonisation = false; 94 useAngGeneratorForIonisation = false;
128 useMottCorrection = false; << 95
129 integral = true; << 96 minSubRange = DBL_MAX;
130 birks = false; << 97 minKinEnergy = 0.1*keV;
131 fICRU90 = false; << 98 maxKinEnergy = 10.0*TeV;
132 gener = false; << 99 maxKinEnergyCSDA = 1.0*GeV;
133 onIsolated = false; <<
134 fSamplingTable = false; <<
135 fPolarisation = false; <<
136 fMuDataFromFile = false; <<
137 fPEKShell = true; <<
138 fMscPosiCorr = true; <<
139 fUseEPICS2017XS = false; <<
140 f3GammaAnnihilationOnFly = false; <<
141 fUseRiGePairProductionModel = false; <<
142 fDNA = false; <<
143 fIsPrinted = false; <<
144 <<
145 minKinEnergy = 0.1*CLHEP::keV; <<
146 maxKinEnergy = 100.0*CLHEP::TeV; <<
147 maxKinEnergyCSDA = 1.0*CLHEP::GeV; <<
148 max5DEnergyForMuPair = 0.0; <<
149 lowestElectronEnergy = 1.0*CLHEP::keV; <<
150 lowestMuHadEnergy = 1.0*CLHEP::keV; <<
151 lowestTripletEnergy = 1.0*CLHEP::MeV; <<
152 maxNIELEnergy = 0.0; <<
153 linLossLimit = 0.01; 100 linLossLimit = 0.01;
154 bremsTh = bremsMuHadTh = maxKinEnergy; << 101 bremsTh = DBL_MAX;
155 lambdaFactor = 0.8; 102 lambdaFactor = 0.8;
156 factorForAngleLimit = 1.0; 103 factorForAngleLimit = 1.0;
157 thetaLimit = CLHEP::pi; 104 thetaLimit = CLHEP::pi;
158 energyLimit = 100.0*CLHEP::MeV; <<
159 rangeFactor = 0.04; 105 rangeFactor = 0.04;
160 rangeFactorMuHad = 0.2; <<
161 geomFactor = 2.5; 106 geomFactor = 2.5;
162 skin = 1.0; 107 skin = 1.0;
163 safetyFactor = 0.6; <<
164 lambdaLimit = 1.0*CLHEP::mm; <<
165 factorScreen = 1.0; <<
166 108
>> 109 nbins = 77;
167 nbinsPerDecade = 7; 110 nbinsPerDecade = 7;
168 verbose = 1; 111 verbose = 1;
169 workerVerbose = 0; 112 workerVerbose = 0;
170 nForFreeVector = 2; <<
171 tripletConv = 0; <<
172 113
173 fTransportationWithMsc = G4TransportationWit <<
174 mscStepLimit = fUseSafety; 114 mscStepLimit = fUseSafety;
175 mscStepLimitMuHad = fMinimal; <<
176 nucFormfactor = fExponentialNF; <<
177 fSStype = fWVI; <<
178 fFluct = fUniversalFluctuation; <<
179 fPositronium = fSimplePositronium; <<
180 <<
181 const char* data_dir = G4FindDataDir("G4LEDA <<
182 if (nullptr != data_dir) { <<
183 fDirLEDATA = G4String(data_dir); <<
184 } <<
185 else { <<
186 G4Exception("G4EmParameters::Initialise()" <<
187 "G4LEDATA data directory was n <<
188 } <<
189 } 115 }
190 116
>> 117 #include "G4AutoLock.hh"
>> 118 namespace { G4Mutex EmParametersMutex = G4MUTEX_INITIALIZER; }
>> 119
191 void G4EmParameters::SetLossFluctuations(G4boo 120 void G4EmParameters::SetLossFluctuations(G4bool val)
192 { 121 {
193 if(IsLocked()) { return; } << 122 G4AutoLock l(&EmParametersMutex);
194 lossFluctuation = val; 123 lossFluctuation = val;
195 } 124 }
196 125
197 G4bool G4EmParameters::LossFluctuation() const 126 G4bool G4EmParameters::LossFluctuation() const
198 { 127 {
199 return lossFluctuation; 128 return lossFluctuation;
200 } 129 }
201 130
202 void G4EmParameters::SetBuildCSDARange(G4bool 131 void G4EmParameters::SetBuildCSDARange(G4bool val)
203 { 132 {
204 if(IsLocked()) { return; } << 133 G4AutoLock l(&EmParametersMutex);
205 buildCSDARange = val; 134 buildCSDARange = val;
206 } 135 }
207 136
208 G4bool G4EmParameters::BuildCSDARange() const 137 G4bool G4EmParameters::BuildCSDARange() const
209 { 138 {
210 return buildCSDARange; 139 return buildCSDARange;
211 } 140 }
212 141
213 void G4EmParameters::SetLPM(G4bool val) 142 void G4EmParameters::SetLPM(G4bool val)
214 { 143 {
215 if(IsLocked()) { return; } << 144 G4AutoLock l(&EmParametersMutex);
216 flagLPM = val; 145 flagLPM = val;
217 } 146 }
218 147
219 G4bool G4EmParameters::LPM() const 148 G4bool G4EmParameters::LPM() const
220 { 149 {
221 return flagLPM; 150 return flagLPM;
222 } 151 }
223 152
>> 153 void G4EmParameters::SetSpline(G4bool val)
>> 154 {
>> 155 G4AutoLock l(&EmParametersMutex);
>> 156 spline = val;
>> 157 }
>> 158
>> 159 G4bool G4EmParameters::Spline() const
>> 160 {
>> 161 return spline;
>> 162 }
>> 163
224 void G4EmParameters::SetUseCutAsFinalRange(G4b 164 void G4EmParameters::SetUseCutAsFinalRange(G4bool val)
225 { 165 {
226 if(IsLocked()) { return; } << 166 G4AutoLock l(&EmParametersMutex);
227 cutAsFinalRange = val; << 167 finalRange = val;
228 } 168 }
229 169
230 G4bool G4EmParameters::UseCutAsFinalRange() co 170 G4bool G4EmParameters::UseCutAsFinalRange() const
231 { 171 {
232 return cutAsFinalRange; << 172 return finalRange;
233 } 173 }
234 174
235 void G4EmParameters::SetApplyCuts(G4bool val) 175 void G4EmParameters::SetApplyCuts(G4bool val)
236 { 176 {
237 if(IsLocked()) { return; } << 177 G4AutoLock l(&EmParametersMutex);
238 applyCuts = val; 178 applyCuts = val;
239 } 179 }
240 180
241 G4bool G4EmParameters::ApplyCuts() const 181 G4bool G4EmParameters::ApplyCuts() const
242 { 182 {
243 return applyCuts; 183 return applyCuts;
244 } 184 }
245 185
246 void G4EmParameters::SetFluo(G4bool val) 186 void G4EmParameters::SetFluo(G4bool val)
247 { 187 {
248 if(IsLocked()) { return; } << 188 G4AutoLock l(&EmParametersMutex);
249 fCParameters->SetFluo(val); << 189 fluo = val;
250 } 190 }
251 191
252 G4bool G4EmParameters::Fluo() const 192 G4bool G4EmParameters::Fluo() const
253 { 193 {
254 return fCParameters->Fluo(); << 194 return fluo;
255 } <<
256 <<
257 G4EmFluoDirectory G4EmParameters::FluoDirector <<
258 { <<
259 return fCParameters->FluoDirectory(); <<
260 } <<
261 <<
262 void G4EmParameters::SetFluoDirectory(G4EmFluo <<
263 { <<
264 if(IsLocked()) { return; } <<
265 fCParameters->SetFluoDirectory(val); <<
266 } <<
267 <<
268 void G4EmParameters::SetBeardenFluoDir(G4bool <<
269 { <<
270 if(IsLocked()) { return; } <<
271 fCParameters->SetBeardenFluoDir(val); <<
272 } <<
273 <<
274 void G4EmParameters::SetANSTOFluoDir(G4bool va <<
275 { <<
276 if(IsLocked()) { return; } <<
277 fCParameters->SetANSTOFluoDir(val); <<
278 } <<
279 <<
280 void G4EmParameters::SetXDB_EADLFluoDir(G4bool <<
281 { <<
282 if(IsLocked()) { return; } <<
283 fCParameters->SetXDB_EADLFluoDir(val); <<
284 } 195 }
285 196
286 void G4EmParameters::SetAuger(G4bool val) 197 void G4EmParameters::SetAuger(G4bool val)
287 { 198 {
288 if(IsLocked()) { return; } << 199 G4AutoLock l(&EmParametersMutex);
289 fCParameters->SetAuger(val); << 200 auger = val;
290 } << 201 if(val) { fluo = true; }
291 <<
292 G4bool G4EmParameters::BeardenFluoDir() <<
293 { <<
294 auto dir = fCParameters->FluoDirectory(); <<
295 return (dir == fluoBearden); <<
296 } <<
297 <<
298 G4bool G4EmParameters::ANSTOFluoDir() <<
299 { <<
300 auto dir = fCParameters->FluoDirectory(); <<
301 return (dir == fluoANSTO); <<
302 } 202 }
303 203
304 G4bool G4EmParameters::Auger() const 204 G4bool G4EmParameters::Auger() const
305 { 205 {
306 return fCParameters->Auger(); << 206 return auger;
307 } 207 }
308 208
309 void G4EmParameters::SetPixe(G4bool val) 209 void G4EmParameters::SetPixe(G4bool val)
310 { 210 {
311 if(IsLocked()) { return; } << 211 G4AutoLock l(&EmParametersMutex);
312 fCParameters->SetPixe(val); << 212 pixe = val;
>> 213 if(val) { fluo = true; }
313 } 214 }
314 215
315 G4bool G4EmParameters::Pixe() const 216 G4bool G4EmParameters::Pixe() const
316 { 217 {
317 return fCParameters->Pixe(); << 218 return pixe;
318 } 219 }
319 220
320 void G4EmParameters::SetDeexcitationIgnoreCut( 221 void G4EmParameters::SetDeexcitationIgnoreCut(G4bool val)
321 { 222 {
322 if(IsLocked()) { return; } << 223 G4AutoLock l(&EmParametersMutex);
323 fCParameters->SetDeexcitationIgnoreCut(val); << 224 deexIgnoreCut = val;
324 } 225 }
325 226
326 G4bool G4EmParameters::DeexcitationIgnoreCut() 227 G4bool G4EmParameters::DeexcitationIgnoreCut() const
327 { 228 {
328 return fCParameters->DeexcitationIgnoreCut() << 229 return deexIgnoreCut;
329 } 230 }
330 231
331 void G4EmParameters::SetLateralDisplacement(G4 232 void G4EmParameters::SetLateralDisplacement(G4bool val)
332 { 233 {
333 if(IsLocked()) { return; } << 234 G4AutoLock l(&EmParametersMutex);
334 lateralDisplacement = val; 235 lateralDisplacement = val;
335 } 236 }
336 237
337 G4bool G4EmParameters::LateralDisplacement() c 238 G4bool G4EmParameters::LateralDisplacement() const
338 { 239 {
339 return lateralDisplacement; 240 return lateralDisplacement;
340 } 241 }
341 242
342 void G4EmParameters::SetLateralDisplacementAlg <<
343 { <<
344 if(IsLocked()) { return; } <<
345 lateralDisplacementAlg96 = val; <<
346 } <<
347 <<
348 G4bool G4EmParameters::LateralDisplacementAlg9 <<
349 { <<
350 return lateralDisplacementAlg96; <<
351 } <<
352 <<
353 void G4EmParameters::SetMuHadLateralDisplaceme 243 void G4EmParameters::SetMuHadLateralDisplacement(G4bool val)
354 { 244 {
355 if(IsLocked()) { return; } << 245 G4AutoLock l(&EmParametersMutex);
356 muhadLateralDisplacement = val; 246 muhadLateralDisplacement = val;
357 } 247 }
358 248
359 G4bool G4EmParameters::MuHadLateralDisplacemen 249 G4bool G4EmParameters::MuHadLateralDisplacement() const
360 { 250 {
361 return muhadLateralDisplacement; 251 return muhadLateralDisplacement;
362 } 252 }
363 253
364 void G4EmParameters::ActivateAngularGeneratorF << 254 void G4EmParameters::SetLatDisplacementBeyondSafety(G4bool val)
365 { 255 {
366 if(IsLocked()) { return; } << 256 G4AutoLock l(&EmParametersMutex);
367 useAngGeneratorForIonisation = val; << 257 latDisplacementBeyondSafety = val;
368 } 258 }
369 259
370 G4bool G4EmParameters::UseAngularGeneratorForI << 260 G4bool G4EmParameters::LatDisplacementBeyondSafety() const
371 { 261 {
372 return useAngGeneratorForIonisation; << 262 return latDisplacementBeyondSafety;
373 } 263 }
374 264
375 void G4EmParameters::SetUseMottCorrection(G4bo << 265 void G4EmParameters::ActivateAngularGeneratorForIonisation(G4bool val)
376 { <<
377 if(IsLocked()) { return; } <<
378 useMottCorrection = val; <<
379 } <<
380 <<
381 G4bool G4EmParameters::UseMottCorrection() con <<
382 { <<
383 return useMottCorrection; <<
384 } <<
385 <<
386 void G4EmParameters::SetIntegral(G4bool val) <<
387 { <<
388 if(IsLocked()) { return; } <<
389 integral = val; <<
390 } <<
391 <<
392 G4bool G4EmParameters::Integral() const <<
393 { <<
394 return integral; <<
395 } <<
396 <<
397 void G4EmParameters::SetEnablePolarisation(G4b <<
398 { <<
399 if(IsLocked()) { return; } <<
400 fPolarisation = val; <<
401 } <<
402 <<
403 G4bool G4EmParameters::EnablePolarisation() co <<
404 { <<
405 return fPolarisation; <<
406 } <<
407 <<
408 void G4EmParameters::SetBirksActive(G4bool val <<
409 { <<
410 if(IsLocked()) { return; } <<
411 birks = val; <<
412 if(birks && nullptr == emSaturation) { emSat <<
413 } <<
414 <<
415 G4bool G4EmParameters::BirksActive() const <<
416 { <<
417 return birks; <<
418 } <<
419 <<
420 void G4EmParameters::SetUseICRU90Data(G4bool v <<
421 { <<
422 if(IsLocked()) { return; } <<
423 fICRU90 = val; <<
424 } <<
425 <<
426 G4bool G4EmParameters::UseICRU90Data() const <<
427 { <<
428 return fICRU90; <<
429 } <<
430 <<
431 void G4EmParameters::SetDNAFast(G4bool val) <<
432 { <<
433 if(IsLocked()) { return; } <<
434 fCParameters->SetDNAFast(val); <<
435 if(val) { ActivateDNA(); } <<
436 } <<
437 <<
438 G4bool G4EmParameters::DNAFast() const <<
439 { <<
440 return fCParameters->DNAFast(); <<
441 } <<
442 <<
443 void G4EmParameters::SetDNAStationary(G4bool v <<
444 { <<
445 if(IsLocked()) { return; } <<
446 fCParameters->SetDNAStationary(val); <<
447 if(val) { ActivateDNA(); } <<
448 } <<
449 <<
450 G4bool G4EmParameters::DNAStationary() const <<
451 { <<
452 return fCParameters->DNAStationary(); <<
453 } <<
454 <<
455 void G4EmParameters::SetDNAElectronMsc(G4bool <<
456 { <<
457 if(IsLocked()) { return; } <<
458 fCParameters->SetDNAElectronMsc(val); <<
459 if(val) { ActivateDNA(); } <<
460 } <<
461 <<
462 G4bool G4EmParameters::DNAElectronMsc() const <<
463 { <<
464 return fCParameters->DNAElectronMsc(); <<
465 } <<
466 <<
467 void G4EmParameters::SetGeneralProcessActive(G <<
468 { 266 {
469 if(IsLocked()) { return; } << 267 useAngGeneratorForIonisation = val;
470 gener = val; <<
471 } 268 }
472 269
473 G4bool G4EmParameters::GeneralProcessActive() << 270 G4bool G4EmParameters::UseAngularGeneratorForIonisation() const
474 { 271 {
475 return gener; << 272 return useAngGeneratorForIonisation;
476 } 273 }
477 274
478 void G4EmParameters::SetEmSaturation(G4EmSatur << 275 void G4EmParameters::SetMinSubRange(G4double val)
479 { 276 {
480 if(IsLocked()) { return; } << 277 G4AutoLock l(&EmParametersMutex);
481 birks = (nullptr != ptr); << 278 if(val > 0.0 && val < 1.0) {
482 if(emSaturation != ptr) { << 279 minSubRange = val;
483 delete emSaturation; << 280 } else {
484 emSaturation = ptr; << 281 G4ExceptionDescription ed;
>> 282 ed << "Value of MinSubRange is out of range (0 - 1): " << val
>> 283 << " is ignored";
>> 284 PrintWarning(ed);
485 } 285 }
486 } 286 }
487 287
488 G4bool G4EmParameters::RetrieveMuDataFromFile( << 288 G4double G4EmParameters::MinSubRange() const
489 { 289 {
490 return fMuDataFromFile; << 290 return minSubRange;
491 } <<
492 <<
493 void G4EmParameters::SetRetrieveMuDataFromFile <<
494 { <<
495 fMuDataFromFile = v; <<
496 } <<
497 <<
498 void G4EmParameters::SetOnIsolated(G4bool val) <<
499 { <<
500 if(IsLocked()) { return; } <<
501 onIsolated = val; <<
502 } <<
503 <<
504 G4bool G4EmParameters::OnIsolated() const <<
505 { <<
506 return onIsolated; <<
507 } <<
508 <<
509 void G4EmParameters::SetEnableSamplingTable(G4 <<
510 { <<
511 if(IsLocked()) { return; } <<
512 fSamplingTable = val; <<
513 } <<
514 <<
515 G4bool G4EmParameters::EnableSamplingTable() c <<
516 { <<
517 return fSamplingTable; <<
518 } <<
519 <<
520 G4bool G4EmParameters::PhotoeffectBelowKShell( <<
521 { <<
522 return fPEKShell; <<
523 } <<
524 <<
525 void G4EmParameters::SetPhotoeffectBelowKShell <<
526 { <<
527 if(IsLocked()) { return; } <<
528 fPEKShell = v; <<
529 } <<
530 <<
531 G4bool G4EmParameters::MscPositronCorrection() <<
532 { <<
533 return fMscPosiCorr; <<
534 } <<
535 <<
536 void G4EmParameters::SetMscPositronCorrection( <<
537 { <<
538 if(IsLocked()) { return; } <<
539 fMscPosiCorr = v; <<
540 } <<
541 <<
542 G4bool G4EmParameters::UseEPICS2017XS() const <<
543 { <<
544 return fUseEPICS2017XS; <<
545 } <<
546 <<
547 void G4EmParameters::SetUseEPICS2017XS(G4bool <<
548 { <<
549 if(IsLocked()) { return; } <<
550 fUseEPICS2017XS = v; <<
551 } <<
552 <<
553 G4bool G4EmParameters::Use3GammaAnnihilationOn <<
554 { <<
555 return f3GammaAnnihilationOnFly; <<
556 } <<
557 <<
558 void G4EmParameters::Set3GammaAnnihilationOnFl <<
559 { <<
560 if(IsLocked()) { return; } <<
561 f3GammaAnnihilationOnFly = v; <<
562 } <<
563 <<
564 G4bool G4EmParameters::UseRiGePairProductionMo <<
565 { <<
566 return fUseRiGePairProductionModel; <<
567 } <<
568 <<
569 void G4EmParameters::SetUseRiGePairProductionM <<
570 { <<
571 if (IsLocked()) { return; } <<
572 fUseRiGePairProductionModel = v; <<
573 } <<
574 <<
575 void G4EmParameters::ActivateDNA() <<
576 { <<
577 if(IsLocked()) { return; } <<
578 fDNA = true; <<
579 } <<
580 <<
581 void G4EmParameters::SetIsPrintedFlag(G4bool v <<
582 { <<
583 fIsPrinted = val; <<
584 } <<
585 <<
586 G4bool G4EmParameters::IsPrintLocked() const <<
587 { <<
588 return fIsPrinted; <<
589 } <<
590 <<
591 G4EmSaturation* G4EmParameters::GetEmSaturatio <<
592 { <<
593 if(nullptr == emSaturation) { <<
594 #ifdef G4MULTITHREADED <<
595 G4MUTEXLOCK(&emParametersMutex); <<
596 if(nullptr == emSaturation) { <<
597 #endif <<
598 emSaturation = new G4EmSaturation(1); <<
599 #ifdef G4MULTITHREADED <<
600 } <<
601 G4MUTEXUNLOCK(&emParametersMutex); <<
602 #endif <<
603 } <<
604 birks = true; <<
605 return emSaturation; <<
606 } 291 }
607 292
608 void G4EmParameters::SetMinEnergy(G4double val 293 void G4EmParameters::SetMinEnergy(G4double val)
609 { 294 {
610 if(IsLocked()) { return; } << 295 G4AutoLock l(&EmParametersMutex);
611 if(val > 1.e-3*CLHEP::eV && val < maxKinEner << 296 if(val > 1.e-3*eV && val < maxKinEnergy) {
612 minKinEnergy = val; 297 minKinEnergy = val;
>> 298 nbins = nbinsPerDecade*G4lrint(std::log10(maxKinEnergy/minKinEnergy));
613 } else { 299 } else {
614 G4ExceptionDescription ed; 300 G4ExceptionDescription ed;
615 ed << "Value of MinKinEnergy - is out of r << 301 ed << "Value of MinKinEnergy is out of range: " << val/MeV
616 << " MeV is ignored"; 302 << " MeV is ignored";
617 PrintWarning(ed); 303 PrintWarning(ed);
618 } 304 }
619 } 305 }
620 306
621 G4double G4EmParameters::MinKinEnergy() const 307 G4double G4EmParameters::MinKinEnergy() const
622 { 308 {
623 return minKinEnergy; 309 return minKinEnergy;
624 } 310 }
625 311
626 void G4EmParameters::SetMaxEnergy(G4double val 312 void G4EmParameters::SetMaxEnergy(G4double val)
627 { 313 {
628 if(IsLocked()) { return; } << 314 G4AutoLock l(&EmParametersMutex);
629 if(val > std::max(minKinEnergy,599.9*CLHEP:: << 315 if(val > minKinEnergy && val < 1.e+7*TeV) {
630 maxKinEnergy = val; 316 maxKinEnergy = val;
>> 317 nbins = nbinsPerDecade*G4lrint(std::log10(maxKinEnergy/minKinEnergy));
631 } else { 318 } else {
632 G4ExceptionDescription ed; 319 G4ExceptionDescription ed;
633 ed << "Value of MaxKinEnergy is out of ran 320 ed << "Value of MaxKinEnergy is out of range: "
634 << val/CLHEP::GeV << 321 << val/GeV << " GeV is ignored";
635 << " GeV is ignored; allowed range 600 <<
636 PrintWarning(ed); 322 PrintWarning(ed);
637 } 323 }
638 } 324 }
639 325
640 G4double G4EmParameters::MaxKinEnergy() const 326 G4double G4EmParameters::MaxKinEnergy() const
641 { 327 {
642 return maxKinEnergy; 328 return maxKinEnergy;
643 } 329 }
644 330
645 void G4EmParameters::SetMaxEnergyForCSDARange( 331 void G4EmParameters::SetMaxEnergyForCSDARange(G4double val)
646 { 332 {
647 if(IsLocked()) { return; } << 333 G4AutoLock l(&EmParametersMutex);
648 if(val > minKinEnergy && val <= 100*CLHEP::T << 334 if(val > minKinEnergy && val <= 100*TeV) {
649 maxKinEnergyCSDA = val; 335 maxKinEnergyCSDA = val;
650 } else { 336 } else {
651 G4ExceptionDescription ed; 337 G4ExceptionDescription ed;
652 ed << "Value of MaxKinEnergyCSDA is out of 338 ed << "Value of MaxKinEnergyCSDA is out of range: "
653 << val/CLHEP::GeV << " GeV is ignored; << 339 << val/GeV << " GeV is ignored";
654 << minKinEnergy << " MeV - 100 TeV"; <<
655 PrintWarning(ed); 340 PrintWarning(ed);
656 } 341 }
657 } 342 }
658 343
659 G4double G4EmParameters::MaxEnergyForCSDARange 344 G4double G4EmParameters::MaxEnergyForCSDARange() const
660 { 345 {
661 return maxKinEnergyCSDA; 346 return maxKinEnergyCSDA;
662 } 347 }
663 348
664 void G4EmParameters::SetLowestElectronEnergy(G <<
665 { <<
666 if(IsLocked()) { return; } <<
667 if(val >= 0.0) { lowestElectronEnergy = val; <<
668 } <<
669 <<
670 G4double G4EmParameters::LowestElectronEnergy( <<
671 { <<
672 return lowestElectronEnergy; <<
673 } <<
674 <<
675 void G4EmParameters::SetLowestMuHadEnergy(G4do <<
676 { <<
677 if(IsLocked()) { return; } <<
678 if(val >= 0.0) { lowestMuHadEnergy = val; } <<
679 } <<
680 <<
681 G4double G4EmParameters::LowestMuHadEnergy() c <<
682 { <<
683 return lowestMuHadEnergy; <<
684 } <<
685 <<
686 void G4EmParameters::SetLowestTripletEnergy(G4 <<
687 { <<
688 if(IsLocked()) { return; } <<
689 if(val > 0.0) { lowestTripletEnergy = val; } <<
690 } <<
691 <<
692 G4double G4EmParameters::LowestTripletEnergy() <<
693 { <<
694 return lowestTripletEnergy; <<
695 } <<
696 <<
697 void G4EmParameters::SetMaxNIELEnergy(G4double <<
698 { <<
699 if(IsLocked()) { return; } <<
700 if(val >= 0.0) { maxNIELEnergy = val; } <<
701 } <<
702 <<
703 G4double G4EmParameters::MaxNIELEnergy() const <<
704 { <<
705 return maxNIELEnergy; <<
706 } <<
707 <<
708 void G4EmParameters::SetMaxEnergyFor5DMuPair(G <<
709 { <<
710 if(IsLocked()) { return; } <<
711 if(val > 0.0) { max5DEnergyForMuPair = val; <<
712 } <<
713 <<
714 G4double G4EmParameters::MaxEnergyFor5DMuPair( <<
715 { <<
716 return max5DEnergyForMuPair; <<
717 } <<
718 <<
719 void G4EmParameters::SetLinearLossLimit(G4doub 349 void G4EmParameters::SetLinearLossLimit(G4double val)
720 { 350 {
721 if(IsLocked()) { return; } << 351 G4AutoLock l(&EmParametersMutex);
722 if(val > 0.0 && val < 0.5) { 352 if(val > 0.0 && val < 0.5) {
723 linLossLimit = val; 353 linLossLimit = val;
724 } else { 354 } else {
725 G4ExceptionDescription ed; 355 G4ExceptionDescription ed;
726 ed << "Value of linLossLimit is out of ran 356 ed << "Value of linLossLimit is out of range: " << val
727 << " is ignored"; 357 << " is ignored";
728 PrintWarning(ed); 358 PrintWarning(ed);
729 } 359 }
730 } 360 }
731 361
732 G4double G4EmParameters::LinearLossLimit() con 362 G4double G4EmParameters::LinearLossLimit() const
733 { 363 {
734 return linLossLimit; 364 return linLossLimit;
735 } 365 }
736 366
737 void G4EmParameters::SetBremsstrahlungTh(G4dou 367 void G4EmParameters::SetBremsstrahlungTh(G4double val)
738 { 368 {
739 if(IsLocked()) { return; } << 369 G4AutoLock l(&EmParametersMutex);
740 if(val > 0.0) { 370 if(val > 0.0) {
741 bremsTh = val; 371 bremsTh = val;
742 } else { 372 } else {
743 G4ExceptionDescription ed; 373 G4ExceptionDescription ed;
744 ed << "Value of bremsstrahlung threshold i 374 ed << "Value of bremsstrahlung threshold is out of range: "
745 << val/GeV << " GeV is ignored"; 375 << val/GeV << " GeV is ignored";
746 PrintWarning(ed); 376 PrintWarning(ed);
747 } 377 }
748 } 378 }
749 379
750 G4double G4EmParameters::BremsstrahlungTh() co 380 G4double G4EmParameters::BremsstrahlungTh() const
751 { 381 {
752 return bremsTh; 382 return bremsTh;
753 } 383 }
754 384
755 void G4EmParameters::SetMuHadBremsstrahlungTh( <<
756 { <<
757 if(IsLocked()) { return; } <<
758 if(val > 0.0) { <<
759 bremsMuHadTh = val; <<
760 } else { <<
761 G4ExceptionDescription ed; <<
762 ed << "Value of bremsstrahlung threshold i <<
763 << val/GeV << " GeV is ignored"; <<
764 PrintWarning(ed); <<
765 } <<
766 } <<
767 <<
768 G4double G4EmParameters::MuHadBremsstrahlungTh <<
769 { <<
770 return bremsMuHadTh; <<
771 } <<
772 <<
773 void G4EmParameters::SetLambdaFactor(G4double 385 void G4EmParameters::SetLambdaFactor(G4double val)
774 { 386 {
775 if(IsLocked()) { return; } << 387 G4AutoLock l(&EmParametersMutex);
776 if(val > 0.0 && val < 1.0) { 388 if(val > 0.0 && val < 1.0) {
777 lambdaFactor = val; 389 lambdaFactor = val;
778 } else { 390 } else {
779 G4ExceptionDescription ed; 391 G4ExceptionDescription ed;
780 ed << "Value of lambda factor is out of ra 392 ed << "Value of lambda factor is out of range: " << val
781 << " is ignored"; 393 << " is ignored";
782 PrintWarning(ed); 394 PrintWarning(ed);
783 } 395 }
784 } 396 }
785 397
786 G4double G4EmParameters::LambdaFactor() const 398 G4double G4EmParameters::LambdaFactor() const
787 { 399 {
788 return lambdaFactor; 400 return lambdaFactor;
789 } 401 }
790 402
791 void G4EmParameters::SetFactorForAngleLimit(G4 403 void G4EmParameters::SetFactorForAngleLimit(G4double val)
792 { 404 {
793 if(IsLocked()) { return; } << 405 G4AutoLock l(&EmParametersMutex);
794 if(val > 0.0) { 406 if(val > 0.0) {
795 factorForAngleLimit = val; 407 factorForAngleLimit = val;
796 } else { 408 } else {
797 G4ExceptionDescription ed; 409 G4ExceptionDescription ed;
798 ed << "Value of factor for enegry limit is 410 ed << "Value of factor for enegry limit is out of range: "
799 << val << " is ignored"; 411 << val << " is ignored";
800 PrintWarning(ed); 412 PrintWarning(ed);
801 } 413 }
802 } 414 }
803 415
804 G4double G4EmParameters::FactorForAngleLimit() 416 G4double G4EmParameters::FactorForAngleLimit() const
805 { 417 {
806 return factorForAngleLimit; 418 return factorForAngleLimit;
807 } 419 }
808 420
809 void G4EmParameters::SetMscThetaLimit(G4double 421 void G4EmParameters::SetMscThetaLimit(G4double val)
810 { 422 {
811 if(IsLocked()) { return; } << 423 G4AutoLock l(&EmParametersMutex);
812 if(val >= 0.0 && val <= pi) { 424 if(val >= 0.0 && val <= pi) {
813 thetaLimit = val; 425 thetaLimit = val;
814 } else { 426 } else {
815 G4ExceptionDescription ed; 427 G4ExceptionDescription ed;
816 ed << "Value of polar angle limit is out o 428 ed << "Value of polar angle limit is out of range: "
817 << val << " is ignored"; 429 << val << " is ignored";
818 PrintWarning(ed); 430 PrintWarning(ed);
819 } 431 }
820 } 432 }
821 433
822 G4double G4EmParameters::MscThetaLimit() const 434 G4double G4EmParameters::MscThetaLimit() const
823 { 435 {
824 return thetaLimit; 436 return thetaLimit;
825 } 437 }
826 438
827 void G4EmParameters::SetMscEnergyLimit(G4doubl <<
828 { <<
829 if(IsLocked()) { return; } <<
830 if(val >= 0.0) { <<
831 energyLimit = val; <<
832 } else { <<
833 G4ExceptionDescription ed; <<
834 ed << "Value of msc energy limit is out of <<
835 << val << " is ignored"; <<
836 PrintWarning(ed); <<
837 } <<
838 } <<
839 <<
840 G4double G4EmParameters::MscEnergyLimit() cons <<
841 { <<
842 return energyLimit; <<
843 } <<
844 <<
845 void G4EmParameters::SetMscRangeFactor(G4doubl 439 void G4EmParameters::SetMscRangeFactor(G4double val)
846 { 440 {
847 if(IsLocked()) { return; } << 441 G4AutoLock l(&EmParametersMutex);
848 if(val > 0.0 && val < 1.0) { 442 if(val > 0.0 && val < 1.0) {
849 rangeFactor = val; 443 rangeFactor = val;
850 } else { 444 } else {
851 G4ExceptionDescription ed; 445 G4ExceptionDescription ed;
852 ed << "Value of rangeFactor is out of rang 446 ed << "Value of rangeFactor is out of range: "
853 << val << " is ignored"; 447 << val << " is ignored";
854 PrintWarning(ed); 448 PrintWarning(ed);
855 } 449 }
856 } 450 }
857 451
858 G4double G4EmParameters::MscRangeFactor() cons 452 G4double G4EmParameters::MscRangeFactor() const
859 { 453 {
860 return rangeFactor; 454 return rangeFactor;
861 } 455 }
862 456
863 void G4EmParameters::SetMscMuHadRangeFactor(G4 <<
864 { <<
865 if(IsLocked()) { return; } <<
866 if(val > 0.0 && val < 1.0) { <<
867 rangeFactorMuHad = val; <<
868 } else { <<
869 G4ExceptionDescription ed; <<
870 ed << "Value of rangeFactorMuHad is out of <<
871 << val << " is ignored"; <<
872 PrintWarning(ed); <<
873 } <<
874 } <<
875 <<
876 G4double G4EmParameters::MscMuHadRangeFactor() <<
877 { <<
878 return rangeFactorMuHad; <<
879 } <<
880 <<
881 void G4EmParameters::SetMscGeomFactor(G4double 457 void G4EmParameters::SetMscGeomFactor(G4double val)
882 { 458 {
883 if(IsLocked()) { return; } << 459 G4AutoLock l(&EmParametersMutex);
884 if(val >= 1.0) { 460 if(val >= 1.0) {
885 geomFactor = val; 461 geomFactor = val;
886 } else { 462 } else {
887 G4ExceptionDescription ed; 463 G4ExceptionDescription ed;
888 ed << "Value of geomFactor is out of range 464 ed << "Value of geomFactor is out of range: "
889 << val << " is ignored"; 465 << val << " is ignored";
890 PrintWarning(ed); 466 PrintWarning(ed);
891 } 467 }
892 } 468 }
893 469
894 G4double G4EmParameters::MscGeomFactor() const 470 G4double G4EmParameters::MscGeomFactor() const
895 { 471 {
896 return geomFactor; 472 return geomFactor;
897 } 473 }
898 474
899 void G4EmParameters::SetMscSafetyFactor(G4doub <<
900 { <<
901 if(IsLocked()) { return; } <<
902 if(val >= 0.1) { <<
903 safetyFactor = val; <<
904 } else { <<
905 G4ExceptionDescription ed; <<
906 ed << "Value of safetyFactor is out of ran <<
907 << val << " is ignored"; <<
908 PrintWarning(ed); <<
909 } <<
910 } <<
911 <<
912 G4double G4EmParameters::MscSafetyFactor() con <<
913 { <<
914 return safetyFactor; <<
915 } <<
916 <<
917 void G4EmParameters::SetMscLambdaLimit(G4doubl <<
918 { <<
919 if(IsLocked()) { return; } <<
920 if(val >= 0.0) { <<
921 lambdaLimit = val; <<
922 } else { <<
923 G4ExceptionDescription ed; <<
924 ed << "Value of lambdaLimit is out of rang <<
925 << val << " is ignored"; <<
926 PrintWarning(ed); <<
927 } <<
928 } <<
929 <<
930 G4double G4EmParameters::MscLambdaLimit() cons <<
931 { <<
932 return lambdaLimit; <<
933 } <<
934 <<
935 void G4EmParameters::SetMscSkin(G4double val) 475 void G4EmParameters::SetMscSkin(G4double val)
936 { 476 {
937 if(IsLocked()) { return; } << 477 G4AutoLock l(&EmParametersMutex);
938 if(val >= 1.0) { 478 if(val >= 1.0) {
939 skin = val; 479 skin = val;
940 } else { 480 } else {
941 G4ExceptionDescription ed; 481 G4ExceptionDescription ed;
942 ed << "Value of skin is out of range: " 482 ed << "Value of skin is out of range: "
943 << val << " is ignored"; 483 << val << " is ignored";
944 PrintWarning(ed); 484 PrintWarning(ed);
945 } 485 }
946 } 486 }
947 487
948 G4double G4EmParameters::MscSkin() const 488 G4double G4EmParameters::MscSkin() const
949 { 489 {
950 return skin; 490 return skin;
951 } 491 }
952 492
953 void G4EmParameters::SetScreeningFactor(G4doub << 493 void G4EmParameters::SetNumberOfBins(G4int val)
954 { 494 {
955 if(IsLocked()) { return; } << 495 G4AutoLock l(&EmParametersMutex);
956 if(val > 0.0) { << 496 if(val >= 5 && val < 10000000) {
957 factorScreen = val; << 497 nbins = val;
>> 498 nbinsPerDecade = G4lrint(nbins/std::log10(maxKinEnergy/minKinEnergy));
958 } else { 499 } else {
959 G4ExceptionDescription ed; 500 G4ExceptionDescription ed;
960 ed << "Value of factorScreen is out of ran << 501 ed << "Value of number of bins is out of range: "
961 << val << " is ignored"; 502 << val << " is ignored";
962 PrintWarning(ed); 503 PrintWarning(ed);
963 } 504 }
964 } 505 }
965 506
966 G4double G4EmParameters::ScreeningFactor() con <<
967 { <<
968 return factorScreen; <<
969 } <<
970 <<
971 void G4EmParameters::SetStepFunction(G4double <<
972 { <<
973 if(IsLocked()) { return; } <<
974 fBParameters->SetStepFunction(v1, v2); <<
975 } <<
976 <<
977 void G4EmParameters::SetStepFunctionMuHad(G4do <<
978 { <<
979 if(IsLocked()) { return; } <<
980 fBParameters->SetStepFunctionMuHad(v1, v2); <<
981 } <<
982 <<
983 void G4EmParameters::SetStepFunctionLightIons( <<
984 { <<
985 if(IsLocked()) { return; } <<
986 fBParameters->SetStepFunctionLightIons(v1, v <<
987 } <<
988 <<
989 void G4EmParameters::SetStepFunctionIons(G4dou <<
990 { <<
991 if(IsLocked()) { return; } <<
992 fBParameters->SetStepFunctionIons(v1, v2); <<
993 } <<
994 <<
995 void G4EmParameters::FillStepFunction(const G4 <<
996 { <<
997 fBParameters->FillStepFunction(part, proc); <<
998 } <<
999 <<
1000 G4int G4EmParameters::NumberOfBins() const 507 G4int G4EmParameters::NumberOfBins() const
1001 { 508 {
1002 return nbinsPerDecade*G4lrint(std::log10(ma << 509 return nbins;
1003 } 510 }
1004 511
1005 void G4EmParameters::SetNumberOfBinsPerDecade 512 void G4EmParameters::SetNumberOfBinsPerDecade(G4int val)
1006 { 513 {
1007 if(IsLocked()) { return; } << 514 G4AutoLock l(&EmParametersMutex);
1008 if(val >= 5 && val < 1000000) { 515 if(val >= 5 && val < 1000000) {
1009 nbinsPerDecade = val; 516 nbinsPerDecade = val;
>> 517 nbins = nbinsPerDecade*G4lrint(std::log10(maxKinEnergy/minKinEnergy));
1010 } else { 518 } else {
1011 G4ExceptionDescription ed; 519 G4ExceptionDescription ed;
1012 ed << "Value of number of bins per decade 520 ed << "Value of number of bins per decade is out of range: "
1013 << val << " is ignored"; 521 << val << " is ignored";
1014 PrintWarning(ed); 522 PrintWarning(ed);
1015 } 523 }
1016 } 524 }
1017 525
1018 G4int G4EmParameters::NumberOfBinsPerDecade() 526 G4int G4EmParameters::NumberOfBinsPerDecade() const
1019 { 527 {
1020 return nbinsPerDecade; 528 return nbinsPerDecade;
1021 } 529 }
1022 530
1023 void G4EmParameters::SetVerbose(G4int val) 531 void G4EmParameters::SetVerbose(G4int val)
1024 { 532 {
1025 if(IsLocked()) { return; } << 533 G4AutoLock l(&EmParametersMutex);
1026 verbose = val; 534 verbose = val;
1027 workerVerbose = std::min(workerVerbose, ver 535 workerVerbose = std::min(workerVerbose, verbose);
1028 } 536 }
1029 537
1030 G4int G4EmParameters::Verbose() const 538 G4int G4EmParameters::Verbose() const
1031 { 539 {
1032 return verbose; 540 return verbose;
1033 } 541 }
1034 542
1035 void G4EmParameters::SetWorkerVerbose(G4int v 543 void G4EmParameters::SetWorkerVerbose(G4int val)
1036 { 544 {
1037 if(IsLocked()) { return; } << 545 G4AutoLock l(&EmParametersMutex);
1038 workerVerbose = val; 546 workerVerbose = val;
1039 } 547 }
1040 548
1041 G4int G4EmParameters::WorkerVerbose() const 549 G4int G4EmParameters::WorkerVerbose() const
1042 { 550 {
1043 return workerVerbose; 551 return workerVerbose;
1044 } 552 }
1045 553
1046 void G4EmParameters::SetNumberForFreeVector(G <<
1047 { <<
1048 if(IsLocked()) { return; } <<
1049 nForFreeVector = val; <<
1050 } <<
1051 <<
1052 G4int G4EmParameters::NumberForFreeVector() c <<
1053 { <<
1054 return nForFreeVector; <<
1055 } <<
1056 <<
1057 void G4EmParameters::SetTransportationWithMsc <<
1058 { <<
1059 if(IsLocked()) { return; } <<
1060 fTransportationWithMsc = val; <<
1061 } <<
1062 <<
1063 G4TransportationWithMscType G4EmParameters::T <<
1064 { <<
1065 return fTransportationWithMsc; <<
1066 } <<
1067 <<
1068 void G4EmParameters::SetFluctuationType(G4EmF <<
1069 { <<
1070 if(IsLocked()) { return; } <<
1071 fFluct = val; <<
1072 } <<
1073 <<
1074 G4EmFluctuationType G4EmParameters::Fluctuati <<
1075 { <<
1076 return fFluct; <<
1077 } <<
1078 <<
1079 void G4EmParameters::SetPositronAtRestModelTy <<
1080 { <<
1081 if(IsLocked()) { return; } <<
1082 fPositronium = val; <<
1083 } <<
1084 <<
1085 G4PositronAtRestModelType G4EmParameters::Pos <<
1086 { <<
1087 return fPositronium; <<
1088 } <<
1089 <<
1090 void G4EmParameters::SetMscStepLimitType(G4Ms 554 void G4EmParameters::SetMscStepLimitType(G4MscStepLimitType val)
1091 { 555 {
1092 if(IsLocked()) { return; } << 556 G4AutoLock l(&EmParametersMutex);
1093 mscStepLimit = val; 557 mscStepLimit = val;
1094 } 558 }
1095 559
1096 G4MscStepLimitType G4EmParameters::MscStepLim 560 G4MscStepLimitType G4EmParameters::MscStepLimitType() const
1097 { 561 {
1098 return mscStepLimit; 562 return mscStepLimit;
1099 } 563 }
1100 564
1101 void G4EmParameters::SetMscMuHadStepLimitType << 565 void G4EmParameters::PrintWarning(G4ExceptionDescription& ed)
1102 { <<
1103 if(IsLocked()) { return; } <<
1104 mscStepLimitMuHad = val; <<
1105 } <<
1106 <<
1107 G4MscStepLimitType G4EmParameters::MscMuHadSt <<
1108 { <<
1109 return mscStepLimitMuHad; <<
1110 } <<
1111 <<
1112 void G4EmParameters::SetSingleScatteringType( <<
1113 { <<
1114 if(IsLocked()) { return; } <<
1115 fSStype = val; <<
1116 } <<
1117 <<
1118 G4eSingleScatteringType G4EmParameters::Singl <<
1119 { <<
1120 return fSStype; <<
1121 } <<
1122 <<
1123 void <<
1124 G4EmParameters::SetNuclearFormfactorType(G4Nu <<
1125 { <<
1126 if(IsLocked()) { return; } <<
1127 nucFormfactor = val; <<
1128 } <<
1129 <<
1130 G4NuclearFormfactorType G4EmParameters::Nucle <<
1131 { <<
1132 return nucFormfactor; <<
1133 } <<
1134 <<
1135 void G4EmParameters::SetDNAeSolvationSubType( <<
1136 { <<
1137 if(IsLocked()) { return; } <<
1138 fCParameters->SetDNAeSolvationSubType(val); <<
1139 ActivateDNA(); <<
1140 } <<
1141 <<
1142 G4DNAModelSubType G4EmParameters::DNAeSolvati <<
1143 { <<
1144 return fCParameters->DNAeSolvationSubType() <<
1145 } <<
1146 <<
1147 void G4EmParameters::SetConversionType(G4int <<
1148 { <<
1149 if(IsLocked()) { return; } <<
1150 tripletConv = val; <<
1151 } <<
1152 <<
1153 G4int G4EmParameters::GetConversionType() con <<
1154 { <<
1155 return tripletConv; <<
1156 } <<
1157 <<
1158 void G4EmParameters::SetPIXECrossSectionModel <<
1159 { <<
1160 if(IsLocked()) { return; } <<
1161 fCParameters->SetPIXECrossSectionModel(sss) <<
1162 } <<
1163 <<
1164 const G4String& G4EmParameters::PIXECrossSect <<
1165 { <<
1166 return fCParameters->PIXECrossSectionModel( <<
1167 } <<
1168 <<
1169 void G4EmParameters::SetPIXEElectronCrossSect <<
1170 { <<
1171 if(IsLocked()) { return; } <<
1172 fCParameters->SetPIXEElectronCrossSectionMo <<
1173 } <<
1174 <<
1175 const G4String& G4EmParameters::PIXEElectronC <<
1176 { <<
1177 return fCParameters->PIXEElectronCrossSecti <<
1178 } <<
1179 <<
1180 void G4EmParameters::SetLivermoreDataDir(cons <<
1181 { <<
1182 if(IsLocked()) { return; } <<
1183 fCParameters->SetLivermoreDataDir(sss); <<
1184 } <<
1185 <<
1186 const G4String& G4EmParameters::LivermoreData <<
1187 { <<
1188 return fCParameters->LivermoreDataDir(); <<
1189 } <<
1190 <<
1191 void G4EmParameters::PrintWarning(G4Exception <<
1192 { 566 {
1193 G4Exception("G4EmParameters", "em0044", Jus 567 G4Exception("G4EmParameters", "em0044", JustWarning, ed);
1194 } 568 }
1195 569
1196 void G4EmParameters::AddPAIModel(const G4Stri <<
1197 const G4Stri <<
1198 const G4Stri <<
1199 { <<
1200 if(IsLocked()) { return; } <<
1201 fBParameters->AddPAIModel(particle, region, <<
1202 } <<
1203 <<
1204 const std::vector<G4String>& G4EmParameters:: <<
1205 { <<
1206 return fBParameters->ParticlesPAI(); <<
1207 } <<
1208 <<
1209 const std::vector<G4String>& G4EmParameters:: <<
1210 { <<
1211 return fBParameters->RegionsPAI(); <<
1212 } <<
1213 <<
1214 const std::vector<G4String>& G4EmParameters:: <<
1215 { <<
1216 return fBParameters->TypesPAI(); <<
1217 } <<
1218 <<
1219 void G4EmParameters::AddMicroElec(const G4Str <<
1220 { <<
1221 if(IsLocked()) { return; } <<
1222 fCParameters->AddMicroElec(region); <<
1223 } <<
1224 <<
1225 const std::vector<G4String>& G4EmParameters:: <<
1226 { <<
1227 return fCParameters->RegionsMicroElec(); <<
1228 } <<
1229 <<
1230 void G4EmParameters::AddDNA(const G4String& r <<
1231 { <<
1232 if(IsLocked()) { return; } <<
1233 fCParameters->AddDNA(region, type); <<
1234 ActivateDNA(); <<
1235 } <<
1236 <<
1237 const std::vector<G4String>& G4EmParameters:: <<
1238 { <<
1239 return fCParameters->RegionsDNA(); <<
1240 } <<
1241 <<
1242 const std::vector<G4String>& G4EmParameters:: <<
1243 { <<
1244 return fCParameters->TypesDNA(); <<
1245 } <<
1246 <<
1247 void G4EmParameters::AddPhysics(const G4Strin <<
1248 { <<
1249 if(IsLocked()) { return; } <<
1250 fBParameters->AddPhysics(region, type); <<
1251 } <<
1252 <<
1253 const std::vector<G4String>& G4EmParameters:: <<
1254 { <<
1255 return fBParameters->RegionsPhysics(); <<
1256 } <<
1257 <<
1258 const std::vector<G4String>& G4EmParameters:: <<
1259 { <<
1260 return fBParameters->TypesPhysics(); <<
1261 } <<
1262 <<
1263 void G4EmParameters::SetSubCutRegion(const G4 <<
1264 { <<
1265 if(IsLocked()) { return; } <<
1266 fBParameters->SetSubCutRegion(region); <<
1267 } <<
1268 <<
1269 void <<
1270 G4EmParameters::SetDeexActiveRegion(const G4S <<
1271 G4bool aa <<
1272 { <<
1273 if(IsLocked()) { return; } <<
1274 fCParameters->SetDeexActiveRegion(region, a <<
1275 } <<
1276 <<
1277 void <<
1278 G4EmParameters::SetProcessBiasingFactor(const <<
1279 G4dou <<
1280 { <<
1281 if(IsLocked()) { return; } <<
1282 fBParameters->SetProcessBiasingFactor(procn <<
1283 } <<
1284 <<
1285 void <<
1286 G4EmParameters::ActivateForcedInteraction(con <<
1287 con <<
1288 G4d <<
1289 G4b <<
1290 { <<
1291 if(IsLocked() && !gener) { return; } <<
1292 fBParameters->ActivateForcedInteraction(pro <<
1293 } <<
1294 <<
1295 void <<
1296 G4EmParameters::ActivateSecondaryBiasing(cons <<
1297 cons <<
1298 G4do <<
1299 G4do <<
1300 { <<
1301 if(IsLocked()) { return; } <<
1302 fBParameters->ActivateSecondaryBiasing(proc <<
1303 } <<
1304 <<
1305 void G4EmParameters::DefineRegParamForLoss(G4 <<
1306 { <<
1307 fBParameters->DefineRegParamForLoss(ptr); <<
1308 } <<
1309 <<
1310 void G4EmParameters::DefineRegParamForEM(G4VE <<
1311 { <<
1312 fBParameters->DefineRegParamForEM(ptr); <<
1313 } <<
1314 <<
1315 G4bool G4EmParameters::QuantumEntanglement() <<
1316 { <<
1317 return fBParameters->QuantumEntanglement(); <<
1318 } <<
1319 <<
1320 void G4EmParameters::SetQuantumEntanglement(G <<
1321 { <<
1322 if(IsLocked()) { return; } <<
1323 fBParameters->SetQuantumEntanglement(v); <<
1324 } <<
1325 <<
1326 G4bool G4EmParameters::GetDirectionalSplittin <<
1327 return fBParameters->GetDirectionalSplittin <<
1328 } <<
1329 <<
1330 void G4EmParameters::SetDirectionalSplitting( <<
1331 { <<
1332 if(IsLocked()) { return; } <<
1333 fBParameters->SetDirectionalSplitting(v); <<
1334 } <<
1335 <<
1336 void G4EmParameters::SetDirectionalSplittingT <<
1337 { <<
1338 if(IsLocked()) { return; } <<
1339 fBParameters->SetDirectionalSplittingTarget <<
1340 } <<
1341 <<
1342 G4ThreeVector G4EmParameters::GetDirectionalS <<
1343 { <<
1344 return fBParameters->GetDirectionalSplittin <<
1345 } <<
1346 <<
1347 void G4EmParameters::SetDirectionalSplittingR <<
1348 { <<
1349 if(IsLocked()) { return; } <<
1350 fBParameters->SetDirectionalSplittingRadius <<
1351 } <<
1352 <<
1353 G4double G4EmParameters::GetDirectionalSplitt <<
1354 { <<
1355 return fBParameters->GetDirectionalSplittin <<
1356 } <<
1357 <<
1358 void G4EmParameters::DefineRegParamForDeex(G4 <<
1359 { <<
1360 fCParameters->DefineRegParamForDeex(ptr); <<
1361 } <<
1362 <<
1363 const G4String& G4EmParameters::GetDirLEDATA( <<
1364 { <<
1365 return fDirLEDATA; <<
1366 } <<
1367 <<
1368 void G4EmParameters::StreamInfo(std::ostream& <<
1369 { <<
1370 G4long prec = os.precision(5); <<
1371 os << "==================================== <<
1372 os << "====== Electromagnet <<
1373 os << "==================================== <<
1374 os << "LPM effect enabled <<
1375 os << "Enable creation and use of sampling <<
1376 os << "Apply cuts on all EM processes <<
1377 const char* transportationWithMsc = "Disabl <<
1378 if(fTransportationWithMsc == G4Transportati <<
1379 transportationWithMsc = "Enabled"; <<
1380 } else if (fTransportationWithMsc == G4Tran <<
1381 transportationWithMsc = "MultipleSteps"; <<
1382 } <<
1383 os << "Use combined TransportationWithMsc <<
1384 os << "Use general process <<
1385 os << "Enable linear polarisation for gamma <<
1386 os << "Enable photoeffect sampling below K- <<
1387 os << "Enable sampling of quantum entanglem <<
1388 <<fBParameters->QuantumEntanglement() < <<
1389 os << "X-section factor for integral approa <<
1390 os << "Min kinetic energy for tables <<
1391 <<G4BestUnit(minKinEnergy,"Energy") << " <<
1392 os << "Max kinetic energy for tables <<
1393 <<G4BestUnit(maxKinEnergy,"Energy") << " <<
1394 os << "Number of bins per decade of a table <<
1395 os << "Verbose level <<
1396 os << "Verbose level for worker thread <<
1397 os << "Bremsstrahlung energy threshold abov <<
1398 << " primary e+- is added to the list o <<
1399 <<G4BestUnit(bremsTh,"Energy") << "\n"; <<
1400 os << "Bremsstrahlung energy threshold abov <<
1401 << " muon/hadron is added to the list o <<
1402 <<G4BestUnit(bremsMuHadTh,"Energy") << " <<
1403 G4String name3g = "SimplePositronium"; <<
1404 if (fPositronium == fAllisonPositronium) { <<
1405 else if (fPositronium == fOrePowell) { name <<
1406 else if (fPositronium == fOrePowellPolar) { <<
1407 os << "Positron annihilation at rest model <<
1408 <<
1409 os << "Enable 3 gamma annihilation on fly <<
1410 << f3GammaAnnihilationOnFly << "\n"; <<
1411 os << "Lowest triplet kinetic energy <<
1412 <<G4BestUnit(lowestTripletEnergy,"Energy <<
1413 os << "Enable sampling of gamma linear pola <<
1414 os << "5D gamma conversion model type <<
1415 os << "5D gamma conversion model on isolate <<
1416 if(max5DEnergyForMuPair>0.0) { <<
1417 os << "5D gamma conversion limit for muon p <<
1418 << max5DEnergyForMuPair/CLHEP::GeV << " <<
1419 } <<
1420 os << "Use Ricardo-Gerardo pair production <<
1421 << fUseRiGePairProductionModel << "\n"; <<
1422 os << "Livermore data directory <<
1423 << fCParameters->LivermoreDataDir() << " <<
1424 <<
1425 os << "==================================== <<
1426 os << "====== Ionisation Pa <<
1427 os << "==================================== <<
1428 os << "Step function for e+- <<
1429 <<"("<<fBParameters->GetStepFunctionP1() <<
1430 << fBParameters->GetStepFunctionP2()/CLH <<
1431 os << "Step function for muons/hadrons <<
1432 <<"("<<fBParameters->GetStepFunctionMuHa <<
1433 << fBParameters->GetStepFunctionMuHadP2( <<
1434 os << "Step function for light ions <<
1435 <<"("<<fBParameters->GetStepFunctionLigh <<
1436 << fBParameters->GetStepFunctionLightIon <<
1437 os << "Step function for general ions <<
1438 <<"("<<fBParameters->GetStepFunctionIons <<
1439 << fBParameters->GetStepFunctionIonsP2() <<
1440 os << "Lowest e+e- kinetic energy <<
1441 <<G4BestUnit(lowestElectronEnergy,"Energ <<
1442 os << "Lowest muon/hadron kinetic energy <<
1443 <<G4BestUnit(lowestMuHadEnergy,"Energy") <<
1444 os << "Use ICRU90 data <<
1445 os << "Fluctuations of dE/dx are enabled <<
1446 G4String namef = "Universal"; <<
1447 if(fFluct == fUrbanFluctuation) { namef = " <<
1448 else if(fFluct == fDummyFluctuation) { name <<
1449 os << "Type of fluctuation model for lepton <<
1450 os << "Use built-in Birks satuaration <<
1451 os << "Build CSDA range enabled <<
1452 os << "Use cut as a final range enabled <<
1453 os << "Enable angular generator interface <<
1454 <<useAngGeneratorForIonisation << "\n"; <<
1455 os << "Max kinetic energy for CSDA tables <<
1456 <<G4BestUnit(maxKinEnergyCSDA,"Energy") <<
1457 os << "Max kinetic energy for NIEL computat <<
1458 <<G4BestUnit(maxNIELEnergy,"Energy") << <<
1459 os << "Linear loss limit <<
1460 os << "Read data from file for e+e- pair pr <<
1461 <<
1462 os << "==================================== <<
1463 os << "====== Multiple Scat <<
1464 os << "==================================== <<
1465 os << "Type of msc step limit algorithm for <<
1466 os << "Type of msc step limit algorithm for <<
1467 os << "Msc lateral displacement for e+- ena <<
1468 os << "Msc lateral displacement for muons a <<
1469 os << "Urban msc model lateral displacement <<
1470 os << "Range factor for msc step limit for <<
1471 os << "Range factor for msc step limit for <<
1472 os << "Geometry factor for msc step limitat <<
1473 os << "Safety factor for msc step limit for <<
1474 os << "Skin parameter for msc step limitati <<
1475 os << "Lambda limit for msc step limit for <<
1476 os << "Use Mott correction for e- scatterin <<
1477 os << "Factor used for dynamic computation <<
1478 << " limit between single and multiple <<
1479 os << "Fixed angular limit between single \ <<
1480 << " and multiple scattering <<
1481 << thetaLimit/CLHEP::rad << " rad\n"; <<
1482 os << "Upper energy limit for e+- multiple <<
1483 << energyLimit/CLHEP::MeV << " MeV\n"; <<
1484 os << "Type of electron single scattering m <<
1485 os << "Type of nuclear form-factor <<
1486 os << "Screening factor <<
1487 os << "==================================== <<
1488 <<
1489 if(fCParameters->Fluo()) { <<
1490 os << "====== Atomic Deexci <<
1491 os << "==================================== <<
1492 os << "Fluorescence enabled <<
1493 G4String named = "fluor"; <<
1494 G4EmFluoDirectory fdir = FluoDirectory(); <<
1495 if(fdir == fluoBearden) { named = "fluor_Be <<
1496 else if(fdir == fluoANSTO) { named = "fluor <<
1497 else if(fdir == fluoXDB_EADL) { named = "fl <<
1498 os << "Directory in G4LEDATA for fluorescen <<
1499 os << "Auger electron cascade enabled <<
1500 <<fCParameters->Auger() << "\n"; <<
1501 os << "PIXE atomic de-excitation enabled <<
1502 os << "De-excitation module ignores cuts <<
1503 <<fCParameters->DeexcitationIgnoreCut() <<
1504 os << "Type of PIXE cross section for hadro <<
1505 <<fCParameters->PIXECrossSectionModel() <<
1506 os << "Type of PIXE cross section for e+- <<
1507 <<fCParameters->PIXEElectronCrossSection <<
1508 os << "==================================== <<
1509 } <<
1510 if(fDNA) { <<
1511 os << "====== DNA Physics P <<
1512 os << "==================================== <<
1513 os << "Use fast sampling in DNA models <<
1514 << fCParameters->DNAFast() << "\n"; <<
1515 os << "Use Stationary option in DNA models <<
1516 << fCParameters->DNAStationary() << "\n" <<
1517 os << "Use DNA with multiple scattering of <<
1518 << fCParameters->DNAElectronMsc() << "\n <<
1519 os << "Use DNA e- solvation model type <<
1520 << fCParameters->DNAeSolvationSubType() <<
1521 auto chemModel = fCParameters->GetChemTimeS <<
1522 if(fCParameters->GetChemTimeStepModel() != <<
1523 { <<
1524 std::vector<G4String> ChemModel{"Unknown" <<
1525 os << "Use DNA Chemistry model <<
1526 << ChemModel.at((std::size_t)chemModel <<
1527 } <<
1528 os << "==================================== <<
1529 } <<
1530 os.precision(prec); <<
1531 } <<
1532 <<
1533 void G4EmParameters::Dump() <<
1534 { <<
1535 if(fIsPrinted) return; <<
1536 <<
1537 #ifdef G4MULTITHREADED <<
1538 G4MUTEXLOCK(&emParametersMutex); <<
1539 #endif <<
1540 StreamInfo(G4cout); <<
1541 #ifdef G4MULTITHREADED <<
1542 G4MUTEXUNLOCK(&emParametersMutex); <<
1543 #endif <<
1544 } <<
1545 <<
1546 std::ostream& operator<< (std::ostream& os, c <<
1547 { <<
1548 par.StreamInfo(os); <<
1549 return os; <<
1550 } <<
1551 <<
1552 G4bool G4EmParameters::IsLocked() const <<
1553 { <<
1554 return (!G4Threading::IsMasterThread() || <<
1555 (fStateManager->GetCurrentState() != G4St <<
1556 fStateManager->GetCurrentState() ! <<
1557 fStateManager->GetCurrentState() != G4St <<
1558 } <<
1559 <<
1560 <<
1561 void G4EmParameters::SetTimeStepModel(const G <<
1562 { <<
1563 fCParameters-> SetChemTimeStepModel(model); <<
1564 } <<
1565 <<
1566 G4ChemTimeStepModel G4EmParameters::GetTimeSt <<
1567 { <<
1568 return fCParameters->GetChemTimeStepModel() <<
1569 } <<
1570 //....oooOO0OOooo........oooOO0OOooo........o 570 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 571
1571 572