Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/utils/src/G4EmParameters.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/electromagnetic/utils/src/G4EmParameters.cc (Version 11.3.0) and /processes/electromagnetic/utils/src/G4EmParameters.cc (Version 6.2.p1)


  1 //                                                  1 
  2 // *******************************************    
  3 // * License and Disclaimer                       
  4 // *                                              
  5 // * The  Geant4 software  is  copyright of th    
  6 // * the Geant4 Collaboration.  It is provided    
  7 // * conditions of the Geant4 Software License    
  8 // * LICENSE and available at  http://cern.ch/    
  9 // * include a list of copyright holders.         
 10 // *                                              
 11 // * Neither the authors of this software syst    
 12 // * institutes,nor the agencies providing fin    
 13 // * work  make  any representation or  warran    
 14 // * regarding  this  software system or assum    
 15 // * use.  Please see the license in the file     
 16 // * for the full disclaimer and the limitatio    
 17 // *                                              
 18 // * This  code  implementation is the result     
 19 // * technical work of the GEANT4 collaboratio    
 20 // * By using,  copying,  modifying or  distri    
 21 // * any work based  on the software)  you  ag    
 22 // * use  in  resulting  scientific  publicati    
 23 // * acceptance of all terms of the Geant4 Sof    
 24 // *******************************************    
 25 //                                                
 26 // -------------------------------------------    
 27 //                                                
 28 // GEANT4 Class file                              
 29 //                                                
 30 // File name:     G4EmParameters                  
 31 //                                                
 32 // Author:        Vladimir Ivanchenko             
 33 //                                                
 34 // Creation date: 18.05.2013                      
 35 //                                                
 36 // Modifications:                                 
 37 //                                                
 38 // -------------------------------------------    
 39 //                                                
 40 //....oooOO0OOooo........oooOO0OOooo........oo    
 41 //....oooOO0OOooo........oooOO0OOooo........oo    
 42                                                   
 43 #include "G4EmParameters.hh"                      
 44 #include "G4PhysicalConstants.hh"                 
 45 #include "G4UnitsTable.hh"                        
 46 #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"             
 53 #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                                                   
 63 namespace                                         
 64 {                                                 
 65   G4Mutex emParametersMutex = G4MUTEX_INITIALI    
 66 }                                                 
 67                                                   
 68 //....oooOO0OOooo........oooOO0OOooo........oo    
 69                                                   
 70 G4EmParameters* G4EmParameters::Instance()        
 71 {                                                 
 72   if(nullptr == theInstance) {                    
 73     G4AutoLock l(&emParametersMutex);             
 74     if(nullptr == theInstance) {                  
 75       static G4EmParameters manager;              
 76       theInstance = &manager;                     
 77     }                                             
 78     l.unlock();                                   
 79   }                                               
 80   return theInstance;                             
 81 }                                                 
 82                                                   
 83 //....oooOO0OOooo........oooOO0OOooo........oo    
 84                                                   
 85 G4EmParameters::~G4EmParameters()                 
 86 {                                                 
 87   delete theMessenger;                            
 88   delete fBParameters;                            
 89   delete fCParameters;                            
 90   delete emSaturation;                            
 91 }                                                 
 92                                                   
 93 //....oooOO0OOooo........oooOO0OOooo........oo    
 94                                                   
 95 G4EmParameters::G4EmParameters()                  
 96 {                                                 
 97   G4NistManager::Instance();                      
 98   theMessenger = new G4EmParametersMessenger(t    
 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                                                   
117 void G4EmParameters::Initialise()                 
118 {                                                 
119   lossFluctuation = true;                         
120   buildCSDARange = false;                         
121   flagLPM = true;                                 
122   cutAsFinalRange = false;                        
123   applyCuts = false;                              
124   lateralDisplacement = true;                     
125   lateralDisplacementAlg96 = true;                
126   muhadLateralDisplacement = false;               
127   useAngGeneratorForIonisation = false;           
128   useMottCorrection = false;                      
129   integral = true;                                
130   birks = false;                                  
131   fICRU90 = false;                                
132   gener = false;                                  
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;                            
154   bremsTh = bremsMuHadTh = maxKinEnergy;          
155   lambdaFactor = 0.8;                             
156   factorForAngleLimit = 1.0;                      
157   thetaLimit = CLHEP::pi;                         
158   energyLimit = 100.0*CLHEP::MeV;                 
159   rangeFactor = 0.04;                             
160   rangeFactorMuHad = 0.2;                         
161   geomFactor = 2.5;                               
162   skin = 1.0;                                     
163   safetyFactor = 0.6;                             
164   lambdaLimit  = 1.0*CLHEP::mm;                   
165   factorScreen = 1.0;                             
166                                                   
167   nbinsPerDecade = 7;                             
168   verbose = 1;                                    
169   workerVerbose = 0;                              
170   nForFreeVector = 2;                             
171   tripletConv = 0;                                
172                                                   
173   fTransportationWithMsc = G4TransportationWit    
174   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 }                                                 
190                                                   
191 void G4EmParameters::SetLossFluctuations(G4boo    
192 {                                                 
193   if(IsLocked()) { return; }                      
194   lossFluctuation = val;                          
195 }                                                 
196                                                   
197 G4bool G4EmParameters::LossFluctuation() const    
198 {                                                 
199   return lossFluctuation;                         
200 }                                                 
201                                                   
202 void G4EmParameters::SetBuildCSDARange(G4bool     
203 {                                                 
204   if(IsLocked()) { return; }                      
205   buildCSDARange = val;                           
206 }                                                 
207                                                   
208 G4bool G4EmParameters::BuildCSDARange() const     
209 {                                                 
210   return buildCSDARange;                          
211 }                                                 
212                                                   
213 void G4EmParameters::SetLPM(G4bool val)           
214 {                                                 
215   if(IsLocked()) { return; }                      
216   flagLPM = val;                                  
217 }                                                 
218                                                   
219 G4bool G4EmParameters::LPM() const                
220 {                                                 
221   return flagLPM;                                 
222 }                                                 
223                                                   
224 void G4EmParameters::SetUseCutAsFinalRange(G4b    
225 {                                                 
226   if(IsLocked()) { return; }                      
227   cutAsFinalRange = val;                          
228 }                                                 
229                                                   
230 G4bool G4EmParameters::UseCutAsFinalRange() co    
231 {                                                 
232   return cutAsFinalRange;                         
233 }                                                 
234                                                   
235 void G4EmParameters::SetApplyCuts(G4bool val)     
236 {                                                 
237   if(IsLocked()) { return; }                      
238   applyCuts = val;                                
239 }                                                 
240                                                   
241 G4bool G4EmParameters::ApplyCuts() const          
242 {                                                 
243   return applyCuts;                               
244 }                                                 
245                                                   
246 void G4EmParameters::SetFluo(G4bool val)          
247 {                                                 
248   if(IsLocked()) { return; }                      
249   fCParameters->SetFluo(val);                     
250 }                                                 
251                                                   
252 G4bool G4EmParameters::Fluo() const               
253 {                                                 
254   return fCParameters->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 }                                                 
285                                                   
286 void G4EmParameters::SetAuger(G4bool val)         
287 {                                                 
288   if(IsLocked()) { return; }                      
289   fCParameters->SetAuger(val);                    
290 }                                                 
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 }                                                 
303                                                   
304 G4bool G4EmParameters::Auger() const              
305 {                                                 
306   return fCParameters->Auger();                   
307 }                                                 
308                                                   
309 void G4EmParameters::SetPixe(G4bool val)          
310 {                                                 
311   if(IsLocked()) { return; }                      
312   fCParameters->SetPixe(val);                     
313 }                                                 
314                                                   
315 G4bool G4EmParameters::Pixe() const               
316 {                                                 
317   return fCParameters->Pixe();                    
318 }                                                 
319                                                   
320 void G4EmParameters::SetDeexcitationIgnoreCut(    
321 {                                                 
322   if(IsLocked()) { return; }                      
323   fCParameters->SetDeexcitationIgnoreCut(val);    
324 }                                                 
325                                                   
326 G4bool G4EmParameters::DeexcitationIgnoreCut()    
327 {                                                 
328   return fCParameters->DeexcitationIgnoreCut()    
329 }                                                 
330                                                   
331 void G4EmParameters::SetLateralDisplacement(G4    
332 {                                                 
333   if(IsLocked()) { return; }                      
334   lateralDisplacement = val;                      
335 }                                                 
336                                                   
337 G4bool G4EmParameters::LateralDisplacement() c    
338 {                                                 
339   return lateralDisplacement;                     
340 }                                                 
341                                                   
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    
354 {                                                 
355   if(IsLocked()) { return; }                      
356   muhadLateralDisplacement = val;                 
357 }                                                 
358                                                   
359 G4bool G4EmParameters::MuHadLateralDisplacemen    
360 {                                                 
361   return muhadLateralDisplacement;                
362 }                                                 
363                                                   
364 void G4EmParameters::ActivateAngularGeneratorF    
365 {                                                 
366   if(IsLocked()) { return; }                      
367   useAngGeneratorForIonisation = val;             
368 }                                                 
369                                                   
370 G4bool G4EmParameters::UseAngularGeneratorForI    
371 {                                                 
372   return useAngGeneratorForIonisation;            
373 }                                                 
374                                                   
375 void G4EmParameters::SetUseMottCorrection(G4bo    
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 {                                                 
469   if(IsLocked()) { return; }                      
470   gener = val;                                    
471 }                                                 
472                                                   
473 G4bool G4EmParameters::GeneralProcessActive()     
474 {                                                 
475   return gener;                                   
476 }                                                 
477                                                   
478 void G4EmParameters::SetEmSaturation(G4EmSatur    
479 {                                                 
480   if(IsLocked()) { return; }                      
481   birks = (nullptr != ptr);                       
482   if(emSaturation != ptr) {                       
483     delete emSaturation;                          
484     emSaturation = ptr;                           
485   }                                               
486 }                                                 
487                                                   
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)    
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 }                                                 
607                                                   
608 void G4EmParameters::SetMinEnergy(G4double val    
609 {                                                 
610   if(IsLocked()) { return; }                      
611   if(val > 1.e-3*CLHEP::eV && val < maxKinEner    
612     minKinEnergy = val;                           
613   } else {                                        
614     G4ExceptionDescription ed;                    
615     ed << "Value of MinKinEnergy - is out of r    
616        << " MeV is ignored";                      
617     PrintWarning(ed);                             
618   }                                               
619 }                                                 
620                                                   
621 G4double G4EmParameters::MinKinEnergy() const     
622 {                                                 
623   return minKinEnergy;                            
624 }                                                 
625                                                   
626 void G4EmParameters::SetMaxEnergy(G4double val    
627 {                                                 
628   if(IsLocked()) { return; }                      
629   if(val > std::max(minKinEnergy,599.9*CLHEP::    
630     maxKinEnergy = val;                           
631   } else {                                        
632     G4ExceptionDescription ed;                    
633     ed << "Value of MaxKinEnergy is out of ran    
634        << val/CLHEP::GeV                          
635        << " GeV is ignored; allowed range 600     
636     PrintWarning(ed);                             
637   }                                               
638 }                                                 
639                                                   
640 G4double G4EmParameters::MaxKinEnergy() const     
641 {                                                 
642   return maxKinEnergy;                            
643 }                                                 
644                                                   
645 void G4EmParameters::SetMaxEnergyForCSDARange(    
646 {                                                 
647   if(IsLocked()) { return; }                      
648   if(val > minKinEnergy && val <= 100*CLHEP::T    
649     maxKinEnergyCSDA = val;                       
650   } else {                                        
651     G4ExceptionDescription ed;                    
652     ed << "Value of MaxKinEnergyCSDA is out of    
653        << val/CLHEP::GeV << " GeV is ignored;     
654        << minKinEnergy << " MeV - 100 TeV";       
655     PrintWarning(ed);                             
656   }                                               
657 }                                                 
658                                                   
659 G4double G4EmParameters::MaxEnergyForCSDARange    
660 {                                                 
661   return maxKinEnergyCSDA;                        
662 }                                                 
663                                                   
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    
720 {                                                 
721   if(IsLocked()) { return; }                      
722   if(val > 0.0 && val < 0.5) {                    
723     linLossLimit = val;                           
724   } else {                                        
725     G4ExceptionDescription ed;                    
726     ed << "Value of linLossLimit is out of ran    
727        << " is ignored";                          
728     PrintWarning(ed);                             
729   }                                               
730 }                                                 
731                                                   
732 G4double G4EmParameters::LinearLossLimit() con    
733 {                                                 
734   return linLossLimit;                            
735 }                                                 
736                                                   
737 void G4EmParameters::SetBremsstrahlungTh(G4dou    
738 {                                                 
739   if(IsLocked()) { return; }                      
740   if(val > 0.0) {                                 
741     bremsTh = val;                                
742   } else {                                        
743     G4ExceptionDescription ed;                    
744     ed << "Value of bremsstrahlung threshold i    
745        << val/GeV << " GeV is ignored";           
746     PrintWarning(ed);                             
747   }                                               
748 }                                                 
749                                                   
750 G4double G4EmParameters::BremsstrahlungTh() co    
751 {                                                 
752   return bremsTh;                                 
753 }                                                 
754                                                   
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     
774 {                                                 
775   if(IsLocked()) { return; }                      
776   if(val > 0.0 && val < 1.0) {                    
777     lambdaFactor = val;                           
778   } else {                                        
779     G4ExceptionDescription ed;                    
780     ed << "Value of lambda factor is out of ra    
781        << " is ignored";                          
782     PrintWarning(ed);                             
783   }                                               
784 }                                                 
785                                                   
786 G4double G4EmParameters::LambdaFactor() const     
787 {                                                 
788   return lambdaFactor;                            
789 }                                                 
790                                                   
791 void G4EmParameters::SetFactorForAngleLimit(G4    
792 {                                                 
793   if(IsLocked()) { return; }                      
794   if(val > 0.0) {                                 
795     factorForAngleLimit = val;                    
796   } else {                                        
797     G4ExceptionDescription ed;                    
798     ed << "Value of factor for enegry limit is    
799        << val << " is ignored";                   
800     PrintWarning(ed);                             
801   }                                               
802 }                                                 
803                                                   
804 G4double G4EmParameters::FactorForAngleLimit()    
805 {                                                 
806   return factorForAngleLimit;                     
807 }                                                 
808                                                   
809 void G4EmParameters::SetMscThetaLimit(G4double    
810 {                                                 
811   if(IsLocked()) { return; }                      
812   if(val >= 0.0 && val <= pi) {                   
813     thetaLimit = val;                             
814   } else {                                        
815     G4ExceptionDescription ed;                    
816     ed << "Value of polar angle limit is out o    
817        << val << " is ignored";                   
818     PrintWarning(ed);                             
819   }                                               
820 }                                                 
821                                                   
822 G4double G4EmParameters::MscThetaLimit() const    
823 {                                                 
824   return thetaLimit;                              
825 }                                                 
826                                                   
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    
846 {                                                 
847   if(IsLocked()) { return; }                      
848   if(val > 0.0 && val < 1.0) {                    
849     rangeFactor = val;                            
850   } else {                                        
851     G4ExceptionDescription ed;                    
852     ed << "Value of rangeFactor is out of rang    
853        << val << " is ignored";                   
854     PrintWarning(ed);                             
855   }                                               
856 }                                                 
857                                                   
858 G4double G4EmParameters::MscRangeFactor() cons    
859 {                                                 
860   return rangeFactor;                             
861 }                                                 
862                                                   
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    
882 {                                                 
883   if(IsLocked()) { return; }                      
884   if(val >= 1.0) {                                
885     geomFactor = val;                             
886   } else {                                        
887     G4ExceptionDescription ed;                    
888     ed << "Value of geomFactor is out of range    
889        << val << " is ignored";                   
890     PrintWarning(ed);                             
891   }                                               
892 }                                                 
893                                                   
894 G4double G4EmParameters::MscGeomFactor() const    
895 {                                                 
896   return geomFactor;                              
897 }                                                 
898                                                   
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)     
936 {                                                 
937   if(IsLocked()) { return; }                      
938   if(val >= 1.0) {                                
939     skin = val;                                   
940   } else {                                        
941     G4ExceptionDescription ed;                    
942     ed << "Value of skin is out of range: "       
943        << val << " is ignored";                   
944     PrintWarning(ed);                             
945   }                                               
946 }                                                 
947                                                   
948 G4double G4EmParameters::MscSkin() const          
949 {                                                 
950   return skin;                                    
951 }                                                 
952                                                   
953 void G4EmParameters::SetScreeningFactor(G4doub    
954 {                                                 
955   if(IsLocked()) { return; }                      
956   if(val > 0.0) {                                 
957     factorScreen = val;                           
958   } else {                                        
959     G4ExceptionDescription ed;                    
960     ed << "Value of factorScreen is out of ran    
961        << val << " is ignored";                   
962     PrintWarning(ed);                             
963   }                                               
964 }                                                 
965                                                   
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       
1001 {                                                
1002   return nbinsPerDecade*G4lrint(std::log10(ma    
1003 }                                                
1004                                                  
1005 void G4EmParameters::SetNumberOfBinsPerDecade    
1006 {                                                
1007   if(IsLocked()) { return; }                     
1008   if(val >= 5 && val < 1000000) {                
1009     nbinsPerDecade = val;                        
1010   } else {                                       
1011     G4ExceptionDescription ed;                   
1012     ed << "Value of number of bins per decade    
1013        << val << " is ignored";                  
1014     PrintWarning(ed);                            
1015   }                                              
1016 }                                                
1017                                                  
1018 G4int G4EmParameters::NumberOfBinsPerDecade()    
1019 {                                                
1020   return nbinsPerDecade;                         
1021 }                                                
1022                                                  
1023 void G4EmParameters::SetVerbose(G4int val)       
1024 {                                                
1025   if(IsLocked()) { return; }                     
1026   verbose = val;                                 
1027   workerVerbose = std::min(workerVerbose, ver    
1028 }                                                
1029                                                  
1030 G4int G4EmParameters::Verbose() const            
1031 {                                                
1032   return verbose;                                
1033 }                                                
1034                                                  
1035 void G4EmParameters::SetWorkerVerbose(G4int v    
1036 {                                                
1037   if(IsLocked()) { return; }                     
1038   workerVerbose = val;                           
1039 }                                                
1040                                                  
1041 G4int G4EmParameters::WorkerVerbose() const      
1042 {                                                
1043   return workerVerbose;                          
1044 }                                                
1045                                                  
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    
1091 {                                                
1092   if(IsLocked()) { return; }                     
1093   mscStepLimit = val;                            
1094 }                                                
1095                                                  
1096 G4MscStepLimitType G4EmParameters::MscStepLim    
1097 {                                                
1098   return mscStepLimit;                           
1099 }                                                
1100                                                  
1101 void G4EmParameters::SetMscMuHadStepLimitType    
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 {                                                
1193   G4Exception("G4EmParameters", "em0044", Jus    
1194 }                                                
1195                                                  
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    
1571