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