#include <G4VeLowEnergyLoss.hh>

Inheritance diagram for G4VeLowEnergyLoss:

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

	G4VeLowEnergyLoss (G4VeLowEnergyLoss &)

virtual	~G4VeLowEnergyLoss ()

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 G4VParticleChange *	PostStepDoIt (const G4Track &, const G4Step &)

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

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

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

virtual G4VParticleChange *	AtRestDoIt (const G4Track &track, const G4Step &stepData)=0

virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)=0

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &track, G4ForceCondition *condition)=0

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

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

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
virtual G4double	GetMeanFreePath (const G4Track &aTrack, G4double previousStepSize, G4ForceCondition *condition)=0

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

Detailed Description

Definition at line 77 of file G4VeLowEnergyLoss.hh.

Constructor & Destructor Documentation

◆ G4VeLowEnergyLoss() [1/2]

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

Definition at line 87 of file G4VeLowEnergyLoss.cc.

                  : G4VContinuousDiscreteProcess(aName, aType),
            lastMaterial(0),
            imat(-1),
            f1Fluct(0),f2Fluct(0),e1Fluct(0),e2Fluct(0),rateFluct(0),
            ipotFluct(0),e1LogFluct(-1),e2LogFluct(-1),ipotLogFluct(-1),        
            nmaxCont1(4),
            nmaxCont2(16)
{;}

Referenced by G4VeLowEnergyLoss().

◆ G4VeLowEnergyLoss() [2/2]

G4VeLowEnergyLoss::G4VeLowEnergyLoss ( G4VeLowEnergyLoss & right )

Definition at line 105 of file G4VeLowEnergyLoss.cc.

                  : G4VContinuousDiscreteProcess(right),
            lastMaterial(0),
            imat(-1),
            f1Fluct(0),f2Fluct(0),e1Fluct(0),e2Fluct(0),rateFluct(0),
            ipotFluct(0),e1LogFluct(-1),e2LogFluct(-1),ipotLogFluct(-1),
            nmaxCont1(4),
            nmaxCont2(16)
{;}

◆ ~G4VeLowEnergyLoss()

G4VeLowEnergyLoss::~G4VeLowEnergyLoss ( )

virtual

Definition at line 99 of file G4VeLowEnergyLoss.cc.

100{

101}

Member Function Documentation

◆ AlongStepDoIt()

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

pure virtual

Reimplemented from G4VContinuousDiscreteProcess.

◆ BuildInverseRangeTable()

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

staticprotected

Definition at line 524 of file G4VeLowEnergyLoss.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-1);
 
    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 ;
}

◆ BuildLabTimeTable()

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

staticprotected

Definition at line 268 of file G4VeLowEnergyLoss.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 ;
}

◆ BuildProperTimeTable()

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

staticprotected

Definition at line 301 of file G4VeLowEnergyLoss.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 ;
}

◆ BuildRangeCoeffATable()

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

staticprotected

Definition at line 649 of file G4VeLowEnergyLoss.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)
        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 ;
}

◆ BuildRangeCoeffBTable()

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

staticprotected

Definition at line 711 of file G4VeLowEnergyLoss.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)
        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 ;
}

◆ BuildRangeCoeffCTable()

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

staticprotected

Definition at line 772 of file G4VeLowEnergyLoss.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)
        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 ;
}

◆ BuildRangeTable()

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

staticprotected

Definition at line 134 of file G4VeLowEnergyLoss.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 ;
}

◆ GetContinuousStepLimit()

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

pure virtual

Implements G4VContinuousDiscreteProcess.

◆ GetLossWithFluct()

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

protected

Definition at line 833 of file G4VeLowEnergyLoss.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 ;
}

◆ GetMeanFreePath()

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

pure virtual

Implements G4VContinuousDiscreteProcess.

◆ PostStepDoIt()

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

pure virtual

Reimplemented from G4VContinuousDiscreteProcess.

◆ SetEnlossFluc()

void G4VeLowEnergyLoss::SetEnlossFluc ( G4bool value )

static

Definition at line 120 of file G4VeLowEnergyLoss.cc.

{
   EnlossFlucFlag = value;
}

◆ SetRndmStep()

void G4VeLowEnergyLoss::SetRndmStep ( G4bool value )

static

Definition at line 115 of file G4VeLowEnergyLoss.cc.

{
   rndmStepFlag   = value;
}

◆ SetStepFunction()

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

static

Definition at line 125 of file G4VeLowEnergyLoss.cc.

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

Member Data Documentation

◆ c1lim

G4double G4VeLowEnergyLoss::c1lim = dRoverRange

staticprotected

Definition at line 237 of file G4VeLowEnergyLoss.hh.

Referenced by SetStepFunction().

◆ c2lim

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

staticprotected

Definition at line 237 of file G4VeLowEnergyLoss.hh.

Referenced by SetStepFunction().

◆ c3lim

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

staticprotected

Definition at line 237 of file G4VeLowEnergyLoss.hh.

Referenced by SetStepFunction().

◆ dRoverRange

G4double G4VeLowEnergyLoss::dRoverRange = 20*perCent

staticprotected

Definition at line 234 of file G4VeLowEnergyLoss.hh.

Referenced by SetStepFunction().

◆ e1Fluct

G4double G4VeLowEnergyLoss::e1Fluct

protected

Definition at line 125 of file G4VeLowEnergyLoss.hh.

Referenced by GetLossWithFluct().

◆ e1LogFluct

G4double G4VeLowEnergyLoss::e1LogFluct

protected

Definition at line 126 of file G4VeLowEnergyLoss.hh.

Referenced by GetLossWithFluct().

◆ e2Fluct

G4double G4VeLowEnergyLoss::e2Fluct

protected

Definition at line 125 of file G4VeLowEnergyLoss.hh.

Referenced by GetLossWithFluct().

◆ e2LogFluct

G4double G4VeLowEnergyLoss::e2LogFluct

protected

Definition at line 126 of file G4VeLowEnergyLoss.hh.

Referenced by GetLossWithFluct().

◆ EnlossFlucFlag

G4bool G4VeLowEnergyLoss::EnlossFlucFlag = true

staticprotected

Definition at line 240 of file G4VeLowEnergyLoss.hh.

Referenced by SetEnlossFluc().

◆ f1Fluct

G4double G4VeLowEnergyLoss::f1Fluct

protected

Definition at line 125 of file G4VeLowEnergyLoss.hh.

Referenced by GetLossWithFluct().

◆ f2Fluct

G4double G4VeLowEnergyLoss::f2Fluct

protected

Definition at line 125 of file G4VeLowEnergyLoss.hh.

Referenced by GetLossWithFluct().

◆ finalRange

G4double G4VeLowEnergyLoss::finalRange = 200*micrometer

staticprotected

Definition at line 236 of file G4VeLowEnergyLoss.hh.

Referenced by SetStepFunction().

◆ imat

G4int G4VeLowEnergyLoss::imat

protected

Definition at line 124 of file G4VeLowEnergyLoss.hh.

Referenced by GetLossWithFluct().

◆ ipotFluct

G4double G4VeLowEnergyLoss::ipotFluct

protected

Definition at line 125 of file G4VeLowEnergyLoss.hh.

Referenced by GetLossWithFluct().

◆ ipotLogFluct

G4double G4VeLowEnergyLoss::ipotLogFluct

protected

Definition at line 126 of file G4VeLowEnergyLoss.hh.

Referenced by GetLossWithFluct().

◆ lastMaterial

const G4Material* G4VeLowEnergyLoss::lastMaterial

protected

Definition at line 123 of file G4VeLowEnergyLoss.hh.

Referenced by GetLossWithFluct().

◆ ltauhigh

G4double G4VeLowEnergyLoss::ltauhigh

staticprotected

Definition at line 231 of file G4VeLowEnergyLoss.hh.

◆ ltaulow

G4double G4VeLowEnergyLoss::ltaulow

staticprotected

Definition at line 231 of file G4VeLowEnergyLoss.hh.

◆ nmaxCont1

const G4int G4VeLowEnergyLoss::nmaxCont1

protected

Definition at line 128 of file G4VeLowEnergyLoss.hh.

Referenced by GetLossWithFluct().

◆ nmaxCont2

const G4int G4VeLowEnergyLoss::nmaxCont2

protected

Definition at line 128 of file G4VeLowEnergyLoss.hh.

Referenced by GetLossWithFluct().

◆ ParticleMass

G4double G4VeLowEnergyLoss::ParticleMass

staticprotected

Definition at line 231 of file G4VeLowEnergyLoss.hh.

Referenced by GetLossWithFluct().

◆ rateFluct

G4double G4VeLowEnergyLoss::rateFluct

protected

Definition at line 125 of file G4VeLowEnergyLoss.hh.

Referenced by GetLossWithFluct().

◆ rndmStepFlag

G4bool G4VeLowEnergyLoss::rndmStepFlag = false

staticprotected

Definition at line 239 of file G4VeLowEnergyLoss.hh.

Referenced by SetRndmStep().

◆ tauhigh

G4double G4VeLowEnergyLoss::tauhigh

staticprotected

Definition at line 231 of file G4VeLowEnergyLoss.hh.

◆ taulow

G4double G4VeLowEnergyLoss::taulow

staticprotected

Definition at line 231 of file G4VeLowEnergyLoss.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

Detailed Description

Constructor & Destructor Documentation

◆ G4VeLowEnergyLoss() [1/2]

◆ G4VeLowEnergyLoss() [2/2]

◆ ~G4VeLowEnergyLoss()

Member Function Documentation

◆ AlongStepDoIt()

◆ BuildInverseRangeTable()

◆ BuildLabTimeTable()

◆ BuildProperTimeTable()

◆ BuildRangeCoeffATable()

◆ BuildRangeCoeffBTable()

◆ BuildRangeCoeffCTable()

◆ BuildRangeTable()

◆ GetContinuousStepLimit()

◆ GetLossWithFluct()

◆ GetMeanFreePath()

◆ PostStepDoIt()

◆ 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