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