#include <G4VEnergyLoss.hh>

Inheritance diagram for G4VEnergyLoss:

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

virtual	~G4VEnergyLoss ()

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	SetSubSec (G4bool value)

static void	SetMinDeltaCutInRange (G4double 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 ChargeSquare, G4double MeanLoss, G4double step)

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

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

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

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

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

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

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

G4bool	CutsWhereModified ()

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 G4bool	EqualCutVectors (G4double vec1, G4double vec2)

static G4double *	CopyCutVectors (G4double dest, G4double source)

Static Protected Attributes
static G4double	dRoverRange = 20*perCent

static G4double	finalRange = 1*mm

static G4double	finalRangeRequested = -1*mm

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

static G4bool	subSecFlag = false

static G4double	MinDeltaCutInRange = 0.100*mm

static G4double *	MinDeltaEnergy = 0

static G4bool *	LowerLimitForced = 0

static G4bool	setMinDeltaCutInRange = false

static G4EnergyLossMessenger *	ELossMessenger = 0

Detailed Description

Definition at line 68 of file G4VEnergyLoss.hh.

Constructor & Destructor Documentation

◆ G4VEnergyLoss()

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

Definition at line 81 of file G4VEnergyLoss.cc.

                  : G4VContinuousDiscreteProcess(aName, aType),
     lastMaterial(NULL),
     nmaxCont1(4),
     nmaxCont2(16)
{
  if(!ELossMessenger) { 
    G4cout << "### G4VEnergyLoss class is obsolete "
       << "and will be removed for the next release." << G4endl;
    ELossMessenger = new G4EnergyLossMessenger(); 
  }
 
  imat = 0;
  f1Fluct = f2Fluct = e1Fluct = e2Fluct = rateFluct = ipotFluct = e1LogFluct 
    = e2LogFluct = ipotLogFluct = taulow = tauhigh = ltaulow = ltauhigh 
    = ParticleMass = 0.0;
}

◆ ~G4VEnergyLoss()

G4VEnergyLoss::~G4VEnergyLoss ( )

virtual

Definition at line 101 of file G4VEnergyLoss.cc.

102{}

Member Function Documentation

◆ AlongStepDoIt()

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

pure virtual

Reimplemented from G4VContinuousDiscreteProcess.

◆ BuildInverseRangeTable()

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

protected

Definition at line 618 of file G4VEnergyLoss.cc.

{
  G4double SmallestRange,BiggestRange ;
  G4bool isOut ;
  size_t numOfMaterials = theRangeTable->length();
 
    if(theInverseRangeTable)
    { theInverseRangeTable->clearAndDestroy();
      delete theInverseRangeTable; }
    theInverseRangeTable = new G4PhysicsTable(numOfMaterials);
 
  // loop for materials
  for (size_t J=0;  J<numOfMaterials; J++)
  {
    SmallestRange = (*theRangeTable)(J)->
                       GetValue(LowestKineticEnergy,isOut) ;
    BiggestRange = (*theRangeTable)(J)->
                       GetValue(HighestKineticEnergy,isOut) ;
    G4PhysicsLogVector* aVector;
    aVector = new G4PhysicsLogVector(SmallestRange,
                            BiggestRange,TotBin);
 
    InvertRangeVector(theRangeTable,
                      theRangeCoeffATable,
                      theRangeCoeffBTable,
                      theRangeCoeffCTable,
         LowestKineticEnergy,HighestKineticEnergy,TotBin,J, aVector);
 
    theInverseRangeTable->insert(aVector);
  }
  return theInverseRangeTable ;
}

◆ BuildLabTimeTable()

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

protected

Definition at line 367 of file G4VEnergyLoss.cc.

{
  size_t numOfMaterials = theDEDXTable->length();
 
  if(theLabTimeTable)
  { theLabTimeTable->clearAndDestroy();
    delete theLabTimeTable; }
  theLabTimeTable = new G4PhysicsTable(numOfMaterials);
 
 
  for (size_t J=0;  J<numOfMaterials; J++)
  {
    G4PhysicsLogVector* aVector;
 
    aVector = new G4PhysicsLogVector(LowestKineticEnergy,
                            HighestKineticEnergy,TotBin);
 
    BuildLabTimeVector(theDEDXTable,
              LowestKineticEnergy,HighestKineticEnergy,TotBin,J,aVector);
    theLabTimeTable->insert(aVector);
 
 
  }
  return theLabTimeTable ;
}

◆ BuildProperTimeTable()

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

protected

Definition at line 399 of file G4VEnergyLoss.cc.

{
  size_t numOfMaterials = theDEDXTable->length();
 
  if(theProperTimeTable)
  { theProperTimeTable->clearAndDestroy();
    delete theProperTimeTable; }
  theProperTimeTable = new G4PhysicsTable(numOfMaterials);
 
 
  for (size_t J=0;  J<numOfMaterials; J++)
  {
    G4PhysicsLogVector* aVector;
 
    aVector = new G4PhysicsLogVector(LowestKineticEnergy,
                            HighestKineticEnergy,TotBin);
 
    BuildProperTimeVector(theDEDXTable,
              LowestKineticEnergy,HighestKineticEnergy,TotBin,J,aVector);
    theProperTimeTable->insert(aVector);
 
 
  }
  return theProperTimeTable ;
}

◆ BuildRangeCoeffATable()

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

protected

Definition at line 716 of file G4VEnergyLoss.cc.

{
  G4int numOfMaterials = theRangeTable->length();
 
  if(theRangeCoeffATable)
  { theRangeCoeffATable->clearAndDestroy();
    delete theRangeCoeffATable; }
  theRangeCoeffATable = new G4PhysicsTable(numOfMaterials);
 
  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<numOfMaterials; 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 ;
}

◆ BuildRangeCoeffBTable()

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

protected

Definition at line 777 of file G4VEnergyLoss.cc.

{
  G4int numOfMaterials = theRangeTable->length();
 
  if(theRangeCoeffBTable)
  { theRangeCoeffBTable->clearAndDestroy();
    delete theRangeCoeffBTable; }
  theRangeCoeffBTable = new G4PhysicsTable(numOfMaterials);
 
  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<numOfMaterials; 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 ;
}

◆ BuildRangeCoeffCTable()

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

protected

Definition at line 837 of file G4VEnergyLoss.cc.

{
  G4int numOfMaterials = theRangeTable->length();
 
  if(theRangeCoeffCTable)
  { theRangeCoeffCTable->clearAndDestroy();
    delete theRangeCoeffCTable; }
  theRangeCoeffCTable = new G4PhysicsTable(numOfMaterials);
 
  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<numOfMaterials; 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 ;
}

◆ BuildRangeTable()

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

protected

Definition at line 133 of file G4VEnergyLoss.cc.

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

◆ CopyCutVectors()

G4double * G4VEnergyLoss::CopyCutVectors	(	G4double *	dest,
		G4double *	source
	)

staticprotected

Definition at line 1131 of file G4VEnergyLoss.cc.

{
  if ( dest != 0) delete [] dest;
  dest = new G4double [G4Material::GetNumberOfMaterials()];
  for (size_t j=0; j<G4Material::GetNumberOfMaterials(); j++){
    dest[j] = source[j];
  }
  return dest;
}

◆ CutsWhereModified()

G4bool G4VEnergyLoss::CutsWhereModified ( )

protected

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

◆ EqualCutVectors()

G4bool G4VEnergyLoss::EqualCutVectors	(	G4double *	vec1,
		G4double *	vec2
	)

staticprotected

Definition at line 1116 of file G4VEnergyLoss.cc.

{
  if ( (vec1==0 ) || (vec2==0) ) return false;
  
  G4bool flag = true;
   
  for (size_t j=0; flag && j<G4Material::GetNumberOfMaterials(); j++){
    flag = (vec1[j] == vec2[j]);
  }
 
  return flag;
}

◆ GetContinuousStepLimit()

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

pure virtual

Implements G4VContinuousDiscreteProcess.

◆ GetLossWithFluct()

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

protected

Definition at line 897 of file G4VEnergyLoss.cc.

{
  const G4double minLoss = 1.*eV ;
  const G4double probLim = 0.01 ;
  const G4double sumaLim = -std::log(probLim) ;
  const G4double alim=10.;
  const G4double kappa = 10. ;
  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,electronDensity;
  G4double a1,a2,a3;
  G4double p1,p2,p3 ;
  G4int nb;
  G4double Corrfac, na,alfa,rfac,namean,sa,alfa1,ea,sea;
  G4double dp3;
  G4double siga ;
 
  // shortcut for very very small loss
  if(MeanLoss < minLoss) return MeanLoss ;
 
  // get particle data
  G4double Tkin   = aParticle->GetKineticEnergy();
  ParticleMass = aParticle->GetMass() ;
 
  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);
 
  if(Tm > threshold) Tm = threshold;
 
  beta2 = tau2/(tau1*tau1);
 
  // Gaussian fluctuation ?
  if(MeanLoss >= kappa*Tm || Tm < kappa*ipotFluct)
  {
    electronDensity = aMaterial->GetElectronDensity() ;
    siga = std::sqrt(Tm*(1.0-0.5*beta2)*step*
                factor*electronDensity*ChargeSquare/beta2) ;
    do {
      loss = G4RandGauss::shoot(MeanLoss,siga) ;
    } while (loss < 0. || loss > 2.*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));
  if(a1 < 0.) a1 = 0.;
  if(a2 < 0.) a2 = 0.;
  if(a3 < 0.) a3 = 0.;
 
  suma = a1+a2+a3;
 
  loss = 0. ;
 
  if(suma < sumaLim)             // very small Step
    {
      e0 = aMaterial->GetIonisation()->GetEnergy0fluct();
 
      if(Tm == ipotFluct)
      {
        a3 = MeanLoss/e0;
 
        if(a3>alim)
        {
          siga=std::sqrt(a3) ;
          p3 = std::max(0.,G4RandGauss::shoot(a3,siga)+0.5);
        }
        else
          p3 = G4float(G4Poisson(a3));
 
        loss = p3*e0 ;
 
        if(p3 > 0)
          loss += (1.-2.*G4UniformRand())*e0 ;
 
      }
      else
      {
        Tm = Tm-ipotFluct+e0 ;
        a3 = MeanLoss*(Tm-e0)/(Tm*e0*std::log(Tm/e0));
 
        if(a3>alim)
        {
          siga=std::sqrt(a3) ;
          p3 = std::max(0.,G4RandGauss::shoot(a3,siga)+0.5);
        }
        else
          p3 = G4float(G4Poisson(a3));
 
        if(p3 > 0)
        {
          w = (Tm-e0)/Tm ;
          if(p3 > G4float(nmaxCont2))
          {
            dp3 = p3 ;
            Corrfac = dp3/G4float(nmaxCont2) ;
            p3 = G4float(nmaxCont2) ;
          }
          else
            Corrfac = 1. ;
 
          for(G4int i=0; i<G4int(p3); i++) loss += 1./(1.-w*G4UniformRand()) ;
          loss *= e0*Corrfac ;  
        }        
      }
    }
    
  else                              // not so small Step
    {
      // excitation type 1
      if(a1>alim)
      {
        siga=std::sqrt(a1) ;
        p1 = std::max(0.,G4RandGauss::shoot(a1,siga)+0.5);
      }
      else
       p1 = G4float(G4Poisson(a1));
 
      // excitation type 2
      if(a2>alim)
      {
        siga=std::sqrt(a2) ;
        p2 = std::max(0.,G4RandGauss::shoot(a2,siga)+0.5);
      }
      else
        p2 = G4float(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.,G4RandGauss::shoot(a3,siga)+0.5);
      }
      else
        p3 = G4float(G4Poisson(a3));
 
      lossc = 0.;
      if(p3 > 0)
      {
        na = 0.; 
        alfa = 1.;
        if (p3 > G4float(nmaxCont2))
        {
          dp3        = p3;
          rfac       = dp3/(G4float(nmaxCont2)+dp3);
          namean     = p3*rfac;
          sa         = G4float(nmaxCont1)*rfac;
          na         = G4RandGauss::shoot(namean,sa);
          if (na > 0.)
          {
            alfa   = w1*(G4float(nmaxCont2)+p3)/(w1*G4float(nmaxCont2)+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(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;  
     }
    } 
 
  if( loss < 0.)
    loss = 0.;
 
  return loss ;
}

◆ GetMeanFreePath()

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

pure virtual

Implements G4VContinuousDiscreteProcess.

◆ PostStepDoIt()

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

pure virtual

Reimplemented from G4VContinuousDiscreteProcess.

◆ SetEnlossFluc()

void G4VEnergyLoss::SetEnlossFluc ( G4bool value )

static

Definition at line 110 of file G4VEnergyLoss.cc.

110{EnlossFlucFlag = value;}

G4VEnergyLoss::EnlossFlucFlag

static G4bool EnlossFlucFlag

Definition: G4VEnergyLoss.hh:234

◆ SetMinDeltaCutInRange()

void G4VEnergyLoss::SetMinDeltaCutInRange ( G4double value )

static

Definition at line 118 of file G4VEnergyLoss.cc.

119{MinDeltaCutInRange = value; setMinDeltaCutInRange = true;}

G4VEnergyLoss::setMinDeltaCutInRange

static G4bool setMinDeltaCutInRange

Definition: G4VEnergyLoss.hh:241

G4VEnergyLoss::MinDeltaCutInRange

static G4double MinDeltaCutInRange

Definition: G4VEnergyLoss.hh:237

◆ SetRndmStep()

void G4VEnergyLoss::SetRndmStep ( G4bool value )

static

Definition at line 106 of file G4VEnergyLoss.cc.

106{rndmStepFlag = value;}

G4VEnergyLoss::rndmStepFlag

static G4bool rndmStepFlag

Definition: G4VEnergyLoss.hh:233

◆ SetStepFunction()

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

static

Definition at line 123 of file G4VEnergyLoss.cc.

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

◆ SetSubSec()

void G4VEnergyLoss::SetSubSec ( G4bool value )

static

Definition at line 114 of file G4VEnergyLoss.cc.

114{subSecFlag = value;}

G4VEnergyLoss::subSecFlag

static G4bool subSecFlag

Definition: G4VEnergyLoss.hh:235

Member Data Documentation

◆ c1lim

G4double G4VEnergyLoss::c1lim = dRoverRange

staticprotected

Definition at line 231 of file G4VEnergyLoss.hh.

Referenced by SetStepFunction().

◆ c2lim

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

staticprotected

Definition at line 231 of file G4VEnergyLoss.hh.

Referenced by SetStepFunction().

◆ c3lim

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

staticprotected

Definition at line 231 of file G4VEnergyLoss.hh.

Referenced by SetStepFunction().

◆ dRoverRange

G4double G4VEnergyLoss::dRoverRange = 20*perCent

staticprotected

Definition at line 227 of file G4VEnergyLoss.hh.

Referenced by SetStepFunction().

◆ ELossMessenger

G4EnergyLossMessenger * G4VEnergyLoss::ELossMessenger = 0

staticprotected

Definition at line 243 of file G4VEnergyLoss.hh.

Referenced by G4VEnergyLoss().

◆ EnlossFlucFlag

G4bool G4VEnergyLoss::EnlossFlucFlag = true

staticprotected

Definition at line 234 of file G4VEnergyLoss.hh.

Referenced by SetEnlossFluc().

◆ finalRange

G4double G4VEnergyLoss::finalRange = 1*mm

staticprotected

Definition at line 229 of file G4VEnergyLoss.hh.

◆ finalRangeRequested

G4double G4VEnergyLoss::finalRangeRequested = -1*mm

staticprotected

Definition at line 230 of file G4VEnergyLoss.hh.

Referenced by SetStepFunction().

◆ LowerLimitForced

G4bool * G4VEnergyLoss::LowerLimitForced = 0

staticprotected

Definition at line 239 of file G4VEnergyLoss.hh.

◆ MinDeltaCutInRange

G4double G4VEnergyLoss::MinDeltaCutInRange = 0.100*mm

staticprotected

Definition at line 237 of file G4VEnergyLoss.hh.

Referenced by SetMinDeltaCutInRange().

◆ MinDeltaEnergy

G4double * G4VEnergyLoss::MinDeltaEnergy = 0

staticprotected

Definition at line 238 of file G4VEnergyLoss.hh.

◆ ParticleMass

G4double G4VEnergyLoss::ParticleMass

protected

Definition at line 175 of file G4VEnergyLoss.hh.

Referenced by G4VEnergyLoss(), and GetLossWithFluct().

◆ rndmStepFlag

G4bool G4VEnergyLoss::rndmStepFlag = false

staticprotected

Definition at line 233 of file G4VEnergyLoss.hh.

Referenced by SetRndmStep().

◆ setMinDeltaCutInRange

G4bool G4VEnergyLoss::setMinDeltaCutInRange = false

staticprotected

Definition at line 241 of file G4VEnergyLoss.hh.

Referenced by SetMinDeltaCutInRange().

◆ subSecFlag

G4bool G4VEnergyLoss::subSecFlag = false

staticprotected

Definition at line 235 of file G4VEnergyLoss.hh.

Referenced by SetSubSec().

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

Protected Attributes
G4double	ParticleMass

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4VEnergyLoss()

◆ ~G4VEnergyLoss()

Member Function Documentation

◆ AlongStepDoIt()

◆ BuildInverseRangeTable()

◆ BuildLabTimeTable()

◆ BuildProperTimeTable()

◆ BuildRangeCoeffATable()

◆ BuildRangeCoeffBTable()

◆ BuildRangeCoeffCTable()

◆ BuildRangeTable()

◆ CopyCutVectors()

◆ CutsWhereModified()

◆ EqualCutVectors()

◆ GetContinuousStepLimit()

◆ GetLossWithFluct()

◆ GetMeanFreePath()

◆ PostStepDoIt()

◆ SetEnlossFluc()

◆ SetMinDeltaCutInRange()

◆ SetRndmStep()

◆ SetStepFunction()

◆ SetSubSec()

Member Data Documentation

◆ c1lim

◆ c2lim

◆ c3lim

◆ dRoverRange

◆ ELossMessenger

◆ EnlossFlucFlag

◆ finalRange

◆ finalRangeRequested

◆ LowerLimitForced

◆ MinDeltaCutInRange

◆ MinDeltaEnergy

◆ ParticleMass

◆ rndmStepFlag

◆ setMinDeltaCutInRange

◆ subSecFlag