#include <G4hRDEnergyLoss.hh>

Inheritance diagram for G4hRDEnergyLoss:

Collaboration diagram for G4hRDEnergyLoss:

Public Member Functions
	G4hRDEnergyLoss (const G4String &)

	~G4hRDEnergyLoss ()

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

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

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

	G4VContinuousDiscreteProcess (G4VContinuousDiscreteProcess &)

virtual	~G4VContinuousDiscreteProcess ()

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

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

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

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

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

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

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4int	operator== (const G4VProcess &right) const

G4int	operator!= (const G4VProcess &right) const

G4double	GetCurrentInteractionLength () const

void	SetPILfactor (G4double value)

G4double	GetPILfactor () const

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

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

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

virtual G4bool	IsApplicable (const G4ParticleDefinition &)

virtual void	BuildPhysicsTable (const G4ParticleDefinition &)

virtual void	PreparePhysicsTable (const G4ParticleDefinition &)

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

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

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

const G4String &	GetProcessName () const

G4ProcessType	GetProcessType () const

void	SetProcessType (G4ProcessType)

G4int	GetProcessSubType () const

void	SetProcessSubType (G4int)

virtual void	StartTracking (G4Track *)

virtual void	EndTracking ()

virtual void	SetProcessManager (const G4ProcessManager *)

virtual const G4ProcessManager *	GetProcessManager ()

virtual void	ResetNumberOfInteractionLengthLeft ()

G4double	GetNumberOfInteractionLengthLeft () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4bool	isAtRestDoItIsEnabled () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

virtual void	DumpInfo () const

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

virtual void	SetMasterProcess (G4VProcess *masterP)

const G4VProcess *	GetMasterProcess () const

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Static Public Member Functions
static G4int	GetNumberOfProcesses ()

static void	SetNumberOfProcesses (G4int number)

static void	PlusNumberOfProcesses ()

static void	MinusNumberOfProcesses ()

static void	SetdRoverRange (G4double value)

static void	SetRndmStep (G4bool value)

static void	SetEnlossFluc (G4bool value)

static void	SetStepFunction (G4double c1, G4double c2)

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

Protected Member Functions
G4bool	CutsWhereModified ()

Protected Member Functions inherited from G4VContinuousDiscreteProcess
virtual G4double	GetContinuousStepLimit (const G4Track &aTrack, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety)=0

void	SetGPILSelection (G4GPILSelection selection)

G4GPILSelection	GetGPILSelection () const

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

void	ClearNumberOfInteractionLengthLeft ()

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

Protected Attributes
const G4double	MaxExcitationNumber

const G4double	probLimFluct

const long	nmaxDirectFluct

const long	nmaxCont1

const long	nmaxCont2

G4PhysicsTable *	theLossTable

G4double	linLossLimit

G4double	MinKineticEnergy

Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager

G4VParticleChange *	pParticleChange

G4ParticleChange	aParticleChange

G4double	theNumberOfInteractionLengthLeft

G4double	currentInteractionLength

G4double	theInitialNumberOfInteractionLength

G4String	theProcessName

G4String	thePhysicsTableFileName

G4ProcessType	theProcessType

G4int	theProcessSubType

G4double	thePILfactor

G4bool	enableAtRestDoIt

G4bool	enableAlongStepDoIt

G4bool	enablePostStepDoIt

G4int	verboseLevel

Static Protected Attributes
static G4ThreadLocal G4PhysicsTable *	theDEDXpTable = 0

static G4ThreadLocal G4PhysicsTable *	theDEDXpbarTable = 0

static G4ThreadLocal G4PhysicsTable *	theRangepTable = 0

static G4ThreadLocal G4PhysicsTable *	theRangepbarTable = 0

static G4ThreadLocal G4PhysicsTable *	theInverseRangepTable = 0

static G4ThreadLocal G4PhysicsTable *	theInverseRangepbarTable = 0

static G4ThreadLocal G4PhysicsTable *	theLabTimepTable = 0

static G4ThreadLocal G4PhysicsTable *	theLabTimepbarTable = 0

static G4ThreadLocal G4PhysicsTable *	theProperTimepTable = 0

static G4ThreadLocal G4PhysicsTable *	theProperTimepbarTable = 0

static G4ThreadLocal G4PhysicsTable **	RecorderOfpProcess = 0

static G4ThreadLocal G4PhysicsTable **	RecorderOfpbarProcess = 0

static G4ThreadLocal G4int	CounterOfpProcess = 0

static G4ThreadLocal G4int	CounterOfpbarProcess = 0

static G4ThreadLocal G4double	ParticleMass

static G4ThreadLocal G4double	ptableElectronCutInRange = 0.0

static G4ThreadLocal G4double	pbartableElectronCutInRange = 0.0

static G4ThreadLocal G4double	Charge

static G4ThreadLocal G4double	LowestKineticEnergy = 1e-05

static G4ThreadLocal G4double	HighestKineticEnergy = 1.e5

static G4ThreadLocal G4int	TotBin = 360

static G4ThreadLocal G4double	RTable

static G4ThreadLocal G4double	LOGRTable

static G4ThreadLocal G4double	dRoverRange = 0.20

static G4ThreadLocal G4double	finalRange = 0.2

static G4ThreadLocal G4double	c1lim = 0.20

static G4ThreadLocal G4double	c2lim = 0.32

static G4ThreadLocal G4double	c3lim = -0.032

static G4ThreadLocal G4bool	rndmStepFlag = false

static G4ThreadLocal G4bool	EnlossFlucFlag = true

Private Member Functions
	G4hRDEnergyLoss (G4hRDEnergyLoss &)

G4hRDEnergyLoss &	operator= (const G4hRDEnergyLoss &right)

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

static void	BuildInverseRangeTable (const G4ParticleDefinition &aParticleType)

static void	BuildTimeTables (const G4ParticleDefinition &aParticleType)

static void	BuildLabTimeVector (G4int materialIndex, G4PhysicsLogVector *rangeVector)

static void	BuildProperTimeVector (G4int materialIndex, G4PhysicsLogVector *rangeVector)

static void	InvertRangeVector (G4int materialIndex, G4PhysicsLogVector *rangeVector)

static void	BuildRangeVector (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)

static void	BuildRangeCoeffATable (const G4ParticleDefinition &aParticleType)

static void	BuildRangeCoeffBTable (const G4ParticleDefinition &aParticleType)

static void	BuildRangeCoeffCTable (const G4ParticleDefinition &aParticleType)

Static Private Attributes
static G4ThreadLocal G4double	Mass

static G4ThreadLocal G4double	taulow

static G4ThreadLocal G4double	tauhigh

static G4ThreadLocal G4double	ltaulow

static G4ThreadLocal G4double	ltauhigh

static G4ThreadLocal G4PhysicsTable *	theDEDXTable = 0

static G4ThreadLocal G4PhysicsTable *	theRangeTable = 0

static G4ThreadLocal G4PhysicsTable *	theInverseRangeTable = 0

static G4ThreadLocal G4PhysicsTable *	theLabTimeTable = 0

static G4ThreadLocal G4PhysicsTable *	theProperTimeTable = 0

static G4ThreadLocal G4PhysicsTable **	RecorderOfProcess = 0

static G4ThreadLocal G4int	CounterOfProcess = 0

static G4ThreadLocal G4PhysicsTable *	thepRangeCoeffATable = 0

static G4ThreadLocal G4PhysicsTable *	thepRangeCoeffBTable = 0

static G4ThreadLocal G4PhysicsTable *	thepRangeCoeffCTable = 0

static G4ThreadLocal G4PhysicsTable *	thepbarRangeCoeffATable = 0

static G4ThreadLocal G4PhysicsTable *	thepbarRangeCoeffBTable = 0

static G4ThreadLocal G4PhysicsTable *	thepbarRangeCoeffCTable = 0

static G4ThreadLocal G4PhysicsTable *	theRangeCoeffATable = 0

static G4ThreadLocal G4PhysicsTable *	theRangeCoeffBTable = 0

static G4ThreadLocal G4PhysicsTable *	theRangeCoeffCTable = 0

static G4ThreadLocal G4int	NumberOfProcesses = 1

Detailed Description

Definition at line 93 of file G4hRDEnergyLoss.hh.

Constructor & Destructor Documentation

◆ G4hRDEnergyLoss() [1/2]

G4hRDEnergyLoss::G4hRDEnergyLoss ( const G4String & processName )

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

◆ ~G4hRDEnergyLoss()

G4hRDEnergyLoss::~G4hRDEnergyLoss ( )

Definition at line 180 of file G4hRDEnergyLoss.cc.

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

Here is the call graph for this function:

◆ G4hRDEnergyLoss() [2/2]

G4hRDEnergyLoss::G4hRDEnergyLoss ( G4hRDEnergyLoss & )

private

Member Function Documentation

◆ BuildDEDXTable()

void G4hRDEnergyLoss::BuildDEDXTable ( const G4ParticleDefinition & aParticleType )

staticprotected

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildInverseRangeTable()

void G4hRDEnergyLoss::BuildInverseRangeTable ( const G4ParticleDefinition & aParticleType )

staticprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildLabTimeVector()

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

staticprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildProperTimeVector()

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

staticprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildRangeCoeffATable()

void G4hRDEnergyLoss::BuildRangeCoeffATable ( const G4ParticleDefinition & aParticleType )

staticprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildRangeCoeffBTable()

void G4hRDEnergyLoss::BuildRangeCoeffBTable ( const G4ParticleDefinition & aParticleType )

staticprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildRangeCoeffCTable()

void G4hRDEnergyLoss::BuildRangeCoeffCTable ( const G4ParticleDefinition & aParticleType )

staticprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildRangeTable()

void G4hRDEnergyLoss::BuildRangeTable ( const G4ParticleDefinition & aParticleType )

staticprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildRangeVector()

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

staticprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildTimeTables()

void G4hRDEnergyLoss::BuildTimeTables ( const G4ParticleDefinition & aParticleType )

staticprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CutsWhereModified()

G4bool G4hRDEnergyLoss::CutsWhereModified ( )

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMeanFreePath()

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

pure virtual

Implements G4VContinuousDiscreteProcess.

Implemented in G4hImpactIonisation.

◆ GetNumberOfProcesses()

G4int G4hRDEnergyLoss::GetNumberOfProcesses ( )

static

Definition at line 191 of file G4hRDEnergyLoss.cc.

 {
   return NumberOfProcesses; 
 } 

◆ InvertRangeVector()

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

staticprivate

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

Here is the call graph for this function:

◆ LabTimeIntLog()

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

staticprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MinusNumberOfProcesses()

void G4hRDEnergyLoss::MinusNumberOfProcesses ( )

static

Definition at line 212 of file G4hRDEnergyLoss.cc.

 {
   NumberOfProcesses--; 
 } 

◆ operator=()

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

private

◆ PlusNumberOfProcesses()

void G4hRDEnergyLoss::PlusNumberOfProcesses ( )

static

Definition at line 205 of file G4hRDEnergyLoss.cc.

 {
   NumberOfProcesses++; 
 } 

◆ PostStepDoIt()

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

pure virtual

Reimplemented from G4VContinuousDiscreteProcess.

Implemented in G4hImpactIonisation.

◆ ProperTimeIntLog()

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

staticprivate

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RangeIntLin()

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

staticprivate

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

Here is the call graph for this function:

◆ RangeIntLog()

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

staticprivate

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

Here is the call graph for this function:

◆ SetdRoverRange()

void G4hRDEnergyLoss::SetdRoverRange ( G4double value )

static

Definition at line 219 of file G4hRDEnergyLoss.cc.

 {
   dRoverRange = value;
 }

◆ SetEnlossFluc()

void G4hRDEnergyLoss::SetEnlossFluc ( G4bool value )

static

Definition at line 233 of file G4hRDEnergyLoss.cc.

 {
   EnlossFlucFlag = value;
 }

◆ SetNumberOfProcesses()

void G4hRDEnergyLoss::SetNumberOfProcesses ( G4int number )

static

Definition at line 198 of file G4hRDEnergyLoss.cc.

 {
   NumberOfProcesses=number; 
 } 

◆ SetRndmStep()

void G4hRDEnergyLoss::SetRndmStep ( G4bool value )

static

Definition at line 226 of file G4hRDEnergyLoss.cc.

 {
   rndmStepFlag = value;
 }

◆ SetStepFunction()

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

static

Definition at line 240 of file G4hRDEnergyLoss.cc.

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

Member Data Documentation

◆ c1lim

G4ThreadLocal G4double G4hRDEnergyLoss::c1lim = 0.20

staticprotected

Definition at line 194 of file G4hRDEnergyLoss.hh.

◆ c2lim

G4ThreadLocal G4double G4hRDEnergyLoss::c2lim = 0.32

staticprotected

Definition at line 194 of file G4hRDEnergyLoss.hh.

◆ c3lim

G4ThreadLocal G4double G4hRDEnergyLoss::c3lim = -0.032

staticprotected

Definition at line 194 of file G4hRDEnergyLoss.hh.

◆ Charge

G4ThreadLocal G4double G4hRDEnergyLoss::Charge

staticprotected

Definition at line 174 of file G4hRDEnergyLoss.hh.

◆ CounterOfpbarProcess

G4ThreadLocal G4int G4hRDEnergyLoss::CounterOfpbarProcess = 0

staticprotected

Definition at line 165 of file G4hRDEnergyLoss.hh.

◆ CounterOfpProcess

G4ThreadLocal G4int G4hRDEnergyLoss::CounterOfpProcess = 0

staticprotected

Definition at line 164 of file G4hRDEnergyLoss.hh.

◆ CounterOfProcess

G4ThreadLocal G4int G4hRDEnergyLoss::CounterOfProcess = 0

staticprivate

Definition at line 254 of file G4hRDEnergyLoss.hh.

◆ dRoverRange

G4ThreadLocal G4double G4hRDEnergyLoss::dRoverRange = 0.20

staticprotected

Definition at line 191 of file G4hRDEnergyLoss.hh.

◆ EnlossFlucFlag

G4ThreadLocal G4bool G4hRDEnergyLoss::EnlossFlucFlag = true

staticprotected

Definition at line 197 of file G4hRDEnergyLoss.hh.

◆ finalRange

G4ThreadLocal G4double G4hRDEnergyLoss::finalRange = 0.2

staticprotected

Definition at line 193 of file G4hRDEnergyLoss.hh.

◆ HighestKineticEnergy

G4ThreadLocal G4double G4hRDEnergyLoss::HighestKineticEnergy = 1.e5

staticprotected

Definition at line 177 of file G4hRDEnergyLoss.hh.

◆ linLossLimit

G4double G4hRDEnergyLoss::linLossLimit

protected

Definition at line 187 of file G4hRDEnergyLoss.hh.

◆ LOGRTable

G4ThreadLocal G4double G4hRDEnergyLoss::LOGRTable

staticprotected

Definition at line 181 of file G4hRDEnergyLoss.hh.

◆ LowestKineticEnergy

G4ThreadLocal G4double G4hRDEnergyLoss::LowestKineticEnergy = 1e-05

staticprotected

Definition at line 176 of file G4hRDEnergyLoss.hh.

◆ ltauhigh

G4ThreadLocal G4double G4hRDEnergyLoss::ltauhigh

staticprivate

Definition at line 208 of file G4hRDEnergyLoss.hh.

◆ ltaulow

G4ThreadLocal G4double G4hRDEnergyLoss::ltaulow

staticprivate

Definition at line 208 of file G4hRDEnergyLoss.hh.

◆ Mass

G4ThreadLocal G4double G4hRDEnergyLoss::Mass

staticprivate

Definition at line 208 of file G4hRDEnergyLoss.hh.

◆ MaxExcitationNumber

const G4double G4hRDEnergyLoss::MaxExcitationNumber

protected

Definition at line 136 of file G4hRDEnergyLoss.hh.

◆ MinKineticEnergy

G4double G4hRDEnergyLoss::MinKineticEnergy

protected

Definition at line 189 of file G4hRDEnergyLoss.hh.

◆ nmaxCont1

const long G4hRDEnergyLoss::nmaxCont1

protected

Definition at line 138 of file G4hRDEnergyLoss.hh.

◆ nmaxCont2

const long G4hRDEnergyLoss::nmaxCont2

protected

Definition at line 138 of file G4hRDEnergyLoss.hh.

◆ nmaxDirectFluct

const long G4hRDEnergyLoss::nmaxDirectFluct

protected

Definition at line 138 of file G4hRDEnergyLoss.hh.

◆ NumberOfProcesses

G4ThreadLocal G4int G4hRDEnergyLoss::NumberOfProcesses = 1

staticprivate

Definition at line 266 of file G4hRDEnergyLoss.hh.

◆ ParticleMass

G4ThreadLocal G4double G4hRDEnergyLoss::ParticleMass

staticprotected

Definition at line 168 of file G4hRDEnergyLoss.hh.

◆ pbartableElectronCutInRange

G4ThreadLocal G4double G4hRDEnergyLoss::pbartableElectronCutInRange = 0.0

staticprotected

Definition at line 172 of file G4hRDEnergyLoss.hh.

◆ probLimFluct

const G4double G4hRDEnergyLoss::probLimFluct

protected

Definition at line 137 of file G4hRDEnergyLoss.hh.

◆ ptableElectronCutInRange

G4ThreadLocal G4double G4hRDEnergyLoss::ptableElectronCutInRange = 0.0

staticprotected

Definition at line 171 of file G4hRDEnergyLoss.hh.

◆ RecorderOfpbarProcess

G4ThreadLocal G4PhysicsTable ** G4hRDEnergyLoss::RecorderOfpbarProcess = 0

staticprotected

Definition at line 163 of file G4hRDEnergyLoss.hh.

◆ RecorderOfpProcess

G4ThreadLocal G4PhysicsTable ** G4hRDEnergyLoss::RecorderOfpProcess = 0

staticprotected

Definition at line 162 of file G4hRDEnergyLoss.hh.

◆ RecorderOfProcess

G4ThreadLocal G4PhysicsTable ** G4hRDEnergyLoss::RecorderOfProcess = 0

staticprivate

Definition at line 253 of file G4hRDEnergyLoss.hh.

◆ rndmStepFlag

G4ThreadLocal G4bool G4hRDEnergyLoss::rndmStepFlag = false

staticprotected

Definition at line 196 of file G4hRDEnergyLoss.hh.

◆ RTable

G4ThreadLocal G4double G4hRDEnergyLoss::RTable

staticprotected

Definition at line 181 of file G4hRDEnergyLoss.hh.

◆ tauhigh

G4ThreadLocal G4double G4hRDEnergyLoss::tauhigh

staticprivate

Definition at line 208 of file G4hRDEnergyLoss.hh.

◆ taulow

G4ThreadLocal G4double G4hRDEnergyLoss::taulow

staticprivate

Definition at line 208 of file G4hRDEnergyLoss.hh.

◆ theDEDXpbarTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theDEDXpbarTable = 0

staticprotected

Definition at line 145 of file G4hRDEnergyLoss.hh.

◆ theDEDXpTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theDEDXpTable = 0

staticprotected

Definition at line 144 of file G4hRDEnergyLoss.hh.

◆ theDEDXTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theDEDXTable = 0

staticprivate

Definition at line 245 of file G4hRDEnergyLoss.hh.

◆ theInverseRangepbarTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theInverseRangepbarTable = 0

staticprotected

Definition at line 151 of file G4hRDEnergyLoss.hh.

◆ theInverseRangepTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theInverseRangepTable = 0

staticprotected

Definition at line 150 of file G4hRDEnergyLoss.hh.

◆ theInverseRangeTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theInverseRangeTable = 0

staticprivate

Definition at line 248 of file G4hRDEnergyLoss.hh.

◆ theLabTimepbarTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theLabTimepbarTable = 0

staticprotected

Definition at line 155 of file G4hRDEnergyLoss.hh.

◆ theLabTimepTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theLabTimepTable = 0

staticprotected

Definition at line 154 of file G4hRDEnergyLoss.hh.

◆ theLabTimeTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theLabTimeTable = 0

staticprivate

Definition at line 250 of file G4hRDEnergyLoss.hh.

◆ theLossTable

G4PhysicsTable* G4hRDEnergyLoss::theLossTable

protected

Definition at line 185 of file G4hRDEnergyLoss.hh.

◆ thepbarRangeCoeffATable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::thepbarRangeCoeffATable = 0

staticprivate

Definition at line 259 of file G4hRDEnergyLoss.hh.

◆ thepbarRangeCoeffBTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::thepbarRangeCoeffBTable = 0

staticprivate

Definition at line 260 of file G4hRDEnergyLoss.hh.

◆ thepbarRangeCoeffCTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::thepbarRangeCoeffCTable = 0

staticprivate

Definition at line 261 of file G4hRDEnergyLoss.hh.

◆ thepRangeCoeffATable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::thepRangeCoeffATable = 0

staticprivate

Definition at line 256 of file G4hRDEnergyLoss.hh.

◆ thepRangeCoeffBTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::thepRangeCoeffBTable = 0

staticprivate

Definition at line 257 of file G4hRDEnergyLoss.hh.

◆ thepRangeCoeffCTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::thepRangeCoeffCTable = 0

staticprivate

Definition at line 258 of file G4hRDEnergyLoss.hh.

◆ theProperTimepbarTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theProperTimepbarTable = 0

staticprotected

Definition at line 158 of file G4hRDEnergyLoss.hh.

◆ theProperTimepTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theProperTimepTable = 0

staticprotected

Definition at line 157 of file G4hRDEnergyLoss.hh.

◆ theProperTimeTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theProperTimeTable = 0

staticprivate

Definition at line 251 of file G4hRDEnergyLoss.hh.

◆ theRangeCoeffATable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangeCoeffATable = 0

staticprivate

Definition at line 263 of file G4hRDEnergyLoss.hh.

◆ theRangeCoeffBTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangeCoeffBTable = 0

staticprivate

Definition at line 264 of file G4hRDEnergyLoss.hh.

◆ theRangeCoeffCTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangeCoeffCTable = 0

staticprivate

Definition at line 265 of file G4hRDEnergyLoss.hh.

◆ theRangepbarTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangepbarTable = 0

staticprotected

Definition at line 147 of file G4hRDEnergyLoss.hh.

◆ theRangepTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangepTable = 0

staticprotected

Definition at line 146 of file G4hRDEnergyLoss.hh.

◆ theRangeTable

G4ThreadLocal G4PhysicsTable * G4hRDEnergyLoss::theRangeTable = 0

staticprivate

Definition at line 247 of file G4hRDEnergyLoss.hh.

◆ TotBin

G4ThreadLocal G4int G4hRDEnergyLoss::TotBin = 360

staticprotected

Definition at line 178 of file G4hRDEnergyLoss.hh.

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

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

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4hRDEnergyLoss() [1/2]

◆ ~G4hRDEnergyLoss()

◆ G4hRDEnergyLoss() [2/2]

Member Function Documentation

◆ BuildDEDXTable()

◆ BuildInverseRangeTable()

◆ BuildLabTimeVector()

◆ BuildProperTimeVector()

◆ BuildRangeCoeffATable()

◆ BuildRangeCoeffBTable()

◆ BuildRangeCoeffCTable()

◆ BuildRangeTable()

◆ BuildRangeVector()

◆ BuildTimeTables()

◆ CutsWhereModified()

◆ GetMeanFreePath()

◆ GetNumberOfProcesses()

◆ InvertRangeVector()

◆ LabTimeIntLog()

◆ MinusNumberOfProcesses()

◆ operator=()

◆ PlusNumberOfProcesses()

◆ PostStepDoIt()

◆ ProperTimeIntLog()

◆ RangeIntLin()

◆ RangeIntLog()

◆ SetdRoverRange()

◆ SetEnlossFluc()

◆ SetNumberOfProcesses()

◆ SetRndmStep()

◆ SetStepFunction()

Member Data Documentation

◆ c1lim

◆ c2lim

◆ c3lim

◆ Charge

◆ CounterOfpbarProcess

◆ CounterOfpProcess

◆ CounterOfProcess

◆ dRoverRange

◆ EnlossFlucFlag

◆ finalRange

◆ HighestKineticEnergy

◆ linLossLimit

◆ LOGRTable

◆ LowestKineticEnergy

◆ ltauhigh

◆ ltaulow

◆ Mass

◆ MaxExcitationNumber

◆ MinKineticEnergy

◆ nmaxCont1

◆ nmaxCont2

◆ nmaxDirectFluct

◆ NumberOfProcesses

◆ ParticleMass

◆ pbartableElectronCutInRange

◆ probLimFluct

◆ ptableElectronCutInRange

◆ RecorderOfpbarProcess

◆ RecorderOfpProcess

◆ RecorderOfProcess

◆ rndmStepFlag

◆ RTable

◆ tauhigh

◆ taulow

◆ theDEDXpbarTable

◆ theDEDXpTable

◆ theDEDXTable