#include <G4hImpactIonisation.hh>

Inheritance diagram for G4hImpactIonisation:

Public Member Functions
void	ActivateAugerElectronProduction (G4bool val)

G4VParticleChange *	AlongStepDoIt (const G4Track &trackData, const G4Step &stepData)

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

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)

void	BuildPhysicsTable (const G4ParticleDefinition &aParticleType)

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

G4double	ComputeDEDX (const G4ParticleDefinition aParticle, const G4MaterialCutsCouple couple, G4double kineticEnergy)

virtual void	DumpInfo () const

virtual void	EndTracking ()

	G4hImpactIonisation (const G4String &processName="hImpactIoni")

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

G4double	GetCurrentInteractionLength () const

const G4VProcess *	GetMasterProcess () const

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

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	GetTotalNumberOfInteractionLengthTraversed () const

G4int	GetVerboseLevel () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	IsApplicable (const G4ParticleDefinition &)

G4bool	isAtRestDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

G4bool	operator!= (const G4VProcess &right) const

G4bool	operator== (const G4VProcess &right) const

G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &Step)

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

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

virtual void	PreparePhysicsTable (const G4ParticleDefinition &)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

void	PrintInfoDefinition () const

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

virtual void	ResetNumberOfInteractionLengthLeft ()

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

void	SetBarkasOff ()

void	SetBarkasOn ()

void	SetCutForAugerElectrons (G4double cut)

void	SetCutForSecondaryPhotons (G4double cut)

void	SetElectronicStoppingPowerModel (const G4ParticleDefinition *aParticle, const G4String &dedxTable)

void	SetHighEnergyForAntiProtonParametrisation (G4double energy)

void	SetHighEnergyForProtonParametrisation (G4double energy)

void	SetLowEnergyForAntiProtonParametrisation (G4double energy)

void	SetLowEnergyForProtonParametrisation (G4double energy)

virtual void	SetMasterProcess (G4VProcess *masterP)

void	SetNuclearStoppingOff ()

void	SetNuclearStoppingOn ()

void	SetNuclearStoppingPowerModel (const G4String &dedxTable)

void	SetPILfactor (G4double value)

void	SetPixe (const G4bool)

void	SetPixeCrossSectionK (const G4String &name)

void	SetPixeCrossSectionL (const G4String &name)

void	SetPixeCrossSectionM (const G4String &name)

void	SetPixeProjectileMaxEnergy (G4double energy)

void	SetPixeProjectileMinEnergy (G4double energy)

virtual void	SetProcessManager (const G4ProcessManager *)

void	SetProcessSubType (G4int)

void	SetProcessType (G4ProcessType)

void	SetVerboseLevel (G4int value)

virtual void	StartTracking (G4Track *)

virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

	~G4hImpactIonisation ()

Static Public Member Functions
static G4int	GetNumberOfProcesses ()

static const G4String &	GetProcessTypeName (G4ProcessType)

static void	MinusNumberOfProcesses ()

static void	PlusNumberOfProcesses ()

static void	SetdRoverRange (G4double value)

static void	SetEnlossFluc (G4bool value)

static void	SetNumberOfProcesses (G4int number)

static void	SetRndmStep (G4bool value)

static void	SetStepFunction (G4double c1, G4double c2)

Protected Member Functions
void	ClearNumberOfInteractionLengthLeft ()

G4bool	CutsWhereModified ()

G4GPILSelection	GetGPILSelection () const

void	SetGPILSelection (G4GPILSelection selection)

void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)

Static Protected Member Functions
static void	BuildDEDXTable (const G4ParticleDefinition &aParticleType)

Protected Attributes
G4ParticleChange	aParticleChange

const G4ProcessManager *	aProcessManager = nullptr

G4double	currentInteractionLength = -1.0

G4bool	enableAlongStepDoIt = true

G4bool	enableAtRestDoIt = true

G4bool	enablePostStepDoIt = true

G4double	linLossLimit

const G4double	MaxExcitationNumber

G4double	MinKineticEnergy

const long	nmaxCont1

const long	nmaxCont2

const long	nmaxDirectFluct

G4VParticleChange *	pParticleChange = nullptr

const G4double	probLimFluct

G4double	theInitialNumberOfInteractionLength = -1.0

G4PhysicsTable *	theLossTable

G4double	theNumberOfInteractionLengthLeft = -1.0

G4String	thePhysicsTableFileName

G4double	thePILfactor = 1.0

G4String	theProcessName

G4int	theProcessSubType = -1

G4ProcessType	theProcessType = fNotDefined

G4int	verboseLevel = 0

Static Protected Attributes
static G4ThreadLocal G4double	c1lim = 0.20

static G4ThreadLocal G4double	c2lim = 0.32

static G4ThreadLocal G4double	c3lim = -0.032

static G4ThreadLocal G4double	Charge

static G4ThreadLocal G4int	CounterOfpbarProcess = 0

static G4ThreadLocal G4int	CounterOfpProcess = 0

static G4ThreadLocal G4double	dRoverRange = 0.20

static G4ThreadLocal G4bool	EnlossFlucFlag = true

static G4ThreadLocal G4double	finalRange = 0.2

static G4ThreadLocal G4double	HighestKineticEnergy = 1.e5

static G4ThreadLocal G4double	LOGRTable

static G4ThreadLocal G4double	LowestKineticEnergy = 1e-05

static G4ThreadLocal G4double	ParticleMass

static G4ThreadLocal G4double	pbartableElectronCutInRange = 0.0

static G4ThreadLocal G4double	ptableElectronCutInRange = 0.0

static G4ThreadLocal G4PhysicsTable **	RecorderOfpbarProcess = 0

static G4ThreadLocal G4PhysicsTable **	RecorderOfpProcess = 0

static G4ThreadLocal G4bool	rndmStepFlag = false

static G4ThreadLocal G4double	RTable

static G4ThreadLocal G4PhysicsTable *	theDEDXpbarTable = 0

static G4ThreadLocal G4PhysicsTable *	theDEDXpTable = 0

static G4ThreadLocal G4PhysicsTable *	theInverseRangepbarTable = 0

static G4ThreadLocal G4PhysicsTable *	theInverseRangepTable = 0

static G4ThreadLocal G4PhysicsTable *	theLabTimepbarTable = 0

static G4ThreadLocal G4PhysicsTable *	theLabTimepTable = 0

static G4ThreadLocal G4PhysicsTable *	theProperTimepbarTable = 0

static G4ThreadLocal G4PhysicsTable *	theProperTimepTable = 0

static G4ThreadLocal G4PhysicsTable *	theRangepbarTable = 0

static G4ThreadLocal G4PhysicsTable *	theRangepTable = 0

static G4ThreadLocal G4int	TotBin = 360

Private Member Functions
G4double	AntiProtonParametrisedDEDX (const G4MaterialCutsCouple *couple, G4double kineticEnergy) const

G4double	BarkasTerm (const G4Material *material, G4double kineticEnergy) const

G4double	BlochTerm (const G4Material *material, G4double kineticEnergy, G4double cSquare) const

void	BuildLambdaTable (const G4ParticleDefinition &aParticleType)

void	BuildLossTable (const G4ParticleDefinition &aParticleType)

G4double	DeltaRaysEnergy (const G4MaterialCutsCouple *couple, G4double kineticEnergy, G4double particleMass) const

G4double	ElectronicLossFluctuation (const G4DynamicParticle particle, const G4MaterialCutsCouple material, G4double meanLoss, G4double step) const

	G4hImpactIonisation (const G4hImpactIonisation &)

G4double	GetConstraints (const G4DynamicParticle particle, const G4MaterialCutsCouple couple)

void	InitializeMe ()

void	InitializeParametrisation ()

G4double	MicroscopicCrossSection (const G4ParticleDefinition &aParticleType, G4double kineticEnergy, G4double atomicNumber, G4double deltaCutInEnergy) const

G4hImpactIonisation &	operator= (const G4hImpactIonisation &right)

G4double	ProtonParametrisedDEDX (const G4MaterialCutsCouple *couple, G4double kineticEnergy) const

void	SetAntiProtonElectronicStoppingPowerModel (const G4String &dedxTable)

void	SetProtonElectronicStoppingPowerModel (const G4String &dedxTable)

Static Private Member Functions
static void	BuildInverseRangeTable (const G4ParticleDefinition &aParticleType)

static void	BuildLabTimeVector (G4int materialIndex, G4PhysicsLogVector *rangeVector)

static void	BuildProperTimeVector (G4int materialIndex, G4PhysicsLogVector *rangeVector)

static void	BuildRangeCoeffATable (const G4ParticleDefinition &aParticleType)

static void	BuildRangeCoeffBTable (const G4ParticleDefinition &aParticleType)

static void	BuildRangeCoeffCTable (const G4ParticleDefinition &aParticleType)

static void	BuildRangeTable (const G4ParticleDefinition &aParticleType)

static void	BuildRangeVector (G4int materialIndex, G4PhysicsLogVector *rangeVector)

static void	BuildTimeTables (const G4ParticleDefinition &aParticleType)

static void	InvertRangeVector (G4int materialIndex, G4PhysicsLogVector *rangeVector)

static G4double	LabTimeIntLog (G4PhysicsVector *physicsVector, G4int nbin)

static G4double	ProperTimeIntLog (G4PhysicsVector *physicsVector, G4int nbin)

static G4double	RangeIntLin (G4PhysicsVector *physicsVector, G4int nbin)

static G4double	RangeIntLog (G4PhysicsVector *physicsVector, G4int nbin)

Private Attributes
G4double	antiprotonHighEnergy

G4double	antiprotonLowEnergy

G4VLowEnergyModel *	antiprotonModel

G4String	antiprotonTable

G4AtomicDeexcitation	atomicDeexcitation

G4VLowEnergyModel *	betheBlochModel

G4double	charge

G4double	chargeSquare

G4DataVector	cutForDelta

G4DataVector	cutForGamma

G4double	eMaxPixe

G4double	eMinPixe

G4double	fBarkas

G4double	fdEdx

G4ProcessTable *	fProcessTable = nullptr

G4double	fRangeNow

G4double	initialMass

G4VProcess *	masterProcessShadow = nullptr

G4double	minElectronEnergy

G4double	minGammaEnergy

G4String	modelK

G4String	modelL

G4String	modelM

G4bool	nStopping

const G4double	paramStepLimit

G4PixeCrossSectionHandler *	pixeCrossSectionHandler

G4bool	pixeIsActive

G4double	protonHighEnergy

G4double	protonLowEnergy

G4VLowEnergyModel *	protonModel

G4String	protonTable

G4bool	theBarkas

G4VLowEnergyModel *	theIonChuFluctuationModel

G4VLowEnergyModel *	theIonEffChargeModel

G4VLowEnergyModel *	theIonYangFluctuationModel

G4PhysicsTable *	theMeanFreePathTable

G4VLowEnergyModel *	theNuclearStoppingModel

G4String	theNuclearTable

G4GPILSelection	valueGPILSelection = CandidateForSelection

Static Private Attributes
static G4ThreadLocal G4int	CounterOfProcess = 0

static G4ThreadLocal G4double	ltauhigh

static G4ThreadLocal G4double	ltaulow

static G4ThreadLocal G4double	Mass

static G4ThreadLocal G4int	NumberOfProcesses = 1

static G4ThreadLocal G4PhysicsTable **	RecorderOfProcess = 0

static G4ThreadLocal G4double	tauhigh

static G4ThreadLocal G4double	taulow

static G4ThreadLocal G4PhysicsTable *	theDEDXTable = 0

static G4ThreadLocal G4PhysicsTable *	theInverseRangeTable = 0

static G4ThreadLocal G4PhysicsTable *	theLabTimeTable = 0

static G4ThreadLocal G4PhysicsTable *	thepbarRangeCoeffATable = 0

static G4ThreadLocal G4PhysicsTable *	thepbarRangeCoeffBTable = 0

static G4ThreadLocal G4PhysicsTable *	thepbarRangeCoeffCTable = 0

static G4ThreadLocal G4PhysicsTable *	thepRangeCoeffATable = 0

static G4ThreadLocal G4PhysicsTable *	thepRangeCoeffBTable = 0

static G4ThreadLocal G4PhysicsTable *	thepRangeCoeffCTable = 0

static G4ThreadLocal G4PhysicsTable *	theProperTimeTable = 0

static G4ThreadLocal G4PhysicsTable *	theRangeCoeffATable = 0

static G4ThreadLocal G4PhysicsTable *	theRangeCoeffBTable = 0

static G4ThreadLocal G4PhysicsTable *	theRangeCoeffCTable = 0

static G4ThreadLocal G4PhysicsTable *	theRangeTable = 0

Detailed Description

Definition at line 74 of file G4hImpactIonisation.hh.

Constructor & Destructor Documentation

◆ G4hImpactIonisation() [1/2]

G4hImpactIonisation::G4hImpactIonisation ( const G4String & processName = "hImpactIoni" )

Definition at line 82 of file G4hImpactIonisation.cc.

  : G4hRDEnergyLoss(processName),
    betheBlochModel(0),
    protonModel(0),
    antiprotonModel(0),
    theIonEffChargeModel(0),
    theNuclearStoppingModel(0),
    theIonChuFluctuationModel(0),
    theIonYangFluctuationModel(0),
    protonTable("ICRU_R49p"),
    antiprotonTable("ICRU_R49p"),
    theNuclearTable("ICRU_R49"),
    nStopping(true),
    theBarkas(true),
    theMeanFreePathTable(0),
    paramStepLimit (0.005),
    pixeCrossSectionHandler(0)
{ 
  InitializeMe();
}

References InitializeMe().

◆ ~G4hImpactIonisation()

G4hImpactIonisation::~G4hImpactIonisation ( )

Definition at line 131 of file G4hImpactIonisation.cc.

{
  if (theMeanFreePathTable) 
    {
      theMeanFreePathTable->clearAndDestroy();
      delete theMeanFreePathTable;
    }
 
  if (betheBlochModel) delete betheBlochModel;
  if (protonModel) delete protonModel;
  if (antiprotonModel) delete antiprotonModel;
  if (theNuclearStoppingModel) delete theNuclearStoppingModel;
  if (theIonEffChargeModel) delete theIonEffChargeModel;
  if (theIonChuFluctuationModel) delete theIonChuFluctuationModel;
  if (theIonYangFluctuationModel) delete theIonYangFluctuationModel;
 
  delete pixeCrossSectionHandler;
 
  // ---- MGP ---- The following is to be checked
  //  if (shellVacancy) delete shellVacancy;
 
  cutForDelta.clear();
}

References antiprotonModel, betheBlochModel, G4PhysicsTable::clearAndDestroy(), cutForDelta, pixeCrossSectionHandler, protonModel, theIonChuFluctuationModel, theIonEffChargeModel, theIonYangFluctuationModel, theMeanFreePathTable, and theNuclearStoppingModel.

◆ G4hImpactIonisation() [2/2]

G4hImpactIonisation::G4hImpactIonisation ( const G4hImpactIonisation & )

private

Member Function Documentation

◆ ActivateAugerElectronProduction()

void G4hImpactIonisation::ActivateAugerElectronProduction ( G4bool val )

Definition at line 1706 of file G4hImpactIonisation.cc.

{
  atomicDeexcitation.ActivateAugerElectronProduction(val);
}

References G4AtomicDeexcitation::ActivateAugerElectronProduction(), and atomicDeexcitation.

◆ AlongStepDoIt()

G4VParticleChange * G4hImpactIonisation::AlongStepDoIt	(	const G4Track &	trackData,
		const G4Step &	stepData
	)

virtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 717 of file G4hImpactIonisation.cc.

{
  // compute the energy loss after a step
  G4Proton* proton = G4Proton::Proton();
  G4AntiProton* antiproton = G4AntiProton::AntiProton();
  G4double finalT = 0.;
 
  aParticleChange.Initialize(track) ;
 
  const G4MaterialCutsCouple* couple = track.GetMaterialCutsCouple();
  const G4Material* material = couple->GetMaterial();
 
  // get the actual (true) Step length from step
  const G4double stepLength = step.GetStepLength() ;
 
  const G4DynamicParticle* particle = track.GetDynamicParticle() ;
 
  G4double kineticEnergy = particle->GetKineticEnergy() ;
  G4double massRatio = proton_mass_c2/(particle->GetMass()) ;
  G4double tScaled = kineticEnergy * massRatio ;
  G4double eLoss = 0.0 ;
  G4double nLoss = 0.0 ;
 
 
  // very small particle energy
  if (kineticEnergy < MinKineticEnergy) 
    {
      eLoss = kineticEnergy ;
      // particle energy outside tabulated energy range
    } 
  
  else if( kineticEnergy > HighestKineticEnergy) 
    {
      eLoss = stepLength * fdEdx ;
      // big step
    } 
  else if (stepLength >= fRangeNow ) 
    {
      eLoss = kineticEnergy ;
      
      // tabulated range
    } 
  else 
    {
      // step longer than linear step limit
      if(stepLength > linLossLimit * fRangeNow) 
    {
      G4double rScaled = fRangeNow * massRatio * chargeSquare ;
      G4double sScaled = stepLength * massRatio * chargeSquare ;
      
      if(charge > 0.0) 
        {
          eLoss = G4EnergyLossTables::GetPreciseEnergyFromRange(proton,rScaled, couple) -
        G4EnergyLossTables::GetPreciseEnergyFromRange(proton,rScaled-sScaled,couple) ;
        
        } 
      else 
        {
          // Antiproton
          eLoss = G4EnergyLossTables::GetPreciseEnergyFromRange(antiproton,rScaled,couple) -
        G4EnergyLossTables::GetPreciseEnergyFromRange(antiproton,rScaled-sScaled,couple) ;
        }
      eLoss /= massRatio ;
      
      // Barkas correction at big step      
      eLoss += fBarkas * stepLength;
      
      // step shorter than linear step limit
    } 
      else 
    {
      eLoss = stepLength *fdEdx  ;
    }
      if (nStopping && tScaled < protonHighEnergy) 
    {
      nLoss = (theNuclearStoppingModel->TheValue(particle, material)) * stepLength;
    }
    }
  
  if (eLoss < 0.0) eLoss = 0.0;
 
  finalT = kineticEnergy - eLoss - nLoss;
 
  if ( EnlossFlucFlag && 0.0 < eLoss && finalT > MinKineticEnergy) 
    {
      
      //  now the electron loss with fluctuation
      eLoss = ElectronicLossFluctuation(particle, couple, eLoss, stepLength) ;
      if (eLoss < 0.0) eLoss = 0.0;
      finalT = kineticEnergy - eLoss - nLoss;
    }
 
  //  stop particle if the kinetic energy <= MinKineticEnergy
  if (finalT*massRatio <= MinKineticEnergy ) 
    {
      
      finalT = 0.0;
      if (!particle->GetDefinition()->GetProcessManager()->GetAtRestProcessVector()->size())
        aParticleChange.ProposeTrackStatus(fStopAndKill);
      else
        aParticleChange.ProposeTrackStatus(fStopButAlive);
    }
 
  aParticleChange.ProposeEnergy( finalT );
  eLoss = kineticEnergy-finalT;
 
  aParticleChange.ProposeLocalEnergyDeposit(eLoss);
  return &aParticleChange ;
}

References G4AntiProton::AntiProton(), G4VProcess::aParticleChange, charge, chargeSquare, ElectronicLossFluctuation(), G4hRDEnergyLoss::EnlossFlucFlag, fBarkas, fdEdx, fRangeNow, fStopAndKill, fStopButAlive, G4ProcessManager::GetAtRestProcessVector(), G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), G4DynamicParticle::GetKineticEnergy(), G4DynamicParticle::GetMass(), G4MaterialCutsCouple::GetMaterial(), G4Track::GetMaterialCutsCouple(), G4EnergyLossTables::GetPreciseEnergyFromRange(), G4ParticleDefinition::GetProcessManager(), G4Step::GetStepLength(), G4hRDEnergyLoss::HighestKineticEnergy, G4ParticleChange::Initialize(), G4hRDEnergyLoss::linLossLimit, eplot::material, G4hRDEnergyLoss::MinKineticEnergy, nStopping, G4ParticleChange::ProposeEnergy(), G4VParticleChange::ProposeLocalEnergyDeposit(), G4VParticleChange::ProposeTrackStatus(), G4Proton::Proton(), G4InuclParticleNames::proton, source.hepunit::proton_mass_c2, protonHighEnergy, G4ProcessVector::size(), theNuclearStoppingModel, and G4VLowEnergyModel::TheValue().

◆ AlongStepGetPhysicalInteractionLength()

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

virtualinherited

Implements G4VProcess.

Reimplemented in G4VMultipleScattering, and G4VEnergyLossProcess.

Definition at line 143 of file G4VContinuousDiscreteProcess.cc.

{
  // GPILSelection is set to defaule value of CandidateForSelection
  valueGPILSelection = CandidateForSelection;
 
  // get Step limit proposed by the process
  G4double steplength = GetContinuousStepLimit(track,previousStepSize,currentMinimumStep,currentSafety);
 
  // set return value for G4GPILSelection
  *selection = valueGPILSelection;
 
#ifdef G4VERBOSE
  if (verboseLevel>1)
  {
    G4cout << "G4VContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength() - ";
    G4cout << "[ " << GetProcessName() << "]" << G4endl;
    track.GetDynamicParticle()->DumpInfo();
    G4cout << " in Material  " <<  track.GetMaterial()->GetName() << G4endl;
    G4cout << "IntractionLength= " << steplength/cm <<"[cm] " << G4endl;
  }
#endif
  return  steplength;
}

References CandidateForSelection, cm, G4DynamicParticle::DumpInfo(), G4cout, G4endl, G4VContinuousDiscreteProcess::GetContinuousStepLimit(), G4Track::GetDynamicParticle(), G4Track::GetMaterial(), G4Material::GetName(), G4VProcess::GetProcessName(), G4VContinuousDiscreteProcess::valueGPILSelection, and G4VProcess::verboseLevel.

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

◆ AntiProtonParametrisedDEDX()

G4double G4hImpactIonisation::AntiProtonParametrisedDEDX	(	const G4MaterialCutsCouple *	couple,
		G4double	kineticEnergy
	)		const

private

Definition at line 866 of file G4hImpactIonisation.cc.

{
  const G4Material* material = couple->GetMaterial();
  G4AntiProton* antiproton = G4AntiProton::AntiProton();
  G4double eLoss = 0.0 ;
 
  // Antiproton model is used
  if(antiprotonModel->IsInCharge(antiproton,material)) {
    if(kineticEnergy < antiprotonLowEnergy) {
      eLoss = antiprotonModel->TheValue(antiproton,material,antiprotonLowEnergy)
    * std::sqrt(kineticEnergy/antiprotonLowEnergy) ;
 
      // Parametrisation
    } else {
      eLoss = antiprotonModel->TheValue(antiproton,material,
                    kineticEnergy);
    }
 
    // The proton model is used + Barkas correction
  } else {
    if(kineticEnergy < protonLowEnergy) {
      eLoss = protonModel->TheValue(G4Proton::Proton(),material,protonLowEnergy)
    * std::sqrt(kineticEnergy/protonLowEnergy) ;
 
      // Parametrisation
    } else {
      eLoss = protonModel->TheValue(G4Proton::Proton(),material,
                    kineticEnergy);
    }
    //if(theBarkas) eLoss -= 2.0*BarkasTerm(material, kineticEnergy);
  }
 
  // Delta rays energy
  eLoss -= DeltaRaysEnergy(couple,kineticEnergy,proton_mass_c2) ;
 
  if(verboseLevel > 2) {
    G4cout << "pbar E(MeV)= " << kineticEnergy/MeV
           << " dE/dx(MeV/mm)= " << eLoss*mm/MeV
           << " for " << material->GetName()
           << " model: " << protonModel << G4endl;
  }
 
  if(eLoss < 0.0) eLoss = 0.0 ;
 
  return eLoss ;
}

References G4AntiProton::AntiProton(), antiprotonLowEnergy, antiprotonModel, DeltaRaysEnergy(), G4cout, G4endl, G4MaterialCutsCouple::GetMaterial(), G4VLowEnergyModel::IsInCharge(), eplot::material, MeV, mm, G4Proton::Proton(), source.hepunit::proton_mass_c2, protonLowEnergy, protonModel, G4VLowEnergyModel::TheValue(), and G4VProcess::verboseLevel.

Referenced by BuildLossTable(), and ComputeDEDX().

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

◆ BarkasTerm()

G4double G4hImpactIonisation::BarkasTerm	(	const G4Material *	material,
		G4double	kineticEnergy
	)		const

private

Definition at line 1305 of file G4hImpactIonisation.cc.

{
  static G4ThreadLocal G4double FTable[47][2] = {
    { 0.02, 21.5},
    { 0.03, 20.0},
    { 0.04, 18.0},
    { 0.05, 15.6},
    { 0.06, 15.0},
    { 0.07, 14.0},
    { 0.08, 13.5},
    { 0.09, 13.},
    { 0.1,  12.2},
    { 0.2,  9.25},
    { 0.3,  7.0},
    { 0.4,  6.0},
    { 0.5,  4.5},
    { 0.6,  3.5},
    { 0.7,  3.0},
    { 0.8,  2.5},
    { 0.9,  2.0},
    { 1.0,  1.7},
    { 1.2,  1.2},
    { 1.3,  1.0},
    { 1.4,  0.86},
    { 1.5,  0.7},
    { 1.6,  0.61},
    { 1.7,  0.52},
    { 1.8,  0.5},
    { 1.9,  0.43},
    { 2.0,  0.42},
    { 2.1,  0.3},
    { 2.4,  0.2},
    { 3.0,  0.13},
    { 3.08, 0.1},
    { 3.1,  0.09},
    { 3.3,  0.08},
    { 3.5,  0.07},
    { 3.8,  0.06},
    { 4.0,  0.051},
    { 4.1,  0.04},
    { 4.8,  0.03},
    { 5.0,  0.024},
    { 5.1,  0.02},
    { 6.0,  0.013},
    { 6.5,  0.01},
    { 7.0,  0.009},
    { 7.1,  0.008},
    { 8.0,  0.006},
    { 9.0,  0.0032},
    { 10.0, 0.0025} };
 
  // Information on particle and material
  G4double kinE  = kineticEnergy ;
  if(0.5*MeV > kinE) kinE = 0.5*MeV ;
  G4double gamma = 1.0 + kinE / proton_mass_c2 ;
  G4double beta2 = 1.0 - 1.0/(gamma*gamma) ;
  if(0.0 >= beta2) return 0.0;
 
  G4double BTerm = 0.0;
  //G4double AMaterial = 0.0;
  G4double ZMaterial = 0.0;
  const G4ElementVector* theElementVector = material->GetElementVector();
  G4int numberOfElements = material->GetNumberOfElements();
 
  for (G4int i = 0; i<numberOfElements; i++) {
 
    //AMaterial = (*theElementVector)[i]->GetA()*mole/g;
    ZMaterial = (*theElementVector)[i]->GetZ();
 
    G4double X = 137.0 * 137.0 * beta2 / ZMaterial;
 
    // Variables to compute L_1
    G4double Eta0Chi = 0.8;
    G4double EtaChi = Eta0Chi * ( 1.0 + 6.02*std::pow( ZMaterial,-1.19 ) );
    G4double W = ( EtaChi * std::pow( ZMaterial,1.0/6.0 ) ) / std::sqrt(X);
    G4double FunctionOfW = FTable[46][1]*FTable[46][0]/W ;
 
    for(G4int j=0; j<47; j++) {
 
      if( W < FTable[j][0] ) {
 
        if(0 == j) {
          FunctionOfW = FTable[0][1] ;
 
        } else {
          FunctionOfW = (FTable[j][1] - FTable[j-1][1]) * (W - FTable[j-1][0])
        / (FTable[j][0] - FTable[j-1][0])
        +  FTable[j-1][1] ;
    }
 
        break;
      }
 
    }
 
    BTerm += FunctionOfW /( std::sqrt(ZMaterial * X) * X);
  }
 
  BTerm *= twopi_mc2_rcl2 * (material->GetElectronDensity()) / beta2 ;
 
  return BTerm;
}

References G4ThreadLocal, eplot::material, MeV, source.hepunit::proton_mass_c2, and source.hepunit::twopi_mc2_rcl2.

Referenced by GetConstraints().

◆ BlochTerm()

G4double G4hImpactIonisation::BlochTerm	(	const G4Material *	material,
		G4double	kineticEnergy,
		G4double	cSquare
	)		const

private

Definition at line 1417 of file G4hImpactIonisation.cc.

{
  G4double eLoss = 0.0 ;
  G4double gamma = 1.0 + kineticEnergy / proton_mass_c2 ;
  G4double beta2 = 1.0 - 1.0/(gamma*gamma) ;
  G4double y = cSquare / (137.0*137.0*beta2) ;
 
  if(y < 0.05) {
    eLoss = 1.202 ;
 
  } else {
    eLoss = 1.0 / (1.0 + y) ;
    G4double de = eLoss ;
 
    for(G4int i=2; de>eLoss*0.01; i++) {
      de = 1.0/( i * (i*i + y)) ;
      eLoss += de ;
    }
  }
  eLoss *= -1.0 * y * cSquare * twopi_mc2_rcl2 *
    (material->GetElectronDensity()) / beta2 ;
 
  return eLoss;
}

References eplot::material, source.hepunit::proton_mass_c2, and source.hepunit::twopi_mc2_rcl2.

Referenced by GetConstraints().

◆ BuildDEDXTable()

void G4hRDEnergyLoss::BuildDEDXTable ( const G4ParticleDefinition & aParticleType )

staticprotectedinherited

Definition at line 250 of file G4hRDEnergyLoss.cc.

{
  //  calculate data members TotBin,LOGRTable,RTable first
 
  if (!RecorderOfpbarProcess) RecorderOfpbarProcess = new G4PhysicsTable*[100];
  if (!RecorderOfpProcess) RecorderOfpProcess = new G4PhysicsTable*[100];
  if (!RecorderOfProcess) RecorderOfProcess = new G4PhysicsTable*[100];
 
  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();
 
  // create/fill proton or antiproton tables depending on the charge
  Charge = aParticleType.GetPDGCharge()/eplus;
  ParticleMass = aParticleType.GetPDGMass() ;
 
  if (Charge>0.) {theDEDXTable= theDEDXpTable;}
  else           {theDEDXTable= theDEDXpbarTable;}
 
  if( ((Charge>0.) && (theDEDXTable==0)) ||
      ((Charge<0.) && (theDEDXTable==0)) 
      )
    {
 
      // Build energy loss table as a sum of the energy loss due to the
      //              different processes.
      if( Charge >0.)
    {
      RecorderOfProcess=RecorderOfpProcess;
      CounterOfProcess=CounterOfpProcess;
 
      if(CounterOfProcess == NumberOfProcesses)
        {
          if(theDEDXpTable)
        { theDEDXpTable->clearAndDestroy();
          delete theDEDXpTable; }
          theDEDXpTable = new G4PhysicsTable(numOfCouples);
          theDEDXTable = theDEDXpTable;
        }
    }
      else
    {
      RecorderOfProcess=RecorderOfpbarProcess;
      CounterOfProcess=CounterOfpbarProcess;
 
      if(CounterOfProcess == NumberOfProcesses)
        {
          if(theDEDXpbarTable)
        { theDEDXpbarTable->clearAndDestroy();
          delete theDEDXpbarTable; }
          theDEDXpbarTable = new G4PhysicsTable(numOfCouples);
          theDEDXTable = theDEDXpbarTable;
        }
    }
 
      if(CounterOfProcess == NumberOfProcesses)
    {
      //  loop for materials
      G4double LowEdgeEnergy , Value ;
      G4bool isOutRange ;
      G4PhysicsTable* pointer ;
 
      for (size_t J=0; J<numOfCouples; J++)
        {
          // create physics vector and fill it
          G4PhysicsLogVector* aVector =
                new G4PhysicsLogVector(LowestKineticEnergy,
                                       HighestKineticEnergy, TotBin);
 
          // loop for the kinetic energy
          for (G4int i=0; i<TotBin; i++)
        {
          LowEdgeEnergy = aVector->GetLowEdgeEnergy(i) ;
          Value = 0. ;
 
          // loop for the contributing processes
          for (G4int process=0; process < NumberOfProcesses; process++)
            {
              pointer= RecorderOfProcess[process];
              Value += (*pointer)[J]->
            GetValue(LowEdgeEnergy,isOutRange) ;
            }
 
          aVector->PutValue(i,Value) ;
        }
 
          theDEDXTable->insert(aVector) ;
        }
 
      //  reset counter to zero ..................
      if( Charge >0.)
        CounterOfpProcess=0 ;
      else
        CounterOfpbarProcess=0 ;
 
      // Build range table
      BuildRangeTable( aParticleType);
 
      // Build lab/proper time tables
      BuildTimeTables( aParticleType) ;
 
      // Build coeff tables for the energy loss calculation
      BuildRangeCoeffATable( aParticleType);
      BuildRangeCoeffBTable( aParticleType);
      BuildRangeCoeffCTable( aParticleType);
 
      // invert the range table
 
      BuildInverseRangeTable(aParticleType);
    }
    }
  // make the energy loss and the range table available
 
  G4EnergyLossTables::Register(&aParticleType,
                   (Charge>0)?
                   theDEDXpTable: theDEDXpbarTable,
                   (Charge>0)?
                   theRangepTable: theRangepbarTable,
                   (Charge>0)?
                   theInverseRangepTable: theInverseRangepbarTable,
                   (Charge>0)?
                   theLabTimepTable: theLabTimepbarTable,
                   (Charge>0)?
                   theProperTimepTable: theProperTimepbarTable,
                   LowestKineticEnergy, HighestKineticEnergy,
                   proton_mass_c2/aParticleType.GetPDGMass(),
                   TotBin);
 
}

References G4hRDEnergyLoss::BuildInverseRangeTable(), G4hRDEnergyLoss::BuildRangeCoeffATable(), G4hRDEnergyLoss::BuildRangeCoeffBTable(), G4hRDEnergyLoss::BuildRangeCoeffCTable(), G4hRDEnergyLoss::BuildRangeTable(), G4hRDEnergyLoss::BuildTimeTables(), G4hRDEnergyLoss::Charge, G4PhysicsTable::clearAndDestroy(), G4hRDEnergyLoss::CounterOfpbarProcess, G4hRDEnergyLoss::CounterOfpProcess, G4hRDEnergyLoss::CounterOfProcess, eplus, G4PhysicsVector::GetLowEdgeEnergy(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4hRDEnergyLoss::HighestKineticEnergy, G4PhysicsTable::insert(), G4hRDEnergyLoss::LowestKineticEnergy, G4hRDEnergyLoss::NumberOfProcesses, G4hRDEnergyLoss::ParticleMass, source.hepunit::proton_mass_c2, G4PhysicsVector::PutValue(), G4hRDEnergyLoss::RecorderOfpbarProcess, G4hRDEnergyLoss::RecorderOfpProcess, G4hRDEnergyLoss::RecorderOfProcess, G4EnergyLossTables::Register(), G4hRDEnergyLoss::theDEDXpbarTable, G4hRDEnergyLoss::theDEDXpTable, G4hRDEnergyLoss::theDEDXTable, G4hRDEnergyLoss::theInverseRangepbarTable, G4hRDEnergyLoss::theInverseRangepTable, G4hRDEnergyLoss::theLabTimepbarTable, G4hRDEnergyLoss::theLabTimepTable, G4hRDEnergyLoss::theProperTimepbarTable, G4hRDEnergyLoss::theProperTimepTable, G4hRDEnergyLoss::theRangepbarTable, G4hRDEnergyLoss::theRangepTable, and G4hRDEnergyLoss::TotBin.

Referenced by BuildPhysicsTable().

◆ BuildInverseRangeTable()

void G4hRDEnergyLoss::BuildInverseRangeTable ( const G4ParticleDefinition & aParticleType )

staticprivateinherited

Definition at line 1001 of file G4hRDEnergyLoss.cc.

{
  // Build inverse table of the range table
 
  G4bool b;
 
  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();
 
  if(&aParticleType == G4Proton::Proton())
    {
      if(theInverseRangepTable)
    { theInverseRangepTable->clearAndDestroy();
      delete theInverseRangepTable; }
      theInverseRangepTable = new G4PhysicsTable(numOfCouples);
      theInverseRangeTable = theInverseRangepTable ;
      theRangeTable = theRangepTable ;
      theDEDXTable =  theDEDXpTable ;
      theRangeCoeffATable = thepRangeCoeffATable ;
      theRangeCoeffBTable = thepRangeCoeffBTable ;
      theRangeCoeffCTable = thepRangeCoeffCTable ;
    }
 
  if(&aParticleType == G4AntiProton::AntiProton())
    {
      if(theInverseRangepbarTable)
    { theInverseRangepbarTable->clearAndDestroy();
      delete theInverseRangepbarTable; }
      theInverseRangepbarTable = new G4PhysicsTable(numOfCouples);
      theInverseRangeTable = theInverseRangepbarTable ;
      theRangeTable = theRangepbarTable ;
      theDEDXTable =  theDEDXpbarTable ;
      theRangeCoeffATable = thepbarRangeCoeffATable ;
      theRangeCoeffBTable = thepbarRangeCoeffBTable ;
      theRangeCoeffCTable = thepbarRangeCoeffCTable ;
    }
 
  // loop for materials 
  for (size_t i=0;  i<numOfCouples; i++)
    {
 
      G4PhysicsVector* pv = (*theRangeTable)[i];
      size_t nbins   = pv->GetVectorLength();
      G4double elow  = pv->GetLowEdgeEnergy(0);
      G4double ehigh = pv->GetLowEdgeEnergy(nbins-1);
      G4double rlow  = pv->GetValue(elow, b);
      G4double rhigh = pv->GetValue(ehigh, b);
 
      if (rlow <DBL_MIN) rlow = 1.e-8;
      if (rhigh > 1.e16) rhigh = 1.e16;
      if (rhigh < 1.e-8) rhigh =1.e-8;
      G4double tmpTrick = rhigh/rlow;
 
      //std::cout << nbins << ", elow " << elow << ", ehigh " << ehigh 
      //        << ", rlow " << rlow << ", rhigh " << rhigh
      //                << ", trick " << tmpTrick << std::endl;
 
      if (tmpTrick <= 0. || tmpTrick < DBL_MIN) tmpTrick = 1.e-8; 
      if (tmpTrick > 1.e16) tmpTrick = 1.e16; 
     
      rhigh *= std::exp(std::log(tmpTrick)/((G4double)(nbins-1)));
 
      G4PhysicsLogVector* v = new G4PhysicsLogVector(rlow, rhigh, nbins);
 
      v->PutValue(0,elow);
      G4double energy1 = elow;
      G4double range1  = rlow;
      G4double energy2 = elow;
      G4double range2  = rlow;
      size_t ilow      = 0;
      size_t ihigh;
 
      for (size_t j=1; j<nbins; j++) {
 
    G4double range = v->GetLowEdgeEnergy(j);
 
    for (ihigh=ilow+1; ihigh<nbins; ihigh++) {
      energy2 = pv->GetLowEdgeEnergy(ihigh);
      range2  = pv->GetValue(energy2, b);
      if(range2 >= range || ihigh == nbins-1) {
        ilow = ihigh - 1;
        energy1 = pv->GetLowEdgeEnergy(ilow);
        range1  = pv->GetValue(energy1, b);
        break;
      }
    }
 
    G4double e = std::log(energy1) + std::log(energy2/energy1)*std::log(range/range1)/std::log(range2/range1);
 
    v->PutValue(j,std::exp(e));
      }
      theInverseRangeTable->insert(v);
 
    }
}

Referenced by G4hRDEnergyLoss::BuildDEDXTable().

◆ BuildLabTimeVector()

void G4hRDEnergyLoss::BuildLabTimeVector	(	G4int	materialIndex,
		G4PhysicsLogVector *	rangeVector
	)

staticprivateinherited

Definition at line 515 of file G4hRDEnergyLoss.cc.

{
  //  create lab time vector for a material
 
  G4int nbin=100;
  G4bool isOut;
  G4double tlim=5.*keV,parlowen=0.4,ppar=0.5-parlowen ;
  //G4double losslim,clim,taulim,timelim,ltaulim,ltaumax,
  G4double losslim,clim,taulim,timelim,
    LowEdgeEnergy,tau,Value ;
 
  G4PhysicsVector* physicsVector= (*theDEDXTable)[materialIndex];
 
  // low energy part first...
  losslim = physicsVector->GetValue(tlim,isOut);
  taulim=tlim/ParticleMass ;
  clim=std::sqrt(ParticleMass*tlim/2.)/(c_light*losslim*ppar) ;
  //ltaulim = std::log(taulim);
  //ltaumax = std::log(HighestKineticEnergy/ParticleMass) ;
 
  G4int i=-1;
  G4double oldValue = 0. ;
  G4double tauold ;
  do  
    {
      i += 1 ;
      LowEdgeEnergy = timeVector->GetLowEdgeEnergy(i);
      tau = LowEdgeEnergy/ParticleMass ;
      if ( tau <= taulim )
    {
      Value = clim*std::exp(ppar*std::log(tau/taulim)) ;
    }
      else
    {
      timelim=clim ;
      ltaulow = std::log(taulim);
      ltauhigh = std::log(tau);
      Value = timelim+LabTimeIntLog(physicsVector,nbin);
    }
      timeVector->PutValue(i,Value);
      oldValue = Value ;
      tauold = tau ;
    } while (tau<=taulim) ;
 
  i += 1 ;
  for (G4int j=i; j<TotBin; j++)
    {
      LowEdgeEnergy = timeVector->GetLowEdgeEnergy(j);
      tau = LowEdgeEnergy/ParticleMass ;
      ltaulow = std::log(tauold);
      ltauhigh = std::log(tau);
      Value = oldValue+LabTimeIntLog(physicsVector,nbin);
      timeVector->PutValue(j,Value);
      oldValue = Value ;
      tauold = tau ;
    }
}

References source.hepunit::c_light, G4PhysicsVector::GetLowEdgeEnergy(), G4PhysicsVector::GetValue(), keV, G4hRDEnergyLoss::LabTimeIntLog(), G4hRDEnergyLoss::ltauhigh, G4hRDEnergyLoss::ltaulow, G4hRDEnergyLoss::ParticleMass, G4PhysicsVector::PutValue(), and G4hRDEnergyLoss::TotBin.

Referenced by G4hRDEnergyLoss::BuildTimeTables().

◆ BuildLambdaTable()

void G4hImpactIonisation::BuildLambdaTable ( const G4ParticleDefinition & aParticleType )

private

Definition at line 445 of file G4hImpactIonisation.cc.

{
  // Build mean free path tables for the delta ray production process
  //     tables are built for MATERIALS
 
  if(verboseLevel > 1) {
    G4cout << "G4hImpactIonisation::BuildLambdaTable for "
           << particleDef.GetParticleName() << " is started" << G4endl;
  }
 
 
  G4double lowEdgeEnergy, value;
  charge = particleDef.GetPDGCharge()/eplus ;
  chargeSquare = charge*charge ;
  initialMass = particleDef.GetPDGMass();
 
  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();
 
 
  if (theMeanFreePathTable) {
    theMeanFreePathTable->clearAndDestroy();
    delete theMeanFreePathTable;
  }
 
  theMeanFreePathTable = new G4PhysicsTable(numOfCouples);
 
  // loop for materials
 
  for (size_t j=0 ; j < numOfCouples; j++) {
 
    //create physics vector then fill it ....
    G4PhysicsLogVector* aVector = new G4PhysicsLogVector(LowestKineticEnergy,
                                                         HighestKineticEnergy,
                                                         TotBin);
 
    // compute the (macroscopic) cross section first
    const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(j);
    const G4Material* material= couple->GetMaterial();
 
    const G4ElementVector* theElementVector =  material->GetElementVector() ;
    const G4double* theAtomicNumDensityVector = material->GetAtomicNumDensityVector();
    const G4int numberOfElements = material->GetNumberOfElements() ;
 
    // get the electron kinetic energy cut for the actual material,
    //  it will be used in ComputeMicroscopicCrossSection
    // ( it is the SAME for ALL the ELEMENTS in THIS MATERIAL )
    //   ------------------------------------------------------
 
    G4double deltaCut = cutForDelta[j];
 
    for ( G4int i = 0 ; i < TotBin ; i++ ) {
      lowEdgeEnergy = aVector->GetLowEdgeEnergy(i) ;
      G4double sigma = 0.0 ;
      G4int Z;
      
      for (G4int iel=0; iel<numberOfElements; iel++ ) 
    {
      Z = (G4int) (*theElementVector)[iel]->GetZ();
      // ---- MGP --- Corrected duplicated cross section calculation here from
      // G4hLowEnergyIonisation original
      G4double microCross = MicroscopicCrossSection( particleDef,
                             lowEdgeEnergy,
                             Z,
                             deltaCut ) ;   
      //totalCrossSectionMap [Z] = microCross;
      sigma += theAtomicNumDensityVector[iel] * microCross ; 
    }
 
      // mean free path = 1./macroscopic cross section
 
      value = sigma<=0 ? DBL_MAX : 1./sigma ;
 
      aVector->PutValue(i, value) ;
    }
 
    theMeanFreePathTable->insert(aVector);
  }
 
}

References charge, chargeSquare, G4PhysicsTable::clearAndDestroy(), cutForDelta, DBL_MAX, eplus, G4cout, G4endl, G4PhysicsVector::GetLowEdgeEnergy(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4hRDEnergyLoss::HighestKineticEnergy, initialMass, G4PhysicsTable::insert(), G4hRDEnergyLoss::LowestKineticEnergy, eplot::material, MicroscopicCrossSection(), G4PhysicsVector::PutValue(), theMeanFreePathTable, G4hRDEnergyLoss::TotBin, G4VProcess::verboseLevel, and Z.

Referenced by BuildPhysicsTable().

◆ BuildLossTable()

void G4hImpactIonisation::BuildLossTable ( const G4ParticleDefinition & aParticleType )

private

Definition at line 347 of file G4hImpactIonisation.cc.

{
  // Initialisation
  G4double lowEdgeEnergy , ionloss, ionlossBB, paramB ;
  //G4double lowEnergy, highEnergy;
  G4double highEnergy;
  G4Proton* proton = G4Proton::Proton();
 
  if (particleDef == *proton) 
    {
      //lowEnergy = protonLowEnergy ;
      highEnergy = protonHighEnergy ;
      charge = 1. ;
    } 
  else 
    {
      //lowEnergy = antiprotonLowEnergy ;
      highEnergy = antiprotonHighEnergy ;
      charge = -1. ;
    }
  chargeSquare = 1. ;
 
  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();
 
  if ( theLossTable) 
    {
      theLossTable->clearAndDestroy();
      delete theLossTable;
    }
 
  theLossTable = new G4PhysicsTable(numOfCouples);
 
  //  loop for materials
  for (size_t j=0; j<numOfCouples; j++) {
 
    // create physics vector and fill it
    G4PhysicsLogVector* aVector = new G4PhysicsLogVector(LowestKineticEnergy,
                                                         HighestKineticEnergy,
                                                         TotBin);
 
    // get material parameters needed for the energy loss calculation
    const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(j);
    const G4Material* material= couple->GetMaterial();
 
    if ( charge > 0.0 ) {
      ionloss = ProtonParametrisedDEDX(couple,highEnergy) ;
    } else {
      ionloss = AntiProtonParametrisedDEDX(couple,highEnergy) ;
    }
 
    ionlossBB = betheBlochModel->TheValue(&particleDef,material,highEnergy) ;
    ionlossBB -= DeltaRaysEnergy(couple,highEnergy,proton_mass_c2) ;
 
 
    paramB =  ionloss/ionlossBB - 1.0 ;
 
    // now comes the loop for the kinetic energy values
    for (G4int i = 0 ; i < TotBin ; i++) {
      lowEdgeEnergy = aVector->GetLowEdgeEnergy(i) ;
 
      // low energy part for this material, parametrised energy loss formulae
      if ( lowEdgeEnergy < highEnergy ) {
 
        if ( charge > 0.0 ) {
          ionloss = ProtonParametrisedDEDX(couple,lowEdgeEnergy) ;
    } else {
          ionloss = AntiProtonParametrisedDEDX(couple,lowEdgeEnergy) ;
    }
 
      } else {
 
        // high energy part for this material, Bethe-Bloch formula
        ionloss = betheBlochModel->TheValue(proton,material,
                        lowEdgeEnergy) ;
 
        ionloss -= DeltaRaysEnergy(couple,lowEdgeEnergy,proton_mass_c2) ;
 
    ionloss *= (1.0 + paramB*highEnergy/lowEdgeEnergy) ;
      }
 
      // now put the loss into the vector
      if(verboseLevel > 1) {
        G4cout << "E(MeV)= " << lowEdgeEnergy/MeV
               << "  dE/dx(MeV/mm)= " << ionloss*mm/MeV
               << " in " << material->GetName() << G4endl;
      }
      aVector->PutValue(i,ionloss) ;
    }
    // Insert vector for this material into the table
    theLossTable->insert(aVector) ;
  }
}

References antiprotonHighEnergy, AntiProtonParametrisedDEDX(), betheBlochModel, charge, chargeSquare, G4PhysicsTable::clearAndDestroy(), DeltaRaysEnergy(), G4cout, G4endl, G4PhysicsVector::GetLowEdgeEnergy(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4hRDEnergyLoss::HighestKineticEnergy, G4PhysicsTable::insert(), G4hRDEnergyLoss::LowestKineticEnergy, eplot::material, MeV, mm, G4Proton::Proton(), G4InuclParticleNames::proton, source.hepunit::proton_mass_c2, protonHighEnergy, ProtonParametrisedDEDX(), G4PhysicsVector::PutValue(), G4hRDEnergyLoss::theLossTable, G4VLowEnergyModel::TheValue(), G4hRDEnergyLoss::TotBin, and G4VProcess::verboseLevel.

Referenced by BuildPhysicsTable().

◆ BuildPhysicsTable()

void G4hImpactIonisation::BuildPhysicsTable ( const G4ParticleDefinition & aParticleType )

virtual

Reimplemented from G4VProcess.

Definition at line 190 of file G4hImpactIonisation.cc.

{
 
  // Verbose print-out
  if(verboseLevel > 0) 
    {
      G4cout << "G4hImpactIonisation::BuildPhysicsTable for "
         << particleDef.GetParticleName()
         << " mass(MeV)= " << particleDef.GetPDGMass()/MeV
         << " charge= " << particleDef.GetPDGCharge()/eplus
         << " type= " << particleDef.GetParticleType()
         << G4endl;
      
      if(verboseLevel > 1) 
    {
      G4ProcessVector* pv = particleDef.GetProcessManager()->GetProcessList();
      
      G4cout << " 0: " << (*pv)[0]->GetProcessName() << " " << (*pv)[0]
         << " 1: " << (*pv)[1]->GetProcessName() << " " << (*pv)[1]
        //        << " 2: " << (*pv)[2]->GetProcessName() << " " << (*pv)[2]
         << G4endl;
      G4cout << "ionModel= " << theIonEffChargeModel
         << " MFPtable= " << theMeanFreePathTable
         << " iniMass= " << initialMass
         << G4endl;
    }
    }
  // End of verbose print-out
 
  if (particleDef.GetParticleType() == "nucleus" &&
      particleDef.GetParticleName() != "GenericIon" &&
      particleDef.GetParticleSubType() == "generic")
    {
 
      G4EnergyLossTables::Register(&particleDef,
                   theDEDXpTable,
                   theRangepTable,
                   theInverseRangepTable,
                   theLabTimepTable,
                   theProperTimepTable,
                   LowestKineticEnergy, HighestKineticEnergy,
                   proton_mass_c2/particleDef.GetPDGMass(),
                   TotBin);
 
      return;
    }
 
  if( !CutsWhereModified() && theLossTable) return;
 
  InitializeParametrisation() ;
  G4Proton* proton = G4Proton::Proton();
  G4AntiProton* antiproton = G4AntiProton::AntiProton();
 
  charge = particleDef.GetPDGCharge() / eplus;
  chargeSquare = charge*charge ;
 
  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();
 
  cutForDelta.clear();
  cutForGamma.clear();
 
  for (size_t j=0; j<numOfCouples; j++) {
 
    // get material parameters needed for the energy loss calculation
    const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(j);
    const G4Material* material= couple->GetMaterial();
 
    // the cut cannot be below lowest limit
    G4double tCut = (*(theCoupleTable->GetEnergyCutsVector(1)))[j];
    if(tCut > HighestKineticEnergy) tCut = HighestKineticEnergy;
 
    G4double excEnergy = material->GetIonisation()->GetMeanExcitationEnergy();
 
    tCut = std::max(tCut,excEnergy);
    cutForDelta.push_back(tCut);
 
    // the cut cannot be below lowest limit
    tCut = (*(theCoupleTable->GetEnergyCutsVector(0)))[j];
    if(tCut > HighestKineticEnergy) tCut = HighestKineticEnergy;
    tCut = std::max(tCut,minGammaEnergy);
    cutForGamma.push_back(tCut);
  }
 
  if(verboseLevel > 0) {
    G4cout << "Cuts are defined " << G4endl;
  }
 
  if(0.0 < charge)
    {
      {
        BuildLossTable(*proton) ;
 
    //      The following vector has a fixed dimension (see src/G4hImpactLoss.cc for more details)        
    //      It happended in the past that caused memory corruption errors. The problem is still pending, even if temporary solved
    //        G4cout << "[NOTE]: __LINE__=" << __LINE__ << ", particleDef=" << particleDef.GetParticleName() << ", proton=" << proton << ", theLossTable=" << theLossTable << ", CounterOfpProcess=" << CounterOfpProcess << G4endl;
        
        RecorderOfpProcess[CounterOfpProcess] = theLossTable ;
        CounterOfpProcess++;
      }
    } else {
    {
      BuildLossTable(*antiproton) ;
        
      //      The following vector has a fixed dimension (see src/G4hImpactLoss.cc for more details)        
      //      It happended in the past that caused memory corruption errors. The problem is still pending, even if temporary solved
      //        G4cout << "[NOTE]: __LINE__=" << __LINE__ << ", particleDef=" << particleDef.GetParticleName() << ", antiproton=" << antiproton << ", theLossTable=" << theLossTable << ", CounterOfpbarProcess=" << CounterOfpbarProcess << G4endl;
        
      RecorderOfpbarProcess[CounterOfpbarProcess] = theLossTable ;
      CounterOfpbarProcess++;
    }
  }
 
  if(verboseLevel > 0) {
    G4cout << "G4hImpactIonisation::BuildPhysicsTable: "
           << "Loss table is built "
      //       << theLossTable
       << G4endl;
  }
 
  BuildLambdaTable(particleDef) ;
  //  BuildDataForFluorescence(particleDef);
 
  if(verboseLevel > 1) {
    G4cout << (*theMeanFreePathTable) << G4endl;
  }
 
  if(verboseLevel > 0) {
    G4cout << "G4hImpactIonisation::BuildPhysicsTable: "
           << "DEDX table will be built "
      //       << theDEDXpTable << " " << theDEDXpbarTable
      //       << " " << theRangepTable << " " << theRangepbarTable
       << G4endl;
  }
 
  BuildDEDXTable(particleDef) ;
 
  if(verboseLevel > 1) {
    G4cout << (*theDEDXpTable) << G4endl;
  }
 
  if((&particleDef == proton) ||  (&particleDef == antiproton)) PrintInfoDefinition() ;
 
  if(verboseLevel > 0) {
    G4cout << "G4hImpactIonisation::BuildPhysicsTable: end for "
           << particleDef.GetParticleName() << G4endl;
  }
}

References G4AntiProton::AntiProton(), G4hRDEnergyLoss::BuildDEDXTable(), BuildLambdaTable(), BuildLossTable(), charge, chargeSquare, G4hRDEnergyLoss::CounterOfpbarProcess, G4hRDEnergyLoss::CounterOfpProcess, cutForDelta, cutForGamma, G4hRDEnergyLoss::CutsWhereModified(), eplus, G4cout, G4endl, G4ProductionCutsTable::GetEnergyCutsVector(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleSubType(), G4ParticleDefinition::GetParticleType(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), G4ProcessManager::GetProcessList(), G4ParticleDefinition::GetProcessManager(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4hRDEnergyLoss::HighestKineticEnergy, InitializeParametrisation(), initialMass, G4hRDEnergyLoss::LowestKineticEnergy, eplot::material, G4INCL::Math::max(), MeV, minGammaEnergy, PrintInfoDefinition(), G4Proton::Proton(), G4InuclParticleNames::proton, source.hepunit::proton_mass_c2, G4hRDEnergyLoss::RecorderOfpbarProcess, G4hRDEnergyLoss::RecorderOfpProcess, G4EnergyLossTables::Register(), G4hRDEnergyLoss::theDEDXpTable, G4hRDEnergyLoss::theInverseRangepTable, theIonEffChargeModel, G4hRDEnergyLoss::theLabTimepTable, G4hRDEnergyLoss::theLossTable, theMeanFreePathTable, G4hRDEnergyLoss::theProperTimepTable, G4hRDEnergyLoss::theRangepTable, G4hRDEnergyLoss::TotBin, and G4VProcess::verboseLevel.

◆ BuildProperTimeVector()

void G4hRDEnergyLoss::BuildProperTimeVector	(	G4int	materialIndex,
		G4PhysicsLogVector *	rangeVector
	)

staticprivateinherited

Definition at line 576 of file G4hRDEnergyLoss.cc.

{
  //  create proper time vector for a material
 
  G4int nbin=100;
  G4bool isOut;
  G4double tlim=5.*keV,parlowen=0.4,ppar=0.5-parlowen ;
  //G4double losslim,clim,taulim,timelim,ltaulim,ltaumax,
  G4double losslim,clim,taulim,timelim,
    LowEdgeEnergy,tau,Value ;
 
  G4PhysicsVector* physicsVector= (*theDEDXTable)[materialIndex];
 
  // low energy part first...
  losslim = physicsVector->GetValue(tlim,isOut);
  taulim=tlim/ParticleMass ;
  clim=std::sqrt(ParticleMass*tlim/2.)/(c_light*losslim*ppar) ;
  //ltaulim = std::log(taulim);
  //ltaumax = std::log(HighestKineticEnergy/ParticleMass) ;
 
  G4int i=-1;
  G4double oldValue = 0. ;
  G4double tauold ;
  do
    {
      i += 1 ;
      LowEdgeEnergy = timeVector->GetLowEdgeEnergy(i);
      tau = LowEdgeEnergy/ParticleMass ;
      if ( tau <= taulim )
    {
      Value = clim*std::exp(ppar*std::log(tau/taulim)) ;
    }
      else
    {
      timelim=clim ;
      ltaulow = std::log(taulim);
      ltauhigh = std::log(tau);
      Value = timelim+ProperTimeIntLog(physicsVector,nbin);
    }
      timeVector->PutValue(i,Value);
      oldValue = Value ;
      tauold = tau ;
    } while (tau<=taulim) ;
 
  i += 1 ;
  for (G4int j=i; j<TotBin; j++)
    {
      LowEdgeEnergy = timeVector->GetLowEdgeEnergy(j);
      tau = LowEdgeEnergy/ParticleMass ;
      ltaulow = std::log(tauold);
      ltauhigh = std::log(tau);
      Value = oldValue+ProperTimeIntLog(physicsVector,nbin);
      timeVector->PutValue(j,Value);
      oldValue = Value ;
      tauold = tau ;
    }
}

References source.hepunit::c_light, G4PhysicsVector::GetLowEdgeEnergy(), G4PhysicsVector::GetValue(), keV, G4hRDEnergyLoss::ltauhigh, G4hRDEnergyLoss::ltaulow, G4hRDEnergyLoss::ParticleMass, G4hRDEnergyLoss::ProperTimeIntLog(), G4PhysicsVector::PutValue(), and G4hRDEnergyLoss::TotBin.

Referenced by G4hRDEnergyLoss::BuildTimeTables().

◆ BuildRangeCoeffATable()

void G4hRDEnergyLoss::BuildRangeCoeffATable ( const G4ParticleDefinition & aParticleType )

staticprivateinherited

Definition at line 771 of file G4hRDEnergyLoss.cc.

{
  // Build tables of coefficients for the energy loss calculation
  //  create table for coefficients "A"
 
  G4int numOfCouples = G4ProductionCutsTable::GetProductionCutsTable()->GetTableSize();
 
  if(Charge>0.)
    {
      if(thepRangeCoeffATable)
    { thepRangeCoeffATable->clearAndDestroy();
      delete thepRangeCoeffATable; }
      thepRangeCoeffATable = new G4PhysicsTable(numOfCouples);
      theRangeCoeffATable = thepRangeCoeffATable ;
      theRangeTable = theRangepTable ;
    }
  else
    {
      if(thepbarRangeCoeffATable)
    { thepbarRangeCoeffATable->clearAndDestroy();
      delete thepbarRangeCoeffATable; }
      thepbarRangeCoeffATable = new G4PhysicsTable(numOfCouples);
      theRangeCoeffATable = thepbarRangeCoeffATable ;
      theRangeTable = theRangepbarTable ;
    }
 
  G4double R2 = RTable*RTable ;
  G4double R1 = RTable+1.;
  G4double w = R1*(RTable-1.)*(RTable-1.);
  G4double w1 = RTable/w , w2 = -RTable*R1/w , w3 = R2/w ;
  G4double Ti , Tim , Tip , Ri , Rim , Rip , Value ;
  G4bool isOut;
 
  //  loop for materials
  for (G4int J=0; J<numOfCouples; J++)
    {
      G4int binmax=TotBin ;
      G4PhysicsLinearVector* aVector = 
    new G4PhysicsLinearVector(0.,binmax, TotBin);
      Ti = LowestKineticEnergy ;
      if (Ti < DBL_MIN) Ti = 1.e-8;
      G4PhysicsVector* rangeVector= (*theRangeTable)[J];
 
      for ( G4int i=0; i<TotBin; i++)
    {
      Ri = rangeVector->GetValue(Ti,isOut) ;
      if (Ti < DBL_MIN) Ti = 1.e-8;
      if ( i==0 )
        Rim = 0. ;
      else
        {
          // ---- MGP ---- Modified to avoid a floating point exception
          // The correction is just a temporary patch, the whole class should be redesigned 
          // Original: Tim = Ti/RTable  results in 0./0. 
          if (RTable != 0.)
        {
          Tim = Ti/RTable ;
        }
          else
        {
          Tim = 0.;
        }
          Rim = rangeVector->GetValue(Tim,isOut);
        }
      if ( i==(TotBin-1))
        Rip = Ri ;
      else
        {
          Tip = Ti*RTable ;
          Rip = rangeVector->GetValue(Tip,isOut);
        }
      Value = (w1*Rip + w2*Ri + w3*Rim)/(Ti*Ti) ; 
 
      aVector->PutValue(i,Value);
      Ti = RTable*Ti ;
    }
  
      theRangeCoeffATable->insert(aVector);
    } 
}

References G4hRDEnergyLoss::Charge, G4PhysicsTable::clearAndDestroy(), DBL_MIN, G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4PhysicsVector::GetValue(), G4PhysicsTable::insert(), G4hRDEnergyLoss::LowestKineticEnergy, G4PhysicsVector::PutValue(), G4hRDEnergyLoss::RTable, G4hRDEnergyLoss::thepbarRangeCoeffATable, G4hRDEnergyLoss::thepRangeCoeffATable, G4hRDEnergyLoss::theRangeCoeffATable, G4hRDEnergyLoss::theRangepbarTable, G4hRDEnergyLoss::theRangepTable, G4hRDEnergyLoss::theRangeTable, and G4hRDEnergyLoss::TotBin.

Referenced by G4hRDEnergyLoss::BuildDEDXTable().

◆ BuildRangeCoeffBTable()

void G4hRDEnergyLoss::BuildRangeCoeffBTable ( const G4ParticleDefinition & aParticleType )

staticprivateinherited

Definition at line 854 of file G4hRDEnergyLoss.cc.

{
  // Build tables of coefficients for the energy loss calculation
  //  create table for coefficients "B"
 
  G4int numOfCouples =
        G4ProductionCutsTable::GetProductionCutsTable()->GetTableSize();
 
  if(Charge>0.)
    {
      if(thepRangeCoeffBTable)
    { thepRangeCoeffBTable->clearAndDestroy();
      delete thepRangeCoeffBTable; }
      thepRangeCoeffBTable = new G4PhysicsTable(numOfCouples);
      theRangeCoeffBTable = thepRangeCoeffBTable ;
      theRangeTable = theRangepTable ;
    }
  else
    {
      if(thepbarRangeCoeffBTable)
    { thepbarRangeCoeffBTable->clearAndDestroy();
      delete thepbarRangeCoeffBTable; }
      thepbarRangeCoeffBTable = new G4PhysicsTable(numOfCouples);
      theRangeCoeffBTable = thepbarRangeCoeffBTable ;
      theRangeTable = theRangepbarTable ;
    }
 
  G4double R2 = RTable*RTable ;
  G4double R1 = RTable+1.;
  G4double w = R1*(RTable-1.)*(RTable-1.);
  if (w < DBL_MIN) w = DBL_MIN;
  G4double w1 = -R1/w , w2 = R1*(R2+1.)/w , w3 = -R2*R1/w ;
  G4double Ti , Tim , Tip , Ri , Rim , Rip , Value ;
  G4bool isOut;
 
  //  loop for materials
  for (G4int J=0; J<numOfCouples; J++)
    {
      G4int binmax=TotBin ;
      G4PhysicsLinearVector* aVector =
    new G4PhysicsLinearVector(0.,binmax, TotBin);
      Ti = LowestKineticEnergy ;
      if (Ti < DBL_MIN) Ti = 1.e-8;
      G4PhysicsVector* rangeVector= (*theRangeTable)[J];
   
      for ( G4int i=0; i<TotBin; i++)
    {
      Ri = rangeVector->GetValue(Ti,isOut) ;
      if (Ti < DBL_MIN) Ti = 1.e-8;
      if ( i==0 )
        Rim = 0. ;
      else
        {
          if (RTable < DBL_MIN) RTable = DBL_MIN;
          Tim = Ti/RTable ;
          Rim = rangeVector->GetValue(Tim,isOut);
        }
      if ( i==(TotBin-1))
        Rip = Ri ;
      else
        {
          Tip = Ti*RTable ;
          Rip = rangeVector->GetValue(Tip,isOut);
        }
      if (Ti < DBL_MIN) Ti = DBL_MIN;
      Value = (w1*Rip + w2*Ri + w3*Rim)/Ti;
 
      aVector->PutValue(i,Value);
      Ti = RTable*Ti ;
    }
      theRangeCoeffBTable->insert(aVector);
    } 
}

References G4hRDEnergyLoss::Charge, G4PhysicsTable::clearAndDestroy(), DBL_MIN, G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4PhysicsVector::GetValue(), G4PhysicsTable::insert(), G4hRDEnergyLoss::LowestKineticEnergy, G4PhysicsVector::PutValue(), G4hRDEnergyLoss::RTable, G4hRDEnergyLoss::thepbarRangeCoeffBTable, G4hRDEnergyLoss::thepRangeCoeffBTable, G4hRDEnergyLoss::theRangeCoeffBTable, G4hRDEnergyLoss::theRangepbarTable, G4hRDEnergyLoss::theRangepTable, G4hRDEnergyLoss::theRangeTable, and G4hRDEnergyLoss::TotBin.

Referenced by G4hRDEnergyLoss::BuildDEDXTable().

◆ BuildRangeCoeffCTable()

void G4hRDEnergyLoss::BuildRangeCoeffCTable ( const G4ParticleDefinition & aParticleType )

staticprivateinherited

Definition at line 930 of file G4hRDEnergyLoss.cc.

{
  // Build tables of coefficients for the energy loss calculation
  //  create table for coefficients "C"
 
  G4int numOfCouples =
        G4ProductionCutsTable::GetProductionCutsTable()->GetTableSize();
 
  if(Charge>0.)
    {
      if(thepRangeCoeffCTable)
    { thepRangeCoeffCTable->clearAndDestroy();
      delete thepRangeCoeffCTable; }
      thepRangeCoeffCTable = new G4PhysicsTable(numOfCouples);
      theRangeCoeffCTable = thepRangeCoeffCTable ;
      theRangeTable = theRangepTable ;
    }
  else
    {
      if(thepbarRangeCoeffCTable)
    { thepbarRangeCoeffCTable->clearAndDestroy();
      delete thepbarRangeCoeffCTable; }
      thepbarRangeCoeffCTable = new G4PhysicsTable(numOfCouples);
      theRangeCoeffCTable = thepbarRangeCoeffCTable ;
      theRangeTable = theRangepbarTable ;
    }
  
  G4double R2 = RTable*RTable ;
  G4double R1 = RTable+1.;
  G4double w = R1*(RTable-1.)*(RTable-1.);
  G4double w1 = 1./w , w2 = -RTable*R1/w , w3 = RTable*R2/w ;
  G4double Ti , Tim , Tip , Ri , Rim , Rip , Value ;
  G4bool isOut;
 
  //  loop for materials
  for (G4int J=0; J<numOfCouples; J++)
    {
      G4int binmax=TotBin ;
      G4PhysicsLinearVector* aVector =
    new G4PhysicsLinearVector(0.,binmax, TotBin);
      Ti = LowestKineticEnergy ;
      G4PhysicsVector* rangeVector= (*theRangeTable)[J];
   
      for ( G4int i=0; i<TotBin; i++)
    {
      Ri = rangeVector->GetValue(Ti,isOut) ;
      if ( i==0 )
        Rim = 0. ;
      else
        {
          Tim = Ti/RTable ;
          Rim = rangeVector->GetValue(Tim,isOut);
        }
      if ( i==(TotBin-1))
        Rip = Ri ;
      else
        {
          Tip = Ti*RTable ;
          Rip = rangeVector->GetValue(Tip,isOut);
        }
      Value = w1*Rip + w2*Ri + w3*Rim ;
 
      aVector->PutValue(i,Value);
      Ti = RTable*Ti ;
    }
      theRangeCoeffCTable->insert(aVector);
    } 
}

References G4hRDEnergyLoss::Charge, G4PhysicsTable::clearAndDestroy(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4PhysicsVector::GetValue(), G4PhysicsTable::insert(), G4hRDEnergyLoss::LowestKineticEnergy, G4PhysicsVector::PutValue(), G4hRDEnergyLoss::RTable, G4hRDEnergyLoss::thepbarRangeCoeffCTable, G4hRDEnergyLoss::thepRangeCoeffCTable, G4hRDEnergyLoss::theRangeCoeffCTable, G4hRDEnergyLoss::theRangepbarTable, G4hRDEnergyLoss::theRangepTable, G4hRDEnergyLoss::theRangeTable, and G4hRDEnergyLoss::TotBin.

Referenced by G4hRDEnergyLoss::BuildDEDXTable().

◆ BuildRangeTable()

void G4hRDEnergyLoss::BuildRangeTable ( const G4ParticleDefinition & aParticleType )

staticprivateinherited

Definition at line 382 of file G4hRDEnergyLoss.cc.

{
  // Build range table from the energy loss table
 
  Mass = aParticleType.GetPDGMass();
 
  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();
 
  if( Charge >0.)
    {
      if(theRangepTable)
    { theRangepTable->clearAndDestroy();
      delete theRangepTable; }
      theRangepTable = new G4PhysicsTable(numOfCouples);
      theRangeTable = theRangepTable ;
    }
  else
    {
      if(theRangepbarTable)
    { theRangepbarTable->clearAndDestroy();
      delete theRangepbarTable; }
      theRangepbarTable = new G4PhysicsTable(numOfCouples);
      theRangeTable = theRangepbarTable ;
    }
 
  // loop for materials
 
  for (size_t J=0;  J<numOfCouples; J++)
    {
      G4PhysicsLogVector* aVector;
      aVector = new G4PhysicsLogVector(LowestKineticEnergy,
                       HighestKineticEnergy,TotBin);
 
      BuildRangeVector(J, aVector);
      theRangeTable->insert(aVector);
    }
}

References G4hRDEnergyLoss::BuildRangeVector(), G4hRDEnergyLoss::Charge, G4PhysicsTable::clearAndDestroy(), G4ParticleDefinition::GetPDGMass(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4hRDEnergyLoss::HighestKineticEnergy, G4PhysicsTable::insert(), G4hRDEnergyLoss::LowestKineticEnergy, G4hRDEnergyLoss::Mass, G4hRDEnergyLoss::theRangepbarTable, G4hRDEnergyLoss::theRangepTable, G4hRDEnergyLoss::theRangeTable, and G4hRDEnergyLoss::TotBin.

Referenced by G4hRDEnergyLoss::BuildDEDXTable().

◆ BuildRangeVector()

void G4hRDEnergyLoss::BuildRangeVector	(	G4int	materialIndex,
		G4PhysicsLogVector *	rangeVector
	)

staticprivateinherited

Definition at line 481 of file G4hRDEnergyLoss.cc.

{
  //  create range vector for a material
 
  G4bool isOut;
  G4PhysicsVector* physicsVector= (*theDEDXTable)[materialIndex];
  G4double energy1 = rangeVector->GetLowEdgeEnergy(0);
  G4double dedx    = physicsVector->GetValue(energy1,isOut);
  G4double range   = 0.5*energy1/dedx;
  rangeVector->PutValue(0,range);
  G4int n = 100;
  G4double del = 1.0/(G4double)n ;
 
  for (G4int j=1; j<TotBin; j++) {
 
    G4double energy2 = rangeVector->GetLowEdgeEnergy(j);
    G4double de = (energy2 - energy1) * del ;
    G4double dedx1 = dedx ;
 
    for (G4int i=1; i<n; i++) {
      G4double energy = energy1 + i*de ;
      G4double dedx2  = physicsVector->GetValue(energy,isOut);
      range  += 0.5*de*(1.0/dedx1 + 1.0/dedx2);
      dedx1   = dedx2;
    }
    rangeVector->PutValue(j,range);
    dedx = dedx1 ;
    energy1 = energy2 ;
  }
}    

References G4INCL::KinematicsUtils::energy(), G4PhysicsVector::GetLowEdgeEnergy(), G4PhysicsVector::GetValue(), CLHEP::detail::n, G4PhysicsVector::PutValue(), and G4hRDEnergyLoss::TotBin.

Referenced by G4hRDEnergyLoss::BuildRangeTable().

◆ BuildTimeTables()

void G4hRDEnergyLoss::BuildTimeTables ( const G4ParticleDefinition & aParticleType )

staticprivateinherited

Definition at line 424 of file G4hRDEnergyLoss.cc.

{
  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();
 
  if(&aParticleType == G4Proton::Proton())
    {
      if(theLabTimepTable)
    { theLabTimepTable->clearAndDestroy();
      delete theLabTimepTable; }
      theLabTimepTable = new G4PhysicsTable(numOfCouples);
      theLabTimeTable = theLabTimepTable ;
 
      if(theProperTimepTable)
    { theProperTimepTable->clearAndDestroy();
      delete theProperTimepTable; }
      theProperTimepTable = new G4PhysicsTable(numOfCouples);
      theProperTimeTable = theProperTimepTable ;
    }
 
  if(&aParticleType == G4AntiProton::AntiProton())
    {
      if(theLabTimepbarTable)
    { theLabTimepbarTable->clearAndDestroy();
      delete theLabTimepbarTable; }
      theLabTimepbarTable = new G4PhysicsTable(numOfCouples);
      theLabTimeTable = theLabTimepbarTable ;
 
      if(theProperTimepbarTable)
    { theProperTimepbarTable->clearAndDestroy();
      delete theProperTimepbarTable; }
      theProperTimepbarTable = new G4PhysicsTable(numOfCouples);
      theProperTimeTable = theProperTimepbarTable ;
    }
 
  for (size_t J=0;  J<numOfCouples; J++)
    {
      G4PhysicsLogVector* aVector;
      G4PhysicsLogVector* bVector;
 
      aVector = new G4PhysicsLogVector(LowestKineticEnergy,
                       HighestKineticEnergy,TotBin);
 
      BuildLabTimeVector(J, aVector);
      theLabTimeTable->insert(aVector);
 
      bVector = new G4PhysicsLogVector(LowestKineticEnergy,
                       HighestKineticEnergy,TotBin);
 
      BuildProperTimeVector(J, bVector);
      theProperTimeTable->insert(bVector);
    }
}

References G4AntiProton::AntiProton(), G4hRDEnergyLoss::BuildLabTimeVector(), G4hRDEnergyLoss::BuildProperTimeVector(), G4PhysicsTable::clearAndDestroy(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4hRDEnergyLoss::HighestKineticEnergy, G4PhysicsTable::insert(), G4hRDEnergyLoss::LowestKineticEnergy, G4Proton::Proton(), G4hRDEnergyLoss::theLabTimepbarTable, G4hRDEnergyLoss::theLabTimepTable, G4hRDEnergyLoss::theLabTimeTable, G4hRDEnergyLoss::theProperTimepbarTable, G4hRDEnergyLoss::theProperTimepTable, G4hRDEnergyLoss::theProperTimeTable, and G4hRDEnergyLoss::TotBin.

Referenced by G4hRDEnergyLoss::BuildDEDXTable().

◆ BuildWorkerPhysicsTable()

void G4VProcess::BuildWorkerPhysicsTable ( const G4ParticleDefinition & part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 200 of file G4VProcess.cc.

{
  BuildPhysicsTable(part);
}

References G4VProcess::BuildPhysicsTable().

Referenced by G4BiasingProcessInterface::BuildWorkerPhysicsTable().

◆ ClearNumberOfInteractionLengthLeft()

void G4VProcess::ClearNumberOfInteractionLengthLeft ( )

inlineprotectedinherited

Definition at line 424 of file G4VProcess.hh.

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

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

◆ ComputeDEDX()

G4double G4hImpactIonisation::ComputeDEDX	(	const G4ParticleDefinition *	aParticle,
		const G4MaterialCutsCouple *	couple,
		G4double	kineticEnergy
	)

Definition at line 1265 of file G4hImpactIonisation.cc.

{
  const G4Material* material = couple->GetMaterial();
  G4Proton* proton = G4Proton::Proton();
  G4AntiProton* antiproton = G4AntiProton::AntiProton();
  G4double dedx = 0.;
 
  G4double tScaled = kineticEnergy * proton_mass_c2 / (aParticle->GetPDGMass()) ;
  charge  = aParticle->GetPDGCharge() ;
 
  if( charge > 0.) 
    {
      if (tScaled > protonHighEnergy) 
    {
      dedx = G4EnergyLossTables::GetDEDX(proton,tScaled,couple) ;  
    }
      else 
    {
      dedx = ProtonParametrisedDEDX(couple,tScaled) ;
    }
    } 
  else 
    {
      if (tScaled > antiprotonHighEnergy) 
    {
      dedx = G4EnergyLossTables::GetDEDX(antiproton,tScaled,couple);
    } 
      else
    {
      dedx = AntiProtonParametrisedDEDX(couple,tScaled) ;
    }
    }
  dedx *= theIonEffChargeModel->TheValue(aParticle, material, kineticEnergy) ;
  
  return dedx ;
}

References G4AntiProton::AntiProton(), antiprotonHighEnergy, AntiProtonParametrisedDEDX(), charge, G4EnergyLossTables::GetDEDX(), G4MaterialCutsCouple::GetMaterial(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), eplot::material, G4Proton::Proton(), G4InuclParticleNames::proton, source.hepunit::proton_mass_c2, protonHighEnergy, ProtonParametrisedDEDX(), theIonEffChargeModel, and G4VLowEnergyModel::TheValue().

◆ CutsWhereModified()

G4bool G4hRDEnergyLoss::CutsWhereModified ( )

protectedinherited

Definition at line 1154 of file G4hRDEnergyLoss.cc.

{
  G4bool wasModified = false;
  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();
 
  for (size_t j=0; j<numOfCouples; j++){
    if (theCoupleTable->GetMaterialCutsCouple(j)->IsRecalcNeeded()) {
      wasModified = true;
      break;
    }
  }
  return wasModified;
}

References G4ProductionCutsTable::GetMaterialCutsCouple(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), and G4MaterialCutsCouple::IsRecalcNeeded().

Referenced by BuildPhysicsTable().

◆ DeltaRaysEnergy()

G4double G4hImpactIonisation::DeltaRaysEnergy	(	const G4MaterialCutsCouple *	couple,
		G4double	kineticEnergy,
		G4double	particleMass
	)		const

private

Definition at line 916 of file G4hImpactIonisation.cc.

{
  G4double dLoss = 0.;
 
  G4double deltaCutNow = cutForDelta[(couple->GetIndex())] ;
  const G4Material* material = couple->GetMaterial();
  G4double electronDensity = material->GetElectronDensity();
  G4double excitationEnergy = material->GetIonisation()->GetMeanExcitationEnergy();
 
  G4double tau = kineticEnergy / particleMass ;
  G4double rateMass = electron_mass_c2/particleMass ;
 
  // some local variables
 
  G4double gamma = tau + 1.0 ;
  G4double bg2 = tau*(tau+2.0) ;
  G4double beta2 = bg2/(gamma*gamma) ;
  G4double tMax = 2.*electron_mass_c2*bg2/(1.0+2.0*gamma*rateMass+rateMass*rateMass) ;
 
  // Validity range for delta electron cross section
  G4double deltaCut = std::max(deltaCutNow, excitationEnergy);
 
  if ( deltaCut < tMax) 
    {
      G4double x = deltaCut / tMax ;
      dLoss = ( beta2 * (x-1.) - std::log(x) ) * twopi_mc2_rcl2 * electronDensity / beta2 ;
    }
  return dLoss ;
}

References cutForDelta, source.hepunit::electron_mass_c2, G4MaterialCutsCouple::GetIndex(), G4MaterialCutsCouple::GetMaterial(), eplot::material, G4INCL::Math::max(), and source.hepunit::twopi_mc2_rcl2.

Referenced by AntiProtonParametrisedDEDX(), BuildLossTable(), and ProtonParametrisedDEDX().

◆ DumpInfo()

void G4VProcess::DumpInfo ( ) const

virtualinherited

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

Definition at line 167 of file G4VProcess.cc.

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

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

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

◆ ElectronicLossFluctuation()

G4double G4hImpactIonisation::ElectronicLossFluctuation	(	const G4DynamicParticle *	particle,
		const G4MaterialCutsCouple *	material,
		G4double	meanLoss,
		G4double	step
	)		const

private

Definition at line 1452 of file G4hImpactIonisation.cc.

{
  // data members to speed up the fluctuation calculation
  //  G4int imat ;
  //  G4double f1Fluct,f2Fluct,e1Fluct,e2Fluct,rateFluct,ipotFluct;
  //  G4double e1LogFluct,e2LogFluct,ipotLogFluct;
 
  static const G4double minLoss = 1.*eV ;
  static const G4double kappa = 10. ;
  static const G4double theBohrBeta2 = 50.0 * keV/proton_mass_c2 ;
 
  const G4Material* material = couple->GetMaterial();
  G4int    imaterial   = couple->GetIndex() ;
  G4double ipotFluct   = material->GetIonisation()->GetMeanExcitationEnergy() ;
  G4double electronDensity = material->GetElectronDensity() ;
  G4double zeff = electronDensity/(material->GetTotNbOfAtomsPerVolume()) ;
 
  // get particle data
  G4double tkin   = particle->GetKineticEnergy();
  G4double particleMass = particle->GetMass() ;
  G4double deltaCutInKineticEnergyNow = cutForDelta[imaterial];
 
  // shortcut for very very small loss
  if(meanLoss < minLoss) return meanLoss ;
 
  // Validity range for delta electron cross section
  G4double threshold = std::max(deltaCutInKineticEnergyNow,ipotFluct);
  G4double loss, siga;
 
  G4double rmass = electron_mass_c2/particleMass;
  G4double tau   = tkin/particleMass;
  G4double tau1 = tau+1.0;
  G4double tau2 = tau*(tau+2.);
  G4double tMax    = 2.*electron_mass_c2*tau2/(1.+2.*tau1*rmass+rmass*rmass);
 
 
  if(tMax > threshold) tMax = threshold;
  G4double beta2 = tau2/(tau1*tau1);
 
  // Gaussian fluctuation
  if(meanLoss > kappa*tMax || tMax < kappa*ipotFluct )
    {
      siga = tMax * (1.0-0.5*beta2) * step * twopi_mc2_rcl2
    * electronDensity / beta2 ;
 
      // High velocity or negatively charged particle
      if( beta2 > 3.0*theBohrBeta2*zeff || charge < 0.0) {
    siga = std::sqrt( siga * chargeSquare ) ;
 
    // Low velocity - additional ion charge fluctuations according to
    // Q.Yang et al., NIM B61(1991)149-155.
      } else {
    G4double chu = theIonChuFluctuationModel->TheValue(particle, material);
    G4double yang = theIonYangFluctuationModel->TheValue(particle, material);
    siga = std::sqrt( siga * (chargeSquare * chu + yang)) ;
      }
 
      do {
        loss = G4RandGauss::shoot(meanLoss,siga);
      } while (loss < 0. || loss > 2.0*meanLoss);
      return loss;
    }
 
  // Non Gaussian fluctuation
  static const G4double probLim = 0.01 ;
  static const G4double sumaLim = -std::log(probLim) ;
  static const G4double alim = 10.;
 
  G4double suma,w1,w2,C,e0,lossc,w;
  G4double a1,a2,a3;
  G4int p1,p2,p3;
  G4int nb;
  G4double corrfac, na,alfa,rfac,namean,sa,alfa1,ea,sea;
  G4double dp3;
 
  G4double f1Fluct     = material->GetIonisation()->GetF1fluct();
  G4double f2Fluct     = material->GetIonisation()->GetF2fluct();
  G4double e1Fluct     = material->GetIonisation()->GetEnergy1fluct();
  G4double e2Fluct     = material->GetIonisation()->GetEnergy2fluct();
  G4double e1LogFluct  = material->GetIonisation()->GetLogEnergy1fluct();
  G4double e2LogFluct  = material->GetIonisation()->GetLogEnergy2fluct();
  G4double rateFluct   = material->GetIonisation()->GetRateionexcfluct();
  G4double ipotLogFluct= material->GetIonisation()->GetLogMeanExcEnergy();
 
  w1 = tMax/ipotFluct;
  w2 = std::log(2.*electron_mass_c2*tau2);
 
  C = meanLoss*(1.-rateFluct)/(w2-ipotLogFluct-beta2);
 
  a1 = C*f1Fluct*(w2-e1LogFluct-beta2)/e1Fluct;
  a2 = C*f2Fluct*(w2-e2LogFluct-beta2)/e2Fluct;
  a3 = rateFluct*meanLoss*(tMax-ipotFluct)/(ipotFluct*tMax*std::log(w1));
  if(a1 < 0.0) a1 = 0.0;
  if(a2 < 0.0) a2 = 0.0;
  if(a3 < 0.0) a3 = 0.0;
 
  suma = a1+a2+a3;
 
  loss = 0.;
 
 
  if(suma < sumaLim)             // very small Step
    {
      e0 = material->GetIonisation()->GetEnergy0fluct();
 
      if(tMax == ipotFluct)
    {
      a3 = meanLoss/e0;
 
      if(a3>alim)
        {
          siga=std::sqrt(a3) ;
          p3 = std::max(0,G4int(G4RandGauss::shoot(a3,siga)+0.5));
        }
      else
        p3 = G4Poisson(a3);
 
      loss = p3*e0 ;
 
      if(p3 > 0)
        loss += (1.-2.*G4UniformRand())*e0 ;
 
    }
      else
    {
      tMax = tMax-ipotFluct+e0 ;
      a3 = meanLoss*(tMax-e0)/(tMax*e0*std::log(tMax/e0));
 
      if(a3>alim)
        {
          siga=std::sqrt(a3) ;
          p3 = std::max(0,int(G4RandGauss::shoot(a3,siga)+0.5));
        }
      else
        p3 = G4Poisson(a3);
 
      if(p3 > 0)
        {
          w = (tMax-e0)/tMax ;
          if(p3 > nmaxCont2)
        {
          dp3 = G4float(p3) ;
          corrfac = dp3/G4float(nmaxCont2) ;
          p3 = nmaxCont2 ;
        }
          else
        corrfac = 1. ;
 
          for(G4int i=0; i<p3; i++) loss += 1./(1.-w*G4UniformRand()) ;
          loss *= e0*corrfac ;
        }
    }
    }
 
  else                              // not so small Step
    {
      // excitation type 1
      if(a1>alim)
    {
      siga=std::sqrt(a1) ;
      p1 = std::max(0,G4int(G4RandGauss::shoot(a1,siga)+0.5));
    }
      else
    p1 = G4Poisson(a1);
 
      // excitation type 2
      if(a2>alim)
    {
      siga=std::sqrt(a2) ;
      p2 = std::max(0,G4int(G4RandGauss::shoot(a2,siga)+0.5));
    }
      else
        p2 = G4Poisson(a2);
 
      loss = p1*e1Fluct+p2*e2Fluct;
 
      // smearing to avoid unphysical peaks
      if(p2 > 0)
        loss += (1.-2.*G4UniformRand())*e2Fluct;
      else if (loss>0.)
        loss += (1.-2.*G4UniformRand())*e1Fluct;
 
      // ionisation .......................................
      if(a3 > 0.)
    {
      if(a3>alim)
        {
          siga=std::sqrt(a3) ;
          p3 = std::max(0,G4int(G4RandGauss::shoot(a3,siga)+0.5));
        }
      else
        p3 = G4Poisson(a3);
 
      lossc = 0.;
      if(p3 > 0)
        {
          na = 0.;
          alfa = 1.;
          if (p3 > nmaxCont2)
        {
          dp3        = G4float(p3);
          rfac       = dp3/(G4float(nmaxCont2)+dp3);
          namean     = G4float(p3)*rfac;
          sa         = G4float(nmaxCont1)*rfac;
          na         = G4RandGauss::shoot(namean,sa);
          if (na > 0.)
            {
              alfa   = w1*G4float(nmaxCont2+p3)/
            (w1*G4float(nmaxCont2)+G4float(p3));
              alfa1  = alfa*std::log(alfa)/(alfa-1.);
              ea     = na*ipotFluct*alfa1;
              sea    = ipotFluct*std::sqrt(na*(alfa-alfa1*alfa1));
              lossc += G4RandGauss::shoot(ea,sea);
            }
        }
 
          nb = G4int(G4float(p3)-na);
          if (nb > 0)
        {
          w2 = alfa*ipotFluct;
          w  = (tMax-w2)/tMax;
          for (G4int k=0; k<nb; k++) lossc += w2/(1.-w*G4UniformRand());
        }
        }
      loss += lossc;
    }
    }
 
  return loss ;
}

References C(), source.hepunit::electron_mass_c2, eV, G4Poisson(), G4UniformRand, keV, eplot::material, G4INCL::Math::max(), source.hepunit::proton_mass_c2, G4INCL::DeJongSpin::shoot(), and source.hepunit::twopi_mc2_rcl2.

Referenced by AlongStepDoIt().

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

◆ GetConstraints()

G4double G4hImpactIonisation::GetConstraints	(	const G4DynamicParticle *	particle,
		const G4MaterialCutsCouple *	couple
	)

private

Definition at line 622 of file G4hImpactIonisation.cc.

{
  // returns the Step limit
  // dEdx is calculated as well as the range
  // based on Effective Charge Approach
 
  const G4Material* material = couple->GetMaterial();
  G4Proton* proton = G4Proton::Proton();
  G4AntiProton* antiproton = G4AntiProton::AntiProton();
 
  G4double stepLimit = 0.;
  G4double dx, highEnergy;
 
  G4double massRatio = proton_mass_c2/(particle->GetMass()) ;
  G4double kineticEnergy = particle->GetKineticEnergy() ;
 
  // Scale the kinetic energy
 
  G4double tScaled = kineticEnergy*massRatio ;
  fBarkas = 0.;
 
  if (charge > 0.) 
    {
      highEnergy = protonHighEnergy ;
      fRangeNow = G4EnergyLossTables::GetRange(proton, tScaled, couple);
      dx = G4EnergyLossTables::GetRange(proton, highEnergy, couple);
      fdEdx = G4EnergyLossTables::GetDEDX(proton, tScaled, couple)
    * chargeSquare ;
      
      // Correction for positive ions
      if (theBarkas && tScaled > highEnergy) 
    { 
      fBarkas = BarkasTerm(material,tScaled)*std::sqrt(chargeSquare)*chargeSquare
        + BlochTerm(material,tScaled,chargeSquare);
    }
      // Antiprotons and negative hadrons
    } 
  else 
    {
      highEnergy = antiprotonHighEnergy ;
      fRangeNow = G4EnergyLossTables::GetRange(antiproton, tScaled, couple);
      dx = G4EnergyLossTables::GetRange(antiproton, highEnergy, couple);
      fdEdx = G4EnergyLossTables::GetDEDX(antiproton, tScaled, couple) * chargeSquare ;
      
      if (theBarkas && tScaled > highEnergy) 
    { 
      fBarkas = -BarkasTerm(material,tScaled)*std::sqrt(chargeSquare)*chargeSquare
        + BlochTerm(material,tScaled,chargeSquare);
    } 
    } 
  /*
    const G4Material* mat = couple->GetMaterial();
    G4double fac = gram/(MeV*cm2*mat->GetDensity());
    G4cout << particle->GetDefinition()->GetParticleName()
    << " in " << mat->GetName()
    << " E(MeV)= " << kineticEnergy/MeV
    << " dedx(MeV*cm^2/g)= " << fdEdx*fac
    << " barcas(MeV*cm^2/gram)= " << fBarkas*fac
    << " Q^2= " << chargeSquare
    << G4endl;
  */
  // scaling back
  fRangeNow /= (chargeSquare*massRatio) ;
  dx        /= (chargeSquare*massRatio) ;
 
  stepLimit  = fRangeNow ;
  G4double r = std::min(finalRange, couple->GetProductionCuts()
            ->GetProductionCut(idxG4ElectronCut));
 
  if (fRangeNow > r) 
    {  
      stepLimit = dRoverRange*fRangeNow + r*(1.0 - dRoverRange)*(2.0 - r/fRangeNow);
      if (stepLimit > fRangeNow) stepLimit = fRangeNow;
    }  
  //   compute the (random) Step limit in standard energy range
  if(tScaled > highEnergy ) 
    {    
      // add Barkas correction directly to dedx
      fdEdx  += fBarkas;
      
      if(stepLimit > fRangeNow - dx*0.9) stepLimit = fRangeNow - dx*0.9 ;
      
      // Step limit in low energy range
    } 
  else 
    {
      G4double x = dx*paramStepLimit;
      if (stepLimit > x) stepLimit = x;
    }
  return stepLimit;
}

References G4AntiProton::AntiProton(), antiprotonHighEnergy, BarkasTerm(), BlochTerm(), charge, chargeSquare, G4hRDEnergyLoss::dRoverRange, fBarkas, fdEdx, G4hRDEnergyLoss::finalRange, fRangeNow, G4EnergyLossTables::GetDEDX(), G4DynamicParticle::GetKineticEnergy(), G4DynamicParticle::GetMass(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCuts::GetProductionCut(), G4MaterialCutsCouple::GetProductionCuts(), G4EnergyLossTables::GetRange(), idxG4ElectronCut, eplot::material, G4INCL::Math::min(), paramStepLimit, G4Proton::Proton(), G4InuclParticleNames::proton, source.hepunit::proton_mass_c2, protonHighEnergy, and theBarkas.

Referenced by GetContinuousStepLimit().

◆ GetContinuousStepLimit()

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

inlinevirtual

Implements G4VContinuousDiscreteProcess.

Definition at line 293 of file G4hImpactIonisation.hh.

{
  G4double step = GetConstraints(track.GetDynamicParticle(),track.GetMaterialCutsCouple()) ;
 
  // ---- MGP ---- The following line, taken as is from G4hLowEnergyIonisation,
  // is meaningless: currentMinimumStep is passed by value,
  // therefore any local modification to it has no effect
 
  if ((step > 0.) && (step < currentMinimumStep)) currentMinimumStep = step ;
 
  return step ;
}

References GetConstraints(), G4Track::GetDynamicParticle(), and G4Track::GetMaterialCutsCouple().

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

◆ GetGPILSelection()

G4GPILSelection G4VContinuousDiscreteProcess::GetGPILSelection ( ) const

inlineprotectedinherited

Definition at line 109 of file G4VContinuousDiscreteProcess.hh.

110 { return valueGPILSelection; }

References G4VContinuousDiscreteProcess::valueGPILSelection.

◆ GetMasterProcess()

const G4VProcess * G4VProcess::GetMasterProcess ( ) const

inlineinherited

Definition at line 518 of file G4VProcess.hh.

{
  return masterProcessShadow;
}

References G4VProcess::masterProcessShadow.

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

◆ GetMeanFreePath()

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

virtual

Implements G4hRDEnergyLoss.

Definition at line 588 of file G4hImpactIonisation.cc.

{
  const G4DynamicParticle* dynamicParticle = track.GetDynamicParticle();
  const G4MaterialCutsCouple* couple = track.GetMaterialCutsCouple();
  const G4Material* material = couple->GetMaterial();
 
  G4double meanFreePath = DBL_MAX;
  // ---- MGP ---- What is the meaning of the local variable isOutOfRange?
  G4bool isOutRange = false;
 
  *condition = NotForced ;
 
  G4double kineticEnergy = (dynamicParticle->GetKineticEnergy())*initialMass/(dynamicParticle->GetMass());
  charge = dynamicParticle->GetCharge()/eplus;
  chargeSquare = theIonEffChargeModel->TheValue(dynamicParticle, material);
 
  if (kineticEnergy < LowestKineticEnergy) 
    {
      meanFreePath = DBL_MAX;
    }
  else 
    {
      if (kineticEnergy > HighestKineticEnergy)  kineticEnergy = HighestKineticEnergy;
      meanFreePath = (((*theMeanFreePathTable)(couple->GetIndex()))->
              GetValue(kineticEnergy,isOutRange))/chargeSquare;
    }
 
  return meanFreePath ;
}

References charge, chargeSquare, condition(), DBL_MAX, eplus, G4DynamicParticle::GetCharge(), G4Track::GetDynamicParticle(), G4MaterialCutsCouple::GetIndex(), G4DynamicParticle::GetKineticEnergy(), G4DynamicParticle::GetMass(), G4MaterialCutsCouple::GetMaterial(), G4Track::GetMaterialCutsCouple(), G4hRDEnergyLoss::HighestKineticEnergy, initialMass, G4hRDEnergyLoss::LowestKineticEnergy, eplot::material, NotForced, theIonEffChargeModel, and G4VLowEnergyModel::TheValue().

◆ GetNumberOfInteractionLengthLeft()

G4double G4VProcess::GetNumberOfInteractionLengthLeft ( ) const

inlineinherited

Definition at line 431 of file G4VProcess.hh.

{
  return theNumberOfInteractionLengthLeft;
}

References G4VProcess::theNumberOfInteractionLengthLeft.

◆ GetNumberOfProcesses()

G4int G4hRDEnergyLoss::GetNumberOfProcesses ( )

staticinherited

Definition at line 190 of file G4hRDEnergyLoss.cc.

{
  return NumberOfProcesses; 
} 

References G4hRDEnergyLoss::NumberOfProcesses.

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

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

◆ InitializeMe()

void G4hImpactIonisation::InitializeMe ( )

private

Definition at line 105 of file G4hImpactIonisation.cc.

{
  LowestKineticEnergy  = 10.0*eV ;
  HighestKineticEnergy = 100.0*GeV ;
  MinKineticEnergy     = 10.0*eV ; 
  TotBin               = 360 ;
  protonLowEnergy      = 1.*keV ;
  protonHighEnergy     = 100.*MeV ;
  antiprotonLowEnergy  = 25.*keV ;
  antiprotonHighEnergy = 2.*MeV ;
  minGammaEnergy       = 100 * eV;
  minElectronEnergy    = 250.* eV;
  verboseLevel         = 0;
 
  // Min and max energy of incident particle for the calculation of shell cross sections
  // for PIXE generation
  eMinPixe = 1.* keV;
  eMaxPixe = 200. * MeV;
  
  G4String defaultPixeModel("ecpssr"); 
  modelK = defaultPixeModel;
  modelL = defaultPixeModel;
  modelM = defaultPixeModel;
}

References antiprotonHighEnergy, antiprotonLowEnergy, eMaxPixe, eMinPixe, eV, GeV, G4hRDEnergyLoss::HighestKineticEnergy, keV, G4hRDEnergyLoss::LowestKineticEnergy, MeV, minElectronEnergy, minGammaEnergy, G4hRDEnergyLoss::MinKineticEnergy, modelK, modelL, modelM, protonHighEnergy, protonLowEnergy, G4hRDEnergyLoss::TotBin, and G4VProcess::verboseLevel.

Referenced by G4hImpactIonisation().

◆ InitializeParametrisation()

void G4hImpactIonisation::InitializeParametrisation ( )

private

Definition at line 174 of file G4hImpactIonisation.cc.

{
  // Define models for parametrisation of electronic energy losses
  betheBlochModel = new G4hBetheBlochModel("Bethe-Bloch") ;
  protonModel = new G4hParametrisedLossModel(protonTable) ;
  protonHighEnergy = std::min(protonHighEnergy,protonModel->HighEnergyLimit(0, 0));
  antiprotonModel = new G4QAOLowEnergyLoss(antiprotonTable) ;
  theNuclearStoppingModel = new G4hNuclearStoppingModel(theNuclearTable) ;
  theIonEffChargeModel = new G4hIonEffChargeSquare("Ziegler1988") ;
  theIonChuFluctuationModel = new G4IonChuFluctuationModel("Chu") ;
  theIonYangFluctuationModel = new G4IonYangFluctuationModel("Yang") ;
}

References antiprotonModel, antiprotonTable, betheBlochModel, G4VLowEnergyModel::HighEnergyLimit(), G4INCL::Math::min(), protonHighEnergy, protonModel, protonTable, theIonChuFluctuationModel, theIonEffChargeModel, theIonYangFluctuationModel, theNuclearStoppingModel, and theNuclearTable.

Referenced by BuildPhysicsTable().

◆ InvertRangeVector()

void G4hRDEnergyLoss::InvertRangeVector	(	G4int	materialIndex,
		G4PhysicsLogVector *	rangeVector
	)

staticprivateinherited

Definition at line 1101 of file G4hRDEnergyLoss.cc.

{
  //  invert range vector for a material
 
  G4double LowEdgeRange,A,B,C,discr,KineticEnergy ;
  G4double Tbin = LowestKineticEnergy/RTable ;
  G4double rangebin = 0.0 ;
  G4int binnumber = -1 ;
  G4bool isOut ;
 
 
  //loop for range values
  for( G4int i=0; i<TotBin; i++)
    {
      LowEdgeRange = aVector->GetLowEdgeEnergy(i) ;  //i.e. GetLowEdgeValue(i)
 
      if( rangebin < LowEdgeRange )
    {
      do
        {
          binnumber += 1 ;
          Tbin *= RTable ;
          rangebin = (*theRangeTable)(materialIndex)->GetValue(Tbin,isOut) ;
        }
      while ((rangebin < LowEdgeRange) && (binnumber < TotBin )) ;
    }
 
      if(binnumber == 0)
    KineticEnergy = LowestKineticEnergy ;
      else if(binnumber == TotBin-1)
    KineticEnergy = HighestKineticEnergy ;
      else
    {
      A = (*(*theRangeCoeffATable)(materialIndex))(binnumber-1) ;
      B = (*(*theRangeCoeffBTable)(materialIndex))(binnumber-1) ;
      C = (*(*theRangeCoeffCTable)(materialIndex))(binnumber-1) ;
      if(A==0.)
        KineticEnergy = (LowEdgeRange -C )/B ;
      else
        {
          discr = B*B - 4.*A*(C-LowEdgeRange);
          discr = discr>0. ? std::sqrt(discr) : 0.;
          KineticEnergy = 0.5*(discr-B)/A ;
        }
    }
 
      aVector->PutValue(i,KineticEnergy) ;
    }
}

References A, B(), C(), G4PhysicsVector::GetLowEdgeEnergy(), G4hRDEnergyLoss::HighestKineticEnergy, G4hRDEnergyLoss::LowestKineticEnergy, G4PhysicsVector::PutValue(), G4hRDEnergyLoss::RTable, and G4hRDEnergyLoss::TotBin.

◆ 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 G4hImpactIonisation::IsApplicable ( const G4ParticleDefinition & particle )

inlinevirtual

Reimplemented from G4VProcess.

Definition at line 310 of file G4hImpactIonisation.hh.

{
  // ---- MGP ---- Better criterion for applicability to be defined;
  // now hard-coded particle mass > 0.1 * proton_mass
 
  return (particle.GetPDGCharge() != 0.0 && particle.GetPDGMass() > CLHEP::proton_mass_c2*0.1);
}

References G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), and CLHEP::proton_mass_c2.

◆ isAtRestDoItIsEnabled()

G4bool G4VProcess::isAtRestDoItIsEnabled ( ) const

inlineinherited

Definition at line 500 of file G4VProcess.hh.

{
  return enableAtRestDoIt;
}

References G4VProcess::enableAtRestDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ isPostStepDoItIsEnabled()

G4bool G4VProcess::isPostStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 512 of file G4VProcess.hh.

{
  return enablePostStepDoIt;
}

References G4VProcess::enablePostStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ LabTimeIntLog()

G4double G4hRDEnergyLoss::LabTimeIntLog	(	G4PhysicsVector *	physicsVector,
		G4int	nbin
	)

staticprivateinherited

Definition at line 703 of file G4hRDEnergyLoss.cc.

{
  //  num. integration, logarithmic binning
 
  G4double ltt,dltau,Value,ui,taui,ti,lossi,ci;
  G4bool isOut;
  ltt = ltauhigh-ltaulow;
  dltau = ltt/nbin;
  Value = 0.;
 
  for (G4int i=0; i<=nbin; i++)
    {
      ui = ltaulow+dltau*i;
      taui = std::exp(ui);
      ti = ParticleMass*taui;
      lossi = physicsVector->GetValue(ti,isOut);
      if(i==0)
    ci=0.5;
      else
    {
      if(i<nbin)
        ci=1.;
      else
        ci=0.5;
    }
      Value += ci*taui*(ti+ParticleMass)/(std::sqrt(ti*(ti+2.*ParticleMass))*lossi);
    }
  Value *= ParticleMass*dltau/c_light;
  return Value;
}

References source.hepunit::c_light, G4PhysicsVector::GetValue(), G4hRDEnergyLoss::ltauhigh, G4hRDEnergyLoss::ltaulow, and G4hRDEnergyLoss::ParticleMass.

Referenced by G4hRDEnergyLoss::BuildLabTimeVector().

◆ MicroscopicCrossSection()

G4double G4hImpactIonisation::MicroscopicCrossSection	(	const G4ParticleDefinition &	aParticleType,
		G4double	kineticEnergy,
		G4double	atomicNumber,
		G4double	deltaCutInEnergy
	)		const

private

Definition at line 530 of file G4hImpactIonisation.cc.

{
  //******************************************************************
    // cross section formula is OK for spin=0, 1/2, 1 only !
    // *****************************************************************
 
    // Calculates the microscopic cross section in GEANT4 internal units
    // Formula documented in Geant4 Phys. Ref. Manual
    // ( it is called for elements, AtomicNumber = z )
 
    G4double totalCrossSection = 0.;
 
  // Particle mass and energy
  G4double particleMass = initialMass;
  G4double energy = kineticEnergy + particleMass;
 
  // Some kinematics
  G4double gamma = energy / particleMass;
  G4double beta2 = 1. - 1. / (gamma * gamma);
  G4double var = electron_mass_c2 / particleMass;
  G4double tMax   = 2. * electron_mass_c2 * (gamma*gamma - 1.) / (1. + 2.* gamma*var + var*var);
 
  // Calculate the total cross section
 
  if ( tMax > deltaCutInEnergy ) 
    {
      var = deltaCutInEnergy / tMax;
      totalCrossSection = (1. - var * (1. - beta2 * std::log(var))) / deltaCutInEnergy ;
      
      G4double spin = particleDef.GetPDGSpin() ;
      
      // +term for spin=1/2 particle
      if (spin == 0.5) 
    {
      totalCrossSection +=  0.5 * (tMax - deltaCutInEnergy) / (energy*energy);
    }
      // +term for spin=1 particle
      else if (spin > 0.9 )
    {
      totalCrossSection += -std::log(var) / 
        (3. * deltaCutInEnergy) + (tMax - deltaCutInEnergy) * ( (5. + 1. /var)*0.25 / (energy*energy) -
                                    beta2 / (tMax * deltaCutInEnergy) ) / 3. ;
    }
      totalCrossSection *= twopi_mc2_rcl2 * atomicNumber / beta2 ;
    }
 
  //std::cout << "Microscopic = " << totalCrossSection/barn 
  //    << ", e = " << kineticEnergy/MeV <<std:: endl; 
 
  return totalCrossSection ;
}

References source.hepunit::electron_mass_c2, G4INCL::KinematicsUtils::energy(), G4ParticleDefinition::GetPDGSpin(), initialMass, and source.hepunit::twopi_mc2_rcl2.

Referenced by BuildLambdaTable().

◆ MinusNumberOfProcesses()

void G4hRDEnergyLoss::MinusNumberOfProcesses ( )

staticinherited

Definition at line 211 of file G4hRDEnergyLoss.cc.

{
  NumberOfProcesses--; 
} 

References G4hRDEnergyLoss::NumberOfProcesses.

◆ operator!=()

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

inherited

Definition at line 161 of file G4VProcess.cc.

{
  return (this !=  &right);
}

◆ operator=()

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

private

◆ operator==()

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

inherited

Definition at line 155 of file G4VProcess.cc.

{
  return (this == &right);
}

◆ PlusNumberOfProcesses()

void G4hRDEnergyLoss::PlusNumberOfProcesses ( )

staticinherited

Definition at line 204 of file G4hRDEnergyLoss.cc.

{
  NumberOfProcesses++; 
} 

References G4hRDEnergyLoss::NumberOfProcesses.

◆ PostStepDoIt()

G4VParticleChange * G4hImpactIonisation::PostStepDoIt	(	const G4Track &	track,
		const G4Step &	Step
	)

virtual

Implements G4hRDEnergyLoss.

Definition at line 951 of file G4hImpactIonisation.cc.

{
  // Units are expressed in GEANT4 internal units.
 
  //  std::cout << "----- Calling PostStepDoIt ----- " << std::endl;
 
  aParticleChange.Initialize(track) ;
  const G4MaterialCutsCouple* couple = track.GetMaterialCutsCouple();  
  const G4DynamicParticle* aParticle = track.GetDynamicParticle() ;
  
  // Some kinematics
 
  G4ParticleDefinition* definition = track.GetDefinition();
  G4double mass = definition->GetPDGMass();
  G4double kineticEnergy = aParticle->GetKineticEnergy();
  G4double totalEnergy = kineticEnergy + mass ;
  G4double pSquare = kineticEnergy *( totalEnergy + mass) ;
  G4double eSquare = totalEnergy * totalEnergy;
  G4double betaSquare = pSquare / eSquare;
  G4ThreeVector particleDirection = aParticle->GetMomentumDirection() ;
 
  G4double gamma = kineticEnergy / mass + 1.;
  G4double r = electron_mass_c2 / mass;
  G4double tMax = 2. * electron_mass_c2 *(gamma*gamma - 1.) / (1. + 2.*gamma*r + r*r);
 
  // Validity range for delta electron cross section
  G4double deltaCut = cutForDelta[couple->GetIndex()];
 
  // This should not be a case
  if (deltaCut >= tMax)
    return G4VContinuousDiscreteProcess::PostStepDoIt(track,step);
 
  G4double xc = deltaCut / tMax;
  G4double rate = tMax / totalEnergy;
  rate = rate*rate ;
  G4double spin = aParticle->GetDefinition()->GetPDGSpin() ;
 
  // Sampling follows ...
  G4double x = 0.;
  G4double gRej = 0.;
 
  do {
    x = xc / (1. - (1. - xc) * G4UniformRand());
    
    if (0.0 == spin) 
      {
    gRej = 1.0 - betaSquare * x ;
      }
    else if (0.5 == spin) 
      {
    gRej = (1. - betaSquare * x + 0.5 * x*x * rate) / (1. + 0.5 * rate) ;
      } 
    else 
      {
    gRej = (1. - betaSquare * x ) * (1. + x/(3.*xc)) +
      x*x * rate * (1. + 0.5*x/xc) / 3.0 /
      (1. + 1./(3.*xc) + rate *(1.+ 0.5/xc) / 3.);
      }
    
  } while( G4UniformRand() > gRej );
 
  G4double deltaKineticEnergy = x * tMax;
  G4double deltaTotalMomentum = std::sqrt(deltaKineticEnergy * 
                      (deltaKineticEnergy + 2. * electron_mass_c2 ));
  G4double totalMomentum = std::sqrt(pSquare) ;
  G4double cosTheta = deltaKineticEnergy * (totalEnergy + electron_mass_c2) / (deltaTotalMomentum*totalMomentum);
 
  //  protection against cosTheta > 1 or < -1 
  if ( cosTheta < -1. ) cosTheta = -1.;
  if ( cosTheta > 1. ) cosTheta = 1.;
 
  //  direction of the delta electron 
  G4double phi = twopi * G4UniformRand();
  G4double sinTheta = std::sqrt(1. - cosTheta*cosTheta);
  G4double dirX = sinTheta * std::cos(phi);
  G4double dirY = sinTheta * std::sin(phi);
  G4double dirZ = cosTheta;
 
  G4ThreeVector deltaDirection(dirX,dirY,dirZ);
  deltaDirection.rotateUz(particleDirection);
 
  // create G4DynamicParticle object for delta ray
  G4DynamicParticle* deltaRay = new G4DynamicParticle;
  deltaRay->SetKineticEnergy( deltaKineticEnergy );
  deltaRay->SetMomentumDirection(deltaDirection.x(),
                 deltaDirection.y(),
                 deltaDirection.z());
  deltaRay->SetDefinition(G4Electron::Electron());
 
  // fill aParticleChange
  G4double finalKineticEnergy = kineticEnergy - deltaKineticEnergy;
  size_t totalNumber = 1;
 
  // Atomic relaxation
 
  // ---- MGP ---- Temporary limitation: currently PIXE only for incident protons
 
  size_t nSecondaries = 0;
  std::vector<G4DynamicParticle*>* secondaryVector = 0;
 
  if (definition == G4Proton::ProtonDefinition())
    {
      const G4Material* material = couple->GetMaterial();
 
      // Lazy initialization of pixeCrossSectionHandler
      if (pixeCrossSectionHandler == 0)
    {
      // Instantiate pixeCrossSectionHandler with selected shell cross section models
      // Ownership of interpolation is transferred to pixeCrossSectionHandler
      G4IInterpolator* interpolation = new G4LogLogInterpolator();
      pixeCrossSectionHandler = 
        new G4PixeCrossSectionHandler(interpolation,modelK,modelL,modelM,eMinPixe,eMaxPixe);
      G4String fileName("proton");
      pixeCrossSectionHandler->LoadShellData(fileName);
      //      pixeCrossSectionHandler->PrintData();
    }
      
      // Select an atom in the current material based on the total shell cross sections
      G4int Z = pixeCrossSectionHandler->SelectRandomAtom(material,kineticEnergy);
      //      std::cout << "G4hImpactIonisation::PostStepDoIt - Z = " << Z << std::endl;
 
      //      G4double microscopicCross = MicroscopicCrossSection(*definition,
      //                              kineticEnergy,
      //                      Z, deltaCut);
  //    G4double crossFromShells = pixeCrossSectionHandler->FindValue(Z,kineticEnergy);
 
      //std::cout << "G4hImpactIonisation: Z= "
      //        << Z
      //        << ", energy = "
      //        << kineticEnergy/MeV
      //        <<" MeV, microscopic = "
      //        << microscopicCross/barn 
      //        << " barn, from shells = "
      //        << crossFromShells/barn
      //        << " barn" 
      //        << std::endl;
 
      // Select a shell in the target atom based on the individual shell cross sections
      G4int shellIndex = pixeCrossSectionHandler->SelectRandomShell(Z,kineticEnergy);
    
      G4AtomicTransitionManager* transitionManager = G4AtomicTransitionManager::Instance();
      const G4AtomicShell* atomicShell = transitionManager->Shell(Z,shellIndex);
      G4double bindingEnergy = atomicShell->BindingEnergy();
      
      //     if (verboseLevel > 1) 
      //       {
      //     G4cout << "G4hImpactIonisation::PostStepDoIt - Z = " 
      //         << Z 
      //     << ", shell = " 
      //     << shellIndex
      //     << ", bindingE (keV) = " 
      //     << bindingEnergy/keV
      //     << G4endl;
      //       }
      
      // Generate PIXE if binding energy larger than cut for photons or electrons
      
      G4ParticleDefinition* type = 0;
      
      if (finalKineticEnergy >= bindingEnergy)
    //    && (bindingEnergy >= minGammaEnergy ||  bindingEnergy >= minElectronEnergy) ) 
    {
      // Vacancy in subshell shellIndex; shellId is the subshell identifier in EADL jargon 
      G4int shellId = atomicShell->ShellId();
      // Atomic relaxation: generate secondaries
      secondaryVector = atomicDeexcitation.GenerateParticles(Z, shellId);
 
      // ---- Debug ----
      //std::cout << "ShellId = "
      //    <<shellId << " ---- Atomic relaxation secondaries: ---- " 
      //    << secondaryVector->size()
      //    << std::endl;
 
      // ---- End debug ---
 
      if (secondaryVector != 0) 
        {
          nSecondaries = secondaryVector->size();
          for (size_t i = 0; i<nSecondaries; i++) 
        {
          G4DynamicParticle* aSecondary = (*secondaryVector)[i];
          if (aSecondary) 
            {
              G4double e = aSecondary->GetKineticEnergy();
              type = aSecondary->GetDefinition();
 
              // ---- Debug ----
              //if (type == G4Gamma::GammaDefinition())
              //    {           
              //      std::cout << "Z = " << Z 
              //            << ", shell: " << shellId
              //            << ", PIXE photon energy (keV) = " << e/keV 
              //            << std::endl;
              //    }
              // ---- End debug ---
 
              if (e < finalKineticEnergy &&
              ((type == G4Gamma::Gamma() && e > minGammaEnergy ) ||
               (type == G4Electron::Electron() && e > minElectronEnergy ))) 
            {
              // Subtract the energy of the emitted secondary from the primary
              finalKineticEnergy -= e;
              totalNumber++;
              // ---- Debug ----
              //if (type == G4Gamma::GammaDefinition())
              //    {           
              //      std::cout << "Z = " << Z 
              //            << ", shell: " << shellId
              //            << ", PIXE photon energy (keV) = " << e/keV
              //            << std::endl;
              //    }
              // ---- End debug ---
            } 
              else 
            {
              // The atomic relaxation product has energy below the cut
              // ---- Debug ----
              // if (type == G4Gamma::GammaDefinition())
              //    {           
              //      std::cout << "Z = " << Z 
              //
              //            << ", PIXE photon energy = " << e/keV 
              //            << " keV below threshold " << minGammaEnergy/keV << " keV"
              //            << std::endl;
              //    }   
              // ---- End debug ---
     
              delete aSecondary;
              (*secondaryVector)[i] = 0;
            }
            }
        }
        }
    }
    }
 
 
  // Save delta-electrons
 
  G4double eDeposit = 0.;
 
  if (finalKineticEnergy > MinKineticEnergy)
    {
      G4double finalPx = totalMomentum*particleDirection.x() - deltaTotalMomentum*deltaDirection.x();
      G4double finalPy = totalMomentum*particleDirection.y() - deltaTotalMomentum*deltaDirection.y();
      G4double finalPz = totalMomentum*particleDirection.z() - deltaTotalMomentum*deltaDirection.z();
      G4double finalMomentum = std::sqrt(finalPx*finalPx + finalPy*finalPy + finalPz*finalPz) ;
      finalPx /= finalMomentum;
      finalPy /= finalMomentum;
      finalPz /= finalMomentum;
 
      aParticleChange.ProposeMomentumDirection( finalPx,finalPy,finalPz );
    }
  else
    {
      eDeposit = finalKineticEnergy;
      finalKineticEnergy = 0.;
      aParticleChange.ProposeMomentumDirection(particleDirection.x(),
                           particleDirection.y(),
                           particleDirection.z());
      if(!aParticle->GetDefinition()->GetProcessManager()->
     GetAtRestProcessVector()->size())
        aParticleChange.ProposeTrackStatus(fStopAndKill);
      else
        aParticleChange.ProposeTrackStatus(fStopButAlive);
    }
 
  aParticleChange.ProposeEnergy(finalKineticEnergy);
  aParticleChange.ProposeLocalEnergyDeposit (eDeposit);
  aParticleChange.SetNumberOfSecondaries(totalNumber);
  aParticleChange.AddSecondary(deltaRay);
 
  // ---- Debug ----
  //  std::cout << "RDHadronIonisation - finalKineticEnergy (MeV) = " 
  //        << finalKineticEnergy/MeV 
  //        << ", delta KineticEnergy (keV) = " 
  //        << deltaKineticEnergy/keV 
  //        << ", energy deposit (MeV) = "
  //        << eDeposit/MeV
  //        << std::endl;
  // ---- End debug ---
  
  // Save Fluorescence and Auger
 
  if (secondaryVector != 0) 
    { 
      for (size_t l = 0; l < nSecondaries; l++) 
    { 
      G4DynamicParticle* secondary = (*secondaryVector)[l];
      if (secondary) aParticleChange.AddSecondary(secondary);
 
      // ---- Debug ----
      //if (secondary != 0) 
      // {
      //   if (secondary->GetDefinition() == G4Gamma::GammaDefinition())
      //    {
      //      G4double eX = secondary->GetKineticEnergy();          
      //      std::cout << " PIXE photon of energy " << eX/keV 
      //            << " keV added to ParticleChange; total number of secondaries is " << totalNumber 
      //            << std::endl;
      //    }
      //}
      // ---- End debug ---   
 
    }
      delete secondaryVector;
    }
 
  return G4VContinuousDiscreteProcess::PostStepDoIt(track,step);
}

References G4ParticleChange::AddSecondary(), G4VProcess::aParticleChange, atomicDeexcitation, G4AtomicShell::BindingEnergy(), G4InuclSpecialFunctions::bindingEnergy(), cutForDelta, G4Electron::Electron(), source.hepunit::electron_mass_c2, eMaxPixe, eMinPixe, fStopAndKill, fStopButAlive, G4UniformRand, G4Gamma::Gamma(), G4AtomicDeexcitation::GenerateParticles(), G4DynamicParticle::GetDefinition(), G4Track::GetDefinition(), G4Track::GetDynamicParticle(), G4MaterialCutsCouple::GetIndex(), G4DynamicParticle::GetKineticEnergy(), G4MaterialCutsCouple::GetMaterial(), G4Track::GetMaterialCutsCouple(), G4DynamicParticle::GetMomentumDirection(), G4ParticleDefinition::GetPDGMass(), G4ParticleDefinition::GetPDGSpin(), G4ParticleDefinition::GetProcessManager(), G4ParticleChange::Initialize(), G4AtomicTransitionManager::Instance(), G4PixeCrossSectionHandler::LoadShellData(), eplot::material, minElectronEnergy, minGammaEnergy, G4hRDEnergyLoss::MinKineticEnergy, modelK, modelL, modelM, pixeCrossSectionHandler, G4VContinuousDiscreteProcess::PostStepDoIt(), G4ParticleChange::ProposeEnergy(), G4VParticleChange::ProposeLocalEnergyDeposit(), G4ParticleChange::ProposeMomentumDirection(), G4VParticleChange::ProposeTrackStatus(), G4Proton::ProtonDefinition(), CLHEP::Hep3Vector::rotateUz(), G4PixeCrossSectionHandler::SelectRandomAtom(), G4PixeCrossSectionHandler::SelectRandomShell(), G4DynamicParticle::SetDefinition(), G4DynamicParticle::SetKineticEnergy(), G4DynamicParticle::SetMomentumDirection(), G4VParticleChange::SetNumberOfSecondaries(), G4AtomicTransitionManager::Shell(), G4AtomicShell::ShellId(), twopi, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), CLHEP::Hep3Vector::z(), and Z.

◆ PostStepGetPhysicalInteractionLength()

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

virtualinherited

Implements G4VProcess.

Reimplemented in G4VMultipleScattering, G4AdjointForcedInteractionForGamma, G4PolarizedIonisation, and G4VEnergyLossProcess.

Definition at line 71 of file G4VContinuousDiscreteProcess.cc.

{
  if ( (previousStepSize <=0.0) || (theNumberOfInteractionLengthLeft<=0.0))
  {
    // beginning of tracking (or just after DoIt() of this process)
    ResetNumberOfInteractionLengthLeft();
  }
  else if ( previousStepSize > 0.0)
  {
    // subtract NumberOfInteractionLengthLeft 
    SubtractNumberOfInteractionLengthLeft(previousStepSize);
  }
  else
  {
    // zero step
    // DO NOTHING
  }
 
  // condition is set to "Not Forced"
  *condition = NotForced;
 
  // get mean free path
  currentInteractionLength = GetMeanFreePath(track,previousStepSize,condition);
 
  G4double value;
  if (currentInteractionLength < DBL_MAX)
  {
    value = theNumberOfInteractionLengthLeft * currentInteractionLength;
  }
  else
  {
    value = DBL_MAX;
  }
#ifdef G4VERBOSE
  if (verboseLevel>1)
  {
    G4cout << "G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength() - ";
    G4cout << "[ " << GetProcessName() << "]" << G4endl;
    track.GetDynamicParticle()->DumpInfo();
    G4cout << " in Material  " <<  track.GetMaterial()->GetName() << G4endl;
    G4cout << "InteractionLength= " << value/cm <<"[cm] " << G4endl;
  }
#endif
  return value;
}

References cm, condition(), G4VProcess::currentInteractionLength, DBL_MAX, G4DynamicParticle::DumpInfo(), G4cout, G4endl, G4Track::GetDynamicParticle(), G4Track::GetMaterial(), G4VContinuousDiscreteProcess::GetMeanFreePath(), G4Material::GetName(), G4VProcess::GetProcessName(), NotForced, G4VProcess::ResetNumberOfInteractionLengthLeft(), G4VProcess::SubtractNumberOfInteractionLengthLeft(), 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()

virtual void G4VProcess::PreparePhysicsTable ( const G4ParticleDefinition & )

inlinevirtualinherited

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

◆ PrintInfoDefinition()

void G4hImpactIonisation::PrintInfoDefinition ( ) const

Definition at line 1713 of file G4hImpactIonisation.cc.

{
  G4String comments = "  Knock-on electron cross sections . ";
  comments += "\n        Good description above the mean excitation energy.\n";
  comments += "        Delta ray energy sampled from  differential Xsection.";
 
  G4cout << G4endl << GetProcessName() << ":  " << comments
         << "\n        PhysicsTables from " << LowestKineticEnergy / eV << " eV "
         << " to " << HighestKineticEnergy / TeV << " TeV "
         << " in " << TotBin << " bins."
     << "\n        Electronic stopping power model is  "
     << protonTable
         << "\n        from " << protonLowEnergy / keV << " keV "
         << " to " << protonHighEnergy / MeV << " MeV " << "." << G4endl ;
  G4cout << "\n        Parametrisation model for antiprotons is  "
         << antiprotonTable
         << "\n        from " << antiprotonLowEnergy / keV << " keV "
         << " to " << antiprotonHighEnergy / MeV << " MeV " << "." << G4endl ;
  if(theBarkas){
    G4cout << "        Parametrization of the Barkas effect is switched on."
       << G4endl ;
  }
  if(nStopping) {
    G4cout << "        Nuclear stopping power model is " << theNuclearTable
       << G4endl ;
  }
 
  G4bool printHead = true;
 
  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();
 
  // loop for materials
 
  for (size_t j=0 ; j < numOfCouples; j++) {
 
    const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(j);
    const G4Material* material= couple->GetMaterial();
    G4double deltaCutNow = cutForDelta[(couple->GetIndex())] ;
    G4double excitationEnergy = material->GetIonisation()->GetMeanExcitationEnergy();
 
    if(excitationEnergy > deltaCutNow) {
      if(printHead) {
        printHead = false ;
 
        G4cout << "           material       min.delta energy(keV) " << G4endl;
        G4cout << G4endl;
      }
 
      G4cout << std::setw(20) << material->GetName()
         << std::setw(15) << excitationEnergy/keV << G4endl;
    }
  }
}

References antiprotonHighEnergy, antiprotonLowEnergy, antiprotonTable, cutForDelta, eV, G4cout, G4endl, G4MaterialCutsCouple::GetIndex(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4VProcess::GetProcessName(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4hRDEnergyLoss::HighestKineticEnergy, keV, G4hRDEnergyLoss::LowestKineticEnergy, eplot::material, MeV, nStopping, protonHighEnergy, protonLowEnergy, protonTable, TeV, theBarkas, theNuclearTable, and G4hRDEnergyLoss::TotBin.

Referenced by BuildPhysicsTable().

◆ ProcessDescription()

void G4VProcess::ProcessDescription ( std::ostream & outfile ) const

virtualinherited

Reimplemented in G4AdjointAlongStepWeightCorrection, G4AdjointForcedInteractionForGamma, G4AdjointhMultipleScattering, G4ContinuousGainOfEnergy, G4eAdjointMultipleScattering, G4eInverseBremsstrahlung, G4eInverseCompton, G4eInverseIonisation, G4InversePEEffect, G4IonInverseIonisation, G4eeToHadrons, G4hBremsstrahlung, G4hhIonisation, G4hPairProduction, G4mplIonisation, G4RayleighScattering, G4ePairProduction, G4MuBremsstrahlung, G4MuIonisation, G4MuMultipleScattering, G4MuPairProduction, G4PolarizedAnnihilation, G4PolarizedBremsstrahlung, G4PolarizedCompton, G4PolarizedGammaConversion, G4PolarizedIonisation, G4PolarizedPhotoElectric, G4ComptonScattering, G4CoulombScattering, G4eBremsstrahlung, G4eIonisation, G4eMultipleScattering, G4eplusAnnihilation, G4GammaConversion, G4hIonisation, G4hMultipleScattering, G4ionIonisation, G4NuclearStopping, G4PhotoElectricEffect, G4ForwardXrayTR, G4GammaXTRadiator, G4GaussXTRadiator, G4RegularXTRadiator, G4Scintillation, G4StrawTubeXTRadiator, G4SynchrotronRadiation, G4TransitionRadiation, G4TransparentRegXTRadiator, G4VTransitionRadiation, G4VXTRenergyLoss, G4XTRGammaRadModel, G4XTRRegularRadModel, G4XTRTransparentRegRadModel, G4Cerenkov, G4Radioactivation, G4RadioactiveDecay, G4ElectronNuclearProcess, G4MuonNuclearProcess, G4NeutrinoElectronProcess, G4NeutronFissionProcess, G4PositronNuclearProcess, G4HadronicAbsorptionBertini, G4HadronicAbsorptionFritiof, G4HadronicAbsorptionFritiofWithBinaryCascade, G4HadronStoppingProcess, G4MuonicAtomDecay, G4MuonMinusAtomicCapture, G4MuonMinusCapture, G4Transportation, G4NeutronCaptureProcess, G4GammaGeneralProcess, G4Decay, G4DecayWithSpin, G4PionDecayMakeSpin, G4UnknownDecay, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4HadronicProcess, G4ElNeutrinoNucleusProcess, G4HadronElasticProcess, and G4MuNeutrinoNucleusProcess.

Definition at line 175 of file G4VProcess.cc.

{
  outFile << "This process has not yet been described\n";
}

Referenced by G4LossTableManager::DumpHtml(), G4HadronicProcessStore::PrintHtml(), and G4GammaGeneralProcess::ProcessDescription().

◆ ProperTimeIntLog()

G4double G4hRDEnergyLoss::ProperTimeIntLog	(	G4PhysicsVector *	physicsVector,
		G4int	nbin
	)

staticprivateinherited

Definition at line 737 of file G4hRDEnergyLoss.cc.

{
  //  num. integration, logarithmic binning
 
  G4double ltt,dltau,Value,ui,taui,ti,lossi,ci;
  G4bool isOut;
  ltt = ltauhigh-ltaulow;
  dltau = ltt/nbin;
  Value = 0.;
 
  for (G4int i=0; i<=nbin; i++)
    {
      ui = ltaulow+dltau*i;
      taui = std::exp(ui);
      ti = ParticleMass*taui;
      lossi = physicsVector->GetValue(ti,isOut);
      if(i==0)
    ci=0.5;
      else
    {
      if(i<nbin)
        ci=1.;
      else
        ci=0.5;
    }
      Value += ci*taui*ParticleMass/(std::sqrt(ti*(ti+2.*ParticleMass))*lossi);
    }
  Value *= ParticleMass*dltau/c_light;
  return Value;
}

References source.hepunit::c_light, G4PhysicsVector::GetValue(), G4hRDEnergyLoss::ltauhigh, G4hRDEnergyLoss::ltaulow, and G4hRDEnergyLoss::ParticleMass.

Referenced by G4hRDEnergyLoss::BuildProperTimeVector().

◆ ProtonParametrisedDEDX()

G4double G4hImpactIonisation::ProtonParametrisedDEDX	(	const G4MaterialCutsCouple *	couple,
		G4double	kineticEnergy
	)		const

private

Definition at line 831 of file G4hImpactIonisation.cc.

{
  const G4Material* material = couple->GetMaterial();
  G4Proton* proton = G4Proton::Proton();
  G4double eLoss = 0.;
 
  // Free Electron Gas Model
  if(kineticEnergy < protonLowEnergy) {
    eLoss = (protonModel->TheValue(proton, material, protonLowEnergy))
      * std::sqrt(kineticEnergy/protonLowEnergy) ;
 
    // Parametrisation
  } else {
    eLoss = protonModel->TheValue(proton, material, kineticEnergy) ;
  }
 
  // Delta rays energy
  eLoss -= DeltaRaysEnergy(couple,kineticEnergy,proton_mass_c2) ;
 
  if(verboseLevel > 2) {
    G4cout << "p E(MeV)= " << kineticEnergy/MeV
           << " dE/dx(MeV/mm)= " << eLoss*mm/MeV
           << " for " << material->GetName()
           << " model: " << protonModel << G4endl;
  }
 
  if(eLoss < 0.0) eLoss = 0.0 ;
 
  return eLoss ;
}

References DeltaRaysEnergy(), G4cout, G4endl, G4MaterialCutsCouple::GetMaterial(), eplot::material, MeV, mm, G4Proton::Proton(), G4InuclParticleNames::proton, source.hepunit::proton_mass_c2, protonLowEnergy, protonModel, G4VLowEnergyModel::TheValue(), and G4VProcess::verboseLevel.

Referenced by BuildLossTable(), and ComputeDEDX().

◆ RangeIntLin()

G4double G4hRDEnergyLoss::RangeIntLin	(	G4PhysicsVector *	physicsVector,
		G4int	nbin
	)

staticprivateinherited

Definition at line 637 of file G4hRDEnergyLoss.cc.

{
  //  num. integration, linear binning
 
  G4double dtau,Value,taui,ti,lossi,ci;
  G4bool isOut;
  dtau = (tauhigh-taulow)/nbin;
  Value = 0.;
 
  for (G4int i=0; i<=nbin; i++)
    {
      taui = taulow + dtau*i ;
      ti = Mass*taui;
      lossi = physicsVector->GetValue(ti,isOut);
      if(i==0)
    ci=0.5;
      else
    {
      if(i<nbin)
        ci=1.;
      else
        ci=0.5;
    }
      Value += ci/lossi;
    }
  Value *= Mass*dtau;
  return Value;
}

References G4PhysicsVector::GetValue(), G4hRDEnergyLoss::Mass, G4hRDEnergyLoss::tauhigh, and G4hRDEnergyLoss::taulow.

◆ RangeIntLog()

G4double G4hRDEnergyLoss::RangeIntLog	(	G4PhysicsVector *	physicsVector,
		G4int	nbin
	)

staticprivateinherited

Definition at line 669 of file G4hRDEnergyLoss.cc.

{
  //  num. integration, logarithmic binning
 
  G4double ltt,dltau,Value,ui,taui,ti,lossi,ci;
  G4bool isOut;
  ltt = ltauhigh-ltaulow;
  dltau = ltt/nbin;
  Value = 0.;
 
  for (G4int i=0; i<=nbin; i++)
    {
      ui = ltaulow+dltau*i;
      taui = std::exp(ui);
      ti = Mass*taui;
      lossi = physicsVector->GetValue(ti,isOut);
      if(i==0)
    ci=0.5;
      else
    {
      if(i<nbin)
        ci=1.;
      else
        ci=0.5;
    }
      Value += ci*taui/lossi;
    }
  Value *= Mass*dltau;
  return Value;
}

References G4PhysicsVector::GetValue(), G4hRDEnergyLoss::ltauhigh, G4hRDEnergyLoss::ltaulow, and G4hRDEnergyLoss::Mass.

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

virtual G4bool G4VProcess::RetrievePhysicsTable	(	const G4ParticleDefinition *	,
		const G4String &	,
		G4bool
	)

inlinevirtualinherited

Reimplemented in G4GammaGeneralProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4WrapperProcess, G4AdjointProcessEquivalentToDirectProcess, and G4BiasingProcessInterface.

Definition at line 211 of file G4VProcess.hh.

212 { return false; }

Referenced by export_G4VProcess(), G4WrapperProcess::RetrievePhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::RetrievePhysicsTable(), and G4BiasingProcessInterface::RetrievePhysicsTable().

◆ SetAntiProtonElectronicStoppingPowerModel()

void G4hImpactIonisation::SetAntiProtonElectronicStoppingPowerModel ( const G4String & dedxTable )

inlineprivate

Definition at line 195 of file G4hImpactIonisation.hh.

196 {antiprotonTable = dedxTable;};

References antiprotonTable.

Referenced by SetElectronicStoppingPowerModel().

◆ SetBarkasOff()

void G4hImpactIonisation::SetBarkasOff ( )

inline

Definition at line 147 of file G4hImpactIonisation.hh.

147{theBarkas = false;};

References theBarkas.

◆ SetBarkasOn()

void G4hImpactIonisation::SetBarkasOn ( )

inline

Definition at line 144 of file G4hImpactIonisation.hh.

144{theBarkas = true;};

References theBarkas.

◆ SetCutForAugerElectrons()

void G4hImpactIonisation::SetCutForAugerElectrons ( G4double cut )

Definition at line 1699 of file G4hImpactIonisation.cc.

{
  minElectronEnergy = cut;
}

References minElectronEnergy.

◆ SetCutForSecondaryPhotons()

void G4hImpactIonisation::SetCutForSecondaryPhotons ( G4double cut )

Definition at line 1692 of file G4hImpactIonisation.cc.

{
  minGammaEnergy = cut;
}

References minGammaEnergy.

◆ SetdRoverRange()

void G4hRDEnergyLoss::SetdRoverRange ( G4double value )

staticinherited

Definition at line 218 of file G4hRDEnergyLoss.cc.

{
  dRoverRange = value;
}

References G4hRDEnergyLoss::dRoverRange.

◆ SetElectronicStoppingPowerModel()

void G4hImpactIonisation::SetElectronicStoppingPowerModel	(	const G4ParticleDefinition *	aParticle,
		const G4String &	dedxTable
	)

Definition at line 156 of file G4hImpactIonisation.cc.

{
  if (particle->GetPDGCharge() > 0 ) 
    {
      // Positive charge
      SetProtonElectronicStoppingPowerModel(dedxTable) ;
    } 
  else 
    {
      // Antiprotons
      SetAntiProtonElectronicStoppingPowerModel(dedxTable) ;
    }
}

References G4ParticleDefinition::GetPDGCharge(), SetAntiProtonElectronicStoppingPowerModel(), and SetProtonElectronicStoppingPowerModel().

◆ SetEnlossFluc()

void G4hRDEnergyLoss::SetEnlossFluc ( G4bool value )

staticinherited

Definition at line 232 of file G4hRDEnergyLoss.cc.

{
  EnlossFlucFlag = value;
}

References G4hRDEnergyLoss::EnlossFlucFlag.

◆ SetGPILSelection()

void G4VContinuousDiscreteProcess::SetGPILSelection ( G4GPILSelection selection )

inlineprotectedinherited

Definition at line 106 of file G4VContinuousDiscreteProcess.hh.

107 { valueGPILSelection = selection; }

References G4VContinuousDiscreteProcess::valueGPILSelection.

◆ SetHighEnergyForAntiProtonParametrisation()

void G4hImpactIonisation::SetHighEnergyForAntiProtonParametrisation ( G4double energy )

inline

Definition at line 109 of file G4hImpactIonisation.hh.

109{antiprotonHighEnergy = energy;} ;

References antiprotonHighEnergy, and G4INCL::KinematicsUtils::energy().

◆ SetHighEnergyForProtonParametrisation()

void G4hImpactIonisation::SetHighEnergyForProtonParametrisation ( G4double energy )

inline

Definition at line 99 of file G4hImpactIonisation.hh.

99{protonHighEnergy = energy;} ;

References G4INCL::KinematicsUtils::energy(), and protonHighEnergy.

◆ SetLowEnergyForAntiProtonParametrisation()

void G4hImpactIonisation::SetLowEnergyForAntiProtonParametrisation ( G4double energy )

inline

Definition at line 114 of file G4hImpactIonisation.hh.

114{antiprotonLowEnergy = energy;} ;

References antiprotonLowEnergy, and G4INCL::KinematicsUtils::energy().

◆ SetLowEnergyForProtonParametrisation()

void G4hImpactIonisation::SetLowEnergyForProtonParametrisation ( G4double energy )

inline

Definition at line 104 of file G4hImpactIonisation.hh.

104{protonLowEnergy = energy;} ;

References G4INCL::KinematicsUtils::energy(), and protonLowEnergy.

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

◆ SetNuclearStoppingOff()

void G4hImpactIonisation::SetNuclearStoppingOff ( )

inline

Definition at line 141 of file G4hImpactIonisation.hh.

141{nStopping = false;};

References nStopping.

◆ SetNuclearStoppingOn()

void G4hImpactIonisation::SetNuclearStoppingOn ( )

inline

Definition at line 138 of file G4hImpactIonisation.hh.

138{nStopping = true;};

References nStopping.

Referenced by SetNuclearStoppingPowerModel().

◆ SetNuclearStoppingPowerModel()

void G4hImpactIonisation::SetNuclearStoppingPowerModel ( const G4String & dedxTable )

inline

Definition at line 130 of file G4hImpactIonisation.hh.

131 {theNuclearTable = dedxTable; SetNuclearStoppingOn();};

G4hImpactIonisation::SetNuclearStoppingOn

void SetNuclearStoppingOn()

Definition: G4hImpactIonisation.hh:138

References SetNuclearStoppingOn(), and theNuclearTable.

◆ SetNumberOfProcesses()

void G4hRDEnergyLoss::SetNumberOfProcesses ( G4int number )

staticinherited

Definition at line 197 of file G4hRDEnergyLoss.cc.

{
  NumberOfProcesses=number; 
} 

References G4hRDEnergyLoss::NumberOfProcesses.

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

◆ SetPixe()

void G4hImpactIonisation::SetPixe ( const G4bool )

inline

Definition at line 150 of file G4hImpactIonisation.hh.

150{pixeIsActive = true;};

G4hImpactIonisation::pixeIsActive

G4bool pixeIsActive

Definition: G4hImpactIonisation.hh:288

References pixeIsActive.

◆ SetPixeCrossSectionK()

void G4hImpactIonisation::SetPixeCrossSectionK ( const G4String & name )

inline

Definition at line 176 of file G4hImpactIonisation.hh.

176{ modelK = name; }

G4InuclParticleNames::name

const char * name(G4int ptype)

Definition: G4InuclParticleNames.hh:76

References modelK, and G4InuclParticleNames::name().

◆ SetPixeCrossSectionL()

void G4hImpactIonisation::SetPixeCrossSectionL ( const G4String & name )

inline

Definition at line 177 of file G4hImpactIonisation.hh.

177{ modelL = name; }

References modelL, and G4InuclParticleNames::name().

◆ SetPixeCrossSectionM()

void G4hImpactIonisation::SetPixeCrossSectionM ( const G4String & name )

inline

Definition at line 178 of file G4hImpactIonisation.hh.

178{ modelM = name; }

References modelM, and G4InuclParticleNames::name().

◆ SetPixeProjectileMaxEnergy()

void G4hImpactIonisation::SetPixeProjectileMaxEnergy ( G4double energy )

inline

Definition at line 180 of file G4hImpactIonisation.hh.

180{ eMaxPixe = energy; }

References eMaxPixe, and G4INCL::KinematicsUtils::energy().

◆ SetPixeProjectileMinEnergy()

void G4hImpactIonisation::SetPixeProjectileMinEnergy ( G4double energy )

inline

Definition at line 179 of file G4hImpactIonisation.hh.

179{ eMinPixe = energy; }

References eMinPixe, and G4INCL::KinematicsUtils::energy().

◆ SetProcessManager()

void G4VProcess::SetProcessManager ( const G4ProcessManager * procMan )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, and G4WrapperProcess.

Definition at line 488 of file G4VProcess.hh.

{
  aProcessManager = procMan; 
}

References G4VProcess::aProcessManager.

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

◆ SetProcessSubType()

void G4VProcess::SetProcessSubType ( G4int value )

inlineinherited

Definition at line 406 of file G4VProcess.hh.

{
  theProcessSubType = value;
}

References G4VProcess::theProcessSubType.

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

◆ SetProcessType()

void G4VProcess::SetProcessType ( G4ProcessType aType )

inlineinherited

Definition at line 394 of file G4VProcess.hh.

{
  theProcessType = aType;
}

References G4VProcess::theProcessType.

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

◆ SetProtonElectronicStoppingPowerModel()

void G4hImpactIonisation::SetProtonElectronicStoppingPowerModel ( const G4String & dedxTable )

inlineprivate

Definition at line 191 of file G4hImpactIonisation.hh.

192 {protonTable = dedxTable ;};

References protonTable.

Referenced by SetElectronicStoppingPowerModel().

◆ SetRndmStep()

void G4hRDEnergyLoss::SetRndmStep ( G4bool value )

staticinherited

Definition at line 225 of file G4hRDEnergyLoss.cc.

{
  rndmStepFlag = value;
}

References G4hRDEnergyLoss::rndmStepFlag.

◆ SetStepFunction()

void G4hRDEnergyLoss::SetStepFunction	(	G4double	c1,
		G4double	c2
	)

staticinherited

Definition at line 239 of file G4hRDEnergyLoss.cc.

{
  dRoverRange = c1; 
  finalRange = c2;
  c1lim=dRoverRange;
  c2lim=2.*(1-dRoverRange)*finalRange;
  c3lim=-(1.-dRoverRange)*finalRange*finalRange;
}

References G4hRDEnergyLoss::c1lim, G4hRDEnergyLoss::c2lim, G4hRDEnergyLoss::c3lim, G4hRDEnergyLoss::dRoverRange, and G4hRDEnergyLoss::finalRange.

◆ 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 G4VProcess::StartTracking ( G4Track * )

virtualinherited

Reimplemented in G4ParallelGeometriesLimiterProcess, G4ImportanceProcess, G4WeightCutOffProcess, G4WeightWindowProcess, G4VITProcess, G4DNASecondOrderReaction, G4WrapperProcess, G4FastSimulationManagerProcess, G4ParallelWorldProcess, G4ParallelWorldScoringProcess, G4ScoreSplittingProcess, G4GammaGeneralProcess, G4Decay, G4AdjointProcessEquivalentToDirectProcess, G4eAdjointMultipleScattering, G4DNAElectronHoleRecombination, G4DNAScavengerProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4ITTransportation, G4DNABrownianTransportation, G4CoupledTransportation, G4Transportation, G4BiasingProcessInterface, and G4VPhononProcess.

Definition at line 87 of file G4VProcess.cc.

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

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

Referenced by G4DNASecondOrderReaction::StartTracking(), G4WrapperProcess::StartTracking(), G4AdjointProcessEquivalentToDirectProcess::StartTracking(), G4DNAElectronHoleRecombination::StartTracking(), G4DNAScavengerProcess::StartTracking(), G4ITTransportation::StartTracking(), G4Transportation::StartTracking(), G4BiasingProcessInterface::StartTracking(), and G4VPhononProcess::StartTracking().

◆ StorePhysicsTable()

virtual G4bool G4VProcess::StorePhysicsTable	(	const G4ParticleDefinition *	,
		const G4String &	,
		G4bool
	)

inlinevirtualinherited

Reimplemented in G4WrapperProcess, G4GammaGeneralProcess, G4AdjointProcessEquivalentToDirectProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, and G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.hh.

207 { return true; }

Referenced by export_G4VProcess(), G4WrapperProcess::StorePhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::StorePhysicsTable(), and G4BiasingProcessInterface::StorePhysicsTable().

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

Field Documentation

◆ antiprotonHighEnergy

G4double G4hImpactIonisation::antiprotonHighEnergy

private

Definition at line 259 of file G4hImpactIonisation.hh.

Referenced by BuildLossTable(), ComputeDEDX(), GetConstraints(), InitializeMe(), PrintInfoDefinition(), and SetHighEnergyForAntiProtonParametrisation().

◆ antiprotonLowEnergy

G4double G4hImpactIonisation::antiprotonLowEnergy

private

Definition at line 258 of file G4hImpactIonisation.hh.

Referenced by AntiProtonParametrisedDEDX(), InitializeMe(), PrintInfoDefinition(), and SetLowEnergyForAntiProtonParametrisation().

◆ antiprotonModel

G4VLowEnergyModel* G4hImpactIonisation::antiprotonModel

private

Definition at line 242 of file G4hImpactIonisation.hh.

Referenced by AntiProtonParametrisedDEDX(), InitializeParametrisation(), and ~G4hImpactIonisation().

◆ antiprotonTable

G4String G4hImpactIonisation::antiprotonTable

private

Definition at line 252 of file G4hImpactIonisation.hh.

Referenced by InitializeParametrisation(), PrintInfoDefinition(), and SetAntiProtonElectronicStoppingPowerModel().

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

◆ atomicDeexcitation

G4AtomicDeexcitation G4hImpactIonisation::atomicDeexcitation

private

Definition at line 281 of file G4hImpactIonisation.hh.

Referenced by ActivateAugerElectronProduction(), and PostStepDoIt().

◆ betheBlochModel

G4VLowEnergyModel* G4hImpactIonisation::betheBlochModel

private

Definition at line 240 of file G4hImpactIonisation.hh.

Referenced by BuildLossTable(), InitializeParametrisation(), and ~G4hImpactIonisation().

◆ c1lim

G4ThreadLocal G4double G4hRDEnergyLoss::c1lim = 0.20

staticprotectedinherited

Definition at line 192 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::SetStepFunction().

◆ c2lim

G4ThreadLocal G4double G4hRDEnergyLoss::c2lim = 0.32

staticprotectedinherited

Definition at line 192 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::SetStepFunction().

◆ c3lim

G4ThreadLocal G4double G4hRDEnergyLoss::c3lim = -0.032

staticprotectedinherited

Definition at line 192 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::SetStepFunction().

◆ charge

G4double G4hImpactIonisation::charge

private

Definition at line 275 of file G4hImpactIonisation.hh.

Referenced by AlongStepDoIt(), BuildLambdaTable(), BuildLossTable(), BuildPhysicsTable(), ComputeDEDX(), GetConstraints(), and GetMeanFreePath().

◆ Charge

G4ThreadLocal G4double G4hRDEnergyLoss::Charge

staticprotectedinherited

Definition at line 172 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), G4hRDEnergyLoss::BuildRangeCoeffATable(), G4hRDEnergyLoss::BuildRangeCoeffBTable(), G4hRDEnergyLoss::BuildRangeCoeffCTable(), and G4hRDEnergyLoss::BuildRangeTable().

◆ chargeSquare

G4double G4hImpactIonisation::chargeSquare

private

Definition at line 276 of file G4hImpactIonisation.hh.

Referenced by AlongStepDoIt(), BuildLambdaTable(), BuildLossTable(), BuildPhysicsTable(), GetConstraints(), and GetMeanFreePath().

◆ CounterOfpbarProcess

G4ThreadLocal G4int G4hRDEnergyLoss::CounterOfpbarProcess = 0

staticprotectedinherited

Definition at line 163 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), and BuildPhysicsTable().

◆ CounterOfpProcess

G4ThreadLocal G4int G4hRDEnergyLoss::CounterOfpProcess = 0

staticprotectedinherited

Definition at line 162 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), and BuildPhysicsTable().

◆ CounterOfProcess

G4ThreadLocal G4int G4hRDEnergyLoss::CounterOfProcess = 0

staticprivateinherited

Definition at line 252 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable().

◆ currentInteractionLength

G4double G4VProcess::currentInteractionLength = -1.0

protectedinherited

Definition at line 335 of file G4VProcess.hh.

◆ cutForDelta

G4DataVector G4hImpactIonisation::cutForDelta

private

Definition at line 265 of file G4hImpactIonisation.hh.

Referenced by BuildLambdaTable(), BuildPhysicsTable(), DeltaRaysEnergy(), PostStepDoIt(), PrintInfoDefinition(), and ~G4hImpactIonisation().

◆ cutForGamma

G4DataVector G4hImpactIonisation::cutForGamma

private

Definition at line 266 of file G4hImpactIonisation.hh.

Referenced by BuildPhysicsTable().

◆ dRoverRange

G4ThreadLocal G4double G4hRDEnergyLoss::dRoverRange = 0.20

staticprotectedinherited

Definition at line 189 of file G4hRDEnergyLoss.hh.

Referenced by GetConstraints(), G4hRDEnergyLoss::SetdRoverRange(), and G4hRDEnergyLoss::SetStepFunction().

◆ eMaxPixe

G4double G4hImpactIonisation::eMaxPixe

private

Definition at line 286 of file G4hImpactIonisation.hh.

Referenced by InitializeMe(), PostStepDoIt(), and SetPixeProjectileMaxEnergy().

◆ eMinPixe

G4double G4hImpactIonisation::eMinPixe

private

Definition at line 285 of file G4hImpactIonisation.hh.

Referenced by InitializeMe(), PostStepDoIt(), and SetPixeProjectileMinEnergy().

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

◆ EnlossFlucFlag

G4ThreadLocal G4bool G4hRDEnergyLoss::EnlossFlucFlag = true

staticprotectedinherited

Definition at line 195 of file G4hRDEnergyLoss.hh.

Referenced by AlongStepDoIt(), and G4hRDEnergyLoss::SetEnlossFluc().

◆ fBarkas

G4double G4hImpactIonisation::fBarkas

private

Definition at line 278 of file G4hImpactIonisation.hh.

Referenced by AlongStepDoIt(), and GetConstraints().

◆ fdEdx

G4double G4hImpactIonisation::fdEdx

private

Definition at line 273 of file G4hImpactIonisation.hh.

Referenced by AlongStepDoIt(), and GetConstraints().

◆ finalRange

G4ThreadLocal G4double G4hRDEnergyLoss::finalRange = 0.2

staticprotectedinherited

Definition at line 191 of file G4hRDEnergyLoss.hh.

Referenced by GetConstraints(), and G4hRDEnergyLoss::SetStepFunction().

◆ fProcessTable

G4ProcessTable* G4VProcess::fProcessTable = nullptr

privateinherited

Definition at line 374 of file G4VProcess.hh.

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

◆ fRangeNow

G4double G4hImpactIonisation::fRangeNow

private

Definition at line 274 of file G4hImpactIonisation.hh.

Referenced by AlongStepDoIt(), and GetConstraints().

◆ HighestKineticEnergy

G4ThreadLocal G4double G4hRDEnergyLoss::HighestKineticEnergy = 1.e5

staticprotectedinherited

Definition at line 175 of file G4hRDEnergyLoss.hh.

Referenced by AlongStepDoIt(), G4hRDEnergyLoss::BuildDEDXTable(), BuildLambdaTable(), BuildLossTable(), BuildPhysicsTable(), G4hRDEnergyLoss::BuildRangeTable(), G4hRDEnergyLoss::BuildTimeTables(), GetMeanFreePath(), InitializeMe(), G4hRDEnergyLoss::InvertRangeVector(), and PrintInfoDefinition().

◆ initialMass

G4double G4hImpactIonisation::initialMass

private

Definition at line 277 of file G4hImpactIonisation.hh.

Referenced by BuildLambdaTable(), BuildPhysicsTable(), GetMeanFreePath(), and MicroscopicCrossSection().

◆ linLossLimit

G4double G4hRDEnergyLoss::linLossLimit

protectedinherited

Definition at line 185 of file G4hRDEnergyLoss.hh.

Referenced by AlongStepDoIt().

◆ LOGRTable

G4ThreadLocal G4double G4hRDEnergyLoss::LOGRTable

staticprotectedinherited

Definition at line 179 of file G4hRDEnergyLoss.hh.

◆ LowestKineticEnergy

G4ThreadLocal G4double G4hRDEnergyLoss::LowestKineticEnergy = 1e-05

staticprotectedinherited

Definition at line 174 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), BuildLambdaTable(), BuildLossTable(), BuildPhysicsTable(), G4hRDEnergyLoss::BuildRangeCoeffATable(), G4hRDEnergyLoss::BuildRangeCoeffBTable(), G4hRDEnergyLoss::BuildRangeCoeffCTable(), G4hRDEnergyLoss::BuildRangeTable(), G4hRDEnergyLoss::BuildTimeTables(), GetMeanFreePath(), InitializeMe(), G4hRDEnergyLoss::InvertRangeVector(), and PrintInfoDefinition().

◆ ltauhigh

G4ThreadLocal G4double G4hRDEnergyLoss::ltauhigh

staticprivateinherited

Definition at line 206 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildLabTimeVector(), G4hRDEnergyLoss::BuildProperTimeVector(), G4hRDEnergyLoss::LabTimeIntLog(), G4hRDEnergyLoss::ProperTimeIntLog(), and G4hRDEnergyLoss::RangeIntLog().

◆ ltaulow

G4ThreadLocal G4double G4hRDEnergyLoss::ltaulow

staticprivateinherited

Definition at line 206 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildLabTimeVector(), G4hRDEnergyLoss::BuildProperTimeVector(), G4hRDEnergyLoss::LabTimeIntLog(), G4hRDEnergyLoss::ProperTimeIntLog(), and G4hRDEnergyLoss::RangeIntLog().

◆ Mass

G4ThreadLocal G4double G4hRDEnergyLoss::Mass

staticprivateinherited

Definition at line 206 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildRangeTable(), G4hRDEnergyLoss::RangeIntLin(), and G4hRDEnergyLoss::RangeIntLog().

◆ masterProcessShadow

G4VProcess* G4VProcess::masterProcessShadow = nullptr

privateinherited

Definition at line 370 of file G4VProcess.hh.

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

◆ MaxExcitationNumber

const G4double G4hRDEnergyLoss::MaxExcitationNumber

protectedinherited

Definition at line 134 of file G4hRDEnergyLoss.hh.

◆ minElectronEnergy

G4double G4hImpactIonisation::minElectronEnergy

private

Definition at line 268 of file G4hImpactIonisation.hh.

Referenced by InitializeMe(), PostStepDoIt(), and SetCutForAugerElectrons().

◆ minGammaEnergy

G4double G4hImpactIonisation::minGammaEnergy

private

Definition at line 267 of file G4hImpactIonisation.hh.

Referenced by BuildPhysicsTable(), InitializeMe(), PostStepDoIt(), and SetCutForSecondaryPhotons().

◆ MinKineticEnergy

G4double G4hRDEnergyLoss::MinKineticEnergy

protectedinherited

Definition at line 187 of file G4hRDEnergyLoss.hh.

Referenced by AlongStepDoIt(), InitializeMe(), and PostStepDoIt().

◆ modelK

G4String G4hImpactIonisation::modelK

private

Definition at line 282 of file G4hImpactIonisation.hh.

Referenced by InitializeMe(), PostStepDoIt(), and SetPixeCrossSectionK().

◆ modelL

G4String G4hImpactIonisation::modelL

private

Definition at line 283 of file G4hImpactIonisation.hh.

Referenced by InitializeMe(), PostStepDoIt(), and SetPixeCrossSectionL().

◆ modelM

G4String G4hImpactIonisation::modelM

private

Definition at line 284 of file G4hImpactIonisation.hh.

Referenced by InitializeMe(), PostStepDoIt(), and SetPixeCrossSectionM().

◆ nmaxCont1

const long G4hRDEnergyLoss::nmaxCont1

protectedinherited

Definition at line 136 of file G4hRDEnergyLoss.hh.

◆ nmaxCont2

const long G4hRDEnergyLoss::nmaxCont2

protectedinherited

Definition at line 136 of file G4hRDEnergyLoss.hh.

◆ nmaxDirectFluct

const long G4hRDEnergyLoss::nmaxDirectFluct

protectedinherited

Definition at line 136 of file G4hRDEnergyLoss.hh.

◆ nStopping

G4bool G4hImpactIonisation::nStopping

private

Definition at line 262 of file G4hImpactIonisation.hh.

Referenced by AlongStepDoIt(), PrintInfoDefinition(), SetNuclearStoppingOff(), and SetNuclearStoppingOn().

◆ NumberOfProcesses

G4ThreadLocal G4int G4hRDEnergyLoss::NumberOfProcesses = 1

staticprivateinherited

Definition at line 264 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), G4hRDEnergyLoss::GetNumberOfProcesses(), G4hRDEnergyLoss::MinusNumberOfProcesses(), G4hRDEnergyLoss::PlusNumberOfProcesses(), and G4hRDEnergyLoss::SetNumberOfProcesses().

◆ paramStepLimit

const G4double G4hImpactIonisation::paramStepLimit

private

Definition at line 271 of file G4hImpactIonisation.hh.

Referenced by GetConstraints().

◆ ParticleMass

G4ThreadLocal G4double G4hRDEnergyLoss::ParticleMass

staticprotectedinherited

Definition at line 166 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), G4hRDEnergyLoss::BuildLabTimeVector(), G4hRDEnergyLoss::BuildProperTimeVector(), G4hRDEnergyLoss::LabTimeIntLog(), and G4hRDEnergyLoss::ProperTimeIntLog().

◆ pbartableElectronCutInRange

G4ThreadLocal G4double G4hRDEnergyLoss::pbartableElectronCutInRange = 0.0

staticprotectedinherited

Definition at line 170 of file G4hRDEnergyLoss.hh.

◆ pixeCrossSectionHandler

G4PixeCrossSectionHandler* G4hImpactIonisation::pixeCrossSectionHandler

private

Definition at line 280 of file G4hImpactIonisation.hh.

Referenced by PostStepDoIt(), and ~G4hImpactIonisation().

◆ pixeIsActive

G4bool G4hImpactIonisation::pixeIsActive

private

Definition at line 288 of file G4hImpactIonisation.hh.

Referenced by SetPixe().

◆ pParticleChange

G4VParticleChange* G4VProcess::pParticleChange = nullptr

protectedinherited

Definition at line 321 of file G4VProcess.hh.

◆ probLimFluct

const G4double G4hRDEnergyLoss::probLimFluct

protectedinherited

Definition at line 135 of file G4hRDEnergyLoss.hh.

◆ protonHighEnergy

G4double G4hImpactIonisation::protonHighEnergy

private

Definition at line 257 of file G4hImpactIonisation.hh.

Referenced by AlongStepDoIt(), BuildLossTable(), ComputeDEDX(), GetConstraints(), InitializeMe(), InitializeParametrisation(), PrintInfoDefinition(), and SetHighEnergyForProtonParametrisation().

◆ protonLowEnergy

G4double G4hImpactIonisation::protonLowEnergy

private

Definition at line 256 of file G4hImpactIonisation.hh.

Referenced by AntiProtonParametrisedDEDX(), InitializeMe(), PrintInfoDefinition(), ProtonParametrisedDEDX(), and SetLowEnergyForProtonParametrisation().

◆ protonModel

G4VLowEnergyModel* G4hImpactIonisation::protonModel

private

Definition at line 241 of file G4hImpactIonisation.hh.

Referenced by AntiProtonParametrisedDEDX(), InitializeParametrisation(), ProtonParametrisedDEDX(), and ~G4hImpactIonisation().

◆ protonTable

G4String G4hImpactIonisation::protonTable

private

Definition at line 251 of file G4hImpactIonisation.hh.

Referenced by InitializeParametrisation(), PrintInfoDefinition(), and SetProtonElectronicStoppingPowerModel().

◆ ptableElectronCutInRange

G4ThreadLocal G4double G4hRDEnergyLoss::ptableElectronCutInRange = 0.0

staticprotectedinherited

Definition at line 169 of file G4hRDEnergyLoss.hh.

◆ RecorderOfpbarProcess

G4ThreadLocal G4PhysicsTable ** G4hRDEnergyLoss::RecorderOfpbarProcess = 0

staticprotectedinherited

Definition at line 161 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), BuildPhysicsTable(), and G4hRDEnergyLoss::G4hRDEnergyLoss().

◆ RecorderOfpProcess

G4ThreadLocal G4PhysicsTable ** G4hRDEnergyLoss::RecorderOfpProcess = 0

staticprotectedinherited

Definition at line 160 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), BuildPhysicsTable(), and G4hRDEnergyLoss::G4hRDEnergyLoss().

◆ RecorderOfProcess

G4ThreadLocal G4PhysicsTable ** G4hRDEnergyLoss::RecorderOfProcess = 0

staticprivateinherited

Definition at line 251 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), and G4hRDEnergyLoss::G4hRDEnergyLoss().

◆ rndmStepFlag

G4ThreadLocal G4bool G4hRDEnergyLoss::rndmStepFlag = false

staticprotectedinherited

Definition at line 194 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::SetRndmStep().

◆ RTable

G4ThreadLocal G4double G4hRDEnergyLoss::RTable

staticprotectedinherited

Definition at line 179 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildRangeCoeffATable(), G4hRDEnergyLoss::BuildRangeCoeffBTable(), G4hRDEnergyLoss::BuildRangeCoeffCTable(), and G4hRDEnergyLoss::InvertRangeVector().

◆ tauhigh

G4ThreadLocal G4double G4hRDEnergyLoss::tauhigh

staticprivateinherited

Definition at line 206 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::RangeIntLin().

◆ taulow

G4ThreadLocal G4double G4hRDEnergyLoss::taulow

staticprivateinherited

Definition at line 206 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::RangeIntLin().

◆ theBarkas

G4bool G4hImpactIonisation::theBarkas

private

Definition at line 263 of file G4hImpactIonisation.hh.

Referenced by GetConstraints(), PrintInfoDefinition(), SetBarkasOff(), and SetBarkasOn().

◆ theDEDXpbarTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theDEDXpbarTable = 0

staticprotectedinherited

Definition at line 143 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), and G4hRDEnergyLoss::BuildInverseRangeTable().

◆ theDEDXpTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theDEDXpTable = 0

staticprotectedinherited

Definition at line 142 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), G4hRDEnergyLoss::BuildInverseRangeTable(), and BuildPhysicsTable().

◆ theDEDXTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theDEDXTable = 0

staticprivateinherited

Definition at line 243 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), and G4hRDEnergyLoss::BuildInverseRangeTable().

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

◆ theInverseRangepbarTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theInverseRangepbarTable = 0

staticprotectedinherited

Definition at line 149 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), and G4hRDEnergyLoss::BuildInverseRangeTable().

◆ theInverseRangepTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theInverseRangepTable = 0

staticprotectedinherited

Definition at line 148 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), G4hRDEnergyLoss::BuildInverseRangeTable(), and BuildPhysicsTable().

◆ theInverseRangeTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theInverseRangeTable = 0

staticprivateinherited

Definition at line 246 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildInverseRangeTable().

◆ theIonChuFluctuationModel

G4VLowEnergyModel* G4hImpactIonisation::theIonChuFluctuationModel

private

Definition at line 245 of file G4hImpactIonisation.hh.

Referenced by InitializeParametrisation(), and ~G4hImpactIonisation().

◆ theIonEffChargeModel

G4VLowEnergyModel* G4hImpactIonisation::theIonEffChargeModel

private

Definition at line 243 of file G4hImpactIonisation.hh.

Referenced by BuildPhysicsTable(), ComputeDEDX(), GetMeanFreePath(), InitializeParametrisation(), and ~G4hImpactIonisation().

◆ theIonYangFluctuationModel

G4VLowEnergyModel* G4hImpactIonisation::theIonYangFluctuationModel

private

Definition at line 246 of file G4hImpactIonisation.hh.

Referenced by InitializeParametrisation(), and ~G4hImpactIonisation().

◆ theLabTimepbarTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theLabTimepbarTable = 0

staticprotectedinherited

Definition at line 153 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), and G4hRDEnergyLoss::BuildTimeTables().

◆ theLabTimepTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theLabTimepTable = 0

staticprotectedinherited

Definition at line 152 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), BuildPhysicsTable(), and G4hRDEnergyLoss::BuildTimeTables().

◆ theLabTimeTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theLabTimeTable = 0

staticprivateinherited

Definition at line 248 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildTimeTables().

◆ theLossTable

G4PhysicsTable* G4hRDEnergyLoss::theLossTable

protectedinherited

Definition at line 183 of file G4hRDEnergyLoss.hh.

Referenced by BuildLossTable(), BuildPhysicsTable(), and G4hRDEnergyLoss::~G4hRDEnergyLoss().

◆ theMeanFreePathTable

G4PhysicsTable* G4hImpactIonisation::theMeanFreePathTable

private

Definition at line 269 of file G4hImpactIonisation.hh.

Referenced by BuildLambdaTable(), BuildPhysicsTable(), and ~G4hImpactIonisation().

◆ theNuclearStoppingModel

G4VLowEnergyModel* G4hImpactIonisation::theNuclearStoppingModel

private

Definition at line 244 of file G4hImpactIonisation.hh.

Referenced by AlongStepDoIt(), InitializeParametrisation(), and ~G4hImpactIonisation().

◆ theNuclearTable

G4String G4hImpactIonisation::theNuclearTable

private

Definition at line 253 of file G4hImpactIonisation.hh.

Referenced by InitializeParametrisation(), PrintInfoDefinition(), and SetNuclearStoppingPowerModel().

◆ theNumberOfInteractionLengthLeft

G4double G4VProcess::theNumberOfInteractionLengthLeft = -1.0

protectedinherited

Definition at line 331 of file G4VProcess.hh.

◆ thepbarRangeCoeffATable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::thepbarRangeCoeffATable = 0

staticprivateinherited

Definition at line 257 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildInverseRangeTable(), and G4hRDEnergyLoss::BuildRangeCoeffATable().

◆ thepbarRangeCoeffBTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::thepbarRangeCoeffBTable = 0

staticprivateinherited

Definition at line 258 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildInverseRangeTable(), and G4hRDEnergyLoss::BuildRangeCoeffBTable().

◆ thepbarRangeCoeffCTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::thepbarRangeCoeffCTable = 0

staticprivateinherited

Definition at line 259 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildInverseRangeTable(), and G4hRDEnergyLoss::BuildRangeCoeffCTable().

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

◆ thepRangeCoeffATable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::thepRangeCoeffATable = 0

staticprivateinherited

Definition at line 254 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildInverseRangeTable(), and G4hRDEnergyLoss::BuildRangeCoeffATable().

◆ thepRangeCoeffBTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::thepRangeCoeffBTable = 0

staticprivateinherited

Definition at line 255 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildInverseRangeTable(), and G4hRDEnergyLoss::BuildRangeCoeffBTable().

◆ thepRangeCoeffCTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::thepRangeCoeffCTable = 0

staticprivateinherited

Definition at line 256 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildInverseRangeTable(), and G4hRDEnergyLoss::BuildRangeCoeffCTable().

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

◆ theProperTimepbarTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theProperTimepbarTable = 0

staticprotectedinherited

Definition at line 156 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), and G4hRDEnergyLoss::BuildTimeTables().

◆ theProperTimepTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theProperTimepTable = 0

staticprotectedinherited

Definition at line 155 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), BuildPhysicsTable(), and G4hRDEnergyLoss::BuildTimeTables().

◆ theProperTimeTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theProperTimeTable = 0

staticprivateinherited

Definition at line 249 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildTimeTables().

◆ theRangeCoeffATable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangeCoeffATable = 0

staticprivateinherited

Definition at line 261 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildInverseRangeTable(), and G4hRDEnergyLoss::BuildRangeCoeffATable().

◆ theRangeCoeffBTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangeCoeffBTable = 0

staticprivateinherited

Definition at line 262 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildInverseRangeTable(), and G4hRDEnergyLoss::BuildRangeCoeffBTable().

◆ theRangeCoeffCTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangeCoeffCTable = 0

staticprivateinherited

Definition at line 263 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildInverseRangeTable(), and G4hRDEnergyLoss::BuildRangeCoeffCTable().

◆ theRangepbarTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangepbarTable = 0

staticprotectedinherited

Definition at line 145 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), G4hRDEnergyLoss::BuildInverseRangeTable(), G4hRDEnergyLoss::BuildRangeCoeffATable(), G4hRDEnergyLoss::BuildRangeCoeffBTable(), G4hRDEnergyLoss::BuildRangeCoeffCTable(), and G4hRDEnergyLoss::BuildRangeTable().

◆ theRangepTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangepTable = 0

staticprotectedinherited

Definition at line 144 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildDEDXTable(), G4hRDEnergyLoss::BuildInverseRangeTable(), BuildPhysicsTable(), G4hRDEnergyLoss::BuildRangeCoeffATable(), G4hRDEnergyLoss::BuildRangeCoeffBTable(), G4hRDEnergyLoss::BuildRangeCoeffCTable(), and G4hRDEnergyLoss::BuildRangeTable().

◆ theRangeTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangeTable = 0

staticprivateinherited

Definition at line 245 of file G4hRDEnergyLoss.hh.

Referenced by G4hRDEnergyLoss::BuildInverseRangeTable(), G4hRDEnergyLoss::BuildRangeCoeffATable(), G4hRDEnergyLoss::BuildRangeCoeffBTable(), G4hRDEnergyLoss::BuildRangeCoeffCTable(), and G4hRDEnergyLoss::BuildRangeTable().

◆ TotBin

G4ThreadLocal G4int G4hRDEnergyLoss::TotBin = 360

staticprotectedinherited

Definition at line 176 of file G4hRDEnergyLoss.hh.

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

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

source/processes/electromagnetic/pii/include/G4hImpactIonisation.hh
source/processes/electromagnetic/pii/src/G4hImpactIonisation.cc

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4hImpactIonisation() [1/2]

◆ ~G4hImpactIonisation()

◆ G4hImpactIonisation() [2/2]

Member Function Documentation

◆ ActivateAugerElectronProduction()

◆ AlongStepDoIt()

◆ AlongStepGetPhysicalInteractionLength()

◆ AlongStepGPIL()

◆ AntiProtonParametrisedDEDX()

◆ AtRestDoIt()

◆ AtRestGetPhysicalInteractionLength()

◆ AtRestGPIL()

◆ BarkasTerm()

◆ BlochTerm()

◆ BuildDEDXTable()

◆ BuildInverseRangeTable()

◆ BuildLabTimeVector()

◆ BuildLambdaTable()

◆ BuildLossTable()

◆ BuildPhysicsTable()

◆ BuildProperTimeVector()

◆ BuildRangeCoeffATable()

◆ BuildRangeCoeffBTable()

◆ BuildRangeCoeffCTable()

◆ BuildRangeTable()

◆ BuildRangeVector()

◆ BuildTimeTables()

◆ BuildWorkerPhysicsTable()

◆ ClearNumberOfInteractionLengthLeft()

◆ ComputeDEDX()

◆ CutsWhereModified()

◆ DeltaRaysEnergy()

◆ DumpInfo()

◆ ElectronicLossFluctuation()

◆ EndTracking()

◆ GetConstraints()

◆ GetContinuousStepLimit()

◆ GetCurrentInteractionLength()

◆ GetGPILSelection()

◆ GetMasterProcess()

◆ GetMeanFreePath()

◆ GetNumberOfInteractionLengthLeft()

◆ GetNumberOfProcesses()

◆ GetPhysicsTableFileName()

◆ GetPILfactor()

◆ GetProcessManager()

◆ GetProcessName()

◆ GetProcessSubType()

◆ GetProcessType()

◆ GetProcessTypeName()

◆ GetTotalNumberOfInteractionLengthTraversed()

◆ GetVerboseLevel()

◆ InitializeMe()

◆ InitializeParametrisation()

◆ InvertRangeVector()

◆ isAlongStepDoItIsEnabled()

◆ IsApplicable()

◆ isAtRestDoItIsEnabled()

◆ isPostStepDoItIsEnabled()

◆ LabTimeIntLog()

◆ MicroscopicCrossSection()

◆ MinusNumberOfProcesses()

◆ operator!=()

◆ operator=()

◆ operator==()

◆ PlusNumberOfProcesses()

◆ PostStepDoIt()

◆ PostStepGetPhysicalInteractionLength()