#include <G4EnergyLossForExtrapolator.hh>

Public Member Functions
G4double	AverageScatteringAngle (G4double kinEnergy, G4double step, const G4Material , const G4ParticleDefinition part)

G4double	AverageScatteringAngle (G4double kinEnergy, G4double step, const G4Material *, const G4String &particleName)

G4double	ComputeDEDX (G4double kinEnergy, const G4ParticleDefinition , const G4Material )

G4double	ComputeEnergy (G4double range, const G4ParticleDefinition , const G4Material )

G4double	ComputeRange (G4double kinEnergy, const G4ParticleDefinition , const G4Material )

G4double	ComputeTrueStep (const G4Material , const G4ParticleDefinition part, G4double kinEnergy, G4double stepLength)

G4double	EnergyAfterStep (G4double kinEnergy, G4double step, const G4Material , const G4ParticleDefinition )

G4double	EnergyAfterStep (G4double kinEnergy, G4double step, const G4Material *, const G4String &particleName)

G4double	EnergyBeforeStep (G4double kinEnergy, G4double step, const G4Material , const G4ParticleDefinition )

G4double	EnergyBeforeStep (G4double kinEnergy, G4double step, const G4Material *, const G4String &particleName)

G4double	EnergyDispersion (G4double kinEnergy, G4double step, const G4Material , const G4ParticleDefinition )

G4double	EnergyDispersion (G4double kinEnergy, G4double step, const G4Material *, const G4String &particleName)

	G4EnergyLossForExtrapolator (const G4EnergyLossForExtrapolator &)=delete

	G4EnergyLossForExtrapolator (G4int verb=1)

void	Initialisation ()

G4EnergyLossForExtrapolator &	operator= (const G4EnergyLossForExtrapolator &right)=delete

void	SetMaxEnergyTransfer (G4double)

void	SetMaxKinEnergy (G4double)

void	SetMinKinEnergy (G4double)

void	SetVerbose (G4int val)

G4double	TrueStepLength (G4double kinEnergy, G4double step, const G4Material , const G4ParticleDefinition part)

	~G4EnergyLossForExtrapolator ()

Private Member Functions
G4double	ComputeValue (G4double x, const G4PhysicsTable *table, size_t idxMat)

const G4ParticleDefinition *	FindParticle (const G4String &name)

const G4PhysicsTable *	GetPhysicsTable (ExtTableType type) const

G4bool	SetupKinematics (const G4ParticleDefinition , const G4Material , G4double kinEnergy)

Private Attributes
G4double	beta2 = 0.0

G4double	bg2 = 0.0

G4double	charge2 = 0.0

const G4Material *	currentMaterial = nullptr

const G4ParticleDefinition *	currentParticle = nullptr

const G4ParticleDefinition *	electron = nullptr

G4double	electronDensity = 0.0

G4double	emax = 0.0

G4double	emin = 0.0

G4double	gam = 1.0

size_t	index = 0

G4bool	isMaster = false

G4double	kineticEnergy = 0.0

G4double	linLossLimit = 0.01

G4double	maxEnergyTransfer = 0.0

const G4ParticleDefinition *	muonMinus = nullptr

const G4ParticleDefinition *	muonPlus = nullptr

G4int	nbins = 80

size_t	nmat = 0

const G4ParticleDefinition *	positron = nullptr

const G4ParticleDefinition *	proton = nullptr

G4double	radLength = 0.0

G4double	tmax = 0.0

G4int	verbose = 0

Static Private Attributes
static G4TablesForExtrapolator *	tables = nullptr

Detailed Description

Definition at line 67 of file G4EnergyLossForExtrapolator.hh.

Constructor & Destructor Documentation

◆ G4EnergyLossForExtrapolator() [1/2]

G4EnergyLossForExtrapolator::G4EnergyLossForExtrapolator ( G4int verb = 1 )

explicit

Definition at line 70 of file G4EnergyLossForExtrapolator.cc.

  : maxEnergyTransfer(DBL_MAX), verbose(verb)
{
  emin = 1.*CLHEP::MeV;
  emax = 100.*CLHEP::TeV;
}

References emax, emin, CLHEP::MeV, and CLHEP::TeV.

◆ ~G4EnergyLossForExtrapolator()

G4EnergyLossForExtrapolator::~G4EnergyLossForExtrapolator ( )

Definition at line 79 of file G4EnergyLossForExtrapolator.cc.

{
  if(isMaster) {
    delete tables;
    tables = nullptr;
  }
}

References isMaster, and tables.

◆ G4EnergyLossForExtrapolator() [2/2]

G4EnergyLossForExtrapolator::G4EnergyLossForExtrapolator ( const G4EnergyLossForExtrapolator & )

delete

Member Function Documentation

◆ AverageScatteringAngle() [1/2]

G4double G4EnergyLossForExtrapolator::AverageScatteringAngle	(	G4double	kinEnergy,
		G4double	step,
		const G4Material *	mat,
		const G4ParticleDefinition *	part
	)

Definition at line 312 of file G4EnergyLossForExtrapolator.cc.

{
  G4double theta = 0.0;
  if(SetupKinematics(part, mat, kinEnergy)) {
    G4double t = stepLength/radLength;
    G4double y = std::max(0.001, t); 
    theta = 19.23*CLHEP::MeV*std::sqrt(charge2*t)*(1.0 + 0.038*G4Log(y))
      /(beta2*gam*part->GetPDGMass());
  }
  return theta;
}

References beta2, charge2, G4Log(), gam, G4ParticleDefinition::GetPDGMass(), G4INCL::Math::max(), CLHEP::MeV, radLength, and SetupKinematics().

Referenced by AverageScatteringAngle(), and ComputeTrueStep().

◆ AverageScatteringAngle() [2/2]

G4double G4EnergyLossForExtrapolator::AverageScatteringAngle	(	G4double	kinEnergy,
		G4double	step,
		const G4Material *	mat,
		const G4String &	particleName
	)

inline

Definition at line 216 of file G4EnergyLossForExtrapolator.hh.

{
  return AverageScatteringAngle(kinEnergy,step,mat,FindParticle(name));
}

References AverageScatteringAngle(), FindParticle(), and G4InuclParticleNames::name().

◆ ComputeDEDX()

G4double G4EnergyLossForExtrapolator::ComputeDEDX	(	G4double	kinEnergy,
		const G4ParticleDefinition *	part,
		const G4Material *	mat
	)

Definition at line 224 of file G4EnergyLossForExtrapolator.cc.

{
  if(mat->GetNumberOfMaterials() != nmat) { Initialisation(); }
  G4double x = 0.0;
  if(part == electron)  { 
    x = ComputeValue(ekin, GetPhysicsTable(fDedxElectron), mat->GetIndex());
  } else if(part == positron) {
    x = ComputeValue(ekin, GetPhysicsTable(fDedxPositron), mat->GetIndex());
  } else if(part == muonPlus || part == muonMinus) {
    x = ComputeValue(ekin, GetPhysicsTable(fDedxMuon), mat->GetIndex());
  } else {
    G4double e = ekin*CLHEP::proton_mass_c2/part->GetPDGMass();
    G4double q = part->GetPDGCharge()/CLHEP::eplus;
    x = ComputeValue(e, GetPhysicsTable(fDedxProton), mat->GetIndex())*q*q;
  }
  return x;
}

References ComputeValue(), electron, CLHEP::eplus, fDedxElectron, fDedxMuon, fDedxPositron, fDedxProton, G4Material::GetIndex(), G4Material::GetNumberOfMaterials(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), GetPhysicsTable(), Initialisation(), muonMinus, muonPlus, nmat, positron, and CLHEP::proton_mass_c2.

Referenced by EnergyAfterStep(), and EnergyBeforeStep().

◆ ComputeEnergy()

G4double G4EnergyLossForExtrapolator::ComputeEnergy	(	G4double	range,
		const G4ParticleDefinition *	part,
		const G4Material *	mat
	)

Definition at line 272 of file G4EnergyLossForExtrapolator.cc.

{
  if(mat->GetNumberOfMaterials() != nmat) { Initialisation(); }
  G4double x = 0.0;
  if(part == electron) {
    x = ComputeValue(range,GetPhysicsTable(fInvRangeElectron),mat->GetIndex());
  } else if(part == positron) {
    x = ComputeValue(range,GetPhysicsTable(fInvRangePositron),mat->GetIndex());
  } else if(part == muonPlus || part == muonMinus) {
    x = ComputeValue(range, GetPhysicsTable(fInvRangeMuon), mat->GetIndex());
  } else {
    G4double massratio = CLHEP::proton_mass_c2/part->GetPDGMass();
    G4double q = part->GetPDGCharge()/CLHEP::eplus;
    G4double r = range*massratio*q*q;
    x = ComputeValue(r, GetPhysicsTable(fInvRangeProton), mat->GetIndex())/massratio;
  }
  return x;
}

References ComputeValue(), electron, CLHEP::eplus, fInvRangeElectron, fInvRangeMuon, fInvRangePositron, fInvRangeProton, G4Material::GetIndex(), G4Material::GetNumberOfMaterials(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), GetPhysicsTable(), Initialisation(), muonMinus, muonPlus, nmat, positron, and CLHEP::proton_mass_c2.

Referenced by EnergyAfterStep(), and EnergyBeforeStep().

◆ ComputeRange()

G4double G4EnergyLossForExtrapolator::ComputeRange	(	G4double	kinEnergy,
		const G4ParticleDefinition *	part,
		const G4Material *	mat
	)

Definition at line 247 of file G4EnergyLossForExtrapolator.cc.

{
  if(mat->GetNumberOfMaterials() != nmat) { Initialisation(); }
  G4double x = 0.0;
  if(part == electron) { 
    x = ComputeValue(ekin, GetPhysicsTable(fRangeElectron), mat->GetIndex());
  } else if(part == positron) {
    x = ComputeValue(ekin, GetPhysicsTable(fRangePositron), mat->GetIndex());
  } else if(part == muonPlus || part == muonMinus) { 
    x = ComputeValue(ekin, GetPhysicsTable(fRangeMuon), mat->GetIndex());
  } else {
    G4double massratio = CLHEP::proton_mass_c2/part->GetPDGMass();
    G4double e = ekin*massratio;
    G4double q = part->GetPDGCharge()/CLHEP::eplus;
    x = ComputeValue(e, GetPhysicsTable(fRangeProton), mat->GetIndex())
      /(q*q*massratio);
  }
  return x;
}

References ComputeValue(), electron, CLHEP::eplus, fRangeElectron, fRangeMuon, fRangePositron, fRangeProton, G4Material::GetIndex(), G4Material::GetNumberOfMaterials(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), GetPhysicsTable(), Initialisation(), muonMinus, muonPlus, nmat, positron, and CLHEP::proton_mass_c2.

Referenced by EnergyAfterStep(), EnergyBeforeStep(), G4ErrorEnergyLoss::GetContinuousStepLimit(), and TrueStepLength().

◆ ComputeTrueStep()

G4double G4EnergyLossForExtrapolator::ComputeTrueStep	(	const G4Material *	mat,
		const G4ParticleDefinition *	part,
		G4double	kinEnergy,
		G4double	stepLength
	)

inline

Definition at line 238 of file G4EnergyLossForExtrapolator.hh.

{
  G4double theta = AverageScatteringAngle(kinEnergy,stepLength,mat,part);
  return stepLength*std::sqrt(1.0 + 0.625*theta*theta);
} 

References AverageScatteringAngle().

Referenced by EnergyDispersion(), and TrueStepLength().

◆ ComputeValue()

G4double G4EnergyLossForExtrapolator::ComputeValue	(	G4double	x,
		const G4PhysicsTable *	table,
		size_t	idxMat
	)

inlineprivate

Definition at line 250 of file G4EnergyLossForExtrapolator.hh.

{
  return (nullptr != table) ? ((*table)[idxMat])->Value(x, index) : 0.0; 
}

References index.

Referenced by ComputeDEDX(), ComputeEnergy(), ComputeRange(), and TrueStepLength().

◆ EnergyAfterStep() [1/2]

G4double G4EnergyLossForExtrapolator::EnergyAfterStep	(	G4double	kinEnergy,
		G4double	step,
		const G4Material *	mat,
		const G4ParticleDefinition *	part
	)

Definition at line 90 of file G4EnergyLossForExtrapolator.cc.

{
  G4double kinEnergyFinal = kinEnergy;
  if(SetupKinematics(part, mat, kinEnergy)) {
    G4double step = TrueStepLength(kinEnergy,stepLength,mat,part);
    G4double r  = ComputeRange(kinEnergy,part,mat);
    if(r <= step) {
      kinEnergyFinal = 0.0;
    } else if(step < linLossLimit*r) {
      kinEnergyFinal -= step*ComputeDEDX(kinEnergy,part,mat);
    } else {  
      G4double r1 = r - step;
      kinEnergyFinal = ComputeEnergy(r1,part,mat);
    }
  }
  return kinEnergyFinal;
}

References ComputeDEDX(), ComputeEnergy(), ComputeRange(), linLossLimit, SetupKinematics(), and TrueStepLength().

Referenced by G4ErrorEnergyLoss::AlongStepDoIt(), and EnergyAfterStep().

◆ EnergyAfterStep() [2/2]

G4double G4EnergyLossForExtrapolator::EnergyAfterStep	(	G4double	kinEnergy,
		G4double	step,
		const G4Material *	mat,
		const G4String &	particleName
	)

inline

Definition at line 194 of file G4EnergyLossForExtrapolator.hh.

{
  return EnergyAfterStep(kinEnergy,step,mat,FindParticle(name));
}

References EnergyAfterStep(), FindParticle(), and G4InuclParticleNames::name().

◆ EnergyBeforeStep() [1/2]

G4double G4EnergyLossForExtrapolator::EnergyBeforeStep	(	G4double	kinEnergy,
		G4double	step,
		const G4Material *	mat,
		const G4ParticleDefinition *	part
	)

Definition at line 114 of file G4EnergyLossForExtrapolator.cc.

{
  //G4cout << "G4EnergyLossForExtrapolator::EnergyBeforeStep" << G4endl;
  G4double kinEnergyFinal = kinEnergy;
 
  if(SetupKinematics(part, mat, kinEnergy)) {
    G4double step = TrueStepLength(kinEnergy,stepLength,mat,part);
    G4double r = ComputeRange(kinEnergy,part,mat);
 
    if(step < linLossLimit*r) {
      kinEnergyFinal += step*ComputeDEDX(kinEnergy,part,mat);
    } else {  
      G4double r1 = r + step;
      kinEnergyFinal = ComputeEnergy(r1,part,mat);
    }
  }
  return kinEnergyFinal;
}

References ComputeDEDX(), ComputeEnergy(), ComputeRange(), linLossLimit, SetupKinematics(), and TrueStepLength().

Referenced by G4ErrorEnergyLoss::AlongStepDoIt(), and EnergyBeforeStep().

◆ EnergyBeforeStep() [2/2]

G4double G4EnergyLossForExtrapolator::EnergyBeforeStep	(	G4double	kinEnergy,
		G4double	step,
		const G4Material *	mat,
		const G4String &	particleName
	)

inline

Definition at line 205 of file G4EnergyLossForExtrapolator.hh.

{
  return EnergyBeforeStep(kinEnergy,step,mat,FindParticle(name));
}

References EnergyBeforeStep(), FindParticle(), and G4InuclParticleNames::name().

◆ EnergyDispersion() [1/2]

G4double G4EnergyLossForExtrapolator::EnergyDispersion	(	G4double	kinEnergy,
		G4double	step,
		const G4Material *	mat,
		const G4ParticleDefinition *	part
	)

Definition at line 296 of file G4EnergyLossForExtrapolator.cc.

{
  G4double sig2 = 0.0;
  if(SetupKinematics(part, mat, kinEnergy)) {
    G4double step = ComputeTrueStep(mat,part,kinEnergy,stepLength);
    sig2 = (1.0/beta2 - 0.5)
      *CLHEP::twopi_mc2_rcl2*tmax*step*electronDensity*charge2;
  }
  return sig2;
}

References beta2, charge2, ComputeTrueStep(), electronDensity, SetupKinematics(), tmax, and CLHEP::twopi_mc2_rcl2.

Referenced by EnergyDispersion().

◆ EnergyDispersion() [2/2]

G4double G4EnergyLossForExtrapolator::EnergyDispersion	(	G4double	kinEnergy,
		G4double	step,
		const G4Material *	mat,
		const G4String &	particleName
	)

inline

Definition at line 227 of file G4EnergyLossForExtrapolator.hh.

{
  return EnergyDispersion(kinEnergy,step,mat,FindParticle(name));
}

References EnergyDispersion(), FindParticle(), and G4InuclParticleNames::name().

◆ FindParticle()

const G4ParticleDefinition * G4EnergyLossForExtrapolator::FindParticle ( const G4String & name )

private

Definition at line 211 of file G4EnergyLossForExtrapolator.cc.

{
  currentParticle = G4ParticleTable::GetParticleTable()->FindParticle(name);
  if(nullptr == currentParticle) {
    G4cout << "### G4EnergyLossForExtrapolator WARNING: "
       << "FindParticle() fails to find " << name << G4endl;
  }
  return currentParticle;
}

References currentParticle, G4ParticleTable::FindParticle(), G4cout, G4endl, G4ParticleTable::GetParticleTable(), and G4InuclParticleNames::name().

Referenced by AverageScatteringAngle(), EnergyAfterStep(), EnergyBeforeStep(), and EnergyDispersion().

◆ GetPhysicsTable()

const G4PhysicsTable * G4EnergyLossForExtrapolator::GetPhysicsTable ( ExtTableType type ) const

inlineprivate

Definition at line 186 of file G4EnergyLossForExtrapolator.hh.

{
  return tables->GetPhysicsTable(type);
}

References G4TablesForExtrapolator::GetPhysicsTable(), and tables.

Referenced by ComputeDEDX(), ComputeEnergy(), ComputeRange(), and TrueStepLength().

◆ Initialisation()

void G4EnergyLossForExtrapolator::Initialisation ( )

Definition at line 330 of file G4EnergyLossForExtrapolator.cc.

{
  if(verbose>0) {
    G4cout << "### G4EnergyLossForExtrapolator::Initialisation tables= " 
       << tables << G4endl;
  }
  electron = G4Electron::Electron();
  positron = G4Positron::Positron();
  proton   = G4Proton::Proton();
  muonPlus = G4MuonPlus::MuonPlus();
  muonMinus= G4MuonMinus::MuonMinus();
 
  // initialisation for the 1st run
  if(nullptr == tables) {
#ifdef G4MULTITHREADED
    G4MUTEXLOCK(&extrMutex);
    if(nullptr == tables) {
#endif
      isMaster = true;
      tables = new G4TablesForExtrapolator(verbose, nbins, emin, emax);
      tables->Initialisation();
      nmat = G4Material::GetNumberOfMaterials();
      if(verbose > 0) {
        G4cout << "### G4EnergyLossForExtrapolator::BuildTables for "
               << nmat << " materials Nbins= " 
               << nbins << " Emin(MeV)= " << emin << "  Emax(MeV)= " << emax 
               << G4endl;
      }
#ifdef G4MULTITHREADED
    }
    G4MUTEXUNLOCK(&extrMutex);
#endif
  } 
 
  // initialisation for the next run
  if(isMaster && G4Material::GetNumberOfMaterials() != nmat) {
#ifdef G4MULTITHREADED
    G4MUTEXLOCK(&extrMutex);
#endif
    tables->Initialisation();
#ifdef G4MULTITHREADED
    G4MUTEXUNLOCK(&extrMutex);
#endif
  }
  nmat = G4Material::GetNumberOfMaterials();
}

References G4Electron::Electron(), electron, emax, emin, G4cout, G4endl, G4MUTEXLOCK, G4MUTEXUNLOCK, G4Material::GetNumberOfMaterials(), G4TablesForExtrapolator::Initialisation(), isMaster, G4MuonMinus::MuonMinus(), muonMinus, G4MuonPlus::MuonPlus(), muonPlus, nbins, nmat, G4Positron::Positron(), positron, G4Proton::Proton(), proton, tables, and verbose.

Referenced by ComputeDEDX(), ComputeEnergy(), ComputeRange(), and SetupKinematics().

◆ operator=()

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

delete

◆ SetMaxEnergyTransfer()

void G4EnergyLossForExtrapolator::SetMaxEnergyTransfer ( G4double val )

inline

Definition at line 280 of file G4EnergyLossForExtrapolator.hh.

{
  maxEnergyTransfer = val;
}

References maxEnergyTransfer.

◆ SetMaxKinEnergy()

void G4EnergyLossForExtrapolator::SetMaxKinEnergy ( G4double val )

inline

Definition at line 273 of file G4EnergyLossForExtrapolator.hh.

{
  emax = val;
}

References emax.

◆ SetMinKinEnergy()

void G4EnergyLossForExtrapolator::SetMinKinEnergy ( G4double val )

inline

Definition at line 266 of file G4EnergyLossForExtrapolator.hh.

{
  emin = val;
}

References emin.

◆ SetupKinematics()

G4bool G4EnergyLossForExtrapolator::SetupKinematics	(	const G4ParticleDefinition *	part,
		const G4Material *	mat,
		G4double	kinEnergy
	)

private

Definition at line 165 of file G4EnergyLossForExtrapolator.cc.

{
  if(mat->GetNumberOfMaterials() != nmat) { Initialisation(); }
  if(nullptr == part || nullptr == mat || kinEnergy < CLHEP::keV) 
    { return false; }
  if(part != currentParticle) {
    currentParticle = part;
    G4double q = part->GetPDGCharge()/eplus;
    charge2 = q*q;
  }
  if(mat != currentMaterial) {
    size_t i = mat->GetIndex();
    if(i >= nmat) {
      G4cout << "### G4EnergyLossForExtrapolator WARNING: material index i= " 
         << i << " above number of materials " << nmat << G4endl;
      return false;
    } else {
      currentMaterial = mat;
      electronDensity = mat->GetElectronDensity();
      radLength       = mat->GetRadlen();
    }
  }
  if(kinEnergy != kineticEnergy) {
    kineticEnergy = kinEnergy;
    G4double mass = part->GetPDGMass();
    G4double tau  = kinEnergy/mass;
 
    gam   = tau + 1.0;
    bg2   = tau * (tau + 2.0);
    beta2 = bg2/(gam*gam);
    tmax  = kinEnergy;
    if(part == electron) tmax *= 0.5;
    else if(part != positron) {
      G4double r = CLHEP::electron_mass_c2/mass;
      tmax = 2.0*bg2*CLHEP::electron_mass_c2/(1.0 + 2.0*gam*r + r*r);
    }
    tmax = std::min(tmax, maxEnergyTransfer);
  }
  return true;
} 

References beta2, bg2, charge2, currentMaterial, currentParticle, electron, CLHEP::electron_mass_c2, electronDensity, eplus, G4cout, G4endl, gam, G4Material::GetElectronDensity(), G4Material::GetIndex(), G4Material::GetNumberOfMaterials(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), G4Material::GetRadlen(), Initialisation(), CLHEP::keV, kineticEnergy, maxEnergyTransfer, G4INCL::Math::min(), nmat, positron, radLength, and tmax.

Referenced by AverageScatteringAngle(), EnergyAfterStep(), EnergyBeforeStep(), EnergyDispersion(), and TrueStepLength().

◆ SetVerbose()

void G4EnergyLossForExtrapolator::SetVerbose ( G4int val )

inline

Definition at line 259 of file G4EnergyLossForExtrapolator.hh.

{
  verbose = val;
}

References verbose.

◆ TrueStepLength()

G4double G4EnergyLossForExtrapolator::TrueStepLength	(	G4double	kinEnergy,
		G4double	step,
		const G4Material *	mat,
		const G4ParticleDefinition *	part
	)

Definition at line 139 of file G4EnergyLossForExtrapolator.cc.

{
  G4double res = stepLength;
  //G4cout << "## G4EnergyLossForExtrapolator::TrueStepLength L= " << res 
  //     <<  "  " << part->GetParticleName() << G4endl;
  if(SetupKinematics(part, mat, kinEnergy)) {
    if(part == electron || part == positron) {
      const G4double x = stepLength*
    ComputeValue(kinEnergy, GetPhysicsTable(fMscElectron), mat->GetIndex());
      //G4cout << " x= " << x << G4endl;
      if(x < 0.2)         { res *= (1.0 + 0.5*x + x*x/3.0); }
      else if(x < 0.9999) { res = -G4Log(1.0 - x)*stepLength/x; }
      else { res = ComputeRange(kinEnergy, part, mat); }
    } else {
      res = ComputeTrueStep(mat,part,kinEnergy,stepLength);
    }
  }
  return res;
}