#include <G4PolarizedIonisation.hh>

Inheritance diagram for G4PolarizedIonisation:

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)

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 override

G4VEmModel *	EmModel (size_t index=0) const

virtual void	EndTracking ()

G4VEmFluctuationModel *	FluctModel () const

	G4PolarizedIonisation (const G4PolarizedIonisation &)=delete

	G4PolarizedIonisation (const G4String &name="pol-eIoni")

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 &p) override

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

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

G4bool	operator== (const G4VProcess &right) const

const G4ParticleDefinition *	Particle () const

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

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

void	PreparePhysicsTable (const G4ParticleDefinition &) override

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

virtual void	ProcessDescription (std::ostream &) 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

virtual	~G4PolarizedIonisation () override

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

Protected Member Functions
virtual void	BuildPhysicsTable (const G4ParticleDefinition &) override

void	ClearNumberOfInteractionLengthLeft ()

size_t	CurrentMaterialCutsCoupleIndex () const

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

G4GPILSelection	GetGPILSelection () const

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

virtual void	InitialiseEnergyLossProcess (const G4ParticleDefinition , const G4ParticleDefinition ) override

G4PhysicsVector *	LambdaPhysicsVector (const G4MaterialCutsCouple *, G4double cut)

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

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

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	BuildAsymmetryTables (const G4ParticleDefinition &part)

void	CleanTables ()

G4double	ComputeAsymmetry (G4double energy, const G4MaterialCutsCouple *couple, const G4ParticleDefinition &particle, G4double cut, G4double &tasm)

void	ComputeLambdaForScaledEnergy (G4double scaledKinE, G4double logScaledKinE)

G4double	ComputeSaturationFactor (const G4Track &aTrack)

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

G4PhysicsTable *	fAsymmetryTable

G4PolarizedIonisationModel *	fEmModel

G4double	fFactor = 1.0

G4VEmFluctuationModel *	fFlucModel

G4double	finalRange

G4bool	fIsElectron

G4bool	fIsInitialised

G4double	fLambda = 0.0

G4double	fLambdaEnergy = 0.0

G4VEmFluctuationModel *	fluctModel = nullptr

G4ProcessTable *	fProcessTable = nullptr

G4double	fRange = 0.0

G4double	fRangeEnergy = 0.0

G4PhysicsTable *	fTransverseAsymmetryTable

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 52 of file G4PolarizedIonisation.hh.

Constructor & Destructor Documentation

◆ G4PolarizedIonisation() [1/2]

G4PolarizedIonisation::G4PolarizedIonisation ( const G4String & name = "pol-eIoni" )

explicit

Definition at line 50 of file G4PolarizedIonisation.cc.

  : G4VEnergyLossProcess(name)
  , fAsymmetryTable(nullptr)
  , fTransverseAsymmetryTable(nullptr)
  , fIsElectron(true)
  , fIsInitialised(false)
{
  verboseLevel = 0;
  SetProcessSubType(fIonisation);
  SetSecondaryParticle(G4Electron::Electron());
  fFlucModel = nullptr;
  fEmModel   = nullptr;
}

References G4Electron::Electron(), fEmModel, fFlucModel, fIonisation, G4VProcess::SetProcessSubType(), G4VEnergyLossProcess::SetSecondaryParticle(), and G4VProcess::verboseLevel.

◆ ~G4PolarizedIonisation()

G4PolarizedIonisation::~G4PolarizedIonisation ( )

overridevirtual

Definition at line 65 of file G4PolarizedIonisation.cc.

65{ CleanTables(); }

G4PolarizedIonisation::CleanTables

void CleanTables()

Definition: G4PolarizedIonisation.cc:76

References CleanTables().

◆ G4PolarizedIonisation() [2/2]

G4PolarizedIonisation::G4PolarizedIonisation ( const G4PolarizedIonisation & )

delete

Member Function Documentation

◆ ActivateForcedInteraction()

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

inherited

Definition at line 1915 of file G4VEnergyLossProcess.cc.

{
  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(), G4VEnergyLossProcess::biasManager, G4cout, G4endl, G4VProcess::GetProcessName(), mm, G4VProcess::verboseLevel, and G4VEnergyLossProcess::weightFlag.

Referenced by G4EmExtraParameters::DefineRegParamForLoss().

◆ ActivateSecondaryBiasing()

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

inherited

Definition at line 1935 of file G4VEnergyLossProcess.cc.

{
  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(), G4VEnergyLossProcess::biasManager, G4Electron::Electron(), G4cout, G4endl, G4VProcess::GetProcessName(), MeV, G4VEnergyLossProcess::secondaryParticle, and G4VProcess::verboseLevel.

Referenced by G4EmExtraParameters::DefineRegParamForLoss().

◆ ActivateSubCutoff()

void G4VEnergyLossProcess::ActivateSubCutoff ( const G4Region * region )

inherited

Definition at line 799 of file G4VEnergyLossProcess.cc.

{
  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 G4VEnergyLossProcess::nSCoffRegions, reg, and G4VEnergyLossProcess::scoffRegions.

Referenced by G4EmExtraParameters::DefineRegParamForLoss().

◆ AddEmModel()

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

inherited

Definition at line 216 of file G4VEnergyLossProcess.cc.

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

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

◆ AlongStepDoIt()

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

overridevirtualinherited

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;
}

◆ AlongStepGetPhysicalInteractionLength()

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

overridevirtualinherited

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 872 of file G4VEnergyLossProcess.cc.

{
  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;
}

Referenced by G4VEnergyLossProcess::ContinuousStepLimit().

◆ AlongStepGPIL()

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

inlineinherited

Definition at line 461 of file G4VProcess.hh.

{
  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

inlineinherited

Definition at line 870 of file G4VEnergyLossProcess.hh.

{
  return baseParticle;
}

References G4VEnergyLossProcess::baseParticle.

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

◆ BuildAsymmetryTables()

void G4PolarizedIonisation::BuildAsymmetryTables ( const G4ParticleDefinition & part )

private

Definition at line 296 of file G4PolarizedIonisation.cc.

{
  // cleanup old, initialise new table
  CleanTables();
  fAsymmetryTable = G4PhysicsTableHelper::PreparePhysicsTable(fAsymmetryTable);
  fTransverseAsymmetryTable =
    G4PhysicsTableHelper::PreparePhysicsTable(fTransverseAsymmetryTable);
 
  const G4ProductionCutsTable* theCoupleTable =
    G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();
 
  for(size_t j = 0; j < numOfCouples; ++j)
  {
    // get cut value
    const G4MaterialCutsCouple* couple =
      theCoupleTable->GetMaterialCutsCouple(j);
 
    G4double cut = (*theCoupleTable->GetEnergyCutsVector(1))[j];
 
    // create physics vectors then fill it (same parameters as lambda vector)
    G4PhysicsVector* ptrVectorA = LambdaPhysicsVector(couple, cut);
    G4PhysicsVector* ptrVectorB = LambdaPhysicsVector(couple, cut);
    size_t bins                 = ptrVectorA->GetVectorLength();
 
    for(size_t i = 0; i < bins; ++i)
    {
      G4double lowEdgeEnergy = ptrVectorA->Energy(i);
      G4double tasm          = 0.;
      G4double asym = ComputeAsymmetry(lowEdgeEnergy, couple, part, cut, tasm);
      ptrVectorA->PutValue(i, asym);
      ptrVectorB->PutValue(i, tasm);
    }
    fAsymmetryTable->insertAt(j, ptrVectorA);
    fTransverseAsymmetryTable->insertAt(j, ptrVectorB);
  }
}

References anonymous_namespace{G4HyperonSampler.cc}::bins, CleanTables(), ComputeAsymmetry(), G4PhysicsVector::Energy(), fAsymmetryTable, fTransverseAsymmetryTable, G4ProductionCutsTable::GetEnergyCutsVector(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4PhysicsVector::GetVectorLength(), G4PhysicsTable::insertAt(), G4VEnergyLossProcess::LambdaPhysicsVector(), G4PhysicsTableHelper::PreparePhysicsTable(), and G4PhysicsVector::PutValue().

Referenced by BuildPhysicsTable().

◆ BuildDEDXTable()

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

inherited

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;
}

Referenced by G4LossTableManager::BuildTables().

◆ BuildLambdaTable()

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

inherited

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;
}

Referenced by G4LossTableManager::BuildTables().

◆ BuildPhysicsTable()

void G4PolarizedIonisation::BuildPhysicsTable ( const G4ParticleDefinition & part )

overrideprotectedvirtual

Reimplemented from G4VProcess.

Definition at line 278 of file G4PolarizedIonisation.cc.

{
  // *** build DEDX and (unpolarized) cross section tables
  G4VEnergyLossProcess::BuildPhysicsTable(part);
  G4bool master = true;
  const G4PolarizedIonisation* masterProcess =
    static_cast<const G4PolarizedIonisation*>(GetMasterProcess());
  if(masterProcess && masterProcess != this)
  {
    master = false;
  }
  if(master)
  {
    BuildAsymmetryTables(part);
  }
}

References BuildAsymmetryTables(), G4VEnergyLossProcess::BuildPhysicsTable(), and G4VProcess::GetMasterProcess().

◆ 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().

◆ CleanTables()

void G4PolarizedIonisation::CleanTables ( )

private

Definition at line 76 of file G4PolarizedIonisation.cc.

{
  if(fAsymmetryTable)
  {
    fAsymmetryTable->clearAndDestroy();
    delete fAsymmetryTable;
    fAsymmetryTable = nullptr;
  }
  if(fTransverseAsymmetryTable)
  {
    fTransverseAsymmetryTable->clearAndDestroy();
    delete fTransverseAsymmetryTable;
    fTransverseAsymmetryTable = nullptr;
  }
}

References G4PhysicsTable::clearAndDestroy(), fAsymmetryTable, and fTransverseAsymmetryTable.

Referenced by BuildAsymmetryTables(), and ~G4PolarizedIonisation().

◆ 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.

◆ ComputeAsymmetry()

G4double G4PolarizedIonisation::ComputeAsymmetry	(	G4double	energy,
		const G4MaterialCutsCouple *	couple,
		const G4ParticleDefinition &	particle,
		G4double	cut,
		G4double &	tasm
	)

private

Definition at line 336 of file G4PolarizedIonisation.cc.

{
  G4double lAsymmetry = 0.0;
  tAsymmetry          = 0.0;
  if(fIsElectron)
  {
    lAsymmetry = tAsymmetry = -1.0;
  }
 
  // calculate polarized cross section
  G4ThreeVector targetPolarization = G4ThreeVector(0., 0., 1.);
  fEmModel->SetTargetPolarization(targetPolarization);
  fEmModel->SetBeamPolarization(targetPolarization);
  G4double sigma2 =
    fEmModel->CrossSection(couple, &aParticle, energy, cut, energy);
 
  // calculate transversely polarized cross section
  targetPolarization = G4ThreeVector(1., 0., 0.);
  fEmModel->SetTargetPolarization(targetPolarization);
  fEmModel->SetBeamPolarization(targetPolarization);
  G4double sigma3 =
    fEmModel->CrossSection(couple, &aParticle, energy, cut, energy);
 
  // calculate unpolarized cross section
  targetPolarization = G4ThreeVector();
  fEmModel->SetTargetPolarization(targetPolarization);
  fEmModel->SetBeamPolarization(targetPolarization);
  G4double sigma0 =
    fEmModel->CrossSection(couple, &aParticle, energy, cut, energy);
  // determine asymmetries
  if(sigma0 > 0.)
  {
    lAsymmetry = sigma2 / sigma0 - 1.;
    tAsymmetry = sigma3 / sigma0 - 1.;
  }
  if(std::fabs(lAsymmetry) > 1.)
  {
    G4ExceptionDescription ed;
    ed << "G4PolarizedIonisation::ComputeAsymmetry : E(MeV)= " << energy
       << " lAsymmetry= " << lAsymmetry << " (" << std::fabs(lAsymmetry) - 1.
       << ")";
    G4Exception("G4PolarizedIonisation::ComputeAsymmetry", "pol002",
                JustWarning, ed);
  }
  if(std::fabs(tAsymmetry) > 1.)
  {
    G4ExceptionDescription ed;
    ed << "G4PolarizedIonisation::ComputeAsymmetry : E(MeV)= " << energy
       << " tAsymmetry= " << tAsymmetry << " (" << std::fabs(tAsymmetry) - 1.
       << ")";
    G4Exception("G4PolarizedIonisation::ComputeAsymmetry", "pol003",
                JustWarning, ed);
  }
  return lAsymmetry;
}

References G4VEmModel::CrossSection(), G4INCL::KinematicsUtils::energy(), fEmModel, fIsElectron, G4Exception(), JustWarning, G4PolarizedIonisationModel::SetBeamPolarization(), and G4PolarizedIonisationModel::SetTargetPolarization().

Referenced by BuildAsymmetryTables().

◆ ComputeLambdaForScaledEnergy()

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

privateinherited

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 G4VEnergyLossProcess::basedCoupleIndex, e1, G4TwoPeaksXS::e1deep, G4TwoPeaksXS::e1peak, G4TwoPeaksXS::e2deep, G4TwoPeaksXS::e2peak, fEmIncreasing, fEmTwoPeaks, G4VEnergyLossProcess::fXSType, G4VEnergyLossProcess::GetLambdaForScaledEnergy(), G4VEnergyLossProcess::lambdaFactor, G4INCL::Math::max(), G4VEnergyLossProcess::mfpKinEnergy, and G4VEnergyLossProcess::preStepLambda.

Referenced by G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength().

◆ ComputeSaturationFactor()

G4double G4PolarizedIonisation::ComputeSaturationFactor ( const G4Track & aTrack )

private

Definition at line 196 of file G4PolarizedIonisation.cc.

{
  G4Material* aMaterial       = track.GetMaterial();
  G4VPhysicalVolume* aPVolume = track.GetVolume();
  G4LogicalVolume* aLVolume   = aPVolume->GetLogicalVolume();
 
  G4PolarizationManager* polarizationManager =
    G4PolarizationManager::GetInstance();
 
  const G4bool volumeIsPolarized = polarizationManager->IsPolarized(aLVolume);
  G4StokesVector volPolarization =
    polarizationManager->GetVolumePolarization(aLVolume);
 
  G4double factor = 1.0;
 
  if(volumeIsPolarized && !volPolarization.IsZero())
  {
    // *** get asymmetry, if target is polarized ***
    const G4DynamicParticle* aDynamicPart = track.GetDynamicParticle();
    const G4double energy                 = aDynamicPart->GetKineticEnergy();
    const G4StokesVector polarization = G4StokesVector(track.GetPolarization());
    const G4ParticleMomentum direction0 = aDynamicPart->GetMomentumDirection();
 
    if(verboseLevel >= 2)
    {
      G4cout << "G4PolarizedIonisation::ComputeSaturationFactor: " << G4endl;
      G4cout << " Energy(MeV)  " << energy / MeV << G4endl;
      G4cout << " Direction    " << direction0 << G4endl;
      G4cout << " Polarization " << polarization << G4endl;
      G4cout << " MaterialPol. " << volPolarization << G4endl;
      G4cout << " Phys. Volume " << aPVolume->GetName() << G4endl;
      G4cout << " Log. Volume  " << aLVolume->GetName() << G4endl;
      G4cout << " Material     " << aMaterial << G4endl;
    }
 
    size_t midx                    = CurrentMaterialCutsCoupleIndex();
    const G4PhysicsVector* aVector = nullptr;
    const G4PhysicsVector* bVector = nullptr;
    if(midx < fAsymmetryTable->size())
    {
      aVector = (*fAsymmetryTable)(midx);
    }
    if(midx < fTransverseAsymmetryTable->size())
    {
      bVector = (*fTransverseAsymmetryTable)(midx);
    }
    if(aVector && bVector)
    {
      G4double lAsymmetry = aVector->Value(energy);
      G4double tAsymmetry = bVector->Value(energy);
      G4double polZZ      = polarization.z() * (volPolarization * direction0);
      G4double polXX =
        polarization.x() *
        (volPolarization * G4PolarizationHelper::GetParticleFrameX(direction0));
      G4double polYY =
        polarization.y() *
        (volPolarization * G4PolarizationHelper::GetParticleFrameY(direction0));
 
      factor /= (1. + polZZ * lAsymmetry + (polXX + polYY) * tAsymmetry);
 
      if(verboseLevel >= 2)
      {
        G4cout << " Asymmetry:     " << lAsymmetry << ", " << tAsymmetry
               << G4endl;
        G4cout << " PolProduct:    " << polXX << ", " << polYY << ", " << polZZ
               << G4endl;
        G4cout << " Factor:        " << factor << G4endl;
      }
    }
    else
    {
      G4ExceptionDescription ed;
      ed << "Problem with asymmetry tables: material index " << midx
         << " is out of range or tables are not filled";
      G4Exception("G4PolarizedIonisation::ComputeSaturationFactor", "em0048",
                  JustWarning, ed, "");
    }
  }
  return factor;
}

References G4VEnergyLossProcess::CurrentMaterialCutsCoupleIndex(), G4INCL::KinematicsUtils::energy(), G4cout, G4endl, G4Exception(), G4Track::GetDynamicParticle(), G4PolarizationManager::GetInstance(), G4DynamicParticle::GetKineticEnergy(), G4VPhysicalVolume::GetLogicalVolume(), G4Track::GetMaterial(), G4DynamicParticle::GetMomentumDirection(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetName(), G4PolarizationHelper::GetParticleFrameX(), G4PolarizationHelper::GetParticleFrameY(), G4Track::GetPolarization(), G4Track::GetVolume(), G4PolarizationManager::GetVolumePolarization(), G4PolarizationManager::IsPolarized(), G4StokesVector::IsZero(), JustWarning, MeV, G4PhysicsVector::Value(), G4VProcess::verboseLevel, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by GetMeanFreePath(), and PostStepGetPhysicalInteractionLength().

◆ ContinuousStepLimit()

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

inherited

Definition at line 1647 of file G4VEnergyLossProcess.cc.

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

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

◆ CrossSectionBiasingFactor()

G4double G4VEnergyLossProcess::CrossSectionBiasingFactor ( ) const

inlineinherited

Definition at line 942 of file G4VEnergyLossProcess.hh.

{
  return biasFactor;
}

References G4VEnergyLossProcess::biasFactor.

◆ CrossSectionPerVolume() [1/2]

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

inherited

◆ CrossSectionPerVolume() [2/2]

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

inherited

Definition at line 1614 of file G4VEnergyLossProcess.cc.

{
  // 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);
}

◆ CrossSectionType()

G4CrossSectionType G4VEnergyLossProcess::CrossSectionType ( ) const

inlineinherited

Definition at line 907 of file G4VEnergyLossProcess.hh.

{
  return fXSType;
}

References G4VEnergyLossProcess::fXSType.

◆ CSDARangeTable()

G4PhysicsTable * G4VEnergyLossProcess::CSDARangeTable ( ) const

inlineinherited

Definition at line 977 of file G4VEnergyLossProcess.hh.

{
  return theCSDARangeTable;
}

References G4VEnergyLossProcess::theCSDARangeTable.

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

◆ CurrentMaterialCutsCoupleIndex()

size_t G4VEnergyLossProcess::CurrentMaterialCutsCoupleIndex ( ) const

inlineprotectedinherited

Definition at line 557 of file G4VEnergyLossProcess.hh.

{
  return currentCoupleIndex;
}

References G4VEnergyLossProcess::currentCoupleIndex.

Referenced by ComputeSaturationFactor().

◆ DEDXTable()

G4PhysicsTable * G4VEnergyLossProcess::DEDXTable ( ) const

inlineinherited

Definition at line 956 of file G4VEnergyLossProcess.hh.

{
  return theDEDXTable;
}

References G4VEnergyLossProcess::theDEDXTable.

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

◆ DEDXunRestrictedTable()

G4PhysicsTable * G4VEnergyLossProcess::DEDXunRestrictedTable ( ) const

inlineinherited

Definition at line 963 of file G4VEnergyLossProcess.hh.

{
  return theDEDXunRestrictedTable;
}

References G4VEnergyLossProcess::theDEDXunRestrictedTable.

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

◆ DefineMaterial()

void G4VEnergyLossProcess::DefineMaterial ( const G4MaterialCutsCouple * couple )

inlineprivateinherited

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);
  }
}

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

◆ DumpInfo()

virtual void G4PolarizedIonisation::DumpInfo ( ) const

inlineoverridevirtual

Reimplemented from G4VProcess.

Definition at line 62 of file G4PolarizedIonisation.hh.

62{ ProcessDescription(G4cout); };

G4PolarizedIonisation::ProcessDescription

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

Definition: G4PolarizedIonisation.cc:68

References G4cout, and ProcessDescription().

◆ EmModel()

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

inlineinherited

Definition at line 1033 of file G4VEnergyLossProcess.hh.

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

References G4VEnergyLossProcess::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 )

privateinherited

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(), G4VEnergyLossProcess::biasID, G4VEnergyLossProcess::biasManager, G4VEnergyLossProcess::currentCoupleIndex, G4VEnergyLossProcess::fParticleChange, CLHEP::detail::n, G4VProcess::pParticleChange, G4VEnergyLossProcess::scTracks, G4EmBiasingManager::SecondaryBiasingRegion(), G4Track::SetCreatorModelID(), G4VParticleChange::SetNumberOfSecondaries(), and G4Track::SetWeight().

Referenced by G4VEnergyLossProcess::AlongStepDoIt().

◆ FluctModel()

G4VEmFluctuationModel * G4VEnergyLossProcess::FluctModel ( ) const

inlineinherited

Definition at line 833 of file G4VEnergyLossProcess.hh.

{
  return fluctModel;
}

References G4VEnergyLossProcess::fluctModel.

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

◆ GetContinuousStepLimit()

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

overrideprotectedvirtualinherited

Implements G4VContinuousDiscreteProcess.

Definition at line 1668 of file G4VEnergyLossProcess.cc.

{
  return DBL_MAX;
}

References DBL_MAX.

◆ GetCSDADEDX()

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

inlineinherited

◆ GetCSDARange()

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

inlineinherited

Definition at line 782 of file G4VEnergyLossProcess.hh.

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

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

Referenced by G4LossTableManager::GetCSDARange().

◆ GetCurrentElement()

const G4Element * G4VEnergyLossProcess::GetCurrentElement ( ) const

inherited

Definition at line 1891 of file G4VEnergyLossProcess.cc.

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

References G4VEnergyLossProcess::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
	)

inlineinherited

Definition at line 740 of file G4VEnergyLossProcess.hh.

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

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

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

◆ GetDEDX() [2/2]

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

inlineinherited

Definition at line 750 of file G4VEnergyLossProcess.hh.

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

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

◆ GetDEDXDispersion()

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

inherited

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 G4VEnergyLossProcess::currentCoupleIndex, G4VEnergyLossProcess::currentMaterial, G4VEnergyLossProcess::currentModel, G4VEnergyLossProcess::DefineMaterial(), G4VEmFluctuationModel::Dispersion(), G4DynamicParticle::GetKineticEnergy(), G4VEmModel::GetModelOfFluctuations(), G4VEnergyLossProcess::massRatio, G4VEmModel::MaxSecondaryKinEnergy(), G4INCL::Math::min(), G4VEnergyLossProcess::SelectModel(), and G4VEnergyLossProcess::theCuts.

Referenced by G4LossTableManager::GetDEDXDispersion().

◆ GetDEDXForScaledEnergy() [1/2]

G4double G4VEnergyLossProcess::GetDEDXForScaledEnergy ( G4double scaledKinE )

inlineprivateinherited

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 G4VEnergyLossProcess::basedCoupleIndex, G4VEnergyLossProcess::fFactor, G4VEnergyLossProcess::idxDEDX, and G4VEnergyLossProcess::minKinEnergy.

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

◆ GetDEDXForScaledEnergy() [2/2]

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

inlineprivateinherited

Definition at line 613 of file G4VEnergyLossProcess.hh.

{
  /*
  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 G4VEnergyLossProcess::basedCoupleIndex, G4VEnergyLossProcess::fFactor, and G4VEnergyLossProcess::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 )

inlineprivateinherited

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 G4VEnergyLossProcess::basedCoupleIndex, G4VEnergyLossProcess::fFactor, G4VEnergyLossProcess::idxIonisation, and G4VEnergyLossProcess::minKinEnergy.

◆ GetKineticEnergy()

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

inlineinherited

Definition at line 793 of file G4VEnergyLossProcess.hh.

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

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

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

◆ GetLambda() [1/2]

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

inlineinherited

Definition at line 803 of file G4VEnergyLossProcess.hh.

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

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

◆ GetLambda() [2/2]

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

inlineinherited

Definition at line 814 of file G4VEnergyLossProcess.hh.

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

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

◆ GetLambdaForScaledEnergy() [1/2]

G4double G4VEnergyLossProcess::GetLambdaForScaledEnergy ( G4double scaledKinE )

inlineprivateinherited

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 G4VEnergyLossProcess::basedCoupleIndex, G4VEnergyLossProcess::coupleIdxLambda, G4VEnergyLossProcess::currentCoupleIndex, G4VEnergyLossProcess::fFactor, G4VEnergyLossProcess::fLambda, G4VEnergyLossProcess::fLambdaEnergy, and G4VEnergyLossProcess::idxLambda.

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

◆ GetLambdaForScaledEnergy() [2/2]

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

inlineprivateinherited

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 G4VEnergyLossProcess::basedCoupleIndex, G4VEnergyLossProcess::coupleIdxLambda, G4VEnergyLossProcess::currentCoupleIndex, G4VEnergyLossProcess::fFactor, G4VEnergyLossProcess::fLambda, and G4VEnergyLossProcess::fLambdaEnergy.

◆ GetLimitScaledRangeForScaledEnergy() [1/2]

G4double G4VEnergyLossProcess::GetLimitScaledRangeForScaledEnergy ( G4double scaledKinE )

inlineprivateinherited

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 G4VEnergyLossProcess::basedCoupleIndex, G4VEnergyLossProcess::idxCSDA, and G4VEnergyLossProcess::minKinEnergy.

Referenced by G4VEnergyLossProcess::GetCSDARange().

◆ GetLimitScaledRangeForScaledEnergy() [2/2]

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

inlineprivateinherited

Definition at line 685 of file G4VEnergyLossProcess.hh.

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

References G4VEnergyLossProcess::basedCoupleIndex, and G4VEnergyLossProcess::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(), BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4BiasingProcessInterface::SetMasterProcess(), and G4VMultipleScattering::StorePhysicsTable().

◆ GetMeanFreePath()

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

overrideprotectedvirtual

Implements G4VContinuousDiscreteProcess.

Definition at line 139 of file G4PolarizedIonisation.cc.

{
  // *** get unploarised mean free path from lambda table ***
  G4double mfp = G4VEnergyLossProcess::GetMeanFreePath(track, step, cond);
  if(fAsymmetryTable && fTransverseAsymmetryTable && mfp < DBL_MAX)
  {
    mfp *= ComputeSaturationFactor(track);
  }
  if(verboseLevel >= 2)
  {
    G4cout << "G4PolarizedIonisation::MeanFreePath:  " << mfp / mm << " mm "
           << G4endl;
  }
  return mfp;
}

References ComputeSaturationFactor(), DBL_MAX, fAsymmetryTable, fTransverseAsymmetryTable, G4cout, G4endl, G4VEnergyLossProcess::GetMeanFreePath(), mm, and G4VProcess::verboseLevel.

◆ GetModelByIndex()

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

inlineinherited

Definition at line 1042 of file G4VEnergyLossProcess.hh.

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

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

Referenced by G4VEnergyLossProcess::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(), G4VEnergyLossProcess::RetrieveTable(), G4GammaGeneralProcess::StorePhysicsTable(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), and G4VEnergyLossProcess::StoreTable().

◆ GetPILfactor()

G4double G4VProcess::GetPILfactor ( ) const

inlineinherited

Definition at line 455 of file G4VProcess.hh.

{
  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(), G4VEnergyLossProcess::PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4PhysicsListHelper::RegisterProcess(), G4ElectronIonPair::ResidualeChargePostStep(), G4EmConfigurator::SetModelForRegion(), G4ChannelingOptrChangeCrossSection::StartRun(), G4VEnergyLossProcess::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
	)

inlineinherited

Definition at line 761 of file G4VEnergyLossProcess.hh.

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

References G4VEnergyLossProcess::DefineMaterial(), G4VEnergyLossProcess::GetScaledRangeForScaledEnergy(), and G4VEnergyLossProcess::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
	)

inlineinherited

Definition at line 771 of file G4VEnergyLossProcess.hh.

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

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

◆ GetScaledRangeForScaledEnergy() [1/2]

G4double G4VEnergyLossProcess::GetScaledRangeForScaledEnergy ( G4double scaledKinE )

inlineprivateinherited

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 G4VEnergyLossProcess::basedCoupleIndex, G4VEnergyLossProcess::coupleIdxRange, G4VEnergyLossProcess::currentCoupleIndex, G4VEnergyLossProcess::fRange, G4VEnergyLossProcess::fRangeEnergy, G4VEnergyLossProcess::idxRange, G4VEnergyLossProcess::minKinEnergy, and G4VEnergyLossProcess::reduceFactor.

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

◆ GetScaledRangeForScaledEnergy() [2/2]

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

inlineprivateinherited

Definition at line 655 of file G4VEnergyLossProcess.hh.

{
  //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 G4VEnergyLossProcess::basedCoupleIndex, G4VEnergyLossProcess::coupleIdxRange, G4VEnergyLossProcess::currentCoupleIndex, G4VEnergyLossProcess::fRange, G4VEnergyLossProcess::fRangeEnergy, G4VEnergyLossProcess::minKinEnergy, and G4VEnergyLossProcess::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()

void G4PolarizedIonisation::InitialiseEnergyLossProcess	(	const G4ParticleDefinition *	part,
		const G4ParticleDefinition *
	)

overrideprotectedvirtual

Implements G4VEnergyLossProcess.

Definition at line 111 of file G4PolarizedIonisation.cc.

{
  if(!fIsInitialised)
  {
    if(part == G4Positron::Positron())
    {
      fIsElectron = false;
    }
 
    if(!FluctModel())
    {
      SetFluctModel(new G4UniversalFluctuation());
    }
    fFlucModel = FluctModel();
 
    fEmModel = new G4PolarizedIonisationModel();
    SetEmModel(fEmModel);
    G4EmParameters* param = G4EmParameters::Instance();
    fEmModel->SetLowEnergyLimit(param->MinKinEnergy());
    fEmModel->SetHighEnergyLimit(param->MaxKinEnergy());
    AddEmModel(1, fEmModel, fFlucModel);
 
    fIsInitialised = true;
  }
}

References G4VEnergyLossProcess::AddEmModel(), fEmModel, fFlucModel, fIsElectron, fIsInitialised, G4VEnergyLossProcess::FluctModel(), G4EmParameters::Instance(), G4EmParameters::MaxKinEnergy(), G4EmParameters::MinKinEnergy(), G4Positron::Positron(), G4VEnergyLossProcess::SetEmModel(), G4VEnergyLossProcess::SetFluctModel(), G4VEmModel::SetHighEnergyLimit(), and G4VEmModel::SetLowEnergyLimit().

◆ InverseRangeTable()

G4PhysicsTable * G4VEnergyLossProcess::InverseRangeTable ( ) const

inlineinherited

Definition at line 998 of file G4VEnergyLossProcess.hh.

{
  return theInverseRangeTable;
}

References G4VEnergyLossProcess::theInverseRangeTable.

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

◆ IonisationTable()

G4PhysicsTable * G4VEnergyLossProcess::IonisationTable ( ) const

inlineinherited

Definition at line 970 of file G4VEnergyLossProcess.hh.

{
  return theIonisationTable;
}

References G4VEnergyLossProcess::theIonisationTable.

Referenced by G4VEnergyLossProcess::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()

G4bool G4PolarizedIonisation::IsApplicable ( const G4ParticleDefinition & p )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 106 of file G4PolarizedIonisation.cc.

{
  return (&p == G4Electron::Electron() || &p == G4Positron::Positron());
}

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

◆ 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

inlineinherited

Definition at line 914 of file G4VEnergyLossProcess.hh.

{
  return isIonisation;
}

References G4VEnergyLossProcess::isIonisation.

Referenced by G4VEnergyLossProcess::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 )

privateinherited

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(), G4VEnergyLossProcess::nSCoffRegions, reg, and G4VEnergyLossProcess::scoffRegions.

Referenced by G4VEnergyLossProcess::AlongStepDoIt().

◆ LambdaPhysicsVector()

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

protectedinherited

Definition at line 1678 of file G4VEnergyLossProcess.cc.

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

References G4VEnergyLossProcess::basedCoupleIndex, and G4VEnergyLossProcess::DefineMaterial().

Referenced by BuildAsymmetryTables().

◆ LambdaTable()

G4PhysicsTable * G4VEnergyLossProcess::LambdaTable ( ) const

inlineinherited

Definition at line 1005 of file G4VEnergyLossProcess.hh.

{
  return theLambdaTable;
}

References G4VEnergyLossProcess::theLambdaTable.

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

◆ MaxKinEnergy()

G4double G4VEnergyLossProcess::MaxKinEnergy ( ) const

inlineinherited

Definition at line 935 of file G4VEnergyLossProcess.hh.

{
  return maxKinEnergy;
}

References G4VEnergyLossProcess::maxKinEnergy.

◆ MeanFreePath()

G4double G4VEnergyLossProcess::MeanFreePath ( const G4Track & track )

inherited

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, G4VEnergyLossProcess::DefineMaterial(), G4Track::GetDynamicParticle(), G4Track::GetKineticEnergy(), G4VEnergyLossProcess::GetLambdaForScaledEnergy(), G4DynamicParticle::GetLogKineticEnergy(), G4Track::GetMaterialCutsCouple(), G4VEnergyLossProcess::logMassRatio, and G4VEnergyLossProcess::massRatio.

Referenced by G4VEnergyLossProcess::GetMeanFreePath().

◆ MinKinEnergy()

G4double G4VEnergyLossProcess::MinKinEnergy ( ) const

inlineinherited

Definition at line 928 of file G4VEnergyLossProcess.hh.

{
  return minKinEnergy;
}

References G4VEnergyLossProcess::minKinEnergy.

◆ MinPrimaryEnergy()

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

overrideprotectedvirtual

Reimplemented from G4VEnergyLossProcess.

Definition at line 93 of file G4PolarizedIonisation.cc.

{
  G4double x = cut;
  if(fIsElectron)
  {
    x += cut;
  }
  return x;
}

References fIsElectron.

◆ NumberOfModels()

size_t G4VEnergyLossProcess::NumberOfModels ( ) const

inlineinherited

Definition at line 1026 of file G4VEnergyLossProcess.hh.

{
  return numberOfModels;
}

References G4VEnergyLossProcess::numberOfModels.

◆ NumberOfSubCutoffRegions()

G4int G4VEnergyLossProcess::NumberOfSubCutoffRegions ( ) const

inlineinherited

Definition at line 921 of file G4VEnergyLossProcess.hh.

{
  return nSCoffRegions;
}

References G4VEnergyLossProcess::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=()

G4PolarizedIonisation & G4PolarizedIonisation::operator= ( const G4PolarizedIonisation & 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

inlineinherited

Definition at line 863 of file G4VEnergyLossProcess.hh.

{
  return particle;
}

References G4VEnergyLossProcess::particle.

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

◆ PostStepDoIt()

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

overridevirtualinherited

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 G4PolarizedIonisation::PostStepGetPhysicalInteractionLength	(	const G4Track &	track,
		G4double	previousStepSize,
		G4ForceCondition *	condition
	)

overrideprotectedvirtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 158 of file G4PolarizedIonisation.cc.

{
  // save previous values
  G4double nLength = theNumberOfInteractionLengthLeft;
  G4double iLength = currentInteractionLength;
 
  // *** get unpolarised mean free path from lambda table ***
  // this changes theNumberOfInteractionLengthLeft and currentInteractionLength
  G4double x = G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(
    track, step, cond);
  G4double x0      = x;
  G4double satFact = 1.;
 
  // *** add corrections on polarisation ***
  if(fAsymmetryTable && fTransverseAsymmetryTable && x < DBL_MAX)
  {
    satFact            = ComputeSaturationFactor(track);
    G4double curLength = currentInteractionLength * satFact;
    G4double prvLength = iLength * satFact;
    if(nLength > 0.0)
    {
      theNumberOfInteractionLengthLeft =
        std::max(nLength - step / prvLength, 0.0);
    }
    x = theNumberOfInteractionLengthLeft * curLength;
  }
  if(verboseLevel >= 2)
  {
    G4cout << "G4PolarizedIonisation::PostStepGPIL: " << std::setprecision(8)
           << x / mm << " mm;" << G4endl
           << "                   unpolarized value: " << std::setprecision(8)
           << x0 / mm << " mm." << G4endl;
  }
  return x;
}

References ComputeSaturationFactor(), G4VProcess::currentInteractionLength, DBL_MAX, fAsymmetryTable, fTransverseAsymmetryTable, G4cout, G4endl, G4INCL::Math::max(), mm, G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::theNumberOfInteractionLengthLeft, and G4VProcess::verboseLevel.

◆ 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 )

overridevirtualinherited

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;
    }
  }
}

◆ 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

privateinherited

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, G4VEnergyLossProcess::maxKinEnergy, G4VEnergyLossProcess::minKinEnergy, and G4VEnergyLossProcess::nBins.

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

◆ ProcessDescription()

void G4PolarizedIonisation::ProcessDescription ( std::ostream & out ) const

overridevirtual

Reimplemented from G4VProcess.

Definition at line 68 of file G4PolarizedIonisation.cc.

{
  out << "Polarized version of G4eIonisation.\n";
 
  G4VEnergyLossProcess::ProcessDescription(out);
}

References G4VEnergyLossProcess::ProcessDescription().

Referenced by DumpInfo().

◆ RangeTableForLoss()

G4PhysicsTable * G4VEnergyLossProcess::RangeTableForLoss ( ) const

inlineinherited

Definition at line 991 of file G4VEnergyLossProcess.hh.

{
  return theRangeTableForLoss;
}

References G4VEnergyLossProcess::theRangeTableForLoss.

Referenced by G4VEnergyLossProcess::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
	)

overridevirtualinherited

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;
}

◆ RetrieveTable()

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

privateinherited

Definition at line 1555 of file G4VEnergyLossProcess.cc.

{
  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(), G4VEnergyLossProcess::spline, and G4VProcess::verboseLevel.

Referenced by G4VEnergyLossProcess::RetrievePhysicsTable().

◆ ScaledKinEnergyForLoss()

G4double G4VEnergyLossProcess::ScaledKinEnergyForLoss ( G4double range )

inlineprivateinherited

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 G4VEnergyLossProcess::basedCoupleIndex, G4PhysicsVector::Energy(), G4VEnergyLossProcess::idxInverseRange, G4VEnergyLossProcess::minKinEnergy, and G4PhysicsVector::Value().

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

◆ SecondaryParticle()

const G4ParticleDefinition * G4VEnergyLossProcess::SecondaryParticle ( ) const

inlineinherited

Definition at line 878 of file G4VEnergyLossProcess.hh.

{
  return secondaryParticle;
}

References G4VEnergyLossProcess::secondaryParticle.

Referenced by G4LossTableManager::CopyTables().

◆ SecondaryRangeTable()

G4PhysicsTable * G4VEnergyLossProcess::SecondaryRangeTable ( ) const

inlineinherited

Definition at line 984 of file G4VEnergyLossProcess.hh.

{
  return theSecondaryRangeTable;
}

References G4VEnergyLossProcess::theSecondaryRangeTable.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable().

◆ SelectModel()

void G4VEnergyLossProcess::SelectModel ( G4double kinEnergy )

inlineprotectedinherited

Definition at line 564 of file G4VEnergyLossProcess.hh.

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

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

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

◆ SelectModelForMaterial()

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

inlineinherited

Definition at line 572 of file G4VEnergyLossProcess.hh.

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

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

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

◆ SetBaseParticle()

void G4VEnergyLossProcess::SetBaseParticle ( const G4ParticleDefinition * p )

inlineinherited

Definition at line 856 of file G4VEnergyLossProcess.hh.

{
  baseParticle = p;
}

References G4VEnergyLossProcess::baseParticle.

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

◆ SetCrossSectionBiasingFactor()

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

inherited

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 G4VEnergyLossProcess::biasFactor, G4cout, G4endl, G4VProcess::GetProcessName(), G4VProcess::verboseLevel, and G4VEnergyLossProcess::weightFlag.

Referenced by G4EmExtraParameters::DefineRegParamForLoss().

◆ SetCrossSectionType()

void G4VEnergyLossProcess::SetCrossSectionType ( G4CrossSectionType val )

inlineinherited

Definition at line 900 of file G4VEnergyLossProcess.hh.

{
  fXSType = val;
}

References G4VEnergyLossProcess::fXSType.

Referenced by G4eBremsstrahlung::G4eBremsstrahlung().

◆ SetCSDARangeTable()

void G4VEnergyLossProcess::SetCSDARangeTable ( G4PhysicsTable * pRange )

inherited

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(), G4VEnergyLossProcess::particle, G4VEnergyLossProcess::theCSDARangeTable, and G4VProcess::verboseLevel.

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

◆ SetDEDXBinning()

void G4VEnergyLossProcess::SetDEDXBinning ( G4int nbins )

inherited

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 G4VEnergyLossProcess::actBinning, CLHEP::detail::n, G4VEnergyLossProcess::nBins, and G4VEnergyLossProcess::PrintWarning().

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

◆ SetDEDXTable()

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

inherited

Definition at line 1689 of file G4VEnergyLossProcess.cc.

{
  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, G4VEnergyLossProcess::theDEDXTable, G4VEnergyLossProcess::theDEDXunRestrictedTable, and G4VEnergyLossProcess::theIonisationTable.

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

◆ SetDynamicMassCharge()

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

inherited

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 G4VEnergyLossProcess::baseMat, G4VEnergyLossProcess::biasFactor, G4VEnergyLossProcess::chargeSqRatio, G4VEnergyLossProcess::currentCoupleIndex, G4VEnergyLossProcess::fFactor, G4Log(), G4VEnergyLossProcess::logMassRatio, G4VEnergyLossProcess::massRatio, and G4VEnergyLossProcess::reduceFactor.

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

◆ SetEmModel()

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

inherited

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 G4VEnergyLossProcess::emModels.

◆ SetFluctModel()

void G4VEnergyLossProcess::SetFluctModel ( G4VEmFluctuationModel * p )

inlineinherited

Definition at line 826 of file G4VEnergyLossProcess.hh.

{
  fluctModel = p;
}

References G4VEnergyLossProcess::fluctModel.

Referenced by G4EmStandardPhysics_option4::ConstructProcess(), G4MuIonisation::InitialiseEnergyLossProcess(), 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 )

inherited

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(), G4VEnergyLossProcess::particle, G4VEnergyLossProcess::theInverseRangeTable, and G4VProcess::verboseLevel.

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

◆ SetIonisation()

void G4VEnergyLossProcess::SetIonisation ( G4bool val )

inherited

Definition at line 1959 of file G4VEnergyLossProcess.cc.

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

References G4VEnergyLossProcess::aGPILSelection, CandidateForSelection, G4VEnergyLossProcess::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 )

inherited

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;
      }
    }
  }
}

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

◆ SetLinearLossLimit()

void G4VEnergyLossProcess::SetLinearLossLimit ( G4double val )

inherited

Definition at line 1967 of file G4VEnergyLossProcess.cc.

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

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

Referenced by G4ionIonisation::G4ionIonisation().

◆ SetLossFluctuations()

void G4VEnergyLossProcess::SetLossFluctuations ( G4bool val )

inlineinherited

Definition at line 885 of file G4VEnergyLossProcess.hh.

{
  lossFluctuationFlag = val;
  actLossFluc = true;
}

References G4VEnergyLossProcess::actLossFluc, and G4VEnergyLossProcess::lossFluctuationFlag.

◆ SetLowestEnergyLimit()

void G4VEnergyLossProcess::SetLowestEnergyLimit ( G4double val )

inherited

Definition at line 1990 of file G4VEnergyLossProcess.cc.

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

References G4VEnergyLossProcess::lowestKinEnergy, and G4VEnergyLossProcess::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 )

inherited

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 G4VEnergyLossProcess::actMaxKinEnergy, G4VEnergyLossProcess::maxKinEnergy, G4VEnergyLossProcess::maxKinEnergyCSDA, G4VEnergyLossProcess::minKinEnergy, and G4VEnergyLossProcess::PrintWarning().

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

◆ SetMinKinEnergy()

void G4VEnergyLossProcess::SetMinKinEnergy ( G4double e )

inherited

Definition at line 2011 of file G4VEnergyLossProcess.cc.

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

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

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

◆ SetParticle()

void G4VEnergyLossProcess::SetParticle ( const G4ParticleDefinition * p )

inlineprotectedinherited

Definition at line 840 of file G4VEnergyLossProcess.hh.

{
  particle = p;
}

References G4VEnergyLossProcess::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(), 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 )

inherited

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(), G4VEnergyLossProcess::particle, G4VEnergyLossProcess::theRangeTableForLoss, and G4VProcess::verboseLevel.

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

◆ SetSecondaryParticle()

void G4VEnergyLossProcess::SetSecondaryParticle ( const G4ParticleDefinition * p )

inlineprotectedinherited

Definition at line 848 of file G4VEnergyLossProcess.hh.

{
  secondaryParticle = p;
}

References G4VEnergyLossProcess::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().

◆ SetSecondaryRangeTable()

void G4VEnergyLossProcess::SetSecondaryRangeTable ( G4PhysicsTable * p )

inherited

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(), G4VEnergyLossProcess::particle, G4VEnergyLossProcess::theSecondaryRangeTable, and G4VProcess::verboseLevel.

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

◆ SetSpline()

void G4VEnergyLossProcess::SetSpline ( G4bool val )

inlineinherited

Definition at line 893 of file G4VEnergyLossProcess.hh.

{
  spline = val;
}

References G4VEnergyLossProcess::spline.

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

◆ SetStepFunction()

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

inherited

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 G4VEnergyLossProcess::dRoverRange, G4VEnergyLossProcess::finalRange, G4INCL::Math::min(), and G4VEnergyLossProcess::PrintWarning().

◆ SetTwoPeaksXS()

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

inherited

Definition at line 1884 of file G4VEnergyLossProcess.cc.

{
  fXSpeaks = ptr;
}

References G4VEnergyLossProcess::fXSpeaks.

Referenced by G4VEnergyLossProcess::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::G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), G4CoulombScattering::InitialiseProcess(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4ProcessManagerMessenger::SetNewValue(), and G4ProcessTableMessenger::SetNewValue().

◆ StartTracking()

void G4VEnergyLossProcess::StartTracking ( G4Track * track )

overridevirtualinherited

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(); 
    }
  }
}

◆ StorePhysicsTable()

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

overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 1445 of file G4VEnergyLossProcess.cc.

{
  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 G4VEnergyLossProcess::baseParticle, G4VEnergyLossProcess::isIonisation, G4VEnergyLossProcess::isMaster, G4VEnergyLossProcess::particle, G4VEnergyLossProcess::StoreTable(), G4VEnergyLossProcess::theCSDARangeTable, G4VEnergyLossProcess::theDEDXTable, G4VEnergyLossProcess::theDEDXunRestrictedTable, G4VEnergyLossProcess::theInverseRangeTable, G4VEnergyLossProcess::theIonisationTable, G4VEnergyLossProcess::theLambdaTable, and G4VEnergyLossProcess::theRangeTableForLoss.

◆ StoreTable()

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

privateinherited

Definition at line 1534 of file G4VEnergyLossProcess.cc.

{
  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 G4VEnergyLossProcess::StorePhysicsTable().

◆ StreamInfo()

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

privateinherited

Definition at line 730 of file G4VEnergyLossProcess.cc.

{
  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;
    }
  }
}

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

◆ StreamProcessInfo()

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

inlineprotectedvirtualinherited

Reimplemented in G4ePairProduction, G4MuPairProduction, G4eBremsstrahlung, and G4ionIonisation.

Definition at line 97 of file G4VEnergyLossProcess.hh.

97{};

Referenced by G4VEnergyLossProcess::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);
  }
}

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

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

◆ TablesAreBuilt()

G4bool G4VEnergyLossProcess::TablesAreBuilt ( ) const

inlineinherited

Definition at line 949 of file G4VEnergyLossProcess.hh.

{
  return tablesAreBuilt;
}

References G4VEnergyLossProcess::tablesAreBuilt.

◆ TwoPeaksXS()

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

inlineinherited

Definition at line 1019 of file G4VEnergyLossProcess.hh.

{
  return fXSpeaks;
}

References G4VEnergyLossProcess::fXSpeaks.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable().

◆ UseBaseMaterial()

G4bool G4VEnergyLossProcess::UseBaseMaterial ( ) const

inlineinherited

Definition at line 1012 of file G4VEnergyLossProcess.hh.

{
  return baseMat;
}

References G4VEnergyLossProcess::baseMat.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable().

Field Documentation

◆ actBinning

G4bool G4VEnergyLossProcess::actBinning = false

privateinherited

Definition at line 546 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::SetDEDXBinning().

◆ actLinLossLimit

G4bool G4VEnergyLossProcess::actLinLossLimit = false

privateinherited

Definition at line 544 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::SetLinearLossLimit().

◆ actLossFluc

G4bool G4VEnergyLossProcess::actLossFluc = false

privateinherited

Definition at line 545 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::SetLossFluctuations().

◆ actMaxKinEnergy

G4bool G4VEnergyLossProcess::actMaxKinEnergy = false

privateinherited

Definition at line 548 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::SetMaxKinEnergy().

◆ actMinKinEnergy

G4bool G4VEnergyLossProcess::actMinKinEnergy = false

privateinherited

Definition at line 547 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::SetMinKinEnergy().

◆ aGPILSelection

G4GPILSelection G4VEnergyLossProcess::aGPILSelection

privateinherited

Definition at line 530 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AlongStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::ContinuousStepLimit(), G4VEnergyLossProcess::G4VEnergyLossProcess(), and G4VEnergyLossProcess::SetIonisation().

◆ aParticleChange

G4ParticleChange G4VProcess::aParticleChange

protectedinherited

Definition at line 327 of file G4VProcess.hh.

◆ aProcessManager

const G4ProcessManager* G4VProcess::aProcessManager = nullptr

protectedinherited

Definition at line 319 of file G4VProcess.hh.

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

◆ atomDeexcitation

G4VAtomDeexcitation* G4VEnergyLossProcess::atomDeexcitation = nullptr

privateinherited

Definition at line 445 of file G4VEnergyLossProcess.hh.

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

◆ basedCoupleIndex

size_t G4VEnergyLossProcess::basedCoupleIndex = 0

privateinherited

Definition at line 518 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::ComputeLambdaForScaledEnergy(), G4VEnergyLossProcess::DefineMaterial(), G4VEnergyLossProcess::GetDEDXForScaledEnergy(), G4VEnergyLossProcess::GetIonisationForScaledEnergy(), G4VEnergyLossProcess::GetLambdaForScaledEnergy(), G4VEnergyLossProcess::GetLimitScaledRangeForScaledEnergy(), G4VEnergyLossProcess::GetScaledRangeForScaledEnergy(), G4VEnergyLossProcess::LambdaPhysicsVector(), and G4VEnergyLossProcess::ScaledKinEnergyForLoss().

◆ baseMat

G4bool G4VEnergyLossProcess::baseMat = false

privateinherited

Definition at line 543 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable(), G4VEnergyLossProcess::CrossSectionPerVolume(), G4VEnergyLossProcess::DefineMaterial(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::SetDynamicMassCharge(), and G4VEnergyLossProcess::UseBaseMaterial().

◆ baseParticle

const G4ParticleDefinition* G4VEnergyLossProcess::baseParticle = nullptr

privateinherited

Definition at line 449 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::BaseParticle(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::SetBaseParticle(), G4VEnergyLossProcess::SetLambdaTable(), G4VEnergyLossProcess::StartTracking(), G4VEnergyLossProcess::StorePhysicsTable(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ biasFactor

G4double G4VEnergyLossProcess::biasFactor = 1.0

privateinherited

Definition at line 484 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AlongStepDoIt(), G4VEnergyLossProcess::CrossSectionBiasingFactor(), G4VEnergyLossProcess::CrossSectionPerVolume(), G4VEnergyLossProcess::DefineMaterial(), G4VEnergyLossProcess::PostStepDoIt(), G4VEnergyLossProcess::SetCrossSectionBiasingFactor(), and G4VEnergyLossProcess::SetDynamicMassCharge().

◆ biasFlag

G4bool G4VEnergyLossProcess::biasFlag = false

privateinherited

Definition at line 540 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::StartTracking().

◆ biasID

G4int G4VEnergyLossProcess::biasID = _DeltaEBelowCut

privateinherited

Definition at line 515 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::FillSecondariesAlongStep(), G4VEnergyLossProcess::PostStepDoIt(), and G4VEnergyLossProcess::PreparePhysicsTable().

◆ biasManager

G4EmBiasingManager* G4VEnergyLossProcess::biasManager = nullptr

privateinherited

Definition at line 441 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::ActivateForcedInteraction(), G4VEnergyLossProcess::ActivateSecondaryBiasing(), G4VEnergyLossProcess::FillSecondariesAlongStep(), G4VEnergyLossProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::StartTracking(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ chargeSqRatio

G4double G4VEnergyLossProcess::chargeSqRatio = 1.0

privateinherited

Definition at line 490 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::DefineMaterial(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::SetDynamicMassCharge().

◆ coupleIdxLambda

size_t G4VEnergyLossProcess::coupleIdxLambda = 0

privateinherited

Definition at line 520 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::GetLambdaForScaledEnergy().

◆ coupleIdxRange

size_t G4VEnergyLossProcess::coupleIdxRange = 0

privateinherited

Definition at line 519 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::GetScaledRangeForScaledEnergy().

◆ currentCouple

const G4MaterialCutsCouple* G4VEnergyLossProcess::currentCouple = nullptr

protectedinherited

Definition at line 434 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AlongStepDoIt(), G4VEnergyLossProcess::AlongStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::DefineMaterial(), G4VEnergyLossProcess::PostStepDoIt(), G4VEnergyLossProcess::SelectModel(), and G4VEnergyLossProcess::StartTracking().

◆ currentCoupleIndex

size_t G4VEnergyLossProcess::currentCoupleIndex = 0

protectedinherited

Definition at line 505 of file G4VEnergyLossProcess.hh.

◆ currentInteractionLength

G4double G4VProcess::currentInteractionLength = -1.0

protectedinherited

Definition at line 335 of file G4VProcess.hh.

◆ currentMaterial

const G4Material* G4VEnergyLossProcess::currentMaterial = nullptr

protectedinherited

Definition at line 433 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AlongStepDoIt(), G4VEnergyLossProcess::CrossSectionPerVolume(), G4VEnergyLossProcess::DefineMaterial(), G4VEnergyLossProcess::GetDEDXDispersion(), and G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength().

◆ currentModel

G4VEmModel* G4VEnergyLossProcess::currentModel = nullptr

privateinherited

Definition at line 440 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AlongStepDoIt(), G4VEnergyLossProcess::AlongStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::CrossSectionPerVolume(), G4VEnergyLossProcess::GetCurrentElement(), G4VEnergyLossProcess::GetDEDXDispersion(), G4VEnergyLossProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::SelectModel().

◆ dRoverRange

G4double G4VEnergyLossProcess::dRoverRange = 0.2

privateinherited

Definition at line 480 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AlongStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::SetStepFunction(), and G4VEnergyLossProcess::StreamInfo().

◆ emModels

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

privateinherited

Definition at line 467 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::EmModel(), G4VEnergyLossProcess::SetEmModel(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ enableAlongStepDoIt

G4bool G4VProcess::enableAlongStepDoIt = true

protectedinherited

Definition at line 360 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ITTransportation::G4ITTransportation(), G4NuclearStopping::G4NuclearStopping(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), G4VITRestDiscreteProcess::G4VITRestDiscreteProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestDiscreteProcess::G4VRestDiscreteProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isAlongStepDoItIsEnabled().

◆ enableAtRestDoIt

G4bool G4VProcess::enableAtRestDoIt = true

protectedinherited

Definition at line 359 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4eplusAnnihilation::G4eplusAnnihilation(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VContinuousDiscreteProcess::G4VContinuousDiscreteProcess(), G4VContinuousProcess::G4VContinuousProcess(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), and G4VProcess::isAtRestDoItIsEnabled().

◆ enablePostStepDoIt

G4bool G4VProcess::enablePostStepDoIt = true

protectedinherited

Definition at line 361 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4NuclearStopping::G4NuclearStopping(), G4VContinuousProcess::G4VContinuousProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestContinuousProcess::G4VRestContinuousProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isPostStepDoItIsEnabled().

◆ fAsymmetryTable

G4PhysicsTable* G4PolarizedIonisation::fAsymmetryTable

private

Definition at line 98 of file G4PolarizedIonisation.hh.

Referenced by BuildAsymmetryTables(), CleanTables(), GetMeanFreePath(), and PostStepGetPhysicalInteractionLength().

◆ fEmModel

G4PolarizedIonisationModel* G4PolarizedIonisation::fEmModel

private

Definition at line 96 of file G4PolarizedIonisation.hh.

Referenced by ComputeAsymmetry(), G4PolarizedIonisation(), and InitialiseEnergyLossProcess().

◆ fFactor

G4double G4VEnergyLossProcess::fFactor = 1.0

privateinherited

Definition at line 488 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::DefineMaterial(), G4VEnergyLossProcess::GetDEDXForScaledEnergy(), G4VEnergyLossProcess::GetIonisationForScaledEnergy(), G4VEnergyLossProcess::GetLambdaForScaledEnergy(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), and G4VEnergyLossProcess::SetDynamicMassCharge().

◆ fFlucModel

G4VEmFluctuationModel* G4PolarizedIonisation::fFlucModel

private

Definition at line 95 of file G4PolarizedIonisation.hh.

Referenced by G4PolarizedIonisation(), and InitialiseEnergyLossProcess().

◆ finalRange

G4double G4VEnergyLossProcess::finalRange

privateinherited

Definition at line 481 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AlongStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VEnergyLossProcess::SetStepFunction(), and G4VEnergyLossProcess::StreamInfo().

◆ fIsElectron

G4bool G4PolarizedIonisation::fIsElectron

private

Definition at line 101 of file G4PolarizedIonisation.hh.

Referenced by ComputeAsymmetry(), InitialiseEnergyLossProcess(), and MinPrimaryEnergy().

◆ fIsInitialised

G4bool G4PolarizedIonisation::fIsInitialised

private

Definition at line 102 of file G4PolarizedIonisation.hh.

Referenced by InitialiseEnergyLossProcess().

◆ fLambda

G4double G4VEnergyLossProcess::fLambda = 0.0

privateinherited

Definition at line 491 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::GetLambdaForScaledEnergy().

◆ fLambdaEnergy

G4double G4VEnergyLossProcess::fLambdaEnergy = 0.0

privateinherited

Definition at line 492 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::GetLambdaForScaledEnergy(), and G4VEnergyLossProcess::PreparePhysicsTable().

◆ fluctModel

G4VEmFluctuationModel* G4VEnergyLossProcess::fluctModel = nullptr

privateinherited

Definition at line 444 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AddEmModel(), G4VEnergyLossProcess::FluctModel(), and G4VEnergyLossProcess::SetFluctModel().

◆ fParticleChange

G4ParticleChangeForLoss G4VEnergyLossProcess::fParticleChange

protectedinherited

Definition at line 432 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AlongStepDoIt(), G4VEnergyLossProcess::FillSecondariesAlongStep(), G4VEnergyLossProcess::G4VEnergyLossProcess(), and G4VEnergyLossProcess::PostStepDoIt().

◆ fProcessTable

G4ProcessTable* G4VProcess::fProcessTable = nullptr

privateinherited

Definition at line 374 of file G4VProcess.hh.

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

◆ fRange

G4double G4VEnergyLossProcess::fRange = 0.0

privateinherited

Definition at line 493 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AlongStepDoIt(), G4VEnergyLossProcess::AlongStepGetPhysicalInteractionLength(), and G4VEnergyLossProcess::GetScaledRangeForScaledEnergy().

◆ fRangeEnergy

G4double G4VEnergyLossProcess::fRangeEnergy = 0.0

privateinherited

Definition at line 494 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::GetScaledRangeForScaledEnergy(), and G4VEnergyLossProcess::PreparePhysicsTable().

◆ fTransverseAsymmetryTable

G4PhysicsTable* G4PolarizedIonisation::fTransverseAsymmetryTable

private

Definition at line 99 of file G4PolarizedIonisation.hh.

Referenced by BuildAsymmetryTables(), CleanTables(), GetMeanFreePath(), and PostStepGetPhysicalInteractionLength().

◆ fXSpeaks

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

privateinherited

Definition at line 472 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::SetTwoPeaksXS(), G4VEnergyLossProcess::TwoPeaksXS(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ fXSType

G4CrossSectionType G4VEnergyLossProcess::fXSType = fEmIncreasing

privateinherited

Definition at line 531 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::ComputeLambdaForScaledEnergy(), G4VEnergyLossProcess::CrossSectionType(), G4VEnergyLossProcess::PostStepDoIt(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::SetCrossSectionType(), G4VEnergyLossProcess::SetLambdaTable(), and G4VEnergyLossProcess::StreamInfo().

◆ idxCSDA

size_t G4VEnergyLossProcess::idxCSDA = 0

privateinherited

Definition at line 525 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::GetLimitScaledRangeForScaledEnergy().

◆ idxDEDX

size_t G4VEnergyLossProcess::idxDEDX = 0

privateinherited

Definition at line 521 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::GetDEDXForScaledEnergy().

◆ idxDEDXunRestricted

size_t G4VEnergyLossProcess::idxDEDXunRestricted = 0

privateinherited

Definition at line 522 of file G4VEnergyLossProcess.hh.

◆ idxInverseRange

size_t G4VEnergyLossProcess::idxInverseRange = 0

privateinherited

Definition at line 527 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::ScaledKinEnergyForLoss().

◆ idxIonisation

size_t G4VEnergyLossProcess::idxIonisation = 0

privateinherited

Definition at line 523 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::GetIonisationForScaledEnergy().

◆ idxLambda

size_t G4VEnergyLossProcess::idxLambda = 0

privateinherited

Definition at line 528 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::DefineMaterial(), and G4VEnergyLossProcess::GetLambdaForScaledEnergy().

◆ idxRange

size_t G4VEnergyLossProcess::idxRange = 0

privateinherited

Definition at line 524 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::GetScaledRangeForScaledEnergy().

◆ idxSecRange

size_t G4VEnergyLossProcess::idxSecRange = 0

privateinherited

Definition at line 526 of file G4VEnergyLossProcess.hh.

◆ isIon

G4bool G4VEnergyLossProcess::isIon = false

privateinherited

Definition at line 537 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AlongStepDoIt(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::StartTracking().

◆ isIonisation

G4bool G4VEnergyLossProcess::isIonisation = true

privateinherited

Definition at line 538 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AlongStepDoIt(), G4VEnergyLossProcess::AlongStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VEnergyLossProcess::IsIonisationProcess(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::SetIonisation(), G4VEnergyLossProcess::StorePhysicsTable(), G4VEnergyLossProcess::StreamInfo(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ isMaster

G4bool G4VEnergyLossProcess::isMaster = true

privateinherited

Definition at line 542 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::SetLambdaTable(), G4VEnergyLossProcess::StorePhysicsTable(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ lambdaFactor

G4double G4VEnergyLossProcess::lambdaFactor = 1.0

privateinherited

Definition at line 482 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::ComputeLambdaForScaledEnergy(), and G4VEnergyLossProcess::PreparePhysicsTable().

◆ linLossLimit

G4double G4VEnergyLossProcess::linLossLimit = 0.01

privateinherited

Definition at line 479 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AlongStepDoIt(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::SetLinearLossLimit(), and G4VEnergyLossProcess::StreamInfo().

◆ lManager

G4LossTableManager* G4VEnergyLossProcess::lManager

privateinherited

Definition at line 438 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::BuildDEDXTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::SetLambdaTable(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ logLambdafactor

G4double G4VEnergyLossProcess::logLambdafactor = 0.0

privateinherited

Definition at line 483 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::PreparePhysicsTable().

◆ logMassRatio

G4double G4VEnergyLossProcess::logMassRatio = 0.0

privateinherited

Definition at line 487 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::CrossSectionPerVolume(), G4VEnergyLossProcess::GetDEDX(), G4VEnergyLossProcess::GetLambda(), G4VEnergyLossProcess::GetRange(), G4VEnergyLossProcess::MeanFreePath(), G4VEnergyLossProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::SetDynamicMassCharge(), and G4VEnergyLossProcess::StartTracking().

◆ lossFluctuationFlag

G4bool G4VEnergyLossProcess::lossFluctuationFlag = true

privateinherited

Definition at line 533 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AlongStepDoIt(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::SetLossFluctuations(), and G4VEnergyLossProcess::StreamInfo().

◆ lowestKinEnergy

G4double G4VEnergyLossProcess::lowestKinEnergy

privateinherited

Definition at line 474 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AlongStepDoIt(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::SetLowestEnergyLimit().

◆ mainSecondaries

G4int G4VEnergyLossProcess::mainSecondaries = 1

privateinherited

Definition at line 516 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::PostStepDoIt(), and G4VEnergyLossProcess::PreparePhysicsTable().

◆ massRatio

G4double G4VEnergyLossProcess::massRatio = 1.0

privateinherited

Definition at line 486 of file G4VEnergyLossProcess.hh.

◆ masterProcessShadow

G4VProcess* G4VProcess::masterProcessShadow = nullptr

privateinherited

Definition at line 370 of file G4VProcess.hh.

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

◆ maxKinEnergy

G4double G4VEnergyLossProcess::maxKinEnergy

privateinherited

Definition at line 476 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::BuildDEDXTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VEnergyLossProcess::MaxKinEnergy(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PrintWarning(), G4VEnergyLossProcess::SetMaxKinEnergy(), G4VEnergyLossProcess::SetMinKinEnergy(), and G4VEnergyLossProcess::StreamInfo().

◆ maxKinEnergyCSDA

G4double G4VEnergyLossProcess::maxKinEnergyCSDA

privateinherited

Definition at line 477 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::BuildDEDXTable(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::SetMaxKinEnergy(), and G4VEnergyLossProcess::StreamInfo().

◆ mfpKinEnergy

G4double G4VEnergyLossProcess::mfpKinEnergy = 0.0

protectedinherited

Definition at line 503 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::ComputeLambdaForScaledEnergy(), G4VEnergyLossProcess::DefineMaterial(), G4VEnergyLossProcess::PostStepDoIt(), and G4VEnergyLossProcess::StartTracking().

◆ minKinEnergy

G4double G4VEnergyLossProcess::minKinEnergy

privateinherited

Definition at line 475 of file G4VEnergyLossProcess.hh.

◆ modelManager

G4EmModelManager* G4VEnergyLossProcess::modelManager

privateinherited

Definition at line 439 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AddEmModel(), G4VEnergyLossProcess::BuildDEDXTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VEnergyLossProcess::GetModelByIndex(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::SelectModel(), G4VEnergyLossProcess::SelectModelForMaterial(), G4VEnergyLossProcess::StreamInfo(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ nBins

G4int G4VEnergyLossProcess::nBins

privateinherited

Definition at line 509 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::BuildDEDXTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PrintWarning(), G4VEnergyLossProcess::SetDEDXBinning(), and G4VEnergyLossProcess::StreamInfo().

◆ nBinsCSDA

G4int G4VEnergyLossProcess::nBinsCSDA

privateinherited

Definition at line 510 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::BuildDEDXTable(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::StreamInfo().

◆ nSCoffRegions

G4int G4VEnergyLossProcess::nSCoffRegions = 0

privateinherited

Definition at line 512 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::ActivateSubCutoff(), G4VEnergyLossProcess::IsRegionForCubcutProcessor(), G4VEnergyLossProcess::NumberOfSubCutoffRegions(), G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::StreamInfo().

◆ numberOfModels

G4int G4VEnergyLossProcess::numberOfModels = 0

privateinherited

Definition at line 511 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable(), G4VEnergyLossProcess::NumberOfModels(), and G4VEnergyLossProcess::PreparePhysicsTable().

◆ particle

const G4ParticleDefinition* G4VEnergyLossProcess::particle = nullptr

privateinherited

Definition at line 448 of file G4VEnergyLossProcess.hh.

◆ pParticleChange

G4VParticleChange* G4VProcess::pParticleChange = nullptr

protectedinherited

Definition at line 321 of file G4VProcess.hh.

◆ preStepKinEnergy

G4double G4VEnergyLossProcess::preStepKinEnergy = 0.0

protectedinherited

Definition at line 499 of file G4VEnergyLossProcess.hh.

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

◆ preStepLambda

G4double G4VEnergyLossProcess::preStepLambda = 0.0

protectedinherited

Definition at line 498 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::ComputeLambdaForScaledEnergy(), G4VEnergyLossProcess::PostStepDoIt(), and G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength().

◆ preStepLogKinEnergy

G4double G4VEnergyLossProcess::preStepLogKinEnergy = LOG_EKIN_MIN

protectedinherited

Definition at line 500 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength().

◆ preStepLogScaledEnergy

G4double G4VEnergyLossProcess::preStepLogScaledEnergy = LOG_EKIN_MIN

protectedinherited

Definition at line 502 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AlongStepDoIt(), G4VEnergyLossProcess::AlongStepGetPhysicalInteractionLength(), and G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength().

◆ preStepScaledEnergy

G4double G4VEnergyLossProcess::preStepScaledEnergy = 0.0

protectedinherited

Definition at line 501 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AlongStepDoIt(), G4VEnergyLossProcess::AlongStepGetPhysicalInteractionLength(), and G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength().

◆ reduceFactor

G4double G4VEnergyLossProcess::reduceFactor = 1.0

privateinherited

Definition at line 489 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::AlongStepDoIt(), G4VEnergyLossProcess::DefineMaterial(), G4VEnergyLossProcess::GetCSDARange(), G4VEnergyLossProcess::GetKineticEnergy(), G4VEnergyLossProcess::GetScaledRangeForScaledEnergy(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::SetDynamicMassCharge().

◆ rndmStepFlag

G4bool G4VEnergyLossProcess::rndmStepFlag = false

privateinherited

Definition at line 534 of file G4VEnergyLossProcess.hh.

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

◆ safetyHelper

G4SafetyHelper* G4VEnergyLossProcess::safetyHelper

privateinherited

Definition at line 442 of file G4VEnergyLossProcess.hh.

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

◆ scoffRegions

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

privateinherited

Definition at line 466 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::ActivateSubCutoff(), G4VEnergyLossProcess::IsRegionForCubcutProcessor(), G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ scTracks

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

privateinherited

Definition at line 551 of file G4VEnergyLossProcess.hh.

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

◆ secID

G4int G4VEnergyLossProcess::secID = _DeltaElectron

privateinherited

Definition at line 513 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::PostStepDoIt(), and G4VEnergyLossProcess::PreparePhysicsTable().

◆ secondaryParticle

const G4ParticleDefinition* G4VEnergyLossProcess::secondaryParticle = nullptr

privateinherited

Definition at line 450 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::ActivateSecondaryBiasing(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::SecondaryParticle(), and G4VEnergyLossProcess::SetSecondaryParticle().

◆ secParticles

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

privateinherited

Definition at line 550 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VEnergyLossProcess::PostStepDoIt(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ spline

G4bool G4VEnergyLossProcess::spline = true

privateinherited

Definition at line 536 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::BuildDEDXTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4VEnergyLossProcess::RetrieveTable(), G4VEnergyLossProcess::SetSpline(), and G4VEnergyLossProcess::StreamInfo().

◆ subcutProducer

G4VSubCutProducer* G4VEnergyLossProcess::subcutProducer = nullptr

privateinherited

Definition at line 446 of file G4VEnergyLossProcess.hh.

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

◆ tablesAreBuilt

G4bool G4VEnergyLossProcess::tablesAreBuilt = false

privateinherited

Definition at line 535 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::SetLambdaTable(), and G4VEnergyLossProcess::TablesAreBuilt().

◆ theCSDARangeTable

G4PhysicsTable* G4VEnergyLossProcess::theCSDARangeTable = nullptr

privateinherited

Definition at line 461 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::CSDARangeTable(), G4VEnergyLossProcess::GetCSDARange(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::SetCSDARangeTable(), G4VEnergyLossProcess::StorePhysicsTable(), G4VEnergyLossProcess::StreamInfo(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ theCuts

const G4DataVector* G4VEnergyLossProcess::theCuts = nullptr

privateinherited

Definition at line 470 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::BuildLambdaTable(), G4VEnergyLossProcess::CrossSectionPerVolume(), G4VEnergyLossProcess::GetDEDXDispersion(), and G4VEnergyLossProcess::PreparePhysicsTable().

◆ theDEDXTable

G4PhysicsTable* G4VEnergyLossProcess::theDEDXTable = nullptr

privateinherited

Definition at line 456 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::BuildDEDXTable(), G4VEnergyLossProcess::DEDXTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::SetDEDXTable(), G4VEnergyLossProcess::StorePhysicsTable(), G4VEnergyLossProcess::StreamInfo(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ theDEDXunRestrictedTable

G4PhysicsTable* G4VEnergyLossProcess::theDEDXunRestrictedTable = nullptr

privateinherited

Definition at line 457 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::BuildDEDXTable(), G4VEnergyLossProcess::DEDXunRestrictedTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::SetDEDXTable(), G4VEnergyLossProcess::StorePhysicsTable(), G4VEnergyLossProcess::StreamInfo(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ theDensityFactor

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

privateinherited

Definition at line 469 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::CrossSectionPerVolume(), G4VEnergyLossProcess::G4VEnergyLossProcess(), and G4VEnergyLossProcess::SetLambdaTable().

◆ theDensityIdx

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

privateinherited

Definition at line 468 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::G4VEnergyLossProcess(), and G4VEnergyLossProcess::SetLambdaTable().

◆ theElectron

const G4ParticleDefinition* G4VEnergyLossProcess::theElectron

privateinherited

Definition at line 451 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::G4VEnergyLossProcess().

◆ theGamma

const G4ParticleDefinition* G4VEnergyLossProcess::theGamma

privateinherited

Definition at line 453 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::G4VEnergyLossProcess().

◆ theGenericIon

const G4ParticleDefinition* G4VEnergyLossProcess::theGenericIon = nullptr

privateinherited

Definition at line 454 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::StartTracking().

◆ theInitialNumberOfInteractionLength

G4double G4VProcess::theInitialNumberOfInteractionLength = -1.0

protectedinherited

Definition at line 338 of file G4VProcess.hh.

Referenced by G4VProcess::ClearNumberOfInteractionLengthLeft(), G4VProcess::EndTracking(), G4VProcess::GetTotalNumberOfInteractionLengthTraversed(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::ResetNumberOfInteractionLengthLeft(), and G4VProcess::StartTracking().

◆ theInverseRangeTable

G4PhysicsTable* G4VEnergyLossProcess::theInverseRangeTable = nullptr

privateinherited

Definition at line 463 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::InverseRangeTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::SetInverseRangeTable(), G4VEnergyLossProcess::StorePhysicsTable(), G4VEnergyLossProcess::StreamInfo(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ theIonisationSubTable

G4PhysicsTable* G4VEnergyLossProcess::theIonisationSubTable = nullptr

privateinherited

Definition at line 459 of file G4VEnergyLossProcess.hh.

◆ theIonisationTable

G4PhysicsTable* G4VEnergyLossProcess::theIonisationTable = nullptr

privateinherited

Definition at line 458 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::IonisationTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::SetDEDXTable(), G4VEnergyLossProcess::StorePhysicsTable(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ theLambdaTable

G4PhysicsTable* G4VEnergyLossProcess::theLambdaTable = nullptr

privateinherited

Definition at line 464 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::BuildLambdaTable(), G4VEnergyLossProcess::CrossSectionPerVolume(), G4VEnergyLossProcess::GetLambda(), G4VEnergyLossProcess::LambdaTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::SetLambdaTable(), G4VEnergyLossProcess::StorePhysicsTable(), G4VEnergyLossProcess::StreamInfo(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ theNumberOfInteractionLengthLeft

G4double G4VProcess::theNumberOfInteractionLengthLeft = -1.0

protectedinherited

Definition at line 331 of file G4VProcess.hh.

◆ theParameters

G4EmParameters* G4VEnergyLossProcess::theParameters

privateinherited

Definition at line 443 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::BuildPhysicsTable(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VEnergyLossProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::StreamInfo().

◆ thePhysicsTableFileName

G4String G4VProcess::thePhysicsTableFileName

protectedinherited

Definition at line 344 of file G4VProcess.hh.

Referenced by G4VProcess::GetPhysicsTableFileName().

◆ thePILfactor

G4double G4VProcess::thePILfactor = 1.0

protectedinherited

Definition at line 352 of file G4VProcess.hh.

Referenced by G4VProcess::AtRestGPIL(), G4VProcess::GetPILfactor(), G4VProcess::PostStepGPIL(), and G4VProcess::SetPILfactor().

◆ thePositron

const G4ParticleDefinition* G4VEnergyLossProcess::thePositron

privateinherited

Definition at line 452 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::G4VEnergyLossProcess().

◆ theProcessName

G4String G4VProcess::theProcessName

protectedinherited

Definition at line 341 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4VProcess::EndTracking(), G4ImportanceProcess::GetName(), G4WeightCutOffProcess::GetName(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetProcessName(), G4WrapperProcess::RegisterProcess(), G4VProcess::StartTracking(), G4VITProcess::SubtractNumberOfInteractionLengthLeft(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

◆ theProcessSubType

G4int G4VProcess::theProcessSubType = -1

protectedinherited

Definition at line 349 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VProcess::GetProcessSubType(), and G4VProcess::SetProcessSubType().

◆ theProcessType

G4ProcessType G4VProcess::theProcessType = fNotDefined

protectedinherited

Definition at line 346 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4VProcess::GetProcessType(), G4WrapperProcess::RegisterProcess(), and G4VProcess::SetProcessType().

◆ theRangeTableForLoss

G4PhysicsTable* G4VEnergyLossProcess::theRangeTableForLoss = nullptr

privateinherited

Definition at line 460 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::PreparePhysicsTable(), G4VEnergyLossProcess::RangeTableForLoss(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::SetRangeTableForLoss(), G4VEnergyLossProcess::StorePhysicsTable(), G4VEnergyLossProcess::StreamInfo(), and G4VEnergyLossProcess::~G4VEnergyLossProcess().

◆ theSecondaryRangeTable

G4PhysicsTable* G4VEnergyLossProcess::theSecondaryRangeTable = nullptr

privateinherited

Definition at line 462 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::SecondaryRangeTable(), and G4VEnergyLossProcess::SetSecondaryRangeTable().

◆ tripletID

G4int G4VEnergyLossProcess::tripletID = _TripletElectron

privateinherited

Definition at line 514 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::PostStepDoIt().

◆ useDeexcitation

G4bool G4VEnergyLossProcess::useDeexcitation = false

privateinherited

Definition at line 539 of file G4VEnergyLossProcess.hh.

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

◆ valueGPILSelection

G4GPILSelection G4VContinuousDiscreteProcess::valueGPILSelection = CandidateForSelection

privateinherited

Definition at line 117 of file G4VContinuousDiscreteProcess.hh.

Referenced by G4VContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::GetGPILSelection(), and G4VContinuousDiscreteProcess::SetGPILSelection().

◆ verboseLevel

G4int G4VProcess::verboseLevel = 0

protectedinherited

Definition at line 356 of file G4VProcess.hh.

◆ weightFlag

G4bool G4VEnergyLossProcess::weightFlag = false

privateinherited

Definition at line 541 of file G4VEnergyLossProcess.hh.

Referenced by G4VEnergyLossProcess::ActivateForcedInteraction(), G4VEnergyLossProcess::AlongStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), and G4VEnergyLossProcess::SetCrossSectionBiasingFactor().

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

source/processes/electromagnetic/polarisation/include/G4PolarizedIonisation.hh
source/processes/electromagnetic/polarisation/src/G4PolarizedIonisation.cc

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4PolarizedIonisation() [1/2]

◆ ~G4PolarizedIonisation()

◆ G4PolarizedIonisation() [2/2]

Member Function Documentation

◆ ActivateForcedInteraction()

◆ ActivateSecondaryBiasing()

◆ ActivateSubCutoff()

◆ AddEmModel()

◆ AlongStepDoIt()

◆ AlongStepGetPhysicalInteractionLength()

◆ AlongStepGPIL()

◆ AtRestDoIt()

◆ AtRestGetPhysicalInteractionLength()

◆ AtRestGPIL()

◆ BaseParticle()

◆ BuildAsymmetryTables()

◆ BuildDEDXTable()

◆ BuildLambdaTable()

◆ BuildPhysicsTable()

◆ BuildWorkerPhysicsTable()

◆ CleanTables()

◆ ClearNumberOfInteractionLengthLeft()

◆ ComputeAsymmetry()

◆ ComputeLambdaForScaledEnergy()

◆ ComputeSaturationFactor()

◆ ContinuousStepLimit()

◆ CrossSectionBiasingFactor()

◆ CrossSectionPerVolume() [1/2]

◆ CrossSectionPerVolume() [2/2]

◆ CrossSectionType()

◆ CSDARangeTable()

◆ CurrentMaterialCutsCoupleIndex()

◆ DEDXTable()

◆ DEDXunRestrictedTable()

◆ DefineMaterial()

◆ DumpInfo()

◆ EmModel()

◆ EndTracking()

◆ FillSecondariesAlongStep()

◆ FluctModel()

◆ GetContinuousStepLimit()

◆ GetCSDADEDX()

◆ GetCSDARange()

◆ GetCurrentElement()

◆ GetCurrentInteractionLength()

◆ GetDEDX() [1/2]

◆ GetDEDX() [2/2]

◆ GetDEDXDispersion()

◆ GetDEDXForScaledEnergy() [1/2]

◆ GetDEDXForScaledEnergy() [2/2]

◆ GetGPILSelection()

◆ GetIonisationForScaledEnergy()

◆ GetKineticEnergy()

◆ GetLambda() [1/2]

◆ GetLambda() [2/2]

◆ GetLambdaForScaledEnergy() [1/2]

◆ GetLambdaForScaledEnergy() [2/2]

◆ GetLimitScaledRangeForScaledEnergy() [1/2]

◆ GetLimitScaledRangeForScaledEnergy() [2/2]

◆ GetMasterProcess()

◆ GetMeanFreePath()

◆ GetModelByIndex()

◆ GetNumberOfInteractionLengthLeft()

◆ GetPhysicsTableFileName()

◆ GetPILfactor()

◆ GetProcessManager()

◆ GetProcessName()

◆ GetProcessSubType()

◆ GetProcessType()

◆ GetProcessTypeName()

◆ GetRange() [1/2]

◆ GetRange() [2/2]