#include <G4RDVeLowEnergyLoss.hh>

Inheritance diagram for G4RDVeLowEnergyLoss:

Collaboration diagram for G4RDVeLowEnergyLoss:

Public Member Functions
	G4RDVeLowEnergyLoss (const G4String &, G4ProcessType aType=fNotDefined)

	G4RDVeLowEnergyLoss (G4RDVeLowEnergyLoss &)

virtual	~G4RDVeLowEnergyLoss ()

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

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

virtual G4double	GetMeanFreePath (const G4Track &track, G4double previousStepSize, 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 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 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
G4double	GetLossWithFluct (const G4DynamicParticle aParticle, const G4MaterialCutsCouple couple, G4double MeanLoss, G4double step)

Protected Member Functions inherited from G4VContinuousDiscreteProcess
void	SetGPILSelection (G4GPILSelection selection)

G4GPILSelection	GetGPILSelection () const

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

void	ClearNumberOfInteractionLengthLeft ()

Static Protected Member Functions
static G4PhysicsTable *	BuildRangeTable (G4PhysicsTable theDEDXTable, G4PhysicsTable theRangeTable, G4double Tmin, G4double Tmax, G4int nbin)

static G4PhysicsTable *	BuildLabTimeTable (G4PhysicsTable theDEDXTable, G4PhysicsTable theLabTimeTable, G4double Tmin, G4double Tmax, G4int nbin)

static G4PhysicsTable *	BuildProperTimeTable (G4PhysicsTable theDEDXTable, G4PhysicsTable ProperTimeTable, G4double Tmin, G4double Tmax, G4int nbin)

static G4PhysicsTable *	BuildRangeCoeffATable (G4PhysicsTable theRangeTable, G4PhysicsTable theCoeffATable, G4double Tmin, G4double Tmax, G4int nbin)

static G4PhysicsTable *	BuildRangeCoeffBTable (G4PhysicsTable theRangeTable, G4PhysicsTable theCoeffBTable, G4double Tmin, G4double Tmax, G4int nbin)

static G4PhysicsTable *	BuildRangeCoeffCTable (G4PhysicsTable theRangeTable, G4PhysicsTable theCoeffCTable, G4double Tmin, G4double Tmax, G4int nbin)

static G4PhysicsTable *	BuildInverseRangeTable (G4PhysicsTable theRangeTable, G4PhysicsTable theRangeCoeffATable, G4PhysicsTable theRangeCoeffBTable, G4PhysicsTable theRangeCoeffCTable, G4PhysicsTable *theInverseRangeTable, G4double Tmin, G4double Tmax, G4int nbin)

Protected Attributes
const G4Material *	lastMaterial

G4int	imat

G4double	f1Fluct

G4double	f2Fluct

G4double	e1Fluct

G4double	e2Fluct

G4double	rateFluct

G4double	ipotFluct

G4double	e1LogFluct

G4double	e2LogFluct

G4double	ipotLogFluct

const G4int	nmaxCont1

const G4int	nmaxCont2

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 G4double	ParticleMass

static G4double	taulow

static G4double	tauhigh

static G4double	ltaulow

static G4double	ltauhigh

static G4double	dRoverRange = 20*perCent

static G4double	finalRange = 200*micrometer

static G4double	c1lim = dRoverRange

static G4double	c2lim = 2.(1.-dRoverRange)finalRange

static G4double	c3lim = -(1.-dRoverRange)finalRangefinalRange

static G4bool	rndmStepFlag = false

static G4bool	EnlossFlucFlag = true

Private Member Functions
	G4RDVeLowEnergyLoss ()

G4RDVeLowEnergyLoss &	operator= (const G4RDVeLowEnergyLoss &right)

Static Private Member Functions
static void	BuildRangeVector (G4PhysicsTable theDEDXTable, G4double Tmin, G4double Tmax, G4int nbin, G4int materialIndex, G4PhysicsLogVector rangeVector)

static void	BuildRangeVectorNew (const G4PhysicsTable , G4int, G4int, G4PhysicsLogVector )

static G4double	RangeIntLin (G4PhysicsVector *physicsVector, G4int nbin)

static G4double	RangeIntLog (G4PhysicsVector *physicsVector, G4int nbin)

static void	BuildLabTimeVector (G4PhysicsTable theDEDXTable, G4double Tmin, G4double Tmax, G4int nbin, G4int materialIndex, G4PhysicsLogVector rangeVector)

static void	BuildProperTimeVector (G4PhysicsTable theDEDXTable, G4double Tmin, G4double Tmax, G4int nbin, G4int materialIndex, G4PhysicsLogVector rangeVector)

static G4double	LabTimeIntLog (G4PhysicsVector *physicsVector, G4int nbin)

static G4double	ProperTimeIntLog (G4PhysicsVector *physicsVector, G4int nbin)

static void	InvertRangeVector (G4PhysicsTable theRangeTable, G4PhysicsTable theRangeCoeffATable, G4PhysicsTable theRangeCoeffBTable, G4PhysicsTable theRangeCoeffCTable, G4double Tmin, G4double Tmax, G4int nbin, G4int materialIndex, G4PhysicsLogVector *rangeVector)

Detailed Description

Definition at line 78 of file G4RDVeLowEnergyLoss.hh.

Constructor & Destructor Documentation

◆ G4RDVeLowEnergyLoss() [1/3]

G4RDVeLowEnergyLoss::G4RDVeLowEnergyLoss	(	const G4String &	aName,
		G4ProcessType	aType = `fNotDefined`
	)

Definition at line 85 of file G4RDVeLowEnergyLoss.cc.

                   : G4VContinuousDiscreteProcess(aName, aType),
      lastMaterial(0),
      nmaxCont1(4),
      nmaxCont2(16)
 {
 }

◆ G4RDVeLowEnergyLoss() [2/3]

G4RDVeLowEnergyLoss::G4RDVeLowEnergyLoss ( G4RDVeLowEnergyLoss & right )

Definition at line 101 of file G4RDVeLowEnergyLoss.cc.

                   : G4VContinuousDiscreteProcess(right),
      lastMaterial(0),
      nmaxCont1(4),
      nmaxCont2(16)
 {
 }

◆ ~G4RDVeLowEnergyLoss()

G4RDVeLowEnergyLoss::~G4RDVeLowEnergyLoss ( )

virtual

Definition at line 95 of file G4RDVeLowEnergyLoss.cc.

96 {

97 }

◆ G4RDVeLowEnergyLoss() [3/3]

G4RDVeLowEnergyLoss::G4RDVeLowEnergyLoss ( )

private

Definition at line 73 of file G4RDVeLowEnergyLoss.cc.

                    :G4VContinuousDiscreteProcess("No Name Loss Process"),
      lastMaterial(0),
      nmaxCont1(4),
      nmaxCont2(16)
 {
   G4Exception("G4RDVeLowEnergyLoss::G4RDVeLowEnergyLoss()", "InvalidCall",
               FatalException, "Default constructor is called!");
 }

Here is the call graph for this function:

Member Function Documentation

◆ AlongStepDoIt()

virtual G4VParticleChange* G4RDVeLowEnergyLoss::AlongStepDoIt	(	const G4Track &	track,
		const G4Step &	Step
	)

pure virtual

Reimplemented from G4VContinuousDiscreteProcess.

Implemented in G4eLowEnergyLoss.

◆ BuildInverseRangeTable()

G4PhysicsTable * G4RDVeLowEnergyLoss::BuildInverseRangeTable	(	G4PhysicsTable *	theRangeTable,
		G4PhysicsTable *	theRangeCoeffATable,
		G4PhysicsTable *	theRangeCoeffBTable,
		G4PhysicsTable *	theRangeCoeffCTable,
		G4PhysicsTable *	theInverseRangeTable,
		G4double	Tmin,
		G4double	Tmax,
		G4int	nbin
	)

staticprotected

Definition at line 514 of file G4RDVeLowEnergyLoss.cc.

 {
   G4bool b;
 
   G4int numOfCouples = G4ProductionCutsTable::GetProductionCutsTable()->GetTableSize();
 
     if(theInverseRangeTable)
     { theInverseRangeTable->clearAndDestroy();
       delete theInverseRangeTable; }
     theInverseRangeTable = new G4PhysicsTable(numOfCouples);
 
   // loop for materials
   for (G4int 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);
 
     rhigh *= std::exp(std::log(rhigh/rlow)/((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);
 
   }
   return theInverseRangeTable ;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildLabTimeTable()

G4PhysicsTable * G4RDVeLowEnergyLoss::BuildLabTimeTable	(	G4PhysicsTable *	theDEDXTable,
		G4PhysicsTable *	theLabTimeTable,
		G4double	Tmin,
		G4double	Tmax,
		G4int	nbin
	)

staticprotected

Definition at line 262 of file G4RDVeLowEnergyLoss.cc.

 {
 
   G4int numOfCouples = G4ProductionCutsTable::GetProductionCutsTable()->GetTableSize();
 
   if(theLabTimeTable)
   { theLabTimeTable->clearAndDestroy();
     delete theLabTimeTable; }
   theLabTimeTable = new G4PhysicsTable(numOfCouples);
 
 
   for (G4int J=0;  J<numOfCouples; J++)
   {
     G4PhysicsLogVector* aVector;
 
     aVector = new G4PhysicsLogVector(lowestKineticEnergy,
                             highestKineticEnergy,TotBin);
 
     BuildLabTimeVector(theDEDXTable,
               lowestKineticEnergy,highestKineticEnergy,TotBin,J,aVector);
     theLabTimeTable->insert(aVector);
 
 
   }
   return theLabTimeTable ;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildLabTimeVector()

void G4RDVeLowEnergyLoss::BuildLabTimeVector	(	G4PhysicsTable *	theDEDXTable,
		G4double	Tmin,
		G4double	Tmax,
		G4int	nbin,
		G4int	materialIndex,
		G4PhysicsLogVector *	rangeVector
	)

staticprivate

Definition at line 328 of file G4RDVeLowEnergyLoss.cc.

 {
 
   G4int nbin=100;
   G4bool isOut;
   G4double tlim=5.*keV,parlowen=0.4,ppar=0.5-parlowen ;
   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) ;
 
   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:

◆ BuildProperTimeTable()

G4PhysicsTable * G4RDVeLowEnergyLoss::BuildProperTimeTable	(	G4PhysicsTable *	theDEDXTable,
		G4PhysicsTable *	ProperTimeTable,
		G4double	Tmin,
		G4double	Tmax,
		G4int	nbin
	)

staticprotected

Definition at line 295 of file G4RDVeLowEnergyLoss.cc.

 {
 
   G4int numOfCouples = G4ProductionCutsTable::GetProductionCutsTable()->GetTableSize();
  
   if(theProperTimeTable)
   { theProperTimeTable->clearAndDestroy();
     delete theProperTimeTable; }
   theProperTimeTable = new G4PhysicsTable(numOfCouples);
 
 
   for (G4int J=0;  J<numOfCouples; J++)
   {
     G4PhysicsLogVector* aVector;
 
     aVector = new G4PhysicsLogVector(lowestKineticEnergy,
                             highestKineticEnergy,TotBin);
 
     BuildProperTimeVector(theDEDXTable,
               lowestKineticEnergy,highestKineticEnergy,TotBin,J,aVector);
     theProperTimeTable->insert(aVector);
 
 
   }
   return theProperTimeTable ;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildProperTimeVector()

void G4RDVeLowEnergyLoss::BuildProperTimeVector	(	G4PhysicsTable *	theDEDXTable,
		G4double	Tmin,
		G4double	Tmax,
		G4int	nbin,
		G4int	materialIndex,
		G4PhysicsLogVector *	rangeVector
	)

staticprivate

Definition at line 388 of file G4RDVeLowEnergyLoss.cc.

 {
   G4int nbin=100;
   G4bool isOut;
   G4double tlim=5.*keV,parlowen=0.4,ppar=0.5-parlowen ;
   G4double losslim,clim,taulim,timelim,
            LowEdgeEnergy,tau,Value ;
 
   G4PhysicsVector* physicsVector= (*theDEDXTable)[materialIndex];
   //const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
 
   // low energy part first...
   losslim = physicsVector->GetValue(tlim,isOut);
   taulim=tlim/ParticleMass ;
   clim=std::sqrt(ParticleMass*tlim/2.)/(c_light*losslim*ppar) ;
 
   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()

G4PhysicsTable * G4RDVeLowEnergyLoss::BuildRangeCoeffATable	(	G4PhysicsTable *	theRangeTable,
		G4PhysicsTable *	theCoeffATable,
		G4double	Tmin,
		G4double	Tmax,
		G4int	nbin
	)

staticprotected

Definition at line 639 of file G4RDVeLowEnergyLoss.cc.

 {
 
   G4int numOfCouples = G4ProductionCutsTable::GetProductionCutsTable()->GetTableSize();
 
   if(theRangeCoeffATable)
   { theRangeCoeffATable->clearAndDestroy();
     delete theRangeCoeffATable; }
   theRangeCoeffATable = new G4PhysicsTable(numOfCouples);
 
   G4double RTable = std::exp(std::log(highestKineticEnergy/lowestKineticEnergy)/TotBin) ;
   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 ;
     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)/(Ti*Ti) ;
 
       aVector->PutValue(i,Value);
       Ti = RTable*Ti ;
     }
  
     theRangeCoeffATable->insert(aVector);
   }
   return theRangeCoeffATable ;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildRangeCoeffBTable()

G4PhysicsTable * G4RDVeLowEnergyLoss::BuildRangeCoeffBTable	(	G4PhysicsTable *	theRangeTable,
		G4PhysicsTable *	theCoeffBTable,
		G4double	Tmin,
		G4double	Tmax,
		G4int	nbin
	)

staticprotected

Definition at line 701 of file G4RDVeLowEnergyLoss.cc.

 {
 
   G4int numOfCouples = G4ProductionCutsTable::GetProductionCutsTable()->GetTableSize();
 
   if(theRangeCoeffBTable)
   { theRangeCoeffBTable->clearAndDestroy();
     delete theRangeCoeffBTable; }
   theRangeCoeffBTable = new G4PhysicsTable(numOfCouples);
 
   G4double RTable = std::exp(std::log(highestKineticEnergy/lowestKineticEnergy)/TotBin) ;
   G4double R2 = RTable*RTable ;
   G4double R1 = RTable+1.;
   G4double w = R1*(RTable-1.)*(RTable-1.);
   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 ;
     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)/Ti;
 
       aVector->PutValue(i,Value);
       Ti = RTable*Ti ;
     }
     theRangeCoeffBTable->insert(aVector);
   }
   return theRangeCoeffBTable ;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildRangeCoeffCTable()

G4PhysicsTable * G4RDVeLowEnergyLoss::BuildRangeCoeffCTable	(	G4PhysicsTable *	theRangeTable,
		G4PhysicsTable *	theCoeffCTable,
		G4double	Tmin,
		G4double	Tmax,
		G4int	nbin
	)

staticprotected

Definition at line 762 of file G4RDVeLowEnergyLoss.cc.

 {
 
   G4int numOfCouples = G4ProductionCutsTable::GetProductionCutsTable()->GetTableSize();
 
   if(theRangeCoeffCTable)
   { theRangeCoeffCTable->clearAndDestroy();
     delete theRangeCoeffCTable; }
   theRangeCoeffCTable = new G4PhysicsTable(numOfCouples);
 
   G4double RTable = std::exp(std::log(highestKineticEnergy/lowestKineticEnergy)/TotBin) ;
   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);
   }
   return theRangeCoeffCTable ;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildRangeTable()

G4PhysicsTable * G4RDVeLowEnergyLoss::BuildRangeTable	(	G4PhysicsTable *	theDEDXTable,
		G4PhysicsTable *	theRangeTable,
		G4double	Tmin,
		G4double	Tmax,
		G4int	nbin
	)

staticprotected

Definition at line 128 of file G4RDVeLowEnergyLoss.cc.

 {
 
    G4int numOfCouples = theDEDXTable->length();
 
    if(theRangeTable)
    { theRangeTable->clearAndDestroy();
      delete theRangeTable; }
    theRangeTable = new G4PhysicsTable(numOfCouples);
 
    // loop for materials
 
    for (G4int J=0;  J<numOfCouples; J++)
    {
      G4PhysicsLogVector* aVector;
      aVector = new G4PhysicsLogVector(lowestKineticEnergy,
                               highestKineticEnergy,TotBin);
      BuildRangeVector(theDEDXTable,lowestKineticEnergy,highestKineticEnergy,
                       TotBin,J,aVector);
      theRangeTable->insert(aVector);
    }
    return theRangeTable ;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildRangeVector()

void G4RDVeLowEnergyLoss::BuildRangeVector	(	G4PhysicsTable *	theDEDXTable,
		G4double	Tmin,
		G4double	Tmax,
		G4int	nbin,
		G4int	materialIndex,
		G4PhysicsLogVector *	rangeVector
	)

staticprivate

Definition at line 159 of file G4RDVeLowEnergyLoss.cc.

 {
   G4bool isOut;
   G4PhysicsVector* physicsVector= (*theDEDXTable)[materialIndex];
   G4double energy1 = lowestKineticEnergy;
   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:

◆ BuildRangeVectorNew()

static void G4RDVeLowEnergyLoss::BuildRangeVectorNew	(	const G4PhysicsTable *	,
		G4int	,
		G4int	,
		G4PhysicsLogVector *
	)

staticprivate

◆ GetContinuousStepLimit()

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

pure virtual

Implements G4VContinuousDiscreteProcess.

Implemented in G4eLowEnergyLoss.

◆ GetLossWithFluct()

G4double G4RDVeLowEnergyLoss::GetLossWithFluct	(	const G4DynamicParticle *	aParticle,
		const G4MaterialCutsCouple *	couple,
		G4double	MeanLoss,
		G4double	step
	)

protected

Definition at line 823 of file G4RDVeLowEnergyLoss.cc.

 {
    static const G4double minLoss = 1.*eV ;
    static const G4double probLim = 0.01 ;
    static const G4double sumaLim = -std::log(probLim) ;
    static const G4double alim=10.;
    static const G4double kappa = 10. ;
    static const G4double factor = twopi_mc2_rcl2 ;
   const G4Material* aMaterial = couple->GetMaterial();
 
   // check if the material has changed ( cache mechanism)
 
   if (aMaterial != lastMaterial)
     {
       lastMaterial = aMaterial;
       imat         = couple->GetIndex();
       f1Fluct      = aMaterial->GetIonisation()->GetF1fluct();
       f2Fluct      = aMaterial->GetIonisation()->GetF2fluct();
       e1Fluct      = aMaterial->GetIonisation()->GetEnergy1fluct();
       e2Fluct      = aMaterial->GetIonisation()->GetEnergy2fluct();
       e1LogFluct   = aMaterial->GetIonisation()->GetLogEnergy1fluct();
       e2LogFluct   = aMaterial->GetIonisation()->GetLogEnergy2fluct();
       rateFluct    = aMaterial->GetIonisation()->GetRateionexcfluct();
       ipotFluct    = aMaterial->GetIonisation()->GetMeanExcitationEnergy();
       ipotLogFluct = aMaterial->GetIonisation()->GetLogMeanExcEnergy();
     }
   G4double threshold,w1,w2,C,
            beta2,suma,e0,loss,lossc,w;
   G4double a1,a2,a3;
   G4int p1,p2,p3;
   G4int nb;
   G4double Corrfac, na,alfa,rfac,namean,sa,alfa1,ea,sea;
   //  G4double dp1;
   G4double dp3;
   G4double siga ;
 
   // shortcut for very very small loss
   if(MeanLoss < minLoss) return MeanLoss ;
 
   // get particle data
   G4double Tkin   = aParticle->GetKineticEnergy();
 
   //  G4cout << "MGP -- Fluc Tkin " << Tkin/keV << " keV "  << " MeanLoss = " << MeanLoss/keV << G4endl;
 
   threshold = (*((G4ProductionCutsTable::GetProductionCutsTable())
                 ->GetEnergyCutsVector(1)))[imat];
   G4double rmass = electron_mass_c2/ParticleMass;
   G4double tau   = Tkin/ParticleMass, tau1 = tau+1., tau2 = tau*(tau+2.);
   G4double Tm    = 2.*electron_mass_c2*tau2/(1.+2.*tau1*rmass+rmass*rmass);
 
   // G4cout << "MGP Particle mass " << ParticleMass/MeV << " Tm " << Tm << G4endl;
 
   if(Tm > threshold) Tm = threshold;
   beta2 = tau2/(tau1*tau1);
 
   // Gaussian fluctuation ?
   if(MeanLoss >= kappa*Tm || MeanLoss <= kappa*ipotFluct)
   {
     G4double electronDensity = aMaterial->GetElectronDensity() ;
     siga = std::sqrt(Tm*(1.0-0.5*beta2)*step*
                 factor*electronDensity/beta2) ;
     do {
       loss = G4RandGauss::shoot(MeanLoss,siga) ;
     } while (loss < 0. || loss > 2.0*MeanLoss);
     return loss ;
   }
 
   w1 = Tm/ipotFluct;
   w2 = std::log(2.*electron_mass_c2*tau2);
 
   C = MeanLoss*(1.-rateFluct)/(w2-ipotLogFluct-beta2);
 
   a1 = C*f1Fluct*(w2-e1LogFluct-beta2)/e1Fluct;
   a2 = C*f2Fluct*(w2-e2LogFluct-beta2)/e2Fluct;
   a3 = rateFluct*MeanLoss*(Tm-ipotFluct)/(ipotFluct*Tm*std::log(w1));
 
   suma = a1+a2+a3;
 
   loss = 0. ;
 
   if(suma < sumaLim)             // very small Step
     {
       e0 = aMaterial->GetIonisation()->GetEnergy0fluct();
       // G4cout << "MGP e0 = " << e0/keV << G4endl;
 
       if(Tm == ipotFluct)
     {
       a3 = MeanLoss/e0;
 
       if(a3>alim)
         {
           siga=std::sqrt(a3) ;
           p3 = std::max(0,G4int(G4RandGauss::shoot(a3,siga)+0.5));
         }
       else p3 = G4Poisson(a3);
 
       loss = p3*e0 ;
 
       if(p3 > 0) loss += (1.-2.*G4UniformRand())*e0 ;
       // G4cout << "MGP very small step " << loss/keV << G4endl;
     }
       else
     {
       //      G4cout << "MGP old Tm = " << Tm << " " << ipotFluct << " " << e0 << G4endl;
       Tm = Tm-ipotFluct+e0 ;
 
       // MGP ---- workaround to avoid log argument<0, TO BE CHECKED
       if (Tm <= 0.)
         {
           loss = MeanLoss;
           p3 = 0;
           // G4cout << "MGP correction loss = MeanLoss " << loss/keV << G4endl;
         }
       else
         {
           a3 = MeanLoss*(Tm-e0)/(Tm*e0*std::log(Tm/e0));
 
           // G4cout << "MGP new Tm = " << Tm << " " << ipotFluct << " " << e0 << " a3= " << a3 << G4endl;
           
           if(a3>alim)
         {
           siga=std::sqrt(a3) ;
           p3 = std::max(0,G4int(G4RandGauss::shoot(a3,siga)+0.5));
         }
           else
         p3 = G4Poisson(a3);
           //G4cout << "MGP p3 " << p3 << G4endl;
 
         }
           
       if(p3 > 0)
         {
           w = (Tm-e0)/Tm ;
           if(p3 > nmaxCont2)
         {
           // G4cout << "MGP dp3 " << dp3 << " p3 " << p3 << " " << nmaxCont2 << G4endl;
           dp3 = G4double(p3) ;
           Corrfac = dp3/G4double(nmaxCont2) ;
           p3 = nmaxCont2 ;
         }
           else
         Corrfac = 1. ;
           
           for(G4int i=0; i<p3; i++) loss += 1./(1.-w*G4UniformRand()) ;
           loss *= e0*Corrfac ; 
           // G4cout << "MGP Corrfac = " << Corrfac << " e0 = " << e0/keV << " loss = " << loss/keV << G4endl;
         }        
     }
     }
 
   else                              // not so small Step
     {
       // excitation type 1
       if(a1>alim)
       {
         siga=std::sqrt(a1) ;
         p1 = std::max(0,int(G4RandGauss::shoot(a1,siga)+0.5));
       }
       else
        p1 = G4Poisson(a1);
 
       // excitation type 2
       if(a2>alim)
       {
         siga=std::sqrt(a2) ;
         p2 = std::max(0,int(G4RandGauss::shoot(a2,siga)+0.5));
       }
       else
         p2 = G4Poisson(a2);
 
       loss = p1*e1Fluct+p2*e2Fluct;
  
       // smearing to avoid unphysical peaks
       if(p2 > 0)
         loss += (1.-2.*G4UniformRand())*e2Fluct;
       else if (loss>0.)
         loss += (1.-2.*G4UniformRand())*e1Fluct;   
       
       // ionisation .......................................
       if(a3 > 0.)
     {
       if(a3>alim)
         {
           siga=std::sqrt(a3) ;
           p3 = std::max(0,int(G4RandGauss::shoot(a3,siga)+0.5));
         }
       else
         p3 = G4Poisson(a3);
       
       lossc = 0.;
       if(p3 > 0)
         {
           na = 0.; 
           alfa = 1.;
           if (p3 > nmaxCont2)
         {
           dp3        = G4double(p3);
           rfac       = dp3/(G4double(nmaxCont2)+dp3);
           namean     = G4double(p3)*rfac;
           sa         = G4double(nmaxCont1)*rfac;
           na         = G4RandGauss::shoot(namean,sa);
           if (na > 0.)
             {
               alfa   = w1*G4double(nmaxCont2+p3)/(w1*G4double(nmaxCont2)+G4double(p3));
               alfa1  = alfa*std::log(alfa)/(alfa-1.);
               ea     = na*ipotFluct*alfa1;
               sea    = ipotFluct*std::sqrt(na*(alfa-alfa1*alfa1));
               lossc += G4RandGauss::shoot(ea,sea);
             }
         }
           
           nb = G4int(G4double(p3)-na);
           if (nb > 0)
         {
           w2 = alfa*ipotFluct;
           w  = (Tm-w2)/Tm;      
           for (G4int k=0; k<nb; k++) lossc += w2/(1.-w*G4UniformRand());
         }
         }        
       
       loss += lossc;  
     }
     } 
   
   return loss ;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMeanFreePath()

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

pure virtual

Implements G4VContinuousDiscreteProcess.

Implemented in G4eLowEnergyLoss, G4LowEnergyBremsstrahlung, and G4LowEnergyIonisation.

◆ InvertRangeVector()

void G4RDVeLowEnergyLoss::InvertRangeVector	(	G4PhysicsTable *	theRangeTable,
		G4PhysicsTable *	theRangeCoeffATable,
		G4PhysicsTable *	theRangeCoeffBTable,
		G4PhysicsTable *	theRangeCoeffCTable,
		G4double	Tmin,
		G4double	Tmax,
		G4int	nbin,
		G4int	materialIndex,
		G4PhysicsLogVector *	rangeVector
	)

staticprivate

Definition at line 583 of file G4RDVeLowEnergyLoss.cc.

 {
   G4double LowEdgeRange,A,B,C,discr,KineticEnergy ;
   G4double RTable = std::exp(std::log(highestKineticEnergy/lowestKineticEnergy)/TotBin) ;
   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 G4RDVeLowEnergyLoss::LabTimeIntLog	(	G4PhysicsVector *	physicsVector,
		G4int	nbin
	)

staticprivate

Definition at line 448 of file G4RDVeLowEnergyLoss.cc.

 {
   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:

◆ operator=()

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

private

◆ PostStepDoIt()

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

pure virtual

Reimplemented from G4VContinuousDiscreteProcess.

Implemented in G4eLowEnergyLoss, G4LowEnergyBremsstrahlung, and G4LowEnergyIonisation.

◆ ProperTimeIntLog()

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

staticprivate

Definition at line 481 of file G4RDVeLowEnergyLoss.cc.

 {
   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 G4RDVeLowEnergyLoss::RangeIntLin	(	G4PhysicsVector *	physicsVector,
		G4int	nbin
	)

staticprivate

Definition at line 197 of file G4RDVeLowEnergyLoss.cc.

 {
   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 = 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/lossi;
   }
   Value *= ParticleMass*dtau;
   return Value;
 }

Here is the call graph for this function:

◆ RangeIntLog()

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

staticprivate

Definition at line 228 of file G4RDVeLowEnergyLoss.cc.

 {
   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/lossi;
   }
   Value *= ParticleMass*dltau;
   return Value;
 }

Here is the call graph for this function:

◆ SetEnlossFluc()

void G4RDVeLowEnergyLoss::SetEnlossFluc ( G4bool value )

static

Definition at line 114 of file G4RDVeLowEnergyLoss.cc.

 {
    EnlossFlucFlag = value;
 }

◆ SetRndmStep()

void G4RDVeLowEnergyLoss::SetRndmStep ( G4bool value )

static

Definition at line 109 of file G4RDVeLowEnergyLoss.cc.

 {
    rndmStepFlag   = value;
 }

◆ SetStepFunction()

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

static

Definition at line 119 of file G4RDVeLowEnergyLoss.cc.

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

Member Data Documentation

◆ c1lim

G4double G4RDVeLowEnergyLoss::c1lim = dRoverRange

staticprotected

Definition at line 238 of file G4RDVeLowEnergyLoss.hh.

◆ c2lim

G4double G4RDVeLowEnergyLoss::c2lim = 2.*(1.-dRoverRange)*finalRange

staticprotected

Definition at line 238 of file G4RDVeLowEnergyLoss.hh.

◆ c3lim

G4double G4RDVeLowEnergyLoss::c3lim = -(1.-dRoverRange)*finalRange*finalRange

staticprotected

Definition at line 238 of file G4RDVeLowEnergyLoss.hh.

◆ dRoverRange

G4double G4RDVeLowEnergyLoss::dRoverRange = 20*perCent

staticprotected

Definition at line 235 of file G4RDVeLowEnergyLoss.hh.

◆ e1Fluct

G4double G4RDVeLowEnergyLoss::e1Fluct

protected

Definition at line 126 of file G4RDVeLowEnergyLoss.hh.

◆ e1LogFluct

G4double G4RDVeLowEnergyLoss::e1LogFluct

protected

Definition at line 127 of file G4RDVeLowEnergyLoss.hh.

◆ e2Fluct

G4double G4RDVeLowEnergyLoss::e2Fluct

protected

Definition at line 126 of file G4RDVeLowEnergyLoss.hh.

◆ e2LogFluct

G4double G4RDVeLowEnergyLoss::e2LogFluct

protected

Definition at line 127 of file G4RDVeLowEnergyLoss.hh.

◆ EnlossFlucFlag

G4bool G4RDVeLowEnergyLoss::EnlossFlucFlag = true

staticprotected

Definition at line 241 of file G4RDVeLowEnergyLoss.hh.

◆ f1Fluct

G4double G4RDVeLowEnergyLoss::f1Fluct

protected

Definition at line 126 of file G4RDVeLowEnergyLoss.hh.

◆ f2Fluct

G4double G4RDVeLowEnergyLoss::f2Fluct

protected

Definition at line 126 of file G4RDVeLowEnergyLoss.hh.

◆ finalRange

G4double G4RDVeLowEnergyLoss::finalRange = 200*micrometer

staticprotected

Definition at line 237 of file G4RDVeLowEnergyLoss.hh.

◆ imat

G4int G4RDVeLowEnergyLoss::imat

protected

Definition at line 125 of file G4RDVeLowEnergyLoss.hh.

◆ ipotFluct

G4double G4RDVeLowEnergyLoss::ipotFluct

protected

Definition at line 126 of file G4RDVeLowEnergyLoss.hh.

◆ ipotLogFluct

G4double G4RDVeLowEnergyLoss::ipotLogFluct

protected

Definition at line 127 of file G4RDVeLowEnergyLoss.hh.

◆ lastMaterial

const G4Material* G4RDVeLowEnergyLoss::lastMaterial

protected

Definition at line 124 of file G4RDVeLowEnergyLoss.hh.

◆ ltauhigh

G4double G4RDVeLowEnergyLoss::ltauhigh

staticprotected

Definition at line 232 of file G4RDVeLowEnergyLoss.hh.

◆ ltaulow

G4double G4RDVeLowEnergyLoss::ltaulow

staticprotected

Definition at line 232 of file G4RDVeLowEnergyLoss.hh.

◆ nmaxCont1

const G4int G4RDVeLowEnergyLoss::nmaxCont1

protected

Definition at line 129 of file G4RDVeLowEnergyLoss.hh.

◆ nmaxCont2

const G4int G4RDVeLowEnergyLoss::nmaxCont2

protected

Definition at line 129 of file G4RDVeLowEnergyLoss.hh.

◆ ParticleMass

G4double G4RDVeLowEnergyLoss::ParticleMass

staticprotected

Definition at line 232 of file G4RDVeLowEnergyLoss.hh.

◆ rateFluct

G4double G4RDVeLowEnergyLoss::rateFluct

protected

Definition at line 126 of file G4RDVeLowEnergyLoss.hh.

◆ rndmStepFlag

G4bool G4RDVeLowEnergyLoss::rndmStepFlag = false

staticprotected

Definition at line 240 of file G4RDVeLowEnergyLoss.hh.

◆ tauhigh

G4double G4RDVeLowEnergyLoss::tauhigh

staticprotected

Definition at line 232 of file G4RDVeLowEnergyLoss.hh.

◆ taulow

G4double G4RDVeLowEnergyLoss::taulow

staticprotected

Definition at line 232 of file G4RDVeLowEnergyLoss.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

Detailed Description

Constructor & Destructor Documentation

◆ G4RDVeLowEnergyLoss() [1/3]

◆ G4RDVeLowEnergyLoss() [2/3]

◆ ~G4RDVeLowEnergyLoss()

◆ G4RDVeLowEnergyLoss() [3/3]

Member Function Documentation

◆ AlongStepDoIt()

◆ BuildInverseRangeTable()

◆ BuildLabTimeTable()

◆ BuildLabTimeVector()

◆ BuildProperTimeTable()

◆ BuildProperTimeVector()

◆ BuildRangeCoeffATable()

◆ BuildRangeCoeffBTable()

◆ BuildRangeCoeffCTable()

◆ BuildRangeTable()

◆ BuildRangeVector()

◆ BuildRangeVectorNew()

◆ GetContinuousStepLimit()

◆ GetLossWithFluct()

◆ GetMeanFreePath()

◆ InvertRangeVector()

◆ LabTimeIntLog()

◆ operator=()

◆ PostStepDoIt()

◆ ProperTimeIntLog()

◆ RangeIntLin()

◆ RangeIntLog()

◆ SetEnlossFluc()

◆ SetRndmStep()

◆ SetStepFunction()

Member Data Documentation

◆ c1lim

◆ c2lim

◆ c3lim

◆ dRoverRange

◆ e1Fluct

◆ e1LogFluct

◆ e2Fluct

◆ e2LogFluct

◆ EnlossFlucFlag

◆ f1Fluct

◆ f2Fluct

◆ finalRange

◆ imat

◆ ipotFluct

◆ ipotLogFluct

◆ lastMaterial

◆ ltauhigh

◆ ltaulow

◆ nmaxCont1

◆ nmaxCont2

◆ ParticleMass

◆ rateFluct

◆ rndmStepFlag

◆ tauhigh

◆ taulow