Geant4-11
Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Private Attributes
G4eBremsstrahlung Class Reference

#include <G4eBremsstrahlung.hh>

Inheritance diagram for G4eBremsstrahlung:
G4VEnergyLossProcess G4VContinuousDiscreteProcess G4VProcess G4PolarizedBremsstrahlung

Public Member Functions

void ActivateForcedInteraction (G4double length, const G4String &region, G4bool flag=true)
 
void ActivateSecondaryBiasing (const G4String &region, G4double factor, G4double energyLimit)
 
void ActivateSubCutoff (const G4Region *region)
 
void AddEmModel (G4int, G4VEmModel *, G4VEmFluctuationModel *fluc=nullptr, const G4Region *region=nullptr)
 
G4VParticleChangeAlongStepDoIt (const G4Track &, const G4Step &) override
 
G4double AlongStepGetPhysicalInteractionLength (const G4Track &, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety, G4GPILSelection *selection) override
 
G4double AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
 
virtual G4VParticleChangeAtRestDoIt (const G4Track &, const G4Step &)
 
virtual G4double AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
 
G4double AtRestGPIL (const G4Track &track, G4ForceCondition *condition)
 
const G4ParticleDefinitionBaseParticle () const
 
G4PhysicsTableBuildDEDXTable (G4EmTableType tType=fRestricted)
 
G4PhysicsTableBuildLambdaTable (G4EmTableType tType=fRestricted)
 
void BuildPhysicsTable (const G4ParticleDefinition &) override
 
virtual void BuildWorkerPhysicsTable (const G4ParticleDefinition &part)
 
G4double ContinuousStepLimit (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety)
 
G4double CrossSectionBiasingFactor () const
 
G4double CrossSectionPerVolume (G4double kineticEnergy, const G4MaterialCutsCouple *couple)
 
G4double CrossSectionPerVolume (G4double kineticEnergy, const G4MaterialCutsCouple *couple, G4double logKineticEnergy)
 
G4CrossSectionType CrossSectionType () const
 
G4PhysicsTableCSDARangeTable () const
 
G4PhysicsTableDEDXTable () const
 
G4PhysicsTableDEDXunRestrictedTable () const
 
virtual void DumpInfo () const
 
G4VEmModelEmModel (size_t index=0) const
 
virtual void EndTracking ()
 
G4VEmFluctuationModelFluctModel () const
 
 G4eBremsstrahlung (const G4eBremsstrahlung &)=delete
 
 G4eBremsstrahlung (const G4String &name="eBrem")
 
G4double GetCSDADEDX (G4double kineticEnergy, const G4MaterialCutsCouple *)
 
G4double GetCSDARange (G4double kineticEnergy, const G4MaterialCutsCouple *)
 
const G4ElementGetCurrentElement () const
 
G4double GetCurrentInteractionLength () const
 
G4double GetDEDX (G4double kineticEnergy, const G4MaterialCutsCouple *)
 
G4double GetDEDX (G4double kineticEnergy, const G4MaterialCutsCouple *, G4double logKineticEnergy)
 
G4double GetDEDXDispersion (const G4MaterialCutsCouple *couple, const G4DynamicParticle *dp, G4double length)
 
G4double GetKineticEnergy (G4double range, const G4MaterialCutsCouple *)
 
G4double GetLambda (G4double kineticEnergy, const G4MaterialCutsCouple *)
 
G4double GetLambda (G4double kineticEnergy, const G4MaterialCutsCouple *, G4double logKineticEnergy)
 
const G4VProcessGetMasterProcess () const
 
G4VEmModelGetModelByIndex (size_t idx=0, G4bool ver=false) const
 
G4double GetNumberOfInteractionLengthLeft () const
 
const G4StringGetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
 
G4double GetPILfactor () const
 
virtual const G4ProcessManagerGetProcessManager ()
 
const G4StringGetProcessName () const
 
G4int GetProcessSubType () const
 
G4ProcessType GetProcessType () const
 
G4double GetRange (G4double kineticEnergy, const G4MaterialCutsCouple *)
 
G4double GetRange (G4double kineticEnergy, const G4MaterialCutsCouple *, G4double logKineticEnergy)
 
G4double GetTotalNumberOfInteractionLengthTraversed () const
 
G4int GetVerboseLevel () const
 
G4PhysicsTableInverseRangeTable () const
 
G4PhysicsTableIonisationTable () const
 
G4bool isAlongStepDoItIsEnabled () const
 
G4bool IsApplicable (const G4ParticleDefinition &p) final
 
G4bool isAtRestDoItIsEnabled () const
 
G4bool IsIonisationProcess () const
 
G4bool isPostStepDoItIsEnabled () const
 
G4PhysicsTableLambdaTable () const
 
G4double MaxKinEnergy () const
 
G4double MeanFreePath (const G4Track &track)
 
G4double MinKinEnergy () const
 
size_t NumberOfModels () const
 
G4int NumberOfSubCutoffRegions () const
 
G4bool operator!= (const G4VProcess &right) const
 
G4eBremsstrahlungoperator= (const G4eBremsstrahlung &right)=delete
 
G4bool operator== (const G4VProcess &right) const
 
const G4ParticleDefinitionParticle () const
 
G4VParticleChangePostStepDoIt (const G4Track &, const G4Step &) override
 
G4double PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition) override
 
G4double PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
 
void PreparePhysicsTable (const G4ParticleDefinition &) override
 
virtual void PrepareWorkerPhysicsTable (const G4ParticleDefinition &)
 
void ProcessDescription (std::ostream &) const override
 
G4PhysicsTableRangeTableForLoss () const
 
virtual void ResetNumberOfInteractionLengthLeft ()
 
G4bool RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii) override
 
const G4ParticleDefinitionSecondaryParticle () const
 
G4PhysicsTableSecondaryRangeTable () const
 
G4VEmModelSelectModelForMaterial (G4double kinEnergy, size_t &idxCouple) const
 
void SetBaseParticle (const G4ParticleDefinition *p)
 
void SetCrossSectionBiasingFactor (G4double f, G4bool flag=true)
 
void SetCrossSectionType (G4CrossSectionType val)
 
void SetCSDARangeTable (G4PhysicsTable *pRange)
 
void SetDEDXBinning (G4int nbins)
 
void SetDEDXTable (G4PhysicsTable *p, G4EmTableType tType)
 
void SetDynamicMassCharge (G4double massratio, G4double charge2ratio)
 
void SetEmModel (G4VEmModel *, G4int index=0)
 
void SetFluctModel (G4VEmFluctuationModel *)
 
void SetInverseRangeTable (G4PhysicsTable *p)
 
void SetIonisation (G4bool val)
 
void SetLambdaTable (G4PhysicsTable *p)
 
void SetLinearLossLimit (G4double val)
 
void SetLossFluctuations (G4bool val)
 
void SetLowestEnergyLimit (G4double)
 
virtual void SetMasterProcess (G4VProcess *masterP)
 
void SetMaxKinEnergy (G4double e)
 
void SetMinKinEnergy (G4double e)
 
void SetPILfactor (G4double value)
 
virtual void SetProcessManager (const G4ProcessManager *)
 
void SetProcessSubType (G4int)
 
void SetProcessType (G4ProcessType)
 
void SetRangeTableForLoss (G4PhysicsTable *p)
 
void SetSecondaryRangeTable (G4PhysicsTable *p)
 
void SetSpline (G4bool val)
 
void SetStepFunction (G4double v1, G4double v2)
 
void SetTwoPeaksXS (std::vector< G4TwoPeaksXS * > *p)
 
void SetVerboseLevel (G4int value)
 
void StartTracking (G4Track *) override
 
G4bool StorePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii=false) override
 
G4bool TablesAreBuilt () const
 
std::vector< G4TwoPeaksXS * > * TwoPeaksXS () const
 
G4bool UseBaseMaterial () const
 
 ~G4eBremsstrahlung () override
 

Static Public Member Functions

static const G4StringGetProcessTypeName (G4ProcessType)
 

Protected Member Functions

void ClearNumberOfInteractionLengthLeft ()
 
size_t CurrentMaterialCutsCoupleIndex () const
 
G4double GetContinuousStepLimit (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety) override
 
G4GPILSelection GetGPILSelection () const
 
G4double GetMeanFreePath (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition) override
 
void InitialiseEnergyLossProcess (const G4ParticleDefinition *, const G4ParticleDefinition *) override
 
G4PhysicsVectorLambdaPhysicsVector (const G4MaterialCutsCouple *, G4double cut)
 
virtual G4double MinPrimaryEnergy (const G4ParticleDefinition *, const G4Material *, G4double cut)
 
void SelectModel (G4double kinEnergy)
 
void SetGPILSelection (G4GPILSelection selection)
 
void SetParticle (const G4ParticleDefinition *p)
 
void SetSecondaryParticle (const G4ParticleDefinition *p)
 
void StreamProcessInfo (std::ostream &outFile) const override
 
void SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)
 

Protected Attributes

G4ParticleChange aParticleChange
 
const G4ProcessManageraProcessManager = nullptr
 
const G4MaterialCutsCouplecurrentCouple = nullptr
 
size_t currentCoupleIndex = 0
 
G4double currentInteractionLength = -1.0
 
const G4MaterialcurrentMaterial = nullptr
 
G4bool enableAlongStepDoIt = true
 
G4bool enableAtRestDoIt = true
 
G4bool enablePostStepDoIt = true
 
G4ParticleChangeForLoss fParticleChange
 
G4double mfpKinEnergy = 0.0
 
G4VParticleChangepParticleChange = nullptr
 
G4double preStepKinEnergy = 0.0
 
G4double preStepLambda = 0.0
 
G4double preStepLogKinEnergy = LOG_EKIN_MIN
 
G4double preStepLogScaledEnergy = LOG_EKIN_MIN
 
G4double preStepScaledEnergy = 0.0
 
G4double theInitialNumberOfInteractionLength = -1.0
 
G4double theNumberOfInteractionLengthLeft = -1.0
 
G4String thePhysicsTableFileName
 
G4double thePILfactor = 1.0
 
G4String theProcessName
 
G4int theProcessSubType = -1
 
G4ProcessType theProcessType = fNotDefined
 
G4int verboseLevel = 0
 

Private Member Functions

void ComputeLambdaForScaledEnergy (G4double scaledKinE, G4double logScaledKinE)
 
void DefineMaterial (const G4MaterialCutsCouple *couple)
 
void FillSecondariesAlongStep (G4double weight)
 
G4double GetDEDXForScaledEnergy (G4double scaledKinE)
 
G4double GetDEDXForScaledEnergy (G4double scaledKinE, G4double logScaledKinE)
 
G4double GetIonisationForScaledEnergy (G4double scaledKinE)
 
G4double GetLambdaForScaledEnergy (G4double scaledKinE)
 
G4double GetLambdaForScaledEnergy (G4double scaledKinE, G4double logScaledKinE)
 
G4double GetLimitScaledRangeForScaledEnergy (G4double scaledKinE)
 
G4double GetLimitScaledRangeForScaledEnergy (G4double scaledKinE, G4double logScaledKinE)
 
G4double GetScaledRangeForScaledEnergy (G4double scaledKinE)
 
G4double GetScaledRangeForScaledEnergy (G4double scaledKinE, G4double logScaledKinE)
 
G4bool IsRegionForCubcutProcessor (const G4Track &aTrack)
 
void PrintWarning (const G4String &, G4double val) const
 
G4bool RetrieveTable (const G4ParticleDefinition *p, G4PhysicsTable *, G4bool ascii, const G4String &directory, const G4String &tname, G4bool mandatory)
 
G4double ScaledKinEnergyForLoss (G4double range)
 
G4bool StoreTable (const G4ParticleDefinition *p, G4PhysicsTable *, G4bool ascii, const G4String &directory, const G4String &tname)
 
void StreamInfo (std::ostream &out, const G4ParticleDefinition &part, G4bool rst=false) const
 

Private Attributes

G4bool actBinning = false
 
G4bool actLinLossLimit = false
 
G4bool actLossFluc = false
 
G4bool actMaxKinEnergy = false
 
G4bool actMinKinEnergy = false
 
G4GPILSelection aGPILSelection
 
G4VAtomDeexcitationatomDeexcitation = nullptr
 
size_t basedCoupleIndex = 0
 
G4bool baseMat = false
 
const G4ParticleDefinitionbaseParticle = nullptr
 
G4double biasFactor = 1.0
 
G4bool biasFlag = false
 
G4int biasID = _DeltaEBelowCut
 
G4EmBiasingManagerbiasManager = nullptr
 
G4double chargeSqRatio = 1.0
 
size_t coupleIdxLambda = 0
 
size_t coupleIdxRange = 0
 
G4VEmModelcurrentModel = nullptr
 
G4double dRoverRange = 0.2
 
std::vector< G4VEmModel * > * emModels = nullptr
 
G4double fFactor = 1.0
 
G4double finalRange
 
G4double fLambda = 0.0
 
G4double fLambdaEnergy = 0.0
 
G4VEmFluctuationModelfluctModel = nullptr
 
G4ProcessTablefProcessTable = nullptr
 
G4double fRange = 0.0
 
G4double fRangeEnergy = 0.0
 
std::vector< G4TwoPeaksXS * > * fXSpeaks = nullptr
 
G4CrossSectionType fXSType = fEmIncreasing
 
size_t idxCSDA = 0
 
size_t idxDEDX = 0
 
size_t idxDEDXunRestricted = 0
 
size_t idxInverseRange = 0
 
size_t idxIonisation = 0
 
size_t idxLambda = 0
 
size_t idxRange = 0
 
size_t idxSecRange = 0
 
G4bool isInitialised = false
 
G4bool isIon = false
 
G4bool isIonisation = true
 
G4bool isMaster = true
 
G4double lambdaFactor = 1.0
 
G4double linLossLimit = 0.01
 
G4LossTableManagerlManager
 
G4double logLambdafactor = 0.0
 
G4double logMassRatio = 0.0
 
G4bool lossFluctuationFlag = true
 
G4double lowestKinEnergy
 
G4int mainSecondaries = 1
 
G4double massRatio = 1.0
 
G4VProcessmasterProcessShadow = nullptr
 
G4double maxKinEnergy
 
G4double maxKinEnergyCSDA
 
G4double minKinEnergy
 
G4EmModelManagermodelManager
 
G4int nBins
 
G4int nBinsCSDA
 
G4int nSCoffRegions = 0
 
G4int numberOfModels = 0
 
const G4ParticleDefinitionparticle = nullptr
 
G4double reduceFactor = 1.0
 
G4bool rndmStepFlag = false
 
G4SafetyHelpersafetyHelper
 
std::vector< const G4Region * > * scoffRegions = nullptr
 
std::vector< G4Track * > scTracks
 
G4int secID = _DeltaElectron
 
const G4ParticleDefinitionsecondaryParticle = nullptr
 
std::vector< G4DynamicParticle * > secParticles
 
G4bool spline = true
 
G4VSubCutProducersubcutProducer = nullptr
 
G4bool tablesAreBuilt = false
 
G4PhysicsTabletheCSDARangeTable = nullptr
 
const G4DataVectortheCuts = nullptr
 
G4PhysicsTabletheDEDXTable = nullptr
 
G4PhysicsTabletheDEDXunRestrictedTable = nullptr
 
const std::vector< G4double > * theDensityFactor = nullptr
 
const std::vector< G4int > * theDensityIdx = nullptr
 
const G4ParticleDefinitiontheElectron
 
const G4ParticleDefinitiontheGamma
 
const G4ParticleDefinitiontheGenericIon = nullptr
 
G4PhysicsTabletheInverseRangeTable = nullptr
 
G4PhysicsTabletheIonisationSubTable = nullptr
 
G4PhysicsTabletheIonisationTable = nullptr
 
G4PhysicsTabletheLambdaTable = nullptr
 
G4EmParameterstheParameters
 
const G4ParticleDefinitionthePositron
 
G4PhysicsTabletheRangeTableForLoss = nullptr
 
G4PhysicsTabletheSecondaryRangeTable = nullptr
 
G4int tripletID = _TripletElectron
 
G4bool useDeexcitation = false
 
G4GPILSelection valueGPILSelection = CandidateForSelection
 
G4bool weightFlag = false
 

Detailed Description

Definition at line 80 of file G4eBremsstrahlung.hh.

Constructor & Destructor Documentation

◆ G4eBremsstrahlung() [1/2]

G4eBremsstrahlung::G4eBremsstrahlung ( const G4String name = "eBrem")
explicit

Definition at line 61 of file G4eBremsstrahlung.cc.

61 :
63{
66 SetIonisation(false);
68}
@ fBremsstrahlung
@ fEmTwoPeaks
static G4Gamma * Gamma()
Definition: G4Gamma.cc:85
void SetCrossSectionType(G4CrossSectionType val)
void SetIonisation(G4bool val)
G4VEnergyLossProcess(const G4String &name="EnergyLoss", G4ProcessType type=fElectromagnetic)
void SetSecondaryParticle(const G4ParticleDefinition *p)
void SetProcessSubType(G4int)
Definition: G4VProcess.hh:406
const char * name(G4int ptype)

References fBremsstrahlung, fEmTwoPeaks, G4Gamma::Gamma(), G4VEnergyLossProcess::SetCrossSectionType(), G4VEnergyLossProcess::SetIonisation(), G4VProcess::SetProcessSubType(), and G4VEnergyLossProcess::SetSecondaryParticle().

◆ ~G4eBremsstrahlung()

G4eBremsstrahlung::~G4eBremsstrahlung ( )
override

Definition at line 72 of file G4eBremsstrahlung.cc.

73{}

◆ G4eBremsstrahlung() [2/2]

G4eBremsstrahlung::G4eBremsstrahlung ( const G4eBremsstrahlung )
delete

Member Function Documentation

◆ ActivateForcedInteraction()

void G4VEnergyLossProcess::ActivateForcedInteraction ( G4double  length,
const G4String region,
G4bool  flag = true 
)
inherited

Definition at line 1915 of file G4VEnergyLossProcess.cc.

1918{
1919 if(nullptr == biasManager) { biasManager = new G4EmBiasingManager(); }
1920 if(1 < verboseLevel) {
1921 G4cout << "### ActivateForcedInteraction: for "
1922 << " process " << GetProcessName()
1923 << " length(mm)= " << length/mm
1924 << " in G4Region <" << region
1925 << "> weightFlag= " << flag
1926 << G4endl;
1927 }
1928 weightFlag = flag;
1929 biasManager->ActivateForcedInteraction(length, region);
1930}
static constexpr double mm
Definition: G4SIunits.hh:95
#define G4endl
Definition: G4ios.hh:57
G4GLOB_DLL std::ostream G4cout
void ActivateForcedInteraction(G4double length=0.0, const G4String &r="")
G4EmBiasingManager * biasManager
G4int verboseLevel
Definition: G4VProcess.hh:356
const G4String & GetProcessName() const
Definition: G4VProcess.hh:382

References G4EmBiasingManager::ActivateForcedInteraction(), G4VEnergyLossProcess::biasManager, G4cout, G4endl, G4VProcess::GetProcessName(), mm, G4VProcess::verboseLevel, and G4VEnergyLossProcess::weightFlag.

Referenced by G4EmExtraParameters::DefineRegParamForLoss().

◆ ActivateSecondaryBiasing()

void G4VEnergyLossProcess::ActivateSecondaryBiasing ( const G4String region,
G4double  factor,
G4double  energyLimit 
)
inherited

Definition at line 1935 of file G4VEnergyLossProcess.cc.

1938{
1939 if (0.0 <= factor) {
1940 // Range cut can be applied only for e-
1941 if(0.0 == factor && secondaryParticle != G4Electron::Electron())
1942 { return; }
1943
1944 if(nullptr == biasManager) { biasManager = new G4EmBiasingManager(); }
1945 biasManager->ActivateSecondaryBiasing(region, factor, energyLimit);
1946 if(1 < verboseLevel) {
1947 G4cout << "### ActivateSecondaryBiasing: for "
1948 << " process " << GetProcessName()
1949 << " factor= " << factor
1950 << " in G4Region <" << region
1951 << "> energyLimit(MeV)= " << energyLimit/MeV
1952 << G4endl;
1953 }
1954 }
1955}
static constexpr double MeV
Definition: G4SIunits.hh:200
static G4Electron * Electron()
Definition: G4Electron.cc:93
void ActivateSecondaryBiasing(const G4String &region, G4double factor, G4double energyLimit)
const G4ParticleDefinition * secondaryParticle

References G4EmBiasingManager::ActivateSecondaryBiasing(), G4VEnergyLossProcess::biasManager, G4Electron::Electron(), G4cout, G4endl, G4VProcess::GetProcessName(), MeV, G4VEnergyLossProcess::secondaryParticle, and G4VProcess::verboseLevel.

Referenced by G4EmExtraParameters::DefineRegParamForLoss().

◆ ActivateSubCutoff()

void G4VEnergyLossProcess::ActivateSubCutoff ( const G4Region region)
inherited

Definition at line 799 of file G4VEnergyLossProcess.cc.

800{
801 if(nullptr == scoffRegions) {
802 scoffRegions = new std::vector<const G4Region*>;
803 }
804 // the region is in the list
805 if(!scoffRegions->empty()) {
806 for (auto & reg : *scoffRegions) {
807 if (reg == r) { return; }
808 }
809 }
810 // new region
811 scoffRegions->push_back(r);
813}
static const G4double reg
std::vector< const G4Region * > * scoffRegions

References G4VEnergyLossProcess::nSCoffRegions, reg, and G4VEnergyLossProcess::scoffRegions.

Referenced by G4EmExtraParameters::DefineRegParamForLoss().

◆ AddEmModel()

void G4VEnergyLossProcess::AddEmModel ( G4int  order,
G4VEmModel ptr,
G4VEmFluctuationModel fluc = nullptr,
const G4Region region = nullptr 
)
inherited

Definition at line 216 of file G4VEnergyLossProcess.cc.

219{
220 if(nullptr == ptr) { return; }
221 G4VEmFluctuationModel* afluc = (nullptr == fluc) ? fluctModel : fluc;
222 modelManager->AddEmModel(order, ptr, afluc, region);
224}
void AddEmModel(G4int, G4VEmModel *, G4VEmFluctuationModel *fm, const G4Region *r)
void SetParticleChange(G4VParticleChange *, G4VEmFluctuationModel *f=nullptr)
Definition: G4VEmModel.cc:447
G4EmModelManager * modelManager
G4VEmFluctuationModel * fluctModel
G4VParticleChange * pParticleChange
Definition: G4VProcess.hh:321

References G4EmModelManager::AddEmModel(), G4VEnergyLossProcess::fluctModel, G4VEnergyLossProcess::modelManager, G4VProcess::pParticleChange, and G4VEmModel::SetParticleChange().

Referenced by LBE::ConstructEM(), G4EmLivermorePhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4hhIonisation::InitialiseEnergyLossProcess(), G4mplIonisation::InitialiseEnergyLossProcess(), G4ePairProduction::InitialiseEnergyLossProcess(), G4MuBremsstrahlung::InitialiseEnergyLossProcess(), G4MuIonisation::InitialiseEnergyLossProcess(), G4MuPairProduction::InitialiseEnergyLossProcess(), G4PolarizedBremsstrahlung::InitialiseEnergyLossProcess(), G4PolarizedIonisation::InitialiseEnergyLossProcess(), InitialiseEnergyLossProcess(), G4eIonisation::InitialiseEnergyLossProcess(), G4hIonisation::InitialiseEnergyLossProcess(), G4ionIonisation::InitialiseEnergyLossProcess(), G4EmConfigurator::PrepareModels(), and G4EmConfigurator::SetModelForRegion().

◆ AlongStepDoIt()

G4VParticleChange * G4VEnergyLossProcess::AlongStepDoIt ( const G4Track track,
const G4Step step 
)
overridevirtualinherited

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 1059 of file G4VEnergyLossProcess.cc.

1061{
1063 // The process has range table - calculate energy loss
1065 return &fParticleChange;
1066 }
1067
1068 // Get the actual (true) Step length
1069 G4double length = step.GetStepLength();
1070 if(length <= 0.0) { return &fParticleChange; }
1071 G4double eloss = 0.0;
1072
1073 /*
1074 if(-1 < verboseLevel) {
1075 const G4ParticleDefinition* d = track.GetParticleDefinition();
1076 G4cout << "AlongStepDoIt for "
1077 << GetProcessName() << " and particle "
1078 << d->GetParticleName()
1079 << " eScaled(MeV)= " << preStepScaledEnergy/MeV
1080 << " range(mm)= " << fRange/mm
1081 << " s(mm)= " << length/mm
1082 << " rf= " << reduceFactor
1083 << " q^2= " << chargeSqRatio
1084 << " md= " << d->GetPDGMass()
1085 << " status= " << track.GetTrackStatus()
1086 << " " << track.GetMaterial()->GetName()
1087 << G4endl;
1088 }
1089 */
1090
1091 const G4DynamicParticle* dynParticle = track.GetDynamicParticle();
1092
1093 // define new weight for primary and secondaries
1095 if(weightFlag) {
1096 weight /= biasFactor;
1098 }
1099
1100 // stopping
1101 if (length >= fRange || preStepKinEnergy <= lowestKinEnergy) {
1102 eloss = preStepKinEnergy;
1103 if (useDeexcitation) {
1105 eloss, currentCoupleIndex);
1106 if(scTracks.size() > 0) { FillSecondariesAlongStep(weight); }
1107 eloss = std::max(eloss, 0.0);
1108 }
1111 return &fParticleChange;
1112 }
1113 //G4cout << theDEDXTable << " idx= " << basedCoupleIndex
1114 // << " " << GetProcessName() << " "<< currentMaterial->GetName()<<G4endl;
1115 //if(particle->GetParticleName() == "e-")G4cout << (*theDEDXTable) <<G4endl;
1116 // Short step
1119
1120 //G4cout << "Short STEP: eloss= " << eloss << G4endl;
1121
1122 // Long step
1123 if(eloss > preStepKinEnergy*linLossLimit) {
1124
1125 G4double x = (fRange - length)/reduceFactor;
1126 //G4cout << "x= " << x << " " << theInverseRangeTable << G4endl;
1128
1129 /*
1130 if(-1 < verboseLevel)
1131 G4cout << "Long STEP: rPre(mm)= "
1132 << GetScaledRangeForScaledEnergy(preStepScaledEnergy)/mm
1133 << " rPost(mm)= " << x/mm
1134 << " ePre(MeV)= " << preStepScaledEnergy/MeV
1135 << " eloss(MeV)= " << eloss/MeV
1136 << " eloss0(MeV)= "
1137 << GetDEDXForScaledEnergy(preStepScaledEnergy)*length/MeV
1138 << " lim(MeV)= " << preStepKinEnergy*linLossLimit/MeV
1139 << G4endl;
1140 */
1141 }
1142
1143 /*
1144 G4double eloss0 = eloss;
1145 if(-1 < verboseLevel ) {
1146 G4cout << "Before fluct: eloss(MeV)= " << eloss/MeV
1147 << " e-eloss= " << preStepKinEnergy-eloss
1148 << " step(mm)= " << length/mm
1149 << " range(mm)= " << fRange/mm
1150 << " fluct= " << lossFluctuationFlag
1151 << G4endl;
1152 }
1153 */
1154
1155 const G4double cut = (*theCuts)[currentCoupleIndex];
1156 G4double esec = 0.0;
1157
1158 // Corrections, which cannot be tabulated
1159 if(isIon) {
1161 length, eloss);
1162 eloss = std::max(eloss, 0.0);
1163 }
1164
1165 // Sample fluctuations if not full energy loss
1166 if(eloss >= preStepKinEnergy) {
1167 eloss = preStepKinEnergy;
1168
1169 } else if (lossFluctuationFlag) {
1170 const G4double tmax = currentModel->MaxSecondaryKinEnergy(dynParticle);
1171 const G4double tcut = std::min(cut, tmax);
1173 eloss = fluc->SampleFluctuations(currentCouple,dynParticle,
1174 tcut, tmax, length, eloss);
1175 /*
1176 if(-1 < verboseLevel)
1177 G4cout << "After fluct: eloss(MeV)= " << eloss/MeV
1178 << " fluc= " << (eloss-eloss0)/MeV
1179 << " ChargeSqRatio= " << chargeSqRatio
1180 << " massRatio= " << massRatio
1181 << " tmax= " << tmax
1182 << G4endl;
1183 */
1184 }
1185
1186 // deexcitation
1187 if (useDeexcitation) {
1188 G4double esecfluo = preStepKinEnergy;
1189 G4double de = esecfluo;
1190 //G4double eloss0 = eloss;
1191 /*
1192 G4cout << "### 1: E(keV)= " << preStepKinEnergy/keV
1193 << " Efluomax(keV)= " << de/keV
1194 << " Eloss(keV)= " << eloss/keV << G4endl;
1195 */
1197 de, currentCoupleIndex);
1198
1199 // sum of de-excitation energies
1200 esecfluo -= de;
1201
1202 // subtracted from energy loss
1203 if(eloss >= esecfluo) {
1204 esec += esecfluo;
1205 eloss -= esecfluo;
1206 } else {
1207 esec += esecfluo;
1208 eloss = 0.0;
1209 }
1210 /*
1211 if(esecfluo > 0.0) {
1212 G4cout << "### 2: E(keV)= " << preStepKinEnergy/keV
1213 << " Esec(keV)= " << esec/keV
1214 << " Esecf(kV)= " << esecfluo/keV
1215 << " Eloss0(kV)= " << eloss0/keV
1216 << " Eloss(keV)= " << eloss/keV
1217 << G4endl;
1218 }
1219 */
1220 }
1221 if(nullptr != subcutProducer && IsRegionForCubcutProcessor(track)) {
1222 subcutProducer->SampleSecondaries(step, scTracks, eloss, cut);
1223 }
1224 // secondaries from atomic de-excitation and subcut
1225 if(!scTracks.empty()) { FillSecondariesAlongStep(weight); }
1226
1227 // Energy balance
1228 G4double finalT = preStepKinEnergy - eloss - esec;
1229 if (finalT <= lowestKinEnergy) {
1230 eloss += finalT;
1231 finalT = 0.0;
1232 } else if(isIon) {
1235 currentMaterial,finalT));
1236 }
1237 eloss = std::max(eloss, 0.0);
1238
1241 /*
1242 if(-1 < verboseLevel) {
1243 G4double del = finalT + eloss + esec - preStepKinEnergy;
1244 G4cout << "Final value eloss(MeV)= " << eloss/MeV
1245 << " preStepKinEnergy= " << preStepKinEnergy
1246 << " postStepKinEnergy= " << finalT
1247 << " de(keV)= " << del/keV
1248 << " lossFlag= " << lossFluctuationFlag
1249 << " status= " << track.GetTrackStatus()
1250 << G4endl;
1251 }
1252 */
1253 return &fParticleChange;
1254}
double G4double
Definition: G4Types.hh:83
void InitializeForAlongStep(const G4Track &)
void SetProposedKineticEnergy(G4double proposedKinEnergy)
void SetProposedCharge(G4double theCharge)
G4double GetStepLength() const
const G4ParticleDefinition * GetParticleDefinition() const
const G4DynamicParticle * GetDynamicParticle() const
void AlongStepDeexcitation(std::vector< G4Track * > &tracks, const G4Step &step, G4double &eLoss, G4int coupleIndex)
virtual G4double SampleFluctuations(const G4MaterialCutsCouple *, const G4DynamicParticle *, const G4double tcut, const G4double tmax, const G4double length, const G4double meanLoss)=0
G4VEmFluctuationModel * GetModelOfFluctuations()
Definition: G4VEmModel.hh:614
virtual G4double GetParticleCharge(const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
Definition: G4VEmModel.cc:391
G4bool IsActive(G4double kinEnergy) const
Definition: G4VEmModel.hh:795
virtual void CorrectionsAlongStep(const G4MaterialCutsCouple *, const G4DynamicParticle *, const G4double &length, G4double &eloss)
Definition: G4VEmModel.cc:399
G4double MaxSecondaryKinEnergy(const G4DynamicParticle *dynParticle)
Definition: G4VEmModel.hh:520
G4double GetDEDXForScaledEnergy(G4double scaledKinE)
G4double ScaledKinEnergyForLoss(G4double range)
G4ParticleChangeForLoss fParticleChange
const G4MaterialCutsCouple * currentCouple
G4VSubCutProducer * subcutProducer
const G4Material * currentMaterial
void FillSecondariesAlongStep(G4double weight)
G4bool IsRegionForCubcutProcessor(const G4Track &aTrack)
std::vector< G4Track * > scTracks
G4VAtomDeexcitation * atomDeexcitation
G4double GetParentWeight() const
void ProposeWeight(G4double finalWeight)
void ProposeLocalEnergyDeposit(G4double anEnergyPart)
virtual void SampleSecondaries(const G4Step &step, std::vector< G4Track * > &tracks, G4double &eloss, G4double cut) const =0
T max(const T t1, const T t2)
brief Return the largest of the two arguments
T min(const T t1, const T t2)
brief Return the smallest of the two arguments

References G4VAtomDeexcitation::AlongStepDeexcitation(), G4VEnergyLossProcess::atomDeexcitation, G4VEnergyLossProcess::biasFactor, G4VEmModel::CorrectionsAlongStep(), G4VEnergyLossProcess::currentCouple, G4VEnergyLossProcess::currentCoupleIndex, G4VEnergyLossProcess::currentMaterial, G4VEnergyLossProcess::currentModel, G4VEnergyLossProcess::FillSecondariesAlongStep(), G4VEnergyLossProcess::fParticleChange, G4VEnergyLossProcess::fRange, G4VEnergyLossProcess::GetDEDXForScaledEnergy(), G4Track::GetDynamicParticle(), G4VEmModel::GetModelOfFluctuations(), G4VParticleChange::GetParentWeight(), G4VEmModel::GetParticleCharge(), G4Track::GetParticleDefinition(), G4Step::GetStepLength(), G4ParticleChangeForLoss::InitializeForAlongStep(), G4VEmModel::IsActive(), G4VEnergyLossProcess::isIon, G4VEnergyLossProcess::isIonisation, G4VEnergyLossProcess::IsRegionForCubcutProcessor(), G4VEnergyLossProcess::linLossLimit, G4VEnergyLossProcess::lossFluctuationFlag, G4VEnergyLossProcess::lowestKinEnergy, G4VEnergyLossProcess::massRatio, G4INCL::Math::max(), G4VEmModel::MaxSecondaryKinEnergy(), G4INCL::Math::min(), G4VEnergyLossProcess::preStepKinEnergy, G4VEnergyLossProcess::preStepLogScaledEnergy, G4VEnergyLossProcess::preStepScaledEnergy, G4VParticleChange::ProposeLocalEnergyDeposit(), G4VParticleChange::ProposeWeight(), G4VEnergyLossProcess::reduceFactor, G4VEmFluctuationModel::SampleFluctuations(), G4VSubCutProducer::SampleSecondaries(), G4VEnergyLossProcess::ScaledKinEnergyForLoss(), G4VEnergyLossProcess::scTracks, G4ParticleChangeForLoss::SetProposedCharge(), G4ParticleChangeForLoss::SetProposedKineticEnergy(), G4VEnergyLossProcess::subcutProducer, G4VEnergyLossProcess::useDeexcitation, and G4VEnergyLossProcess::weightFlag.

◆ AlongStepGetPhysicalInteractionLength()

G4double G4VEnergyLossProcess::AlongStepGetPhysicalInteractionLength ( const G4Track ,
G4double  previousStepSize,
G4double  currentMinimumStep,
G4double currentSafety,
G4GPILSelection selection 
)
overridevirtualinherited

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 872 of file G4VEnergyLossProcess.cc.

875{
876 G4double x = DBL_MAX;
877 *selection = aGPILSelection;
880 const G4double finR = (rndmStepFlag) ? std::min(finalRange,
882 x = (fRange > finR) ?
883 fRange*dRoverRange + finR*(1.0-dRoverRange)*(2.0-finR/fRange) : fRange;
884 // if(particle->GetPDGMass() > 0.9*GeV)
885 /*
886 G4cout << GetProcessName() << ": e= " << preStepKinEnergy
887 <<" range= "<<fRange << " idx= " << basedCoupleIndex
888 << " finR= " << finR << " limit= " << x <<
889 << "\n" << "massRatio= " << massRatio << " Q^2= " << chargeSqRatio
890 << " dRoverRange= " << dRoverRange
891 << " finalRange= " << finalRange << G4endl;
892 */
893 }
894 //G4cout<<"AlongStepGPIL: " << GetProcessName()<<": e= "<<preStepKinEnergy
895 //<<" stepLimit= "<<x<<G4endl;
896 return x;
897}
G4ProductionCuts * GetProductionCuts() const
G4double GetProductionCut(G4int index) const
G4double GetScaledRangeForScaledEnergy(G4double scaledKinE)
G4GPILSelection aGPILSelection
#define DBL_MAX
Definition: templates.hh:62

References G4VEnergyLossProcess::aGPILSelection, G4VEnergyLossProcess::currentCouple, G4VEnergyLossProcess::currentModel, DBL_MAX, G4VEnergyLossProcess::dRoverRange, G4VEnergyLossProcess::finalRange, G4VEnergyLossProcess::fRange, G4ProductionCuts::GetProductionCut(), G4MaterialCutsCouple::GetProductionCuts(), G4VEnergyLossProcess::GetScaledRangeForScaledEnergy(), G4VEmModel::IsActive(), G4VEnergyLossProcess::isIonisation, G4INCL::Math::min(), G4VEnergyLossProcess::preStepLogScaledEnergy, G4VEnergyLossProcess::preStepScaledEnergy, and G4VEnergyLossProcess::rndmStepFlag.

Referenced by G4VEnergyLossProcess::ContinuousStepLimit().

◆ AlongStepGPIL()

G4double G4VProcess::AlongStepGPIL ( const G4Track track,
G4double  previousStepSize,
G4double  currentMinimumStep,
G4double proposedSafety,
G4GPILSelection selection 
)
inlineinherited

Definition at line 461 of file G4VProcess.hh.

466{
467 return AlongStepGetPhysicalInteractionLength(track, previousStepSize,
468 currentMinimumStep, proposedSafety, selection);
469}
virtual G4double AlongStepGetPhysicalInteractionLength(const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)=0

References G4VProcess::AlongStepGetPhysicalInteractionLength().

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

◆ AtRestDoIt()

virtual G4VParticleChange * G4VContinuousDiscreteProcess::AtRestDoIt ( const G4Track ,
const G4Step  
)
inlinevirtualinherited

Implements G4VProcess.

Definition at line 87 of file G4VContinuousDiscreteProcess.hh.

90 { return 0; }

◆ AtRestGetPhysicalInteractionLength()

virtual G4double G4VContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength ( const G4Track ,
G4ForceCondition  
)
inlinevirtualinherited

Implements G4VProcess.

Definition at line 81 of file G4VContinuousDiscreteProcess.hh.

84 { return -1.0; }

◆ AtRestGPIL()

G4double G4VProcess::AtRestGPIL ( const G4Track track,
G4ForceCondition condition 
)
inlineinherited

Definition at line 472 of file G4VProcess.hh.

474{
476}
G4double condition(const G4ErrorSymMatrix &m)
G4double thePILfactor
Definition: G4VProcess.hh:352
virtual G4double AtRestGetPhysicalInteractionLength(const G4Track &track, G4ForceCondition *condition)=0

References G4VProcess::AtRestGetPhysicalInteractionLength(), condition(), and G4VProcess::thePILfactor.

Referenced by G4ITStepProcessor::GetAtRestIL(), and G4SteppingManager::InvokeAtRestDoItProcs().

◆ BaseParticle()

const G4ParticleDefinition * G4VEnergyLossProcess::BaseParticle ( ) const
inlineinherited

◆ BuildDEDXTable()

G4PhysicsTable * G4VEnergyLossProcess::BuildDEDXTable ( G4EmTableType  tType = fRestricted)
inherited

Definition at line 573 of file G4VEnergyLossProcess.cc.

574{
575 if(1 < verboseLevel ) {
576 G4cout << "G4VEnergyLossProcess::BuildDEDXTable() of type " << tType
577 << " for " << GetProcessName()
578 << " and particle " << particle->GetParticleName()
579 << G4endl;
580 }
581 G4PhysicsTable* table = nullptr;
583 G4int bin = nBins;
584
585 if(fTotal == tType) {
587 bin = nBinsCSDA;
589 } else if(fRestricted == tType) {
590 table = theDEDXTable;
591 } else {
592 G4cout << "G4VEnergyLossProcess::BuildDEDXTable WARNING: wrong type "
593 << tType << G4endl;
594 }
595
596 // Access to materials
597 const G4ProductionCutsTable* theCoupleTable=
599 size_t numOfCouples = theCoupleTable->GetTableSize();
600
601 if(1 < verboseLevel) {
602 G4cout << numOfCouples << " materials"
603 << " minKinEnergy= " << minKinEnergy
604 << " maxKinEnergy= " << emax
605 << " nbin= " << bin
606 << " EmTableType= " << tType
607 << " table= " << table << " " << this
608 << G4endl;
609 }
610 if(nullptr == table) { return table; }
611
613 G4PhysicsLogVector* aVector = nullptr;
614 G4PhysicsLogVector* bVector = nullptr;
615
616 for(size_t i=0; i<numOfCouples; ++i) {
617
618 if(1 < verboseLevel) {
619 G4cout << "G4VEnergyLossProcess::BuildDEDXVector Idx= " << i
620 << " flagTable= " << table->GetFlag(i)
621 << " Flag= " << bld->GetFlag(i) << G4endl;
622 }
623 if(bld->GetFlag(i)) {
624
625 // create physics vector and fill it
626 const G4MaterialCutsCouple* couple =
627 theCoupleTable->GetMaterialCutsCouple(i);
628 if(nullptr != (*table)[i]) { delete (*table)[i]; }
629 if(nullptr != bVector) {
630 aVector = new G4PhysicsLogVector(*bVector);
631 } else {
632 bVector = new G4PhysicsLogVector(minKinEnergy, emax, bin, spline);
633 aVector = bVector;
634 }
635
636 modelManager->FillDEDXVector(aVector, couple, tType);
637 if(spline) { aVector->FillSecondDerivatives(); }
638
639 // Insert vector for this material into the table
641 }
642 }
643
644 if(1 < verboseLevel) {
645 G4cout << "G4VEnergyLossProcess::BuildDEDXTable(): table is built for "
647 << " and process " << GetProcessName()
648 << G4endl;
649 if(2 < verboseLevel) G4cout << (*table) << G4endl;
650 }
651
652 return table;
653}
static const G4double emax
@ fTotal
@ fRestricted
int G4int
Definition: G4Types.hh:85
void FillDEDXVector(G4PhysicsVector *, const G4MaterialCutsCouple *, G4EmTableType t=fRestricted)
G4bool GetFlag(size_t idx)
G4LossTableBuilder * GetTableBuilder()
const G4String & GetParticleName() const
static void SetPhysicsVector(G4PhysicsTable *physTable, std::size_t idx, G4PhysicsVector *vec)
G4bool GetFlag(std::size_t i) const
void FillSecondDerivatives(const G4SplineType=G4SplineType::Base, const G4double dir1=0.0, const G4double dir2=0.0)
const G4MaterialCutsCouple * GetMaterialCutsCouple(G4int i) const
std::size_t GetTableSize() const
static G4ProductionCutsTable * GetProductionCutsTable()
G4PhysicsTable * theDEDXTable
G4PhysicsTable * theDEDXunRestrictedTable
const G4ParticleDefinition * particle
G4LossTableManager * lManager

References emax, G4EmModelManager::FillDEDXVector(), G4PhysicsVector::FillSecondDerivatives(), fRestricted, fTotal, G4cout, G4endl, G4LossTableBuilder::GetFlag(), G4PhysicsTable::GetFlag(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4ProductionCutsTable::GetProductionCutsTable(), G4LossTableManager::GetTableBuilder(), G4ProductionCutsTable::GetTableSize(), G4VEnergyLossProcess::lManager, G4VEnergyLossProcess::maxKinEnergy, G4VEnergyLossProcess::maxKinEnergyCSDA, G4VEnergyLossProcess::minKinEnergy, G4VEnergyLossProcess::modelManager, G4VEnergyLossProcess::nBins, G4VEnergyLossProcess::nBinsCSDA, G4VEnergyLossProcess::particle, G4PhysicsTableHelper::SetPhysicsVector(), G4VEnergyLossProcess::spline, G4VEnergyLossProcess::theDEDXTable, G4VEnergyLossProcess::theDEDXunRestrictedTable, and G4VProcess::verboseLevel.

Referenced by G4LossTableManager::BuildTables().

◆ BuildLambdaTable()

G4PhysicsTable * G4VEnergyLossProcess::BuildLambdaTable ( G4EmTableType  tType = fRestricted)
inherited

Definition at line 657 of file G4VEnergyLossProcess.cc.

658{
659 G4PhysicsTable* table = nullptr;
660
661 if(fRestricted == tType) {
662 table = theLambdaTable;
663 } else {
664 G4cout << "G4VEnergyLossProcess::BuildLambdaTable WARNING: wrong type "
665 << tType << G4endl;
666 }
667
668 if(1 < verboseLevel) {
669 G4cout << "G4VEnergyLossProcess::BuildLambdaTable() of type "
670 << tType << " for process "
671 << GetProcessName() << " and particle "
673 << " EmTableType= " << tType
674 << " table= " << table
675 << G4endl;
676 }
677 if(nullptr == table) { return table; }
678
679 // Access to materials
680 const G4ProductionCutsTable* theCoupleTable=
682 size_t numOfCouples = theCoupleTable->GetTableSize();
684
685 G4PhysicsLogVector* aVector = nullptr;
687
688 for(size_t i=0; i<numOfCouples; ++i) {
689
690 if (bld->GetFlag(i)) {
691
692 // create physics vector and fill it
693 const G4MaterialCutsCouple* couple =
694 theCoupleTable->GetMaterialCutsCouple(i);
695 delete (*table)[i];
696
697 G4bool startNull = true;
698 G4double emin =
700 if(minKinEnergy > emin) {
701 emin = minKinEnergy;
702 startNull = false;
703 }
704
706 if(emax <= emin) { emax = 2*emin; }
707 G4int bin = G4lrint(nBins*G4Log(emax/emin)/scale);
708 bin = std::max(bin, 3);
709 aVector = new G4PhysicsLogVector(emin, emax, bin, spline);
710
711 modelManager->FillLambdaVector(aVector, couple, startNull, tType);
712 if(spline) { aVector->FillSecondDerivatives(); }
713
714 // Insert vector for this material into the table
716 }
717 }
718
719 if(1 < verboseLevel) {
720 G4cout << "Lambda table is built for "
722 << G4endl;
723 }
724
725 return table;
726}
G4double G4Log(G4double x)
Definition: G4Log.hh:226
bool G4bool
Definition: G4Types.hh:86
void FillLambdaVector(G4PhysicsVector *, const G4MaterialCutsCouple *, G4bool startFromNull=true, G4EmTableType t=fRestricted)
const G4Material * GetMaterial() const
const G4DataVector * theCuts
virtual G4double MinPrimaryEnergy(const G4ParticleDefinition *, const G4Material *, G4double cut)
G4PhysicsTable * theLambdaTable
int G4lrint(double ad)
Definition: templates.hh:134

References emax, G4EmModelManager::FillLambdaVector(), G4PhysicsVector::FillSecondDerivatives(), fRestricted, G4cout, G4endl, G4Log(), G4lrint(), G4LossTableBuilder::GetFlag(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4ProductionCutsTable::GetProductionCutsTable(), G4LossTableManager::GetTableBuilder(), G4ProductionCutsTable::GetTableSize(), G4VEnergyLossProcess::lManager, G4INCL::Math::max(), G4VEnergyLossProcess::maxKinEnergy, G4VEnergyLossProcess::minKinEnergy, G4VEnergyLossProcess::MinPrimaryEnergy(), G4VEnergyLossProcess::modelManager, G4VEnergyLossProcess::nBins, G4VEnergyLossProcess::particle, G4PhysicsTableHelper::SetPhysicsVector(), G4VEnergyLossProcess::spline, G4VEnergyLossProcess::theCuts, G4VEnergyLossProcess::theLambdaTable, and G4VProcess::verboseLevel.

Referenced by G4LossTableManager::BuildTables().

◆ BuildPhysicsTable()

void G4VEnergyLossProcess::BuildPhysicsTable ( const G4ParticleDefinition part)
overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 473 of file G4VEnergyLossProcess.cc.

474{
475 if(1 < verboseLevel) {
476 G4cout << "### G4VEnergyLossProcess::BuildPhysicsTable() for "
477 << GetProcessName()
478 << " and particle " << part.GetParticleName()
479 << "; local: " << particle->GetParticleName();
480 if(baseParticle) {
481 G4cout << "; base: " << baseParticle->GetParticleName();
482 }
483 G4cout << " TablesAreBuilt= " << tablesAreBuilt
484 << " isIon= " << isIon << " " << this << G4endl;
485 }
486
487 if(&part == particle) {
488
489 if(isMaster) {
491
492 } else {
493
494 const G4VEnergyLossProcess* masterProcess =
495 static_cast<const G4VEnergyLossProcess*>(GetMasterProcess());
496
497 // copy table pointers from master thread
498 SetDEDXTable(masterProcess->DEDXTable(),fRestricted);
499 SetDEDXTable(masterProcess->DEDXunRestrictedTable(),fTotal);
501 SetRangeTableForLoss(masterProcess->RangeTableForLoss());
502 SetCSDARangeTable(masterProcess->CSDARangeTable());
504 SetInverseRangeTable(masterProcess->InverseRangeTable());
505 SetLambdaTable(masterProcess->LambdaTable());
506 SetTwoPeaksXS(masterProcess->TwoPeaksXS());
507 isIonisation = masterProcess->IsIonisationProcess();
508 baseMat = masterProcess->UseBaseMaterial();
509
510 tablesAreBuilt = true;
511 // local initialisation of models
512 G4bool printing = true;
513 for(G4int i=0; i<numberOfModels; ++i) {
514 G4VEmModel* mod = GetModelByIndex(i, printing);
515 G4VEmModel* mod0= masterProcess->GetModelByIndex(i, printing);
517 mod->InitialiseLocal(particle, mod0);
518 }
520 }
521
522 // needs to be done only once
524 }
525 // Added tracking cut to avoid tracking artifacts
526 // and identified deexcitation flag
527 if(isIonisation) {
529 if(nullptr != atomDeexcitation) {
531 }
532 }
533
534 // protection against double printout
535 if(theParameters->IsPrintLocked()) { return; }
536
537 // explicitly defined printout by particle name
538 G4String num = part.GetParticleName();
539 if(1 < verboseLevel ||
540 (0 < verboseLevel && (num == "e-" ||
541 num == "e+" || num == "mu+" ||
542 num == "mu-" || num == "proton"||
543 num == "pi+" || num == "pi-" ||
544 num == "kaon+" || num == "kaon-" ||
545 num == "alpha" || num == "anti_proton" ||
546 num == "GenericIon"|| num == "alpha+" )))
547 {
548 StreamInfo(G4cout, part);
549 }
550
551 /*
552 G4cout << "** G4VEnergyLossProcess::BuildPhysicsTable() for "
553 << GetProcessName() << " and " << particle->GetParticleName()
554 << " isMaster: " << isMaster << " isIonisation: "
555 << isIonisation << G4endl;
556 G4cout << " theDEDX: " << theDEDXTable
557 << " theRange: " << theRangeTableForLoss
558 << " theInverse: " << theInverseRangeTable
559 << " theLambda: " << theLambdaTable << G4endl;
560 */
561 //if(1 < verboseLevel || verb) {
562 if(1 < verboseLevel) {
563 G4cout << "### G4VEnergyLossProcess::BuildPhysicsTable() done for "
564 << GetProcessName()
565 << " and particle " << part.GetParticleName();
566 if(isIonisation) { G4cout << " isIonisation flag=1"; }
567 G4cout << " baseMat=" << baseMat << G4endl;
568 }
569}
@ fIsIonisation
G4bool IsPrintLocked() const
void LocalPhysicsTables(const G4ParticleDefinition *aParticle, G4VEnergyLossProcess *p)
void BuildPhysicsTable(const G4ParticleDefinition *aParticle)
G4VAtomDeexcitation * AtomDeexcitation()
void InitialiseHelper()
void SetUseBaseMaterials(G4bool val)
Definition: G4VEmModel.hh:753
virtual void InitialiseLocal(const G4ParticleDefinition *, G4VEmModel *masterModel)
Definition: G4VEmModel.cc:204
G4PhysicsTable * RangeTableForLoss() const
G4PhysicsTable * InverseRangeTable() const
G4PhysicsTable * CSDARangeTable() const
void SetRangeTableForLoss(G4PhysicsTable *p)
G4VEmModel * GetModelByIndex(size_t idx=0, G4bool ver=false) const
std::vector< G4TwoPeaksXS * > * TwoPeaksXS() const
G4EmParameters * theParameters
G4PhysicsTable * SecondaryRangeTable() const
void StreamInfo(std::ostream &out, const G4ParticleDefinition &part, G4bool rst=false) const
void SetInverseRangeTable(G4PhysicsTable *p)
G4bool IsIonisationProcess() const
void SetDEDXTable(G4PhysicsTable *p, G4EmTableType tType)
void SetTwoPeaksXS(std::vector< G4TwoPeaksXS * > *p)
void SetSecondaryRangeTable(G4PhysicsTable *p)
void SetLambdaTable(G4PhysicsTable *p)
G4PhysicsTable * IonisationTable() const
G4PhysicsTable * LambdaTable() const
void SetCSDARangeTable(G4PhysicsTable *pRange)
G4PhysicsTable * DEDXunRestrictedTable() const
G4SafetyHelper * safetyHelper
G4PhysicsTable * DEDXTable() const
const G4VProcess * GetMasterProcess() const
Definition: G4VProcess.hh:518

References G4LossTableManager::AtomDeexcitation(), G4VEnergyLossProcess::atomDeexcitation, G4VEnergyLossProcess::baseMat, G4VEnergyLossProcess::baseParticle, G4LossTableManager::BuildPhysicsTable(), G4VEnergyLossProcess::CSDARangeTable(), G4VEnergyLossProcess::DEDXTable(), G4VEnergyLossProcess::DEDXunRestrictedTable(), fIsIonisation, fRestricted, fTotal, G4cout, G4endl, G4VProcess::GetMasterProcess(), G4VEnergyLossProcess::GetModelByIndex(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4SafetyHelper::InitialiseHelper(), G4VEmModel::InitialiseLocal(), G4VEnergyLossProcess::InverseRangeTable(), G4VEnergyLossProcess::IonisationTable(), G4VEnergyLossProcess::isIon, G4VEnergyLossProcess::isIonisation, G4VEnergyLossProcess::IsIonisationProcess(), G4VEnergyLossProcess::isMaster, G4VAtomDeexcitation::IsPIXEActive(), G4EmParameters::IsPrintLocked(), G4VEnergyLossProcess::LambdaTable(), G4VEnergyLossProcess::lManager, G4LossTableManager::LocalPhysicsTables(), G4VEnergyLossProcess::numberOfModels, G4VEnergyLossProcess::particle, G4VEnergyLossProcess::RangeTableForLoss(), G4VEnergyLossProcess::safetyHelper, G4VEnergyLossProcess::SecondaryRangeTable(), G4VEnergyLossProcess::SetCSDARangeTable(), G4VEnergyLossProcess::SetDEDXTable(), G4VEnergyLossProcess::SetInverseRangeTable(), G4VEnergyLossProcess::SetLambdaTable(), G4VEnergyLossProcess::SetRangeTableForLoss(), G4VEnergyLossProcess::SetSecondaryRangeTable(), G4VEnergyLossProcess::SetTwoPeaksXS(), G4VEmModel::SetUseBaseMaterials(), G4VEnergyLossProcess::StreamInfo(), G4VEnergyLossProcess::tablesAreBuilt, G4VEnergyLossProcess::theParameters, G4VEnergyLossProcess::TwoPeaksXS(), G4VEnergyLossProcess::UseBaseMaterial(), G4VEnergyLossProcess::useDeexcitation, and G4VProcess::verboseLevel.

Referenced by G4PolarizedIonisation::BuildPhysicsTable().

◆ BuildWorkerPhysicsTable()

void G4VProcess::BuildWorkerPhysicsTable ( const G4ParticleDefinition part)
virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 200 of file G4VProcess.cc.

201{
202 BuildPhysicsTable(part);
203}
virtual void BuildPhysicsTable(const G4ParticleDefinition &)
Definition: G4VProcess.hh:187

References G4VProcess::BuildPhysicsTable().

Referenced by G4BiasingProcessInterface::BuildWorkerPhysicsTable().

◆ ClearNumberOfInteractionLengthLeft()

void G4VProcess::ClearNumberOfInteractionLengthLeft ( )
inlineprotectedinherited

◆ ComputeLambdaForScaledEnergy()

void G4VEnergyLossProcess::ComputeLambdaForScaledEnergy ( G4double  scaledKinE,
G4double  logScaledKinE 
)
privateinherited

Definition at line 994 of file G4VEnergyLossProcess.cc.

995{
996 // cross section increased with energy
997 if(fXSType == fEmIncreasing) {
998 if(e/lambdaFactor < mfpKinEnergy) {
999 mfpKinEnergy = e;
1001 }
1002
1003 // cross section has two peaks
1004 } else if(fXSType == fEmTwoPeaks) {
1005 G4TwoPeaksXS* xs = (*fXSpeaks)[basedCoupleIndex];
1006 const G4double e1peak = xs->e1peak;
1007
1008 // below the 1st peak
1009 if(e <= e1peak) {
1010 if(e/lambdaFactor < mfpKinEnergy) {
1011 mfpKinEnergy = e;
1013 }
1014 return;
1015 }
1016 const G4double e1deep = xs->e1deep;
1017 // above the 1st peak, below the deep
1018 if(e <= e1deep) {
1019 if(mfpKinEnergy >= e1deep || e <= mfpKinEnergy) {
1020 const G4double e1 = std::max(e1peak, e*lambdaFactor);
1022 mfpKinEnergy = e1;
1023 }
1024 return;
1025 }
1026 const G4double e2peak = xs->e2peak;
1027 // above the deep, below 2nd peak
1028 if(e <= e2peak) {
1029 if(e/lambdaFactor < mfpKinEnergy) {
1030 mfpKinEnergy = e;
1032 }
1033 return;
1034 }
1035 const G4double e2deep = xs->e2deep;
1036 // above the 2nd peak, below the deep
1037 if(e <= e2deep) {
1038 if(mfpKinEnergy >= e2deep || e <= mfpKinEnergy) {
1039 const G4double e1 = std::max(e2peak, e*lambdaFactor);
1041 mfpKinEnergy = e1;
1042 }
1043 return;
1044 }
1045 // above the deep, below 3d peak
1046 if(e/lambdaFactor < mfpKinEnergy) {
1047 mfpKinEnergy = e;
1049 }
1050
1051 // integral method is not used
1052 } else {
1054 }
1055}
static const G4double e1[44]
@ fEmIncreasing
G4CrossSectionType fXSType
G4double GetLambdaForScaledEnergy(G4double scaledKinE)
G4double e1peak
G4double e2deep
G4double e1deep
G4double e2peak

References G4VEnergyLossProcess::basedCoupleIndex, e1, G4TwoPeaksXS::e1deep, G4TwoPeaksXS::e1peak, G4TwoPeaksXS::e2deep, G4TwoPeaksXS::e2peak, fEmIncreasing, fEmTwoPeaks, G4VEnergyLossProcess::fXSType, G4VEnergyLossProcess::GetLambdaForScaledEnergy(), G4VEnergyLossProcess::lambdaFactor, G4INCL::Math::max(), G4VEnergyLossProcess::mfpKinEnergy, and G4VEnergyLossProcess::preStepLambda.

Referenced by G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength().

◆ ContinuousStepLimit()

G4double G4VEnergyLossProcess::ContinuousStepLimit ( const G4Track track,
G4double  previousStepSize,
G4double  currentMinimumStep,
G4double currentSafety 
)
inherited

Definition at line 1647 of file G4VEnergyLossProcess.cc.

1650{
1652}
G4double AlongStepGetPhysicalInteractionLength(const G4Track &, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety, G4GPILSelection *selection) override

References G4VEnergyLossProcess::aGPILSelection, and G4VEnergyLossProcess::AlongStepGetPhysicalInteractionLength().

◆ CrossSectionBiasingFactor()

G4double G4VEnergyLossProcess::CrossSectionBiasingFactor ( ) const
inlineinherited

Definition at line 942 of file G4VEnergyLossProcess.hh.

943{
944 return biasFactor;
945}

References G4VEnergyLossProcess::biasFactor.

◆ CrossSectionPerVolume() [1/2]

G4double G4VEnergyLossProcess::CrossSectionPerVolume ( G4double  kineticEnergy,
const G4MaterialCutsCouple couple 
)
inherited

◆ CrossSectionPerVolume() [2/2]

G4double G4VEnergyLossProcess::CrossSectionPerVolume ( G4double  kineticEnergy,
const G4MaterialCutsCouple couple,
G4double  logKineticEnergy 
)
inherited

Definition at line 1614 of file G4VEnergyLossProcess.cc.

1617{
1618 // Cross section per volume is calculated
1619 DefineMaterial(couple);
1620 G4double cross = 0.0;
1621 if (nullptr != theLambdaTable) {
1622 cross = GetLambdaForScaledEnergy(kineticEnergy * massRatio,
1623 logKineticEnergy + logMassRatio);
1624 } else {
1625 SelectModel(kineticEnergy*massRatio);
1629 }
1630 return std::max(cross, 0.0);
1631}
virtual G4double CrossSectionPerVolume(const G4Material *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
Definition: G4VEmModel.cc:237
void SelectModel(G4double kinEnergy)
const std::vector< G4double > * theDensityFactor
void DefineMaterial(const G4MaterialCutsCouple *couple)

References G4VEnergyLossProcess::baseMat, G4VEnergyLossProcess::biasFactor, G4VEmModel::CrossSectionPerVolume(), G4VEnergyLossProcess::currentCoupleIndex, G4VEnergyLossProcess::currentMaterial, G4VEnergyLossProcess::currentModel, G4VEnergyLossProcess::DefineMaterial(), G4VEnergyLossProcess::GetLambdaForScaledEnergy(), G4VEnergyLossProcess::logMassRatio, G4VEnergyLossProcess::massRatio, G4INCL::Math::max(), G4VEnergyLossProcess::particle, G4VEnergyLossProcess::SelectModel(), G4VEnergyLossProcess::theCuts, G4VEnergyLossProcess::theDensityFactor, and G4VEnergyLossProcess::theLambdaTable.

◆ CrossSectionType()

G4CrossSectionType G4VEnergyLossProcess::CrossSectionType ( ) const
inlineinherited

Definition at line 907 of file G4VEnergyLossProcess.hh.

908{
909 return fXSType;
910}

References G4VEnergyLossProcess::fXSType.

◆ CSDARangeTable()

G4PhysicsTable * G4VEnergyLossProcess::CSDARangeTable ( ) const
inlineinherited

◆ CurrentMaterialCutsCoupleIndex()

size_t G4VEnergyLossProcess::CurrentMaterialCutsCoupleIndex ( ) const
inlineprotectedinherited

◆ DEDXTable()

G4PhysicsTable * G4VEnergyLossProcess::DEDXTable ( ) const
inlineinherited

◆ DEDXunRestrictedTable()

G4PhysicsTable * G4VEnergyLossProcess::DEDXunRestrictedTable ( ) const
inlineinherited

◆ DefineMaterial()

void G4VEnergyLossProcess::DefineMaterial ( const G4MaterialCutsCouple couple)
inlineprivateinherited

Definition at line 581 of file G4VEnergyLossProcess.hh.

582{
583 if(couple != currentCouple) {
584 currentCouple = couple;
585 currentMaterial = couple->GetMaterial();
589 idxLambda = 0;
590 if(baseMat) {
591 basedCoupleIndex = (*theDensityIdx)[currentCoupleIndex];
592 fFactor *= (*theDensityFactor)[currentCoupleIndex];
593 }
595 }
596}

References G4VEnergyLossProcess::basedCoupleIndex, G4VEnergyLossProcess::baseMat, G4VEnergyLossProcess::biasFactor, G4VEnergyLossProcess::chargeSqRatio, G4VEnergyLossProcess::currentCouple, G4VEnergyLossProcess::currentCoupleIndex, G4VEnergyLossProcess::currentMaterial, DBL_MAX, G4VEnergyLossProcess::fFactor, G4MaterialCutsCouple::GetIndex(), G4MaterialCutsCouple::GetMaterial(), G4VEnergyLossProcess::idxLambda, G4VEnergyLossProcess::massRatio, G4VEnergyLossProcess::mfpKinEnergy, and G4VEnergyLossProcess::reduceFactor.

Referenced by G4VEnergyLossProcess::CrossSectionPerVolume(), G4VEnergyLossProcess::GetCSDARange(), G4VEnergyLossProcess::GetDEDX(), G4VEnergyLossProcess::GetDEDXDispersion(), G4VEnergyLossProcess::GetKineticEnergy(), G4VEnergyLossProcess::GetLambda(), G4VEnergyLossProcess::GetRange(), G4VEnergyLossProcess::LambdaPhysicsVector(), G4VEnergyLossProcess::MeanFreePath(), and G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength().

◆ DumpInfo()

void G4VProcess::DumpInfo ( ) const
virtualinherited

Reimplemented in G4AdjointAlongStepWeightCorrection, G4AdjointForcedInteractionForGamma, G4AdjointhMultipleScattering, G4ContinuousGainOfEnergy, G4eAdjointMultipleScattering, G4eInverseBremsstrahlung, G4eInverseCompton, G4eInverseIonisation, G4InversePEEffect, G4IonInverseIonisation, G4PolarizedAnnihilation, G4PolarizedBremsstrahlung, G4PolarizedCompton, G4PolarizedGammaConversion, G4PolarizedIonisation, G4PolarizedPhotoElectric, G4Cerenkov, G4ForwardXrayTR, G4GammaXTRadiator, G4GaussXTRadiator, G4RegularXTRadiator, G4Scintillation, G4StrawTubeXTRadiator, G4SynchrotronRadiation, G4TransitionRadiation, G4TransparentRegXTRadiator, G4VTransitionRadiation, G4VXTRenergyLoss, G4XTRGammaRadModel, G4XTRRegularRadModel, and G4XTRTransparentRegRadModel.

Definition at line 167 of file G4VProcess.cc.

168{
169 G4cout << "Process Name " << theProcessName ;
170 G4cout << " : Type[" << GetProcessTypeName(theProcessType) << "]";
171 G4cout << " : SubType[" << theProcessSubType << "]"<< G4endl;
172}
static const G4String & GetProcessTypeName(G4ProcessType)
Definition: G4VProcess.cc:134
G4ProcessType theProcessType
Definition: G4VProcess.hh:346
G4int theProcessSubType
Definition: G4VProcess.hh:349
G4String theProcessName
Definition: G4VProcess.hh:341

References G4cout, G4endl, G4VProcess::GetProcessTypeName(), G4VProcess::theProcessName, G4VProcess::theProcessSubType, and G4VProcess::theProcessType.

Referenced by G4ProcessTable::DumpInfo(), export_G4VProcess(), G4Scintillation::ProcessDescription(), G4Cerenkov::ProcessDescription(), and G4ProcessManagerMessenger::SetNewValue().

◆ EmModel()

G4VEmModel * G4VEnergyLossProcess::EmModel ( size_t  index = 0) const
inlineinherited

◆ EndTracking()

void G4VProcess::EndTracking ( )
virtualinherited

◆ FillSecondariesAlongStep()

void G4VEnergyLossProcess::FillSecondariesAlongStep ( G4double  weight)
privateinherited

Definition at line 1258 of file G4VEnergyLossProcess.cc.

1259{
1260 const G4int n0 = scTracks.size();
1261 G4double weight = wt;
1262 // weight may be changed by biasing manager
1263 if(biasManager) {
1265 weight *=
1267 }
1268 }
1269
1270 // fill secondaries
1271 const G4int n = scTracks.size();
1273
1274 for(G4int i=0; i<n; ++i) {
1275 G4Track* t = scTracks[i];
1276 if(nullptr != t) {
1277 t->SetWeight(weight);
1279 if(i >= n0) { t->SetCreatorModelID(biasID); }
1280 //G4cout << "Secondary(along step) has weight " << t->GetWeight()
1281 //<< ", kenergy " << t->GetKineticEnergy()/MeV << " MeV" <<G4endl;
1282 }
1283 }
1284 scTracks.clear();
1285}
G4double ApplySecondaryBiasing(std::vector< G4DynamicParticle * > &, const G4Track &track, G4VEmModel *currentModel, G4ParticleChangeForGamma *pParticleChange, G4double &eloss, G4int coupleIdx, G4double tcut, G4double safety=0.0)
G4bool SecondaryBiasingRegion(G4int coupleIdx)
void SetWeight(G4double aValue)
void SetCreatorModelID(const G4int id)
void AddSecondary(G4Track *aSecondary)
void SetNumberOfSecondaries(G4int totSecondaries)

References G4VParticleChange::AddSecondary(), G4EmBiasingManager::ApplySecondaryBiasing(), G4VEnergyLossProcess::biasID, G4VEnergyLossProcess::biasManager, G4VEnergyLossProcess::currentCoupleIndex, G4VEnergyLossProcess::fParticleChange, CLHEP::detail::n, G4VProcess::pParticleChange, G4VEnergyLossProcess::scTracks, G4EmBiasingManager::SecondaryBiasingRegion(), G4Track::SetCreatorModelID(), G4VParticleChange::SetNumberOfSecondaries(), and G4Track::SetWeight().

Referenced by G4VEnergyLossProcess::AlongStepDoIt().

◆ FluctModel()

G4VEmFluctuationModel * G4VEnergyLossProcess::FluctModel ( ) const
inlineinherited

◆ GetContinuousStepLimit()

G4double G4VEnergyLossProcess::GetContinuousStepLimit ( const G4Track track,
G4double  previousStepSize,
G4double  currentMinimumStep,
G4double currentSafety 
)
overrideprotectedvirtualinherited

Implements G4VContinuousDiscreteProcess.

Definition at line 1668 of file G4VEnergyLossProcess.cc.

1671{
1672 return DBL_MAX;
1673}

References DBL_MAX.

◆ GetCSDADEDX()

G4double G4VEnergyLossProcess::GetCSDADEDX ( G4double  kineticEnergy,
const G4MaterialCutsCouple  
)
inlineinherited

◆ GetCSDARange()

G4double G4VEnergyLossProcess::GetCSDARange ( G4double  kineticEnergy,
const G4MaterialCutsCouple couple 
)
inlineinherited

◆ GetCurrentElement()

const G4Element * G4VEnergyLossProcess::GetCurrentElement ( ) const
inherited

Definition at line 1891 of file G4VEnergyLossProcess.cc.

1892{
1893 return (nullptr != currentModel) ? currentModel->GetCurrentElement() : nullptr;
1894}
const G4Element * GetCurrentElement() const
Definition: G4VEmModel.hh:505

References G4VEnergyLossProcess::currentModel, and G4VEmModel::GetCurrentElement().

◆ GetCurrentInteractionLength()

G4double G4VProcess::GetCurrentInteractionLength ( ) const
inlineinherited

◆ GetDEDX() [1/2]

G4double G4VEnergyLossProcess::GetDEDX ( G4double  kineticEnergy,
const G4MaterialCutsCouple couple 
)
inlineinherited

◆ GetDEDX() [2/2]

G4double G4VEnergyLossProcess::GetDEDX ( G4double  kineticEnergy,
const G4MaterialCutsCouple couple,
G4double  logKineticEnergy 
)
inlineinherited

◆ GetDEDXDispersion()

G4double G4VEnergyLossProcess::GetDEDXDispersion ( const G4MaterialCutsCouple couple,
const G4DynamicParticle dp,
G4double  length 
)
inherited

◆ GetDEDXForScaledEnergy() [1/2]

G4double G4VEnergyLossProcess::GetDEDXForScaledEnergy ( G4double  scaledKinE)
inlineprivateinherited

Definition at line 600 of file G4VEnergyLossProcess.hh.

601{
602 /*
603 G4cout << "G4VEnergyLossProcess::GetDEDX: Idx= "
604 << basedCoupleIndex << " E(MeV)= " << e
605 << " Emin= " << minKinEnergy << " Factor= " << fFactor
606 << " " << theDEDXTable << G4endl; */
607 G4double x = fFactor*(*theDEDXTable)[basedCoupleIndex]->Value(e, idxDEDX);
608 if(e < minKinEnergy) { x *= std::sqrt(e/minKinEnergy); }
609 return x;
610}

References G4VEnergyLossProcess::basedCoupleIndex, G4VEnergyLossProcess::fFactor, G4VEnergyLossProcess::idxDEDX, and G4VEnergyLossProcess::minKinEnergy.

Referenced by G4VEnergyLossProcess::AlongStepDoIt(), and G4VEnergyLossProcess::GetDEDX().

◆ GetDEDXForScaledEnergy() [2/2]

G4double G4VEnergyLossProcess::GetDEDXForScaledEnergy ( G4double  scaledKinE,
G4double  logScaledKinE 
)
inlineprivateinherited

Definition at line 613 of file G4VEnergyLossProcess.hh.

614{
615 /*
616 G4cout << "G4VEnergyLossProcess::GetDEDX: Idx= "
617 << basedCoupleIndex << " E(MeV)= " << e
618 << " Emin= " << minKinEnergy << " Factor= " << fFactor
619 << " " << theDEDXTable << G4endl; */
620 G4double x = fFactor*(*theDEDXTable)[basedCoupleIndex]->LogVectorValue(e,loge);
621 if(e < minKinEnergy) { x *= std::sqrt(e/minKinEnergy); }
622 return x;
623}

References G4VEnergyLossProcess::basedCoupleIndex, G4VEnergyLossProcess::fFactor, and G4VEnergyLossProcess::minKinEnergy.

◆ GetGPILSelection()

G4GPILSelection G4VContinuousDiscreteProcess::GetGPILSelection ( ) const
inlineprotectedinherited

◆ GetIonisationForScaledEnergy()

G4double G4VEnergyLossProcess::GetIonisationForScaledEnergy ( G4double  scaledKinE)
inlineprivateinherited

Definition at line 627 of file G4VEnergyLossProcess.hh.

628{
629 G4double x =
630 fFactor*(*theIonisationTable)[basedCoupleIndex]->Value(e, idxIonisation);
631 if(e < minKinEnergy) { x *= std::sqrt(e/minKinEnergy); }
632 return x;
633}

References G4VEnergyLossProcess::basedCoupleIndex, G4VEnergyLossProcess::fFactor, G4VEnergyLossProcess::idxIonisation, and G4VEnergyLossProcess::minKinEnergy.

◆ GetKineticEnergy()

G4double G4VEnergyLossProcess::GetKineticEnergy ( G4double  range,
const G4MaterialCutsCouple couple 
)
inlineinherited

◆ GetLambda() [1/2]

G4double G4VEnergyLossProcess::GetLambda ( G4double  kineticEnergy,
const G4MaterialCutsCouple couple 
)
inlineinherited

◆ GetLambda() [2/2]

G4double G4VEnergyLossProcess::GetLambda ( G4double  kineticEnergy,
const G4MaterialCutsCouple couple,
G4double  logKineticEnergy 
)
inlineinherited

◆ GetLambdaForScaledEnergy() [1/2]

G4double G4VEnergyLossProcess::GetLambdaForScaledEnergy ( G4double  scaledKinE)
inlineprivateinherited

◆ GetLambdaForScaledEnergy() [2/2]

G4double G4VEnergyLossProcess::GetLambdaForScaledEnergy ( G4double  scaledKinE,
G4double  logScaledKinE 
)
inlineprivateinherited

◆ GetLimitScaledRangeForScaledEnergy() [1/2]

G4double G4VEnergyLossProcess::GetLimitScaledRangeForScaledEnergy ( G4double  scaledKinE)
inlineprivateinherited

Definition at line 675 of file G4VEnergyLossProcess.hh.

676{
677 G4double x = ((*theCSDARangeTable)[basedCoupleIndex])->Value(e, idxCSDA);
678 if(e < minKinEnergy) { x *= std::sqrt(e/minKinEnergy); }
679 return x;
680}

References G4VEnergyLossProcess::basedCoupleIndex, G4VEnergyLossProcess::idxCSDA, and G4VEnergyLossProcess::minKinEnergy.

Referenced by G4VEnergyLossProcess::GetCSDARange().

◆ GetLimitScaledRangeForScaledEnergy() [2/2]

G4double G4VEnergyLossProcess::GetLimitScaledRangeForScaledEnergy ( G4double  scaledKinE,
G4double  logScaledKinE 
)
inlineprivateinherited

Definition at line 685 of file G4VEnergyLossProcess.hh.

687{
688 G4double x = ((*theCSDARangeTable)[basedCoupleIndex])->LogVectorValue(e, loge);
689 if(e < minKinEnergy) { x *= std::sqrt(e/minKinEnergy); }
690 return x;
691}

References G4VEnergyLossProcess::basedCoupleIndex, and G4VEnergyLossProcess::minKinEnergy.

◆ GetMasterProcess()

const G4VProcess * G4VProcess::GetMasterProcess ( ) const
inlineinherited

◆ GetMeanFreePath()

G4double G4VEnergyLossProcess::GetMeanFreePath ( const G4Track track,
G4double  previousStepSize,
G4ForceCondition condition 
)
overrideprotectedvirtualinherited

Implements G4VContinuousDiscreteProcess.

Definition at line 1656 of file G4VEnergyLossProcess.cc.

1661{
1663 return MeanFreePath(track);
1664}
@ NotForced
G4double MeanFreePath(const G4Track &track)

References condition(), G4VEnergyLossProcess::MeanFreePath(), and NotForced.

Referenced by G4PolarizedIonisation::GetMeanFreePath().

◆ GetModelByIndex()

G4VEmModel * G4VEnergyLossProcess::GetModelByIndex ( size_t  idx = 0,
G4bool  ver = false 
) const
inlineinherited

Definition at line 1042 of file G4VEnergyLossProcess.hh.

1043{
1044 return modelManager->GetModel(idx, ver);
1045}
G4VEmModel * GetModel(G4int idx, G4bool ver=false)

References G4EmModelManager::GetModel(), and G4VEnergyLossProcess::modelManager.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable().

◆ GetNumberOfInteractionLengthLeft()

G4double G4VProcess::GetNumberOfInteractionLengthLeft ( ) const
inlineinherited

Definition at line 431 of file G4VProcess.hh.

432{
434}

References G4VProcess::theNumberOfInteractionLengthLeft.

◆ GetPhysicsTableFileName()

const G4String & G4VProcess::GetPhysicsTableFileName ( const G4ParticleDefinition particle,
const G4String directory,
const G4String tableName,
G4bool  ascii = false 
)
inherited

Definition at line 181 of file G4VProcess.cc.

186{
187 G4String thePhysicsTableFileExt;
188 if (ascii) thePhysicsTableFileExt = ".asc";
189 else thePhysicsTableFileExt = ".dat";
190
191 thePhysicsTableFileName = directory + "/";
192 thePhysicsTableFileName += tableName + "." + theProcessName + ".";
194 + thePhysicsTableFileExt;
195
197}
G4String thePhysicsTableFileName
Definition: G4VProcess.hh:344

References G4ParticleDefinition::GetParticleName(), G4VProcess::thePhysicsTableFileName, and G4VProcess::theProcessName.

Referenced by export_G4VProcess(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrieveTable(), G4GammaGeneralProcess::StorePhysicsTable(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), and G4VEnergyLossProcess::StoreTable().

◆ GetPILfactor()

G4double G4VProcess::GetPILfactor ( ) const
inlineinherited

Definition at line 455 of file G4VProcess.hh.

456{
457 return thePILfactor;
458}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

◆ GetProcessManager()

const G4ProcessManager * G4VProcess::GetProcessManager ( )
inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 494 of file G4VProcess.hh.

495{
496 return aProcessManager;
497}
const G4ProcessManager * aProcessManager
Definition: G4VProcess.hh:319

References G4VProcess::aProcessManager.

Referenced by G4BiasingProcessInterface::GetProcessManager(), and G4WrapperProcess::GetProcessManager().

◆ GetProcessName()

const G4String & G4VProcess::GetProcessName ( ) const
inlineinherited

Definition at line 382 of file G4VProcess.hh.

383{
384 return theProcessName;
385}

References G4VProcess::theProcessName.

Referenced by G4VEnergyLossProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateForcedInteraction(), G4ProcessManager::ActivateProcess(), G4VEmProcess::ActivateSecondaryBiasing(), G4VEnergyLossProcess::ActivateSecondaryBiasing(), G4ParallelGeometriesLimiterProcess::AddParallelWorld(), G4IonQMDPhysics::AddProcess(), G4IonINCLXXPhysics::AddProcess(), G4ProcessManager::AddProcess(), G4ProcessPlacer::AddProcessAs(), G4ITSteppingVerbose::AlongStepDoItAllDone(), G4SteppingVerbose::AlongStepDoItAllDone(), G4SteppingVerboseWithUnits::AlongStepDoItAllDone(), G4ITSteppingVerbose::AlongStepDoItOneByOne(), G4SteppingVerbose::AlongStepDoItOneByOne(), G4SteppingVerboseWithUnits::AlongStepDoItOneByOne(), G4VContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4ParallelWorldProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4VContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4BOptnLeadingParticle::ApplyFinalStateBiasing(), G4ITSteppingVerbose::AtRestDoItInvoked(), G4SteppingVerbose::AtRestDoItInvoked(), G4SteppingVerboseWithUnits::AtRestDoItInvoked(), G4ITSteppingVerbose::AtRestDoItOneByOne(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4HadronicProcess::BiasCrossSectionByFactor(), G4VXTRenergyLoss::BuildAngleForEnergyBank(), G4VEnergyLossProcess::BuildDEDXTable(), G4VUserPhysicsList::BuildIntegralPhysicsTable(), G4VEmProcess::BuildLambdaTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4DNABrownianTransportation::BuildPhysicsTable(), G4GammaGeneralProcess::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4LossTableManager::BuildPhysicsTable(), G4LossTableManager::BuildTables(), G4HadronicProcess::CheckEnergyMomentumConservation(), G4ProcessManager::CheckOrderingParameters(), G4HadronicProcess::CheckResult(), G4StackChecker::ClassifyNewTrack(), G4BOptrForceCollision::ConfigureForWorker(), G4RunManagerKernel::ConfirmCoupledTransportation(), G4FastSimulationPhysics::ConstructProcess(), G4GenericBiasingPhysics::ConstructProcess(), G4IonElasticPhysics::ConstructProcess(), G4LossTableManager::CopyTables(), G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4VPhononProcess::CreateSecondary(), G4EmExtraParameters::DefineRegParamForEM(), G4EmExtraParameters::DefineRegParamForLoss(), G4HadronicProcessStore::DeRegisterExtraProcess(), G4ITSteppingVerbose::DPSLAlongStep(), G4SteppingVerbose::DPSLAlongStep(), G4SteppingVerboseWithUnits::DPSLAlongStep(), G4ITSteppingVerbose::DPSLPostStep(), G4SteppingVerbose::DPSLPostStep(), G4SteppingVerboseWithUnits::DPSLPostStep(), G4HadronicProcessStore::Dump(), G4HadronicProcess::DumpState(), G4MuonicAtomDecay::DumpState(), G4ExceptionHandler::DumpTrackInfo(), export_G4VProcess(), G4EmCalculator::FindEmModel(), G4VEmProcess::FindLambdaMax(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ErrorEnergyLoss::G4ErrorEnergyLoss(), G4ErrorTrackLengthTarget::G4ErrorTrackLengthTarget(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4ImportanceProcess::G4ImportanceProcess(), G4MaxTimeCuts::G4MaxTimeCuts(), G4MicroElecSurface::G4MicroElecSurface(), G4MinEkineCuts::G4MinEkineCuts(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4Scintillation::G4Scintillation(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4SpecialCuts::G4SpecialCuts(), G4StepLimiter::G4StepLimiter(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UserSpecialCuts::G4UserSpecialCuts(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4HadronicProcess::GetElementCrossSection(), G4VEmProcess::GetEmProcess(), G4GammaGeneralProcess::GetEmProcess(), G4WeightWindowProcess::GetName(), G4ProcessManager::GetProcess(), G4ProcessManager::GetProcessVectorIndex(), G4GammaGeneralProcess::GetSubProcessName(), G4ProcessManager::InActivateProcess(), G4hhIonisation::InitialiseEnergyLossProcess(), G4ProcessTable::Insert(), G4ITStepProcessor::InvokeAlongStepDoItProcs(), G4SteppingManager::InvokeAlongStepDoItProcs(), G4SteppingManager::InvokeAtRestDoItProcs(), G4SteppingManager::InvokePSDIP(), G4LossTableManager::LocalPhysicsTables(), G4ErrorPropagator::MakeOneStep(), G4VEmProcess::PostStepDoIt(), G4ITSteppingVerbose::PostStepDoItAllDone(), G4SteppingVerbose::PostStepDoItAllDone(), G4SteppingVerboseWithUnits::PostStepDoItAllDone(), G4ITSteppingVerbose::PostStepDoItOneByOne(), G4SteppingVerbose::PostStepDoItOneByOne(), G4SteppingVerboseWithUnits::PostStepDoItOneByOne(), G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNASecondOrderReaction::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4ITSteppingVerbose::PostStepVerbose(), G4EmConfigurator::PrepareModels(), G4HadronStoppingProcess::PreparePhysicsTable(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4LossTableManager::PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4HadronicProcessStore::PrintHtml(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4hImpactIonisation::PrintInfoDefinition(), G4ProcessPlacer::PrintProcVec(), G4VEnergyLossProcess::PrintWarning(), G4VEmProcess::PrintWarning(), G4SynchrotronRadiation::ProcessDescription(), G4Decay::ProcessDescription(), G4DecayWithSpin::ProcessDescription(), G4PionDecayMakeSpin::ProcessDescription(), G4UnknownDecay::ProcessDescription(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), G4StackManager::PushOneTrack(), G4HadronicProcessStore::Register(), G4LossTableManager::Register(), G4LossTableManager::RegisterExtraParticle(), G4HadronicProcessStore::RegisterExtraProcess(), G4HadronicProcessStore::RegisterParticle(), G4WrapperProcess::RegisterProcess(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTable::Remove(), G4ParallelGeometriesLimiterProcess::RemoveParallelWorld(), G4ProcessManager::RemoveProcess(), G4ProcessPlacer::RemoveProcess(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEmProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCSDARangeTable(), G4VEnergyLossProcess::SetInverseRangeTable(), G4VEnergyLossProcess::SetLambdaTable(), G4ProcessTableMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), G4ProcessManager::SetProcessOrdering(), G4ProcessManager::SetProcessOrderingToFirst(), G4ProcessManager::SetProcessOrderingToLast(), G4ProcessManager::SetProcessOrderingToSecond(), G4VEnergyLossProcess::SetRangeTableForLoss(), G4VEnergyLossProcess::SetSecondaryRangeTable(), G4FastSimulationManagerProcess::SetWorldVolume(), G4ITSteppingVerbose::ShowStep(), G4SteppingVerbose::ShowStep(), G4SteppingVerboseWithUnits::ShowStep(), G4ChannelingOptrChangeCrossSection::StartRun(), G4ITSteppingVerbose::StepInfo(), G4SteppingVerbose::StepInfo(), G4SteppingVerboseWithUnits::StepInfo(), G4ITSteppingVerbose::StepInfoForLeadingTrack(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), G4VMultipleScattering::StreamInfo(), G4EmCalculator::UpdateParticle(), G4ParallelWorldScoringProcess::Verbose(), G4ScoreSplittingProcess::Verbose(), G4ITSteppingVerbose::VerboseTrack(), G4SteppingVerbose::VerboseTrack(), and G4SteppingVerboseWithUnits::VerboseTrack().

◆ GetProcessSubType()

G4int G4VProcess::GetProcessSubType ( ) const
inlineinherited

◆ GetProcessType()

G4ProcessType G4VProcess::GetProcessType ( ) const
inlineinherited

◆ GetProcessTypeName()

const G4String & G4VProcess::GetProcessTypeName ( G4ProcessType  aType)
staticinherited

Definition at line 134 of file G4VProcess.cc.

135{
136 switch (aType)
137 {
138 case fNotDefined: return typeNotDefined; break;
139 case fTransportation: return typeTransportation; break;
140 case fElectromagnetic: return typeElectromagnetic; break;
141 case fOptical: return typeOptical; break;
142 case fHadronic: return typeHadronic; break;
144 case fDecay: return typeDecay; break;
145 case fGeneral: return typeGeneral; break;
146 case fParameterisation: return typeParameterisation; break;
147 case fUserDefined: return typeUserDefined; break;
148 case fPhonon: return typePhonon; break;
149 default: ;
150 }
151 return noType;
152}
@ fOptical
@ fPhonon
@ fParameterisation
@ fGeneral
@ fDecay
@ fElectromagnetic
@ fHadronic
@ fUserDefined
@ fTransportation
@ fPhotolepton_hadron
@ fNotDefined
static const G4String typeNotDefined
Definition: G4VProcess.cc:119
static const G4String typeParameterisation
Definition: G4VProcess.cc:127
static const G4String typePhotolepton_hadron
Definition: G4VProcess.cc:124
static const G4String typeElectromagnetic
Definition: G4VProcess.cc:121
static const G4String noType
Definition: G4VProcess.cc:130
static const G4String typeUserDefined
Definition: G4VProcess.cc:128
static const G4String typeDecay
Definition: G4VProcess.cc:125
static const G4String typeTransportation
Definition: G4VProcess.cc:120
static const G4String typeHadronic
Definition: G4VProcess.cc:123
static const G4String typeOptical
Definition: G4VProcess.cc:122
static const G4String typeGeneral
Definition: G4VProcess.cc:126
static const G4String typePhonon
Definition: G4VProcess.cc:129

References fDecay, fElectromagnetic, fGeneral, fHadronic, fNotDefined, fOptical, fParameterisation, fPhonon, fPhotolepton_hadron, fTransportation, fUserDefined, anonymous_namespace{G4VProcess.cc}::noType, anonymous_namespace{G4VProcess.cc}::typeDecay, anonymous_namespace{G4VProcess.cc}::typeElectromagnetic, anonymous_namespace{G4VProcess.cc}::typeGeneral, anonymous_namespace{G4VProcess.cc}::typeHadronic, anonymous_namespace{G4VProcess.cc}::typeNotDefined, anonymous_namespace{G4VProcess.cc}::typeOptical, anonymous_namespace{G4VProcess.cc}::typeParameterisation, anonymous_namespace{G4VProcess.cc}::typePhonon, anonymous_namespace{G4VProcess.cc}::typePhotolepton_hadron, anonymous_namespace{G4VProcess.cc}::typeTransportation, and anonymous_namespace{G4VProcess.cc}::typeUserDefined.

Referenced by G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4ProcessManager::DumpInfo(), G4VProcess::DumpInfo(), G4ProcessTableMessenger::G4ProcessTableMessenger(), G4ProcessTableMessenger::GetProcessType(), G4ProcessTableMessenger::GetProcessTypeName(), and G4ProcessTableMessenger::SetNumberOfProcessType().

◆ GetRange() [1/2]

G4double G4VEnergyLossProcess::GetRange ( G4double  kineticEnergy,
const G4MaterialCutsCouple couple 
)
inlineinherited

◆ GetRange() [2/2]

G4double G4VEnergyLossProcess::GetRange ( G4double  kineticEnergy,
const G4MaterialCutsCouple couple,
G4double  logKineticEnergy 
)
inlineinherited

◆ GetScaledRangeForScaledEnergy() [1/2]

G4double G4VEnergyLossProcess::GetScaledRangeForScaledEnergy ( G4double  scaledKinE)
inlineprivateinherited

Definition at line 637 of file G4VEnergyLossProcess.hh.

638{
639 //G4cout << "G4VEnergyLossProcess::GetScaledRange: Idx= "
640 // << basedCoupleIndex << " E(MeV)= " << e
641 // << " lastIdx= " << lastIdx << " " << theRangeTableForLoss << G4endl;
644 fRangeEnergy = e;
645 fRange = reduceFactor*((*theRangeTableForLoss)[basedCoupleIndex])->Value(e, idxRange);
646 if(e < minKinEnergy) { fRange *= std::sqrt(e/minKinEnergy); }
647 }
648 //G4cout << "G4VEnergyLossProcess::GetScaledRange: Idx= "
649 // << basedCoupleIndex << " E(MeV)= " << e
650 // << " R= " << computedRange << " " << theRangeTableForLoss << G4endl;
651 return fRange;
652}

References G4VEnergyLossProcess::basedCoupleIndex, G4VEnergyLossProcess::coupleIdxRange, G4VEnergyLossProcess::currentCoupleIndex, G4VEnergyLossProcess::fRange, G4VEnergyLossProcess::fRangeEnergy, G4VEnergyLossProcess::idxRange, G4VEnergyLossProcess::minKinEnergy, and G4VEnergyLossProcess::reduceFactor.

Referenced by G4VEnergyLossProcess::AlongStepGetPhysicalInteractionLength(), and G4VEnergyLossProcess::GetRange().

◆ GetScaledRangeForScaledEnergy() [2/2]

G4double G4VEnergyLossProcess::GetScaledRangeForScaledEnergy ( G4double  scaledKinE,
G4double  logScaledKinE 
)
inlineprivateinherited

Definition at line 655 of file G4VEnergyLossProcess.hh.

656{
657 //G4cout << "G4VEnergyLossProcess::GetScaledRange: Idx= "
658 // << basedCoupleIndex << " E(MeV)= " << e
659 // << " lastIdx= " << lastIdx << " " << theRangeTableForLoss << G4endl;
662 fRangeEnergy = e;
663 fRange = reduceFactor*((*theRangeTableForLoss)[basedCoupleIndex])->LogVectorValue(e, loge);
664 if(e < minKinEnergy) { fRange *= std::sqrt(e/minKinEnergy); }
665 }
666 //G4cout << "G4VEnergyLossProcess::GetScaledRange: Idx= "
667 // << basedCoupleIndex << " E(MeV)= " << e
668 // << " R= " << fRange << " " << theRangeTableForLoss << G4endl;
669 return fRange;
670}

References G4VEnergyLossProcess::basedCoupleIndex, G4VEnergyLossProcess::coupleIdxRange, G4VEnergyLossProcess::currentCoupleIndex, G4VEnergyLossProcess::fRange, G4VEnergyLossProcess::fRangeEnergy, G4VEnergyLossProcess::minKinEnergy, and G4VEnergyLossProcess::reduceFactor.

◆ GetTotalNumberOfInteractionLengthTraversed()

G4double G4VProcess::GetTotalNumberOfInteractionLengthTraversed ( ) const
inlineinherited

◆ GetVerboseLevel()

G4int G4VProcess::GetVerboseLevel ( ) const
inlineinherited

◆ InitialiseEnergyLossProcess()

void G4eBremsstrahlung::InitialiseEnergyLossProcess ( const G4ParticleDefinition ,
const G4ParticleDefinition  
)
overrideprotectedvirtual

Implements G4VEnergyLossProcess.

Definition at line 85 of file G4eBremsstrahlung.cc.

87{
88 if(!isInitialised) {
90
91 G4double emin = param->MinKinEnergy();
92 G4double emax = param->MaxKinEnergy();
93 G4VEmFluctuationModel* fm = nullptr;
94
95 if (nullptr == EmModel(0)) { SetEmModel(new G4SeltzerBergerModel()); }
96 EmModel(0)->SetLowEnergyLimit(emin);
97 G4double energyLimit = std::min(EmModel(0)->HighEnergyLimit(), GeV);
98 EmModel(0)->SetHighEnergyLimit(energyLimit);
100 EmModel(0)->SetLPMFlag(false);
101 AddEmModel(1, EmModel(0), fm);
102
103 if(emax > energyLimit) {
104 if (nullptr == EmModel(1)) { SetEmModel(new G4eBremsstrahlungRelModel()); }
105 EmModel(1)->SetLowEnergyLimit(energyLimit);
108 EmModel(1)->SetLPMFlag(param->LPM());
109 AddEmModel(1, EmModel(1), fm);
110 }
111 isInitialised = true;
112 }
113}
static constexpr double GeV
Definition: G4SIunits.hh:203
static G4EmParameters * Instance()
G4double MinKinEnergy() const
G4double BremsstrahlungTh() const
G4double MaxKinEnergy() const
G4bool LPM() const
void SetHighEnergyLimit(G4double)
Definition: G4VEmModel.hh:767
void SetSecondaryThreshold(G4double)
Definition: G4VEmModel.hh:809
void SetLPMFlag(G4bool val)
Definition: G4VEmModel.hh:816
void SetLowEnergyLimit(G4double)
Definition: G4VEmModel.hh:774
void AddEmModel(G4int, G4VEmModel *, G4VEmFluctuationModel *fluc=nullptr, const G4Region *region=nullptr)
void SetEmModel(G4VEmModel *, G4int index=0)
G4VEmModel * EmModel(size_t index=0) const

References G4VEnergyLossProcess::AddEmModel(), G4EmParameters::BremsstrahlungTh(), emax, G4VEnergyLossProcess::EmModel(), GeV, G4EmParameters::Instance(), isInitialised, G4EmParameters::LPM(), G4EmParameters::MaxKinEnergy(), G4INCL::Math::min(), G4EmParameters::MinKinEnergy(), G4VEnergyLossProcess::SetEmModel(), G4VEmModel::SetHighEnergyLimit(), G4VEmModel::SetLowEnergyLimit(), G4VEmModel::SetLPMFlag(), and G4VEmModel::SetSecondaryThreshold().

◆ InverseRangeTable()

G4PhysicsTable * G4VEnergyLossProcess::InverseRangeTable ( ) const
inlineinherited

◆ IonisationTable()

G4PhysicsTable * G4VEnergyLossProcess::IonisationTable ( ) const
inlineinherited

◆ isAlongStepDoItIsEnabled()

G4bool G4VProcess::isAlongStepDoItIsEnabled ( ) const
inlineinherited

Definition at line 506 of file G4VProcess.hh.

507{
508 return enableAlongStepDoIt;
509}
G4bool enableAlongStepDoIt
Definition: G4VProcess.hh:360

References G4VProcess::enableAlongStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ IsApplicable()

G4bool G4eBremsstrahlung::IsApplicable ( const G4ParticleDefinition p)
finalvirtual

Reimplemented from G4VProcess.

Definition at line 77 of file G4eBremsstrahlung.cc.

78{
79 return (&p == G4Electron::Electron() || &p == G4Positron::Positron());
80}
static G4Positron * Positron()
Definition: G4Positron.cc:93

References G4Electron::Electron(), and G4Positron::Positron().

◆ isAtRestDoItIsEnabled()

G4bool G4VProcess::isAtRestDoItIsEnabled ( ) const
inlineinherited

Definition at line 500 of file G4VProcess.hh.

501{
502 return enableAtRestDoIt;
503}
G4bool enableAtRestDoIt
Definition: G4VProcess.hh:359

References G4VProcess::enableAtRestDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ IsIonisationProcess()

G4bool G4VEnergyLossProcess::IsIonisationProcess ( ) const
inlineinherited

◆ isPostStepDoItIsEnabled()

G4bool G4VProcess::isPostStepDoItIsEnabled ( ) const
inlineinherited

Definition at line 512 of file G4VProcess.hh.

513{
514 return enablePostStepDoIt;
515}
G4bool enablePostStepDoIt
Definition: G4VProcess.hh:361

References G4VProcess::enablePostStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ IsRegionForCubcutProcessor()

G4bool G4VEnergyLossProcess::IsRegionForCubcutProcessor ( const G4Track aTrack)
privateinherited

Definition at line 817 of file G4VEnergyLossProcess.cc.

818{
819 if(0 == nSCoffRegions) { return true; }
820 const G4Region* r = aTrack.GetVolume()->GetLogicalVolume()->GetRegion();
821 for(auto & reg : *scoffRegions) {
822 if(r == reg) { return true; }
823 }
824 return false;
825}
G4Region * GetRegion() const
G4VPhysicalVolume * GetVolume() const
G4LogicalVolume * GetLogicalVolume() const

References G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetRegion(), G4Track::GetVolume(), G4VEnergyLossProcess::nSCoffRegions, reg, and G4VEnergyLossProcess::scoffRegions.

Referenced by G4VEnergyLossProcess::AlongStepDoIt().

◆ LambdaPhysicsVector()

G4PhysicsVector * G4VEnergyLossProcess::LambdaPhysicsVector ( const G4MaterialCutsCouple couple,
G4double  cut 
)
protectedinherited

◆ LambdaTable()

G4PhysicsTable * G4VEnergyLossProcess::LambdaTable ( ) const
inlineinherited

◆ MaxKinEnergy()

G4double G4VEnergyLossProcess::MaxKinEnergy ( ) const
inlineinherited

Definition at line 935 of file G4VEnergyLossProcess.hh.

936{
937 return maxKinEnergy;
938}

References G4VEnergyLossProcess::maxKinEnergy.

◆ MeanFreePath()

G4double G4VEnergyLossProcess::MeanFreePath ( const G4Track track)
inherited

◆ MinKinEnergy()

G4double G4VEnergyLossProcess::MinKinEnergy ( ) const
inlineinherited

Definition at line 928 of file G4VEnergyLossProcess.hh.

929{
930 return minKinEnergy;
931}

References G4VEnergyLossProcess::minKinEnergy.

◆ MinPrimaryEnergy()

G4double G4VEnergyLossProcess::MinPrimaryEnergy ( const G4ParticleDefinition ,
const G4Material ,
G4double  cut 
)
protectedvirtualinherited

◆ NumberOfModels()

size_t G4VEnergyLossProcess::NumberOfModels ( ) const
inlineinherited

Definition at line 1026 of file G4VEnergyLossProcess.hh.

1027{
1028 return numberOfModels;
1029}

References G4VEnergyLossProcess::numberOfModels.

◆ NumberOfSubCutoffRegions()

G4int G4VEnergyLossProcess::NumberOfSubCutoffRegions ( ) const
inlineinherited

Definition at line 921 of file G4VEnergyLossProcess.hh.

922{
923 return nSCoffRegions;
924}

References G4VEnergyLossProcess::nSCoffRegions.

Referenced by G4LossTableManager::BuildTables().

◆ operator!=()

G4bool G4VProcess::operator!= ( const G4VProcess right) const
inherited

Definition at line 161 of file G4VProcess.cc.

162{
163 return (this != &right);
164}

◆ operator=()

G4eBremsstrahlung & G4eBremsstrahlung::operator= ( const G4eBremsstrahlung right)
delete

◆ operator==()

G4bool G4VProcess::operator== ( const G4VProcess right) const
inherited

Definition at line 155 of file G4VProcess.cc.

156{
157 return (this == &right);
158}

◆ Particle()

const G4ParticleDefinition * G4VEnergyLossProcess::Particle ( ) const
inlineinherited

◆ PostStepDoIt()

G4VParticleChange * G4VEnergyLossProcess::PostStepDoIt ( const G4Track track,
const G4Step step 
)
overridevirtualinherited

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 1289 of file G4VEnergyLossProcess.cc.

1291{
1292 // In all cases clear number of interaction lengths
1295
1297 const G4double finalT = track.GetKineticEnergy();
1298
1299 const G4double postStepScaledEnergy = finalT*massRatio;
1300 SelectModel(postStepScaledEnergy);
1301
1302 if(!currentModel->IsActive(postStepScaledEnergy)) {
1303 return &fParticleChange;
1304 }
1305 /*
1306 if(-1 < verboseLevel) {
1307 G4cout << GetProcessName()
1308 << "::PostStepDoIt: E(MeV)= " << finalT/MeV
1309 << G4endl;
1310 }
1311 */
1312
1313 // forced process - should happen only once per track
1314 if(biasFlag) {
1316 biasFlag = false;
1317 }
1318 }
1319
1320 const G4DynamicParticle* dp = track.GetDynamicParticle();
1321
1322 // Integral approach
1323 if (fXSType != fEmNoIntegral) {
1324 const G4double logFinalT = dp->GetLogKineticEnergy();
1325 G4double lx = GetLambdaForScaledEnergy(postStepScaledEnergy,
1326 logFinalT + logMassRatio);
1327 lx = std::max(lx, 0.0);
1328
1329 // cache cross section useful for the false interaction
1330 const G4double lg = preStepLambda;
1331 if(postStepScaledEnergy < mfpKinEnergy) {
1332 mfpKinEnergy = postStepScaledEnergy;
1333 preStepLambda = lx;
1334 }
1335 /*
1336 if(preStepLambda<lx && 1 < verboseLevel) {
1337 G4cout << "WARNING: for " << particle->GetParticleName()
1338 << " and " << GetProcessName()
1339 << " E(MeV)= " << finalT/MeV
1340 << " preLambda= " << preStepLambda
1341 << " < " << lx << " (postLambda) "
1342 << G4endl;
1343 }
1344 */
1345 // if both lg and lx are zero then no interaction
1346 if(lg*G4UniformRand() >= lx) {
1347 return &fParticleChange;
1348 }
1349 }
1350 // define new weight for primary and secondaries
1352 if(weightFlag) {
1353 weight /= biasFactor;
1355 }
1356
1357 const G4double tcut = (*theCuts)[currentCoupleIndex];
1358
1359 // sample secondaries
1360 secParticles.clear();
1361 //G4cout<< "@@@ Eprimary= "<<dynParticle->GetKineticEnergy()/MeV
1362 // << " cut= " << tcut/MeV << G4endl;
1364
1365 const G4int num0 = secParticles.size();
1366
1367 // bremsstrahlung splitting or Russian roulette
1368 if(biasManager) {
1370 G4double eloss = 0.0;
1373 track, currentModel,
1374 &fParticleChange, eloss,
1375 currentCoupleIndex, tcut,
1376 step.GetPostStepPoint()->GetSafety());
1377 if(eloss > 0.0) {
1380 }
1381 }
1382 }
1383
1384 // save secondaries
1385 const G4int num = secParticles.size();
1386 if(num > 0) {
1387
1389 G4double time = track.GetGlobalTime();
1390
1391 G4int n1(0), n2(0);
1392 if(num0 > mainSecondaries) {
1394 }
1395
1396 for (G4int i=0; i<num; ++i) {
1397 if(nullptr != secParticles[i]) {
1398 G4Track* t = new G4Track(secParticles[i], time, track.GetPosition());
1400 if (biasManager) {
1401 t->SetWeight(weight * biasManager->GetWeight(i));
1402 } else {
1403 t->SetWeight(weight);
1404 }
1405 if(i < num0) {
1407 } else if(i < num0 + n1) {
1409 } else {
1411 }
1412
1413 //G4cout << "Secondary(post step) has weight " << t->GetWeight()
1414 // << ", kenergy " << t->GetKineticEnergy()/MeV << " MeV"
1415 // << " time= " << time/ns << " ns " << G4endl;
1417 }
1418 }
1419 }
1420
1426 }
1427
1428 /*
1429 if(-1 < verboseLevel) {
1430 G4cout << "::PostStepDoIt: Sample secondary; Efin= "
1431 << fParticleChange.GetProposedKineticEnergy()/MeV
1432 << " MeV; model= (" << currentModel->LowEnergyLimit()
1433 << ", " << currentModel->HighEnergyLimit() << ")"
1434 << " preStepLambda= " << preStepLambda
1435 << " dir= " << track.GetMomentumDirection()
1436 << " status= " << track.GetTrackStatus()
1437 << G4endl;
1438 }
1439 */
1440 return &fParticleChange;
1441}
@ fEmNoIntegral
@ fAlive
@ fStopAndKill
@ fStopButAlive
#define G4UniformRand()
Definition: Randomize.hh:52
G4bool ForcedInteractionRegion(G4int coupleIdx)
G4double GetWeight(G4int i)
void InitializeForPostStep(const G4Track &)
G4double GetProposedKineticEnergy() const
G4ProcessManager * GetProcessManager() const
G4ProcessVector * GetAtRestProcessVector(G4ProcessVectorTypeIndex typ=typeGPIL) const
std::size_t size() const
G4double GetSafety() const
G4StepPoint * GetPostStepPoint() const
const G4ThreeVector & GetPosition() const
void SetTouchableHandle(const G4TouchableHandle &apValue)
G4double GetGlobalTime() const
const G4TouchableHandle & GetTouchableHandle() const
virtual void FillNumberOfSecondaries(G4int &numberOfTriplets, G4int &numberOfRecoil)
Definition: G4VEmModel.cc:365
virtual void SampleSecondaries(std::vector< G4DynamicParticle * > *, const G4MaterialCutsCouple *, const G4DynamicParticle *, G4double tmin=0.0, G4double tmax=DBL_MAX)=0
std::vector< G4DynamicParticle * > secParticles
void ProposeTrackStatus(G4TrackStatus status)
G4double GetLocalEnergyDeposit() const
G4TrackStatus GetTrackStatus() const

References G4VParticleChange::AddSecondary(), G4EmBiasingManager::ApplySecondaryBiasing(), G4VEnergyLossProcess::biasFactor, G4VEnergyLossProcess::biasFlag, G4VEnergyLossProcess::biasID, G4VEnergyLossProcess::biasManager, G4VEnergyLossProcess::currentCouple, G4VEnergyLossProcess::currentCoupleIndex, G4VEnergyLossProcess::currentModel, DBL_MAX, fAlive, fEmNoIntegral, G4VEmModel::FillNumberOfSecondaries(), G4EmBiasingManager::ForcedInteractionRegion(), G4VEnergyLossProcess::fParticleChange, fStopAndKill, fStopButAlive, G4VEnergyLossProcess::fXSType, G4UniformRand, G4ProcessManager::GetAtRestProcessVector(), G4Track::GetDynamicParticle(), G4Track::GetGlobalTime(), G4Track::GetKineticEnergy(), G4VEnergyLossProcess::GetLambdaForScaledEnergy(), G4VParticleChange::GetLocalEnergyDeposit(), G4DynamicParticle::GetLogKineticEnergy(), G4VParticleChange::GetParentWeight(), G4Track::GetPosition(), G4Step::GetPostStepPoint(), G4ParticleDefinition::GetProcessManager(), G4ParticleChangeForLoss::GetProposedKineticEnergy(), G4StepPoint::GetSafety(), G4Track::GetTouchableHandle(), G4VParticleChange::GetTrackStatus(), G4EmBiasingManager::GetWeight(), G4ParticleChangeForLoss::InitializeForPostStep(), G4VEmModel::IsActive(), G4VEnergyLossProcess::logMassRatio, G4VEnergyLossProcess::mainSecondaries, G4VEnergyLossProcess::massRatio, G4INCL::Math::max(), G4VEnergyLossProcess::mfpKinEnergy, G4VEnergyLossProcess::particle, G4VProcess::pParticleChange, G4VEnergyLossProcess::preStepLambda, G4VParticleChange::ProposeLocalEnergyDeposit(), G4VParticleChange::ProposeTrackStatus(), G4VParticleChange::ProposeWeight(), G4VEmModel::SampleSecondaries(), G4VEnergyLossProcess::secID, G4EmBiasingManager::SecondaryBiasingRegion(), G4VEnergyLossProcess::secParticles, G4VEnergyLossProcess::SelectModel(), G4Track::SetCreatorModelID(), G4VParticleChange::SetNumberOfSecondaries(), G4Track::SetTouchableHandle(), G4Track::SetWeight(), G4ProcessVector::size(), G4VProcess::theNumberOfInteractionLengthLeft, G4VEnergyLossProcess::tripletID, and G4VEnergyLossProcess::weightFlag.

◆ PostStepGetPhysicalInteractionLength()

G4double G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength ( const G4Track track,
G4double  previousStepSize,
G4ForceCondition condition 
)
overridevirtualinherited

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 901 of file G4VEnergyLossProcess.cc.

905{
906 // condition is set to "Not Forced"
908 G4double x = DBL_MAX;
909
910 // initialisation of material, mass, charge, model
911 // at the beginning of the step
918
922 return x;
923 }
924
925 // change effective charge of a charged particle on fly
926 if(isIon) {
927 const G4double q2 = currentModel->ChargeSquareRatio(track);
928 if(q2 != chargeSqRatio) {
931 chargeSqRatio = q2;
932 // G4cout << "PostStepGPIL: Q^2=" << chargeSqRatio << " reducedFactor=" << reduceFactor << G4endl;
933 }
934 }
935
936 // forced biasing only for primary particles
937 if(biasManager) {
938 if(0 == track.GetParentID() && biasFlag &&
940 return biasManager->GetStepLimit(currentCoupleIndex, previousStepSize);
941 }
942 }
943
944 // compute mean free path
946
947 // zero cross section
948 if(preStepLambda <= 0.0) {
951 } else {
952
953 // non-zero cross section
955
956 // beggining of tracking (or just after DoIt of this process)
959
960 } else if(currentInteractionLength < DBL_MAX) {
961
962 // subtract NumberOfInteractionLengthLeft using previous step
964 previousStepSize/currentInteractionLength;
965
968 }
969
970 // new mean free path and step limit
973 }
974#ifdef G4VERBOSE
975 if (verboseLevel>2){
976 // if(particle->GetPDGMass() > 0.9*GeV){
977 G4cout << "G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength ";
978 G4cout << "[ " << GetProcessName() << "]" << G4endl;
979 G4cout << " for " << track.GetDefinition()->GetParticleName()
980 << " in Material " << currentMaterial->GetName()
981 << " Ekin(MeV)= " << preStepKinEnergy/MeV
982 << " " << track.GetMaterial()->GetName()
983 <<G4endl;
984 G4cout << "MeanFreePath = " << currentInteractionLength/cm << "[cm]"
985 << "InteractionLength= " << x/cm <<"[cm] " <<G4endl;
986 }
987#endif
988 return x;
989}
static constexpr double cm
Definition: G4SIunits.hh:99
G4double GetStepLimit(G4int coupleIdx, G4double previousStep)
const G4String & GetName() const
Definition: G4Material.hh:173
G4Material * GetMaterial() const
G4ParticleDefinition * GetDefinition() const
G4int GetParentID() const
virtual G4double ChargeSquareRatio(const G4Track &)
Definition: G4VEmModel.cc:374
void ComputeLambdaForScaledEnergy(G4double scaledKinE, G4double logScaledKinE)

References G4VEnergyLossProcess::biasFlag, G4VEnergyLossProcess::biasManager, G4VEnergyLossProcess::chargeSqRatio, G4VEmModel::ChargeSquareRatio(), cm, G4VEnergyLossProcess::ComputeLambdaForScaledEnergy(), condition(), G4VEnergyLossProcess::currentCoupleIndex, G4VProcess::currentInteractionLength, G4VEnergyLossProcess::currentMaterial, G4VEnergyLossProcess::currentModel, DBL_MAX, G4VEnergyLossProcess::DefineMaterial(), G4VEnergyLossProcess::fFactor, G4EmBiasingManager::ForcedInteractionRegion(), G4cout, G4endl, G4Log(), G4UniformRand, G4Track::GetDefinition(), G4Track::GetDynamicParticle(), G4Track::GetKineticEnergy(), G4DynamicParticle::GetLogKineticEnergy(), G4Track::GetMaterial(), G4Track::GetMaterialCutsCouple(), G4Material::GetName(), G4Track::GetParentID(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4EmBiasingManager::GetStepLimit(), G4VEmModel::IsActive(), G4VEnergyLossProcess::isIon, G4VEnergyLossProcess::logMassRatio, G4VEnergyLossProcess::massRatio, G4INCL::Math::max(), MeV, NotForced, G4VEnergyLossProcess::preStepKinEnergy, G4VEnergyLossProcess::preStepLambda, G4VEnergyLossProcess::preStepLogKinEnergy, G4VEnergyLossProcess::preStepLogScaledEnergy, G4VEnergyLossProcess::preStepScaledEnergy, G4VEnergyLossProcess::reduceFactor, G4VEnergyLossProcess::SelectModel(), G4VProcess::theInitialNumberOfInteractionLength, G4VProcess::theNumberOfInteractionLengthLeft, and G4VProcess::verboseLevel.

Referenced by G4PolarizedIonisation::PostStepGetPhysicalInteractionLength().

◆ PostStepGPIL()

G4double G4VProcess::PostStepGPIL ( const G4Track track,
G4double  previousStepSize,
G4ForceCondition condition 
)
inlineinherited

Definition at line 479 of file G4VProcess.hh.

482{
483 return thePILfactor *
484 PostStepGetPhysicalInteractionLength(track, previousStepSize, condition);
485}
virtual G4double PostStepGetPhysicalInteractionLength(const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)=0

References condition(), G4VProcess::PostStepGetPhysicalInteractionLength(), and G4VProcess::thePILfactor.

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

◆ PreparePhysicsTable()

void G4VEnergyLossProcess::PreparePhysicsTable ( const G4ParticleDefinition part)
overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 254 of file G4VEnergyLossProcess.cc.

255{
256 if(1 < verboseLevel) {
257 G4cout << "G4VEnergyLossProcess::PreparePhysicsTable for "
258 << GetProcessName() << " for " << part.GetParticleName()
259 << " " << this << G4endl;
260 }
262
263 // Are particle defined?
264 if(nullptr == particle) { particle = &part; }
265
266 if(part.GetParticleType() == "nucleus") {
267
269 if(pname != "deuteron" && pname != "triton" &&
270 pname != "alpha+" && pname != "alpha") {
271
272 if(nullptr == theGenericIon) {
275 }
276 isIon = true;
277 if(particle != theGenericIon) {
280 size_t n = v->size();
281 for(size_t j=0; j<n; ++j) {
282 if((*v)[j] == this) {
284 break;
285 }
286 }
287 }
288 }
289 }
290
291 if( particle != &part ) {
292 if(!isIon) {
293 lManager->RegisterExtraParticle(&part, this);
294 }
295 if(1 < verboseLevel) {
296 G4cout << "### G4VEnergyLossProcess::PreparePhysicsTable()"
297 << " interrupted for "
298 << part.GetParticleName() << " isIon=" << isIon
299 << " baseMat=" << baseMat
300 << " particle " << particle << " GenericIon " << theGenericIon
301 << G4endl;
302 }
303 return;
304 }
305
306 tablesAreBuilt = false;
307
310
311 // Base particle and set of models can be defined here
313
314 // parameters of the process
328
330
332
333 G4double initialCharge = particle->GetPDGCharge();
334 G4double initialMass = particle->GetPDGMass();
335
337
338 // integral option may be disabled
340
341 // parameters for scaling from the base particle
342 if (nullptr != baseParticle) {
343 massRatio = (baseParticle->GetPDGMass())/initialMass;
345 G4double q = initialCharge/baseParticle->GetPDGCharge();
346 chargeSqRatio = q*q;
348 }
349 lowestKinEnergy = (initialMass < CLHEP::MeV)
352
353 // Tables preparation
354 if (isMaster && nullptr == baseParticle) {
355
356 if(nullptr != theDEDXTable && isIonisation) {
359 delete theDEDXTable;
361 }
362 }
363
366
372 }
373
375
376 if(isIonisation) {
381 }
382
383 if(fXSType == fEmTwoPeaks) {
384 const G4ProductionCutsTable* theCoupleTable=
386 size_t n = theCoupleTable->GetTableSize();
387 if(nullptr == fXSpeaks) {
388 fXSpeaks = new std::vector<G4TwoPeaksXS*>;
389 }
390 fXSpeaks->resize(n, nullptr);
391 }
392 }
393 /*
394 G4cout << "** G4VEnergyLossProcess::PreparePhysicsTable() for "
395 << GetProcessName() << " and " << particle->GetParticleName()
396 << " isMaster: " << isMaster << " isIonisation: "
397 << isIonisation << G4endl;
398 G4cout << " theDEDX: " << theDEDXTable
399 << " theRange: " << theRangeTableForLoss
400 << " theInverse: " << theInverseRangeTable
401 << " theLambda: " << theLambdaTable << G4endl;
402 */
403 // forced biasing
404 if(nullptr != biasManager) {
406 biasFlag = false;
407 }
408
409 // defined ID of secondary particles
410 G4int stype = GetProcessSubType();
411 if(stype == fBremsstrahlung) {
414 } else if(stype == fPairProdByCharged) {
416 mainSecondaries = 2;
417 }
419
420 // initialisation of models
422 for(G4int i=0; i<numberOfModels; ++i) {
424 if(0 == i) { currentModel = mod; }
428 if(mod->HighEnergyLimit() > maxKinEnergy) {
430 }
432 SetEmModel(mod);
433 }
435 1.0, verboseLevel);
436
437 // subcut processor
438 if(isIonisation) {
440 }
441 if(1 == nSCoffRegions) {
442 if((*scoffRegions)[0]->GetName() == "DefaultRegionForTheWorld") {
443 delete scoffRegions;
444 scoffRegions = nullptr;
445 nSCoffRegions = 0;
446 }
447 }
448
449 if(1 < verboseLevel) {
450 G4cout << "G4VEnergyLossProcess::PrepearPhysicsTable() is done "
451 << " for local " << particle->GetParticleName()
452 << " isIon= " << isIon;
453 if(baseParticle) {
454 G4cout << "; base: " << baseParticle->GetParticleName();
455 }
456 G4cout << " chargeSqRatio= " << chargeSqRatio
457 << " massRatio= " << massRatio
458 << " reduceFactor= " << reduceFactor << G4endl;
459 if (nSCoffRegions > 0) {
460 G4cout << " SubCut secondary production is ON for regions: " << G4endl;
461 for (G4int i=0; i<nSCoffRegions; ++i) {
462 const G4Region* r = (*scoffRegions)[i];
463 G4cout << " " << r->GetName() << G4endl;
464 }
465 } else if(nullptr != subcutProducer) {
466 G4cout << " SubCut secondary production is ON for all regions" << G4endl;
467 }
468 }
469}
@ fPairProdByCharged
@ _SplitBremsstrahlung
void Initialise(const G4ParticleDefinition &part, const G4String &procName, G4int verbose)
G4int NumberOfModels() const
const G4DataVector * Initialise(const G4ParticleDefinition *part, const G4ParticleDefinition *secPart, G4double, G4int verb)
void DefineRegParamForLoss(G4VEnergyLossProcess *) const
void FillStepFunction(const G4ParticleDefinition *, G4VEnergyLossProcess *) const
G4int NumberOfBins() const
G4int NumberOfBinsPerDecade() const
G4bool BuildCSDARange() const
G4bool LossFluctuation() const
G4bool UseCutAsFinalRange() const
G4int Verbose() const
G4int WorkerVerbose() const
G4bool Integral() const
G4double MaxEnergyForCSDARange() const
G4bool UseAngularGeneratorForIonisation() const
G4double LinearLossLimit() const
G4double LowestMuHadEnergy() const
G4double LambdaFactor() const
G4double LowestElectronEnergy() const
void InitialiseBaseMaterials(const G4PhysicsTable *table=nullptr)
void PreparePhysicsTable(const G4ParticleDefinition *aParticle, G4VEnergyLossProcess *p, G4bool theMaster)
G4VSubCutProducer * SubCutProducer()
void RegisterExtraParticle(const G4ParticleDefinition *aParticle, G4VEnergyLossProcess *p)
const G4String & GetParticleType() const
G4double GetPDGCharge() const
G4ParticleDefinition * FindParticle(G4int PDGEncoding)
static G4ParticleTable * GetParticleTable()
static G4PhysicsTable * PreparePhysicsTable(G4PhysicsTable *physTable)
void clearAndDestroy()
G4ProcessVector * GetAlongStepProcessVector(G4ProcessVectorTypeIndex typ=typeGPIL) const
const G4String & GetName() const
void SetMasterThread(G4bool val)
Definition: G4VEmModel.hh:739
void SetAngularGeneratorFlag(G4bool)
Definition: G4VEmModel.hh:725
G4double HighEnergyLimit() const
Definition: G4VEmModel.hh:655
virtual void InitialiseEnergyLossProcess(const G4ParticleDefinition *, const G4ParticleDefinition *)=0
const G4ParticleDefinition * theGenericIon
G4PhysicsTable * theRangeTableForLoss
std::vector< G4TwoPeaksXS * > * fXSpeaks
void SetVerboseLevel(G4int value)
Definition: G4VProcess.hh:412
G4int GetProcessSubType() const
Definition: G4VProcess.hh:400
static constexpr double MeV
string pname
Definition: eplot.py:33

References _Bremsstrahlung, _PairProduction, _SplitBremsstrahlung, G4VEnergyLossProcess::actBinning, G4VEnergyLossProcess::actLinLossLimit, G4VEnergyLossProcess::actLossFluc, G4VEnergyLossProcess::actMaxKinEnergy, G4VEnergyLossProcess::actMinKinEnergy, G4VEnergyLossProcess::baseMat, G4VEnergyLossProcess::baseParticle, G4VEnergyLossProcess::biasFlag, G4VEnergyLossProcess::biasID, G4VEnergyLossProcess::biasManager, G4EmParameters::BuildCSDARange(), G4VEnergyLossProcess::chargeSqRatio, G4PhysicsTable::clearAndDestroy(), G4VEnergyLossProcess::currentModel, G4EmParameters::DefineRegParamForLoss(), fBremsstrahlung, fEmNoIntegral, fEmTwoPeaks, G4EmParameters::FillStepFunction(), G4ParticleTable::FindParticle(), G4VEnergyLossProcess::fLambdaEnergy, fPairProdByCharged, G4VEnergyLossProcess::fRangeEnergy, G4VEnergyLossProcess::fXSpeaks, G4VEnergyLossProcess::fXSType, G4cout, G4endl, G4Log(), G4lrint(), G4ProcessManager::GetAlongStepProcessVector(), G4LossTableBuilder::GetBaseMaterialFlag(), G4EmModelManager::GetModel(), G4Region::GetName(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetParticleType(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), G4ParticleDefinition::GetProcessManager(), G4VProcess::GetProcessName(), G4VProcess::GetProcessSubType(), G4ProductionCutsTable::GetProductionCutsTable(), G4LossTableManager::GetTableBuilder(), G4ProductionCutsTable::GetTableSize(), G4VEmModel::HighEnergyLimit(), G4EmBiasingManager::Initialise(), G4EmModelManager::Initialise(), G4LossTableBuilder::InitialiseBaseMaterials(), G4VEnergyLossProcess::InitialiseEnergyLossProcess(), G4EmParameters::Integral(), G4VEnergyLossProcess::isIon, G4VEnergyLossProcess::isIonisation, G4LossTableManager::IsMaster(), G4VEnergyLossProcess::isMaster, G4EmParameters::LambdaFactor(), G4VEnergyLossProcess::lambdaFactor, G4EmParameters::LinearLossLimit(), G4VEnergyLossProcess::linLossLimit, G4VEnergyLossProcess::lManager, G4VEnergyLossProcess::logLambdafactor, G4VEnergyLossProcess::logMassRatio, G4EmParameters::LossFluctuation(), G4VEnergyLossProcess::lossFluctuationFlag, G4EmParameters::LowestElectronEnergy(), G4VEnergyLossProcess::lowestKinEnergy, G4EmParameters::LowestMuHadEnergy(), G4VEnergyLossProcess::mainSecondaries, G4VEnergyLossProcess::massRatio, G4EmParameters::MaxEnergyForCSDARange(), G4EmParameters::MaxKinEnergy(), G4VEnergyLossProcess::maxKinEnergy, G4VEnergyLossProcess::maxKinEnergyCSDA, CLHEP::MeV, G4EmParameters::MinKinEnergy(), G4VEnergyLossProcess::minKinEnergy, G4VEnergyLossProcess::modelManager, CLHEP::detail::n, G4VEnergyLossProcess::nBins, G4VEnergyLossProcess::nBinsCSDA, G4VEnergyLossProcess::nSCoffRegions, G4EmParameters::NumberOfBins(), G4EmParameters::NumberOfBinsPerDecade(), G4EmModelManager::NumberOfModels(), G4VEnergyLossProcess::numberOfModels, G4VEnergyLossProcess::particle, eplot::pname, G4LossTableManager::PreparePhysicsTable(), G4PhysicsTableHelper::PreparePhysicsTable(), G4VEnergyLossProcess::reduceFactor, G4LossTableManager::RegisterExtraParticle(), G4VEnergyLossProcess::rndmStepFlag, G4VEnergyLossProcess::scoffRegions, G4VEnergyLossProcess::secID, G4VEnergyLossProcess::secondaryParticle, G4VEmModel::SetAngularGeneratorFlag(), G4VEnergyLossProcess::SetEmModel(), G4VEmModel::SetHighEnergyLimit(), G4VEmModel::SetMasterThread(), G4VEmModel::SetUseBaseMaterials(), G4VProcess::SetVerboseLevel(), G4ProcessVector::size(), G4LossTableManager::SubCutProducer(), G4VEnergyLossProcess::subcutProducer, G4VEnergyLossProcess::tablesAreBuilt, G4VEnergyLossProcess::theCSDARangeTable, G4VEnergyLossProcess::theCuts, G4VEnergyLossProcess::theDEDXTable, G4VEnergyLossProcess::theDEDXunRestrictedTable, G4VEnergyLossProcess::theGenericIon, G4VEnergyLossProcess::theInverseRangeTable, G4VEnergyLossProcess::theIonisationTable, G4VEnergyLossProcess::theLambdaTable, G4VEnergyLossProcess::theParameters, G4VEnergyLossProcess::theRangeTableForLoss, G4EmParameters::UseAngularGeneratorForIonisation(), G4EmParameters::UseCutAsFinalRange(), G4EmParameters::Verbose(), G4VProcess::verboseLevel, and G4EmParameters::WorkerVerbose().

◆ PrepareWorkerPhysicsTable()

void G4VProcess::PrepareWorkerPhysicsTable ( const G4ParticleDefinition part)
virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.cc.

207{
209}
virtual void PreparePhysicsTable(const G4ParticleDefinition &)
Definition: G4VProcess.hh:194

References G4VProcess::PreparePhysicsTable().

Referenced by G4BiasingProcessInterface::PrepareWorkerPhysicsTable().

◆ PrintWarning()

void G4VEnergyLossProcess::PrintWarning ( const G4String tit,
G4double  val 
) const
privateinherited

Definition at line 2032 of file G4VEnergyLossProcess.cc.

2033{
2034 G4String ss = "G4VEnergyLossProcess::" + tit;
2036 ed << "Parameter is out of range: " << val
2037 << " it will have no effect!\n" << " Process "
2038 << GetProcessName() << " nbins= " << nBins
2039 << " Emin(keV)= " << minKinEnergy/keV
2040 << " Emax(GeV)= " << maxKinEnergy/GeV;
2041 G4Exception(ss, "em0044", JustWarning, ed);
2042}
@ JustWarning
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:35
std::ostringstream G4ExceptionDescription
Definition: G4Exception.hh:40
static constexpr double keV
Definition: G4SIunits.hh:202

References G4Exception(), G4VProcess::GetProcessName(), GeV, JustWarning, keV, G4VEnergyLossProcess::maxKinEnergy, G4VEnergyLossProcess::minKinEnergy, and G4VEnergyLossProcess::nBins.

Referenced by G4VEnergyLossProcess::SetDEDXBinning(), G4VEnergyLossProcess::SetLinearLossLimit(), G4VEnergyLossProcess::SetLowestEnergyLimit(), G4VEnergyLossProcess::SetMaxKinEnergy(), G4VEnergyLossProcess::SetMinKinEnergy(), and G4VEnergyLossProcess::SetStepFunction().

◆ ProcessDescription()

void G4eBremsstrahlung::ProcessDescription ( std::ostream &  out) const
overridevirtual

Reimplemented from G4VProcess.

Definition at line 133 of file G4eBremsstrahlung.cc.

134{
135 out << " Bremsstrahlung";
137}
void ProcessDescription(std::ostream &outFile) const override

References G4VEnergyLossProcess::ProcessDescription().

Referenced by G4PolarizedBremsstrahlung::ProcessDescription().

◆ RangeTableForLoss()

G4PhysicsTable * G4VEnergyLossProcess::RangeTableForLoss ( ) const
inlineinherited

◆ ResetNumberOfInteractionLengthLeft()

void G4VProcess::ResetNumberOfInteractionLengthLeft ( )
virtualinherited

◆ RetrievePhysicsTable()

G4bool G4VEnergyLossProcess::RetrievePhysicsTable ( const G4ParticleDefinition part,
const G4String directory,
G4bool  ascii 
)
overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 1484 of file G4VEnergyLossProcess.cc.

1487{
1488 G4bool res = true;
1489 if (!isMaster) return res;
1490 const G4String& particleName = part->GetParticleName();
1491
1492 if(1 < verboseLevel) {
1493 G4cout << "G4VEnergyLossProcess::RetrievePhysicsTable() for "
1494 << particleName << " and process " << GetProcessName()
1495 << "; tables_are_built= " << tablesAreBuilt
1496 << G4endl;
1497 }
1498 if(particle == part) {
1499
1500 if(nullptr == baseParticle) {
1501
1502 G4bool fpi = true;
1503 if(!RetrieveTable(part,theDEDXTable,ascii,directory,"DEDX",fpi))
1504 { fpi = false; }
1505
1506 // ionisation table keeps individual dEdx and not sum of sub-processes
1507 if(!RetrieveTable(part,theDEDXTable,ascii,directory,"Ionisation",false))
1508 { fpi = false; }
1509
1510 if(!RetrieveTable(part,theRangeTableForLoss,ascii,directory,"Range",fpi))
1511 { res = false; }
1512
1513 if(!RetrieveTable(part,theDEDXunRestrictedTable,ascii,directory,
1514 "DEDXnr",false))
1515 { res = false; }
1516
1517 if(!RetrieveTable(part,theCSDARangeTable,ascii,directory,
1518 "CSDARange",false))
1519 { res = false; }
1520
1521 if(!RetrieveTable(part,theInverseRangeTable,ascii,directory,
1522 "InverseRange",fpi))
1523 { res = false; }
1524
1525 if(!RetrieveTable(part,theLambdaTable,ascii,directory,"Lambda",true))
1526 { res = false; }
1527 }
1528 }
1529 return res;
1530}
G4bool RetrieveTable(const G4ParticleDefinition *p, G4PhysicsTable *, G4bool ascii, const G4String &directory, const G4String &tname, G4bool mandatory)

References G4VEnergyLossProcess::baseParticle, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4VEnergyLossProcess::isMaster, G4VEnergyLossProcess::particle, G4VEnergyLossProcess::RetrieveTable(), G4VEnergyLossProcess::tablesAreBuilt, G4VEnergyLossProcess::theCSDARangeTable, G4VEnergyLossProcess::theDEDXTable, G4VEnergyLossProcess::theDEDXunRestrictedTable, G4VEnergyLossProcess::theInverseRangeTable, G4VEnergyLossProcess::theLambdaTable, G4VEnergyLossProcess::theRangeTableForLoss, and G4VProcess::verboseLevel.

◆ RetrieveTable()

G4bool G4VEnergyLossProcess::RetrieveTable ( const G4ParticleDefinition p,
G4PhysicsTable aTable,
G4bool  ascii,
const G4String directory,
const G4String tname,
G4bool  mandatory 
)
privateinherited

Definition at line 1555 of file G4VEnergyLossProcess.cc.

1561{
1562 G4bool isRetrieved = false;
1563 G4String filename = GetPhysicsTableFileName(part,directory,tname,ascii);
1564 if(nullptr != aTable) {
1565 if(aTable->ExistPhysicsTable(filename)) {
1566 if(G4PhysicsTableHelper::RetrievePhysicsTable(aTable,filename,ascii,spline)) {
1567 isRetrieved = true;
1568 if(spline) {
1569 for(auto & v : *aTable) {
1570 if(nullptr != v) { v->FillSecondDerivatives(); }
1571 }
1572 }
1573 if (0 < verboseLevel) {
1574 G4cout << tname << " table for " << part->GetParticleName()
1575 << " is Retrieved from <" << filename << ">"
1576 << G4endl;
1577 }
1578 }
1579 }
1580 }
1581 if(mandatory && !isRetrieved) {
1582 if(0 < verboseLevel) {
1583 G4cout << tname << " table for " << part->GetParticleName()
1584 << " from file <"
1585 << filename << "> is not Retrieved"
1586 << G4endl;
1587 }
1588 return false;
1589 }
1590 return true;
1591}
static G4bool RetrievePhysicsTable(G4PhysicsTable *physTable, const G4String &fileName, G4bool ascii, G4bool spline)
G4bool ExistPhysicsTable(const G4String &fileName) const
const G4String & GetPhysicsTableFileName(const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
Definition: G4VProcess.cc:182

References G4PhysicsTable::ExistPhysicsTable(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetPhysicsTableFileName(), G4PhysicsTableHelper::RetrievePhysicsTable(), G4VEnergyLossProcess::spline, and G4VProcess::verboseLevel.

Referenced by G4VEnergyLossProcess::RetrievePhysicsTable().

◆ ScaledKinEnergyForLoss()

G4double G4VEnergyLossProcess::ScaledKinEnergyForLoss ( G4double  range)
inlineprivateinherited

Definition at line 695 of file G4VEnergyLossProcess.hh.

696{
697 //G4cout << "G4VEnergyLossProcess::GetEnergy: Idx= "
698 // << basedCoupleIndex << " R(mm)= " << r << " "
699 // << theInverseRangeTable << G4endl;
700 G4PhysicsVector* v = (*theInverseRangeTable)[basedCoupleIndex];
701 G4double rmin = v->Energy(0);
702 G4double e = 0.0;
703 if(r >= rmin) { e = v->Value(r, idxInverseRange); }
704 else if(r > 0.0) {
705 G4double x = r/rmin;
706 e = minKinEnergy*x*x;
707 }
708 return e;
709}
G4double Energy(const std::size_t index) const
G4double Value(const G4double energy, std::size_t &lastidx) const

References G4VEnergyLossProcess::basedCoupleIndex, G4PhysicsVector::Energy(), G4VEnergyLossProcess::idxInverseRange, G4VEnergyLossProcess::minKinEnergy, and G4PhysicsVector::Value().

Referenced by G4VEnergyLossProcess::AlongStepDoIt(), and G4VEnergyLossProcess::GetKineticEnergy().

◆ SecondaryParticle()

const G4ParticleDefinition * G4VEnergyLossProcess::SecondaryParticle ( ) const
inlineinherited

Definition at line 878 of file G4VEnergyLossProcess.hh.

879{
880 return secondaryParticle;
881}

References G4VEnergyLossProcess::secondaryParticle.

Referenced by G4LossTableManager::CopyTables().

◆ SecondaryRangeTable()

G4PhysicsTable * G4VEnergyLossProcess::SecondaryRangeTable ( ) const
inlineinherited

◆ SelectModel()

void G4VEnergyLossProcess::SelectModel ( G4double  kinEnergy)
inlineprotectedinherited

◆ SelectModelForMaterial()

G4VEmModel * G4VEnergyLossProcess::SelectModelForMaterial ( G4double  kinEnergy,
size_t &  idxCouple 
) const
inlineinherited

◆ SetBaseParticle()

void G4VEnergyLossProcess::SetBaseParticle ( const G4ParticleDefinition p)
inlineinherited

◆ SetCrossSectionBiasingFactor()

void G4VEnergyLossProcess::SetCrossSectionBiasingFactor ( G4double  f,
G4bool  flag = true 
)
inherited

Definition at line 1898 of file G4VEnergyLossProcess.cc.

1900{
1901 if(f > 0.0) {
1902 biasFactor = f;
1903 weightFlag = flag;
1904 if(1 < verboseLevel) {
1905 G4cout << "### SetCrossSectionBiasingFactor: for "
1906 << " process " << GetProcessName()
1907 << " biasFactor= " << f << " weightFlag= " << flag
1908 << G4endl;
1909 }
1910 }
1911}

References G4VEnergyLossProcess::biasFactor, G4cout, G4endl, G4VProcess::GetProcessName(), G4VProcess::verboseLevel, and G4VEnergyLossProcess::weightFlag.

Referenced by G4EmExtraParameters::DefineRegParamForLoss().

◆ SetCrossSectionType()

void G4VEnergyLossProcess::SetCrossSectionType ( G4CrossSectionType  val)
inlineinherited

Definition at line 900 of file G4VEnergyLossProcess.hh.

901{
902 fXSType = val;
903}

References G4VEnergyLossProcess::fXSType.

Referenced by G4eBremsstrahlung().

◆ SetCSDARangeTable()

void G4VEnergyLossProcess::SetCSDARangeTable ( G4PhysicsTable pRange)
inherited

◆ SetDEDXBinning()

void G4VEnergyLossProcess::SetDEDXBinning ( G4int  nbins)
inherited

Definition at line 1998 of file G4VEnergyLossProcess.cc.

1999{
2000 if(2 < n && n < 1000000000) {
2001 nBins = n;
2002 actBinning = true;
2003 } else {
2004 G4double e = (G4double)n;
2005 PrintWarning("SetDEDXBinning", e);
2006 }
2007}
void PrintWarning(const G4String &, G4double val) const

References G4VEnergyLossProcess::actBinning, CLHEP::detail::n, G4VEnergyLossProcess::nBins, and G4VEnergyLossProcess::PrintWarning().

Referenced by G4hhIonisation::InitialiseEnergyLossProcess(), G4mplIonisation::InitialiseEnergyLossProcess(), and G4hIonisation::InitialiseEnergyLossProcess().

◆ SetDEDXTable()

void G4VEnergyLossProcess::SetDEDXTable ( G4PhysicsTable p,
G4EmTableType  tType 
)
inherited

Definition at line 1689 of file G4VEnergyLossProcess.cc.

1690{
1691 if(fTotal == tType) {
1693
1694 } else if(fRestricted == tType) {
1695 /*
1696 G4cout<< "G4VEnergyLossProcess::SetDEDXTable "
1697 << particle->GetParticleName()
1698 << " oldTable " << theDEDXTable << " newTable " << p
1699 << " ion " << theIonisationTable
1700 << " IsMaster " << isMaster
1701 << " " << GetProcessName() << G4endl;
1702 G4cout << (*p) << G4endl;
1703 */
1704 theDEDXTable = p;
1705 } else if(fIsIonisation == tType) {
1706 /*
1707 G4cout<< "G4VEnergyLossProcess::SetIonisationTable "
1708 << particle->GetParticleName()
1709 << " oldTable " << theDEDXTable << " newTable " << p
1710 << " ion " << theIonisationTable
1711 << " IsMaster " << isMaster
1712 << " " << GetProcessName() << G4endl;
1713 */
1715 }
1716}

References fIsIonisation, fRestricted, fTotal, G4VEnergyLossProcess::theDEDXTable, G4VEnergyLossProcess::theDEDXunRestrictedTable, and G4VEnergyLossProcess::theIonisationTable.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable(), G4LossTableManager::BuildTables(), and G4LossTableManager::CopyTables().

◆ SetDynamicMassCharge()

void G4VEnergyLossProcess::SetDynamicMassCharge ( G4double  massratio,
G4double  charge2ratio 
)
inherited

◆ SetEmModel()

void G4VEnergyLossProcess::SetEmModel ( G4VEmModel ptr,
G4int  index = 0 
)
inherited

◆ SetFluctModel()

void G4VEnergyLossProcess::SetFluctModel ( G4VEmFluctuationModel p)
inlineinherited

◆ SetGPILSelection()

void G4VContinuousDiscreteProcess::SetGPILSelection ( G4GPILSelection  selection)
inlineprotectedinherited

◆ SetInverseRangeTable()

void G4VEnergyLossProcess::SetInverseRangeTable ( G4PhysicsTable p)
inherited

◆ SetIonisation()

void G4VEnergyLossProcess::SetIonisation ( G4bool  val)
inherited

◆ SetLambdaTable()

void G4VEnergyLossProcess::SetLambdaTable ( G4PhysicsTable p)
inherited

Definition at line 1768 of file G4VEnergyLossProcess.cc.

1769{
1770 if(1 < verboseLevel) {
1771 G4cout << "### Set Lambda table " << p
1772 << " for " << particle->GetParticleName()
1773 << " and process " << GetProcessName() << G4endl;
1774 //G4cout << *p << G4endl;
1775 }
1776 theLambdaTable = p;
1777 tablesAreBuilt = true;
1778
1782
1783 if(isMaster && nullptr == baseParticle &&
1784 nullptr != theLambdaTable && fEmTwoPeaks == fXSType) {
1785
1786 size_t n = theLambdaTable->length();
1787
1788 G4double e, ss, xs, ee, e1peak, xs1peak, e1deep, e2peak, e2deep, xs2peak;
1789
1790 // first loop on existing vectors
1791 for (size_t i=0; i<n; ++i) {
1792 const G4PhysicsVector* pv = (*theLambdaTable)[i];
1793 ee = xs = xs1peak = xs2peak = 0.0;
1794 e1peak = e1deep = e2peak = e2deep = DBL_MAX;
1795 if(nullptr != pv) {
1796 size_t nb = pv->GetVectorLength();
1797 for (size_t j=0; j<nb; ++j) {
1798 e = pv->Energy(j);
1799 ss = (*pv)(j);
1800 // find out 1st peak
1801 if(e1peak == DBL_MAX) {
1802 if(ss >= xs) {
1803 xs = ss;
1804 ee = e;
1805 continue;
1806 } else {
1807 e1peak = ee;
1808 xs1peak = xs;
1809 }
1810 }
1811 // find out the deep
1812 if(e1deep == DBL_MAX) {
1813 if(ss <= xs) {
1814 xs = ss;
1815 ee = e;
1816 continue;
1817 } else {
1818 e1deep = ee;
1819 }
1820 }
1821 // find out 2nd peak
1822 if(e2peak == DBL_MAX) {
1823 if(ss >= xs) {
1824 xs = ss;
1825 ee = e;
1826 continue;
1827 } else {
1828 e2peak = ee;
1829 xs2peak = xs;
1830 }
1831 }
1832 if(e2deep == DBL_MAX) {
1833 if(ss <= xs) {
1834 xs = ss;
1835 ee = e;
1836 continue;
1837 } else {
1838 e2deep = ee;
1839 break;
1840 }
1841 }
1842 }
1843 }
1844 G4TwoPeaksXS* x = (*fXSpeaks)[i];
1845 if(nullptr == x) {
1846 x = new G4TwoPeaksXS();
1847 (*fXSpeaks)[i] = x;
1848 }
1849 x->e1peak = e1peak;
1850 x->e1deep = e1deep;
1851 x->e2peak = e2peak;
1852 x->e2deep = e2deep;
1853
1854 if(1 < verboseLevel) {
1855 G4cout << "For " << particle->GetParticleName()
1856 << " index= " << i << " data:\n" << " E1peak=" << e1peak
1857 << " xs1= " << xs1peak << " E1deep=" << e1deep
1858 << " E2peak=" << e2peak << " xs2=" << xs2peak
1859 << " E2deep=" << e2deep << G4endl;
1860 }
1861 }
1862 // second loop using base materials
1863 for (size_t i=0; i<n; ++i) {
1864 const G4PhysicsVector* pv = (*theLambdaTable)[i];
1865 if (nullptr == pv) {
1866 G4int j = (*theDensityIdx)[i];
1867 G4TwoPeaksXS* x = (*fXSpeaks)[i];
1868 G4TwoPeaksXS* y = (*fXSpeaks)[j];
1869 if(nullptr == x) {
1870 x = new G4TwoPeaksXS();
1871 (*fXSpeaks)[i] = x;
1872 }
1873 x->e1peak = y->e1peak;
1874 x->e1deep = y->e1deep;
1875 x->e2peak = y->e2peak;
1876 x->e2deep = y->e2deep;
1877 }
1878 }
1879 }
1880}
const std::vector< G4double > * GetDensityFactors() const
const std::vector< G4int > * GetCoupleIndexes() const
std::size_t length() const
std::size_t GetVectorLength() const
const std::vector< G4int > * theDensityIdx

References G4VEnergyLossProcess::baseParticle, DBL_MAX, G4TwoPeaksXS::e1deep, G4TwoPeaksXS::e1peak, G4TwoPeaksXS::e2deep, G4TwoPeaksXS::e2peak, G4PhysicsVector::Energy(), fEmTwoPeaks, G4VEnergyLossProcess::fXSType, G4cout, G4endl, G4LossTableBuilder::GetCoupleIndexes(), G4LossTableBuilder::GetDensityFactors(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4LossTableManager::GetTableBuilder(), G4PhysicsVector::GetVectorLength(), G4VEnergyLossProcess::isMaster, G4PhysicsTable::length(), G4VEnergyLossProcess::lManager, CLHEP::detail::n, G4VEnergyLossProcess::particle, G4VEnergyLossProcess::tablesAreBuilt, G4VEnergyLossProcess::theDensityFactor, G4VEnergyLossProcess::theDensityIdx, G4VEnergyLossProcess::theLambdaTable, and G4VProcess::verboseLevel.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable(), G4LossTableManager::BuildTables(), and G4LossTableManager::CopyTables().

◆ SetLinearLossLimit()

void G4VEnergyLossProcess::SetLinearLossLimit ( G4double  val)
inherited

Definition at line 1967 of file G4VEnergyLossProcess.cc.

1968{
1969 if(0.0 < val && val < 1.0) {
1970 linLossLimit = val;
1971 actLinLossLimit = true;
1972 } else { PrintWarning("SetLinearLossLimit", val); }
1973}

References G4VEnergyLossProcess::actLinLossLimit, G4VEnergyLossProcess::linLossLimit, and G4VEnergyLossProcess::PrintWarning().

Referenced by G4ionIonisation::G4ionIonisation().

◆ SetLossFluctuations()

void G4VEnergyLossProcess::SetLossFluctuations ( G4bool  val)
inlineinherited

◆ SetLowestEnergyLimit()

void G4VEnergyLossProcess::SetLowestEnergyLimit ( G4double  val)
inherited

Definition at line 1990 of file G4VEnergyLossProcess.cc.

1991{
1992 if(1.e-18 < val && val < 1.e+50) { lowestKinEnergy = val; }
1993 else { PrintWarning("SetLowestEnergyLimit", val); }
1994}

References G4VEnergyLossProcess::lowestKinEnergy, and G4VEnergyLossProcess::PrintWarning().

◆ SetMasterProcess()

void G4VProcess::SetMasterProcess ( G4VProcess masterP)
virtualinherited

◆ SetMaxKinEnergy()

void G4VEnergyLossProcess::SetMaxKinEnergy ( G4double  e)
inherited

◆ SetMinKinEnergy()

void G4VEnergyLossProcess::SetMinKinEnergy ( G4double  e)
inherited

◆ SetParticle()

void G4VEnergyLossProcess::SetParticle ( const G4ParticleDefinition p)
inlineprotectedinherited

Definition at line 840 of file G4VEnergyLossProcess.hh.

841{
842 particle = p;
843}

References G4VEnergyLossProcess::particle.

◆ SetPILfactor()

void G4VProcess::SetPILfactor ( G4double  value)
inlineinherited

Definition at line 449 of file G4VProcess.hh.

450{
451 if (value>0.) { thePILfactor = value; }
452}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

◆ SetProcessManager()

void G4VProcess::SetProcessManager ( const G4ProcessManager procMan)
inlinevirtualinherited

◆ SetProcessSubType()

void G4VProcess::SetProcessSubType ( G4int  value)
inlineinherited

Definition at line 406 of file G4VProcess.hh.

407{
408 theProcessSubType = value;
409}

References G4VProcess::theProcessSubType.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4AnnihiToMuPair::G4AnnihiToMuPair(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4CoupledTransportation::G4CoupledTransportation(), G4Decay::G4Decay(), G4DecayWithSpin::G4DecayWithSpin(), G4DNAAttachment::G4DNAAttachment(), G4DNABrownianTransportation::G4DNABrownianTransportation(), G4DNAChargeDecrease::G4DNAChargeDecrease(), G4DNAChargeIncrease::G4DNAChargeIncrease(), G4DNAElastic::G4DNAElastic(), G4DNAElectronSolvation::G4DNAElectronSolvation(), G4DNAExcitation::G4DNAExcitation(), G4DNAIonisation::G4DNAIonisation(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4DNAVibExcitation::G4DNAVibExcitation(), G4eBremsstrahlung(), G4eeToHadrons::G4eeToHadrons(), G4eIonisation::G4eIonisation(), G4ePairProduction::G4ePairProduction(), G4eplusAnnihilation::G4eplusAnnihilation(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GammaConversion::G4GammaConversion(), G4GammaConversionToMuons::G4GammaConversionToMuons(), G4GammaGeneralProcess::G4GammaGeneralProcess(), G4HadronicProcess::G4HadronicProcess(), G4hhIonisation::G4hhIonisation(), G4hIonisation::G4hIonisation(), G4ionIonisation::G4ionIonisation(), G4ITTransportation::G4ITTransportation(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4MicroElecElastic::G4MicroElecElastic(), G4MicroElecInelastic::G4MicroElecInelastic(), G4MicroElecLOPhononScattering::G4MicroElecLOPhononScattering(), G4MicroElecSurface::G4MicroElecSurface(), G4mplIonisation::G4mplIonisation(), G4MuBremsstrahlung::G4MuBremsstrahlung(), G4MuIonisation::G4MuIonisation(), G4MuonMinusAtomicCapture::G4MuonMinusAtomicCapture(), G4MuPairProduction::G4MuPairProduction(), G4NeutronKiller::G4NeutronKiller(), G4NuclearStopping::G4NuclearStopping(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4PhotoElectricEffect::G4PhotoElectricEffect(), G4PionDecayMakeSpin::G4PionDecayMakeSpin(), G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), G4PolarizedIonisation::G4PolarizedIonisation(), G4PolarizedPhotoElectric::G4PolarizedPhotoElectric(), G4RadioactiveDecay::G4RadioactiveDecay(), G4RayleighScattering::G4RayleighScattering(), G4Scintillation::G4Scintillation(), G4StepLimiter::G4StepLimiter(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4TransitionRadiation::G4TransitionRadiation(), G4Transportation::G4Transportation(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UnknownDecay::G4UnknownDecay(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VMultipleScattering::G4VMultipleScattering(), G4VTransitionRadiation::G4VTransitionRadiation(), G4VXTRenergyLoss::G4VXTRenergyLoss(), and G4Decay::SetExtDecayer().

◆ SetProcessType()

void G4VProcess::SetProcessType ( G4ProcessType  aType)
inlineinherited

Definition at line 394 of file G4VProcess.hh.

395{
396 theProcessType = aType;
397}

References G4VProcess::theProcessType.

Referenced by G4MaxTimeCuts::G4MaxTimeCuts(), and G4MinEkineCuts::G4MinEkineCuts().

◆ SetRangeTableForLoss()

void G4VEnergyLossProcess::SetRangeTableForLoss ( G4PhysicsTable p)
inherited

◆ SetSecondaryParticle()

void G4VEnergyLossProcess::SetSecondaryParticle ( const G4ParticleDefinition p)
inlineprotectedinherited

◆ SetSecondaryRangeTable()

void G4VEnergyLossProcess::SetSecondaryRangeTable ( G4PhysicsTable p)
inherited

◆ SetSpline()

void G4VEnergyLossProcess::SetSpline ( G4bool  val)
inlineinherited

◆ SetStepFunction()

void G4VEnergyLossProcess::SetStepFunction ( G4double  v1,
G4double  v2 
)
inherited

◆ SetTwoPeaksXS()

void G4VEnergyLossProcess::SetTwoPeaksXS ( std::vector< G4TwoPeaksXS * > *  p)
inherited

Definition at line 1884 of file G4VEnergyLossProcess.cc.

1885{
1886 fXSpeaks = ptr;
1887}

References G4VEnergyLossProcess::fXSpeaks.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable().

◆ SetVerboseLevel()

void G4VProcess::SetVerboseLevel ( G4int  value)
inlineinherited

◆ StartTracking()

void G4VEnergyLossProcess::StartTracking ( G4Track track)
overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 829 of file G4VEnergyLossProcess.cc.

830{
831 /*
832 G4cout << "G4VEnergyLossProcess::StartTracking: "
833 << track->GetDefinition()->GetParticleName()
834 << " e(MeV)= " << track->GetKineticEnergy();
835 if(particle) G4cout << " " << particle->GetParticleName();
836 if(baseParticle) G4cout << " basePart: " << baseParticle->GetParticleName();
837 G4cout << " " << GetProcessName();
838 if(isIon) G4cout << " isIon: Q=" << track->GetDefinition()->GetPDGCharge()
839 << " Qdyn=" << track->GetDynamicParticle()->GetCharge();
840 G4cout << G4endl;
841 */
842 // reset parameters for the new track
845 currentCouple = nullptr;
846
847 // reset ion
848 if(isIon) {
849 const G4double newmass = track->GetDefinition()->GetPDGMass();
850 if(nullptr != baseParticle) {
851 massRatio = baseParticle->GetPDGMass()/newmass;
853 } else if(nullptr != theGenericIon) {
856 } else {
857 massRatio = 1.0;
858 logMassRatio = 0.0;
859 }
860 }
861 // forced biasing only for primary particles
862 if(biasManager) {
863 if(0 == track->GetParentID()) {
864 biasFlag = true;
866 }
867 }
868}
static constexpr double proton_mass_c2

References G4VEnergyLossProcess::baseParticle, G4VEnergyLossProcess::biasFlag, G4VEnergyLossProcess::biasManager, G4VEnergyLossProcess::currentCouple, DBL_MAX, G4Log(), G4Track::GetDefinition(), G4Track::GetParentID(), G4ParticleDefinition::GetPDGMass(), G4VEnergyLossProcess::isIon, G4VEnergyLossProcess::logMassRatio, G4VEnergyLossProcess::massRatio, G4VEnergyLossProcess::mfpKinEnergy, CLHEP::proton_mass_c2, G4EmBiasingManager::ResetForcedInteraction(), G4VEnergyLossProcess::theGenericIon, and G4VProcess::theNumberOfInteractionLengthLeft.

◆ StorePhysicsTable()

G4bool G4VEnergyLossProcess::StorePhysicsTable ( const G4ParticleDefinition part,
const G4String directory,
G4bool  ascii = false 
)
overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 1445 of file G4VEnergyLossProcess.cc.

1448{
1449 G4bool res = true;
1450 //G4cout << "G4VEnergyLossProcess::StorePhysicsTable: " << part->GetParticleName()
1451 // << " " << directory << " " << ascii << G4endl;
1452 if (!isMaster || baseParticle || part != particle ) return res;
1453
1454 if(!StoreTable(part,theDEDXTable,ascii,directory,"DEDX"))
1455 {res = false;}
1456
1457 if(!StoreTable(part,theDEDXunRestrictedTable,ascii,directory,"DEDXnr"))
1458 {res = false;}
1459
1460 if(!StoreTable(part,theIonisationTable,ascii,directory,"Ionisation"))
1461 {res = false;}
1462
1463 if(isIonisation &&
1464 !StoreTable(part,theCSDARangeTable,ascii,directory,"CSDARange"))
1465 {res = false;}
1466
1467 if(isIonisation &&
1468 !StoreTable(part,theRangeTableForLoss,ascii,directory,"Range"))
1469 {res = false;}
1470
1471 if(isIonisation &&
1472 !StoreTable(part,theInverseRangeTable,ascii,directory,"InverseRange"))
1473 {res = false;}
1474
1475 if(!StoreTable(part,theLambdaTable,ascii,directory,"Lambda"))
1476 {res = false;}
1477
1478 return res;
1479}
G4bool StoreTable(const G4ParticleDefinition *p, G4PhysicsTable *, G4bool ascii, const G4String &directory, const G4String &tname)

References G4VEnergyLossProcess::baseParticle, G4VEnergyLossProcess::isIonisation, G4VEnergyLossProcess::isMaster, G4VEnergyLossProcess::particle, G4VEnergyLossProcess::StoreTable(), G4VEnergyLossProcess::theCSDARangeTable, G4VEnergyLossProcess::theDEDXTable, G4VEnergyLossProcess::theDEDXunRestrictedTable, G4VEnergyLossProcess::theInverseRangeTable, G4VEnergyLossProcess::theIonisationTable, G4VEnergyLossProcess::theLambdaTable, and G4VEnergyLossProcess::theRangeTableForLoss.

◆ StoreTable()

G4bool G4VEnergyLossProcess::StoreTable ( const G4ParticleDefinition p,
G4PhysicsTable aTable,
G4bool  ascii,
const G4String directory,
const G4String tname 
)
privateinherited

Definition at line 1534 of file G4VEnergyLossProcess.cc.

1538{
1539 G4bool res = true;
1540 if (nullptr != aTable) {
1541 const G4String& name = GetPhysicsTableFileName(part, directory, tname, ascii);
1542 if ( aTable->StorePhysicsTable(name,ascii) ) {
1543 if (0 < verboseLevel) G4cout << "Stored: " << name << G4endl;
1544 } else {
1545 res = false;
1546 G4cout << "Fail to store: " << name << G4endl;
1547 }
1548 }
1549 return res;
1550}
G4bool StorePhysicsTable(const G4String &filename, G4bool ascii=false)

References G4cout, G4endl, G4VProcess::GetPhysicsTableFileName(), G4InuclParticleNames::name(), G4PhysicsTable::StorePhysicsTable(), and G4VProcess::verboseLevel.

Referenced by G4VEnergyLossProcess::StorePhysicsTable().

◆ StreamInfo()

void G4VEnergyLossProcess::StreamInfo ( std::ostream &  out,
const G4ParticleDefinition part,
G4bool  rst = false 
) const
privateinherited

Definition at line 730 of file G4VEnergyLossProcess.cc.

732{
733 G4String indent = (rst ? " " : "");
734 out << std::setprecision(6);
735 out << G4endl << indent << GetProcessName() << ": ";
736 if (!rst) out << " for " << part.GetParticleName();
737 out << " XStype:" << fXSType
738 << " SubType=" << GetProcessSubType() << G4endl
739 << " dE/dx and range tables from "
740 << G4BestUnit(minKinEnergy,"Energy")
741 << " to " << G4BestUnit(maxKinEnergy,"Energy")
742 << " in " << nBins << " bins" << G4endl
743 << " Lambda tables from threshold to "
744 << G4BestUnit(maxKinEnergy,"Energy")
746 << " bins/decade, spline: " << spline
747 << G4endl;
748 if(nullptr != theRangeTableForLoss && isIonisation) {
749 out << " StepFunction=(" << dRoverRange << ", "
750 << finalRange/mm << " mm)"
751 << ", integ: " << fXSType
752 << ", fluct: " << lossFluctuationFlag
753 << ", linLossLim= " << linLossLimit
754 << G4endl;
755 }
758 if(nullptr != theCSDARangeTable && isIonisation) {
759 out << " CSDA range table up"
760 << " to " << G4BestUnit(maxKinEnergyCSDA,"Energy")
761 << " in " << nBinsCSDA << " bins" << G4endl;
762 }
763 if(nSCoffRegions>0 && isIonisation) {
764 out << " Subcutoff sampling in " << nSCoffRegions
765 << " regions" << G4endl;
766 }
767 if(2 < verboseLevel) {
768 out << " DEDXTable address= " << theDEDXTable << G4endl;
769 if(nullptr != theDEDXTable && isIonisation)
770 out << (*theDEDXTable) << G4endl;
771 out << "non restricted DEDXTable address= "
773 if(nullptr != theDEDXunRestrictedTable && isIonisation) {
774 out << (*theDEDXunRestrictedTable) << G4endl;
775 }
776 out << " CSDARangeTable address= " << theCSDARangeTable << G4endl;
777 if(nullptr != theCSDARangeTable && isIonisation) {
778 out << (*theCSDARangeTable) << G4endl;
779 }
780 out << " RangeTableForLoss address= " << theRangeTableForLoss
781 << G4endl;
782 if(nullptr != theRangeTableForLoss && isIonisation) {
783 out << (*theRangeTableForLoss) << G4endl;
784 }
785 out << " InverseRangeTable address= " << theInverseRangeTable
786 << G4endl;
787 if(nullptr != theInverseRangeTable && isIonisation) {
788 out << (*theInverseRangeTable) << G4endl;
789 }
790 out << " LambdaTable address= " << theLambdaTable << G4endl;
791 if(nullptr != theLambdaTable) {
792 out << (*theLambdaTable) << G4endl;
793 }
794 }
795}
#define G4BestUnit(a, b)
void DumpModelList(std::ostream &out, G4int verb)
virtual void StreamProcessInfo(std::ostream &) const

References G4VEnergyLossProcess::dRoverRange, G4EmModelManager::DumpModelList(), G4VEnergyLossProcess::finalRange, G4VEnergyLossProcess::fXSType, G4BestUnit, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4VProcess::GetProcessSubType(), G4VEnergyLossProcess::isIonisation, G4VEnergyLossProcess::linLossLimit, G4VEnergyLossProcess::lossFluctuationFlag, G4VEnergyLossProcess::maxKinEnergy, G4VEnergyLossProcess::maxKinEnergyCSDA, G4VEnergyLossProcess::minKinEnergy, mm, G4VEnergyLossProcess::modelManager, G4VEnergyLossProcess::nBins, G4VEnergyLossProcess::nBinsCSDA, G4VEnergyLossProcess::nSCoffRegions, G4EmParameters::NumberOfBinsPerDecade(), G4VEnergyLossProcess::spline, G4VEnergyLossProcess::StreamProcessInfo(), G4VEnergyLossProcess::theCSDARangeTable, G4VEnergyLossProcess::theDEDXTable, G4VEnergyLossProcess::theDEDXunRestrictedTable, G4VEnergyLossProcess::theInverseRangeTable, G4VEnergyLossProcess::theLambdaTable, G4VEnergyLossProcess::theParameters, G4VEnergyLossProcess::theRangeTableForLoss, and G4VProcess::verboseLevel.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable(), and G4VEnergyLossProcess::ProcessDescription().

◆ StreamProcessInfo()

void G4eBremsstrahlung::StreamProcessInfo ( std::ostream &  outFile) const
overrideprotectedvirtual

Reimplemented from G4VEnergyLossProcess.

Definition at line 117 of file G4eBremsstrahlung.cc.

118{
119 if(nullptr != EmModel(0)) {
121 G4double eth = param->BremsstrahlungTh();
122 out << " LPM flag: " << param->LPM() << " for E > "
123 << EmModel(0)->HighEnergyLimit()/GeV << " GeV";
124 if(eth < DBL_MAX) {
125 out << ", VertexHighEnergyTh(GeV)= " << eth/GeV;
126 }
127 out << G4endl;
128 }
129}

References G4EmParameters::BremsstrahlungTh(), DBL_MAX, G4VEnergyLossProcess::EmModel(), G4endl, GeV, G4VEmModel::HighEnergyLimit(), G4EmParameters::Instance(), and G4EmParameters::LPM().

◆ SubtractNumberOfInteractionLengthLeft()

void G4VProcess::SubtractNumberOfInteractionLengthLeft ( G4double  prevStepSize)
inlineprotectedinherited

Definition at line 524 of file G4VProcess.hh.

525{
527 {
530 {
532 }
533 }
534 else
535 {
536#ifdef G4VERBOSE
537 if (verboseLevel>0)
538 {
539 G4cerr << "G4VProcess::SubtractNumberOfInteractionLengthLeft()";
540 G4cerr << " [" << theProcessName << "]" <<G4endl;
541 G4cerr << " currentInteractionLength = "
542 << currentInteractionLength << " [mm]";
543 G4cerr << " previousStepSize = " << prevStepSize << " [mm]";
544 G4cerr << G4endl;
545 }
546#endif
547 G4String msg = "Negative currentInteractionLength for ";
548 msg += theProcessName;
549 G4Exception("G4VProcess::SubtractNumberOfInteractionLengthLeft()",
550 "ProcMan201", EventMustBeAborted, msg);
551 }
552}
@ EventMustBeAborted
G4GLOB_DLL std::ostream G4cerr
static constexpr double perMillion

References G4VProcess::currentInteractionLength, EventMustBeAborted, G4cerr, G4endl, G4Exception(), CLHEP::perMillion, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), and G4Decay::PostStepGetPhysicalInteractionLength().

◆ TablesAreBuilt()

G4bool G4VEnergyLossProcess::TablesAreBuilt ( ) const
inlineinherited

Definition at line 949 of file G4VEnergyLossProcess.hh.

950{
951 return tablesAreBuilt;
952}

References G4VEnergyLossProcess::tablesAreBuilt.

◆ TwoPeaksXS()

std::vector< G4TwoPeaksXS * > * G4VEnergyLossProcess::TwoPeaksXS ( ) const
inlineinherited

Definition at line 1019 of file G4VEnergyLossProcess.hh.

1020{
1021 return fXSpeaks;
1022}

References G4VEnergyLossProcess::fXSpeaks.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable().

◆ UseBaseMaterial()

G4bool G4VEnergyLossProcess::UseBaseMaterial ( ) const
inlineinherited

Definition at line 1012 of file G4VEnergyLossProcess.hh.

1013{
1014 return baseMat;
1015}

References G4VEnergyLossProcess::baseMat.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable().

Field Documentation

◆ actBinning

G4bool G4VEnergyLossProcess::actBinning = false
privateinherited

◆ actLinLossLimit

G4bool G4VEnergyLossProcess::actLinLossLimit = false
privateinherited

◆ actLossFluc

G4bool G4VEnergyLossProcess::actLossFluc = false
privateinherited

◆ actMaxKinEnergy

G4bool G4VEnergyLossProcess::actMaxKinEnergy = false
privateinherited

◆ actMinKinEnergy

G4bool G4VEnergyLossProcess::actMinKinEnergy = false
privateinherited

◆ aGPILSelection

G4GPILSelection G4VEnergyLossProcess::aGPILSelection
privateinherited

◆ aParticleChange

G4ParticleChange G4VProcess::aParticleChange
protectedinherited

◆ aProcessManager

const G4ProcessManager* G4VProcess::aProcessManager = nullptr
protectedinherited

Definition at line 319 of file G4VProcess.hh.

Referenced by G4VProcess::GetProcessManager(), and G4VProcess::SetProcessManager().

◆ atomDeexcitation

G4VAtomDeexcitation* G4VEnergyLossProcess::atomDeexcitation = nullptr
privateinherited

◆ basedCoupleIndex

size_t G4VEnergyLossProcess::basedCoupleIndex = 0
privateinherited

◆ baseMat

G4bool G4VEnergyLossProcess::baseMat = false
privateinherited

◆ baseParticle

const G4ParticleDefinition* G4VEnergyLossProcess::baseParticle = nullptr
privateinherited

◆ biasFactor

G4double G4VEnergyLossProcess::biasFactor = 1.0
privateinherited

◆ biasFlag

G4bool G4VEnergyLossProcess::biasFlag = false
privateinherited

◆ biasID

G4int G4VEnergyLossProcess::biasID = _DeltaEBelowCut
privateinherited

◆ biasManager

G4EmBiasingManager* G4VEnergyLossProcess::biasManager = nullptr
privateinherited

◆ chargeSqRatio

G4double G4VEnergyLossProcess::chargeSqRatio = 1.0
privateinherited

◆ coupleIdxLambda

size_t G4VEnergyLossProcess::coupleIdxLambda = 0
privateinherited

◆ coupleIdxRange

size_t G4VEnergyLossProcess::coupleIdxRange = 0
privateinherited

◆ currentCouple

const G4MaterialCutsCouple* G4VEnergyLossProcess::currentCouple = nullptr
protectedinherited

◆ currentCoupleIndex

size_t G4VEnergyLossProcess::currentCoupleIndex = 0
protectedinherited

◆ currentInteractionLength

G4double G4VProcess::currentInteractionLength = -1.0
protectedinherited

◆ currentMaterial

const G4Material* G4VEnergyLossProcess::currentMaterial = nullptr
protectedinherited

◆ currentModel

G4VEmModel* G4VEnergyLossProcess::currentModel = nullptr
privateinherited

◆ dRoverRange

G4double G4VEnergyLossProcess::dRoverRange = 0.2
privateinherited

◆ emModels

std::vector<G4VEmModel*>* G4VEnergyLossProcess::emModels = nullptr
privateinherited

◆ enableAlongStepDoIt

G4bool G4VProcess::enableAlongStepDoIt = true
protectedinherited

◆ enableAtRestDoIt

G4bool G4VProcess::enableAtRestDoIt = true
protectedinherited

◆ enablePostStepDoIt

G4bool G4VProcess::enablePostStepDoIt = true
protectedinherited

◆ fFactor

G4double G4VEnergyLossProcess::fFactor = 1.0
privateinherited

◆ finalRange

G4double G4VEnergyLossProcess::finalRange
privateinherited

◆ fLambda

G4double G4VEnergyLossProcess::fLambda = 0.0
privateinherited

◆ fLambdaEnergy

G4double G4VEnergyLossProcess::fLambdaEnergy = 0.0
privateinherited

◆ fluctModel

G4VEmFluctuationModel* G4VEnergyLossProcess::fluctModel = nullptr
privateinherited

◆ fParticleChange

G4ParticleChangeForLoss G4VEnergyLossProcess::fParticleChange
protectedinherited

◆ fProcessTable

G4ProcessTable* G4VProcess::fProcessTable = nullptr
privateinherited

Definition at line 374 of file G4VProcess.hh.

Referenced by G4VProcess::G4VProcess(), and G4VProcess::~G4VProcess().

◆ fRange

G4double G4VEnergyLossProcess::fRange = 0.0
privateinherited

◆ fRangeEnergy

G4double G4VEnergyLossProcess::fRangeEnergy = 0.0
privateinherited

◆ fXSpeaks

std::vector<G4TwoPeaksXS*>* G4VEnergyLossProcess::fXSpeaks = nullptr
privateinherited

◆ fXSType

G4CrossSectionType G4VEnergyLossProcess::fXSType = fEmIncreasing
privateinherited

◆ idxCSDA

size_t G4VEnergyLossProcess::idxCSDA = 0
privateinherited

◆ idxDEDX

size_t G4VEnergyLossProcess::idxDEDX = 0
privateinherited

◆ idxDEDXunRestricted

size_t G4VEnergyLossProcess::idxDEDXunRestricted = 0
privateinherited

Definition at line 522 of file G4VEnergyLossProcess.hh.

◆ idxInverseRange

size_t G4VEnergyLossProcess::idxInverseRange = 0
privateinherited

◆ idxIonisation

size_t G4VEnergyLossProcess::idxIonisation = 0
privateinherited

◆ idxLambda

size_t G4VEnergyLossProcess::idxLambda = 0
privateinherited

◆ idxRange

size_t G4VEnergyLossProcess::idxRange = 0
privateinherited

◆ idxSecRange

size_t G4VEnergyLossProcess::idxSecRange = 0
privateinherited

Definition at line 526 of file G4VEnergyLossProcess.hh.

◆ isInitialised

G4bool G4eBremsstrahlung::isInitialised = false
private

Definition at line 109 of file G4eBremsstrahlung.hh.

Referenced by InitialiseEnergyLossProcess().

◆ isIon

G4bool G4VEnergyLossProcess::isIon = false
privateinherited

◆ isIonisation

G4bool G4VEnergyLossProcess::isIonisation = true
privateinherited

◆ isMaster

G4bool G4VEnergyLossProcess::isMaster = true
privateinherited

◆ lambdaFactor

G4double G4VEnergyLossProcess::lambdaFactor = 1.0
privateinherited

◆ linLossLimit

G4double G4VEnergyLossProcess::linLossLimit = 0.01
privateinherited

◆ lManager

G4LossTableManager* G4VEnergyLossProcess::lManager
privateinherited

◆ logLambdafactor

G4double G4VEnergyLossProcess::logLambdafactor = 0.0
privateinherited

Definition at line 483 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::PreparePhysicsTable().

◆ logMassRatio

G4double G4VEnergyLossProcess::logMassRatio = 0.0
privateinherited

◆ lossFluctuationFlag

G4bool G4VEnergyLossProcess::lossFluctuationFlag = true
privateinherited

◆ lowestKinEnergy

G4double G4VEnergyLossProcess::lowestKinEnergy
privateinherited

◆ mainSecondaries

G4int G4VEnergyLossProcess::mainSecondaries = 1
privateinherited

◆ massRatio

G4double G4VEnergyLossProcess::massRatio = 1.0
privateinherited

◆ masterProcessShadow

G4VProcess* G4VProcess::masterProcessShadow = nullptr
privateinherited

Definition at line 370 of file G4VProcess.hh.

Referenced by G4VProcess::GetMasterProcess(), and G4VProcess::SetMasterProcess().

◆ maxKinEnergy

G4double G4VEnergyLossProcess::maxKinEnergy
privateinherited

◆ maxKinEnergyCSDA

G4double G4VEnergyLossProcess::maxKinEnergyCSDA
privateinherited

◆ mfpKinEnergy

G4double G4VEnergyLossProcess::mfpKinEnergy = 0.0
protectedinherited

◆ minKinEnergy

G4double G4VEnergyLossProcess::minKinEnergy
privateinherited

◆ modelManager

G4EmModelManager* G4VEnergyLossProcess::modelManager
privateinherited

◆ nBins

G4int G4VEnergyLossProcess::nBins
privateinherited

◆ nBinsCSDA

G4int G4VEnergyLossProcess::nBinsCSDA
privateinherited

◆ nSCoffRegions

G4int G4VEnergyLossProcess::nSCoffRegions = 0
privateinherited

◆ numberOfModels

G4int G4VEnergyLossProcess::numberOfModels = 0
privateinherited

◆ particle

const G4ParticleDefinition* G4VEnergyLossProcess::particle = nullptr
privateinherited

◆ pParticleChange

G4VParticleChange* G4VProcess::pParticleChange = nullptr
protectedinherited

Definition at line 321 of file G4VProcess.hh.

Referenced by G4VMultipleScattering::AddEmModel(), G4VEmProcess::AddEmModel(), G4VEnergyLossProcess::AddEmModel(), G4ImportanceProcess::AlongStepDoIt(), G4WeightCutOffProcess::AlongStepDoIt(), G4WeightWindowProcess::AlongStepDoIt(), G4VContinuousDiscreteProcess::AlongStepDoIt(), G4VContinuousProcess::AlongStepDoIt(), G4VRestContinuousDiscreteProcess::AlongStepDoIt(), G4VRestContinuousProcess::AlongStepDoIt(), G4ParallelWorldProcess::AlongStepDoIt(), G4ParallelWorldScoringProcess::AlongStepDoIt(), G4VITRestProcess::AtRestDoIt(), G4VRestContinuousDiscreteProcess::AtRestDoIt(), G4VRestContinuousProcess::AtRestDoIt(), G4VRestDiscreteProcess::AtRestDoIt(), G4VRestProcess::AtRestDoIt(), G4ParallelWorldProcess::AtRestDoIt(), G4ParallelWorldScoringProcess::AtRestDoIt(), G4ScoreSplittingProcess::AtRestDoIt(), G4VITRestDiscreteProcess::AtRestDoIt(), G4eplusAnnihilation::AtRestDoIt(), G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4VEnergyLossProcess::FillSecondariesAlongStep(), G4Decay::G4Decay(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ImportanceProcess::G4ImportanceProcess(), G4ITTransportation::G4ITTransportation(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4RadioactiveDecay::G4RadioactiveDecay(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4Transportation::G4Transportation(), G4UnknownDecay::G4UnknownDecay(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), G4VProcess::G4VProcess(), G4VXTRenergyLoss::G4VXTRenergyLoss(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4VITDiscreteProcess::PostStepDoIt(), G4VContinuousDiscreteProcess::PostStepDoIt(), G4VDiscreteProcess::PostStepDoIt(), G4VRestContinuousDiscreteProcess::PostStepDoIt(), G4VRestDiscreteProcess::PostStepDoIt(), G4ParallelWorldProcess::PostStepDoIt(), G4ParallelWorldScoringProcess::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4NeutronKiller::PostStepDoIt(), G4VITRestDiscreteProcess::PostStepDoIt(), G4LowECapture::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), and G4VTransitionRadiation::PostStepDoIt().

◆ preStepKinEnergy

G4double G4VEnergyLossProcess::preStepKinEnergy = 0.0
protectedinherited

◆ preStepLambda

G4double G4VEnergyLossProcess::preStepLambda = 0.0
protectedinherited

◆ preStepLogKinEnergy

G4double G4VEnergyLossProcess::preStepLogKinEnergy = LOG_EKIN_MIN
protectedinherited

◆ preStepLogScaledEnergy

G4double G4VEnergyLossProcess::preStepLogScaledEnergy = LOG_EKIN_MIN
protectedinherited

◆ preStepScaledEnergy

G4double G4VEnergyLossProcess::preStepScaledEnergy = 0.0
protectedinherited

◆ reduceFactor

G4double G4VEnergyLossProcess::reduceFactor = 1.0
privateinherited

◆ rndmStepFlag

G4bool G4VEnergyLossProcess::rndmStepFlag = false
privateinherited

◆ safetyHelper

G4SafetyHelper* G4VEnergyLossProcess::safetyHelper
privateinherited

◆ scoffRegions

std::vector<const G4Region*>* G4VEnergyLossProcess::scoffRegions = nullptr
privateinherited

◆ scTracks

std::vector<G4Track*> G4VEnergyLossProcess::scTracks
privateinherited

◆ secID

G4int G4VEnergyLossProcess::secID = _DeltaElectron
privateinherited

◆ secondaryParticle

const G4ParticleDefinition* G4VEnergyLossProcess::secondaryParticle = nullptr
privateinherited

◆ secParticles

std::vector<G4DynamicParticle*> G4VEnergyLossProcess::secParticles
privateinherited

◆ spline

G4bool G4VEnergyLossProcess::spline = true
privateinherited

◆ subcutProducer

G4VSubCutProducer* G4VEnergyLossProcess::subcutProducer = nullptr
privateinherited

◆ tablesAreBuilt

G4bool G4VEnergyLossProcess::tablesAreBuilt = false
privateinherited

◆ theCSDARangeTable

G4PhysicsTable* G4VEnergyLossProcess::theCSDARangeTable = nullptr
privateinherited

◆ theCuts

const G4DataVector* G4VEnergyLossProcess::theCuts = nullptr
privateinherited

◆ theDEDXTable

G4PhysicsTable* G4VEnergyLossProcess::theDEDXTable = nullptr
privateinherited

◆ theDEDXunRestrictedTable

G4PhysicsTable* G4VEnergyLossProcess::theDEDXunRestrictedTable = nullptr
privateinherited

◆ theDensityFactor

const std::vector<G4double>* G4VEnergyLossProcess::theDensityFactor = nullptr
privateinherited

◆ theDensityIdx

const std::vector<G4int>* G4VEnergyLossProcess::theDensityIdx = nullptr
privateinherited

◆ theElectron

const G4ParticleDefinition* G4VEnergyLossProcess::theElectron
privateinherited

Definition at line 451 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::G4VEnergyLossProcess().

◆ theGamma

const G4ParticleDefinition* G4VEnergyLossProcess::theGamma
privateinherited

Definition at line 453 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::G4VEnergyLossProcess().

◆ theGenericIon

const G4ParticleDefinition* G4VEnergyLossProcess::theGenericIon = nullptr
privateinherited

◆ theInitialNumberOfInteractionLength

G4double G4VProcess::theInitialNumberOfInteractionLength = -1.0
protectedinherited

◆ theInverseRangeTable

G4PhysicsTable* G4VEnergyLossProcess::theInverseRangeTable = nullptr
privateinherited

◆ theIonisationSubTable

G4PhysicsTable* G4VEnergyLossProcess::theIonisationSubTable = nullptr
privateinherited

Definition at line 459 of file G4VEnergyLossProcess.hh.

◆ theIonisationTable

G4PhysicsTable* G4VEnergyLossProcess::theIonisationTable = nullptr
privateinherited

◆ theLambdaTable

G4PhysicsTable* G4VEnergyLossProcess::theLambdaTable = nullptr
privateinherited

◆ theNumberOfInteractionLengthLeft

G4double G4VProcess::theNumberOfInteractionLengthLeft = -1.0
protectedinherited

Definition at line 331 of file G4VProcess.hh.

Referenced by G4AdjointForcedInteractionForGamma::AlongStepDoIt(), G4MuonicAtomDecay::AtRestGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4Decay::AtRestGetPhysicalInteractionLength(), G4VProcess::ClearNumberOfInteractionLengthLeft(), G4MuonicAtomDecay::DecayIt(), G4VProcess::EndTracking(), G4VProcess::GetNumberOfInteractionLengthLeft(), G4VProcess::GetTotalNumberOfInteractionLengthTraversed(), G4GammaGeneralProcess::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4Decay::PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::ResetNumberOfInteractionLengthLeft(), G4VProcess::StartTracking(), G4GammaGeneralProcess::StartTracking(), G4VEmProcess::StartTracking(), G4VEnergyLossProcess::StartTracking(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

◆ theParameters

G4EmParameters* G4VEnergyLossProcess::theParameters
privateinherited

◆ thePhysicsTableFileName

G4String G4VProcess::thePhysicsTableFileName
protectedinherited

Definition at line 344 of file G4VProcess.hh.

Referenced by G4VProcess::GetPhysicsTableFileName().

◆ thePILfactor

G4double G4VProcess::thePILfactor = 1.0
protectedinherited

◆ thePositron

const G4ParticleDefinition* G4VEnergyLossProcess::thePositron
privateinherited

Definition at line 452 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::G4VEnergyLossProcess().

◆ theProcessName

G4String G4VProcess::theProcessName
protectedinherited

◆ theProcessSubType

G4int G4VProcess::theProcessSubType = -1
protectedinherited

◆ theProcessType

G4ProcessType G4VProcess::theProcessType = fNotDefined
protectedinherited

◆ theRangeTableForLoss

G4PhysicsTable* G4VEnergyLossProcess::theRangeTableForLoss = nullptr
privateinherited

◆ theSecondaryRangeTable

G4PhysicsTable* G4VEnergyLossProcess::theSecondaryRangeTable = nullptr
privateinherited

◆ tripletID

G4int G4VEnergyLossProcess::tripletID = _TripletElectron
privateinherited

Definition at line 514 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::PostStepDoIt().

◆ useDeexcitation

G4bool G4VEnergyLossProcess::useDeexcitation = false
privateinherited

◆ valueGPILSelection

G4GPILSelection G4VContinuousDiscreteProcess::valueGPILSelection = CandidateForSelection
privateinherited

◆ verboseLevel

G4int G4VProcess::verboseLevel = 0
protectedinherited

Definition at line 356 of file G4VProcess.hh.

Referenced by G4VEnergyLossProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateSecondaryBiasing(), G4VEnergyLossProcess::ActivateSecondaryBiasing(), G4LowECapture::AddRegion(), G4CoupledTransportation::AlongStepDoIt(), G4Transportation::AlongStepDoIt(), G4VContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4ParallelWorldProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4CoupledTransportation::AlongStepGetPhysicalInteractionLength(), G4Transportation::AlongStepGetPhysicalInteractionLength(), G4VContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4hImpactIonisation::AntiProtonParametrisedDEDX(), G4ParallelWorldScoringProcess::AtRestDoIt(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4VXTRenergyLoss::BuildAngleForEnergyBank(), G4VXTRenergyLoss::BuildAngleTable(), G4VEnergyLossProcess::BuildDEDXTable(), G4VXTRenergyLoss::BuildEnergyTable(), G4VXTRenergyLoss::BuildGlobalAngleTable(), G4VEmProcess::BuildLambdaTable(), G4hImpactIonisation::BuildLambdaTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4hImpactIonisation::BuildLossTable(), G4DNABrownianTransportation::BuildPhysicsTable(), G4GammaGeneralProcess::BuildPhysicsTable(), G4LowECapture::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4SynchrotronRadiation::BuildPhysicsTable(), G4VXTRenergyLoss::BuildPhysicsTable(), G4hImpactIonisation::BuildPhysicsTable(), G4ChargeExchangeProcess::BuildPhysicsTable(), G4OpRayleigh::CalculateRayleighMeanFreePaths(), G4PolarizedAnnihilation::ComputeSaturationFactor(), G4PolarizedCompton::ComputeSaturationFactor(), G4PolarizedIonisation::ComputeSaturationFactor(), G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4VPhononProcess::CreateSecondary(), G4VProcess::EndTracking(), G4VEmProcess::FindLambdaMax(), G4Cerenkov::G4Cerenkov(), G4ChargeExchangeProcess::G4ChargeExchangeProcess(), G4CoupledTransportation::G4CoupledTransportation(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ErrorEnergyLoss::G4ErrorEnergyLoss(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GaussXTRadiator::G4GaussXTRadiator(), G4ImportanceProcess::G4ImportanceProcess(), G4MaxTimeCuts::G4MaxTimeCuts(), G4MicroElecSurface::G4MicroElecSurface(), G4MinEkineCuts::G4MinEkineCuts(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4PolarizedIonisation::G4PolarizedIonisation(), G4Scintillation::G4Scintillation(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4SpecialCuts::G4SpecialCuts(), G4StepLimiter::G4StepLimiter(), G4StrawTubeXTRadiator::G4StrawTubeXTRadiator(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4TransparentRegXTRadiator::G4TransparentRegXTRadiator(), G4Transportation::G4Transportation(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VXTRenergyLoss::G4VXTRenergyLoss(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4VXTRenergyLoss::GetAngleVector(), G4ChargeExchangeProcess::GetElementCrossSection(), G4VXTRenergyLoss::GetGasZmuProduct(), G4PhononDownconversion::GetMeanFreePath(), G4PhononScattering::GetMeanFreePath(), G4PolarizedCompton::GetMeanFreePath(), G4VXTRenergyLoss::GetMeanFreePath(), G4UCNAbsorption::GetMeanFreePath(), G4PolarizedAnnihilation::GetMeanFreePath(), G4PolarizedIonisation::GetMeanFreePath(), G4SynchrotronRadiation::GetMeanFreePath(), G4VXTRenergyLoss::GetNumberOfPhotons(), G4VXTRenergyLoss::GetPlateZmuProduct(), G4SynchrotronRadiation::GetRandomEnergySR(), G4VProcess::GetVerboseLevel(), G4hhIonisation::InitialiseEnergyLossProcess(), G4eeToHadrons::InitialiseProcess(), G4hImpactIonisation::InitializeMe(), G4UCNBoundaryProcess::MRreflect(), G4UCNBoundaryProcess::MRreflectHigh(), G4DNASecondOrderReaction::PostStepDoIt(), G4ParallelWorldScoringProcess::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4DNAScavengerProcess::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4UCNAbsorption::PostStepDoIt(), G4UCNBoundaryProcess::PostStepDoIt(), G4UCNLoss::PostStepDoIt(), G4UCNMultiScattering::PostStepDoIt(), G4MicroElecSurface::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), G4Scintillation::PostStepDoIt(), G4VXTRenergyLoss::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4OpAbsorption::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpMieHG::PostStepDoIt(), G4OpRayleigh::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), G4CoupledTransportation::PostStepDoIt(), G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNASecondOrderReaction::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNAScavengerProcess::PostStepGetPhysicalInteractionLength(), G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4hImpactIonisation::ProtonParametrisedDEDX(), G4UCNBoundaryProcess::Reflect(), G4CoupledTransportation::ReportInexactEnergy(), G4CoupledTransportation::ReportMissingLogger(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrieveTable(), G4VEmProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCSDARangeTable(), G4CoupledTransportation::SetHighLooperThresholds(), G4Transportation::SetHighLooperThresholds(), G4VEnergyLossProcess::SetInverseRangeTable(), G4LowECapture::SetKinEnergyLimit(), G4NeutronKiller::SetKinEnergyLimit(), G4VEnergyLossProcess::SetLambdaTable(), G4CoupledTransportation::SetLowLooperThresholds(), G4Transportation::SetLowLooperThresholds(), G4VEnergyLossProcess::SetRangeTableForLoss(), G4VEnergyLossProcess::SetSecondaryRangeTable(), G4NeutronKiller::SetTimeLimit(), G4VProcess::SetVerboseLevel(), G4Cerenkov::SetVerboseLevel(), G4Scintillation::SetVerboseLevel(), G4OpAbsorption::SetVerboseLevel(), G4OpBoundaryProcess::SetVerboseLevel(), G4OpMieHG::SetVerboseLevel(), G4OpRayleigh::SetVerboseLevel(), G4OpWLS::SetVerboseLevel(), G4OpWLS2::SetVerboseLevel(), G4FastSimulationManagerProcess::SetWorldVolume(), G4GaussXTRadiator::SpectralXTRdEdx(), G4RegularXTRadiator::SpectralXTRdEdx(), G4TransparentRegXTRadiator::SpectralXTRdEdx(), G4XTRRegularRadModel::SpectralXTRdEdx(), G4VProcess::StartTracking(), G4CoupledTransportation::StartTracking(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), G4VEnergyLossProcess::StoreTable(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), G4VMultipleScattering::StreamInfo(), G4VITProcess::SubtractNumberOfInteractionLengthLeft(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

◆ weightFlag

G4bool G4VEnergyLossProcess::weightFlag = false
privateinherited

The documentation for this class was generated from the following files: