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 11.2.2)


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