#include <G4hRDEnergyLoss.hh>

Inheritance diagram for G4hRDEnergyLoss:

Public Member Functions
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &)

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)

virtual void	BuildPhysicsTable (const G4ParticleDefinition &)

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

virtual void	DumpInfo () const

virtual void	EndTracking ()

	G4hRDEnergyLoss (const G4String &)

G4double	GetCurrentInteractionLength () const

const G4VProcess *	GetMasterProcess () const

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

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

virtual G4bool	IsApplicable (const G4ParticleDefinition &)

G4bool	isAtRestDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

G4bool	operator!= (const G4VProcess &right) const

G4bool	operator== (const G4VProcess &right) const

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

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

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

virtual void	ResetNumberOfInteractionLengthLeft ()

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

virtual void	SetMasterProcess (G4VProcess *masterP)

void	SetPILfactor (G4double value)

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)

	~G4hRDEnergyLoss ()

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

virtual G4double	GetContinuousStepLimit (const G4Track &aTrack, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety)=0

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
	G4hRDEnergyLoss (G4hRDEnergyLoss &)

G4hRDEnergyLoss &	operator= (const G4hRDEnergyLoss &right)

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
G4ProcessTable *	fProcessTable = nullptr

G4VProcess *	masterProcessShadow = nullptr

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 91 of file G4hRDEnergyLoss.hh.

Constructor & Destructor Documentation

◆ G4hRDEnergyLoss() [1/2]

G4hRDEnergyLoss::G4hRDEnergyLoss ( const G4String & processName )

Definition at line 161 of file G4hRDEnergyLoss.cc.

  : G4VContinuousDiscreteProcess (processName),
    MaxExcitationNumber (1.e6),
    probLimFluct (0.01),
    nmaxDirectFluct (100),
    nmaxCont1(4),
    nmaxCont2(16),
    theLossTable(0),
    linLossLimit(0.05),
    MinKineticEnergy(0.0) 
{
  if (!RecorderOfpbarProcess) RecorderOfpbarProcess = new G4PhysicsTable*[100];
  if (!RecorderOfpProcess) RecorderOfpProcess = new G4PhysicsTable*[100];
  if (!RecorderOfProcess) RecorderOfProcess = new G4PhysicsTable*[100];
}

References RecorderOfpbarProcess, RecorderOfpProcess, and RecorderOfProcess.

◆ ~G4hRDEnergyLoss()

G4hRDEnergyLoss::~G4hRDEnergyLoss ( )

Definition at line 179 of file G4hRDEnergyLoss.cc.

{
  if(theLossTable)
  {
    theLossTable->clearAndDestroy();
    delete theLossTable;
  }
}

References G4PhysicsTable::clearAndDestroy(), and theLossTable.

◆ G4hRDEnergyLoss() [2/2]

G4hRDEnergyLoss::G4hRDEnergyLoss ( G4hRDEnergyLoss & )

private

Member Function Documentation

◆ AlongStepDoIt()

G4VParticleChange * G4VContinuousDiscreteProcess::AlongStepDoIt	(	const G4Track &	,
		const G4Step &
	)

virtualinherited

Implements G4VProcess.

Reimplemented in G4VEnergyLossProcess, G4VMultipleScattering, G4AdjointForcedInteractionForGamma, and G4hImpactIonisation.

Definition at line 133 of file G4VContinuousDiscreteProcess.cc.

{ 
  // clear  NumberOfInteractionLengthLeft
  ClearNumberOfInteractionLengthLeft();
 
  return pParticleChange;
}

References G4VProcess::ClearNumberOfInteractionLengthLeft(), and G4VProcess::pParticleChange.

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

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

◆ BuildDEDXTable()

void G4hRDEnergyLoss::BuildDEDXTable ( const G4ParticleDefinition & aParticleType )

staticprotected

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

Referenced by G4hImpactIonisation::BuildPhysicsTable().

◆ BuildInverseRangeTable()

void G4hRDEnergyLoss::BuildInverseRangeTable ( const G4ParticleDefinition & aParticleType )

staticprivate

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

References G4AntiProton::AntiProton(), G4PhysicsTable::clearAndDestroy(), DBL_MIN, G4PhysicsVector::GetLowEdgeEnergy(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4PhysicsVector::GetValue(), G4PhysicsVector::GetVectorLength(), G4PhysicsTable::insert(), G4Proton::Proton(), G4PhysicsVector::PutValue(), theDEDXpbarTable, theDEDXpTable, theDEDXTable, theInverseRangepbarTable, theInverseRangepTable, theInverseRangeTable, thepbarRangeCoeffATable, thepbarRangeCoeffBTable, thepbarRangeCoeffCTable, thepRangeCoeffATable, thepRangeCoeffBTable, thepRangeCoeffCTable, theRangeCoeffATable, theRangeCoeffBTable, theRangeCoeffCTable, theRangepbarTable, theRangepTable, and theRangeTable.

Referenced by BuildDEDXTable().

◆ BuildLabTimeVector()

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

staticprivate

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, LabTimeIntLog(), ltauhigh, ltaulow, ParticleMass, G4PhysicsVector::PutValue(), and TotBin.

Referenced by BuildTimeTables().

◆ BuildPhysicsTable()

virtual void G4VProcess::BuildPhysicsTable ( const G4ParticleDefinition & )

inlinevirtualinherited

Reimplemented in G4ITTransportation, G4VITProcess, G4DNABrownianTransportation, G4DNASecondOrderReaction, G4RadioactiveDecay, G4HadronStoppingProcess, G4MuonMinusAtomicCapture, G4WrapperProcess, G4Channeling, G4GammaGeneralProcess, G4Decay, G4UnknownDecay, G4AdjointForcedInteractionForGamma, G4AdjointProcessEquivalentToDirectProcess, G4VAdjointReverseReaction, G4DNAElectronHoleRecombination, G4DNAScavengerProcess, G4AnnihiToMuPair, G4GammaConversionToMuons, G4LowECapture, G4MicroElecSurface, G4PolarizedAnnihilation, G4PolarizedCompton, G4PolarizedIonisation, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4SynchrotronRadiation, G4VXTRenergyLoss, G4HadronicProcess, G4hImpactIonisation, G4ChargeExchangeProcess, G4Cerenkov, G4Scintillation, G4OpRayleigh, G4OpWLS, G4OpWLS2, and G4BiasingProcessInterface.

Definition at line 187 of file G4VProcess.hh.

187{}

Referenced by G4VUserPhysicsList::BuildIntegralPhysicsTable(), G4WrapperProcess::BuildPhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::BuildPhysicsTable(), G4BiasingProcessInterface::BuildPhysicsTable(), G4VProcess::BuildWorkerPhysicsTable(), and export_G4VProcess().

◆ BuildProperTimeVector()

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

staticprivate

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, ltauhigh, ltaulow, ParticleMass, ProperTimeIntLog(), G4PhysicsVector::PutValue(), and TotBin.

Referenced by BuildTimeTables().

◆ BuildRangeCoeffATable()

void G4hRDEnergyLoss::BuildRangeCoeffATable ( const G4ParticleDefinition & aParticleType )

staticprivate

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 Charge, G4PhysicsTable::clearAndDestroy(), DBL_MIN, G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4PhysicsVector::GetValue(), G4PhysicsTable::insert(), LowestKineticEnergy, G4PhysicsVector::PutValue(), RTable, thepbarRangeCoeffATable, thepRangeCoeffATable, theRangeCoeffATable, theRangepbarTable, theRangepTable, theRangeTable, and TotBin.

Referenced by BuildDEDXTable().

◆ BuildRangeCoeffBTable()

void G4hRDEnergyLoss::BuildRangeCoeffBTable ( const G4ParticleDefinition & aParticleType )

staticprivate

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 Charge, G4PhysicsTable::clearAndDestroy(), DBL_MIN, G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4PhysicsVector::GetValue(), G4PhysicsTable::insert(), LowestKineticEnergy, G4PhysicsVector::PutValue(), RTable, thepbarRangeCoeffBTable, thepRangeCoeffBTable, theRangeCoeffBTable, theRangepbarTable, theRangepTable, theRangeTable, and TotBin.

Referenced by BuildDEDXTable().

◆ BuildRangeCoeffCTable()

void G4hRDEnergyLoss::BuildRangeCoeffCTable ( const G4ParticleDefinition & aParticleType )

staticprivate

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 Charge, G4PhysicsTable::clearAndDestroy(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4PhysicsVector::GetValue(), G4PhysicsTable::insert(), LowestKineticEnergy, G4PhysicsVector::PutValue(), RTable, thepbarRangeCoeffCTable, thepRangeCoeffCTable, theRangeCoeffCTable, theRangepbarTable, theRangepTable, theRangeTable, and TotBin.

Referenced by BuildDEDXTable().

◆ BuildRangeTable()

void G4hRDEnergyLoss::BuildRangeTable ( const G4ParticleDefinition & aParticleType )

staticprivate

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 BuildRangeVector(), Charge, G4PhysicsTable::clearAndDestroy(), G4ParticleDefinition::GetPDGMass(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), HighestKineticEnergy, G4PhysicsTable::insert(), LowestKineticEnergy, Mass, theRangepbarTable, theRangepTable, theRangeTable, and TotBin.

Referenced by BuildDEDXTable().

◆ BuildRangeVector()

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

staticprivate

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

Referenced by BuildRangeTable().

◆ BuildTimeTables()

void G4hRDEnergyLoss::BuildTimeTables ( const G4ParticleDefinition & aParticleType )

staticprivate

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(), BuildLabTimeVector(), BuildProperTimeVector(), G4PhysicsTable::clearAndDestroy(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), HighestKineticEnergy, G4PhysicsTable::insert(), LowestKineticEnergy, G4Proton::Proton(), theLabTimepbarTable, theLabTimepTable, theLabTimeTable, theProperTimepbarTable, theProperTimepTable, theProperTimeTable, and TotBin.

Referenced by 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.

◆ CutsWhereModified()

G4bool G4hRDEnergyLoss::CutsWhereModified ( )

protected

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 G4hImpactIonisation::BuildPhysicsTable().

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

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

◆ GetContinuousStepLimit()

virtual G4double G4VContinuousDiscreteProcess::GetContinuousStepLimit	(	const G4Track &	aTrack,
		G4double	previousStepSize,
		G4double	currentMinimumStep,
		G4double &	currentSafety
	)

protectedpure virtualinherited

Implemented in G4AdjointForcedInteractionForGamma, G4VMultipleScattering, G4hImpactIonisation, and G4VEnergyLossProcess.

Referenced by G4VContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength().

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

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

pure virtual

Implements G4VContinuousDiscreteProcess.

Implemented in G4hImpactIonisation.

◆ GetNumberOfInteractionLengthLeft()

G4double G4VProcess::GetNumberOfInteractionLengthLeft ( ) const

inlineinherited

Definition at line 431 of file G4VProcess.hh.

{
  return theNumberOfInteractionLengthLeft;
}

References G4VProcess::theNumberOfInteractionLengthLeft.

◆ GetNumberOfProcesses()

G4int G4hRDEnergyLoss::GetNumberOfProcesses ( )

static

Definition at line 190 of file G4hRDEnergyLoss.cc.

{
  return NumberOfProcesses; 
} 

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

◆ InvertRangeVector()

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

staticprivate

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(), HighestKineticEnergy, LowestKineticEnergy, G4PhysicsVector::PutValue(), RTable, and 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()

virtual G4bool G4VProcess::IsApplicable ( const G4ParticleDefinition & )

inlinevirtualinherited

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

Definition at line 182 of file G4VProcess.hh.

182{ return true; }

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

◆ isAtRestDoItIsEnabled()

G4bool G4VProcess::isAtRestDoItIsEnabled ( ) const

inlineinherited

Definition at line 500 of file G4VProcess.hh.

{
  return enableAtRestDoIt;
}

References G4VProcess::enableAtRestDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

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

staticprivate

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(), ltauhigh, ltaulow, and ParticleMass.

Referenced by BuildLabTimeVector().

◆ MinusNumberOfProcesses()

void G4hRDEnergyLoss::MinusNumberOfProcesses ( )

static

Definition at line 211 of file G4hRDEnergyLoss.cc.

{
  NumberOfProcesses--; 
} 

References NumberOfProcesses.

◆ operator!=()

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

inherited

Definition at line 161 of file G4VProcess.cc.

{
  return (this !=  &right);
}

◆ operator=()

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

static

Definition at line 204 of file G4hRDEnergyLoss.cc.

{
  NumberOfProcesses++; 
} 

References NumberOfProcesses.

◆ PostStepDoIt()

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

pure virtual

Reimplemented from G4VContinuousDiscreteProcess.

Implemented in G4hImpactIonisation.

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

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

staticprivate

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(), ltauhigh, ltaulow, and ParticleMass.

Referenced by BuildProperTimeVector().

◆ RangeIntLin()

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

staticprivate

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(), Mass, tauhigh, and taulow.

◆ RangeIntLog()

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

staticprivate

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(), ltauhigh, ltaulow, and 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().

◆ SetdRoverRange()

void G4hRDEnergyLoss::SetdRoverRange ( G4double value )

static

Definition at line 218 of file G4hRDEnergyLoss.cc.

{
  dRoverRange = value;
}

References dRoverRange.

◆ SetEnlossFluc()

void G4hRDEnergyLoss::SetEnlossFluc ( G4bool value )

static

Definition at line 232 of file G4hRDEnergyLoss.cc.

{
  EnlossFlucFlag = value;
}

References EnlossFlucFlag.

◆ SetGPILSelection()

void G4VContinuousDiscreteProcess::SetGPILSelection ( G4GPILSelection selection )

inlineprotectedinherited

Definition at line 106 of file G4VContinuousDiscreteProcess.hh.

107 { valueGPILSelection = selection; }

References G4VContinuousDiscreteProcess::valueGPILSelection.

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

◆ SetNumberOfProcesses()

void G4hRDEnergyLoss::SetNumberOfProcesses ( G4int number )

static

Definition at line 197 of file G4hRDEnergyLoss.cc.

{
  NumberOfProcesses=number; 
} 

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

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

◆ SetRndmStep()

void G4hRDEnergyLoss::SetRndmStep ( G4bool value )

static

Definition at line 225 of file G4hRDEnergyLoss.cc.

{
  rndmStepFlag = value;
}

References rndmStepFlag.

◆ SetStepFunction()

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

static

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 c1lim, c2lim, c3lim, dRoverRange, and 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

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

◆ c1lim

G4ThreadLocal G4double G4hRDEnergyLoss::c1lim = 0.20

staticprotected

Definition at line 192 of file G4hRDEnergyLoss.hh.

Referenced by SetStepFunction().

◆ c2lim

G4ThreadLocal G4double G4hRDEnergyLoss::c2lim = 0.32

staticprotected

Definition at line 192 of file G4hRDEnergyLoss.hh.

Referenced by SetStepFunction().

◆ c3lim

G4ThreadLocal G4double G4hRDEnergyLoss::c3lim = -0.032

staticprotected

Definition at line 192 of file G4hRDEnergyLoss.hh.

Referenced by SetStepFunction().

◆ Charge

G4ThreadLocal G4double G4hRDEnergyLoss::Charge

staticprotected

Definition at line 172 of file G4hRDEnergyLoss.hh.

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

◆ CounterOfpbarProcess

G4ThreadLocal G4int G4hRDEnergyLoss::CounterOfpbarProcess = 0

staticprotected

Definition at line 163 of file G4hRDEnergyLoss.hh.

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

◆ CounterOfpProcess

G4ThreadLocal G4int G4hRDEnergyLoss::CounterOfpProcess = 0

staticprotected

Definition at line 162 of file G4hRDEnergyLoss.hh.

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

◆ CounterOfProcess

G4ThreadLocal G4int G4hRDEnergyLoss::CounterOfProcess = 0

staticprivate

Definition at line 252 of file G4hRDEnergyLoss.hh.

Referenced by BuildDEDXTable().

◆ currentInteractionLength

G4double G4VProcess::currentInteractionLength = -1.0

protectedinherited

Definition at line 335 of file G4VProcess.hh.

◆ dRoverRange

G4ThreadLocal G4double G4hRDEnergyLoss::dRoverRange = 0.20

staticprotected

Definition at line 189 of file G4hRDEnergyLoss.hh.

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

◆ 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

staticprotected

Definition at line 195 of file G4hRDEnergyLoss.hh.

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

◆ finalRange

G4ThreadLocal G4double G4hRDEnergyLoss::finalRange = 0.2

staticprotected

Definition at line 191 of file G4hRDEnergyLoss.hh.

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

◆ fProcessTable

G4ProcessTable* G4VProcess::fProcessTable = nullptr

privateinherited

Definition at line 374 of file G4VProcess.hh.

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

◆ HighestKineticEnergy

G4ThreadLocal G4double G4hRDEnergyLoss::HighestKineticEnergy = 1.e5

staticprotected

Definition at line 175 of file G4hRDEnergyLoss.hh.

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

◆ linLossLimit

G4double G4hRDEnergyLoss::linLossLimit

protected

Definition at line 185 of file G4hRDEnergyLoss.hh.

Referenced by G4hImpactIonisation::AlongStepDoIt().

◆ LOGRTable

G4ThreadLocal G4double G4hRDEnergyLoss::LOGRTable

staticprotected

Definition at line 179 of file G4hRDEnergyLoss.hh.

◆ LowestKineticEnergy

G4ThreadLocal G4double G4hRDEnergyLoss::LowestKineticEnergy = 1e-05

staticprotected

Definition at line 174 of file G4hRDEnergyLoss.hh.

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

◆ ltauhigh

G4ThreadLocal G4double G4hRDEnergyLoss::ltauhigh

staticprivate

Definition at line 206 of file G4hRDEnergyLoss.hh.

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

◆ ltaulow

G4ThreadLocal G4double G4hRDEnergyLoss::ltaulow

staticprivate

Definition at line 206 of file G4hRDEnergyLoss.hh.

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

◆ Mass

G4ThreadLocal G4double G4hRDEnergyLoss::Mass

staticprivate

Definition at line 206 of file G4hRDEnergyLoss.hh.

Referenced by BuildRangeTable(), RangeIntLin(), and 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

protected

Definition at line 134 of file G4hRDEnergyLoss.hh.

◆ MinKineticEnergy

G4double G4hRDEnergyLoss::MinKineticEnergy

protected

Definition at line 187 of file G4hRDEnergyLoss.hh.

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

◆ nmaxCont1

const long G4hRDEnergyLoss::nmaxCont1

protected

Definition at line 136 of file G4hRDEnergyLoss.hh.

◆ nmaxCont2

const long G4hRDEnergyLoss::nmaxCont2

protected

Definition at line 136 of file G4hRDEnergyLoss.hh.

◆ nmaxDirectFluct

const long G4hRDEnergyLoss::nmaxDirectFluct

protected

Definition at line 136 of file G4hRDEnergyLoss.hh.

◆ NumberOfProcesses

G4ThreadLocal G4int G4hRDEnergyLoss::NumberOfProcesses = 1

staticprivate

Definition at line 264 of file G4hRDEnergyLoss.hh.

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

◆ ParticleMass

G4ThreadLocal G4double G4hRDEnergyLoss::ParticleMass

staticprotected

Definition at line 166 of file G4hRDEnergyLoss.hh.

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

◆ pbartableElectronCutInRange

G4ThreadLocal G4double G4hRDEnergyLoss::pbartableElectronCutInRange = 0.0

staticprotected

Definition at line 170 of file G4hRDEnergyLoss.hh.

◆ pParticleChange

G4VParticleChange* G4VProcess::pParticleChange = nullptr

protectedinherited

Definition at line 321 of file G4VProcess.hh.

◆ probLimFluct

const G4double G4hRDEnergyLoss::probLimFluct

protected

Definition at line 135 of file G4hRDEnergyLoss.hh.

◆ ptableElectronCutInRange

G4ThreadLocal G4double G4hRDEnergyLoss::ptableElectronCutInRange = 0.0

staticprotected

Definition at line 169 of file G4hRDEnergyLoss.hh.

◆ RecorderOfpbarProcess

G4ThreadLocal G4PhysicsTable ** G4hRDEnergyLoss::RecorderOfpbarProcess = 0

staticprotected

Definition at line 161 of file G4hRDEnergyLoss.hh.

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

◆ RecorderOfpProcess

G4ThreadLocal G4PhysicsTable ** G4hRDEnergyLoss::RecorderOfpProcess = 0

staticprotected

Definition at line 160 of file G4hRDEnergyLoss.hh.

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

◆ RecorderOfProcess

G4ThreadLocal G4PhysicsTable ** G4hRDEnergyLoss::RecorderOfProcess = 0

staticprivate

Definition at line 251 of file G4hRDEnergyLoss.hh.

Referenced by BuildDEDXTable(), and G4hRDEnergyLoss().

◆ rndmStepFlag

G4ThreadLocal G4bool G4hRDEnergyLoss::rndmStepFlag = false

staticprotected

Definition at line 194 of file G4hRDEnergyLoss.hh.

Referenced by SetRndmStep().

◆ RTable

G4ThreadLocal G4double G4hRDEnergyLoss::RTable

staticprotected

Definition at line 179 of file G4hRDEnergyLoss.hh.

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

◆ tauhigh

G4ThreadLocal G4double G4hRDEnergyLoss::tauhigh

staticprivate

Definition at line 206 of file G4hRDEnergyLoss.hh.

Referenced by RangeIntLin().

◆ taulow

G4ThreadLocal G4double G4hRDEnergyLoss::taulow

staticprivate

Definition at line 206 of file G4hRDEnergyLoss.hh.

Referenced by RangeIntLin().

◆ theDEDXpbarTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theDEDXpbarTable = 0

staticprotected

Definition at line 143 of file G4hRDEnergyLoss.hh.

Referenced by BuildDEDXTable(), and BuildInverseRangeTable().

◆ theDEDXpTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theDEDXpTable = 0

staticprotected

Definition at line 142 of file G4hRDEnergyLoss.hh.

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

◆ theDEDXTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theDEDXTable = 0

staticprivate

Definition at line 243 of file G4hRDEnergyLoss.hh.

Referenced by BuildDEDXTable(), and 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

staticprotected

Definition at line 149 of file G4hRDEnergyLoss.hh.

Referenced by BuildDEDXTable(), and BuildInverseRangeTable().

◆ theInverseRangepTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theInverseRangepTable = 0

staticprotected

Definition at line 148 of file G4hRDEnergyLoss.hh.

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

◆ theInverseRangeTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theInverseRangeTable = 0

staticprivate

Definition at line 246 of file G4hRDEnergyLoss.hh.

Referenced by BuildInverseRangeTable().

◆ theLabTimepbarTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theLabTimepbarTable = 0

staticprotected

Definition at line 153 of file G4hRDEnergyLoss.hh.

Referenced by BuildDEDXTable(), and BuildTimeTables().

◆ theLabTimepTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theLabTimepTable = 0

staticprotected

Definition at line 152 of file G4hRDEnergyLoss.hh.

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

◆ theLabTimeTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theLabTimeTable = 0

staticprivate

Definition at line 248 of file G4hRDEnergyLoss.hh.

Referenced by BuildTimeTables().

◆ theLossTable

G4PhysicsTable* G4hRDEnergyLoss::theLossTable

protected

Definition at line 183 of file G4hRDEnergyLoss.hh.

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

◆ theNumberOfInteractionLengthLeft

G4double G4VProcess::theNumberOfInteractionLengthLeft = -1.0

protectedinherited

Definition at line 331 of file G4VProcess.hh.

◆ thepbarRangeCoeffATable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::thepbarRangeCoeffATable = 0

staticprivate

Definition at line 257 of file G4hRDEnergyLoss.hh.

Referenced by BuildInverseRangeTable(), and BuildRangeCoeffATable().

◆ thepbarRangeCoeffBTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::thepbarRangeCoeffBTable = 0

staticprivate

Definition at line 258 of file G4hRDEnergyLoss.hh.

Referenced by BuildInverseRangeTable(), and BuildRangeCoeffBTable().

◆ thepbarRangeCoeffCTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::thepbarRangeCoeffCTable = 0

staticprivate

Definition at line 259 of file G4hRDEnergyLoss.hh.

Referenced by BuildInverseRangeTable(), and 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

staticprivate

Definition at line 254 of file G4hRDEnergyLoss.hh.

Referenced by BuildInverseRangeTable(), and BuildRangeCoeffATable().

◆ thepRangeCoeffBTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::thepRangeCoeffBTable = 0

staticprivate

Definition at line 255 of file G4hRDEnergyLoss.hh.

Referenced by BuildInverseRangeTable(), and BuildRangeCoeffBTable().

◆ thepRangeCoeffCTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::thepRangeCoeffCTable = 0

staticprivate

Definition at line 256 of file G4hRDEnergyLoss.hh.

Referenced by BuildInverseRangeTable(), and 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

staticprotected

Definition at line 156 of file G4hRDEnergyLoss.hh.

Referenced by BuildDEDXTable(), and BuildTimeTables().

◆ theProperTimepTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theProperTimepTable = 0

staticprotected

Definition at line 155 of file G4hRDEnergyLoss.hh.

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

◆ theProperTimeTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theProperTimeTable = 0

staticprivate

Definition at line 249 of file G4hRDEnergyLoss.hh.

Referenced by BuildTimeTables().

◆ theRangeCoeffATable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangeCoeffATable = 0

staticprivate

Definition at line 261 of file G4hRDEnergyLoss.hh.

Referenced by BuildInverseRangeTable(), and BuildRangeCoeffATable().

◆ theRangeCoeffBTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangeCoeffBTable = 0

staticprivate

Definition at line 262 of file G4hRDEnergyLoss.hh.

Referenced by BuildInverseRangeTable(), and BuildRangeCoeffBTable().

◆ theRangeCoeffCTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangeCoeffCTable = 0

staticprivate

Definition at line 263 of file G4hRDEnergyLoss.hh.

Referenced by BuildInverseRangeTable(), and BuildRangeCoeffCTable().

◆ theRangepbarTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangepbarTable = 0

staticprotected

Definition at line 145 of file G4hRDEnergyLoss.hh.

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

◆ theRangepTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangepTable = 0

staticprotected

Definition at line 144 of file G4hRDEnergyLoss.hh.

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

◆ theRangeTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangeTable = 0

staticprivate

Definition at line 245 of file G4hRDEnergyLoss.hh.

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

◆ TotBin

G4ThreadLocal G4int G4hRDEnergyLoss::TotBin = 360

staticprotected

Definition at line 176 of file G4hRDEnergyLoss.hh.

Referenced by BuildDEDXTable(), BuildLabTimeVector(), G4hImpactIonisation::BuildLambdaTable(), G4hImpactIonisation::BuildLossTable(), G4hImpactIonisation::BuildPhysicsTable(), BuildProperTimeVector(), BuildRangeCoeffATable(), BuildRangeCoeffBTable(), BuildRangeCoeffCTable(), BuildRangeTable(), BuildRangeVector(), BuildTimeTables(), G4hImpactIonisation::InitializeMe(), InvertRangeVector(), and G4hImpactIonisation::PrintInfoDefinition().

◆ 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/G4hRDEnergyLoss.hh
source/processes/electromagnetic/pii/src/G4hRDEnergyLoss.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

◆ G4hRDEnergyLoss() [1/2]

◆ ~G4hRDEnergyLoss()

◆ G4hRDEnergyLoss() [2/2]

Member Function Documentation

◆ AlongStepDoIt()

◆ AlongStepGetPhysicalInteractionLength()

◆ AlongStepGPIL()

◆ AtRestDoIt()

◆ AtRestGetPhysicalInteractionLength()

◆ AtRestGPIL()

◆ BuildDEDXTable()

◆ BuildInverseRangeTable()

◆ BuildLabTimeVector()

◆ BuildPhysicsTable()

◆ BuildProperTimeVector()

◆ BuildRangeCoeffATable()

◆ BuildRangeCoeffBTable()

◆ BuildRangeCoeffCTable()

◆ BuildRangeTable()

◆ BuildRangeVector()

◆ BuildTimeTables()

◆ BuildWorkerPhysicsTable()

◆ ClearNumberOfInteractionLengthLeft()

◆ CutsWhereModified()

◆ DumpInfo()

◆ EndTracking()

◆ GetContinuousStepLimit()

◆ GetCurrentInteractionLength()

◆ GetGPILSelection()

◆ GetMasterProcess()

◆ GetMeanFreePath()

◆ GetNumberOfInteractionLengthLeft()

◆ GetNumberOfProcesses()

◆ GetPhysicsTableFileName()

◆ GetPILfactor()

◆ GetProcessManager()

◆ GetProcessName()

◆ GetProcessSubType()

◆ GetProcessType()

◆ GetProcessTypeName()

◆ GetTotalNumberOfInteractionLengthTraversed()

◆ GetVerboseLevel()

◆ InvertRangeVector()

◆ isAlongStepDoItIsEnabled()

◆ IsApplicable()

◆ isAtRestDoItIsEnabled()

◆ isPostStepDoItIsEnabled()

◆ LabTimeIntLog()

◆ MinusNumberOfProcesses()

◆ operator!=()

◆ operator=()

◆ operator==()

◆ PlusNumberOfProcesses()

◆ PostStepDoIt()

◆ PostStepGetPhysicalInteractionLength()

◆ PostStepGPIL()

◆ PreparePhysicsTable()

◆ PrepareWorkerPhysicsTable()

◆ ProcessDescription()

◆ ProperTimeIntLog()

◆ RangeIntLin()

◆ RangeIntLog()

◆ ResetNumberOfInteractionLengthLeft()

◆ RetrievePhysicsTable()

◆ SetdRoverRange()

◆ SetEnlossFluc()

◆ SetGPILSelection()

◆ SetMasterProcess()