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 10.7.p2)


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