Gabriele Cosmo
1421 lines
36 KiB
C++
1421 lines
36 KiB
C++
//
|
|
// ********************************************************************
|
|
// * License and Disclaimer *
|
|
// * *
|
|
// * The Geant4 software is copyright of the Copyright Holders of *
|
|
// * the Geant4 Collaboration. It is provided under the terms and *
|
|
// * conditions of the Geant4 Software License, included in the file *
|
|
// * LICENSE and available at http://cern.ch/geant4/license . These *
|
|
// * include a list of copyright holders. *
|
|
// * *
|
|
// * Neither the authors of this software system, nor their employing *
|
|
// * institutes,nor the agencies providing financial support for this *
|
|
// * work make any representation or warranty, express or implied, *
|
|
// * regarding this software system or assume any liability for its *
|
|
// * use. Please see the license in the file LICENSE and URL above *
|
|
// * for the full disclaimer and the limitation of liability. *
|
|
// * *
|
|
// * This code implementation is the result of the scientific and *
|
|
// * technical work of the GEANT4 collaboration. *
|
|
// * By using, copying, modifying or distributing the software (or *
|
|
// * any work based on the software) you agree to acknowledge its *
|
|
// * use in resulting scientific publications, and indicate your *
|
|
// * acceptance of all terms of the Geant4 Software license. *
|
|
// ********************************************************************
|
|
//
|
|
// $Id: G4EmParameters.cc 69320 2013-04-30 15:59:36Z vnivanch $
|
|
//
|
|
// -------------------------------------------------------------------
|
|
//
|
|
// GEANT4 Class file
|
|
//
|
|
//
|
|
// File name: G4EmParameters
|
|
//
|
|
// Author: Vladimir Ivanchenko
|
|
//
|
|
// Creation date: 18.05.2013
|
|
//
|
|
// Modifications:
|
|
//
|
|
//
|
|
//
|
|
// -------------------------------------------------------------------
|
|
//
|
|
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
|
|
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
|
|
|
|
#include "G4EmParameters.hh"
|
|
#include "G4PhysicalConstants.hh"
|
|
#include "G4UnitsTable.hh"
|
|
#include "G4SystemOfUnits.hh"
|
|
#include "G4VEmProcess.hh"
|
|
#include "G4VEnergyLossProcess.hh"
|
|
#include "G4VAtomDeexcitation.hh"
|
|
#include "G4EmParametersMessenger.hh"
|
|
#include "G4NistManager.hh"
|
|
#include "G4RegionStore.hh"
|
|
#include "G4Region.hh"
|
|
#include "G4ApplicationState.hh"
|
|
#include "G4StateManager.hh"
|
|
|
|
G4EmParameters* G4EmParameters::theInstance = nullptr;
|
|
|
|
#ifdef G4MULTITHREADED
|
|
G4Mutex G4EmParameters::emParametersMutex = G4MUTEX_INITIALIZER;
|
|
#endif
|
|
|
|
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
|
|
|
|
G4EmParameters* G4EmParameters::Instance()
|
|
{
|
|
if(nullptr == theInstance) {
|
|
#ifdef G4MULTITHREADED
|
|
G4MUTEXLOCK(&emParametersMutex);
|
|
if(nullptr == theInstance) {
|
|
#endif
|
|
static G4EmParameters manager;
|
|
theInstance = &manager;
|
|
#ifdef G4MULTITHREADED
|
|
}
|
|
G4MUTEXUNLOCK(&emParametersMutex);
|
|
#endif
|
|
}
|
|
return theInstance;
|
|
}
|
|
|
|
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
|
|
|
|
G4EmParameters::~G4EmParameters()
|
|
{
|
|
delete theMessenger;
|
|
delete emSaturation;
|
|
}
|
|
|
|
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
|
|
|
|
G4EmParameters::G4EmParameters()
|
|
{
|
|
G4NistManager::Instance();
|
|
theMessenger = new G4EmParametersMessenger(this);
|
|
|
|
fStateManager = G4StateManager::GetStateManager();
|
|
Initialise();
|
|
emSaturation = nullptr;
|
|
}
|
|
|
|
void G4EmParameters::SetDefaults()
|
|
{
|
|
if(!IsLocked()) { Initialise(); }
|
|
}
|
|
|
|
void G4EmParameters::Initialise()
|
|
{
|
|
lossFluctuation = true;
|
|
buildCSDARange = false;
|
|
flagLPM = true;
|
|
spline = true;
|
|
cutAsFinalRange = false;
|
|
applyCuts = false;
|
|
fluo = false;
|
|
beardenFluoDir = false;
|
|
auger = false;
|
|
augerCascade = false;
|
|
pixe = false;
|
|
deexIgnoreCut = false;
|
|
lateralDisplacement = true;
|
|
lateralDisplacementAlg96 = true;
|
|
muhadLateralDisplacement = false;
|
|
latDisplacementBeyondSafety = false;
|
|
useAngGeneratorForIonisation = false;
|
|
useMottCorrection = false;
|
|
integral = true;
|
|
birks = false;
|
|
dnaFast = false;
|
|
dnaStationary = false;
|
|
dnaMsc = false;
|
|
gammaShark = false;
|
|
onIsolated = false;
|
|
|
|
minSubRange = 1.0;
|
|
minKinEnergy = 0.1*CLHEP::keV;
|
|
maxKinEnergy = 100.0*CLHEP::TeV;
|
|
maxKinEnergyCSDA = 1.0*CLHEP::GeV;
|
|
lowestElectronEnergy = 1.0*CLHEP::keV;
|
|
lowestMuHadEnergy = 1.0*CLHEP::keV;
|
|
lowestTripletEnergy = 1.0*CLHEP::MeV;
|
|
linLossLimit = 0.01;
|
|
bremsTh = maxKinEnergy;
|
|
lambdaFactor = 0.8;
|
|
factorForAngleLimit = 1.0;
|
|
thetaLimit = CLHEP::pi;
|
|
energyLimit = 100.0*CLHEP::MeV;
|
|
rangeFactor = 0.04;
|
|
rangeFactorMuHad = 0.2;
|
|
geomFactor = 2.5;
|
|
skin = 1.0;
|
|
dRoverRange = 0.2;
|
|
finalRange = CLHEP::mm;
|
|
dRoverRangeMuHad = 0.2;
|
|
finalRangeMuHad = 0.1*CLHEP::mm;
|
|
factorScreen = 1.0;
|
|
|
|
nbins = 84;
|
|
nbinsPerDecade = 7;
|
|
verbose = 1;
|
|
workerVerbose = 0;
|
|
tripletConv = 0;
|
|
|
|
mscStepLimit = fUseSafety;
|
|
mscStepLimitMuHad = fMinimal;
|
|
nucFormfactor = fExponentialNF;
|
|
dnaElectronSolvation = fMeesungnoen2002eSolvation;
|
|
|
|
namePIXE = "Empirical";
|
|
nameElectronPIXE = "Livermore";
|
|
}
|
|
|
|
void G4EmParameters::SetLossFluctuations(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
lossFluctuation = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::LossFluctuation() const
|
|
{
|
|
return lossFluctuation;
|
|
}
|
|
|
|
void G4EmParameters::SetBuildCSDARange(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
buildCSDARange = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::BuildCSDARange() const
|
|
{
|
|
return buildCSDARange;
|
|
}
|
|
|
|
void G4EmParameters::SetLPM(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
flagLPM = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::LPM() const
|
|
{
|
|
return flagLPM;
|
|
}
|
|
|
|
void G4EmParameters::SetSpline(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
spline = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::Spline() const
|
|
{
|
|
return spline;
|
|
}
|
|
|
|
void G4EmParameters::SetUseCutAsFinalRange(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
cutAsFinalRange = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::UseCutAsFinalRange() const
|
|
{
|
|
return cutAsFinalRange;
|
|
}
|
|
|
|
void G4EmParameters::SetApplyCuts(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
applyCuts = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::ApplyCuts() const
|
|
{
|
|
return applyCuts;
|
|
}
|
|
|
|
void G4EmParameters::SetFluo(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
fluo = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::Fluo() const
|
|
{
|
|
return fluo;
|
|
}
|
|
|
|
void G4EmParameters::SetBeardenFluoDir(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
beardenFluoDir = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::BeardenFluoDir() const
|
|
{
|
|
return beardenFluoDir;
|
|
}
|
|
|
|
void G4EmParameters::SetAuger(G4bool val)
|
|
{
|
|
SetAugerCascade(val);
|
|
}
|
|
|
|
G4bool G4EmParameters::Auger() const
|
|
{
|
|
return auger;
|
|
}
|
|
|
|
void G4EmParameters::SetAugerCascade(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
augerCascade = val;
|
|
auger = val;
|
|
if(val) { fluo = true; }
|
|
}
|
|
|
|
G4bool G4EmParameters::AugerCascade() const
|
|
{
|
|
return augerCascade;
|
|
}
|
|
|
|
void G4EmParameters::SetPixe(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
pixe = val;
|
|
if(val) { fluo = true; }
|
|
}
|
|
|
|
G4bool G4EmParameters::Pixe() const
|
|
{
|
|
return pixe;
|
|
}
|
|
|
|
void G4EmParameters::SetDeexcitationIgnoreCut(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
deexIgnoreCut = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::DeexcitationIgnoreCut() const
|
|
{
|
|
return deexIgnoreCut;
|
|
}
|
|
|
|
void G4EmParameters::SetLateralDisplacement(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
lateralDisplacement = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::LateralDisplacement() const
|
|
{
|
|
return lateralDisplacement;
|
|
}
|
|
|
|
void G4EmParameters::SetLateralDisplacementAlg96(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
lateralDisplacementAlg96 = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::LateralDisplacementAlg96() const
|
|
{
|
|
return lateralDisplacementAlg96;
|
|
}
|
|
|
|
void G4EmParameters::SetMuHadLateralDisplacement(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
muhadLateralDisplacement = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::MuHadLateralDisplacement() const
|
|
{
|
|
return muhadLateralDisplacement;
|
|
}
|
|
|
|
void G4EmParameters::SetLatDisplacementBeyondSafety(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
latDisplacementBeyondSafety = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::LatDisplacementBeyondSafety() const
|
|
{
|
|
return latDisplacementBeyondSafety;
|
|
}
|
|
|
|
void G4EmParameters::ActivateAngularGeneratorForIonisation(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
useAngGeneratorForIonisation = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::UseAngularGeneratorForIonisation() const
|
|
{
|
|
return useAngGeneratorForIonisation;
|
|
}
|
|
|
|
void G4EmParameters::SetUseMottCorrection(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
useMottCorrection = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::UseMottCorrection() const
|
|
{
|
|
return useMottCorrection;
|
|
}
|
|
|
|
void G4EmParameters::SetIntegral(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
integral = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::Integral() const
|
|
{
|
|
return integral;
|
|
}
|
|
|
|
void G4EmParameters::SetBirksActive(G4bool val)
|
|
{
|
|
birks = val;
|
|
#ifdef G4MULTITHREADED
|
|
G4MUTEXLOCK(&G4EmParameters::emParametersMutex);
|
|
#endif
|
|
if(birks) {
|
|
if(!emSaturation) { emSaturation = new G4EmSaturation(1); }
|
|
emSaturation->InitialiseG4Saturation();
|
|
}
|
|
#ifdef G4MULTITHREADED
|
|
G4MUTEXUNLOCK(&G4EmParameters::emParametersMutex);
|
|
#endif
|
|
}
|
|
|
|
G4bool G4EmParameters::BirksActive() const
|
|
{
|
|
return birks;
|
|
}
|
|
|
|
void G4EmParameters::SetDNAFast(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
dnaFast = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::DNAFast() const
|
|
{
|
|
return dnaFast;
|
|
}
|
|
|
|
void G4EmParameters::SetDNAStationary(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
dnaStationary = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::DNAStationary() const
|
|
{
|
|
return dnaStationary;
|
|
}
|
|
|
|
void G4EmParameters::SetDNAElectronMsc(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
dnaMsc = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::DNAElectronMsc() const
|
|
{
|
|
return dnaMsc;
|
|
}
|
|
|
|
void G4EmParameters::SetGammaSharkActive(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
gammaShark = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::GammaSharkActive() const
|
|
{
|
|
return gammaShark;
|
|
}
|
|
|
|
void G4EmParameters::SetEmSaturation(G4EmSaturation* ptr)
|
|
{
|
|
if(emSaturation != ptr) {
|
|
delete emSaturation;
|
|
emSaturation = ptr;
|
|
SetBirksActive(true);
|
|
}
|
|
}
|
|
|
|
void G4EmParameters::SetOnIsolated(G4bool val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
onIsolated = val;
|
|
}
|
|
|
|
G4bool G4EmParameters::OnIsolated() const
|
|
{
|
|
return onIsolated;
|
|
}
|
|
|
|
G4EmSaturation* G4EmParameters::GetEmSaturation()
|
|
{
|
|
if(!emSaturation) { SetBirksActive(true); }
|
|
return emSaturation;
|
|
}
|
|
|
|
void G4EmParameters::SetMinSubRange(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val > 0.0 && val < 1.0) {
|
|
minSubRange = val;
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of MinSubRange is out of range (0 - 1): " << val
|
|
<< " is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4double G4EmParameters::MinSubRange() const
|
|
{
|
|
return minSubRange;
|
|
}
|
|
|
|
void G4EmParameters::SetMinEnergy(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val > 1.e-3*eV && val < maxKinEnergy) {
|
|
minKinEnergy = val;
|
|
nbins = nbinsPerDecade*G4lrint(std::log10(maxKinEnergy/minKinEnergy));
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of MinKinEnergy is out of range: " << val/MeV
|
|
<< " MeV is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4double G4EmParameters::MinKinEnergy() const
|
|
{
|
|
return minKinEnergy;
|
|
}
|
|
|
|
void G4EmParameters::SetMaxEnergy(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val > minKinEnergy && val < 1.e+7*TeV) {
|
|
maxKinEnergy = val;
|
|
nbins = nbinsPerDecade*G4lrint(std::log10(maxKinEnergy/minKinEnergy));
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of MaxKinEnergy is out of range: "
|
|
<< val/GeV << " GeV is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4double G4EmParameters::MaxKinEnergy() const
|
|
{
|
|
return maxKinEnergy;
|
|
}
|
|
|
|
void G4EmParameters::SetMaxEnergyForCSDARange(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val > minKinEnergy && val <= 100*TeV) {
|
|
maxKinEnergyCSDA = val;
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of MaxKinEnergyCSDA is out of range: "
|
|
<< val/GeV << " GeV is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4double G4EmParameters::MaxEnergyForCSDARange() const
|
|
{
|
|
return maxKinEnergyCSDA;
|
|
}
|
|
|
|
void G4EmParameters::SetLowestElectronEnergy(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val >= 0.0) {
|
|
lowestElectronEnergy = val;
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of lowestElectronEnergy is out of range: "
|
|
<< val/MeV << " MeV is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4double G4EmParameters::LowestElectronEnergy() const
|
|
{
|
|
return lowestElectronEnergy;
|
|
}
|
|
|
|
void G4EmParameters::SetLowestMuHadEnergy(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val >= 0.0) {
|
|
lowestMuHadEnergy = val;
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of lowestMuHadEnergy is out of range: "
|
|
<< val/MeV << " MeV is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4double G4EmParameters::LowestMuHadEnergy() const
|
|
{
|
|
return lowestMuHadEnergy;
|
|
}
|
|
|
|
void G4EmParameters::SetLowestTripletEnergy(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val > 0.0) { lowestTripletEnergy = val; }
|
|
}
|
|
|
|
G4double G4EmParameters::LowestTripletEnergy() const
|
|
{
|
|
return lowestTripletEnergy;
|
|
}
|
|
|
|
void G4EmParameters::SetLinearLossLimit(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val > 0.0 && val < 0.5) {
|
|
linLossLimit = val;
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of linLossLimit is out of range: " << val
|
|
<< " is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4double G4EmParameters::LinearLossLimit() const
|
|
{
|
|
return linLossLimit;
|
|
}
|
|
|
|
void G4EmParameters::SetBremsstrahlungTh(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val > 0.0) {
|
|
bremsTh = val;
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of bremsstrahlung threshold is out of range: "
|
|
<< val/GeV << " GeV is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4double G4EmParameters::BremsstrahlungTh() const
|
|
{
|
|
return bremsTh;
|
|
}
|
|
|
|
void G4EmParameters::SetLambdaFactor(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val > 0.0 && val < 1.0) {
|
|
lambdaFactor = val;
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of lambda factor is out of range: " << val
|
|
<< " is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4double G4EmParameters::LambdaFactor() const
|
|
{
|
|
return lambdaFactor;
|
|
}
|
|
|
|
void G4EmParameters::SetFactorForAngleLimit(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val > 0.0) {
|
|
factorForAngleLimit = val;
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of factor for enegry limit is out of range: "
|
|
<< val << " is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4double G4EmParameters::FactorForAngleLimit() const
|
|
{
|
|
return factorForAngleLimit;
|
|
}
|
|
|
|
void G4EmParameters::SetMscThetaLimit(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val >= 0.0 && val <= pi) {
|
|
thetaLimit = val;
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of polar angle limit is out of range: "
|
|
<< val << " is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4double G4EmParameters::MscThetaLimit() const
|
|
{
|
|
return thetaLimit;
|
|
}
|
|
|
|
void G4EmParameters::SetMscEnergyLimit(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val >= 0.0) {
|
|
energyLimit = val;
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of msc energy limit is out of range: "
|
|
<< val << " is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4double G4EmParameters::MscEnergyLimit() const
|
|
{
|
|
return energyLimit;
|
|
}
|
|
|
|
void G4EmParameters::SetMscRangeFactor(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val > 0.0 && val < 1.0) {
|
|
rangeFactor = val;
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of rangeFactor is out of range: "
|
|
<< val << " is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4double G4EmParameters::MscRangeFactor() const
|
|
{
|
|
return rangeFactor;
|
|
}
|
|
|
|
void G4EmParameters::SetMscMuHadRangeFactor(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val > 0.0 && val < 1.0) {
|
|
rangeFactorMuHad = val;
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of rangeFactorMuHad is out of range: "
|
|
<< val << " is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4double G4EmParameters::MscMuHadRangeFactor() const
|
|
{
|
|
return rangeFactorMuHad;
|
|
}
|
|
|
|
void G4EmParameters::SetMscGeomFactor(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val >= 1.0) {
|
|
geomFactor = val;
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of geomFactor is out of range: "
|
|
<< val << " is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4double G4EmParameters::MscGeomFactor() const
|
|
{
|
|
return geomFactor;
|
|
}
|
|
|
|
void G4EmParameters::SetMscSkin(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val >= 1.0) {
|
|
skin = val;
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of skin is out of range: "
|
|
<< val << " is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4double G4EmParameters::MscSkin() const
|
|
{
|
|
return skin;
|
|
}
|
|
|
|
void G4EmParameters::SetScreeningFactor(G4double val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val > 0.0) {
|
|
factorScreen = val;
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of factorScreen is out of range: "
|
|
<< val << " is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4double G4EmParameters::ScreeningFactor() const
|
|
{
|
|
return factorScreen;
|
|
}
|
|
|
|
void G4EmParameters::SetStepFunction(G4double v1, G4double v2)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(v1 > 0.0 && v1 <= 1.0 && v2 > 0.0) {
|
|
dRoverRange = v1;
|
|
finalRange = v2;
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Values of step function are out of range: "
|
|
<< v1 << ", " << v2/CLHEP::mm << " mm - are ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
void G4EmParameters::SetStepFunctionMuHad(G4double v1, G4double v2)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(v1 > 0.0 && v1 <= 1.0 && v2 > 0.0) {
|
|
dRoverRangeMuHad = v1;
|
|
finalRangeMuHad = v2;
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Values of step function are out of range: "
|
|
<< v1 << ", " << v2/CLHEP::mm << " mm - are ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
void G4EmParameters::SetNumberOfBins(G4int val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val >= 5 && val < 10000000) {
|
|
nbins = val;
|
|
nbinsPerDecade = G4lrint(nbins/std::log10(maxKinEnergy/minKinEnergy));
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of number of bins is out of range: "
|
|
<< val << " is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4int G4EmParameters::NumberOfBins() const
|
|
{
|
|
return nbins;
|
|
}
|
|
|
|
void G4EmParameters::SetNumberOfBinsPerDecade(G4int val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val >= 5 && val < 1000000) {
|
|
nbinsPerDecade = val;
|
|
nbins = nbinsPerDecade*G4lrint(std::log10(maxKinEnergy/minKinEnergy));
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Value of number of bins per decade is out of range: "
|
|
<< val << " is ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
G4int G4EmParameters::NumberOfBinsPerDecade() const
|
|
{
|
|
return nbinsPerDecade;
|
|
}
|
|
|
|
void G4EmParameters::SetVerbose(G4int val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
verbose = val;
|
|
workerVerbose = std::min(workerVerbose, verbose);
|
|
}
|
|
|
|
G4int G4EmParameters::Verbose() const
|
|
{
|
|
return verbose;
|
|
}
|
|
|
|
void G4EmParameters::SetWorkerVerbose(G4int val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
workerVerbose = val;
|
|
}
|
|
|
|
G4int G4EmParameters::WorkerVerbose() const
|
|
{
|
|
return workerVerbose;
|
|
}
|
|
|
|
void G4EmParameters::SetMscStepLimitType(G4MscStepLimitType val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
mscStepLimit = val;
|
|
}
|
|
|
|
G4MscStepLimitType G4EmParameters::MscStepLimitType() const
|
|
{
|
|
return mscStepLimit;
|
|
}
|
|
|
|
void G4EmParameters::SetMscMuHadStepLimitType(G4MscStepLimitType val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
mscStepLimitMuHad = val;
|
|
}
|
|
|
|
G4MscStepLimitType G4EmParameters::MscMuHadStepLimitType() const
|
|
{
|
|
return mscStepLimitMuHad;
|
|
}
|
|
|
|
void
|
|
G4EmParameters::SetNuclearFormfactorType(G4NuclearFormfactorType val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
nucFormfactor = val;
|
|
}
|
|
|
|
G4NuclearFormfactorType G4EmParameters::NuclearFormfactorType() const
|
|
{
|
|
return nucFormfactor;
|
|
}
|
|
|
|
void G4EmParameters::SetDNAeSolvationSubType(G4DNAModelSubType val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
dnaElectronSolvation = val;
|
|
}
|
|
|
|
G4DNAModelSubType G4EmParameters::DNAeSolvationSubType() const
|
|
{
|
|
return dnaElectronSolvation;
|
|
}
|
|
|
|
void G4EmParameters::SetConversionType(G4int val)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
tripletConv = val;
|
|
}
|
|
|
|
G4int G4EmParameters::GetConversionType() const
|
|
{
|
|
return tripletConv;
|
|
}
|
|
|
|
void G4EmParameters::SetPIXECrossSectionModel(const G4String& sss)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
G4cout << "G4EmParameters::SetPIXECrossSectionModel " << sss << G4endl;
|
|
namePIXE = sss;
|
|
}
|
|
|
|
const G4String& G4EmParameters::PIXECrossSectionModel()
|
|
{
|
|
return namePIXE;
|
|
}
|
|
|
|
void G4EmParameters::SetPIXEElectronCrossSectionModel(const G4String& sss)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
nameElectronPIXE = sss;
|
|
}
|
|
|
|
const G4String& G4EmParameters::PIXEElectronCrossSectionModel()
|
|
{
|
|
return nameElectronPIXE;
|
|
}
|
|
|
|
void G4EmParameters::PrintWarning(G4ExceptionDescription& ed) const
|
|
{
|
|
G4Exception("G4EmParameters", "em0044", JustWarning, ed);
|
|
}
|
|
|
|
G4String G4EmParameters::CheckRegion(const G4String& reg) const
|
|
{
|
|
G4String r = reg;
|
|
if(r == "" || r == "world" || r == "World") {
|
|
r = "DefaultRegionForTheWorld";
|
|
}
|
|
return r;
|
|
}
|
|
|
|
void G4EmParameters::AddPAIModel(const G4String& particle,
|
|
const G4String& region,
|
|
const G4String& type)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
G4String r = CheckRegion(region);
|
|
G4int nreg = m_regnamesPAI.size();
|
|
for(G4int i=0; i<nreg; ++i) {
|
|
if((m_particlesPAI[i] == particle ||
|
|
m_particlesPAI[i] == "all" ||
|
|
particle == "all") &&
|
|
(m_regnamesPAI[i] == r ||
|
|
m_regnamesPAI[i] == "DefaultRegionForTheWorld" ||
|
|
r == "DefaultRegionForTheWorld") ) {
|
|
|
|
m_typesPAI[i] = type;
|
|
if(particle == "all") { m_particlesPAI[i] = particle; }
|
|
if(r == "DefaultRegionForTheWorld") { m_regnamesPAI[i] = r; }
|
|
return;
|
|
}
|
|
}
|
|
m_particlesPAI.push_back(particle);
|
|
m_regnamesPAI.push_back(r);
|
|
m_typesPAI.push_back(type);
|
|
}
|
|
|
|
const std::vector<G4String>& G4EmParameters::ParticlesPAI() const
|
|
{
|
|
return m_particlesPAI;
|
|
}
|
|
|
|
const std::vector<G4String>& G4EmParameters::RegionsPAI() const
|
|
{
|
|
return m_regnamesPAI;
|
|
}
|
|
|
|
const std::vector<G4String>& G4EmParameters::TypesPAI() const
|
|
{
|
|
return m_typesPAI;
|
|
}
|
|
|
|
void G4EmParameters::AddMicroElec(const G4String& region)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
G4String r = CheckRegion(region);
|
|
G4int nreg = m_regnamesME.size();
|
|
for(G4int i=0; i<nreg; ++i) {
|
|
if(r == m_regnamesME[i]) { return; }
|
|
}
|
|
m_regnamesME.push_back(r);
|
|
}
|
|
|
|
const std::vector<G4String>& G4EmParameters::RegionsMicroElec() const
|
|
{
|
|
return m_regnamesME;
|
|
}
|
|
|
|
void G4EmParameters::AddDNA(const G4String& region, const G4String& type)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
G4String r = CheckRegion(region);
|
|
G4int nreg = m_regnamesDNA.size();
|
|
for(G4int i=0; i<nreg; ++i) {
|
|
if(r == m_regnamesDNA[i]) { return; }
|
|
}
|
|
m_regnamesDNA.push_back(r);
|
|
m_typesDNA.push_back(type);
|
|
}
|
|
|
|
const std::vector<G4String>& G4EmParameters::RegionsDNA() const
|
|
{
|
|
return m_regnamesDNA;
|
|
}
|
|
|
|
const std::vector<G4String>& G4EmParameters::TypesDNA() const
|
|
{
|
|
return m_typesDNA;
|
|
}
|
|
|
|
void G4EmParameters::AddMsc(const G4String& region, const G4String& type)
|
|
{
|
|
AddPhysics(region, type);
|
|
}
|
|
|
|
const std::vector<G4String>& G4EmParameters::RegionsMsc() const
|
|
{
|
|
return m_regnamesMsc;
|
|
}
|
|
|
|
const std::vector<G4String>& G4EmParameters::TypesMsc() const
|
|
{
|
|
return m_typesMsc;
|
|
}
|
|
|
|
void G4EmParameters::AddPhysics(const G4String& region, const G4String& type)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
G4String r = CheckRegion(region);
|
|
G4int nreg = m_regnamesMsc.size();
|
|
for(G4int i=0; i<nreg; ++i) {
|
|
if(r == m_regnamesMsc[i]) { return; }
|
|
}
|
|
m_regnamesMsc.push_back(r);
|
|
m_typesMsc.push_back(type);
|
|
}
|
|
|
|
const std::vector<G4String>& G4EmParameters::RegionsPhysics() const
|
|
{
|
|
return m_regnamesMsc;
|
|
}
|
|
|
|
const std::vector<G4String>& G4EmParameters::TypesPhysics() const
|
|
{
|
|
return m_typesMsc;
|
|
}
|
|
|
|
void G4EmParameters::SetSubCutoff(G4bool val, const G4String& region)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
G4String r = CheckRegion(region);
|
|
G4int nreg = m_regnamesSubCut.size();
|
|
for(G4int i=0; i<nreg; ++i) {
|
|
if(r == m_regnamesSubCut[i]) {
|
|
m_subCuts[i] = val;
|
|
return;
|
|
}
|
|
}
|
|
m_regnamesSubCut.push_back(r);
|
|
m_subCuts.push_back(val);
|
|
}
|
|
|
|
void
|
|
G4EmParameters::SetDeexActiveRegion(const G4String& region, G4bool fdeex,
|
|
G4bool fauger, G4bool fpixe)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(fdeex) { fluo = true; }
|
|
G4String r = CheckRegion(region);
|
|
G4int nreg = m_regnamesDeex.size();
|
|
if(0 == nreg && r != "DefaultRegionForTheWorld") {
|
|
m_regnamesDeex.push_back("DefaultRegionForTheWorld");
|
|
m_fluo.push_back(false);
|
|
m_auger.push_back(false);
|
|
m_pixe.push_back(false);
|
|
nreg = 1;
|
|
}
|
|
for(G4int i=0; i<nreg; ++i) {
|
|
if(r == m_regnamesDeex[i]) {
|
|
m_fluo[i] = fdeex;
|
|
m_auger[i]= fauger;
|
|
m_pixe[i] = fpixe;
|
|
return;
|
|
}
|
|
}
|
|
m_regnamesDeex.push_back(r);
|
|
m_fluo.push_back(fdeex);
|
|
m_auger.push_back(fauger);
|
|
m_pixe.push_back(fpixe);
|
|
}
|
|
|
|
void
|
|
G4EmParameters::SetProcessBiasingFactor(const G4String& procname,
|
|
G4double val, G4bool wflag)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
if(val > 0.0) {
|
|
G4int n = m_procBiasedXS.size();
|
|
for(G4int i=0; i<n; ++i) {
|
|
if(procname == m_procBiasedXS[i]) {
|
|
m_factBiasedXS[i] = val;
|
|
m_weightBiasedXS[i]= wflag;
|
|
return;
|
|
}
|
|
}
|
|
m_procBiasedXS.push_back(procname);
|
|
m_factBiasedXS.push_back(val);
|
|
m_weightBiasedXS.push_back(wflag);
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Process: " << procname << " XS biasing factor "
|
|
<< val << " is negative - ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
void
|
|
G4EmParameters::ActivateForcedInteraction(const G4String& procname,
|
|
const G4String& region,
|
|
G4double length,
|
|
G4bool wflag)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
G4String r = CheckRegion(region);
|
|
if(length >= 0.0) {
|
|
G4int n = m_procForced.size();
|
|
for(G4int i=0; i<n; ++i) {
|
|
if(procname == m_procForced[i] && r == m_regnamesForced[i] ) {
|
|
m_lengthForced[i] = length;
|
|
m_weightForced[i]= wflag;
|
|
return;
|
|
}
|
|
}
|
|
m_regnamesForced.push_back(r);
|
|
m_procForced.push_back(procname);
|
|
m_lengthForced.push_back(length);
|
|
m_weightForced.push_back(wflag);
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Process: " << procname << " in region " << r
|
|
<< " : forced interacttion length= "
|
|
<< length << " is negative - ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
void
|
|
G4EmParameters::ActivateSecondaryBiasing(const G4String& procname,
|
|
const G4String& region,
|
|
G4double factor,
|
|
G4double energyLim)
|
|
{
|
|
if(IsLocked()) { return; }
|
|
G4String r = CheckRegion(region);
|
|
if(factor >= 0.0 && energyLim >= 0.0) {
|
|
G4int n = m_procBiasedSec.size();
|
|
for(G4int i=0; i<n; ++i) {
|
|
if(procname == m_procBiasedSec[i] && r == m_regnamesBiasedSec[i] ) {
|
|
m_factBiasedSec[i] = factor;
|
|
m_elimBiasedSec[i] = energyLim;
|
|
return;
|
|
}
|
|
}
|
|
m_regnamesBiasedSec.push_back(r);
|
|
m_procBiasedSec.push_back(procname);
|
|
m_factBiasedSec.push_back(factor);
|
|
m_elimBiasedSec.push_back(energyLim);
|
|
} else {
|
|
G4ExceptionDescription ed;
|
|
ed << "Process: " << procname << " in region " << r
|
|
<< " : secondary bised factor= "
|
|
<< factor << ", Elim= " << energyLim << " - ignored";
|
|
PrintWarning(ed);
|
|
}
|
|
}
|
|
|
|
void G4EmParameters::DefineRegParamForLoss(G4VEnergyLossProcess* ptr,
|
|
G4bool isElectron) const
|
|
{
|
|
if(isElectron) { ptr->SetStepFunction(dRoverRange, finalRange, false); }
|
|
else { ptr->SetStepFunction(dRoverRangeMuHad, finalRangeMuHad, false); }
|
|
|
|
G4RegionStore* regionStore = G4RegionStore::GetInstance();
|
|
G4int n = m_regnamesSubCut.size();
|
|
for(G4int i=0; i<n; ++i) {
|
|
const G4Region* reg = regionStore->GetRegion(m_regnamesSubCut[i], false);
|
|
if(reg) { ptr->ActivateSubCutoff(m_subCuts[i], reg); }
|
|
}
|
|
n = m_procBiasedXS.size();
|
|
for(G4int i=0; i<n; ++i) {
|
|
if(ptr->GetProcessName() == m_procBiasedXS[i]) {
|
|
ptr->SetCrossSectionBiasingFactor(m_factBiasedXS[i],
|
|
m_weightBiasedXS[i]);
|
|
break;
|
|
}
|
|
}
|
|
n = m_procForced.size();
|
|
for(G4int i=0; i<n; ++i) {
|
|
if(ptr->GetProcessName() == m_procForced[i]) {
|
|
ptr->ActivateForcedInteraction(m_lengthForced[i],
|
|
m_regnamesForced[i],
|
|
m_weightForced[i]);
|
|
break;
|
|
}
|
|
}
|
|
n = m_procBiasedSec.size();
|
|
for(G4int i=0; i<n; ++i) {
|
|
if(ptr->GetProcessName() == m_procBiasedSec[i]) {
|
|
ptr->ActivateSecondaryBiasing(m_regnamesBiasedSec[i],
|
|
m_factBiasedSec[i],
|
|
m_elimBiasedSec[i]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void G4EmParameters::DefineRegParamForEM(G4VEmProcess* ptr) const
|
|
{
|
|
G4int n = m_procBiasedXS.size();
|
|
for(G4int i=0; i<n; ++i) {
|
|
if(ptr->GetProcessName() == m_procBiasedXS[i]) {
|
|
ptr->SetCrossSectionBiasingFactor(m_factBiasedXS[i],
|
|
m_weightBiasedXS[i]);
|
|
break;
|
|
}
|
|
}
|
|
n = m_procForced.size();
|
|
for(G4int i=0; i<n; ++i) {
|
|
if(ptr->GetProcessName() == m_procForced[i]) {
|
|
ptr->ActivateForcedInteraction(m_lengthForced[i],
|
|
m_regnamesForced[i],
|
|
m_weightForced[i]);
|
|
break;
|
|
}
|
|
}
|
|
n = m_procBiasedSec.size();
|
|
for(G4int i=0; i<n; ++i) {
|
|
if(ptr->GetProcessName() == m_procBiasedSec[i]) {
|
|
ptr->ActivateSecondaryBiasing(m_regnamesBiasedSec[i],
|
|
m_factBiasedSec[i],
|
|
m_elimBiasedSec[i]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void G4EmParameters::DefineRegParamForDeex(G4VAtomDeexcitation* ptr) const
|
|
{
|
|
G4int n = m_regnamesDeex.size();
|
|
for(G4int i=0; i<n; ++i) {
|
|
ptr->SetDeexcitationActiveRegion(m_regnamesDeex[i],
|
|
m_fluo[i], m_auger[i], m_pixe[i]);
|
|
}
|
|
}
|
|
|
|
std::ostream& G4EmParameters::StreamInfo(std::ostream& os) const
|
|
{
|
|
G4int prec = os.precision(5);
|
|
os << "=======================================================================" << "\n";
|
|
os << "====== Electromagnetic Physics Parameters ========" << "\n";
|
|
os << "=======================================================================" << "\n";
|
|
os << "LPM effect enabled " <<flagLPM << "\n";
|
|
os << "Spline of EM tables enabled " <<spline << "\n";
|
|
os << "Apply cuts on all EM processes " <<applyCuts << "\n";
|
|
os << "Use integral approach for tracking " <<integral << "\n";
|
|
os << "X-section factor for integral approach " <<lambdaFactor << "\n";
|
|
os << "Min kinetic energy for tables "
|
|
<<G4BestUnit(minKinEnergy,"Energy") << "\n";
|
|
os << "Max kinetic energy for tables "
|
|
<<G4BestUnit(maxKinEnergy,"Energy") << "\n";
|
|
os << "Number of bins in tables " <<nbins << "\n";
|
|
os << "Number of bins per decade of a table " <<nbinsPerDecade << "\n";
|
|
os << "Verbose level " <<verbose << "\n";
|
|
os << "Verbose level for worker thread " <<workerVerbose << "\n";
|
|
os << "Bremsstrahlung energy threshold above which \n"
|
|
<< " primary is added to the list of secondary "
|
|
<<G4BestUnit(bremsTh,"Energy") << "\n";
|
|
os << "Lowest triplet kinetic energy "
|
|
<<G4BestUnit(lowestTripletEnergy,"Energy") << "\n";
|
|
os << "5D gamma conversion model type " <<tripletConv << "\n";
|
|
os << "5D gamma conversion model on isolated ion " <<onIsolated << "\n";
|
|
|
|
os << "=======================================================================" << "\n";
|
|
os << "====== Ionisation Parameters ========" << "\n";
|
|
os << "=======================================================================" << "\n";
|
|
os << "Step function for e+- " <<"("<< dRoverRange
|
|
<< ", " << finalRange/CLHEP::mm << " mm)\n";
|
|
os << "Step function for muons/hadrons " <<"("<< dRoverRangeMuHad
|
|
<< ", " << finalRangeMuHad/CLHEP::mm << " mm)\n";
|
|
os << "Lowest e+e- kinetic energy "
|
|
<<G4BestUnit(lowestElectronEnergy,"Energy") << "\n";
|
|
os << "Lowest muon/hadron kinetic energy "
|
|
<<G4BestUnit(lowestMuHadEnergy,"Energy") << "\n";
|
|
os << "Fluctuations of dE/dx are enabled " <<lossFluctuation << "\n";
|
|
os << "Use built-in Birks satuaration " << birks << "\n";
|
|
os << "Build CSDA range enabled " <<buildCSDARange << "\n";
|
|
os << "Use cut as a final range enabled " <<finalRange << "\n";
|
|
os << "Enable angular generator interface "
|
|
<<useAngGeneratorForIonisation << "\n";
|
|
os << "Factor of cut reduction for sub-cutoff method " << minSubRange << "\n";
|
|
os << "Max kinetic energy for CSDA tables "
|
|
<<G4BestUnit(maxKinEnergyCSDA,"Energy") << "\n";
|
|
os << "Linear loss limit " <<linLossLimit << "\n";
|
|
|
|
os << "=======================================================================" << "\n";
|
|
os << "====== Multiple Scattering Parameters ========" << "\n";
|
|
os << "=======================================================================" << "\n";
|
|
os << "Type of msc step limit algorithm for e+- " <<mscStepLimit << "\n";
|
|
os << "Type of msc step limit algorithm for muons/hadrons " <<mscStepLimitMuHad << "\n";
|
|
os << "Msc lateral displacement for e+- enabled " <<lateralDisplacement << "\n";
|
|
os << "Msc lateral displacement for muons and hadrons " <<muhadLateralDisplacement << "\n";
|
|
os << "Urban msc model lateral displacement alg96 " <<lateralDisplacementAlg96 << "\n";
|
|
os << "Msc lateral displacement beyond geometry safety " <<latDisplacementBeyondSafety << "\n";
|
|
os << "Range factor for msc step limit for e+- " <<rangeFactor << "\n";
|
|
os << "Range factor for msc step limit for muons/hadrons " <<rangeFactorMuHad << "\n";
|
|
os << "Geometry factor for msc step limitation of e+- " <<geomFactor << "\n";
|
|
os << "Skin parameter for msc step limitation of e+- " <<skin << "\n";
|
|
os << "Use Mott correction for e- scattering " << useMottCorrection << "\n";
|
|
os << "Factor used for dynamic computation of angular \n"
|
|
<< " limit between single and multiple scattering " << factorForAngleLimit << "\n";
|
|
os << "Fixed angular limit between single \n"
|
|
<< " and multiple scattering "
|
|
<< thetaLimit/CLHEP::rad << " rad" << "\n";
|
|
os << "Upper energy limit for e+- multiple scattering "
|
|
<< energyLimit/CLHEP::MeV << " MeV" << "\n";
|
|
os << "Type of nuclear form-factor " <<nucFormfactor << "\n";
|
|
os << "Screening factor " <<factorScreen << "\n";
|
|
|
|
os << "=======================================================================" << "\n";
|
|
os << "====== Atomic Deexcitation Parameters ========" << "\n";
|
|
os << "=======================================================================" << "\n";
|
|
os << "Fluorescence enabled " <<fluo << "\n";
|
|
os << "Fluorescence Bearden data files enabled " <<beardenFluoDir << "\n";
|
|
os << "Auger electron production enabled " <<auger << "\n";
|
|
os << "Auger cascade enabled " <<augerCascade << "\n";
|
|
os << "PIXE atomic de-excitation enabled " <<pixe << "\n";
|
|
os << "De-excitation module ignores cuts " <<deexIgnoreCut << "\n";
|
|
os << "Type of PIXE cross section for hadrons " <<namePIXE << "\n";
|
|
os << "Type of PIXE cross section for e+- " <<nameElectronPIXE << "\n";
|
|
|
|
os << "=======================================================================" << "\n";
|
|
os << "====== DNA Physics Parameters ========" << "\n";
|
|
os << "=======================================================================" << "\n";
|
|
os << "Use fast sampling in DNA models " << dnaFast << "\n";
|
|
os << "Use Stationary option in DNA models " << dnaStationary << "\n";
|
|
os << "Use DNA with multiple scattering of e- " << dnaMsc << "\n";
|
|
os << "Use DNA e- solvation model type "
|
|
<< dnaElectronSolvation << "\n";
|
|
os << "=======================================================================" << "\n";
|
|
os.precision(prec);
|
|
return os;
|
|
}
|
|
|
|
void G4EmParameters::Dump() const
|
|
{
|
|
StreamInfo(G4cout);
|
|
}
|
|
|
|
std::ostream& operator<< (std::ostream& os, const G4EmParameters& par)
|
|
{
|
|
return par.StreamInfo(os);
|
|
}
|
|
|
|
G4bool G4EmParameters::IsLocked() const
|
|
{
|
|
return (!G4Threading::IsMasterThread() ||
|
|
(fStateManager->GetCurrentState() != G4State_PreInit &&
|
|
fStateManager->GetCurrentState() != G4State_Init &&
|
|
fStateManager->GetCurrentState() != G4State_Idle));
|
|
}
|
|
|
|
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
|