#include <G4VEnergyLossProcess.hh>

Inheritance diagram for G4VEnergyLossProcess:

Collaboration diagram for G4VEnergyLossProcess:

Public Member Functions
	G4VEnergyLossProcess (const G4String &name="EnergyLoss", G4ProcessType type=fElectromagnetic)

virtual	~G4VEnergyLossProcess ()

virtual G4bool	IsApplicable (const G4ParticleDefinition &p)=0

virtual void	PrintInfo ()=0

virtual void	ProcessDescription (std::ostream &outFile) const

virtual void	PreparePhysicsTable (const G4ParticleDefinition &)

virtual void	BuildPhysicsTable (const G4ParticleDefinition &)

G4PhysicsTable *	BuildDEDXTable (G4EmTableType tType=fRestricted)

G4PhysicsTable *	BuildLambdaTable (G4EmTableType tType=fRestricted)

void	PrintInfoDefinition (const G4ParticleDefinition &part)

virtual void	StartTracking (G4Track *)

virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety, G4GPILSelection *selection)

virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)

virtual G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &)

G4double	SampleSubCutSecondaries (std::vector< G4Track > &, const G4Step &, G4VEmModel model, G4int matIdx)

virtual G4VParticleChange *	PostStepDoIt (const G4Track &, const G4Step &)

virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii=false)

virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii)

G4double	GetDEDXDispersion (const G4MaterialCutsCouple couple, const G4DynamicParticle dp, G4double length)

G4double	CrossSectionPerVolume (G4double kineticEnergy, const G4MaterialCutsCouple *couple)

G4double	MeanFreePath (const G4Track &track)

G4double	ContinuousStepLimit (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety)

G4VEmModel *	SelectModelForMaterial (G4double kinEnergy, size_t &idx) const

void	AddEmModel (G4int, G4VEmModel , G4VEmFluctuationModel fluc=0, const G4Region *region=0)

void	UpdateEmModel (const G4String &, G4double, G4double)

void	SetEmModel (G4VEmModel *, G4int index=1)

G4VEmModel *	EmModel (G4int index=1) const

G4VEmModel *	GetModelByIndex (G4int idx=0, G4bool ver=false) const

G4int	NumberOfModels () const

void	SetFluctModel (G4VEmFluctuationModel *)

G4VEmFluctuationModel *	FluctModel ()

void	SetBaseParticle (const G4ParticleDefinition *p)

const G4ParticleDefinition *	Particle () const

const G4ParticleDefinition *	BaseParticle () const

const G4ParticleDefinition *	SecondaryParticle () const

void	ActivateSubCutoff (G4bool val, const G4Region *region=0)

void	SetCrossSectionBiasingFactor (G4double f, G4bool flag=true)

void	ActivateForcedInteraction (G4double length=0.0, const G4String &region="", G4bool flag=true)

void	ActivateSecondaryBiasing (const G4String &region, G4double factor, G4double energyLimit)

void	AddCollaborativeProcess (G4VEnergyLossProcess *)

void	SetLossFluctuations (G4bool val)

void	SetIntegral (G4bool val)

G4bool	IsIntegral () const

void	SetIonisation (G4bool val)

G4bool	IsIonisationProcess () const

void	SetLinearLossLimit (G4double val)

void	SetStepFunction (G4double v1, G4double v2)

void	SetLowestEnergyLimit (G4double)

G4int	NumberOfSubCutoffRegions () const

void	SetDEDXTable (G4PhysicsTable *p, G4EmTableType tType)

void	SetCSDARangeTable (G4PhysicsTable *pRange)

void	SetRangeTableForLoss (G4PhysicsTable *p)

void	SetSecondaryRangeTable (G4PhysicsTable *p)

void	SetInverseRangeTable (G4PhysicsTable *p)

void	SetLambdaTable (G4PhysicsTable *p)

void	SetSubLambdaTable (G4PhysicsTable *p)

void	SetDEDXBinning (G4int nbins)

void	SetMinKinEnergy (G4double e)

G4double	MinKinEnergy () const

void	SetMaxKinEnergy (G4double e)

G4double	MaxKinEnergy () const

G4double	CrossSectionBiasingFactor () const

G4double	GetDEDX (G4double &kineticEnergy, const G4MaterialCutsCouple *)

G4double	GetDEDXForSubsec (G4double &kineticEnergy, const G4MaterialCutsCouple *)

G4double	GetRange (G4double &kineticEnergy, const G4MaterialCutsCouple *)

G4double	GetCSDARange (G4double &kineticEnergy, const G4MaterialCutsCouple *)

G4double	GetRangeForLoss (G4double &kineticEnergy, const G4MaterialCutsCouple *)

G4double	GetKineticEnergy (G4double &range, const G4MaterialCutsCouple *)

G4double	GetLambda (G4double &kineticEnergy, const G4MaterialCutsCouple *)

G4bool	TablesAreBuilt () const

G4PhysicsTable *	DEDXTable () const

G4PhysicsTable *	DEDXTableForSubsec () const

G4PhysicsTable *	DEDXunRestrictedTable () const

G4PhysicsTable *	IonisationTable () const

G4PhysicsTable *	IonisationTableForSubsec () const

G4PhysicsTable *	CSDARangeTable () const

G4PhysicsTable *	SecondaryRangeTable () const

G4PhysicsTable *	RangeTableForLoss () const

G4PhysicsTable *	InverseRangeTable () const

G4PhysicsTable *	LambdaTable () const

G4PhysicsTable *	SubLambdaTable () const

const G4Element *	GetCurrentElement () const

void	SetDynamicMassCharge (G4double massratio, G4double charge2ratio)

Public Member Functions inherited from G4VContinuousDiscreteProcess
	G4VContinuousDiscreteProcess (const G4String &, G4ProcessType aType=fNotDefined)

	G4VContinuousDiscreteProcess (G4VContinuousDiscreteProcess &)

virtual	~G4VContinuousDiscreteProcess ()

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)

Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4int	operator== (const G4VProcess &right) const

G4int	operator!= (const G4VProcess &right) const

G4double	GetCurrentInteractionLength () const

void	SetPILfactor (G4double value)

G4double	GetPILfactor () const

G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)

G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)

G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)

const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)

const G4String &	GetProcessName () const

G4ProcessType	GetProcessType () const

void	SetProcessType (G4ProcessType)

G4int	GetProcessSubType () const

void	SetProcessSubType (G4int)

virtual void	EndTracking ()

virtual void	SetProcessManager (const G4ProcessManager *)

virtual const G4ProcessManager *	GetProcessManager ()

virtual void	ResetNumberOfInteractionLengthLeft ()

G4double	GetNumberOfInteractionLengthLeft () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4bool	isAtRestDoItIsEnabled () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

virtual void	DumpInfo () const

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

virtual void	SetMasterProcess (G4VProcess *masterP)

const G4VProcess *	GetMasterProcess () const

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Protected Member Functions
virtual void	InitialiseEnergyLossProcess (const G4ParticleDefinition , const G4ParticleDefinition )=0

virtual G4double	MinPrimaryEnergy (const G4ParticleDefinition , const G4Material , G4double cut)

virtual G4double	GetMeanFreePath (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)

virtual G4double	GetContinuousStepLimit (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety)

G4PhysicsVector *	LambdaPhysicsVector (const G4MaterialCutsCouple *, G4double cut)

size_t	CurrentMaterialCutsCoupleIndex () const

void	SelectModel (G4double kinEnergy)

void	SetParticle (const G4ParticleDefinition *p)

void	SetSecondaryParticle (const G4ParticleDefinition *p)

Protected Member Functions inherited from G4VContinuousDiscreteProcess
void	SetGPILSelection (G4GPILSelection selection)

G4GPILSelection	GetGPILSelection () const

Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double previousStepSize)

void	ClearNumberOfInteractionLengthLeft ()

Protected Attributes
G4ParticleChangeForLoss	fParticleChange

Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager

G4VParticleChange *	pParticleChange

G4ParticleChange	aParticleChange

G4double	theNumberOfInteractionLengthLeft

G4double	currentInteractionLength

G4double	theInitialNumberOfInteractionLength

G4String	theProcessName

G4String	thePhysicsTableFileName

G4ProcessType	theProcessType

G4int	theProcessSubType

G4double	thePILfactor

G4bool	enableAtRestDoIt

G4bool	enableAlongStepDoIt

G4bool	enablePostStepDoIt

G4int	verboseLevel

Private Member Functions
void	Clean ()

G4bool	StoreTable (const G4ParticleDefinition p, G4PhysicsTable , G4bool ascii, const G4String &directory, const G4String &tname)

G4bool	RetrieveTable (const G4ParticleDefinition p, G4PhysicsTable , G4bool ascii, const G4String &directory, const G4String &tname, G4bool mandatory)

void	FillSecondariesAlongStep (G4double &eloss, G4double &weight)

void	PrintWarning (G4String, G4double val)

void	DefineMaterial (const G4MaterialCutsCouple *couple)

G4double	GetDEDXForScaledEnergy (G4double scaledKinEnergy)

G4double	GetSubDEDXForScaledEnergy (G4double scaledKinEnergy)

G4double	GetIonisationForScaledEnergy (G4double scaledKinEnergy)

G4double	GetSubIonisationForScaledEnergy (G4double scaledKinEnergy)

G4double	GetScaledRangeForScaledEnergy (G4double scaledKinEnergy)

G4double	GetLimitScaledRangeForScaledEnergy (G4double scaledKinEnergy)

G4double	ScaledKinEnergyForLoss (G4double range)

G4double	GetLambdaForScaledEnergy (G4double scaledKinEnergy)

void	ComputeLambdaForScaledEnergy (G4double scaledKinEnergy)

	G4VEnergyLossProcess (G4VEnergyLossProcess &)

G4VEnergyLossProcess &	operator= (const G4VEnergyLossProcess &right)

Private Attributes
G4LossTableManager *	lManager

G4EmModelManager *	modelManager

G4EmBiasingManager *	biasManager

G4SafetyHelper *	safetyHelper

G4EmParameters *	theParameters

const G4ParticleDefinition *	secondaryParticle

const G4ParticleDefinition *	theElectron

const G4ParticleDefinition *	thePositron

const G4ParticleDefinition *	theGamma

const G4ParticleDefinition *	theGenericIon

std::vector< G4VEmModel * >	emModels

G4VEmFluctuationModel *	fluctModel

G4VAtomDeexcitation *	atomDeexcitation

G4VSubCutProducer *	subcutProducer

std::vector< const G4Region * >	scoffRegions

G4int	nSCoffRegions

G4bool *	idxSCoffRegions

std::vector< G4VEnergyLossProcess * >	scProcesses

G4int	nProcesses

G4PhysicsTable *	theDEDXTable

G4PhysicsTable *	theDEDXSubTable

G4PhysicsTable *	theDEDXunRestrictedTable

G4PhysicsTable *	theIonisationTable

G4PhysicsTable *	theIonisationSubTable

G4PhysicsTable *	theRangeTableForLoss

G4PhysicsTable *	theCSDARangeTable

G4PhysicsTable *	theSecondaryRangeTable

G4PhysicsTable *	theInverseRangeTable

G4PhysicsTable *	theLambdaTable

G4PhysicsTable *	theSubLambdaTable

size_t	idxDEDX

size_t	idxDEDXSub

size_t	idxDEDXunRestricted

size_t	idxIonisation

size_t	idxIonisationSub

size_t	idxRange

size_t	idxCSDA

size_t	idxSecRange

size_t	idxInverseRange

size_t	idxLambda

size_t	idxSubLambda

std::vector< G4double >	theDEDXAtMaxEnergy

std::vector< G4double >	theRangeAtMaxEnergy

std::vector< G4double >	theEnergyOfCrossSectionMax

std::vector< G4double >	theCrossSectionMax

const std::vector< G4double > *	theDensityFactor

const std::vector< G4int > *	theDensityIdx

const G4DataVector *	theCuts

const G4DataVector *	theSubCuts

const G4ParticleDefinition *	baseParticle

G4int	nBins

G4int	nBinsCSDA

G4double	lowestKinEnergy

G4double	minKinEnergy

G4double	maxKinEnergy

G4double	maxKinEnergyCSDA

G4double	linLossLimit

G4double	dRoverRange

G4double	finalRange

G4double	lambdaFactor

G4double	biasFactor

G4bool	lossFluctuationFlag

G4bool	rndmStepFlag

G4bool	tablesAreBuilt

G4bool	integral

G4bool	isIon

G4bool	isIonisation

G4bool	useSubCutoff

G4bool	useDeexcitation

G4bool	biasFlag

G4bool	weightFlag

G4bool	isMaster

G4bool	actLinLossLimit

G4bool	actLossFluc

G4bool	actBinning

G4bool	actMinKinEnergy

G4bool	actMaxKinEnergy

std::vector< G4DynamicParticle * >	secParticles

std::vector< G4Track * >	scTracks

const G4ParticleDefinition *	particle

G4VEmModel *	currentModel

const G4Material *	currentMaterial

const G4MaterialCutsCouple *	currentCouple

size_t	currentCoupleIndex

size_t	basedCoupleIndex

size_t	lastIdx

G4int	nWarnings

G4double	massRatio

G4double	fFactor

G4double	reduceFactor

G4double	chargeSqRatio

G4double	preStepLambda

G4double	fRange

G4double	computedRange

G4double	preStepKinEnergy

G4double	preStepScaledEnergy

G4double	preStepRangeEnergy

G4double	mfpKinEnergy

G4GPILSelection	aGPILSelection

G4int	secID

G4int	subsecID

G4int	biasID

Additional Inherited Members
Static Public Member Functions inherited from G4VProcess
static const G4String &	GetProcessTypeName (G4ProcessType)

Detailed Description

Definition at line 124 of file G4VEnergyLossProcess.hh.

Constructor & Destructor Documentation

◆ G4VEnergyLossProcess() [1/2]

G4VEnergyLossProcess::G4VEnergyLossProcess	(	const G4String &	name = `"EnergyLoss"`,
		G4ProcessType	type = `fElectromagnetic`
	)

Definition at line 167 of file G4VEnergyLossProcess.cc.

                                                               : 
   G4VContinuousDiscreteProcess(name, type),
   secondaryParticle(nullptr),
   nSCoffRegions(0),
   idxSCoffRegions(nullptr),
   nProcesses(0),
   theDEDXTable(nullptr),
   theDEDXSubTable(nullptr),
   theDEDXunRestrictedTable(nullptr),
   theIonisationTable(nullptr),
   theIonisationSubTable(nullptr),
   theRangeTableForLoss(nullptr),
   theCSDARangeTable(nullptr),
   theSecondaryRangeTable(nullptr),
   theInverseRangeTable(nullptr),
   theLambdaTable(nullptr),
   theSubLambdaTable(nullptr),
   theDensityFactor(nullptr),
   theDensityIdx(nullptr),
   baseParticle(nullptr),
   lossFluctuationFlag(true),
   rndmStepFlag(false),
   tablesAreBuilt(false),
   integral(true),
   isIon(false),
   isIonisation(true),
   useSubCutoff(false),
   useDeexcitation(false),
   particle(nullptr),
   currentCouple(nullptr),
   nWarnings(0),
   mfpKinEnergy(0.0)
 {
   theParameters = G4EmParameters::Instance();
   SetVerboseLevel(1);
 
   // low energy limit
   lowestKinEnergy  = theParameters->LowestElectronEnergy();
   preStepKinEnergy = 0.0;
   preStepRangeEnergy = 0.0;
   computedRange = DBL_MAX;
 
   // Size of tables assuming spline
   minKinEnergy     = 0.1*keV;
   maxKinEnergy     = 10.0*TeV;
   nBins            = 77;
   maxKinEnergyCSDA = 1.0*GeV;
   nBinsCSDA        = 35;
   actMinKinEnergy = actMaxKinEnergy = actBinning = actLinLossLimit 
     = actLossFluc = false;
 
   // default linear loss limit for spline
   linLossLimit  = 0.01;
 
   // default dRoverRange and finalRange
   SetStepFunction(0.2, 1.0*mm);
 
   // default lambda factor
   lambdaFactor  = 0.8;
 
   // cross section biasing
   biasFactor = 1.0;
 
   // particle types
   theElectron   = G4Electron::Electron();
   thePositron   = G4Positron::Positron();
   theGamma      = G4Gamma::Gamma();
   theGenericIon = nullptr;
 
   // run time objects
   pParticleChange = &fParticleChange;
   fParticleChange.SetSecondaryWeightByProcess(true);
   modelManager = new G4EmModelManager();
   safetyHelper = G4TransportationManager::GetTransportationManager()
     ->GetSafetyHelper();
   aGPILSelection = CandidateForSelection;
 
   // initialise model
   lManager = G4LossTableManager::Instance();
   lManager->Register(this);
   fluctModel = nullptr;
   currentModel = nullptr;
   atomDeexcitation = nullptr;
   subcutProducer = nullptr;
 
   biasManager  = nullptr;
   biasFlag     = false; 
   weightFlag   = false; 
   isMaster     = true;
   lastIdx      = 0;
 
   idxDEDX = idxDEDXSub = idxDEDXunRestricted = idxIonisation =
     idxIonisationSub = idxRange = idxCSDA = idxSecRange =
     idxInverseRange = idxLambda = idxSubLambda = 0;
 
   scTracks.reserve(5);
   secParticles.reserve(5);
 
   theCuts = theSubCuts = nullptr;
   currentMaterial = nullptr;
   currentCoupleIndex  = basedCoupleIndex = 0;
   massRatio = fFactor = reduceFactor = chargeSqRatio = 1.0;
   preStepLambda = preStepScaledEnergy = fRange = 0.0;
 
   secID = biasID = subsecID = -1;
 }

Here is the call graph for this function:

◆ ~G4VEnergyLossProcess()

G4VEnergyLossProcess::~G4VEnergyLossProcess ( )

virtual

Definition at line 277 of file G4VEnergyLossProcess.cc.

 {
   /*
   G4cout << "** G4VEnergyLossProcess::~G4VEnergyLossProcess() for " 
          << GetProcessName() << " isMaster: " << isMaster
          << "  basePart: " << baseParticle 
          << G4endl;
   */
   Clean();
 
   // G4cout << " isIonisation " << isIonisation << "  " 
   //   << theDEDXTable << "  " <<  theIonisationTable << G4endl;
 
   if (isMaster && !baseParticle) {
     if(theDEDXTable) {
 
       //G4cout << " theIonisationTable " << theIonisationTable << G4endl;
       if(theIonisationTable == theDEDXTable) { theIonisationTable = 0; }
       //G4cout << " delete theDEDXTable " << theDEDXTable << G4endl;
       theDEDXTable->clearAndDestroy();
       delete theDEDXTable;
       theDEDXTable = nullptr;
       if(theDEDXSubTable) {
         if(theIonisationSubTable == theDEDXSubTable) 
           { theIonisationSubTable = nullptr; }
         theDEDXSubTable->clearAndDestroy();
         delete theDEDXSubTable;
         theDEDXSubTable = nullptr;
       }
     }
     //G4cout << " theIonisationTable " << theIonisationTable << G4endl;
     if(theIonisationTable) {
       //G4cout << " delete theIonisationTable " << theIonisationTable << G4endl;
       theIonisationTable->clearAndDestroy();
       delete theIonisationTable;
       theIonisationTable = nullptr;
     }
     if(theIonisationSubTable) {
       theIonisationSubTable->clearAndDestroy();
       delete theIonisationSubTable;
       theIonisationSubTable = nullptr;
     }
     if(theDEDXunRestrictedTable && isIonisation) {
       theDEDXunRestrictedTable->clearAndDestroy();
       delete theDEDXunRestrictedTable;
       theDEDXunRestrictedTable = nullptr;
     }
     if(theCSDARangeTable && isIonisation) {
       theCSDARangeTable->clearAndDestroy();
       delete theCSDARangeTable;
       theCSDARangeTable = nullptr;
     }
     //G4cout << "delete RangeTable: " << theRangeTableForLoss << G4endl;
     if(theRangeTableForLoss && isIonisation) {
       theRangeTableForLoss->clearAndDestroy();
       delete theRangeTableForLoss;
       theRangeTableForLoss = nullptr;
     }
     //G4cout << "delete InvRangeTable: " << theInverseRangeTable << G4endl;
     if(theInverseRangeTable && isIonisation /*&& !isIon*/) {
       theInverseRangeTable->clearAndDestroy();
       delete theInverseRangeTable;
       theInverseRangeTable = nullptr;
     }
     //G4cout << "delete LambdaTable: " << theLambdaTable << G4endl;
     if(theLambdaTable) {
       theLambdaTable->clearAndDestroy();
       delete theLambdaTable;
       theLambdaTable = nullptr;
     }
     if(theSubLambdaTable) {
       theSubLambdaTable->clearAndDestroy();
       delete theSubLambdaTable;
       theSubLambdaTable = nullptr;
     }
   }
  
   delete modelManager;
   delete biasManager;
   lManager->DeRegister(this);
   //G4cout << "** all removed" << G4endl;
 }

Here is the call graph for this function:

◆ G4VEnergyLossProcess() [2/2]

G4VEnergyLossProcess::G4VEnergyLossProcess ( G4VEnergyLossProcess & )

private

Member Function Documentation

◆ ActivateForcedInteraction()

void G4VEnergyLossProcess::ActivateForcedInteraction	(	G4double	length = `0.0`,
		const G4String &	region = `""`,
		G4bool	flag = `true`
	)

Definition at line 2285 of file G4VEnergyLossProcess.cc.

 {
   if(!biasManager) { biasManager = new G4EmBiasingManager(); }
   if(1 < verboseLevel) {
     G4cout << "### ActivateForcedInteraction: for " 
            << " process " << GetProcessName()
            << " length(mm)= " << length/mm
            << " in G4Region <" << region
            << "> weightFlag= " << flag 
            << G4endl; 
   }
   weightFlag = flag;
   biasManager->ActivateForcedInteraction(length, region);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ActivateSecondaryBiasing()

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

Definition at line 2305 of file G4VEnergyLossProcess.cc.

 {
   if (0.0 <= factor) {
 
     // Range cut can be applied only for e-
     if(0.0 == factor && secondaryParticle != G4Electron::Electron())
       { return; }
 
     if(!biasManager) { biasManager = new G4EmBiasingManager(); }
     biasManager->ActivateSecondaryBiasing(region, factor, energyLimit);
     if(1 < verboseLevel) {
       G4cout << "### ActivateSecondaryBiasing: for " 
              << " process " << GetProcessName()
              << " factor= " << factor
              << " in G4Region <" << region 
              << "> energyLimit(MeV)= " << energyLimit/MeV
              << G4endl; 
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ActivateSubCutoff()

void G4VEnergyLossProcess::ActivateSubCutoff	(	G4bool	val,
		const G4Region *	region = `0`
	)

Definition at line 1047 of file G4VEnergyLossProcess.cc.

 {
   G4RegionStore* regionStore = G4RegionStore::GetInstance();
   const G4Region* reg = r;
   if (!reg) {
     reg = regionStore->GetRegion("DefaultRegionForTheWorld", false);
   }
 
   // the region is in the list
   if (nSCoffRegions > 0) {
     for (G4int i=0; i<nSCoffRegions; ++i) {
       if (reg == scoffRegions[i]) {
         return;
       }
     }
   }
 
   // new region 
   if(val) {
     scoffRegions.push_back(reg);
     ++nSCoffRegions;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddCollaborativeProcess()

void G4VEnergyLossProcess::AddCollaborativeProcess ( G4VEnergyLossProcess * p )

Definition at line 2034 of file G4VEnergyLossProcess.cc.

 {
   G4bool add = true;
   if(p->GetProcessName() != "eBrem") { add = false; }
   if(add && nProcesses > 0) {
     for(G4int i=0; i<nProcesses; ++i) {
       if(p == scProcesses[i]) {
         add = false;
         break;
       }
     }
   }
   if(add) {
     scProcesses.push_back(p);
     ++nProcesses;
     if (1 < verboseLevel) { 
       G4cout << "### The process " << p->GetProcessName() 
              << " is added to the list of collaborative processes of "
              << GetProcessName() << G4endl; 
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddEmModel()

void G4VEnergyLossProcess::AddEmModel	(	G4int	order,
		G4VEmModel *	p,
		G4VEmFluctuationModel *	fluc = `0`,
		const G4Region *	region = `0`
	)

Definition at line 393 of file G4VEnergyLossProcess.cc.

 {
   modelManager->AddEmModel(order, p, fluc, region);
   if(p) { p->SetParticleChange(pParticleChange, fluc); }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AlongStepDoIt()

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

virtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 1245 of file G4VEnergyLossProcess.cc.

 {
   fParticleChange.InitializeForAlongStep(track);
   // The process has range table - calculate energy loss
   if(!isIonisation || !currentModel->IsActive(preStepScaledEnergy)) {
     return &fParticleChange;
   }
 
   // Get the actual (true) Step length
   G4double length = step.GetStepLength();
   if(length <= 0.0) { return &fParticleChange; }
   G4double eloss  = 0.0;
  
   /*      
   if(-1 < verboseLevel) {
     const G4ParticleDefinition* d = track.GetParticleDefinition();
     G4cout << "AlongStepDoIt for "
            << GetProcessName() << " and particle "
            << d->GetParticleName()
            << "  eScaled(MeV)= " << preStepScaledEnergy/MeV
            << "  range(mm)= " << fRange/mm
            << "  s(mm)= " << length/mm
            << "  rf= " << reduceFactor
            << "  q^2= " << chargeSqRatio
            << " md= " << d->GetPDGMass()
            << "  status= " << track.GetTrackStatus()
            << "  " << track.GetMaterial()->GetName()
            << G4endl;
   }
   */
 
   const G4DynamicParticle* dynParticle = track.GetDynamicParticle();
 
   // define new weight for primary and secondaries
   G4double weight = fParticleChange.GetParentWeight();
   if(weightFlag) {
     weight /= biasFactor;
     fParticleChange.ProposeWeight(weight);
   }
 
   // stopping
   if (length >= fRange || preStepKinEnergy <= lowestKinEnergy) {
     eloss = preStepKinEnergy;
     if (useDeexcitation) {
       atomDeexcitation->AlongStepDeexcitation(scTracks, step, 
                                               eloss, currentCoupleIndex);
       if(scTracks.size() > 0) { FillSecondariesAlongStep(eloss, weight); }
       if(eloss < 0.0) { eloss = 0.0; }
     }
     fParticleChange.SetProposedKineticEnergy(0.0);
     fParticleChange.ProposeLocalEnergyDeposit(eloss);
     return &fParticleChange;
   }
   //G4cout << theDEDXTable << "  idx= " << basedCoupleIndex 
   // << "  " << GetProcessName() << "  "<< currentMaterial->GetName()<<G4endl;
   //if(particle->GetParticleName() == "e-")G4cout << (*theDEDXTable) <<G4endl;
   // Short step
   eloss = GetDEDXForScaledEnergy(preStepScaledEnergy)*length;
 
   //G4cout << "eloss= " << eloss << G4endl;
 
   // Long step
   if(eloss > preStepKinEnergy*linLossLimit) {
 
     G4double x = (fRange - length)/reduceFactor;
     //G4cout << "x= " << x << "  " << theInverseRangeTable << G4endl;
     eloss = preStepKinEnergy - ScaledKinEnergyForLoss(x)/massRatio;
    
     /*
     if(-1 < verboseLevel) 
       G4cout << "Long STEP: rPre(mm)= " 
              << GetScaledRangeForScaledEnergy(preStepScaledEnergy)/mm
              << " rPost(mm)= " << x/mm
              << " ePre(MeV)= " << preStepScaledEnergy/MeV
              << " eloss(MeV)= " << eloss/MeV
              << " eloss0(MeV)= "
              << GetDEDXForScaledEnergy(preStepScaledEnergy)*length/MeV
              << " lim(MeV)= " << preStepKinEnergy*linLossLimit/MeV
              << G4endl;
     */
   }
 
   /*   
   G4double eloss0 = eloss;
   if(-1 < verboseLevel ) {
     G4cout << "Before fluct: eloss(MeV)= " << eloss/MeV
            << " e-eloss= " << preStepKinEnergy-eloss
            << " step(mm)= " << length/mm
            << " range(mm)= " << fRange/mm
            << " fluct= " << lossFluctuationFlag
            << G4endl;
   }
   */
 
   G4double cut  = (*theCuts)[currentCoupleIndex];
   G4double esec = 0.0;
 
   //G4cout << "cut= " << cut << " useSubCut= " << useSubCutoff << G4endl;
 
   // SubCutOff 
   if(useSubCutoff && !subcutProducer) {
     if(idxSCoffRegions[currentCoupleIndex]) {
 
       G4bool yes = false;
       G4StepPoint* prePoint = step.GetPreStepPoint();
 
       // Check boundary
       if(prePoint->GetStepStatus() == fGeomBoundary) { yes = true; }
 
       // Check PrePoint
       else {
         G4double preSafety  = prePoint->GetSafety();
         G4double rcut = 
           currentCouple->GetProductionCuts()->GetProductionCut(1);
 
         // recompute presafety
         if(preSafety < rcut) {
           preSafety = safetyHelper->ComputeSafety(prePoint->GetPosition(),
                                                   rcut);
         }
 
         if(preSafety < rcut) { yes = true; }
 
         // Check PostPoint
         else {
           G4double postSafety = preSafety - length; 
           if(postSafety < rcut) {
             postSafety = safetyHelper->ComputeSafety(
               step.GetPostStepPoint()->GetPosition(), rcut);
             if(postSafety < rcut) { yes = true; }
           }
         }
       }
   
       // Decided to start subcut sampling
       if(yes) {
 
         cut = (*theSubCuts)[currentCoupleIndex];
          eloss -= GetSubDEDXForScaledEnergy(preStepScaledEnergy)*length;
         esec = SampleSubCutSecondaries(scTracks, step, 
                                        currentModel,currentCoupleIndex);
         // add bremsstrahlung sampling
         /*
         if(nProcesses > 0) {
           for(G4int i=0; i<nProcesses; ++i) {
             (scProcesses[i])->SampleSubCutSecondaries(
                 scTracks, step, (scProcesses[i])->
                 SelectModelForMaterial(preStepKinEnergy, currentCoupleIndex),
                 currentCoupleIndex);
           }
         } 
         */
       }   
     }
   }
 
   // Corrections, which cannot be tabulated
   if(isIon) {
     G4double eadd = 0.0;
     G4double eloss_before = eloss;
     currentModel->CorrectionsAlongStep(currentCouple, dynParticle, 
                                        eloss, eadd, length);
     if(eloss < 0.0) { eloss = 0.5*eloss_before; }
   }
 
   // Sample fluctuations
   if (lossFluctuationFlag) {
     G4VEmFluctuationModel* fluc = currentModel->GetModelOfFluctuations();
     if(eloss + esec < preStepKinEnergy) {
 
       G4double tmax = 
         std::min(currentModel->MaxSecondaryKinEnergy(dynParticle),cut);
       eloss = fluc->SampleFluctuations(currentCouple,dynParticle,
                                        tmax,length,eloss);
       /*                                  
       if(-1 < verboseLevel) 
       G4cout << "After fluct: eloss(MeV)= " << eloss/MeV
              << " fluc= " << (eloss-eloss0)/MeV
              << " ChargeSqRatio= " << chargeSqRatio
              << " massRatio= " << massRatio
              << " tmax= " << tmax
              << G4endl;
       */
     }
   }
 
   // deexcitation
   if (useDeexcitation) {
     G4double esecfluo = preStepKinEnergy - esec;
     G4double de = esecfluo;
     //G4double eloss0 = eloss;
     /*
     G4cout << "### 1: E(keV)= " << preStepKinEnergy/keV
            << " Efluomax(keV)= " << de/keV
            << " Eloss(keV)= " << eloss/keV << G4endl; 
     */
     atomDeexcitation->AlongStepDeexcitation(scTracks, step, 
                                             de, currentCoupleIndex);
 
     // sum of de-excitation energies
     esecfluo -= de;
 
     // subtracted from energy loss
     if(eloss >= esecfluo) {
       esec  += esecfluo;
       eloss -= esecfluo;
     } else {
       esec += esecfluo;
       eloss = 0.0; 
     } 
     /*    
     if(esecfluo > 0.0) {
       G4cout << "### 2: E(keV)= " << preStepKinEnergy/keV
              << " Esec(keV)= " << esec/keV
              << " Esecf(kV)= " << esecfluo/keV
              << " Eloss0(kV)= " << eloss0/keV
              << " Eloss(keV)= " << eloss/keV 
              << G4endl; 
     } 
     */   
   }
   if(subcutProducer && idxSCoffRegions[currentCoupleIndex]) {
     subcutProducer->SampleSecondaries(step, scTracks, eloss, cut);
   }
   if(scTracks.size() > 0) { FillSecondariesAlongStep(eloss, weight); }
 
   // Energy balance
   G4double finalT = preStepKinEnergy - eloss - esec;
   if (finalT <= lowestKinEnergy) {
     eloss += finalT;
     finalT = 0.0;
   } else if(isIon) {
     fParticleChange.SetProposedCharge(
       currentModel->GetParticleCharge(track.GetParticleDefinition(),
                                       currentMaterial,finalT));
   }
 
   eloss = std::max(eloss, 0.0);
 
   fParticleChange.SetProposedKineticEnergy(finalT);
   fParticleChange.ProposeLocalEnergyDeposit(eloss);
   /*
   if(-1 < verboseLevel) {
     G4double del = finalT + eloss + esec - preStepKinEnergy;
     G4cout << "Final value eloss(MeV)= " << eloss/MeV
            << " preStepKinEnergy= " << preStepKinEnergy
            << " postStepKinEnergy= " << finalT
            << " de(keV)= " << del/keV
            << " lossFlag= " << lossFluctuationFlag
            << "  status= " << track.GetTrackStatus()
            << G4endl;
   }
   */
   return &fParticleChange;
 }

Here is the call graph for this function:

◆ AlongStepGetPhysicalInteractionLength()

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

virtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 1112 of file G4VEnergyLossProcess.cc.

 {
   G4double x = DBL_MAX;
   *selection = aGPILSelection;
   if(isIonisation && currentModel->IsActive(preStepScaledEnergy)) {
     fRange = GetScaledRangeForScaledEnergy(preStepScaledEnergy)*reduceFactor;
     x = fRange;
     G4double finR = finalRange;
     if(rndmStepFlag) { 
       finR = std::min(finR,
                       currentCouple->GetProductionCuts()->GetProductionCut(1));
     }
     if(fRange > finR) { 
       x = fRange*dRoverRange + finR*(1.0 - dRoverRange)*(2.0 - finR/fRange); 
     }
     
    // if(particle->GetPDGMass() > 0.9*GeV)
     /*
     G4cout<<GetProcessName()<<": e= "<<preStepKinEnergy
           <<" range= "<<fRange << " idx= " << basedCoupleIndex
               << " finR= " << finR
           << " limit= " << x <<G4endl;
     G4cout << "massRatio= " << massRatio << " Q^2= " << chargeSqRatio 
            << " finR= " << finR << " dRoverRange= " << dRoverRange 
            << " finalRange= " << finalRange << G4endl;
     */
   }
   //G4cout<<GetProcessName()<<": e= "<<preStepKinEnergy 
   //<<" stepLimit= "<<x<<G4endl;
   return x;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BaseParticle()

const G4ParticleDefinition * G4VEnergyLossProcess::BaseParticle ( ) const

inline

Definition at line 925 of file G4VEnergyLossProcess.hh.

 {
   return baseParticle;
 }

Here is the caller graph for this function:

◆ BuildDEDXTable()

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

Definition at line 800 of file G4VEnergyLossProcess.cc.

 {
   if(1 < verboseLevel ) {
     G4cout << "G4VEnergyLossProcess::BuildDEDXTable() of type " << tType
            << " for " << GetProcessName()
            << " and particle " << particle->GetParticleName()
            << G4endl;
   }
   G4PhysicsTable* table = nullptr;
   G4double emax = maxKinEnergy;
   G4int bin = nBins;
 
   if(fTotal == tType) {
     emax  = maxKinEnergyCSDA;
     bin   = nBinsCSDA;
     table = theDEDXunRestrictedTable;
   } else if(fRestricted == tType) {
     table = theDEDXTable;
   } else if(fSubRestricted == tType) {    
     table = theDEDXSubTable;
   } else {
     G4cout << "G4VEnergyLossProcess::BuildDEDXTable WARNING: wrong type "
            << tType << G4endl;
   }
 
   // Access to materials
   const G4ProductionCutsTable* theCoupleTable=
         G4ProductionCutsTable::GetProductionCutsTable();
   size_t numOfCouples = theCoupleTable->GetTableSize();
 
   if(1 < verboseLevel) {
     G4cout << numOfCouples << " materials"
            << " minKinEnergy= " << minKinEnergy
            << " maxKinEnergy= " << emax
            << " nbin= " << bin
            << " EmTableType= " << tType
            << " table= " << table << "  " << this 
            << G4endl;
   }
   if(!table) { return table; }
 
   G4LossTableBuilder* bld = lManager->GetTableBuilder();
   G4bool splineFlag = theParameters->Spline();
   G4PhysicsLogVector* aVector = nullptr;
   G4PhysicsLogVector* bVector = nullptr;
 
   for(size_t i=0; i<numOfCouples; ++i) {
 
     if(1 < verboseLevel) {
       G4cout << "G4VEnergyLossProcess::BuildDEDXVector Idx= " << i 
              << "  flagTable=  " << table->GetFlag(i) 
              << " Flag= " << bld->GetFlag(i) << G4endl;
     }
     if(bld->GetFlag(i)) {
 
       // create physics vector and fill it
       const G4MaterialCutsCouple* couple = 
         theCoupleTable->GetMaterialCutsCouple(i);
       if((*table)[i]) { delete (*table)[i]; }
       if(bVector) {
         aVector = new G4PhysicsLogVector(*bVector);
       } else {
         bVector = new G4PhysicsLogVector(minKinEnergy, emax, bin);
         aVector = bVector;
       }
       aVector->SetSpline(splineFlag);
 
       modelManager->FillDEDXVector(aVector, couple, tType);
       if(splineFlag) { aVector->FillSecondDerivatives(); }
 
       // Insert vector for this material into the table
       G4PhysicsTableHelper::SetPhysicsVector(table, i, aVector);
     }
   }
 
   if(1 < verboseLevel) {
     G4cout << "G4VEnergyLossProcess::BuildDEDXTable(): table is built for "
            << particle->GetParticleName()
            << " and process " << GetProcessName()
            << G4endl;
     if(2 < verboseLevel) G4cout << (*table) << G4endl;
   }
 
   return table;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildLambdaTable()

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

Definition at line 888 of file G4VEnergyLossProcess.cc.

 {
   G4PhysicsTable* table = nullptr;
 
   if(fRestricted == tType) {
     table = theLambdaTable;
   } else if(fSubRestricted == tType) {    
     table = theSubLambdaTable;
   } else {
     G4cout << "G4VEnergyLossProcess::BuildLambdaTable WARNING: wrong type "
            << tType << G4endl;
   }
 
   if(1 < verboseLevel) {
     G4cout << "G4VEnergyLossProcess::BuildLambdaTable() of type "
            << tType << " for process "
            << GetProcessName() << " and particle "
            << particle->GetParticleName()
            << " EmTableType= " << tType
            << " table= " << table
            << G4endl;
   }
   if(!table) {return table;}
 
   // Access to materials
   const G4ProductionCutsTable* theCoupleTable=
         G4ProductionCutsTable::GetProductionCutsTable();
   size_t numOfCouples = theCoupleTable->GetTableSize();
 
   G4LossTableBuilder* bld = lManager->GetTableBuilder();
   theDensityFactor = bld->GetDensityFactors();
   theDensityIdx = bld->GetCoupleIndexes();
 
   G4bool splineFlag = theParameters->Spline();
   G4PhysicsLogVector* aVector = nullptr;
   G4double scale = G4Log(maxKinEnergy/minKinEnergy);
 
   for(size_t i=0; i<numOfCouples; ++i) {
 
     if (bld->GetFlag(i)) {
 
       // create physics vector and fill it
       const G4MaterialCutsCouple* couple = 
         theCoupleTable->GetMaterialCutsCouple(i);
       delete (*table)[i];
 
       G4bool startNull = true;
       G4double emin = 
         MinPrimaryEnergy(particle,couple->GetMaterial(),(*theCuts)[i]);
       if(minKinEnergy > emin) { 
         emin = minKinEnergy; 
         startNull = false;
       }
 
       G4double emax = maxKinEnergy;
       if(emax <= emin) { emax = 2*emin; }
       G4int bin = G4lrint(nBins*G4Log(emax/emin)/scale);
       bin = std::max(bin, 3);
       aVector = new G4PhysicsLogVector(emin, emax, bin);
       aVector->SetSpline(splineFlag);
 
       modelManager->FillLambdaVector(aVector, couple, startNull, tType);
       if(splineFlag) { aVector->FillSecondDerivatives(); }
 
       // Insert vector for this material into the table
       G4PhysicsTableHelper::SetPhysicsVector(table, i, aVector);
     }
   }
 
   if(1 < verboseLevel) {
     G4cout << "Lambda table is built for "
            << particle->GetParticleName()
            << G4endl;
   }
 
   return table;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildPhysicsTable()

void G4VEnergyLossProcess::BuildPhysicsTable ( const G4ParticleDefinition & part )

virtual

Reimplemented from G4VProcess.

Reimplemented in G4ePolarizedIonisation.

Definition at line 691 of file G4VEnergyLossProcess.cc.

 {
   if(1 < verboseLevel) {
   
     G4cout << "### G4VEnergyLossProcess::BuildPhysicsTable() for "
            << GetProcessName()
            << " and particle " << part.GetParticleName()
            << "; local: " << particle->GetParticleName();
     if(baseParticle) { 
       G4cout << "; base: " << baseParticle->GetParticleName(); 
     }
     G4cout << " TablesAreBuilt= " << tablesAreBuilt
            << " isIon= " << isIon << "  " << this << G4endl;
   }
 
   if(&part == particle) {
 
     G4LossTableBuilder* bld = lManager->GetTableBuilder();
     if(isMaster) {
       theDensityFactor = bld->GetDensityFactors();
       theDensityIdx = bld->GetCoupleIndexes();
       lManager->BuildPhysicsTable(particle, this);
 
     } else {
 
       const G4VEnergyLossProcess* masterProcess = 
         static_cast<const G4VEnergyLossProcess*>(GetMasterProcess());
 
       // define density factors for worker thread
       bld->InitialiseBaseMaterials(masterProcess->DEDXTable()); 
       theDensityFactor = bld->GetDensityFactors();
       theDensityIdx = bld->GetCoupleIndexes();
 
       // copy table pointers from master thread
       SetDEDXTable(masterProcess->DEDXTable(),fRestricted);
       SetDEDXTable(masterProcess->DEDXTableForSubsec(),fSubRestricted);
       SetDEDXTable(masterProcess->DEDXunRestrictedTable(),fTotal);
       SetDEDXTable(masterProcess->IonisationTable(),fIsIonisation);
       SetDEDXTable(masterProcess->IonisationTableForSubsec(),fIsSubIonisation);
       SetRangeTableForLoss(masterProcess->RangeTableForLoss());
       SetCSDARangeTable(masterProcess->CSDARangeTable());
       SetSecondaryRangeTable(masterProcess->SecondaryRangeTable());
       SetInverseRangeTable(masterProcess->InverseRangeTable());
       SetLambdaTable(masterProcess->LambdaTable());
       SetSubLambdaTable(masterProcess->SubLambdaTable());
       isIonisation = masterProcess->IsIonisationProcess();
 
       tablesAreBuilt = true;  
       // local initialisation of models
       G4bool printing = true;
       G4int numberOfModels = modelManager->NumberOfModels();
       for(G4int i=0; i<numberOfModels; ++i) {
         G4VEmModel* mod = GetModelByIndex(i, printing);
         G4VEmModel* mod0= masterProcess->GetModelByIndex(i,printing);
         mod->InitialiseLocal(particle, mod0);
       }
 
       lManager->LocalPhysicsTables(particle, this);
     }
    
     // needs to be done only once
     safetyHelper->InitialiseHelper();
   }
   // explicitly defined printout by particle name
   G4String num = part.GetParticleName();
   if(1 < verboseLevel || 
      (0 < verboseLevel && (num == "e-" || 
                            num == "e+"    || num == "mu+" || 
                            num == "mu-"   || num == "proton"|| 
                            num == "pi+"   || num == "pi-" || 
                            num == "kaon+" || num == "kaon-" || 
                            num == "alpha" || num == "anti_proton" || 
                            num == "GenericIon")))
     { 
       PrintInfoDefinition(part); 
     }
 
   // Added tracking cut to avoid tracking artifacts
   // identify deexcitation flag
   if(isIonisation) { 
     //VI: seems not needed fParticleChange.SetLowEnergyLimit(lowestKinEnergy); 
     atomDeexcitation = lManager->AtomDeexcitation();
     if(nSCoffRegions > 0) { subcutProducer = lManager->SubCutProducer(); }
     if(atomDeexcitation) { 
       if(atomDeexcitation->IsPIXEActive()) { useDeexcitation = true; } 
     }
   }
   /*  
   G4cout << "** G4VEnergyLossProcess::BuildPhysicsTable() for " 
          << GetProcessName() << " and " << particle->GetParticleName()
          << " isMaster: " << isMaster << " isIonisation: " 
          << isIonisation << G4endl;
   G4cout << " theDEDX: " << theDEDXTable 
          << " theRange: " << theRangeTableForLoss
          << " theInverse: " << theInverseRangeTable
          << " theLambda: " << theLambdaTable << G4endl;
   */
   //if(1 < verboseLevel || verb) {
   if(1 < verboseLevel) {
     G4cout << "### G4VEnergyLossProcess::BuildPhysicsTable() done for "
            << GetProcessName()
            << " and particle " << part.GetParticleName();
     if(isIonisation) { G4cout << "  isIonisation  flag = 1"; }
     G4cout << G4endl;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Clean()

void G4VEnergyLossProcess::Clean ( )

private

Definition at line 362 of file G4VEnergyLossProcess.cc.

 {
   /*
   if(1 < verboseLevel) { 
     G4cout << "G4VEnergyLossProcess::Clear() for " << GetProcessName() 
            << G4endl;
   }
   */
   delete [] idxSCoffRegions;
 
   tablesAreBuilt = false;
 
   scProcesses.clear();
   nProcesses = 0;
 
   idxDEDX = idxDEDXSub = idxDEDXunRestricted = idxIonisation =
     idxIonisationSub = idxRange = idxCSDA = idxSecRange =
     idxInverseRange = idxLambda = idxSubLambda = 0;
 }

Here is the caller graph for this function:

◆ ComputeLambdaForScaledEnergy()

void G4VEnergyLossProcess::ComputeLambdaForScaledEnergy ( G4double scaledKinEnergy )

inlineprivate

Definition at line 858 of file G4VEnergyLossProcess.hh.

 {
   mfpKinEnergy  = theEnergyOfCrossSectionMax[currentCoupleIndex];
   if (e <= mfpKinEnergy) {
     preStepLambda = GetLambdaForScaledEnergy(e);
 
   } else {
     G4double e1 = e*lambdaFactor;
     if(e1 > mfpKinEnergy) {
       preStepLambda  = GetLambdaForScaledEnergy(e);
       G4double preStepLambda1 = GetLambdaForScaledEnergy(e1);
       if(preStepLambda1 > preStepLambda) {
         mfpKinEnergy = e1;
         preStepLambda = preStepLambda1;
       }
     } else {
       preStepLambda = fFactor*theCrossSectionMax[currentCoupleIndex];
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ContinuousStepLimit()

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

Definition at line 1991 of file G4VEnergyLossProcess.cc.

 {
   G4GPILSelection sel;
   return AlongStepGetPhysicalInteractionLength(track, x, y, z, &sel);
 }

Here is the call graph for this function:

◆ CrossSectionBiasingFactor()

G4double G4VEnergyLossProcess::CrossSectionBiasingFactor ( ) const

inline

Definition at line 989 of file G4VEnergyLossProcess.hh.

 {
   return biasFactor;
 }

◆ CrossSectionPerVolume()

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

Definition at line 1959 of file G4VEnergyLossProcess.cc.

 {
   // Cross section per volume is calculated
   DefineMaterial(couple);
   G4double cross = 0.0;
   if(theLambdaTable) { 
     cross = GetLambdaForScaledEnergy(kineticEnergy*massRatio);
   } else {
     SelectModel(kineticEnergy*massRatio);
     cross = biasFactor*(*theDensityFactor)[currentCoupleIndex]
       *(currentModel->CrossSectionPerVolume(currentMaterial,
                                             particle, kineticEnergy,
                                             (*theCuts)[currentCoupleIndex]));
   }
   if(cross < 0.0) { cross = 0.0; }
   return cross;
 }

Here is the call graph for this function:

◆ CSDARangeTable()

G4PhysicsTable * G4VEnergyLossProcess::CSDARangeTable ( ) const

inline

Definition at line 1038 of file G4VEnergyLossProcess.hh.

 {
   return theCSDARangeTable;
 }

Here is the caller graph for this function:

◆ CurrentMaterialCutsCoupleIndex()

size_t G4VEnergyLossProcess::CurrentMaterialCutsCoupleIndex ( ) const

inlineprotected

Definition at line 610 of file G4VEnergyLossProcess.hh.

 {
   return currentCoupleIndex;
 }

Here is the caller graph for this function:

◆ DEDXTable()

G4PhysicsTable * G4VEnergyLossProcess::DEDXTable ( ) const

inline

Definition at line 1003 of file G4VEnergyLossProcess.hh.

 {
   return theDEDXTable;
 }

Here is the caller graph for this function:

◆ DEDXTableForSubsec()

G4PhysicsTable * G4VEnergyLossProcess::DEDXTableForSubsec ( ) const

inline

Definition at line 1010 of file G4VEnergyLossProcess.hh.

 {
   return theDEDXSubTable;
 }

Here is the caller graph for this function:

◆ DEDXunRestrictedTable()

G4PhysicsTable * G4VEnergyLossProcess::DEDXunRestrictedTable ( ) const

inline

Definition at line 1017 of file G4VEnergyLossProcess.hh.

 {
   return theDEDXunRestrictedTable;
 }

Here is the caller graph for this function:

◆ DefineMaterial()

void G4VEnergyLossProcess::DefineMaterial ( const G4MaterialCutsCouple * couple )

inlineprivate

Definition at line 634 of file G4VEnergyLossProcess.hh.

 {
   if(couple != currentCouple) {
     currentCouple   = couple;
     currentMaterial = couple->GetMaterial();
     currentCoupleIndex = couple->GetIndex();
     basedCoupleIndex   = (*theDensityIdx)[currentCoupleIndex];
     fFactor = chargeSqRatio*biasFactor*(*theDensityFactor)[currentCoupleIndex];
     reduceFactor = 1.0/(fFactor*massRatio);
     mfpKinEnergy = DBL_MAX;
     idxLambda = idxSubLambda = 0;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EmModel()

G4VEmModel * G4VEnergyLossProcess::EmModel ( G4int index = 1 ) const

Definition at line 420 of file G4VEnergyLossProcess.cc.

 {
   G4VEmModel* p = nullptr;
   if(index >= 0 && index <  G4int(emModels.size())) { p = emModels[index]; }
   return p;
 }

Here is the caller graph for this function:

◆ FillSecondariesAlongStep()

void G4VEnergyLossProcess::FillSecondariesAlongStep	(	G4double &	eloss,
		G4double &	weight
	)

private

Definition at line 1505 of file G4VEnergyLossProcess.cc.

 {
   G4int n0 = scTracks.size();
 
   // weight may be changed by biasing manager
   if(biasManager) {
     if(biasManager->SecondaryBiasingRegion(currentCoupleIndex)) {
       weight *=
         biasManager->ApplySecondaryBiasing(scTracks, currentCoupleIndex);
     }
   } 
 
   // fill secondaries
   G4int n = scTracks.size();
   fParticleChange.SetNumberOfSecondaries(n);
 
   for(G4int i=0; i<n; ++i) {
     G4Track* t = scTracks[i];
     if(t) {
       t->SetWeight(weight); 
       pParticleChange->AddSecondary(t);
       if(i >= n0) { t->SetCreatorModelIndex(biasID); }
       //G4cout << "Secondary(along step) has weight " << t->GetWeight() 
       //<< ", kenergy " << t->GetKineticEnergy()/MeV << " MeV" <<G4endl;
     }
   }
   scTracks.clear();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FluctModel()

G4VEmFluctuationModel * G4VEnergyLossProcess::FluctModel ( )

inline

Definition at line 888 of file G4VEnergyLossProcess.hh.

 {
   return fluctModel;
 }

Here is the caller graph for this function:

◆ GetContinuousStepLimit()

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

protectedvirtual

Implements G4VContinuousDiscreteProcess.

Definition at line 2013 of file G4VEnergyLossProcess.cc.

 {
   return DBL_MAX;
 }

◆ GetCSDARange()

G4double G4VEnergyLossProcess::GetCSDARange	(	G4double &	kineticEnergy,
		const G4MaterialCutsCouple *	couple
	)

inline

Definition at line 806 of file G4VEnergyLossProcess.hh.

 {
   DefineMaterial(couple);
   G4double x = DBL_MAX;
   if(theCSDARangeTable) {
     x=GetLimitScaledRangeForScaledEnergy(kineticEnergy*massRatio)*reduceFactor;
   }
   return x;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCurrentElement()

const G4Element * G4VEnergyLossProcess::GetCurrentElement ( ) const

Definition at line 2258 of file G4VEnergyLossProcess.cc.

 {
   const G4Element* elm = nullptr;
   if(currentModel) { elm = currentModel->GetCurrentElement(); }
   return elm;
 }

Here is the call graph for this function:

◆ GetDEDX()

G4double G4VEnergyLossProcess::GetDEDX	(	G4double &	kineticEnergy,
		const G4MaterialCutsCouple *	couple
	)

inline

Definition at line 769 of file G4VEnergyLossProcess.hh.

 {
   DefineMaterial(couple);
   return GetDEDXForScaledEnergy(kineticEnergy*massRatio);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetDEDXDispersion()

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

Definition at line 1941 of file G4VEnergyLossProcess.cc.

 {
   DefineMaterial(couple);
   G4double ekin = dp->GetKineticEnergy();
   SelectModel(ekin*massRatio);
   G4double tmax = currentModel->MaxSecondaryKinEnergy(dp);
   tmax = std::min(tmax,(*theCuts)[currentCoupleIndex]);
   G4double d = 0.0;
   G4VEmFluctuationModel* fm = currentModel->GetModelOfFluctuations();
   if(fm) { d = fm->Dispersion(currentMaterial,dp,tmax,length); }
   return d;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetDEDXForScaledEnergy()

G4double G4VEnergyLossProcess::GetDEDXForScaledEnergy ( G4double scaledKinEnergy )

inlineprivate

Definition at line 661 of file G4VEnergyLossProcess.hh.

 {
   /*
   G4cout << "G4VEnergyLossProcess::GetDEDX: Idx= " 
            << basedCoupleIndex << " E(MeV)= " << e 
          << " Emin= " << minKinEnergy << "  Factor= " << fFactor 
          << "  " << theDEDXTable << G4endl; */
   G4double x = fFactor*(*theDEDXTable)[basedCoupleIndex]->Value(e, idxDEDX);
   if(e < minKinEnergy) { x *= std::sqrt(e/minKinEnergy); }
   return x;
 }

Here is the caller graph for this function:

◆ GetDEDXForSubsec()

G4double G4VEnergyLossProcess::GetDEDXForSubsec	(	G4double &	kineticEnergy,
		const G4MaterialCutsCouple *	couple
	)

inline

Definition at line 779 of file G4VEnergyLossProcess.hh.

 {
   DefineMaterial(couple);
   return GetSubDEDXForScaledEnergy(kineticEnergy*massRatio);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetIonisationForScaledEnergy()

G4double G4VEnergyLossProcess::GetIonisationForScaledEnergy ( G4double scaledKinEnergy )

inlineprivate

Definition at line 685 of file G4VEnergyLossProcess.hh.

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

◆ GetKineticEnergy()

G4double G4VEnergyLossProcess::GetKineticEnergy	(	G4double &	range,
		const G4MaterialCutsCouple *	couple
	)

inline

Definition at line 835 of file G4VEnergyLossProcess.hh.

 {
   DefineMaterial(couple);
   return ScaledKinEnergyForLoss(range/reduceFactor)/massRatio;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetLambda()

G4double G4VEnergyLossProcess::GetLambda	(	G4double &	kineticEnergy,
		const G4MaterialCutsCouple *	couple
	)

inline

Definition at line 845 of file G4VEnergyLossProcess.hh.

 {
   DefineMaterial(couple);
   G4double x = 0.0;
   if(theLambdaTable) { 
     x = GetLambdaForScaledEnergy(kineticEnergy*massRatio); 
   }
   return x;
 }

Here is the call graph for this function:

◆ GetLambdaForScaledEnergy()

G4double G4VEnergyLossProcess::GetLambdaForScaledEnergy ( G4double scaledKinEnergy )

inlineprivate

Definition at line 761 of file G4VEnergyLossProcess.hh.

 {
   return fFactor*((*theLambdaTable)[basedCoupleIndex])->Value(e, idxLambda);
 }

Here is the caller graph for this function:

◆ GetLimitScaledRangeForScaledEnergy()

G4double G4VEnergyLossProcess::GetLimitScaledRangeForScaledEnergy ( G4double scaledKinEnergy )

inlineprivate

Definition at line 728 of file G4VEnergyLossProcess.hh.

 {
   G4double x;
   if (e < maxKinEnergyCSDA) {
     x = ((*theCSDARangeTable)[basedCoupleIndex])->Value(e, idxCSDA);
     if(e < minKinEnergy) { x *= std::sqrt(e/minKinEnergy); }
   } else {
     x = theRangeAtMaxEnergy[basedCoupleIndex] +
       (e - maxKinEnergyCSDA)/theDEDXAtMaxEnergy[basedCoupleIndex];
   }
   return x;
 }

Here is the caller graph for this function:

◆ GetMeanFreePath()

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

protectedvirtual

Implements G4VContinuousDiscreteProcess.

Reimplemented in G4ePolarizedIonisation.

Definition at line 2001 of file G4VEnergyLossProcess.cc.

 {
   *condition = NotForced;
   return MeanFreePath(track);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetModelByIndex()

G4VEmModel * G4VEnergyLossProcess::GetModelByIndex	(	G4int	idx = `0`,
		G4bool	ver = `false`
	)		const

Definition at line 429 of file G4VEnergyLossProcess.cc.

 {
   return modelManager->GetModel(idx, ver);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetRange()

G4double G4VEnergyLossProcess::GetRange	(	G4double &	kineticEnergy,
		const G4MaterialCutsCouple *	couple
	)

inline

Definition at line 789 of file G4VEnergyLossProcess.hh.

 {
   G4double x = fRange;
   DefineMaterial(couple);
   if(theCSDARangeTable) {
     x = GetLimitScaledRangeForScaledEnergy(kineticEnergy*massRatio)
       * reduceFactor;
   } else if(theRangeTableForLoss) {
     x = GetScaledRangeForScaledEnergy(kineticEnergy*massRatio)*reduceFactor;
   }
   return x;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetRangeForLoss()

G4double G4VEnergyLossProcess::GetRangeForLoss	(	G4double &	kineticEnergy,
		const G4MaterialCutsCouple *	couple
	)

inline

Definition at line 820 of file G4VEnergyLossProcess.hh.

 {
   //  G4cout << "GetRangeForLoss: Range from " << GetProcessName() << G4endl;
   DefineMaterial(couple);
   G4double x = 
     GetScaledRangeForScaledEnergy(kineticEnergy*massRatio)*reduceFactor;
   //G4cout << "GetRangeForLoss: Range from " << GetProcessName() 
   //         << "  e= " << kineticEnergy << " r= " << x << G4endl;
   return x;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetScaledRangeForScaledEnergy()

G4double G4VEnergyLossProcess::GetScaledRangeForScaledEnergy ( G4double scaledKinEnergy )

inlineprivate

Definition at line 706 of file G4VEnergyLossProcess.hh.

 {
   //G4cout << "G4VEnergyLossProcess::GetScaledRange: Idx= " 
   //         << basedCoupleIndex << " E(MeV)= " << e 
   //         << " lastIdx= " << lastIdx << "  " << theRangeTableForLoss << G4endl; 
   if(basedCoupleIndex != lastIdx || preStepRangeEnergy != e) {
     lastIdx = basedCoupleIndex;
     preStepRangeEnergy = e;
     computedRange = 
       ((*theRangeTableForLoss)[basedCoupleIndex])->Value(e, idxRange);
     if(e < minKinEnergy) { computedRange *= std::sqrt(e/minKinEnergy); }
   }
   //G4cout << "G4VEnergyLossProcess::GetScaledRange: Idx= " 
   //         << basedCoupleIndex << " E(MeV)= " << e 
   //         << " R=  " << fRange << "  " << theRangeTableForLoss << G4endl; 
 
   return computedRange;
 }

Here is the caller graph for this function:

◆ GetSubDEDXForScaledEnergy()

G4double G4VEnergyLossProcess::GetSubDEDXForScaledEnergy ( G4double scaledKinEnergy )

inlineprivate

Definition at line 675 of file G4VEnergyLossProcess.hh.

 {
   G4double x = 
     fFactor*(*theDEDXSubTable)[basedCoupleIndex]->Value(e, idxDEDXSub);
   if(e < minKinEnergy) { x *= std::sqrt(e/minKinEnergy); }
   return x;
 }

Here is the caller graph for this function:

◆ GetSubIonisationForScaledEnergy()

G4double G4VEnergyLossProcess::GetSubIonisationForScaledEnergy ( G4double scaledKinEnergy )

inlineprivate

Definition at line 696 of file G4VEnergyLossProcess.hh.

 {
   G4double x = fFactor*
     (*theIonisationSubTable)[basedCoupleIndex]->Value(e, idxIonisationSub);
   if(e < minKinEnergy) { x *= std::sqrt(e/minKinEnergy); }
   return x;
 }

◆ InitialiseEnergyLossProcess()

virtual void G4VEnergyLossProcess::InitialiseEnergyLossProcess	(	const G4ParticleDefinition *	,
		const G4ParticleDefinition *
	)

protectedpure virtual

Implemented in G4MuIonisation, G4hIonisation, G4MuBremsstrahlung, G4ionIonisation, G4eBremsstrahlung, G4eIonisation, G4MuPairProduction, G4ePolarizedIonisation, G4hhIonisation, G4mplIonisation, G4hBremsstrahlung, G4alphaIonisation, and G4hPairProduction.

Here is the caller graph for this function:

◆ InverseRangeTable()

G4PhysicsTable * G4VEnergyLossProcess::InverseRangeTable ( ) const

inline

Definition at line 1059 of file G4VEnergyLossProcess.hh.

 {
   return theInverseRangeTable;
 }

Here is the caller graph for this function:

◆ IonisationTable()

G4PhysicsTable * G4VEnergyLossProcess::IonisationTable ( ) const

inline

Definition at line 1024 of file G4VEnergyLossProcess.hh.

 {
   return theIonisationTable;
 }

Here is the caller graph for this function:

◆ IonisationTableForSubsec()

G4PhysicsTable * G4VEnergyLossProcess::IonisationTableForSubsec ( ) const

inline

Definition at line 1031 of file G4VEnergyLossProcess.hh.

 {
   return theIonisationSubTable;
 }

Here is the caller graph for this function:

◆ IsApplicable()

virtual G4bool G4VEnergyLossProcess::IsApplicable ( const G4ParticleDefinition & p )

pure virtual

Reimplemented from G4VProcess.

Implemented in G4MuIonisation, G4hIonisation, G4eBremsstrahlung, G4eIonisation, G4MuBremsstrahlung, G4ionIonisation, G4MuPairProduction, G4ePolarizedIonisation, G4mplIonisation, G4hBremsstrahlung, G4hhIonisation, G4hPairProduction, and G4alphaIonisation.

◆ IsIntegral()

G4bool G4VEnergyLossProcess::IsIntegral ( ) const

inline

Definition at line 954 of file G4VEnergyLossProcess.hh.

 {
   return integral;
 }

◆ IsIonisationProcess()

G4bool G4VEnergyLossProcess::IsIonisationProcess ( ) const

inline

Definition at line 961 of file G4VEnergyLossProcess.hh.

 {
   return isIonisation;
 }

Here is the caller graph for this function:

◆ LambdaPhysicsVector()

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

protected

Definition at line 2023 of file G4VEnergyLossProcess.cc.

 {
   G4PhysicsVector* v = 
     new G4PhysicsLogVector(minKinEnergy, maxKinEnergy, nBins);
   v->SetSpline(theParameters->Spline());
   return v;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LambdaTable()

G4PhysicsTable * G4VEnergyLossProcess::LambdaTable ( ) const

inline

Definition at line 1066 of file G4VEnergyLossProcess.hh.

 {
   return theLambdaTable;
 }

Here is the caller graph for this function:

◆ MaxKinEnergy()

G4double G4VEnergyLossProcess::MaxKinEnergy ( ) const

inline

Definition at line 982 of file G4VEnergyLossProcess.hh.

 {
   return maxKinEnergy;
 }

◆ MeanFreePath()

G4double G4VEnergyLossProcess::MeanFreePath ( const G4Track & track )

Definition at line 1980 of file G4VEnergyLossProcess.cc.

 {
   DefineMaterial(track.GetMaterialCutsCouple());
   preStepLambda = GetLambdaForScaledEnergy(track.GetKineticEnergy()*massRatio);
   G4double x = DBL_MAX;
   if(0.0 < preStepLambda) { x = 1.0/preStepLambda; }
   return x;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MinKinEnergy()

G4double G4VEnergyLossProcess::MinKinEnergy ( ) const

inline

Definition at line 975 of file G4VEnergyLossProcess.hh.

 {
   return minKinEnergy;
 }

◆ MinPrimaryEnergy()

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

protectedvirtual

Reimplemented in G4ionIonisation, G4eIonisation, G4MuIonisation, G4hIonisation, G4MuBremsstrahlung, G4ePolarizedIonisation, G4MuPairProduction, G4alphaIonisation, and G4hhIonisation.

Definition at line 384 of file G4VEnergyLossProcess.cc.

 {
   return cut;
 }

Here is the caller graph for this function:

◆ NumberOfModels()

G4int G4VEnergyLossProcess::NumberOfModels ( ) const

Definition at line 436 of file G4VEnergyLossProcess.cc.

 {
   return modelManager->NumberOfModels();
 }

Here is the call graph for this function:

◆ NumberOfSubCutoffRegions()

G4int G4VEnergyLossProcess::NumberOfSubCutoffRegions ( ) const

inline

Definition at line 968 of file G4VEnergyLossProcess.hh.

 {
   return nSCoffRegions;
 }

Here is the caller graph for this function:

◆ operator=()

G4VEnergyLossProcess& G4VEnergyLossProcess::operator= ( const G4VEnergyLossProcess & right )

private

◆ Particle()

const G4ParticleDefinition * G4VEnergyLossProcess::Particle ( ) const

inline

Definition at line 918 of file G4VEnergyLossProcess.hh.

 {
   return particle;
 }

Here is the caller graph for this function:

◆ PostStepDoIt()

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

virtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 1616 of file G4VEnergyLossProcess.cc.

 {
   // In all cases clear number of interaction lengths
   theNumberOfInteractionLengthLeft = -1.0;
   mfpKinEnergy = currentInteractionLength = DBL_MAX; 
 
   fParticleChange.InitializeForPostStep(track);
   G4double finalT = track.GetKineticEnergy();
   if(finalT <= lowestKinEnergy) { return &fParticleChange; }
 
   G4double postStepScaledEnergy = finalT*massRatio;
 
   if(!currentModel->IsActive(postStepScaledEnergy)) { 
     return &fParticleChange; 
   }
   /*
   if(-1 < verboseLevel) {
     G4cout << GetProcessName()
            << "::PostStepDoIt: E(MeV)= " << finalT/MeV
            << G4endl;
   }
   */
 
   // forced process - should happen only once per track
   if(biasFlag) {
     if(biasManager->ForcedInteractionRegion(currentCoupleIndex)) {
       biasFlag = false;
     }
   }
 
   // Integral approach
   if (integral) {
     G4double lx = GetLambdaForScaledEnergy(postStepScaledEnergy);
     /*
     if(preStepLambda<lx && 1 < verboseLevel && nWarnings<200) {
       G4cout << "WARNING: for " << particle->GetParticleName()
              << " and " << GetProcessName()
              << " E(MeV)= " << finalT/MeV
              << " preLambda= " << preStepLambda 
              << " < " << lx << " (postLambda) "
              << G4endl;
       ++nWarnings;
     }
     */
     if(lx <= 0.0 || preStepLambda*G4UniformRand() > lx) {
       return &fParticleChange;
     }
   }
 
   SelectModel(postStepScaledEnergy);
 
   // define new weight for primary and secondaries
   G4double weight = fParticleChange.GetParentWeight();
   if(weightFlag) {
     weight /= biasFactor;
     fParticleChange.ProposeWeight(weight);
   }
 
   const G4DynamicParticle* dynParticle = track.GetDynamicParticle();
   G4double tcut = (*theCuts)[currentCoupleIndex];
 
   // sample secondaries
   secParticles.clear();
   //G4cout<< "@@@ Eprimary= "<<dynParticle->GetKineticEnergy()/MeV
   //        << " cut= " << tcut/MeV << G4endl;
   currentModel->SampleSecondaries(&secParticles, currentCouple, 
                                   dynParticle, tcut);
 
   G4int num0 = secParticles.size();
 
   // bremsstrahlung splitting or Russian roulette  
   if(biasManager) {
     if(biasManager->SecondaryBiasingRegion(currentCoupleIndex)) {
       G4double eloss = 0.0;
       weight *= biasManager->ApplySecondaryBiasing(
                                       secParticles,
                                       track, currentModel, 
                                       &fParticleChange, eloss,
                                       currentCoupleIndex, tcut, 
                                       step.GetPostStepPoint()->GetSafety());
       if(eloss > 0.0) {
         eloss += fParticleChange.GetLocalEnergyDeposit();
         fParticleChange.ProposeLocalEnergyDeposit(eloss);
       }
     }
   }
 
   // save secondaries
   G4int num = secParticles.size();
   if(num > 0) {
 
     fParticleChange.SetNumberOfSecondaries(num);
     G4double time = track.GetGlobalTime();
 
     for (G4int i=0; i<num; ++i) {
       if(secParticles[i]) {
         G4Track* t = new G4Track(secParticles[i], time, track.GetPosition());
         t->SetTouchableHandle(track.GetTouchableHandle());
         t->SetWeight(weight); 
         if(i < num0) { t->SetCreatorModelIndex(secID); }
         else         { t->SetCreatorModelIndex(biasID); }
 
         //G4cout << "Secondary(post step) has weight " << t->GetWeight() 
         //       << ", kenergy " << t->GetKineticEnergy()/MeV << " MeV" 
         //       << " time= " << time/ns << " ns " << G4endl;
         pParticleChange->AddSecondary(t);
       }
     }
   }
 
   if(0.0 == fParticleChange.GetProposedKineticEnergy() &&
      fAlive == fParticleChange.GetTrackStatus()) {
     if(particle->GetProcessManager()->GetAtRestProcessVector()->size() > 0)
          { fParticleChange.ProposeTrackStatus(fStopButAlive); }
     else { fParticleChange.ProposeTrackStatus(fStopAndKill); }
   }
 
   /*
   if(-1 < verboseLevel) {
     G4cout << "::PostStepDoIt: Sample secondary; Efin= " 
     << fParticleChange.GetProposedKineticEnergy()/MeV
            << " MeV; model= (" << currentModel->LowEnergyLimit()
            << ", " <<  currentModel->HighEnergyLimit() << ")"
            << "  preStepLambda= " << preStepLambda
            << "  dir= " << track.GetMomentumDirection()
            << "  status= " << track.GetTrackStatus()
            << G4endl;
   }
   */
   return &fParticleChange;
 }

Here is the call graph for this function:

◆ PostStepGetPhysicalInteractionLength()

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

virtual

Reimplemented from G4VContinuousDiscreteProcess.

Reimplemented in G4ePolarizedIonisation.

Definition at line 1148 of file G4VEnergyLossProcess.cc.

 {
   // condition is set to "Not Forced"
   *condition = NotForced;
   G4double x = DBL_MAX;
 
   // initialisation of material, mass, charge, model 
   // at the beginning of the step
   DefineMaterial(track.GetMaterialCutsCouple());
   preStepKinEnergy    = track.GetKineticEnergy();
   preStepScaledEnergy = preStepKinEnergy*massRatio;
   SelectModel(preStepScaledEnergy);
 
   if(!currentModel->IsActive(preStepScaledEnergy)) { 
     theNumberOfInteractionLengthLeft = -1.0;
     currentInteractionLength = DBL_MAX;
     return x; 
   }
 
   // change effective charge of an ion on fly
   if(isIon) {
     G4double q2 = currentModel->ChargeSquareRatio(track);
     if(q2 != chargeSqRatio && q2 > 0.0) {
       chargeSqRatio = q2;
       fFactor = q2*biasFactor*(*theDensityFactor)[currentCoupleIndex];
       reduceFactor = 1.0/(fFactor*massRatio);
     }
   }
   //  if(particle->GetPDGMass() > 0.9*GeV)
   //G4cout << "q2= "<<chargeSqRatio << " massRatio= " << massRatio << G4endl; 
 
   // forced biasing only for primary particles
   if(biasManager) {
     if(0 == track.GetParentID()) {
       if(biasFlag && 
          biasManager->ForcedInteractionRegion(currentCoupleIndex)) {
         return biasManager->GetStepLimit(currentCoupleIndex, previousStepSize);
       }
     }
   }
 
   // compute mean free path
   if(preStepScaledEnergy < mfpKinEnergy) {
     if (integral) { ComputeLambdaForScaledEnergy(preStepScaledEnergy); }
     else  { preStepLambda = GetLambdaForScaledEnergy(preStepScaledEnergy); }
 
     // zero cross section
     if(preStepLambda <= 0.0) { 
       theNumberOfInteractionLengthLeft = -1.0;
       currentInteractionLength = DBL_MAX;
     }
   }
 
   // non-zero cross section
   if(preStepLambda > 0.0) { 
     if (theNumberOfInteractionLengthLeft < 0.0) {
 
       // beggining of tracking (or just after DoIt of this process)
       theNumberOfInteractionLengthLeft =  -G4Log( G4UniformRand() );
       theInitialNumberOfInteractionLength = theNumberOfInteractionLengthLeft; 
 
     } else if(currentInteractionLength < DBL_MAX) {
 
       // subtract NumberOfInteractionLengthLeft using previous step
       theNumberOfInteractionLengthLeft -= 
         previousStepSize/currentInteractionLength;
 
       theNumberOfInteractionLengthLeft = 
         std::max(theNumberOfInteractionLengthLeft, 0.0);
     }
 
     // new mean free path and step limit
     currentInteractionLength = 1.0/preStepLambda;
     x = theNumberOfInteractionLengthLeft * currentInteractionLength;
   }
 #ifdef G4VERBOSE
   if (verboseLevel>2){
     //  if(particle->GetPDGMass() > 0.9*GeV){
     G4cout << "G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength ";
     G4cout << "[ " << GetProcessName() << "]" << G4endl; 
     G4cout << " for " << track.GetDefinition()->GetParticleName() 
            << " in Material  " <<  currentMaterial->GetName()
            << " Ekin(MeV)= " << preStepKinEnergy/MeV 
            << "  " << track.GetMaterial()->GetName()
            <<G4endl;
     G4cout << "MeanFreePath = " << currentInteractionLength/cm << "[cm]" 
            << "InteractionLength= " << x/cm <<"[cm] " <<G4endl;
   }
 #endif
   return x;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PreparePhysicsTable()

void G4VEnergyLossProcess::PreparePhysicsTable ( const G4ParticleDefinition & part )

virtual

Reimplemented from G4VProcess.

Definition at line 444 of file G4VEnergyLossProcess.cc.

 {
   if(1 < verboseLevel) {
     G4cout << "G4VEnergyLossProcess::PreparePhysicsTable for "
            << GetProcessName() << " for " << part.GetParticleName() 
            << "  " << this << G4endl;
   }
 
   const G4VEnergyLossProcess* masterProcess = 
     static_cast<const G4VEnergyLossProcess*>(GetMasterProcess());
   if(masterProcess && masterProcess != this) { isMaster = false; }
 
   currentCouple = nullptr;
   preStepLambda = 0.0;
   mfpKinEnergy  = DBL_MAX;
   fRange        = DBL_MAX;
   preStepKinEnergy = 0.0;
   preStepRangeEnergy = 0.0;
   chargeSqRatio = 1.0;
   massRatio = 1.0;
   reduceFactor = 1.0;
   fFactor = 1.0;
   lastIdx = 0;
 
   // Are particle defined?
   if( !particle ) { particle = &part; }
 
   if(part.GetParticleType() == "nucleus") {
 
     G4String pname = part.GetParticleName();
     if(pname != "deuteron" && pname != "triton" &&
        pname != "alpha+"   && pname != "helium" &&
        pname != "hydrogen") {
 
       if(!theGenericIon) {
         theGenericIon = 
           G4ParticleTable::GetParticleTable()->FindParticle("GenericIon");
       }
       isIon = true; 
       if(theGenericIon && particle != theGenericIon) {
         G4ProcessManager* pm =  theGenericIon->GetProcessManager();
         G4ProcessVector* v = pm->GetAlongStepProcessVector();
         size_t n = v->size();
         for(size_t j=0; j<n; ++j) {
           if((*v)[j] == this) {
             particle = theGenericIon;
             break;
           } 
         }
       }
     }
   }
 
   if( particle != &part ) {
     if(!isIon) {
       lManager->RegisterExtraParticle(&part, this);
     }
     if(1 < verboseLevel) {
       G4cout << "### G4VEnergyLossProcess::PreparePhysicsTable()"
              << " interrupted for "
              << part.GetParticleName() << "  isIon= " << isIon 
              << "  particle " << particle << "  GenericIon " << theGenericIon 
              << G4endl;
     }
     return;
   }
 
   Clean();
   lManager->PreparePhysicsTable(&part, this, isMaster);
   G4LossTableBuilder* bld = lManager->GetTableBuilder();
 
   // Base particle and set of models can be defined here
   InitialiseEnergyLossProcess(particle, baseParticle);
 
   const G4ProductionCutsTable* theCoupleTable=
     G4ProductionCutsTable::GetProductionCutsTable();
   size_t n = theCoupleTable->GetTableSize();
 
   theDEDXAtMaxEnergy.resize(n, 0.0);
   theRangeAtMaxEnergy.resize(n, 0.0);
   theEnergyOfCrossSectionMax.resize(n, 0.0);
   theCrossSectionMax.resize(n, DBL_MAX);
 
   // parameters of the process
   if(!actLossFluc) { lossFluctuationFlag = theParameters->LossFluctuation(); }
   rndmStepFlag = theParameters->UseCutAsFinalRange();
   if(!actMinKinEnergy) { minKinEnergy = theParameters->MinKinEnergy(); }
   if(!actMaxKinEnergy) { maxKinEnergy = theParameters->MaxKinEnergy(); }
   if(!actBinning) { nBins = theParameters->NumberOfBins(); }
   maxKinEnergyCSDA = theParameters->MaxEnergyForCSDARange();
   nBinsCSDA = theParameters->NumberOfBinsPerDecade()
     *G4lrint(std::log10(maxKinEnergyCSDA/minKinEnergy));
   if(!actLinLossLimit) { linLossLimit = theParameters->LinearLossLimit(); }
   lambdaFactor = theParameters->LambdaFactor();
   if(isMaster) { SetVerboseLevel(theParameters->Verbose()); }
   else {  SetVerboseLevel(theParameters->WorkerVerbose()); }
 
   G4double initialCharge = particle->GetPDGCharge();
   G4double initialMass   = particle->GetPDGMass();
 
   if (baseParticle) {
     massRatio = (baseParticle->GetPDGMass())/initialMass;
     G4double q = initialCharge/baseParticle->GetPDGCharge();
     chargeSqRatio = q*q;
     if(chargeSqRatio > 0.0) { reduceFactor = 1.0/(chargeSqRatio*massRatio); }
   }
   if(initialMass < MeV) {
     lowestKinEnergy = theParameters->LowestElectronEnergy();
   } else {
     lowestKinEnergy = theParameters->LowestMuHadEnergy();
   }
 
   // Tables preparation
   if (isMaster && !baseParticle) {
 
     if(theDEDXTable && isIonisation) {
       if(theIonisationTable && theDEDXTable != theIonisationTable) {
         theDEDXTable->clearAndDestroy();
         delete theDEDXTable;
         theDEDXTable = theIonisationTable;
       }   
       if(theDEDXSubTable && theIonisationSubTable && 
          theDEDXSubTable != theIonisationSubTable) {
         theDEDXSubTable->clearAndDestroy();
         delete theDEDXSubTable;
         theDEDXSubTable = theIonisationSubTable;
       }   
     }
     
     theDEDXTable = G4PhysicsTableHelper::PreparePhysicsTable(theDEDXTable);
     bld->InitialiseBaseMaterials(theDEDXTable);
 
     if(theDEDXSubTable) {
       theDEDXSubTable = 
         G4PhysicsTableHelper::PreparePhysicsTable(theDEDXSubTable);
     }
 
     if (lManager->BuildCSDARange()) {
       theDEDXunRestrictedTable = 
         G4PhysicsTableHelper::PreparePhysicsTable(theDEDXunRestrictedTable);
       theCSDARangeTable = 
         G4PhysicsTableHelper::PreparePhysicsTable(theCSDARangeTable);
     }
 
     theLambdaTable = G4PhysicsTableHelper::PreparePhysicsTable(theLambdaTable);
 
     if(isIonisation) {
       theRangeTableForLoss = 
         G4PhysicsTableHelper::PreparePhysicsTable(theRangeTableForLoss);
       theInverseRangeTable = 
         G4PhysicsTableHelper::PreparePhysicsTable(theInverseRangeTable);  
     }
 
     if (nSCoffRegions && !lManager->SubCutProducer()) {
       theDEDXSubTable = 
         G4PhysicsTableHelper::PreparePhysicsTable(theDEDXSubTable);
       theSubLambdaTable = 
         G4PhysicsTableHelper::PreparePhysicsTable(theSubLambdaTable);
     }
   }
   /*
   G4cout << "** G4VEnergyLossProcess::PreparePhysicsTable() for " 
          << GetProcessName() << " and " << particle->GetParticleName()
          << " isMaster: " << isMaster << " isIonisation: " 
          << isIonisation << G4endl;
   G4cout << " theDEDX: " << theDEDXTable 
          << " theRange: " << theRangeTableForLoss
          << " theInverse: " << theInverseRangeTable
          << " theLambda: " << theLambdaTable << G4endl;
   */
   // forced biasing
   if(biasManager) { 
     biasManager->Initialise(part,GetProcessName(),verboseLevel); 
     biasFlag = false; 
   }
 
   // defined ID of secondary particles
   if(isMaster) {
     G4String nam1 = GetProcessName();
     G4String nam4 = nam1 + "_split";
     G4String nam5 = nam1 + "_subcut";
     secID   = G4PhysicsModelCatalog::Register(nam1); 
     biasID  = G4PhysicsModelCatalog::Register(nam4); 
     subsecID= G4PhysicsModelCatalog::Register(nam5);
   } 
 
   // initialisation of models
   G4int nmod = modelManager->NumberOfModels();
   for(G4int i=0; i<nmod; ++i) {
     G4VEmModel* mod = modelManager->GetModel(i);
     mod->SetMasterThread(isMaster);
     mod->SetAngularGeneratorFlag(
       theParameters->UseAngularGeneratorForIonisation());
     if(mod->HighEnergyLimit() > maxKinEnergy) {
       mod->SetHighEnergyLimit(maxKinEnergy);
     }
   }
   theCuts = modelManager->Initialise(particle, secondaryParticle, 
                                      theParameters->MinSubRange(), 
                                      verboseLevel);
 
   // Sub Cutoff 
   if(nSCoffRegions > 0) {
     if(theParameters->MinSubRange() < 1.0) { useSubCutoff = true; }
 
     theSubCuts = modelManager->SubCutoff();
 
     idxSCoffRegions = new G4bool[n]; 
     for (size_t j=0; j<n; ++j) {
 
       const G4MaterialCutsCouple* couple = 
         theCoupleTable->GetMaterialCutsCouple(j);
       const G4ProductionCuts* pcuts = couple->GetProductionCuts();
       
       G4bool reg = false;
       for(G4int i=0; i<nSCoffRegions; ++i) {
         if( pcuts == scoffRegions[i]->GetProductionCuts()) { 
           reg = true;
           break; 
         }
       }
       idxSCoffRegions[j] = reg;
     }
   }
 
   if(1 < verboseLevel) {
     G4cout << "G4VEnergyLossProcess::PrepearPhysicsTable() is done "
            << " for local " << particle->GetParticleName()
            << " isIon= " << isIon;
     if(baseParticle) { 
       G4cout << "; base: " << baseParticle->GetParticleName(); 
     }
     G4cout << " chargeSqRatio= " << chargeSqRatio
            << " massRatio= " << massRatio
            << " reduceFactor= " << reduceFactor << G4endl;
     if (nSCoffRegions) {
       G4cout << " SubCutoff Regime is ON for regions: " << G4endl;
       for (G4int i=0; i<nSCoffRegions; ++i) {
         const G4Region* r = scoffRegions[i];
         G4cout << "           " << r->GetName() << G4endl;
       }
     }
   }
 }

◆ PrintInfo()

virtual void G4VEnergyLossProcess::PrintInfo ( )

pure virtual

Implemented in G4MuIonisation, G4hIonisation, G4MuBremsstrahlung, G4eBremsstrahlung, G4eIonisation, G4ionIonisation, G4MuPairProduction, G4ePolarizedIonisation, G4hhIonisation, G4mplIonisation, and G4alphaIonisation.

Here is the caller graph for this function:

◆ PrintInfoDefinition()

void G4VEnergyLossProcess::PrintInfoDefinition ( const G4ParticleDefinition & part )

Definition at line 969 of file G4VEnergyLossProcess.cc.

 {
   if(0 < verboseLevel) {
     G4cout << std::setprecision(6);
     G4cout << G4endl << GetProcessName() << ":   for  "
            << part.GetParticleName()
            << "    SubType= " << GetProcessSubType() 
            << G4endl;
     G4cout << "      dE/dx and range tables from "
             << G4BestUnit(minKinEnergy,"Energy")
            << " to " << G4BestUnit(maxKinEnergy,"Energy")
            << " in " << nBins << " bins" << G4endl
            << "      Lambda tables from threshold to "
            << G4BestUnit(maxKinEnergy,"Energy")
            << ", " << theParameters->NumberOfBinsPerDecade() 
            << " bins per decade, spline: " 
            << theParameters->Spline()
            << G4endl;
     if(theRangeTableForLoss && isIonisation) {
       G4cout << "      finalRange(mm)= " << finalRange/mm
              << ", dRoverRange= " << dRoverRange
              << ", integral: " << integral
              << ", fluct: " << lossFluctuationFlag
              << ", linLossLimit= " << linLossLimit
              << G4endl;
     }
     PrintInfo();
     modelManager->DumpModelList(verboseLevel);
     if(theCSDARangeTable && isIonisation) {
       G4cout << "      CSDA range table up"
              << " to " << G4BestUnit(maxKinEnergyCSDA,"Energy")
              << " in " << nBinsCSDA << " bins" << G4endl;
     }
     if(nSCoffRegions>0 && isIonisation) {
       G4cout << "      Subcutoff sampling in " << nSCoffRegions 
              << " regions" << G4endl;
     }
     if(2 < verboseLevel) {
       G4cout << "      DEDXTable address= " << theDEDXTable << G4endl;
       if(theDEDXTable && isIonisation) G4cout << (*theDEDXTable) << G4endl;
       G4cout << "non restricted DEDXTable address= " 
              << theDEDXunRestrictedTable << G4endl;
       if(theDEDXunRestrictedTable && isIonisation) {
            G4cout << (*theDEDXunRestrictedTable) << G4endl;
       }
       if(theDEDXSubTable && isIonisation) {
         G4cout << (*theDEDXSubTable) << G4endl;
       }
       G4cout << "      CSDARangeTable address= " << theCSDARangeTable 
              << G4endl;
       if(theCSDARangeTable && isIonisation) {
         G4cout << (*theCSDARangeTable) << G4endl;
       }
       G4cout << "      RangeTableForLoss address= " << theRangeTableForLoss 
              << G4endl;
       if(theRangeTableForLoss && isIonisation) {
              G4cout << (*theRangeTableForLoss) << G4endl;
       }
       G4cout << "      InverseRangeTable address= " << theInverseRangeTable 
              << G4endl;
       if(theInverseRangeTable && isIonisation) {
              G4cout << (*theInverseRangeTable) << G4endl;
       }
       G4cout << "      LambdaTable address= " << theLambdaTable << G4endl;
       if(theLambdaTable && isIonisation) {
         G4cout << (*theLambdaTable) << G4endl;
       }
       G4cout << "      SubLambdaTable address= " << theSubLambdaTable 
              << G4endl;
       if(theSubLambdaTable && isIonisation) {
         G4cout << (*theSubLambdaTable) << G4endl;
       }
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintWarning()

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

private

Definition at line 2405 of file G4VEnergyLossProcess.cc.

 {
   G4String ss = "G4VEnergyLossProcess::" + tit; 
   G4ExceptionDescription ed;
   ed << "Parameter is out of range: " << val 
      << " it will have no effect!\n" << "  Process " 
      << GetProcessName() << "  nbins= " << nBins 
      << " Emin(keV)= " << minKinEnergy/keV 
      << " Emax(GeV)= " << maxKinEnergy/GeV;
   G4Exception(ss, "em0044", JustWarning, ed);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ProcessDescription()

void G4VEnergyLossProcess::ProcessDescription ( std::ostream & outFile ) const

virtual

Definition at line 2419 of file G4VEnergyLossProcess.cc.

 {
   outFile << "Energy loss process <" << GetProcessName() << ">" << G4endl;
 }

Here is the call graph for this function:

◆ RangeTableForLoss()

G4PhysicsTable * G4VEnergyLossProcess::RangeTableForLoss ( ) const

inline

Definition at line 1052 of file G4VEnergyLossProcess.hh.

 {
   return theRangeTableForLoss;
 }

Here is the caller graph for this function:

◆ RetrievePhysicsTable()

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

virtual

Reimplemented from G4VProcess.

Definition at line 1814 of file G4VEnergyLossProcess.cc.

 {
   G4bool res = true;
   if (!isMaster) return res;
   const G4String particleName = part->GetParticleName();
 
   if(1 < verboseLevel) {
     G4cout << "G4VEnergyLossProcess::RetrievePhysicsTable() for "
            << particleName << " and process " << GetProcessName()
            << "; tables_are_built= " << tablesAreBuilt
            << G4endl;
   }
   if(particle == part) {
 
     if ( !baseParticle ) {
 
       G4bool fpi = true;
       if(!RetrieveTable(part,theDEDXTable,ascii,directory,"DEDX",fpi)) 
         {fpi = false;}
 
       // ionisation table keeps individual dEdx and not sum of sub-processes
       if(!RetrieveTable(part,theDEDXTable,ascii,directory,"Ionisation",false)) 
         {fpi = false;}
 
       if(!RetrieveTable(part,theRangeTableForLoss,ascii,directory,"Range",fpi)) 
         {res = false;}
 
       if(!RetrieveTable(part,theDEDXunRestrictedTable,ascii,directory,
                         "DEDXnr",false)) 
         {res = false;}
 
       if(!RetrieveTable(part,theCSDARangeTable,ascii,directory,
                         "CSDARange",false)) 
         {res = false;}
 
       if(!RetrieveTable(part,theInverseRangeTable,ascii,directory,
                         "InverseRange",fpi)) 
         {res = false;}
 
       if(!RetrieveTable(part,theLambdaTable,ascii,directory,"Lambda",true)) 
         {res = false;}
 
       G4bool yes = false;
       if(nSCoffRegions > 0) {yes = true;}
 
       if(!RetrieveTable(part,theDEDXSubTable,ascii,directory,"SubDEDX",yes)) 
         {res = false;}
 
       if(!RetrieveTable(part,theSubLambdaTable,ascii,directory,
                         "SubLambda",yes)) 
         {res = false;}
 
       if(!fpi) yes = false;
       if(!RetrieveTable(part,theIonisationSubTable,ascii,directory,
                         "SubIonisation",yes))
         {res = false;}
     }
   }
 
   return res;
 }

Here is the call graph for this function:

◆ RetrieveTable()

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

private

Definition at line 1900 of file G4VEnergyLossProcess.cc.

 {
   G4bool isRetrieved = false;
   G4String filename = GetPhysicsTableFileName(part,directory,tname,ascii);
   if(aTable) {
     if(aTable->ExistPhysicsTable(filename)) {
       if(G4PhysicsTableHelper::RetrievePhysicsTable(aTable,filename,ascii)) {
         isRetrieved = true;
         if(theParameters->Spline()) {
           size_t n = aTable->length();
           for(size_t i=0; i<n; ++i) {
             if((*aTable)[i]) { (*aTable)[i]->SetSpline(true); }
           }
         }
         if (0 < verboseLevel) {
           G4cout << tname << " table for " << part->GetParticleName() 
                  << " is Retrieved from <" << filename << ">"
                  << G4endl;
         }
       }
     }
   }
   if(mandatory && !isRetrieved) {
     if(0 < verboseLevel) {
       G4cout << tname << " table for " << part->GetParticleName() 
              << " from file <"
              << filename << "> is not Retrieved"
              << G4endl;
     }
     return false;
   }
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SampleSubCutSecondaries()

G4double G4VEnergyLossProcess::SampleSubCutSecondaries	(	std::vector< G4Track *> &	tracks,
		const G4Step &	step,
		G4VEmModel *	model,
		G4int	matIdx
	)

Definition at line 1537 of file G4VEnergyLossProcess.cc.

 {
   // Fast check weather subcutoff can work
   G4double esec = 0.0;
   G4double subcut = (*theSubCuts)[idx];
   G4double cut = (*theCuts)[idx];
   if(cut <= subcut) { return esec; }
 
   const G4Track* track = step.GetTrack();
   const G4DynamicParticle* dp = track->GetDynamicParticle();
   G4double e = dp->GetKineticEnergy()*massRatio;
   G4double cross = (*theDensityFactor)[idx]*chargeSqRatio
     *(((*theSubLambdaTable)[(*theDensityIdx)[idx]])->Value(e, idxSubLambda));
   G4double length = step.GetStepLength();
 
   // negligible probability to get any interaction
   if(length*cross < perMillion) { return esec; }
   /*      
   if(-1 < verboseLevel) 
     G4cout << "<<< Subcutoff for " << GetProcessName()
            << " cross(1/mm)= " << cross*mm << ">>>"
            << " e(MeV)= " << preStepScaledEnergy
            << " matIdx= " << currentCoupleIndex
            << G4endl;
   */
 
   // Sample subcutoff secondaries
   G4StepPoint* preStepPoint = step.GetPreStepPoint();
   G4StepPoint* postStepPoint = step.GetPostStepPoint();
   G4ThreeVector prepoint = preStepPoint->GetPosition();
   G4ThreeVector dr = postStepPoint->GetPosition() - prepoint;
   G4double pretime = preStepPoint->GetGlobalTime();
   G4double dt = postStepPoint->GetGlobalTime() - pretime;
   //G4double dt = length/preStepPoint->GetVelocity();
   G4double fragment = 0.0;
 
   do {
     G4double del = -G4Log(G4UniformRand())/cross;
     fragment += del/length;
     if (fragment > 1.0) { break; }
 
     // sample secondaries
     secParticles.clear();
     model->SampleSecondaries(&secParticles,track->GetMaterialCutsCouple(),
                              dp,subcut,cut);
 
     // position of subcutoff particles
     G4ThreeVector r = prepoint + fragment*dr;
     std::vector<G4DynamicParticle*>::iterator it;
     for(it=secParticles.begin(); it!=secParticles.end(); ++it) {
 
       G4Track* t = new G4Track((*it), pretime + fragment*dt, r);
       t->SetTouchableHandle(track->GetTouchableHandle());
       t->SetCreatorModelIndex(subsecID);
       tracks.push_back(t);
       esec += t->GetKineticEnergy();
       if (t->GetParticleDefinition() == thePositron) { 
         esec += 2.0*electron_mass_c2; 
       }
 
         /*        
         if(-1 < verboseLevel) 
           G4cout << "New track " 
                  << t->GetParticleDefinition()->GetParticleName()
                  << " e(keV)= " << t->GetKineticEnergy()/keV
                  << " fragment= " << fragment
                  << G4endl;
         */
     }
     // Loop checking, 03-Aug-2015, Vladimir Ivanchenko
   } while (fragment <= 1.0);
   return esec;
 } 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ScaledKinEnergyForLoss()

G4double G4VEnergyLossProcess::ScaledKinEnergyForLoss ( G4double range )

inlineprivate

Definition at line 743 of file G4VEnergyLossProcess.hh.

 {
   //G4cout << "G4VEnergyLossProcess::GetEnergy: Idx= " 
   //         << basedCoupleIndex << " R(mm)= " << r << "  " 
   //         << theInverseRangeTable << G4endl; 
   G4PhysicsVector* v = (*theInverseRangeTable)[basedCoupleIndex];
   G4double rmin = v->Energy(0);
   G4double e = 0.0; 
   if(r >= rmin) { e = v->Value(r, idxInverseRange); }
   else if(r > 0.0) {
     G4double x = r/rmin;
     e = minKinEnergy*x*x;
   }
   return e;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SecondaryParticle()

const G4ParticleDefinition * G4VEnergyLossProcess::SecondaryParticle ( ) const

inline

Definition at line 933 of file G4VEnergyLossProcess.hh.

 {
   return secondaryParticle;
 }

Here is the caller graph for this function:

◆ SecondaryRangeTable()

G4PhysicsTable * G4VEnergyLossProcess::SecondaryRangeTable ( ) const

inline

Definition at line 1045 of file G4VEnergyLossProcess.hh.

 {
   return theSecondaryRangeTable;
 }

Here is the caller graph for this function:

◆ SelectModel()

void G4VEnergyLossProcess::SelectModel ( G4double kinEnergy )

inlineprotected

Definition at line 617 of file G4VEnergyLossProcess.hh.

 {
   currentModel = modelManager->SelectModel(kinEnergy, currentCoupleIndex);
   currentModel->SetCurrentCouple(currentCouple);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SelectModelForMaterial()

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

inline

Definition at line 625 of file G4VEnergyLossProcess.hh.

 {
   return modelManager->SelectModel(kinEnergy, idx);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetBaseParticle()

void G4VEnergyLossProcess::SetBaseParticle ( const G4ParticleDefinition * p )

inline

Definition at line 911 of file G4VEnergyLossProcess.hh.

 {
   baseParticle = p;
 }

Here is the caller graph for this function:

◆ SetCrossSectionBiasingFactor()

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

Definition at line 2267 of file G4VEnergyLossProcess.cc.

 {
   if(f > 0.0) { 
     biasFactor = f; 
     weightFlag = flag;
     if(1 < verboseLevel) {
       G4cout << "### SetCrossSectionBiasingFactor: for " 
              << " process " << GetProcessName()
              << " biasFactor= " << f << " weightFlag= " << flag 
              << G4endl; 
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetCSDARangeTable()

void G4VEnergyLossProcess::SetCSDARangeTable ( G4PhysicsTable * pRange )

Definition at line 2122 of file G4VEnergyLossProcess.cc.

 {
   theCSDARangeTable = p; 
 
   if(p) {
     size_t n = p->length();
     G4PhysicsVector* pv;
     G4double emax = maxKinEnergyCSDA;
 
     for (size_t i=0; i<n; ++i) {
       pv = (*p)[i];
       G4double rmax = 0.0;
       if(pv) { rmax = pv->Value(emax, idxCSDA); }
       else {
         pv = (*p)[(*theDensityIdx)[i]];
         if(pv) { rmax = pv->Value(emax, idxCSDA)/(*theDensityFactor)[i]; }
       }
       theRangeAtMaxEnergy[i] = rmax;
       //G4cout << "i= " << i << " Emax(MeV)= " << emax/MeV << " Rmax= " 
       //<< rmax<< G4endl;
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetDEDXBinning()

void G4VEnergyLossProcess::SetDEDXBinning ( G4int nbins )

Definition at line 2371 of file G4VEnergyLossProcess.cc.

 {
   if(2 < n && n < 1000000000) { 
     nBins = n; 
     actBinning = true;
   } else {
     G4double e = (G4double)n;
     PrintWarning("SetDEDXBinning", e); 
   } 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetDEDXTable()

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

Definition at line 2061 of file G4VEnergyLossProcess.cc.

 {
   if(fTotal == tType) {
     theDEDXunRestrictedTable = p;
     if(p) {
       size_t n = p->length();
       G4PhysicsVector* pv = (*p)[0];
       G4double emax = maxKinEnergyCSDA;
 
       G4LossTableBuilder* bld = lManager->GetTableBuilder();
       theDensityFactor = bld->GetDensityFactors();
       theDensityIdx = bld->GetCoupleIndexes();
 
       for (size_t i=0; i<n; ++i) {
         G4double dedx = 0.0; 
         pv = (*p)[i];
         if(pv) { 
           dedx = pv->Value(emax, idxDEDXunRestricted); 
         } else {
           pv = (*p)[(*theDensityIdx)[i]];
           if(pv) { 
             dedx = 
               pv->Value(emax, idxDEDXunRestricted)*(*theDensityFactor)[i]; 
           }
         }
         theDEDXAtMaxEnergy[i] = dedx;
         //G4cout << "i= " << i << " emax(MeV)= " << emax/MeV<< " dedx= " 
         //     << dedx << G4endl;
       }
     }
 
   } else if(fRestricted == tType) {
     /*
       G4cout<< "G4VEnergyLossProcess::SetDEDXTable "
             << particle->GetParticleName()
             << " oldTable " << theDEDXTable << " newTable " << p 
             << " ion " << theIonisationTable 
             << " IsMaster " << isMaster 
             << " " << GetProcessName() << G4endl;
       G4cout << (*p) << G4endl;
     */
     theDEDXTable = p;
   } else if(fSubRestricted == tType) {
       theDEDXSubTable = p;
   } else if(fIsIonisation == tType) {
     /*
       G4cout<< "G4VEnergyLossProcess::SetIonisationTable "
             << particle->GetParticleName()
             << " oldTable " << theDEDXTable << " newTable " << p 
             << " ion " << theIonisationTable 
             << " IsMaster " << isMaster 
             << " " << GetProcessName() << G4endl;
     */
     theIonisationTable = p;
   } else if(fIsSubIonisation == tType) {
     theIonisationSubTable = p;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetDynamicMassCharge()

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

inline

Definition at line 650 of file G4VEnergyLossProcess.hh.

 {
   massRatio     = massratio;
   fFactor = charge2ratio*biasFactor*(*theDensityFactor)[currentCoupleIndex];
   chargeSqRatio = charge2ratio;
   reduceFactor  = 1.0/(fFactor*massRatio);
 }

Here is the caller graph for this function:

◆ SetEmModel()

void G4VEnergyLossProcess::SetEmModel	(	G4VEmModel *	p,
		G4int	index = `1`
	)

Definition at line 411 of file G4VEnergyLossProcess.cc.

 {
   G4int n = emModels.size();
   if(index >= n) { for(G4int i=n; i<=index; ++i) {emModels.push_back(0);} }
   emModels[index] = p;
 }

Here is the caller graph for this function:

◆ SetFluctModel()

void G4VEnergyLossProcess::SetFluctModel ( G4VEmFluctuationModel * p )

inline

Definition at line 881 of file G4VEnergyLossProcess.hh.

 {
   fluctModel = p;
 }

Here is the caller graph for this function:

◆ SetIntegral()

void G4VEnergyLossProcess::SetIntegral ( G4bool val )

inline

Definition at line 947 of file G4VEnergyLossProcess.hh.

 {
   integral = val;
 }

Here is the caller graph for this function:

◆ SetInverseRangeTable()

void G4VEnergyLossProcess::SetInverseRangeTable ( G4PhysicsTable * p )

Definition at line 2172 of file G4VEnergyLossProcess.cc.

 {
   theInverseRangeTable = p;
   if(1 < verboseLevel) {
     G4cout << "### Set InverseRange table " << p 
            << " for " << particle->GetParticleName()
            << " and process " << GetProcessName() << G4endl;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetIonisation()

void G4VEnergyLossProcess::SetIonisation ( G4bool val )

Definition at line 2330 of file G4VEnergyLossProcess.cc.

 {
   isIonisation = val;
   if(val) { aGPILSelection = CandidateForSelection; }
   else    { aGPILSelection = NotCandidateForSelection; }
 }

Here is the caller graph for this function:

◆ SetLambdaTable()

void G4VEnergyLossProcess::SetLambdaTable ( G4PhysicsTable * p )

Definition at line 2184 of file G4VEnergyLossProcess.cc.

 {
   if(1 < verboseLevel) {
     G4cout << "### Set Lambda table " << p 
            << " for " << particle->GetParticleName()
            << " and process " << GetProcessName() << G4endl;
     //G4cout << *p << G4endl;
   }
   theLambdaTable = p; 
   tablesAreBuilt = true;
 
   G4LossTableBuilder* bld = lManager->GetTableBuilder();
   theDensityFactor = bld->GetDensityFactors();
   theDensityIdx = bld->GetCoupleIndexes();
 
   if(theLambdaTable) {
     size_t n = theLambdaTable->length();
     G4PhysicsVector* pv = (*theLambdaTable)[0];
     G4double e, ss, smax, emax;
 
     size_t i;
 
     // first loop on existing vectors
     for (i=0; i<n; ++i) {
       pv = (*theLambdaTable)[i];
       if(pv) {
         size_t nb = pv->GetVectorLength();
         emax = DBL_MAX;
         smax = 0.0;
         if(nb > 0) {
           for (size_t j=0; j<nb; ++j) {
             e = pv->Energy(j);
             ss = (*pv)(j);
             if(ss > smax) {
               smax = ss;
               emax = e;
             }
           }
         }
         theEnergyOfCrossSectionMax[i] = emax;
         theCrossSectionMax[i] = smax;
         if(1 < verboseLevel) {
           G4cout << "For " << particle->GetParticleName() 
                  << " Max CS at i= " << i << " emax(MeV)= " << emax/MeV
                  << " lambda= " << smax << G4endl;
         }
       }
     }
     // second loop using base materials
     for (i=0; i<n; ++i) {
       pv = (*theLambdaTable)[i];
       if(!pv){
         G4int j = (*theDensityIdx)[i];
         theEnergyOfCrossSectionMax[i] = theEnergyOfCrossSectionMax[j];
         theCrossSectionMax[i] = (*theDensityFactor)[i]*theCrossSectionMax[j];
       }
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetLinearLossLimit()

void G4VEnergyLossProcess::SetLinearLossLimit ( G4double val )

Definition at line 2339 of file G4VEnergyLossProcess.cc.

 {
   if(0.0 < val && val < 1.0) { 
     linLossLimit = val;
     actLinLossLimit = true; 
   } else { PrintWarning("SetLinearLossLimit", val); }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetLossFluctuations()

void G4VEnergyLossProcess::SetLossFluctuations ( G4bool val )

inline

Definition at line 940 of file G4VEnergyLossProcess.hh.

 {
   lossFluctuationFlag = val;
 }

Here is the caller graph for this function:

◆ SetLowestEnergyLimit()

void G4VEnergyLossProcess::SetLowestEnergyLimit ( G4double val )

Definition at line 2363 of file G4VEnergyLossProcess.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetMaxKinEnergy()

void G4VEnergyLossProcess::SetMaxKinEnergy ( G4double e )

Definition at line 2394 of file G4VEnergyLossProcess.cc.

 {
   if(minKinEnergy < e && e < 1.e+50) { 
     maxKinEnergy = e;
     actMaxKinEnergy = true;
     if(e < maxKinEnergyCSDA) { maxKinEnergyCSDA = e; }
   } else { PrintWarning("SetMaxKinEnergy", e); } 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetMinKinEnergy()

void G4VEnergyLossProcess::SetMinKinEnergy ( G4double e )

Definition at line 2384 of file G4VEnergyLossProcess.cc.

 {
   if(1.e-18 < e && e < maxKinEnergy) { 
     minKinEnergy = e; 
     actMinKinEnergy = true;
   } else { PrintWarning("SetMinKinEnergy", e); } 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetParticle()

void G4VEnergyLossProcess::SetParticle ( const G4ParticleDefinition * p )

inlineprotected

Definition at line 895 of file G4VEnergyLossProcess.hh.

 {
   particle = p;
 }

◆ SetRangeTableForLoss()

void G4VEnergyLossProcess::SetRangeTableForLoss ( G4PhysicsTable * p )

Definition at line 2148 of file G4VEnergyLossProcess.cc.

 {
   theRangeTableForLoss = p;
   if(1 < verboseLevel) {
     G4cout << "### Set Range table " << p 
            << " for " << particle->GetParticleName()
            << " and process " << GetProcessName() << G4endl;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetSecondaryParticle()

void G4VEnergyLossProcess::SetSecondaryParticle ( const G4ParticleDefinition * p )

inlineprotected

Definition at line 903 of file G4VEnergyLossProcess.hh.

 {
   secondaryParticle = p;
 }

Here is the caller graph for this function:

◆ SetSecondaryRangeTable()

void G4VEnergyLossProcess::SetSecondaryRangeTable ( G4PhysicsTable * p )

Definition at line 2160 of file G4VEnergyLossProcess.cc.

 {
   theSecondaryRangeTable = p;
   if(1 < verboseLevel) {
     G4cout << "### Set SecondaryRange table " << p 
            << " for " << particle->GetParticleName()
            << " and process " << GetProcessName() << G4endl;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetStepFunction()

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

Definition at line 2349 of file G4VEnergyLossProcess.cc.

 {
   if(0.0 < v1 && 0.0 < v2 && v2 < 1.e+50) { 
     dRoverRange = std::min(1.0, v1);
     finalRange = v2;
   } else if(v1 <= 0.0) {
     PrintWarning("SetStepFunction", v1); 
   } else {
     PrintWarning("SetStepFunction", v2); 
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetSubLambdaTable()

void G4VEnergyLossProcess::SetSubLambdaTable ( G4PhysicsTable * p )

Definition at line 2246 of file G4VEnergyLossProcess.cc.

 {
   theSubLambdaTable = p;
   if(1 < verboseLevel) {
     G4cout << "### Set SebLambda table " << p 
            << " for " << particle->GetParticleName()
            << " and process " << GetProcessName() << G4endl;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StartTracking()

void G4VEnergyLossProcess::StartTracking ( G4Track * track )

virtual

Reimplemented from G4VProcess.

Definition at line 1073 of file G4VEnergyLossProcess.cc.

 {
   /*      
     G4cout << track->GetDefinition()->GetParticleName() 
            << " e(MeV)= " << track->GetKineticEnergy()
            << "  baseParticle " << baseParticle << " proc " << this;
     if(particle) G4cout << "  " << particle->GetParticleName();
     G4cout << " isIon= " << isIon << " dedx " << theDEDXTable <<G4endl;
   */
   // reset parameters for the new track
   theNumberOfInteractionLengthLeft = -1.0;
   currentInteractionLength = mfpKinEnergy = DBL_MAX; 
   preStepRangeEnergy = 0.0;
 
   // reset ion
   if(isIon) {
     chargeSqRatio = 0.5;
 
     G4double newmass = track->GetDefinition()->GetPDGMass();
     if(baseParticle) {
       massRatio = baseParticle->GetPDGMass()/newmass;
     } else if(theGenericIon) {
       massRatio = proton_mass_c2/newmass;
     } else {
       massRatio = 1.0;
     }
   }  
   // forced biasing only for primary particles
   if(biasManager) {
     if(0 == track->GetParentID()) {
       // primary particle
       biasFlag = true; 
       biasManager->ResetForcedInteraction(); 
     }
   }
 }

Here is the call graph for this function:

◆ StorePhysicsTable()

G4bool G4VEnergyLossProcess::StorePhysicsTable	(	const G4ParticleDefinition *	part,
		const G4String &	directory,
		G4bool	ascii = `false`
	)

virtual

Reimplemented from G4VProcess.

Definition at line 1751 of file G4VEnergyLossProcess.cc.

 {
   G4bool res = true;
   //G4cout << "G4VEnergyLossProcess::StorePhysicsTable: " << part->GetParticleName()
   //         << "  " << directory << "  " << ascii << G4endl;
   if (!isMaster || baseParticle || part != particle ) return res;
 
   if(!StoreTable(part,theDEDXTable,ascii,directory,"DEDX")) 
     {res = false;}
 
   if(!StoreTable(part,theDEDXunRestrictedTable,ascii,directory,"DEDXnr")) 
     {res = false;}
 
   if(!StoreTable(part,theDEDXSubTable,ascii,directory,"SubDEDX")) 
     {res = false;}
 
   if(!StoreTable(part,theIonisationTable,ascii,directory,"Ionisation")) 
     {res = false;}
 
   if(!StoreTable(part,theIonisationSubTable,ascii,directory,"SubIonisation")) 
     {res = false;}
 
   if(isIonisation &&
      !StoreTable(part,theCSDARangeTable,ascii,directory,"CSDARange")) 
     {res = false;}
 
   if(isIonisation &&
      !StoreTable(part,theRangeTableForLoss,ascii,directory,"Range")) 
     {res = false;}
   
   if(isIonisation &&
      !StoreTable(part,theInverseRangeTable,ascii,directory,"InverseRange")) 
     {res = false;}
   
   if(!StoreTable(part,theLambdaTable,ascii,directory,"Lambda")) 
     {res = false;}
 
   if(!StoreTable(part,theSubLambdaTable,ascii,directory,"SubLambda")) 
     {res = false;}
 
   if ( !res ) {
     if(1 < verboseLevel) {
       G4cout << "Physics tables are stored for " 
              << particle->GetParticleName()
              << " and process " << GetProcessName()
              << " in the directory <" << directory
              << "> " << G4endl;
     }
   } else {
     G4cout << "Fail to store Physics Tables for " 
            << particle->GetParticleName()
            << " and process " << GetProcessName()
            << " in the directory <" << directory
            << "> " << G4endl;
   }
   return res;
 }

Here is the call graph for this function:

◆ StoreTable()

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

private

Definition at line 1880 of file G4VEnergyLossProcess.cc.

 {
   //G4cout << "G4VEnergyLossProcess::StoreTable: " << aTable
   //         << "  " << directory << "  " << tname << G4endl;
   G4bool res = true;
   if ( aTable ) {
     const G4String name = GetPhysicsTableFileName(part,directory,tname,ascii);
     G4cout << name << G4endl;
     //G4cout << *aTable << G4endl;
     if( !aTable->StorePhysicsTable(name,ascii)) res = false;
   }
   return res;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SubLambdaTable()

G4PhysicsTable * G4VEnergyLossProcess::SubLambdaTable ( ) const

inline

Definition at line 1073 of file G4VEnergyLossProcess.hh.

 {
   return theSubLambdaTable;
 }

Here is the caller graph for this function:

◆ TablesAreBuilt()

G4bool G4VEnergyLossProcess::TablesAreBuilt ( ) const

inline

Definition at line 996 of file G4VEnergyLossProcess.hh.

 {
   return  tablesAreBuilt;
 }

◆ UpdateEmModel()

void G4VEnergyLossProcess::UpdateEmModel	(	const G4String &	nam,
		G4double	emin,
		G4double	emax
	)

Definition at line 403 of file G4VEnergyLossProcess.cc.

 {
   modelManager->UpdateEmModel(nam, emin, emax);
 }

Here is the call graph for this function:

Member Data Documentation

◆ actBinning

G4bool G4VEnergyLossProcess::actBinning

private

Definition at line 562 of file G4VEnergyLossProcess.hh.

◆ actLinLossLimit

G4bool G4VEnergyLossProcess::actLinLossLimit

private

Definition at line 560 of file G4VEnergyLossProcess.hh.

◆ actLossFluc

G4bool G4VEnergyLossProcess::actLossFluc

private

Definition at line 561 of file G4VEnergyLossProcess.hh.

◆ actMaxKinEnergy

G4bool G4VEnergyLossProcess::actMaxKinEnergy

private

Definition at line 564 of file G4VEnergyLossProcess.hh.

◆ actMinKinEnergy

G4bool G4VEnergyLossProcess::actMinKinEnergy

private

Definition at line 563 of file G4VEnergyLossProcess.hh.

◆ aGPILSelection

G4GPILSelection G4VEnergyLossProcess::aGPILSelection

private

Definition at line 601 of file G4VEnergyLossProcess.hh.

◆ atomDeexcitation

G4VAtomDeexcitation* G4VEnergyLossProcess::atomDeexcitation

private

Definition at line 488 of file G4VEnergyLossProcess.hh.

◆ basedCoupleIndex

size_t G4VEnergyLossProcess::basedCoupleIndex

private

Definition at line 583 of file G4VEnergyLossProcess.hh.

◆ baseParticle

const G4ParticleDefinition* G4VEnergyLossProcess::baseParticle

private

Definition at line 533 of file G4VEnergyLossProcess.hh.

◆ biasFactor

G4double G4VEnergyLossProcess::biasFactor

private

Definition at line 547 of file G4VEnergyLossProcess.hh.

◆ biasFlag

G4bool G4VEnergyLossProcess::biasFlag

private

Definition at line 557 of file G4VEnergyLossProcess.hh.

◆ biasID

G4int G4VEnergyLossProcess::biasID

private

Definition at line 605 of file G4VEnergyLossProcess.hh.

◆ biasManager

G4EmBiasingManager* G4VEnergyLossProcess::biasManager

private

Definition at line 474 of file G4VEnergyLossProcess.hh.

◆ chargeSqRatio

G4double G4VEnergyLossProcess::chargeSqRatio

private

Definition at line 591 of file G4VEnergyLossProcess.hh.

◆ computedRange

G4double G4VEnergyLossProcess::computedRange

private

Definition at line 595 of file G4VEnergyLossProcess.hh.

◆ currentCouple

const G4MaterialCutsCouple* G4VEnergyLossProcess::currentCouple

private

Definition at line 581 of file G4VEnergyLossProcess.hh.

◆ currentCoupleIndex

size_t G4VEnergyLossProcess::currentCoupleIndex

private

Definition at line 582 of file G4VEnergyLossProcess.hh.

◆ currentMaterial

const G4Material* G4VEnergyLossProcess::currentMaterial

private

Definition at line 580 of file G4VEnergyLossProcess.hh.

◆ currentModel

G4VEmModel* G4VEnergyLossProcess::currentModel

private

Definition at line 579 of file G4VEnergyLossProcess.hh.

◆ dRoverRange

G4double G4VEnergyLossProcess::dRoverRange

private

Definition at line 544 of file G4VEnergyLossProcess.hh.

◆ emModels

std::vector<G4VEmModel*> G4VEnergyLossProcess::emModels

private

Definition at line 486 of file G4VEnergyLossProcess.hh.

◆ fFactor

G4double G4VEnergyLossProcess::fFactor

private

Definition at line 589 of file G4VEnergyLossProcess.hh.

◆ finalRange

G4double G4VEnergyLossProcess::finalRange

private

Definition at line 545 of file G4VEnergyLossProcess.hh.

◆ fluctModel

G4VEmFluctuationModel* G4VEnergyLossProcess::fluctModel

private

Definition at line 487 of file G4VEnergyLossProcess.hh.

◆ fParticleChange

G4ParticleChangeForLoss G4VEnergyLossProcess::fParticleChange

protected

Definition at line 568 of file G4VEnergyLossProcess.hh.

◆ fRange

G4double G4VEnergyLossProcess::fRange

private

Definition at line 594 of file G4VEnergyLossProcess.hh.

◆ idxCSDA

size_t G4VEnergyLossProcess::idxCSDA

private

Definition at line 516 of file G4VEnergyLossProcess.hh.

◆ idxDEDX

size_t G4VEnergyLossProcess::idxDEDX

private

Definition at line 510 of file G4VEnergyLossProcess.hh.

◆ idxDEDXSub

size_t G4VEnergyLossProcess::idxDEDXSub

private

Definition at line 511 of file G4VEnergyLossProcess.hh.

◆ idxDEDXunRestricted

size_t G4VEnergyLossProcess::idxDEDXunRestricted

private

Definition at line 512 of file G4VEnergyLossProcess.hh.

◆ idxInverseRange

size_t G4VEnergyLossProcess::idxInverseRange

private

Definition at line 518 of file G4VEnergyLossProcess.hh.

◆ idxIonisation

size_t G4VEnergyLossProcess::idxIonisation

private

Definition at line 513 of file G4VEnergyLossProcess.hh.

◆ idxIonisationSub

size_t G4VEnergyLossProcess::idxIonisationSub

private

Definition at line 514 of file G4VEnergyLossProcess.hh.

◆ idxLambda

size_t G4VEnergyLossProcess::idxLambda

private

Definition at line 519 of file G4VEnergyLossProcess.hh.

◆ idxRange

size_t G4VEnergyLossProcess::idxRange

private

Definition at line 515 of file G4VEnergyLossProcess.hh.

◆ idxSCoffRegions

G4bool* G4VEnergyLossProcess::idxSCoffRegions

private

Definition at line 492 of file G4VEnergyLossProcess.hh.

◆ idxSecRange

size_t G4VEnergyLossProcess::idxSecRange

private

Definition at line 517 of file G4VEnergyLossProcess.hh.

◆ idxSubLambda

size_t G4VEnergyLossProcess::idxSubLambda

private

Definition at line 520 of file G4VEnergyLossProcess.hh.

◆ integral

G4bool G4VEnergyLossProcess::integral

private

Definition at line 552 of file G4VEnergyLossProcess.hh.

◆ isIon

G4bool G4VEnergyLossProcess::isIon

private

Definition at line 553 of file G4VEnergyLossProcess.hh.

◆ isIonisation

G4bool G4VEnergyLossProcess::isIonisation

private

Definition at line 554 of file G4VEnergyLossProcess.hh.

◆ isMaster

G4bool G4VEnergyLossProcess::isMaster

private

Definition at line 559 of file G4VEnergyLossProcess.hh.

◆ lambdaFactor

G4double G4VEnergyLossProcess::lambdaFactor

private

Definition at line 546 of file G4VEnergyLossProcess.hh.

◆ lastIdx

size_t G4VEnergyLossProcess::lastIdx

private

Definition at line 584 of file G4VEnergyLossProcess.hh.

◆ linLossLimit

G4double G4VEnergyLossProcess::linLossLimit

private

Definition at line 543 of file G4VEnergyLossProcess.hh.

◆ lManager

G4LossTableManager* G4VEnergyLossProcess::lManager

private

Definition at line 472 of file G4VEnergyLossProcess.hh.

◆ lossFluctuationFlag

G4bool G4VEnergyLossProcess::lossFluctuationFlag

private

Definition at line 549 of file G4VEnergyLossProcess.hh.

◆ lowestKinEnergy

G4double G4VEnergyLossProcess::lowestKinEnergy

private

Definition at line 538 of file G4VEnergyLossProcess.hh.

◆ massRatio

G4double G4VEnergyLossProcess::massRatio

private

Definition at line 588 of file G4VEnergyLossProcess.hh.

◆ maxKinEnergy

G4double G4VEnergyLossProcess::maxKinEnergy

private

Definition at line 540 of file G4VEnergyLossProcess.hh.

◆ maxKinEnergyCSDA

G4double G4VEnergyLossProcess::maxKinEnergyCSDA

private

Definition at line 541 of file G4VEnergyLossProcess.hh.

◆ mfpKinEnergy

G4double G4VEnergyLossProcess::mfpKinEnergy

private

Definition at line 599 of file G4VEnergyLossProcess.hh.

◆ minKinEnergy

G4double G4VEnergyLossProcess::minKinEnergy

private

Definition at line 539 of file G4VEnergyLossProcess.hh.

◆ modelManager

G4EmModelManager* G4VEnergyLossProcess::modelManager

private

Definition at line 473 of file G4VEnergyLossProcess.hh.

◆ nBins

G4int G4VEnergyLossProcess::nBins

private

Definition at line 535 of file G4VEnergyLossProcess.hh.

◆ nBinsCSDA

G4int G4VEnergyLossProcess::nBinsCSDA

private

Definition at line 536 of file G4VEnergyLossProcess.hh.

◆ nProcesses

G4int G4VEnergyLossProcess::nProcesses

private

Definition at line 495 of file G4VEnergyLossProcess.hh.

◆ nSCoffRegions

G4int G4VEnergyLossProcess::nSCoffRegions

private

Definition at line 491 of file G4VEnergyLossProcess.hh.

◆ nWarnings

G4int G4VEnergyLossProcess::nWarnings

private

Definition at line 586 of file G4VEnergyLossProcess.hh.

◆ particle

const G4ParticleDefinition* G4VEnergyLossProcess::particle

private

Definition at line 577 of file G4VEnergyLossProcess.hh.

◆ preStepKinEnergy

G4double G4VEnergyLossProcess::preStepKinEnergy

private

Definition at line 596 of file G4VEnergyLossProcess.hh.

◆ preStepLambda

G4double G4VEnergyLossProcess::preStepLambda

private

Definition at line 593 of file G4VEnergyLossProcess.hh.

◆ preStepRangeEnergy

G4double G4VEnergyLossProcess::preStepRangeEnergy

private

Definition at line 598 of file G4VEnergyLossProcess.hh.

◆ preStepScaledEnergy

G4double G4VEnergyLossProcess::preStepScaledEnergy

private

Definition at line 597 of file G4VEnergyLossProcess.hh.

◆ reduceFactor

G4double G4VEnergyLossProcess::reduceFactor

private

Definition at line 590 of file G4VEnergyLossProcess.hh.

◆ rndmStepFlag

G4bool G4VEnergyLossProcess::rndmStepFlag

private

Definition at line 550 of file G4VEnergyLossProcess.hh.

◆ safetyHelper

G4SafetyHelper* G4VEnergyLossProcess::safetyHelper

private

Definition at line 475 of file G4VEnergyLossProcess.hh.

◆ scoffRegions

std::vector<const G4Region*> G4VEnergyLossProcess::scoffRegions

private

Definition at line 490 of file G4VEnergyLossProcess.hh.

◆ scProcesses

std::vector<G4VEnergyLossProcess*> G4VEnergyLossProcess::scProcesses

private

Definition at line 494 of file G4VEnergyLossProcess.hh.

◆ scTracks

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

private

Definition at line 575 of file G4VEnergyLossProcess.hh.

◆ secID

G4int G4VEnergyLossProcess::secID

private

Definition at line 603 of file G4VEnergyLossProcess.hh.

◆ secondaryParticle

const G4ParticleDefinition* G4VEnergyLossProcess::secondaryParticle

private

Definition at line 478 of file G4VEnergyLossProcess.hh.

◆ secParticles

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

private

Definition at line 574 of file G4VEnergyLossProcess.hh.

◆ subcutProducer

G4VSubCutProducer* G4VEnergyLossProcess::subcutProducer

private

Definition at line 489 of file G4VEnergyLossProcess.hh.

◆ subsecID

G4int G4VEnergyLossProcess::subsecID

private

Definition at line 604 of file G4VEnergyLossProcess.hh.

◆ tablesAreBuilt

G4bool G4VEnergyLossProcess::tablesAreBuilt

private

Definition at line 551 of file G4VEnergyLossProcess.hh.

◆ theCrossSectionMax

std::vector<G4double> G4VEnergyLossProcess::theCrossSectionMax

private

Definition at line 525 of file G4VEnergyLossProcess.hh.

◆ theCSDARangeTable

G4PhysicsTable* G4VEnergyLossProcess::theCSDARangeTable

private

Definition at line 504 of file G4VEnergyLossProcess.hh.

◆ theCuts

const G4DataVector* G4VEnergyLossProcess::theCuts

private

Definition at line 530 of file G4VEnergyLossProcess.hh.

◆ theDEDXAtMaxEnergy

std::vector<G4double> G4VEnergyLossProcess::theDEDXAtMaxEnergy

private

Definition at line 522 of file G4VEnergyLossProcess.hh.

◆ theDEDXSubTable

G4PhysicsTable* G4VEnergyLossProcess::theDEDXSubTable

private

Definition at line 499 of file G4VEnergyLossProcess.hh.

◆ theDEDXTable

G4PhysicsTable* G4VEnergyLossProcess::theDEDXTable

private

Definition at line 498 of file G4VEnergyLossProcess.hh.

◆ theDEDXunRestrictedTable

G4PhysicsTable* G4VEnergyLossProcess::theDEDXunRestrictedTable

private

Definition at line 500 of file G4VEnergyLossProcess.hh.

◆ theDensityFactor

const std::vector<G4double>* G4VEnergyLossProcess::theDensityFactor

private

Definition at line 527 of file G4VEnergyLossProcess.hh.

◆ theDensityIdx

const std::vector<G4int>* G4VEnergyLossProcess::theDensityIdx

private

Definition at line 528 of file G4VEnergyLossProcess.hh.

◆ theElectron

const G4ParticleDefinition* G4VEnergyLossProcess::theElectron

private

Definition at line 479 of file G4VEnergyLossProcess.hh.

◆ theEnergyOfCrossSectionMax

std::vector<G4double> G4VEnergyLossProcess::theEnergyOfCrossSectionMax

private

Definition at line 524 of file G4VEnergyLossProcess.hh.

◆ theGamma

const G4ParticleDefinition* G4VEnergyLossProcess::theGamma

private

Definition at line 481 of file G4VEnergyLossProcess.hh.

◆ theGenericIon

const G4ParticleDefinition* G4VEnergyLossProcess::theGenericIon

private

Definition at line 482 of file G4VEnergyLossProcess.hh.

◆ theInverseRangeTable

G4PhysicsTable* G4VEnergyLossProcess::theInverseRangeTable

private

Definition at line 506 of file G4VEnergyLossProcess.hh.

◆ theIonisationSubTable

G4PhysicsTable* G4VEnergyLossProcess::theIonisationSubTable

private

Definition at line 502 of file G4VEnergyLossProcess.hh.

◆ theIonisationTable

G4PhysicsTable* G4VEnergyLossProcess::theIonisationTable

private

Definition at line 501 of file G4VEnergyLossProcess.hh.

◆ theLambdaTable

G4PhysicsTable* G4VEnergyLossProcess::theLambdaTable

private

Definition at line 507 of file G4VEnergyLossProcess.hh.

◆ theParameters

G4EmParameters* G4VEnergyLossProcess::theParameters

private

Definition at line 476 of file G4VEnergyLossProcess.hh.

◆ thePositron

const G4ParticleDefinition* G4VEnergyLossProcess::thePositron

private

Definition at line 480 of file G4VEnergyLossProcess.hh.

◆ theRangeAtMaxEnergy

std::vector<G4double> G4VEnergyLossProcess::theRangeAtMaxEnergy

private

Definition at line 523 of file G4VEnergyLossProcess.hh.

◆ theRangeTableForLoss

G4PhysicsTable* G4VEnergyLossProcess::theRangeTableForLoss

private

Definition at line 503 of file G4VEnergyLossProcess.hh.

◆ theSecondaryRangeTable

G4PhysicsTable* G4VEnergyLossProcess::theSecondaryRangeTable

private

Definition at line 505 of file G4VEnergyLossProcess.hh.

◆ theSubCuts

const G4DataVector* G4VEnergyLossProcess::theSubCuts

private

Definition at line 531 of file G4VEnergyLossProcess.hh.

◆ theSubLambdaTable

G4PhysicsTable* G4VEnergyLossProcess::theSubLambdaTable

private

Definition at line 508 of file G4VEnergyLossProcess.hh.

◆ useDeexcitation

G4bool G4VEnergyLossProcess::useDeexcitation

private

Definition at line 556 of file G4VEnergyLossProcess.hh.

◆ useSubCutoff

G4bool G4VEnergyLossProcess::useSubCutoff

private

Definition at line 555 of file G4VEnergyLossProcess.hh.

◆ weightFlag

G4bool G4VEnergyLossProcess::weightFlag

private

Definition at line 558 of file G4VEnergyLossProcess.hh.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4VEnergyLossProcess() [1/2]

◆ ~G4VEnergyLossProcess()

◆ G4VEnergyLossProcess() [2/2]

Member Function Documentation

◆ ActivateForcedInteraction()

◆ ActivateSecondaryBiasing()

◆ ActivateSubCutoff()

◆ AddCollaborativeProcess()

◆ AddEmModel()

◆ AlongStepDoIt()

◆ AlongStepGetPhysicalInteractionLength()

◆ BaseParticle()

◆ BuildDEDXTable()

◆ BuildLambdaTable()

◆ BuildPhysicsTable()

◆ Clean()

◆ ComputeLambdaForScaledEnergy()

◆ ContinuousStepLimit()

◆ CrossSectionBiasingFactor()

◆ CrossSectionPerVolume()

◆ CSDARangeTable()

◆ CurrentMaterialCutsCoupleIndex()

◆ DEDXTable()

◆ DEDXTableForSubsec()

◆ DEDXunRestrictedTable()

◆ DefineMaterial()

◆ EmModel()

◆ FillSecondariesAlongStep()

◆ FluctModel()

◆ GetContinuousStepLimit()

◆ GetCSDARange()

◆ GetCurrentElement()

◆ GetDEDX()

◆ GetDEDXDispersion()

◆ GetDEDXForScaledEnergy()

◆ GetDEDXForSubsec()

◆ GetIonisationForScaledEnergy()

◆ GetKineticEnergy()

◆ GetLambda()

◆ GetLambdaForScaledEnergy()

◆ GetLimitScaledRangeForScaledEnergy()

◆ GetMeanFreePath()

◆ GetModelByIndex()

◆ GetRange()

◆ GetRangeForLoss()

◆ GetScaledRangeForScaledEnergy()

◆ GetSubDEDXForScaledEnergy()

◆ GetSubIonisationForScaledEnergy()

◆ InitialiseEnergyLossProcess()

◆ InverseRangeTable()

◆ IonisationTable()

◆ IonisationTableForSubsec()

◆ IsApplicable()

◆ IsIntegral()

◆ IsIonisationProcess()

◆ LambdaPhysicsVector()

◆ LambdaTable()

◆ MaxKinEnergy()

◆ MeanFreePath()

◆ MinKinEnergy()

◆ MinPrimaryEnergy()

◆ NumberOfModels()

◆ NumberOfSubCutoffRegions()

◆ operator=()

◆ Particle()

◆ PostStepDoIt()

◆ PostStepGetPhysicalInteractionLength()

◆ PreparePhysicsTable()

◆ PrintInfo()

◆ PrintInfoDefinition()

◆ PrintWarning()

◆ ProcessDescription()