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