#include <G4VEnergyLossProcess.hh>

Inheritance diagram for G4VEnergyLossProcess:

Public Member Functions
void	ActivateForcedInteraction (G4double length, const G4String &region, G4bool flag=true)

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

void	ActivateSubCutoff (const G4Region *region)

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

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

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

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

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

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

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

const G4ParticleDefinition *	BaseParticle () const

G4PhysicsTable *	BuildDEDXTable (G4EmTableType tType=fRestricted)

G4PhysicsTable *	BuildLambdaTable (G4EmTableType tType=fRestricted)

void	BuildPhysicsTable (const G4ParticleDefinition &) override

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

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

G4double	CrossSectionBiasingFactor () const

G4double	CrossSectionPerVolume (G4double kineticEnergy, const G4MaterialCutsCouple *couple)

G4double	CrossSectionPerVolume (G4double kineticEnergy, const G4MaterialCutsCouple *couple, G4double logKineticEnergy)

G4CrossSectionType	CrossSectionType () const

G4PhysicsTable *	CSDARangeTable () const

G4PhysicsTable *	DEDXTable () const

G4PhysicsTable *	DEDXunRestrictedTable () const

virtual void	DumpInfo () const

G4VEmModel *	EmModel (size_t index=0) const

virtual void	EndTracking ()

G4VEmFluctuationModel *	FluctModel () const

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

	G4VEnergyLossProcess (G4VEnergyLossProcess &)=delete

G4double	GetCSDADEDX (G4double kineticEnergy, const G4MaterialCutsCouple *)

G4double	GetCSDARange (G4double kineticEnergy, const G4MaterialCutsCouple *)

const G4Element *	GetCurrentElement () const

G4double	GetCurrentInteractionLength () const

G4double	GetDEDX (G4double kineticEnergy, const G4MaterialCutsCouple *)

G4double	GetDEDX (G4double kineticEnergy, const G4MaterialCutsCouple *, G4double logKineticEnergy)

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

G4double	GetKineticEnergy (G4double range, const G4MaterialCutsCouple *)

G4double	GetLambda (G4double kineticEnergy, const G4MaterialCutsCouple *)

G4double	GetLambda (G4double kineticEnergy, const G4MaterialCutsCouple *, G4double logKineticEnergy)

const G4VProcess *	GetMasterProcess () const

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

G4double	GetNumberOfInteractionLengthLeft () const

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

G4double	GetPILfactor () const

virtual const G4ProcessManager *	GetProcessManager ()

const G4String &	GetProcessName () const

G4int	GetProcessSubType () const

G4ProcessType	GetProcessType () const

G4double	GetRange (G4double kineticEnergy, const G4MaterialCutsCouple *)

G4double	GetRange (G4double kineticEnergy, const G4MaterialCutsCouple *, G4double logKineticEnergy)

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4int	GetVerboseLevel () const

G4PhysicsTable *	InverseRangeTable () const

G4PhysicsTable *	IonisationTable () const

G4bool	isAlongStepDoItIsEnabled () const

virtual G4bool	IsApplicable (const G4ParticleDefinition &)

G4bool	isAtRestDoItIsEnabled () const

G4bool	IsIonisationProcess () const

G4bool	isPostStepDoItIsEnabled () const

G4PhysicsTable *	LambdaTable () const

G4double	MaxKinEnergy () const

G4double	MeanFreePath (const G4Track &track)

G4double	MinKinEnergy () const

size_t	NumberOfModels () const

G4int	NumberOfSubCutoffRegions () const

G4bool	operator!= (const G4VProcess &right) const

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

G4bool	operator== (const G4VProcess &right) const

const G4ParticleDefinition *	Particle () const

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

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

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

void	PreparePhysicsTable (const G4ParticleDefinition &) override

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

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

G4PhysicsTable *	RangeTableForLoss () const

virtual void	ResetNumberOfInteractionLengthLeft ()

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

const G4ParticleDefinition *	SecondaryParticle () const

G4PhysicsTable *	SecondaryRangeTable () const

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

void	SetBaseParticle (const G4ParticleDefinition *p)

void	SetCrossSectionBiasingFactor (G4double f, G4bool flag=true)

void	SetCrossSectionType (G4CrossSectionType val)

void	SetCSDARangeTable (G4PhysicsTable *pRange)

void	SetDEDXBinning (G4int nbins)

void	SetDEDXTable (G4PhysicsTable *p, G4EmTableType tType)

void	SetDynamicMassCharge (G4double massratio, G4double charge2ratio)

void	SetEmModel (G4VEmModel *, G4int index=0)

void	SetFluctModel (G4VEmFluctuationModel *)

void	SetInverseRangeTable (G4PhysicsTable *p)

void	SetIonisation (G4bool val)

void	SetLambdaTable (G4PhysicsTable *p)

void	SetLinearLossLimit (G4double val)

void	SetLossFluctuations (G4bool val)

void	SetLowestEnergyLimit (G4double)

virtual void	SetMasterProcess (G4VProcess *masterP)

void	SetMaxKinEnergy (G4double e)

void	SetMinKinEnergy (G4double e)

void	SetPILfactor (G4double value)

virtual void	SetProcessManager (const G4ProcessManager *)

void	SetProcessSubType (G4int)

void	SetProcessType (G4ProcessType)

void	SetRangeTableForLoss (G4PhysicsTable *p)

void	SetSecondaryRangeTable (G4PhysicsTable *p)

void	SetSpline (G4bool val)

void	SetStepFunction (G4double v1, G4double v2)

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

void	SetVerboseLevel (G4int value)

void	StartTracking (G4Track *) override

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

G4bool	TablesAreBuilt () const

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

G4bool	UseBaseMaterial () const

	~G4VEnergyLossProcess () override

Static Public Member Functions
static const G4String &	GetProcessTypeName (G4ProcessType)

Protected Member Functions
void	ClearNumberOfInteractionLengthLeft ()

size_t	CurrentMaterialCutsCoupleIndex () const

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

G4GPILSelection	GetGPILSelection () const

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

virtual void	InitialiseEnergyLossProcess (const G4ParticleDefinition , const G4ParticleDefinition )=0

G4PhysicsVector *	LambdaPhysicsVector (const G4MaterialCutsCouple *, G4double cut)

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

void	SelectModel (G4double kinEnergy)

void	SetGPILSelection (G4GPILSelection selection)

void	SetParticle (const G4ParticleDefinition *p)

void	SetSecondaryParticle (const G4ParticleDefinition *p)

virtual void	StreamProcessInfo (std::ostream &) const

void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)

Protected Attributes
G4ParticleChange	aParticleChange

const G4ProcessManager *	aProcessManager = nullptr

const G4MaterialCutsCouple *	currentCouple = nullptr

size_t	currentCoupleIndex = 0

G4double	currentInteractionLength = -1.0

const G4Material *	currentMaterial = nullptr

G4bool	enableAlongStepDoIt = true

G4bool	enableAtRestDoIt = true

G4bool	enablePostStepDoIt = true

G4ParticleChangeForLoss	fParticleChange

G4double	mfpKinEnergy = 0.0

G4VParticleChange *	pParticleChange = nullptr

G4double	preStepKinEnergy = 0.0

G4double	preStepLambda = 0.0

G4double	preStepLogKinEnergy = LOG_EKIN_MIN

G4double	preStepLogScaledEnergy = LOG_EKIN_MIN

G4double	preStepScaledEnergy = 0.0

G4double	theInitialNumberOfInteractionLength = -1.0

G4double	theNumberOfInteractionLengthLeft = -1.0

G4String	thePhysicsTableFileName

G4double	thePILfactor = 1.0

G4String	theProcessName

G4int	theProcessSubType = -1

G4ProcessType	theProcessType = fNotDefined

G4int	verboseLevel = 0

Private Member Functions
void	ComputeLambdaForScaledEnergy (G4double scaledKinE, G4double logScaledKinE)

void	DefineMaterial (const G4MaterialCutsCouple *couple)

void	FillSecondariesAlongStep (G4double weight)

G4double	GetDEDXForScaledEnergy (G4double scaledKinE)

G4double	GetDEDXForScaledEnergy (G4double scaledKinE, G4double logScaledKinE)

G4double	GetIonisationForScaledEnergy (G4double scaledKinE)

G4double	GetLambdaForScaledEnergy (G4double scaledKinE)

G4double	GetLambdaForScaledEnergy (G4double scaledKinE, G4double logScaledKinE)

G4double	GetLimitScaledRangeForScaledEnergy (G4double scaledKinE)

G4double	GetLimitScaledRangeForScaledEnergy (G4double scaledKinE, G4double logScaledKinE)

G4double	GetScaledRangeForScaledEnergy (G4double scaledKinE)

G4double	GetScaledRangeForScaledEnergy (G4double scaledKinE, G4double logScaledKinE)

G4bool	IsRegionForCubcutProcessor (const G4Track &aTrack)

void	PrintWarning (const G4String &, G4double val) const

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

G4double	ScaledKinEnergyForLoss (G4double range)

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

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

Private Attributes
G4bool	actBinning = false

G4bool	actLinLossLimit = false

G4bool	actLossFluc = false

G4bool	actMaxKinEnergy = false

G4bool	actMinKinEnergy = false

G4GPILSelection	aGPILSelection

G4VAtomDeexcitation *	atomDeexcitation = nullptr

size_t	basedCoupleIndex = 0

G4bool	baseMat = false

const G4ParticleDefinition *	baseParticle = nullptr

G4double	biasFactor = 1.0

G4bool	biasFlag = false

G4int	biasID = _DeltaEBelowCut

G4EmBiasingManager *	biasManager = nullptr

G4double	chargeSqRatio = 1.0

size_t	coupleIdxLambda = 0

size_t	coupleIdxRange = 0

G4VEmModel *	currentModel = nullptr

G4double	dRoverRange = 0.2

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

G4double	fFactor = 1.0

G4double	finalRange

G4double	fLambda = 0.0

G4double	fLambdaEnergy = 0.0

G4VEmFluctuationModel *	fluctModel = nullptr

G4ProcessTable *	fProcessTable = nullptr

G4double	fRange = 0.0

G4double	fRangeEnergy = 0.0

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

G4CrossSectionType	fXSType = fEmIncreasing

size_t	idxCSDA = 0

size_t	idxDEDX = 0

size_t	idxDEDXunRestricted = 0

size_t	idxInverseRange = 0

size_t	idxIonisation = 0

size_t	idxLambda = 0

size_t	idxRange = 0

size_t	idxSecRange = 0

G4bool	isIon = false

G4bool	isIonisation = true

G4bool	isMaster = true

G4double	lambdaFactor = 1.0

G4double	linLossLimit = 0.01

G4LossTableManager *	lManager

G4double	logLambdafactor = 0.0

G4double	logMassRatio = 0.0

G4bool	lossFluctuationFlag = true

G4double	lowestKinEnergy

G4int	mainSecondaries = 1

G4double	massRatio = 1.0

G4VProcess *	masterProcessShadow = nullptr

G4double	maxKinEnergy

G4double	maxKinEnergyCSDA

G4double	minKinEnergy

G4EmModelManager *	modelManager

G4int	nBins

G4int	nBinsCSDA

G4int	nSCoffRegions = 0

G4int	numberOfModels = 0

const G4ParticleDefinition *	particle = nullptr

G4double	reduceFactor = 1.0

G4bool	rndmStepFlag = false

G4SafetyHelper *	safetyHelper

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

std::vector< G4Track * >	scTracks

G4int	secID = _DeltaElectron

const G4ParticleDefinition *	secondaryParticle = nullptr

std::vector< G4DynamicParticle * >	secParticles

G4bool	spline = true

G4VSubCutProducer *	subcutProducer = nullptr

G4bool	tablesAreBuilt = false

G4PhysicsTable *	theCSDARangeTable = nullptr

const G4DataVector *	theCuts = nullptr

G4PhysicsTable *	theDEDXTable = nullptr

G4PhysicsTable *	theDEDXunRestrictedTable = nullptr

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

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

const G4ParticleDefinition *	theElectron

const G4ParticleDefinition *	theGamma

const G4ParticleDefinition *	theGenericIon = nullptr

G4PhysicsTable *	theInverseRangeTable = nullptr

G4PhysicsTable *	theIonisationSubTable = nullptr

G4PhysicsTable *	theIonisationTable = nullptr

G4PhysicsTable *	theLambdaTable = nullptr

G4EmParameters *	theParameters

const G4ParticleDefinition *	thePositron

G4PhysicsTable *	theRangeTableForLoss = nullptr

G4PhysicsTable *	theSecondaryRangeTable = nullptr

G4int	tripletID = _TripletElectron

G4bool	useDeexcitation = false

G4GPILSelection	valueGPILSelection = CandidateForSelection

G4bool	weightFlag = false

Detailed Description

Definition at line 81 of file G4VEnergyLossProcess.hh.

Constructor & Destructor Documentation

◆ G4VEnergyLossProcess() [1/2]

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

Definition at line 87 of file G4VEnergyLossProcess.cc.

                                                              : 
  G4VContinuousDiscreteProcess(name, type)
{
  theParameters = G4EmParameters::Instance();
  SetVerboseLevel(1);
 
  // low energy limit
  lowestKinEnergy = theParameters->LowestElectronEnergy();
 
  // Size of tables
  minKinEnergy     = 0.1*CLHEP::keV;
  maxKinEnergy     = 100.0*CLHEP::TeV;
  maxKinEnergyCSDA = 1.0*CLHEP::GeV;
  nBins            = 84;
  nBinsCSDA        = 35;
 
  // default linear loss limit
  finalRange = 1.*CLHEP::mm;
 
  // particle types
  theElectron   = G4Electron::Electron();
  thePositron   = G4Positron::Positron();
  theGamma      = G4Gamma::Gamma();
 
  // 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);
 
  G4LossTableBuilder* bld = lManager->GetTableBuilder();
  theDensityFactor = bld->GetDensityFactors();
  theDensityIdx = bld->GetCoupleIndexes();
 
  scTracks.reserve(10);
  secParticles.reserve(12);
}

References aGPILSelection, CandidateForSelection, G4Electron::Electron(), finalRange, fParticleChange, G4Gamma::Gamma(), G4LossTableBuilder::GetCoupleIndexes(), G4LossTableBuilder::GetDensityFactors(), G4TransportationManager::GetSafetyHelper(), G4LossTableManager::GetTableBuilder(), G4TransportationManager::GetTransportationManager(), CLHEP::GeV, G4EmParameters::Instance(), G4LossTableManager::Instance(), CLHEP::keV, lManager, G4EmParameters::LowestElectronEnergy(), lowestKinEnergy, maxKinEnergy, maxKinEnergyCSDA, minKinEnergy, CLHEP::mm, modelManager, nBins, nBinsCSDA, G4Positron::Positron(), G4VProcess::pParticleChange, G4LossTableManager::Register(), safetyHelper, scTracks, secParticles, G4VParticleChange::SetSecondaryWeightByProcess(), G4VProcess::SetVerboseLevel(), CLHEP::TeV, theDensityFactor, theDensityIdx, theElectron, theGamma, theParameters, and thePositron.

◆ ~G4VEnergyLossProcess()

G4VEnergyLossProcess::~G4VEnergyLossProcess ( )

override

Definition at line 134 of file G4VEnergyLossProcess.cc.

{
  /*
  G4cout << "** G4VEnergyLossProcess::~G4VEnergyLossProcess() for " 
         << GetProcessName() << " isMaster: " << isMaster
         << "  basePart: " << baseParticle 
         << G4endl;
  G4cout << " isIonisation " << isIonisation << "  " 
         << theDEDXTable << "  " <<  theIonisationTable << G4endl;
  */
 
  if (isMaster && nullptr == baseParticle) {
    if(nullptr != theDEDXTable) {
 
      //G4cout << " theIonisationTable " << theIonisationTable << G4endl;
      if(theIonisationTable == theDEDXTable) { theIonisationTable = nullptr; }
      //G4cout << " delete theDEDXTable " << theDEDXTable << G4endl;
      theDEDXTable->clearAndDestroy();
      delete theDEDXTable;
      theDEDXTable = nullptr;
    }
    //G4cout << " theIonisationTable " << theIonisationTable << G4endl;
    if(nullptr != theIonisationTable) {
      //G4cout << " delete theIonisationTable " << theIonisationTable << G4endl;
      theIonisationTable->clearAndDestroy();
      delete theIonisationTable;
      theIonisationTable = nullptr;
    }
    if(nullptr != theDEDXunRestrictedTable && isIonisation) {
      theDEDXunRestrictedTable->clearAndDestroy();
      delete theDEDXunRestrictedTable;
      theDEDXunRestrictedTable = nullptr;
    }
    if(nullptr != theCSDARangeTable && isIonisation) {
      theCSDARangeTable->clearAndDestroy();
      delete theCSDARangeTable;
      theCSDARangeTable = nullptr;
    }
    //G4cout << "delete RangeTable: " << theRangeTableForLoss << G4endl;
    if(nullptr != theRangeTableForLoss && isIonisation) {
      theRangeTableForLoss->clearAndDestroy();
      delete theRangeTableForLoss;
      theRangeTableForLoss = nullptr;
    }
    //G4cout << "delete InvRangeTable: " << theInverseRangeTable << G4endl;
    if(nullptr != theInverseRangeTable && isIonisation /*&& !isIon*/) {
      theInverseRangeTable->clearAndDestroy();
      delete theInverseRangeTable;
      theInverseRangeTable = nullptr;
    }
    //G4cout << "delete LambdaTable: " << theLambdaTable << G4endl;
    if(nullptr != theLambdaTable) {
      theLambdaTable->clearAndDestroy();
      delete theLambdaTable;
      theLambdaTable = nullptr;
    }
    if(nullptr != fXSpeaks) {
      for(auto const & v : *fXSpeaks) { delete v; }
      delete fXSpeaks;
      fXSpeaks = nullptr;
    }
  }
  secParticles.clear();
  delete modelManager;
  delete biasManager;
  delete scoffRegions;
  delete emModels;
  lManager->DeRegister(this);
  //G4cout << "** all removed" << G4endl;
}

References baseParticle, biasManager, G4PhysicsTable::clearAndDestroy(), G4LossTableManager::DeRegister(), emModels, fXSpeaks, isIonisation, isMaster, lManager, modelManager, scoffRegions, secParticles, theCSDARangeTable, theDEDXTable, theDEDXunRestrictedTable, theInverseRangeTable, theIonisationTable, theLambdaTable, and theRangeTableForLoss.

◆ G4VEnergyLossProcess() [2/2]

G4VEnergyLossProcess::G4VEnergyLossProcess ( G4VEnergyLossProcess & )

delete

Member Function Documentation

◆ ActivateForcedInteraction()

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

Definition at line 1915 of file G4VEnergyLossProcess.cc.

{
  if(nullptr == 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);
}

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

Referenced by G4EmExtraParameters::DefineRegParamForLoss().

◆ ActivateSecondaryBiasing()

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

Definition at line 1935 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(nullptr == 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; 
    }
  }
}

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

Referenced by G4EmExtraParameters::DefineRegParamForLoss().

◆ ActivateSubCutoff()

void G4VEnergyLossProcess::ActivateSubCutoff ( const G4Region * region )

Definition at line 799 of file G4VEnergyLossProcess.cc.

{
  if(nullptr == scoffRegions) {
    scoffRegions = new std::vector<const G4Region*>;
  }
  // the region is in the list
  if(!scoffRegions->empty()) {
    for (auto & reg : *scoffRegions) {
      if (reg == r) { return; }
    }
  }
  // new region 
  scoffRegions->push_back(r);
  ++nSCoffRegions;
}

References nSCoffRegions, reg, and scoffRegions.

Referenced by G4EmExtraParameters::DefineRegParamForLoss().

◆ AddEmModel()

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

Definition at line 216 of file G4VEnergyLossProcess.cc.

{
  if(nullptr == ptr) { return; }
  G4VEmFluctuationModel* afluc = (nullptr == fluc) ? fluctModel : fluc;
  modelManager->AddEmModel(order, ptr, afluc, region);
  ptr->SetParticleChange(pParticleChange, afluc);
}

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

◆ AlongStepDoIt()

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

overridevirtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 1059 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(weight); }
      eloss = std::max(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 = length*GetDEDXForScaledEnergy(preStepScaledEnergy,
                                        preStepLogScaledEnergy);
 
  //G4cout << "Short STEP: 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;
  }
  */
 
  const G4double cut = (*theCuts)[currentCoupleIndex];
  G4double esec = 0.0;
 
  // Corrections, which cannot be tabulated
  if(isIon) {
    currentModel->CorrectionsAlongStep(currentCouple, dynParticle, 
                                       length, eloss);
    eloss = std::max(eloss, 0.0);
  }
 
  // Sample fluctuations if not full energy loss
  if(eloss >= preStepKinEnergy) {
    eloss = preStepKinEnergy;
 
  } else if (lossFluctuationFlag) {
    const G4double tmax = currentModel->MaxSecondaryKinEnergy(dynParticle);
    const G4double tcut = std::min(cut, tmax);
    G4VEmFluctuationModel* fluc = currentModel->GetModelOfFluctuations();
    eloss = fluc->SampleFluctuations(currentCouple,dynParticle,
                                     tcut, 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;
    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(nullptr != subcutProducer && IsRegionForCubcutProcessor(track)) {
    subcutProducer->SampleSecondaries(step, scTracks, eloss, cut);
  }
  // secondaries from atomic de-excitation and subcut
  if(!scTracks.empty()) { FillSecondariesAlongStep(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;
}

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

◆ AlongStepGetPhysicalInteractionLength()

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

overridevirtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 872 of file G4VEnergyLossProcess.cc.

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

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

Referenced by ContinuousStepLimit().

◆ AlongStepGPIL()

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

inlineinherited

Definition at line 461 of file G4VProcess.hh.

{
  return AlongStepGetPhysicalInteractionLength(track, previousStepSize,
                             currentMinimumStep, proposedSafety, selection);
}

References G4VProcess::AlongStepGetPhysicalInteractionLength().

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

◆ AtRestDoIt()

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

inlinevirtualinherited

Implements G4VProcess.

Definition at line 87 of file G4VContinuousDiscreteProcess.hh.

90 { return 0; }

◆ AtRestGetPhysicalInteractionLength()

virtual G4double G4VContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength	(	const G4Track &	,
		G4ForceCondition *
	)

inlinevirtualinherited

Implements G4VProcess.

Definition at line 81 of file G4VContinuousDiscreteProcess.hh.

84 { return -1.0; }

◆ AtRestGPIL()

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

inlineinherited

Definition at line 472 of file G4VProcess.hh.

{
  return thePILfactor * AtRestGetPhysicalInteractionLength(track, condition);
}

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

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

◆ BaseParticle()

const G4ParticleDefinition * G4VEnergyLossProcess::BaseParticle ( ) const

inline

Definition at line 870 of file G4VEnergyLossProcess.hh.

{
  return baseParticle;
}

References baseParticle.

Referenced by G4LossTableManager::BuildPhysicsTable(), G4LossTableManager::LocalPhysicsTables(), G4LossTableManager::RegisterExtraParticle(), and G4EmCalculator::UpdateParticle().

◆ BuildDEDXTable()

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

Definition at line 573 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 {
    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(nullptr == table) { return table; }
 
  G4LossTableBuilder* bld = lManager->GetTableBuilder();
  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(nullptr != (*table)[i]) { delete (*table)[i]; }
      if(nullptr != bVector) {
        aVector = new G4PhysicsLogVector(*bVector);
      } else {
        bVector = new G4PhysicsLogVector(minKinEnergy, emax, bin, spline);
        aVector = bVector;
      }
 
      modelManager->FillDEDXVector(aVector, couple, tType);
      if(spline) { 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;
}

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

Referenced by G4LossTableManager::BuildTables().

◆ BuildLambdaTable()

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

Definition at line 657 of file G4VEnergyLossProcess.cc.

{
  G4PhysicsTable* table = nullptr;
 
  if(fRestricted == tType) {
    table = theLambdaTable;
  } 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(nullptr == table) { return table; }
 
  // Access to materials
  const G4ProductionCutsTable* theCoupleTable=
        G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();
  G4LossTableBuilder* bld = lManager->GetTableBuilder();
 
  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, spline);
 
      modelManager->FillLambdaVector(aVector, couple, startNull, tType);
      if(spline) { 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;
}

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

Referenced by G4LossTableManager::BuildTables().

◆ BuildPhysicsTable()

void G4VEnergyLossProcess::BuildPhysicsTable ( const G4ParticleDefinition & part )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 473 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) {
 
    if(isMaster) {
      lManager->BuildPhysicsTable(particle, this);
 
    } else {
 
      const G4VEnergyLossProcess* masterProcess = 
        static_cast<const G4VEnergyLossProcess*>(GetMasterProcess());
 
      // copy table pointers from master thread
      SetDEDXTable(masterProcess->DEDXTable(),fRestricted);
      SetDEDXTable(masterProcess->DEDXunRestrictedTable(),fTotal);
      SetDEDXTable(masterProcess->IonisationTable(),fIsIonisation);
      SetRangeTableForLoss(masterProcess->RangeTableForLoss());
      SetCSDARangeTable(masterProcess->CSDARangeTable());
      SetSecondaryRangeTable(masterProcess->SecondaryRangeTable());
      SetInverseRangeTable(masterProcess->InverseRangeTable());
      SetLambdaTable(masterProcess->LambdaTable());
      SetTwoPeaksXS(masterProcess->TwoPeaksXS());
      isIonisation = masterProcess->IsIonisationProcess();
      baseMat = masterProcess->UseBaseMaterial();
 
      tablesAreBuilt = true;  
      // local initialisation of models
      G4bool printing = true;
      for(G4int i=0; i<numberOfModels; ++i) {
        G4VEmModel* mod = GetModelByIndex(i, printing);
        G4VEmModel* mod0= masterProcess->GetModelByIndex(i, printing);
        mod->SetUseBaseMaterials(baseMat);
        mod->InitialiseLocal(particle, mod0);
      }
      lManager->LocalPhysicsTables(particle, this);
    }
   
    // needs to be done only once
    safetyHelper->InitialiseHelper();
  }
  // Added tracking cut to avoid tracking artifacts
  // and identified deexcitation flag
  if(isIonisation) { 
    atomDeexcitation = lManager->AtomDeexcitation();
    if(nullptr != atomDeexcitation) { 
      if(atomDeexcitation->IsPIXEActive()) { useDeexcitation = true; } 
    }
  }
 
  // protection against double printout
  if(theParameters->IsPrintLocked()) { return; }
 
  // 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"|| num == "alpha+" )))
    { 
      StreamInfo(G4cout, part); 
    }
 
  /*  
  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 << " baseMat=" << baseMat << G4endl;
  }
}

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

Referenced by G4PolarizedIonisation::BuildPhysicsTable().

◆ BuildWorkerPhysicsTable()

void G4VProcess::BuildWorkerPhysicsTable ( const G4ParticleDefinition & part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 200 of file G4VProcess.cc.

{
  BuildPhysicsTable(part);
}

References G4VProcess::BuildPhysicsTable().

Referenced by G4BiasingProcessInterface::BuildWorkerPhysicsTable().

◆ ClearNumberOfInteractionLengthLeft()

void G4VProcess::ClearNumberOfInteractionLengthLeft ( )

inlineprotectedinherited

Definition at line 424 of file G4VProcess.hh.

{
  theInitialNumberOfInteractionLength = -1.0; 
  theNumberOfInteractionLengthLeft =  -1.0;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

◆ ComputeLambdaForScaledEnergy()

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

private

Definition at line 994 of file G4VEnergyLossProcess.cc.

{
  // cross section increased with energy
  if(fXSType == fEmIncreasing) {
    if(e/lambdaFactor < mfpKinEnergy) {
      mfpKinEnergy = e;
      preStepLambda = GetLambdaForScaledEnergy(e, loge); 
    }
 
  // cross section has two peaks
  } else if(fXSType == fEmTwoPeaks) {
    G4TwoPeaksXS* xs = (*fXSpeaks)[basedCoupleIndex];
    const G4double e1peak = xs->e1peak;
 
    // below the 1st peak
    if(e <= e1peak) {
      if(e/lambdaFactor < mfpKinEnergy) {
        mfpKinEnergy = e;
        preStepLambda = GetLambdaForScaledEnergy(e, loge); 
      }
      return;
    }
    const G4double e1deep = xs->e1deep;
    // above the 1st peak, below the deep
    if(e <= e1deep) {
      if(mfpKinEnergy >= e1deep || e <= mfpKinEnergy) { 
        const G4double e1 = std::max(e1peak, e*lambdaFactor);
        preStepLambda = GetLambdaForScaledEnergy(e1); 
        mfpKinEnergy = e1;
      }
      return;
    }
    const G4double e2peak = xs->e2peak;
    // above the deep, below 2nd peak
    if(e <= e2peak) {
      if(e/lambdaFactor < mfpKinEnergy) {
        mfpKinEnergy = e;
        preStepLambda = GetLambdaForScaledEnergy(e, loge); 
      }
      return;
    }
    const G4double e2deep = xs->e2deep;
    // above the 2nd peak, below the deep
    if(e <= e2deep) {
      if(mfpKinEnergy >= e2deep || e <= mfpKinEnergy) { 
        const G4double e1 = std::max(e2peak, e*lambdaFactor);
        preStepLambda = GetLambdaForScaledEnergy(e1); 
        mfpKinEnergy = e1;
      }
      return;
    }
    // above the deep, below 3d peak
    if(e/lambdaFactor < mfpKinEnergy) {
      mfpKinEnergy = e;
      preStepLambda = GetLambdaForScaledEnergy(e, loge); 
    }
 
    // integral method is not used
  } else {
    preStepLambda = GetLambdaForScaledEnergy(e, loge); 
  }
}

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

Referenced by PostStepGetPhysicalInteractionLength().

◆ ContinuousStepLimit()

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

Definition at line 1647 of file G4VEnergyLossProcess.cc.

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

References aGPILSelection, and AlongStepGetPhysicalInteractionLength().

◆ CrossSectionBiasingFactor()

G4double G4VEnergyLossProcess::CrossSectionBiasingFactor ( ) const

inline

Definition at line 942 of file G4VEnergyLossProcess.hh.

{
  return biasFactor;
}

References biasFactor.

◆ CrossSectionPerVolume() [1/2]

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

◆ CrossSectionPerVolume() [2/2]

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

Definition at line 1614 of file G4VEnergyLossProcess.cc.

{
  // Cross section per volume is calculated
  DefineMaterial(couple);
  G4double cross = 0.0;
  if (nullptr != theLambdaTable) {
    cross = GetLambdaForScaledEnergy(kineticEnergy * massRatio,
                                     logKineticEnergy + logMassRatio);
  } else {
    SelectModel(kineticEnergy*massRatio);
    cross = (!baseMat) ? biasFactor : biasFactor*(*theDensityFactor)[currentCoupleIndex];
    cross *= (currentModel->CrossSectionPerVolume(currentMaterial, particle, kineticEnergy,
                                                  (*theCuts)[currentCoupleIndex]));
  }
  return std::max(cross, 0.0);
}

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

◆ CrossSectionType()

G4CrossSectionType G4VEnergyLossProcess::CrossSectionType ( ) const

inline

Definition at line 907 of file G4VEnergyLossProcess.hh.

{
  return fXSType;
}

References fXSType.

◆ CSDARangeTable()

G4PhysicsTable * G4VEnergyLossProcess::CSDARangeTable ( ) const

inline

Definition at line 977 of file G4VEnergyLossProcess.hh.

{
  return theCSDARangeTable;
}

References theCSDARangeTable.

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

◆ CurrentMaterialCutsCoupleIndex()

size_t G4VEnergyLossProcess::CurrentMaterialCutsCoupleIndex ( ) const

inlineprotected

Definition at line 557 of file G4VEnergyLossProcess.hh.

{
  return currentCoupleIndex;
}

References currentCoupleIndex.

Referenced by G4PolarizedIonisation::ComputeSaturationFactor().

◆ DEDXTable()

G4PhysicsTable * G4VEnergyLossProcess::DEDXTable ( ) const

inline

Definition at line 956 of file G4VEnergyLossProcess.hh.

{
  return theDEDXTable;
}

References theDEDXTable.

Referenced by BuildPhysicsTable(), G4LossTableManager::BuildTables(), G4LossTableManager::LocalPhysicsTables(), and G4EmCalculator::PrintDEDXTable().

◆ DEDXunRestrictedTable()

G4PhysicsTable * G4VEnergyLossProcess::DEDXunRestrictedTable ( ) const

inline

Definition at line 963 of file G4VEnergyLossProcess.hh.

{
  return theDEDXunRestrictedTable;
}

References theDEDXunRestrictedTable.

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

◆ DefineMaterial()

void G4VEnergyLossProcess::DefineMaterial ( const G4MaterialCutsCouple * couple )

inlineprivate

Definition at line 581 of file G4VEnergyLossProcess.hh.

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

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

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

◆ DumpInfo()

void G4VProcess::DumpInfo ( ) const

virtualinherited

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

Definition at line 167 of file G4VProcess.cc.

{
  G4cout << "Process Name " << theProcessName ;
  G4cout << " : Type[" << GetProcessTypeName(theProcessType) << "]";
  G4cout << " : SubType[" << theProcessSubType << "]"<< G4endl;
}

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

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

◆ EmModel()

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

inline

Definition at line 1033 of file G4VEnergyLossProcess.hh.

{
  return (nullptr != emModels && index < emModels->size()) 
    ? (*emModels)[index] : nullptr;
}

References emModels.

◆ EndTracking()

void G4VProcess::EndTracking ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, G4WrapperProcess, G4FastSimulationManagerProcess, G4VPhononProcess, G4CoupledTransportation, G4Decay, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 102 of file G4VProcess.cc.

{
#ifdef G4VERBOSE
  if (verboseLevel>2)
  {
    G4cout << "G4VProcess::EndTracking() - [" << theProcessName << "]"
           << G4endl;
  }
#endif
  theNumberOfInteractionLengthLeft = -1.0;
  currentInteractionLength = -1.0;
  theInitialNumberOfInteractionLength=-1.0;
}

References G4VProcess::currentInteractionLength, G4cout, G4endl, G4VProcess::theInitialNumberOfInteractionLength, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4BiasingProcessInterface::EndTracking(), G4WrapperProcess::EndTracking(), G4VPhononProcess::EndTracking(), and G4AdjointProcessEquivalentToDirectProcess::EndTracking().

◆ FillSecondariesAlongStep()

void G4VEnergyLossProcess::FillSecondariesAlongStep ( G4double weight )

private

Definition at line 1258 of file G4VEnergyLossProcess.cc.

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

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

Referenced by AlongStepDoIt().

◆ FluctModel()

G4VEmFluctuationModel * G4VEnergyLossProcess::FluctModel ( ) const

inline

Definition at line 833 of file G4VEnergyLossProcess.hh.

{
  return fluctModel;
}

References fluctModel.

Referenced by G4MuIonisation::InitialiseEnergyLossProcess(), G4PolarizedIonisation::InitialiseEnergyLossProcess(), G4eIonisation::InitialiseEnergyLossProcess(), G4hIonisation::InitialiseEnergyLossProcess(), and G4ionIonisation::InitialiseEnergyLossProcess().

◆ GetContinuousStepLimit()

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

overrideprotectedvirtual

Implements G4VContinuousDiscreteProcess.

Definition at line 1668 of file G4VEnergyLossProcess.cc.

{
  return DBL_MAX;
}

References DBL_MAX.

◆ GetCSDADEDX()

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

inline

◆ GetCSDARange()

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

inline

Definition at line 782 of file G4VEnergyLossProcess.hh.

{
  DefineMaterial(couple);
  return (nullptr == theCSDARangeTable) ? DBL_MAX : 
    GetLimitScaledRangeForScaledEnergy(kineticEnergy*massRatio)*reduceFactor;
}

References DBL_MAX, DefineMaterial(), GetLimitScaledRangeForScaledEnergy(), massRatio, reduceFactor, and theCSDARangeTable.

Referenced by G4LossTableManager::GetCSDARange().

◆ GetCurrentElement()

const G4Element * G4VEnergyLossProcess::GetCurrentElement ( ) const

Definition at line 1891 of file G4VEnergyLossProcess.cc.

{
  return (nullptr != currentModel) ? currentModel->GetCurrentElement() : nullptr;
}

References currentModel, and G4VEmModel::GetCurrentElement().

◆ GetCurrentInteractionLength()

G4double G4VProcess::GetCurrentInteractionLength ( ) const

inlineinherited

Definition at line 443 of file G4VProcess.hh.

{
  return currentInteractionLength;
}

References G4VProcess::currentInteractionLength.

Referenced by G4BiasingProcessInterface::InvokeWrappedProcessPostStepGPIL(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), and G4BOptrForceCollision::ProposeOccurenceBiasingOperation().

◆ GetDEDX() [1/2]

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

inline

Definition at line 740 of file G4VEnergyLossProcess.hh.

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

References DefineMaterial(), GetDEDXForScaledEnergy(), and massRatio.

Referenced by G4ContinuousGainOfEnergy::AlongStepDoIt(), G4LossTableManager::GetDEDX(), and G4VMscModel::GetDEDX().

◆ GetDEDX() [2/2]

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

inline

Definition at line 750 of file G4VEnergyLossProcess.hh.

{
  DefineMaterial(couple);
  return GetDEDXForScaledEnergy(kinEnergy*massRatio, logKinEnergy+logMassRatio);
}

References DefineMaterial(), GetDEDXForScaledEnergy(), logMassRatio, and massRatio.

◆ GetDEDXDispersion()

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

Definition at line 1595 of file G4VEnergyLossProcess.cc.

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

References currentCoupleIndex, currentMaterial, currentModel, DefineMaterial(), G4VEmFluctuationModel::Dispersion(), G4DynamicParticle::GetKineticEnergy(), G4VEmModel::GetModelOfFluctuations(), massRatio, G4VEmModel::MaxSecondaryKinEnergy(), G4INCL::Math::min(), SelectModel(), and theCuts.

Referenced by G4LossTableManager::GetDEDXDispersion().

◆ GetDEDXForScaledEnergy() [1/2]

G4double G4VEnergyLossProcess::GetDEDXForScaledEnergy ( G4double scaledKinE )

inlineprivate

Definition at line 600 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;
}

References basedCoupleIndex, fFactor, idxDEDX, and minKinEnergy.

Referenced by AlongStepDoIt(), and GetDEDX().

◆ GetDEDXForScaledEnergy() [2/2]

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

inlineprivate

Definition at line 613 of file G4VEnergyLossProcess.hh.

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

References basedCoupleIndex, fFactor, and minKinEnergy.

◆ GetGPILSelection()

G4GPILSelection G4VContinuousDiscreteProcess::GetGPILSelection ( ) const

inlineprotectedinherited

Definition at line 109 of file G4VContinuousDiscreteProcess.hh.

110 { return valueGPILSelection; }

G4VContinuousDiscreteProcess::valueGPILSelection

G4GPILSelection valueGPILSelection

Definition: G4VContinuousDiscreteProcess.hh:117

References G4VContinuousDiscreteProcess::valueGPILSelection.

◆ GetIonisationForScaledEnergy()

G4double G4VEnergyLossProcess::GetIonisationForScaledEnergy ( G4double scaledKinE )

inlineprivate

Definition at line 627 of file G4VEnergyLossProcess.hh.

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

References basedCoupleIndex, fFactor, idxIonisation, and minKinEnergy.

◆ GetKineticEnergy()

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

inline

Definition at line 793 of file G4VEnergyLossProcess.hh.

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

References DefineMaterial(), massRatio, reduceFactor, and ScaledKinEnergyForLoss().

Referenced by G4ContinuousGainOfEnergy::AlongStepDoIt(), G4LossTableManager::GetEnergy(), and G4VMscModel::GetEnergy().

◆ GetLambda() [1/2]

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

inline

Definition at line 803 of file G4VEnergyLossProcess.hh.

{
  DefineMaterial(couple);
  return (nullptr != theLambdaTable) ? 
    GetLambdaForScaledEnergy(kinEnergy*massRatio) : 0.0;
}

References DefineMaterial(), GetLambdaForScaledEnergy(), massRatio, and theLambdaTable.

◆ GetLambda() [2/2]

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

inline

Definition at line 814 of file G4VEnergyLossProcess.hh.

{
  DefineMaterial(couple);
  return (nullptr != theLambdaTable) ?
    GetLambdaForScaledEnergy(kinEnergy*massRatio, logKinEnergy+logMassRatio) 
    :  0.0;
}

References DefineMaterial(), GetLambdaForScaledEnergy(), logMassRatio, massRatio, and theLambdaTable.

◆ GetLambdaForScaledEnergy() [1/2]

G4double G4VEnergyLossProcess::GetLambdaForScaledEnergy ( G4double scaledKinE )

inlineprivate

Definition at line 713 of file G4VEnergyLossProcess.hh.

{
  if(currentCoupleIndex != coupleIdxLambda || fLambdaEnergy != e) {
    coupleIdxLambda = currentCoupleIndex;
    fLambdaEnergy = e;
    fLambda = fFactor*((*theLambdaTable)[basedCoupleIndex])->Value(e, idxLambda);
  }
  return fLambda;
}

References basedCoupleIndex, coupleIdxLambda, currentCoupleIndex, fFactor, fLambda, fLambdaEnergy, and idxLambda.

Referenced by ComputeLambdaForScaledEnergy(), CrossSectionPerVolume(), GetLambda(), MeanFreePath(), and PostStepDoIt().

◆ GetLambdaForScaledEnergy() [2/2]

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

inlineprivate

Definition at line 726 of file G4VEnergyLossProcess.hh.

{
  if(currentCoupleIndex != coupleIdxLambda || fLambdaEnergy != e) {
    coupleIdxLambda = currentCoupleIndex;
    fLambdaEnergy = e;
    fLambda = fFactor*
      ((*theLambdaTable)[basedCoupleIndex])->LogVectorValue(e, loge);
  }
  return fLambda;
}

References basedCoupleIndex, coupleIdxLambda, currentCoupleIndex, fFactor, fLambda, and fLambdaEnergy.

◆ GetLimitScaledRangeForScaledEnergy() [1/2]

G4double G4VEnergyLossProcess::GetLimitScaledRangeForScaledEnergy ( G4double scaledKinE )

inlineprivate

Definition at line 675 of file G4VEnergyLossProcess.hh.

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

References basedCoupleIndex, idxCSDA, and minKinEnergy.

Referenced by GetCSDARange().

◆ GetLimitScaledRangeForScaledEnergy() [2/2]

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

inlineprivate

Definition at line 685 of file G4VEnergyLossProcess.hh.

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

References basedCoupleIndex, and minKinEnergy.

◆ GetMasterProcess()

const G4VProcess * G4VProcess::GetMasterProcess ( ) const

inlineinherited

Definition at line 518 of file G4VProcess.hh.

{
  return masterProcessShadow;
}

References G4VProcess::masterProcessShadow.

Referenced by G4PolarizedCompton::BuildPhysicsTable(), G4PolarizedIonisation::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4BiasingProcessInterface::SetMasterProcess(), and G4VMultipleScattering::StorePhysicsTable().

◆ GetMeanFreePath()

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

overrideprotectedvirtual

Implements G4VContinuousDiscreteProcess.

Definition at line 1656 of file G4VEnergyLossProcess.cc.

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

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

Referenced by G4PolarizedIonisation::GetMeanFreePath().

◆ GetModelByIndex()

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

inline

Definition at line 1042 of file G4VEnergyLossProcess.hh.

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

References G4EmModelManager::GetModel(), and modelManager.

Referenced by BuildPhysicsTable().

◆ GetNumberOfInteractionLengthLeft()

G4double G4VProcess::GetNumberOfInteractionLengthLeft ( ) const

inlineinherited

Definition at line 431 of file G4VProcess.hh.

{
  return theNumberOfInteractionLengthLeft;
}

References G4VProcess::theNumberOfInteractionLengthLeft.

◆ GetPhysicsTableFileName()

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

inherited

Definition at line 181 of file G4VProcess.cc.

{
  G4String thePhysicsTableFileExt;
  if (ascii) thePhysicsTableFileExt = ".asc";
  else       thePhysicsTableFileExt = ".dat";
 
  thePhysicsTableFileName = directory + "/";
  thePhysicsTableFileName += tableName + "." +  theProcessName + ".";
  thePhysicsTableFileName += particle->GetParticleName()
                           + thePhysicsTableFileExt;
  
  return thePhysicsTableFileName;
}

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

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

◆ GetPILfactor()

G4double G4VProcess::GetPILfactor ( ) const

inlineinherited

Definition at line 455 of file G4VProcess.hh.

{
  return thePILfactor;
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

◆ GetProcessManager()

const G4ProcessManager * G4VProcess::GetProcessManager ( )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 494 of file G4VProcess.hh.

{
  return aProcessManager; 
}

References G4VProcess::aProcessManager.

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

◆ GetProcessName()

const G4String & G4VProcess::GetProcessName ( ) const

inlineinherited

Definition at line 382 of file G4VProcess.hh.

{
  return theProcessName;
}

References G4VProcess::theProcessName.

◆ GetProcessSubType()

G4int G4VProcess::GetProcessSubType ( ) const

inlineinherited

Definition at line 400 of file G4VProcess.hh.

{
  return theProcessSubType;
}

References G4VProcess::theProcessSubType.

Referenced by G4GammaGeneralProcess::AddEmProcess(), G4DNABrownianTransportation::BuildPhysicsTable(), G4HadronicProcessStore::FindProcess(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4HadronicProcessStore::GetCrossSectionPerAtom(), G4HadronicProcessStore::GetCrossSectionPerVolume(), G4GammaGeneralProcess::GetSubProcessSubType(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4PhysicsListHelper::RegisterProcess(), G4ElectronIonPair::ResidualeChargePostStep(), G4EmConfigurator::SetModelForRegion(), G4ChannelingOptrChangeCrossSection::StartRun(), StreamInfo(), G4VEmProcess::StreamInfo(), and G4VMultipleScattering::StreamInfo().

◆ GetProcessType()

G4ProcessType G4VProcess::GetProcessType ( ) const

inlineinherited

Definition at line 388 of file G4VProcess.hh.

{
  return theProcessType;
}

References G4VProcess::theProcessType.

Referenced by G4BiasingHelper::ActivatePhysicsBiasing(), G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4SteppingManager::DefinePhysicalStepLength(), export_G4VProcess(), G4ProcessTable::Find(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4WrapperProcess::RegisterProcess(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTableMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), and G4ChannelingOptrChangeCrossSection::StartRun().

◆ GetProcessTypeName()

const G4String & G4VProcess::GetProcessTypeName ( G4ProcessType aType )

staticinherited

Definition at line 134 of file G4VProcess.cc.

{
  switch (aType)
  {
    case fNotDefined:         return typeNotDefined; break;
    case fTransportation:     return typeTransportation; break;
    case fElectromagnetic:    return typeElectromagnetic; break;
    case fOptical:            return typeOptical; break;
    case fHadronic:           return typeHadronic; break;
    case fPhotolepton_hadron: return typePhotolepton_hadron; break;
    case fDecay:              return typeDecay; break;
    case fGeneral:            return typeGeneral; break;
    case fParameterisation:   return typeParameterisation; break;
    case fUserDefined:        return typeUserDefined; break;
    case fPhonon:             return typePhonon; break;
    default: ;
  }
  return noType;  
}

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

◆ GetRange() [1/2]

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

inline

Definition at line 761 of file G4VEnergyLossProcess.hh.

{
  DefineMaterial(couple);
  return GetScaledRangeForScaledEnergy(kinEnergy*massRatio);
}

References DefineMaterial(), GetScaledRangeForScaledEnergy(), and massRatio.

Referenced by G4ContinuousGainOfEnergy::AlongStepDoIt(), G4EmBiasingManager::ApplyRangeCut(), G4ContinuousGainOfEnergy::GetContinuousStepLimit(), G4LossTableManager::GetRange(), G4VMscModel::GetRange(), and G4LossTableManager::GetRangeFromRestricteDEDX().

◆ GetRange() [2/2]

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

inline

Definition at line 771 of file G4VEnergyLossProcess.hh.

{
  DefineMaterial(couple);
  return GetScaledRangeForScaledEnergy(kinEnergy*massRatio, logKinEnergy+logMassRatio);
}

References DefineMaterial(), GetScaledRangeForScaledEnergy(), logMassRatio, and massRatio.

◆ GetScaledRangeForScaledEnergy() [1/2]

G4double G4VEnergyLossProcess::GetScaledRangeForScaledEnergy ( G4double scaledKinE )

inlineprivate

Definition at line 637 of file G4VEnergyLossProcess.hh.

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

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

Referenced by AlongStepGetPhysicalInteractionLength(), and GetRange().

◆ GetScaledRangeForScaledEnergy() [2/2]

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

inlineprivate

Definition at line 655 of file G4VEnergyLossProcess.hh.

{
  //G4cout << "G4VEnergyLossProcess::GetScaledRange: Idx= " 
  //         << basedCoupleIndex << " E(MeV)= " << e 
  //         << " lastIdx= " << lastIdx << "  " << theRangeTableForLoss << G4endl; 
  if(currentCoupleIndex != coupleIdxRange || fRangeEnergy != e) {
    coupleIdxRange = currentCoupleIndex;
    fRangeEnergy = e;
    fRange = reduceFactor*((*theRangeTableForLoss)[basedCoupleIndex])->LogVectorValue(e, loge);
    if(e < minKinEnergy) { fRange *= std::sqrt(e/minKinEnergy); }
  }
  //G4cout << "G4VEnergyLossProcess::GetScaledRange: Idx= " 
  //         << basedCoupleIndex << " E(MeV)= " << e 
  //         << " R=  " << fRange << "  " << theRangeTableForLoss << G4endl;
  return fRange;
}

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

◆ GetTotalNumberOfInteractionLengthTraversed()

G4double G4VProcess::GetTotalNumberOfInteractionLengthTraversed ( ) const

inlineinherited

Definition at line 437 of file G4VProcess.hh.

{
  return theInitialNumberOfInteractionLength - theNumberOfInteractionLengthLeft;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4HadronicProcess::XBiasSecondaryWeight(), and G4HadronicProcess::XBiasSurvivalProbability().

◆ GetVerboseLevel()

G4int G4VProcess::GetVerboseLevel ( ) const

inlineinherited

Definition at line 418 of file G4VProcess.hh.

{
  return  verboseLevel;
}

References G4VProcess::verboseLevel.

Referenced by G4MuonMinusAtomicCapture::AtRestDoIt(), G4Decay::DecayIt(), G4UnknownDecay::DecayIt(), G4ProcessTable::DumpInfo(), export_G4VProcess(), G4Decay::G4Decay(), G4UnknownDecay::G4UnknownDecay(), G4Decay::GetMeanFreePath(), G4Decay::GetMeanLifeTime(), and G4DecayWithSpin::Spin_Precession().

◆ InitialiseEnergyLossProcess()

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

protectedpure virtual

Implemented in G4hBremsstrahlung, G4hhIonisation, G4hPairProduction, G4mplIonisation, G4ePairProduction, G4MuBremsstrahlung, G4MuIonisation, G4MuPairProduction, G4PolarizedBremsstrahlung, G4PolarizedIonisation, G4eBremsstrahlung, G4eIonisation, G4hIonisation, and G4ionIonisation.

Referenced by PreparePhysicsTable().

◆ InverseRangeTable()

G4PhysicsTable * G4VEnergyLossProcess::InverseRangeTable ( ) const

inline

Definition at line 998 of file G4VEnergyLossProcess.hh.

{
  return theInverseRangeTable;
}

References theInverseRangeTable.

Referenced by BuildPhysicsTable(), G4LossTableManager::BuildTables(), G4LossTableManager::CopyTables(), G4LossTableManager::LocalPhysicsTables(), and G4EmCalculator::PrintInverseRangeTable().

◆ IonisationTable()

G4PhysicsTable * G4VEnergyLossProcess::IonisationTable ( ) const

inline

Definition at line 970 of file G4VEnergyLossProcess.hh.

{
  return theIonisationTable;
}

References theIonisationTable.

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

◆ isAlongStepDoItIsEnabled()

G4bool G4VProcess::isAlongStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 506 of file G4VProcess.hh.

{
  return enableAlongStepDoIt;
}

References G4VProcess::enableAlongStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ IsApplicable()

virtual G4bool G4VProcess::IsApplicable ( const G4ParticleDefinition & )

inlinevirtualinherited

Reimplemented in G4DNAAttachment, G4DNAChargeDecrease, G4DNAChargeIncrease, G4DNADissociation, G4DNAElastic, G4DNAElectronSolvation, G4DNAExcitation, G4DNAIonisation, G4DNAPlasmonExcitation, G4DNAPositronium, G4DNARotExcitation, G4DNAVibExcitation, G4hImpactIonisation, G4RadioactiveDecay, G4HadronicAbsorptionBertini, G4HadronicAbsorptionFritiof, G4HadronicAbsorptionFritiofWithBinaryCascade, G4HadronStoppingProcess, G4MuonicAtomDecay, G4MuonMinusAtomicCapture, G4MuonMinusCapture, G4WrapperProcess, G4PhononDownconversion, G4NeutronKiller, G4ComptonScattering, G4GammaConversion, G4PhotoElectricEffect, G4GammaGeneralProcess, G4Decay, G4UnknownDecay, G4AdjointProcessEquivalentToDirectProcess, G4DNAElectronHoleRecombination, G4DNAMolecularDissociation, G4AnnihiToMuPair, G4GammaConversionToMuons, G4JAEAElasticScattering, G4LowECapture, G4MicroElecElastic, G4MicroElecInelastic, G4MicroElecLOPhononScattering, G4RayleighScattering, G4PolarizedCompton, G4PolarizedGammaConversion, G4PolarizedPhotoElectric, G4SynchrotronRadiation, G4SynchrotronRadiationInMat, G4VXTRenergyLoss, G4HadronInelasticProcess, G4NoProcess, G4ChargeExchangeProcess, G4MuonNuclearProcess, G4UCNAbsorption, G4UCNBoundaryProcess, G4UCNLoss, G4UCNMultiScattering, G4NeutronCaptureProcess, G4MicroElecSurface, G4ErrorEnergyLoss, G4Cerenkov, G4Scintillation, G4TransitionRadiation, G4VTransitionRadiation, G4OpAbsorption, G4OpBoundaryProcess, G4OpMieHG, G4OpRayleigh, G4OpWLS, G4OpWLS2, G4Channeling, G4VPhononProcess, G4NeutronFissionProcess, G4CoulombScattering, G4eBremsstrahlung, G4eIonisation, G4eMultipleScattering, G4eplusAnnihilation, G4hMultipleScattering, G4ionIonisation, G4NuclearStopping, G4AdjointhMultipleScattering, G4eAdjointMultipleScattering, G4eeToHadrons, G4hBremsstrahlung, G4hhIonisation, G4hPairProduction, G4mplIonisation, G4ePairProduction, G4MuBremsstrahlung, G4MuIonisation, G4MuMultipleScattering, G4MuPairProduction, G4PolarizedIonisation, G4hIonisation, G4VEmProcess, and G4BiasingProcessInterface.

Definition at line 182 of file G4VProcess.hh.

182{ return true; }

Referenced by G4ProcessManager::AddProcess(), export_G4VProcess(), G4WrapperProcess::IsApplicable(), G4AdjointProcessEquivalentToDirectProcess::IsApplicable(), and G4BiasingProcessInterface::IsApplicable().

◆ isAtRestDoItIsEnabled()

G4bool G4VProcess::isAtRestDoItIsEnabled ( ) const

inlineinherited

Definition at line 500 of file G4VProcess.hh.

{
  return enableAtRestDoIt;
}

References G4VProcess::enableAtRestDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ IsIonisationProcess()

G4bool G4VEnergyLossProcess::IsIonisationProcess ( ) const

inline

Definition at line 914 of file G4VEnergyLossProcess.hh.

{
  return isIonisation;
}

References isIonisation.

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

◆ isPostStepDoItIsEnabled()

G4bool G4VProcess::isPostStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 512 of file G4VProcess.hh.

{
  return enablePostStepDoIt;
}

References G4VProcess::enablePostStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ IsRegionForCubcutProcessor()

G4bool G4VEnergyLossProcess::IsRegionForCubcutProcessor ( const G4Track & aTrack )

private

Definition at line 817 of file G4VEnergyLossProcess.cc.

{
  if(0 == nSCoffRegions) { return true; }
  const G4Region* r = aTrack.GetVolume()->GetLogicalVolume()->GetRegion();
  for(auto & reg : *scoffRegions) {
    if(r == reg) { return true; }
  }
  return false;
}

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

Referenced by AlongStepDoIt().

◆ LambdaPhysicsVector()

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

protected

Definition at line 1678 of file G4VEnergyLossProcess.cc.

{
  DefineMaterial(couple);
  G4PhysicsVector* v = (*theLambdaTable)[basedCoupleIndex];
  return new G4PhysicsVector(*v);
}

References basedCoupleIndex, and DefineMaterial().

Referenced by G4PolarizedIonisation::BuildAsymmetryTables().

◆ LambdaTable()

G4PhysicsTable * G4VEnergyLossProcess::LambdaTable ( ) const

inline

Definition at line 1005 of file G4VEnergyLossProcess.hh.

{
  return theLambdaTable;
}

References theLambdaTable.

Referenced by BuildPhysicsTable(), G4LossTableManager::CopyTables(), and G4EmCalculator::FindLambdaTable().

◆ MaxKinEnergy()

G4double G4VEnergyLossProcess::MaxKinEnergy ( ) const

inline

Definition at line 935 of file G4VEnergyLossProcess.hh.

{
  return maxKinEnergy;
}

References maxKinEnergy.

◆ MeanFreePath()

G4double G4VEnergyLossProcess::MeanFreePath ( const G4Track & track )

Definition at line 1635 of file G4VEnergyLossProcess.cc.

{
  DefineMaterial(track.GetMaterialCutsCouple());
  const G4double kinEnergy    = track.GetKineticEnergy();
  const G4double logKinEnergy = track.GetDynamicParticle()->GetLogKineticEnergy();
  const G4double cs = GetLambdaForScaledEnergy(kinEnergy * massRatio, 
                                               logKinEnergy + logMassRatio);
  return (0.0 < cs) ? 1.0/cs : DBL_MAX;
}

References DBL_MAX, DefineMaterial(), G4Track::GetDynamicParticle(), G4Track::GetKineticEnergy(), GetLambdaForScaledEnergy(), G4DynamicParticle::GetLogKineticEnergy(), G4Track::GetMaterialCutsCouple(), logMassRatio, and massRatio.

Referenced by GetMeanFreePath().

◆ MinKinEnergy()

G4double G4VEnergyLossProcess::MinKinEnergy ( ) const

inline

Definition at line 928 of file G4VEnergyLossProcess.hh.

{
  return minKinEnergy;
}

References minKinEnergy.

◆ MinPrimaryEnergy()

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

protectedvirtual

Reimplemented in G4eIonisation, G4PolarizedIonisation, G4mplIonisation, G4hIonisation, G4ionIonisation, G4hhIonisation, G4ePairProduction, G4MuBremsstrahlung, G4MuIonisation, and G4MuPairProduction.

Definition at line 207 of file G4VEnergyLossProcess.cc.

{
  return cut;
}

Referenced by BuildLambdaTable().

◆ NumberOfModels()

size_t G4VEnergyLossProcess::NumberOfModels ( ) const

inline

Definition at line 1026 of file G4VEnergyLossProcess.hh.

{
  return numberOfModels;
}

References numberOfModels.

◆ NumberOfSubCutoffRegions()

G4int G4VEnergyLossProcess::NumberOfSubCutoffRegions ( ) const

inline

Definition at line 921 of file G4VEnergyLossProcess.hh.

{
  return nSCoffRegions;
}

References nSCoffRegions.

Referenced by G4LossTableManager::BuildTables().

◆ operator!=()

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

inherited

Definition at line 161 of file G4VProcess.cc.

{
  return (this !=  &right);
}

◆ operator=()

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

delete

◆ operator==()

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

inherited

Definition at line 155 of file G4VProcess.cc.

{
  return (this == &right);
}

◆ Particle()

const G4ParticleDefinition * G4VEnergyLossProcess::Particle ( ) const

inline

Definition at line 863 of file G4VEnergyLossProcess.hh.

{
  return particle;
}

References particle.

Referenced by G4LossTableManager::BuildPhysicsTable(), and G4LossTableManager::LocalPhysicsTables().

◆ PostStepDoIt()

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

overridevirtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 1289 of file G4VEnergyLossProcess.cc.

{
  // In all cases clear number of interaction lengths
  theNumberOfInteractionLengthLeft = -1.0;
  mfpKinEnergy = DBL_MAX;
 
  fParticleChange.InitializeForPostStep(track);
  const G4double finalT = track.GetKineticEnergy();
 
  const G4double postStepScaledEnergy = finalT*massRatio;
  SelectModel(postStepScaledEnergy);
 
  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;
    }
  }
 
  const G4DynamicParticle* dp = track.GetDynamicParticle();
 
  // Integral approach
  if (fXSType != fEmNoIntegral) {
    const G4double logFinalT = dp->GetLogKineticEnergy();
    G4double lx = GetLambdaForScaledEnergy(postStepScaledEnergy,
                                           logFinalT + logMassRatio);
    lx = std::max(lx, 0.0);
 
    // cache cross section useful for the false interaction
    const G4double lg = preStepLambda;
    if(postStepScaledEnergy < mfpKinEnergy) {
      mfpKinEnergy = postStepScaledEnergy;
      preStepLambda = lx;
    }
    /*
    if(preStepLambda<lx && 1 < verboseLevel) {
      G4cout << "WARNING: for " << particle->GetParticleName()
             << " and " << GetProcessName()
             << " E(MeV)= " << finalT/MeV
             << " preLambda= " << preStepLambda 
             << " < " << lx << " (postLambda) "
             << G4endl;
    }
    */
    // if both lg and lx are zero then no interaction
    if(lg*G4UniformRand() >= lx) {
      return &fParticleChange;
    }
  }
  // define new weight for primary and secondaries
  G4double weight = fParticleChange.GetParentWeight();
  if(weightFlag) {
    weight /= biasFactor;
    fParticleChange.ProposeWeight(weight);
  }
 
  const G4double tcut = (*theCuts)[currentCoupleIndex];
 
  // sample secondaries
  secParticles.clear();
  //G4cout<< "@@@ Eprimary= "<<dynParticle->GetKineticEnergy()/MeV
  //        << " cut= " << tcut/MeV << G4endl;
  currentModel->SampleSecondaries(&secParticles, currentCouple, dp, tcut);
 
  const 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
  const G4int num = secParticles.size();
  if(num > 0) {
 
    fParticleChange.SetNumberOfSecondaries(num);
    G4double time = track.GetGlobalTime();
 
    G4int n1(0), n2(0);
    if(num0 > mainSecondaries) { 
      currentModel->FillNumberOfSecondaries(n1, n2);
    }
 
    for (G4int i=0; i<num; ++i) {
      if(nullptr != secParticles[i]) {
        G4Track* t = new G4Track(secParticles[i], time, track.GetPosition());
        t->SetTouchableHandle(track.GetTouchableHandle());
        if (biasManager) {
          t->SetWeight(weight * biasManager->GetWeight(i));
        } else {
          t->SetWeight(weight);
        }
        if(i < num0) {
          t->SetCreatorModelID(secID);
        } else if(i < num0 + n1) {
          t->SetCreatorModelID(tripletID);
        } else {
          t->SetCreatorModelID(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;
}

◆ PostStepGetPhysicalInteractionLength()

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

overridevirtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 901 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();
  preStepLogKinEnergy    = track.GetDynamicParticle()->GetLogKineticEnergy();
  preStepScaledEnergy    = preStepKinEnergy*massRatio;
  preStepLogScaledEnergy = preStepLogKinEnergy + logMassRatio;
  SelectModel(preStepScaledEnergy);
 
  if(!currentModel->IsActive(preStepScaledEnergy)) { 
    theNumberOfInteractionLengthLeft = -1.0;
    currentInteractionLength = DBL_MAX;
    return x; 
  }
 
  // change effective charge of a charged particle on fly
  if(isIon) {
    const G4double q2 = currentModel->ChargeSquareRatio(track);
    if(q2 != chargeSqRatio) { 
      fFactor *= q2/chargeSqRatio;
      reduceFactor = 1.0/(fFactor*massRatio);
      chargeSqRatio = q2;
      // G4cout << "PostStepGPIL: Q^2=" << chargeSqRatio << " reducedFactor=" << reduceFactor << G4endl;
    }
  }
 
  // forced biasing only for primary particles
  if(biasManager) {
    if(0 == track.GetParentID() && biasFlag && 
       biasManager->ForcedInteractionRegion(currentCoupleIndex)) {
      return biasManager->GetStepLimit(currentCoupleIndex, previousStepSize);
    }
  }
 
  // compute mean free path
  ComputeLambdaForScaledEnergy(preStepScaledEnergy, preStepLogScaledEnergy);
 
  // zero cross section
  if(preStepLambda <= 0.0) { 
    theNumberOfInteractionLengthLeft = -1.0;
    currentInteractionLength = DBL_MAX;
  } else {
 
    // non-zero cross section
    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;
}

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

Referenced by G4PolarizedIonisation::PostStepGetPhysicalInteractionLength().

◆ PostStepGPIL()

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

inlineinherited

Definition at line 479 of file G4VProcess.hh.

{
  return thePILfactor *
      PostStepGetPhysicalInteractionLength(track, previousStepSize, condition);
}

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

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

◆ PreparePhysicsTable()

void G4VEnergyLossProcess::PreparePhysicsTable ( const G4ParticleDefinition & part )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 254 of file G4VEnergyLossProcess.cc.

{
  if(1 < verboseLevel) {
    G4cout << "G4VEnergyLossProcess::PreparePhysicsTable for "
           << GetProcessName() << " for " << part.GetParticleName() 
           << "  " << this << G4endl;
  }
  isMaster = lManager->IsMaster();
 
  // Are particle defined?
  if(nullptr == particle) { particle = &part; }
 
  if(part.GetParticleType() == "nucleus") {
 
    G4String pname = part.GetParticleName();
    if(pname != "deuteron" && pname != "triton" &&
       pname != "alpha+"   && pname != "alpha") {
 
      if(nullptr == theGenericIon) {
        theGenericIon = 
          G4ParticleTable::GetParticleTable()->FindParticle("GenericIon");
      }
      isIon = true; 
      if(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
             << " baseMat=" << baseMat 
             << "  particle " << particle << "  GenericIon " << theGenericIon 
             << G4endl;
    }
    return;
  }
 
  tablesAreBuilt = false;
 
  G4LossTableBuilder* bld = lManager->GetTableBuilder();
  lManager->PreparePhysicsTable(&part, this, isMaster);
 
  // Base particle and set of models can be defined here
  InitialiseEnergyLossProcess(particle, baseParticle);
 
  // 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();
  logLambdafactor = G4Log(lambdaFactor);
  if(isMaster) { SetVerboseLevel(theParameters->Verbose()); }
  else { SetVerboseLevel(theParameters->WorkerVerbose()); }
 
  theParameters->DefineRegParamForLoss(this);
 
  fRangeEnergy = fLambdaEnergy = 0.0;
 
  G4double initialCharge = particle->GetPDGCharge();
  G4double initialMass   = particle->GetPDGMass();
 
  theParameters->FillStepFunction(particle, this);
 
  // integral option may be disabled
  if(!theParameters->Integral()) { fXSType = fEmNoIntegral; }
 
  // parameters for scaling from the base particle
  if (nullptr != baseParticle) {
    massRatio    = (baseParticle->GetPDGMass())/initialMass;
    logMassRatio = G4Log(massRatio);
    G4double q = initialCharge/baseParticle->GetPDGCharge();
    chargeSqRatio = q*q;
    if(chargeSqRatio > 0.0) { reduceFactor = 1.0/(chargeSqRatio*massRatio); }
  }
  lowestKinEnergy = (initialMass < CLHEP::MeV) 
    ? theParameters->LowestElectronEnergy()
    : theParameters->LowestMuHadEnergy();
 
  // Tables preparation
  if (isMaster && nullptr == baseParticle) {
 
    if(nullptr != theDEDXTable && isIonisation) {
      if(nullptr != theIonisationTable && theDEDXTable != theIonisationTable) {
        theDEDXTable->clearAndDestroy();
        delete theDEDXTable;
        theDEDXTable = theIonisationTable;
      }   
    }
    
    theDEDXTable = G4PhysicsTableHelper::PreparePhysicsTable(theDEDXTable);
    bld->InitialiseBaseMaterials(theDEDXTable);
 
    if (theParameters->BuildCSDARange()) {
      theDEDXunRestrictedTable = 
        G4PhysicsTableHelper::PreparePhysicsTable(theDEDXunRestrictedTable);
      theCSDARangeTable = 
        G4PhysicsTableHelper::PreparePhysicsTable(theCSDARangeTable);
    }
 
    theLambdaTable = G4PhysicsTableHelper::PreparePhysicsTable(theLambdaTable);
 
    if(isIonisation) {
      theRangeTableForLoss = 
        G4PhysicsTableHelper::PreparePhysicsTable(theRangeTableForLoss);
      theInverseRangeTable = 
        G4PhysicsTableHelper::PreparePhysicsTable(theInverseRangeTable);  
    }
 
    if(fXSType == fEmTwoPeaks) {
      const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
      size_t n = theCoupleTable->GetTableSize();
      if(nullptr == fXSpeaks) { 
    fXSpeaks = new std::vector<G4TwoPeaksXS*>;
      }
      fXSpeaks->resize(n, nullptr);
    }
  }
  /*
  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(nullptr != biasManager) { 
    biasManager->Initialise(part,GetProcessName(),verboseLevel); 
    biasFlag = false; 
  }
 
  // defined ID of secondary particles
  G4int stype = GetProcessSubType();
  if(stype == fBremsstrahlung) {
    secID = _Bremsstrahlung;
    biasID = _SplitBremsstrahlung;
  } else if(stype == fPairProdByCharged) {
    secID = _PairProduction;
    mainSecondaries = 2;
  }
  baseMat = bld->GetBaseMaterialFlag();
 
  // initialisation of models
  numberOfModels = modelManager->NumberOfModels();
  for(G4int i=0; i<numberOfModels; ++i) {
    G4VEmModel* mod = modelManager->GetModel(i);
    if(0 == i) { currentModel = mod; }
    mod->SetMasterThread(isMaster);
    mod->SetAngularGeneratorFlag(
      theParameters->UseAngularGeneratorForIonisation());
    if(mod->HighEnergyLimit() > maxKinEnergy) {
      mod->SetHighEnergyLimit(maxKinEnergy);
    }
    mod->SetUseBaseMaterials(baseMat);
    SetEmModel(mod);
  }
  theCuts = modelManager->Initialise(particle, secondaryParticle, 
                                     1.0, verboseLevel);
 
  // subcut processor
  if(isIonisation) { 
    subcutProducer = lManager->SubCutProducer();
  }
  if(1 == nSCoffRegions) {
    if((*scoffRegions)[0]->GetName() == "DefaultRegionForTheWorld") {
      delete scoffRegions;
      scoffRegions = nullptr;
      nSCoffRegions = 0;
    }
  }
 
  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 > 0) {
      G4cout << " SubCut secondary production is ON for regions: " << G4endl;
      for (G4int i=0; i<nSCoffRegions; ++i) {
        const G4Region* r = (*scoffRegions)[i];
        G4cout << "           " << r->GetName() << G4endl;
      }
    } else if(nullptr != subcutProducer) {
      G4cout << " SubCut secondary production is ON for all regions" << G4endl;
    }
  }
}

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

◆ PrepareWorkerPhysicsTable()

void G4VProcess::PrepareWorkerPhysicsTable ( const G4ParticleDefinition & part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.cc.

{
  PreparePhysicsTable(part);
}

References G4VProcess::PreparePhysicsTable().

Referenced by G4BiasingProcessInterface::PrepareWorkerPhysicsTable().

◆ PrintWarning()

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

private

Definition at line 2032 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);
}

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

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

◆ ProcessDescription()

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

overridevirtual

Reimplemented from G4VProcess.

Definition at line 2046 of file G4VEnergyLossProcess.cc.

{
  if(nullptr != particle) { StreamInfo(out, *particle, true); }
}

References particle, and StreamInfo().

◆ RangeTableForLoss()

G4PhysicsTable * G4VEnergyLossProcess::RangeTableForLoss ( ) const

inline

Definition at line 991 of file G4VEnergyLossProcess.hh.

{
  return theRangeTableForLoss;
}

References theRangeTableForLoss.

Referenced by BuildPhysicsTable(), G4LossTableManager::BuildTables(), G4LossTableManager::CopyTables(), G4LossTableManager::LocalPhysicsTables(), and G4EmCalculator::PrintRangeTable().

◆ ResetNumberOfInteractionLengthLeft()

void G4VProcess::ResetNumberOfInteractionLengthLeft ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4VITProcess, G4WrapperProcess, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 80 of file G4VProcess.cc.

{
  theNumberOfInteractionLengthLeft =  -1.*G4Log( G4UniformRand() );
  theInitialNumberOfInteractionLength = theNumberOfInteractionLengthLeft; 
}

References G4Log(), G4UniformRand, G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

◆ RetrievePhysicsTable()

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

overridevirtual

Reimplemented from G4VProcess.

Definition at line 1484 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(nullptr == 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; }
    }
  }
  return res;
}

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

◆ RetrieveTable()

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

private

Definition at line 1555 of file G4VEnergyLossProcess.cc.

{
  G4bool isRetrieved = false;
  G4String filename = GetPhysicsTableFileName(part,directory,tname,ascii);
  if(nullptr != aTable) {
    if(aTable->ExistPhysicsTable(filename)) {
      if(G4PhysicsTableHelper::RetrievePhysicsTable(aTable,filename,ascii,spline)) {
        isRetrieved = true;
        if(spline) {
          for(auto & v : *aTable) { 
            if(nullptr != v) { v->FillSecondDerivatives(); } 
          }
        }
        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;
}

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

Referenced by RetrievePhysicsTable().

◆ ScaledKinEnergyForLoss()

G4double G4VEnergyLossProcess::ScaledKinEnergyForLoss ( G4double range )

inlineprivate

Definition at line 695 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;
}

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

Referenced by AlongStepDoIt(), and GetKineticEnergy().

◆ SecondaryParticle()

const G4ParticleDefinition * G4VEnergyLossProcess::SecondaryParticle ( ) const

inline

Definition at line 878 of file G4VEnergyLossProcess.hh.

{
  return secondaryParticle;
}

References secondaryParticle.

Referenced by G4LossTableManager::CopyTables().

◆ SecondaryRangeTable()

G4PhysicsTable * G4VEnergyLossProcess::SecondaryRangeTable ( ) const

inline

Definition at line 984 of file G4VEnergyLossProcess.hh.

{
  return theSecondaryRangeTable;
}

References theSecondaryRangeTable.

Referenced by BuildPhysicsTable().

◆ SelectModel()

void G4VEnergyLossProcess::SelectModel ( G4double kinEnergy )

inlineprotected

Definition at line 564 of file G4VEnergyLossProcess.hh.

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

References currentCouple, currentCoupleIndex, currentModel, modelManager, G4EmModelManager::SelectModel(), and G4VEmModel::SetCurrentCouple().

Referenced by CrossSectionPerVolume(), GetDEDXDispersion(), PostStepDoIt(), and PostStepGetPhysicalInteractionLength().

◆ SelectModelForMaterial()

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

inline

Definition at line 572 of file G4VEnergyLossProcess.hh.

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

References modelManager, and G4EmModelManager::SelectModel().

Referenced by G4EmCalculator::FindEmModel(), and G4ContinuousGainOfEnergy::GetContinuousStepLimit().

◆ SetBaseParticle()

void G4VEnergyLossProcess::SetBaseParticle ( const G4ParticleDefinition * p )

inline

Definition at line 856 of file G4VEnergyLossProcess.hh.

{
  baseParticle = p;
}

References baseParticle.

Referenced by G4hIonisation::InitialiseEnergyLossProcess(), and G4ionIonisation::InitialiseEnergyLossProcess().

◆ SetCrossSectionBiasingFactor()

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

Definition at line 1898 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; 
    }
  }
}

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

Referenced by G4EmExtraParameters::DefineRegParamForLoss().

◆ SetCrossSectionType()

void G4VEnergyLossProcess::SetCrossSectionType ( G4CrossSectionType val )

inline

Definition at line 900 of file G4VEnergyLossProcess.hh.

{
  fXSType = val;
}

References fXSType.

Referenced by G4eBremsstrahlung::G4eBremsstrahlung().

◆ SetCSDARangeTable()

void G4VEnergyLossProcess::SetCSDARangeTable ( G4PhysicsTable * pRange )

Definition at line 1720 of file G4VEnergyLossProcess.cc.

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

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), particle, theCSDARangeTable, and G4VProcess::verboseLevel.

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

◆ SetDEDXBinning()

void G4VEnergyLossProcess::SetDEDXBinning ( G4int nbins )

Definition at line 1998 of file G4VEnergyLossProcess.cc.

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

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

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

◆ SetDEDXTable()

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

Definition at line 1689 of file G4VEnergyLossProcess.cc.

{
  if(fTotal == tType) {
    theDEDXunRestrictedTable = p;
 
  } 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(fIsIonisation == tType) {
    /*
      G4cout<< "G4VEnergyLossProcess::SetIonisationTable "
            << particle->GetParticleName()
            << " oldTable " << theDEDXTable << " newTable " << p 
            << " ion " << theIonisationTable 
            << " IsMaster " << isMaster 
            << " " << GetProcessName() << G4endl;
    */
    theIonisationTable = p;
  }
}

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

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

◆ SetDynamicMassCharge()

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

Definition at line 240 of file G4VEnergyLossProcess.cc.

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

References baseMat, biasFactor, chargeSqRatio, currentCoupleIndex, fFactor, G4Log(), logMassRatio, massRatio, and reduceFactor.

Referenced by G4ContinuousGainOfEnergy::AlongStepDoIt(), G4ContinuousGainOfEnergy::GetContinuousStepLimit(), G4ContinuousGainOfEnergy::SetDynamicMassCharge(), and G4EmCalculator::UpdateParticle().

◆ SetEmModel()

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

Definition at line 228 of file G4VEnergyLossProcess.cc.

{
  if(nullptr == ptr) { return; }
  if(nullptr == emModels) { emModels = new std::vector<G4VEmModel*>; }
  if(!emModels->empty()) {
    for(auto & em : *emModels) { if(em == ptr) { return; } }
  }
  emModels->push_back(ptr);  
}

References emModels.

◆ SetFluctModel()

void G4VEnergyLossProcess::SetFluctModel ( G4VEmFluctuationModel * p )

inline

Definition at line 826 of file G4VEnergyLossProcess.hh.

{
  fluctModel = p;
}

References fluctModel.

Referenced by G4EmStandardPhysics_option4::ConstructProcess(), G4MuIonisation::InitialiseEnergyLossProcess(), G4PolarizedIonisation::InitialiseEnergyLossProcess(), G4eIonisation::InitialiseEnergyLossProcess(), G4hIonisation::InitialiseEnergyLossProcess(), G4ionIonisation::InitialiseEnergyLossProcess(), and G4EmConfigurator::PrepareModels().

◆ SetGPILSelection()

void G4VContinuousDiscreteProcess::SetGPILSelection ( G4GPILSelection selection )

inlineprotectedinherited

Definition at line 106 of file G4VContinuousDiscreteProcess.hh.

107 { valueGPILSelection = selection; }

References G4VContinuousDiscreteProcess::valueGPILSelection.

◆ SetInverseRangeTable()

void G4VEnergyLossProcess::SetInverseRangeTable ( G4PhysicsTable * p )

Definition at line 1756 of file G4VEnergyLossProcess.cc.

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

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), particle, theInverseRangeTable, and G4VProcess::verboseLevel.

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

◆ SetIonisation()

void G4VEnergyLossProcess::SetIonisation ( G4bool val )

Definition at line 1959 of file G4VEnergyLossProcess.cc.

{
  isIonisation = val;
  aGPILSelection = (val) ? CandidateForSelection : NotCandidateForSelection;
}

References aGPILSelection, CandidateForSelection, isIonisation, and NotCandidateForSelection.

Referenced by G4LossTableManager::BuildPhysicsTable(), G4LossTableManager::BuildTables(), G4LossTableManager::CopyTables(), G4eBremsstrahlung::G4eBremsstrahlung(), G4ePairProduction::G4ePairProduction(), G4MuBremsstrahlung::G4MuBremsstrahlung(), and G4MuPairProduction::G4MuPairProduction().

◆ SetLambdaTable()

void G4VEnergyLossProcess::SetLambdaTable ( G4PhysicsTable * p )

Definition at line 1768 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(isMaster && nullptr == baseParticle && 
     nullptr != theLambdaTable && fEmTwoPeaks == fXSType) {
 
    size_t n = theLambdaTable->length();
 
    G4double e, ss, xs, ee, e1peak, xs1peak, e1deep, e2peak, e2deep, xs2peak;
 
    // first loop on existing vectors
    for (size_t i=0; i<n; ++i) {
      const G4PhysicsVector* pv = (*theLambdaTable)[i];
      ee = xs = xs1peak = xs2peak = 0.0;
      e1peak = e1deep = e2peak = e2deep = DBL_MAX;
      if(nullptr != pv) {
        size_t nb = pv->GetVectorLength();
        for (size_t j=0; j<nb; ++j) {
          e = pv->Energy(j);
          ss = (*pv)(j);
          // find out 1st peak
          if(e1peak == DBL_MAX) {
            if(ss >= xs) {
              xs = ss;
              ee = e;
              continue;
            } else {
              e1peak = ee;
              xs1peak = xs;
            }
          }
          // find out the deep
          if(e1deep == DBL_MAX) {
            if(ss <= xs) {
              xs = ss;
              ee = e;
              continue;
            } else {
              e1deep = ee;
            }
          }
          // find out 2nd peak
          if(e2peak == DBL_MAX) {
            if(ss >= xs) {
              xs = ss;
              ee = e;
              continue;
            } else {
              e2peak = ee;
              xs2peak = xs;
            }
          }
          if(e2deep == DBL_MAX) {
            if(ss <= xs) {
              xs = ss;
              ee = e;
              continue;
            } else {
              e2deep = ee;
              break;
            }
          }
        }
      }
      G4TwoPeaksXS* x = (*fXSpeaks)[i];
      if(nullptr == x) { 
        x = new G4TwoPeaksXS(); 
        (*fXSpeaks)[i] = x;
      }
      x->e1peak = e1peak;
      x->e1deep = e1deep;
      x->e2peak = e2peak;
      x->e2deep = e2deep;
       
      if(1 < verboseLevel) {
        G4cout << "For " << particle->GetParticleName() 
               << " index= " << i << " data:\n" << " E1peak=" << e1peak 
               << " xs1= " << xs1peak << " E1deep=" << e1deep
               << " E2peak=" << e2peak << " xs2=" << xs2peak 
               << " E2deep=" << e2deep << G4endl;
      }
    }
    // second loop using base materials
    for (size_t i=0; i<n; ++i) {
      const G4PhysicsVector* pv = (*theLambdaTable)[i];
      if (nullptr == pv) {
        G4int j = (*theDensityIdx)[i];
        G4TwoPeaksXS* x = (*fXSpeaks)[i];
        G4TwoPeaksXS* y = (*fXSpeaks)[j];
        if(nullptr == x) { 
          x = new G4TwoPeaksXS(); 
          (*fXSpeaks)[i] = x;
        }
        x->e1peak = y->e1peak;
        x->e1deep = y->e1deep;
        x->e2peak = y->e2peak;
        x->e2deep = y->e2deep;
      }
    }
  }
}

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

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

◆ SetLinearLossLimit()

void G4VEnergyLossProcess::SetLinearLossLimit ( G4double val )

Definition at line 1967 of file G4VEnergyLossProcess.cc.

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

References actLinLossLimit, linLossLimit, and PrintWarning().

Referenced by G4ionIonisation::G4ionIonisation().

◆ SetLossFluctuations()

void G4VEnergyLossProcess::SetLossFluctuations ( G4bool val )

inline

Definition at line 885 of file G4VEnergyLossProcess.hh.

{
  lossFluctuationFlag = val;
  actLossFluc = true;
}

References actLossFluc, and lossFluctuationFlag.

◆ SetLowestEnergyLimit()

void G4VEnergyLossProcess::SetLowestEnergyLimit ( G4double val )

Definition at line 1990 of file G4VEnergyLossProcess.cc.

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

References lowestKinEnergy, and PrintWarning().

◆ SetMasterProcess()

void G4VProcess::SetMasterProcess ( G4VProcess * masterP )

virtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 212 of file G4VProcess.cc.

{
  masterProcessShadow = masterP;
}

References G4VProcess::masterProcessShadow.

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

◆ SetMaxKinEnergy()

void G4VEnergyLossProcess::SetMaxKinEnergy ( G4double e )

Definition at line 2021 of file G4VEnergyLossProcess.cc.

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

References actMaxKinEnergy, maxKinEnergy, maxKinEnergyCSDA, minKinEnergy, and PrintWarning().

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

◆ SetMinKinEnergy()

void G4VEnergyLossProcess::SetMinKinEnergy ( G4double e )

Definition at line 2011 of file G4VEnergyLossProcess.cc.

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

References actMinKinEnergy, maxKinEnergy, minKinEnergy, and PrintWarning().

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

◆ SetParticle()

void G4VEnergyLossProcess::SetParticle ( const G4ParticleDefinition * p )

inlineprotected

Definition at line 840 of file G4VEnergyLossProcess.hh.

{
  particle = p;
}

References particle.

◆ SetPILfactor()

void G4VProcess::SetPILfactor ( G4double value )

inlineinherited

Definition at line 449 of file G4VProcess.hh.

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

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

◆ SetProcessManager()

void G4VProcess::SetProcessManager ( const G4ProcessManager * procMan )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, and G4WrapperProcess.

Definition at line 488 of file G4VProcess.hh.

{
  aProcessManager = procMan; 
}

References G4VProcess::aProcessManager.

Referenced by G4ProcessManager::AddProcess(), G4BiasingProcessInterface::SetProcessManager(), and G4WrapperProcess::SetProcessManager().

◆ SetProcessSubType()

void G4VProcess::SetProcessSubType ( G4int value )

inlineinherited

Definition at line 406 of file G4VProcess.hh.

{
  theProcessSubType = value;
}

References G4VProcess::theProcessSubType.

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

◆ SetProcessType()

void G4VProcess::SetProcessType ( G4ProcessType aType )

inlineinherited

Definition at line 394 of file G4VProcess.hh.

{
  theProcessType = aType;
}

References G4VProcess::theProcessType.

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

◆ SetRangeTableForLoss()

void G4VEnergyLossProcess::SetRangeTableForLoss ( G4PhysicsTable * p )

Definition at line 1732 of file G4VEnergyLossProcess.cc.

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

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), particle, theRangeTableForLoss, and G4VProcess::verboseLevel.

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

◆ SetSecondaryParticle()

void G4VEnergyLossProcess::SetSecondaryParticle ( const G4ParticleDefinition * p )

inlineprotected

Definition at line 848 of file G4VEnergyLossProcess.hh.

{
  secondaryParticle = p;
}

References secondaryParticle.

Referenced by G4eBremsstrahlung::G4eBremsstrahlung(), G4eIonisation::G4eIonisation(), G4ePairProduction::G4ePairProduction(), G4hhIonisation::G4hhIonisation(), G4hIonisation::G4hIonisation(), G4ionIonisation::G4ionIonisation(), G4mplIonisation::G4mplIonisation(), G4MuBremsstrahlung::G4MuBremsstrahlung(), G4MuIonisation::G4MuIonisation(), G4MuPairProduction::G4MuPairProduction(), and G4PolarizedIonisation::G4PolarizedIonisation().

◆ SetSecondaryRangeTable()

void G4VEnergyLossProcess::SetSecondaryRangeTable ( G4PhysicsTable * p )

Definition at line 1744 of file G4VEnergyLossProcess.cc.

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

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), particle, theSecondaryRangeTable, and G4VProcess::verboseLevel.

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

◆ SetSpline()

void G4VEnergyLossProcess::SetSpline ( G4bool val )

inline

Definition at line 893 of file G4VEnergyLossProcess.hh.

{
  spline = val;
}

References spline.

Referenced by G4ePairProduction::G4ePairProduction(), G4MuBremsstrahlung::G4MuBremsstrahlung(), and G4MuPairProduction::G4MuPairProduction().

◆ SetStepFunction()

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

Definition at line 1977 of file G4VEnergyLossProcess.cc.

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

References dRoverRange, finalRange, G4INCL::Math::min(), and PrintWarning().

◆ SetTwoPeaksXS()

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

Definition at line 1884 of file G4VEnergyLossProcess.cc.

{
  fXSpeaks = ptr;
}

References fXSpeaks.

Referenced by BuildPhysicsTable().

◆ SetVerboseLevel()

void G4VProcess::SetVerboseLevel ( G4int value )

inlineinherited

Definition at line 412 of file G4VProcess.hh.

{
  verboseLevel = value;
}

References G4VProcess::verboseLevel.

Referenced by G4EmDNAChemistry::ConstructProcess(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4EmDNAChemistry_option2::ConstructProcess(), G4ProcessTable::DumpInfo(), export_G4VProcess(), G4CoupledTransportation::G4CoupledTransportation(), G4GammaGeneralProcess::G4GammaGeneralProcess(), G4hhIonisation::G4hhIonisation(), G4mplIonisation::G4mplIonisation(), G4Transportation::G4Transportation(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), G4CoulombScattering::InitialiseProcess(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4ProcessManagerMessenger::SetNewValue(), and G4ProcessTableMessenger::SetNewValue().

◆ StartTracking()

void G4VEnergyLossProcess::StartTracking ( G4Track * track )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 829 of file G4VEnergyLossProcess.cc.

{
  /*
  G4cout << "G4VEnergyLossProcess::StartTracking: " 
         << track->GetDefinition()->GetParticleName() 
         << " e(MeV)= " << track->GetKineticEnergy();
  if(particle) G4cout << "  " << particle->GetParticleName();
  if(baseParticle) G4cout << " basePart: " << baseParticle->GetParticleName();
  G4cout << "  " << GetProcessName();
  if(isIon) G4cout << " isIon:  Q=" << track->GetDefinition()->GetPDGCharge() 
  << " Qdyn=" << track->GetDynamicParticle()->GetCharge(); 
  G4cout << G4endl;
  */
  // reset parameters for the new track
  theNumberOfInteractionLengthLeft = -1.0;
  mfpKinEnergy = DBL_MAX;
  currentCouple = nullptr;
 
  // reset ion
  if(isIon) {
    const G4double newmass = track->GetDefinition()->GetPDGMass();
    if(nullptr != baseParticle) {
      massRatio    = baseParticle->GetPDGMass()/newmass;
      logMassRatio = G4Log(massRatio);
    } else if(nullptr != theGenericIon) {
      massRatio    = CLHEP::proton_mass_c2/newmass;
      logMassRatio = G4Log(massRatio);
    } else {
      massRatio    = 1.0;
      logMassRatio = 0.0;
    }
  }  
  // forced biasing only for primary particles
  if(biasManager) {
    if(0 == track->GetParentID()) {
      biasFlag = true; 
      biasManager->ResetForcedInteraction(); 
    }
  }
}

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

◆ StorePhysicsTable()

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

overridevirtual

Reimplemented from G4VProcess.

Definition at line 1445 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,theIonisationTable,ascii,directory,"Ionisation")) 
    {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;}
 
  return res;
}

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

◆ StoreTable()

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

private

Definition at line 1534 of file G4VEnergyLossProcess.cc.

{
  G4bool res = true;
  if (nullptr != aTable) {
    const G4String& name = GetPhysicsTableFileName(part, directory, tname, ascii);
    if ( aTable->StorePhysicsTable(name,ascii) ) {
      if (0 < verboseLevel) G4cout << "Stored: " << name << G4endl;
    } else {
      res = false;
      G4cout << "Fail to store: " << name << G4endl;
    }
  }
  return res;
}

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

Referenced by StorePhysicsTable().

◆ StreamInfo()

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

private

Definition at line 730 of file G4VEnergyLossProcess.cc.

{
  G4String indent = (rst ? "  " : "");
  out << std::setprecision(6);
  out << G4endl << indent << GetProcessName()  << ": ";
  if (!rst) out << " for " << part.GetParticleName();
  out << "  XStype:" << fXSType 
      << "  SubType=" << GetProcessSubType() << G4endl
      << "      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/decade, spline: " << spline
      << G4endl;
  if(nullptr != theRangeTableForLoss && isIonisation) {
    out << "      StepFunction=(" << dRoverRange << ", "
        << finalRange/mm << " mm)"
        << ", integ: " << fXSType
        << ", fluct: " << lossFluctuationFlag
        << ", linLossLim= " << linLossLimit
        << G4endl;
  }
  StreamProcessInfo(out);
  modelManager->DumpModelList(out, verboseLevel);
  if(nullptr != theCSDARangeTable && isIonisation) {
    out << "      CSDA range table up"
        << " to " << G4BestUnit(maxKinEnergyCSDA,"Energy")
        << " in " << nBinsCSDA << " bins" << G4endl;
  }
  if(nSCoffRegions>0 && isIonisation) {
    out << "      Subcutoff sampling in " << nSCoffRegions 
        << " regions" << G4endl;
  }
  if(2 < verboseLevel) {
    out << "      DEDXTable address= " << theDEDXTable << G4endl; 
    if(nullptr != theDEDXTable && isIonisation) 
      out << (*theDEDXTable) << G4endl;
    out << "non restricted DEDXTable address= " 
        << theDEDXunRestrictedTable << G4endl;
    if(nullptr != theDEDXunRestrictedTable && isIonisation) {
      out << (*theDEDXunRestrictedTable) << G4endl;
    }
    out << "      CSDARangeTable address= " << theCSDARangeTable << G4endl;
    if(nullptr != theCSDARangeTable && isIonisation) {
      out << (*theCSDARangeTable) << G4endl;
    }
    out << "      RangeTableForLoss address= " << theRangeTableForLoss 
        << G4endl;
    if(nullptr != theRangeTableForLoss && isIonisation) {
      out << (*theRangeTableForLoss) << G4endl;
    }
    out << "      InverseRangeTable address= " << theInverseRangeTable 
        << G4endl;
    if(nullptr != theInverseRangeTable && isIonisation) {
      out << (*theInverseRangeTable) << G4endl;
    }
    out << "      LambdaTable address= " << theLambdaTable << G4endl;
    if(nullptr != theLambdaTable) {
      out << (*theLambdaTable) << G4endl;
    }
  }
}

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

Referenced by BuildPhysicsTable(), and ProcessDescription().

◆ StreamProcessInfo()

virtual void G4VEnergyLossProcess::StreamProcessInfo ( std::ostream & ) const

inlineprotectedvirtual

Reimplemented in G4ePairProduction, G4MuPairProduction, G4eBremsstrahlung, and G4ionIonisation.

Definition at line 97 of file G4VEnergyLossProcess.hh.

97{};

Referenced by StreamInfo().

◆ SubtractNumberOfInteractionLengthLeft()

void G4VProcess::SubtractNumberOfInteractionLengthLeft ( G4double prevStepSize )

inlineprotectedinherited

Definition at line 524 of file G4VProcess.hh.

{
  if (currentInteractionLength>0.0)
  {
    theNumberOfInteractionLengthLeft -= prevStepSize/currentInteractionLength;
    if(theNumberOfInteractionLengthLeft<0.)
    {
       theNumberOfInteractionLengthLeft=CLHEP::perMillion;
    }
  }
  else
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cerr << "G4VProcess::SubtractNumberOfInteractionLengthLeft()";
      G4cerr << " [" << theProcessName << "]" <<G4endl;
      G4cerr << " currentInteractionLength = "
             << currentInteractionLength << " [mm]";
      G4cerr << " previousStepSize = " << prevStepSize << " [mm]";
      G4cerr << G4endl;
    }
#endif
    G4String msg = "Negative currentInteractionLength for ";
    msg += theProcessName;
    G4Exception("G4VProcess::SubtractNumberOfInteractionLengthLeft()",
                "ProcMan201", EventMustBeAborted, msg);
  }
}