EnergyLossForExtrapolator Class Reference

Calculate energy loss, fluctuation, and multiple-scattering angle for extrapolator. More...

#include <EnergyLossForExtrapolator.h>

Public Member Functions
	EnergyLossForExtrapolator ()
	Constructor (WITHOUT GEANT4 verbosity flag)
	~EnergyLossForExtrapolator ()
	Destructor.
G4double	ComputeDEDX (G4double kinEnergy, const G4ParticleDefinition *)
	Get specific ionization energy loss for the given kinetic energy and particle.
G4double	ComputeRange (G4double kinEnergy, const G4ParticleDefinition *)
	Get range for the given kinetic energy and particle.
G4double	ComputeEnergy (G4double range, const G4ParticleDefinition *)
	Get kinetic energy corresponding to the given range and particle.
G4double	EnergyAfterStep (G4double kinEnergy, G4double step, const G4Material *, const G4ParticleDefinition *)
	Get kinetic energy after a step in given material by given particle.
G4double	EnergyBeforeStep (G4double kinEnergy, G4double step, const G4Material *, const G4ParticleDefinition *)
	Get kinetic energy before a step in given material by given particle.
G4double	TrueStepLength (G4double kinEnergy, G4double step, const G4Material *, const G4ParticleDefinition *part)
	Get true step length for given particle and kinetic energy.
G4double	AverageScatteringAngle (G4double kinEnergy, G4double step, const G4Material *, const G4ParticleDefinition *part)
	Get kinetic energy after a step in given material by given particle.
G4double	ComputeTrueStep (const G4Material *, const G4ParticleDefinition *part, G4double kinEnergy, G4double stepLength)
	Get average scattering angle after a step in given material by given particle.
void	SetMinKinEnergy (G4double)
	Get energy dispersion for a step in given material by given particle.
void	SetMaxKinEnergy (G4double)
	Change the maximum particle kinetic energy for this class (default is 10 TeV)
void	SetMaxEnergyTransfer (G4double)
	Change the maximum energy loss or gain for this class (default is infinity)

Private Member Functions
void	Initialisation ()
	Initialize tables used to calculate energy loss, fluctuation, and scattering for electrons, positrons, muons, pions, kaons, protons and deuterons in all materials.
G4bool	SetupKinematics (const G4ParticleDefinition *, const G4Material *, G4double kinEnergy)
	Save current particle properties, kinetic energy and material in internal cached state.
G4PhysicsTable *	PrepareTable ()
	Create a new table to store one type of kinematics data for a particle.
const G4ParticleDefinition *	FindParticle (const G4String &name)
	Get the particle definition of the named particle.
void	ComputeElectronDEDX (const G4ParticleDefinition *part, G4PhysicsTable *table)
	Fill the table with the specific ionization energy loss of an electron.
void	ComputeMuonDEDX (const G4ParticleDefinition *part, G4PhysicsTable *table)
	Fill the table with the specific ionization energy loss of a muon.
void	ComputeHadronDEDX (const G4ParticleDefinition *part, G4PhysicsTable *table)
	Fill the table with the specific ionization energy loss of a hadron.
void	ComputeTransportXS (const G4ParticleDefinition *part, G4PhysicsTable *table)
	Fill the table with the multiple-scattering cross section of a particle.
G4double	ComputeValue (G4double x, const G4PhysicsTable *table)
	Get the tabulated energy-loss, fluctuation, or scattering value for the given input.
EnergyLossForExtrapolator &	operator= (const EnergyLossForExtrapolator &right)
	Hide assignment operator.
	EnergyLossForExtrapolator (const EnergyLossForExtrapolator &)
	Hide copy-assignment operator.

Private Attributes
const G4ParticleDefinition *	m_Particle
	Pointer to definition of the currently cached particle.
const G4ParticleDefinition *	m_Electron
	Pointer to definition of the electron.
const G4ParticleDefinition *	m_Positron
	Pointer to definition of the positron.
const G4ParticleDefinition *	m_MuonPlus
	Pointer to definition of the positive muon.
const G4ParticleDefinition *	m_MuonMinus
	Pointer to definition of the negative muon.
const G4ParticleDefinition *	m_PionPlus
	Pointer to definition of the positive pion.
const G4ParticleDefinition *	m_PionMinus
	Pointer to definition of the negative pion.
const G4ParticleDefinition *	m_KaonPlus
	Pointer to definition of the positive kaon.
const G4ParticleDefinition *	m_KaonMinus
	Pointer to definition of the negative kaon.
const G4ParticleDefinition *	m_Proton
	Pointer to definition of the proton.
const G4ParticleDefinition *	m_AntiProton
	Pointer to definition of the antiproton.
const G4ParticleDefinition *	m_Deuteron
	Pointer to definition of the deuteron.
const G4ParticleDefinition *	m_AntiDeuteron
	Pointer to definition of the antideuteron.
G4DataVector	m_Cuts
	Vector of particle cuts.
G4ProductionCuts *	m_ProductionCuts
	Pointer to the internal cache of default G4ProductionCuts.
std::vector< const G4MaterialCutsCouple * >	m_Couples
	List of material-cuts pairings.
G4PhysicsTable *	m_DedxElectron
	Pointer to the electron's specific ionization energy loss vs KE table.
G4PhysicsTable *	m_DedxPositron
	Pointer to the positron's specific ionization energy loss vs KE table.
G4PhysicsTable *	m_DedxMuon
	Pointer to the muon's specific ionization energy loss vs KE table.
G4PhysicsTable *	m_DedxPion
	Pointer to the pion's specific ionization energy loss vs KE table.
G4PhysicsTable *	m_DedxKaon
	Pointer to the kaon's specific ionization energy loss vs KE table.
G4PhysicsTable *	m_DedxProton
	Pointer to the proton's specific ionization energy loss vs KE table.
G4PhysicsTable *	m_DedxDeuteron
	Pointer to the deuteron's specific ionization energy loss vs KE table.
G4PhysicsTable *	m_RangeElectron
	Pointer to the electron's range vs KE table.
G4PhysicsTable *	m_RangePositron
	Pointer to the positron's range vs KE table.
G4PhysicsTable *	m_RangeMuon
	Pointer to the muon's range vs KE table.
G4PhysicsTable *	m_RangePion
	Pointer to the pion's range vs KE table.
G4PhysicsTable *	m_RangeKaon
	Pointer to the kaon's range vs KE table.
G4PhysicsTable *	m_RangeProton
	Pointer to the proton's range vs KE table.
G4PhysicsTable *	m_RangeDeuteron
	Pointer to the deuteron's range vs KE table.
G4PhysicsTable *	m_InvRangeElectron
	Pointer to the electron's inverse-range vs KE table.
G4PhysicsTable *	m_InvRangePositron
	Pointer to the positron's inverse-range vs KE table.
G4PhysicsTable *	m_InvRangeMuon
	Pointer to the muon's inverse-range vs KE table.
G4PhysicsTable *	m_InvRangePion
	Pointer to the pion's inverse-range vs KE table.
G4PhysicsTable *	m_InvRangeKaon
	Pointer to the kaon's inverse-range vs KE table.
G4PhysicsTable *	m_InvRangeProton
	Pointer to the proton's inverse-range vs KE table.
G4PhysicsTable *	m_InvRangeDeuteron
	Pointer to the deuteron's inverse-range vs KE table.
G4PhysicsTable *	m_MscatElectron
	Pointer to the electron's multiple-scattering cross section vs KE table.
const G4Material *	m_Material
	Pointer to internally cached material.
G4int	m_MaterialIndex
	Cached material index.
G4double	m_ElectronDensity
	Cached material electron density.
G4double	m_RadLength
	Cached material radiation length.
G4double	m_Mass
	Cached particle mass.
G4double	m_ChargeSq
	Cached charge-squared (in units of e)
G4double	m_KineticEnergy
	Cached particle kinetic energy.
G4double	m_Gamma
	Cached particle's gamma value.
G4double	m_BetaGammaSq
	Cached particle's beta*gamma squared.
G4double	m_BetaSq
	Cached particle's beta squared.
G4double	m_Tmax
	Cached particle's maximum kinetic-energy loss.
G4double	m_LinLossLimit
	Step-length limit in units of range (0.01); not modifiable by user.
G4double	m_UserTmin
	User's minimum kinetic energy for particles (default 1 MeV)
G4double	m_UserTmax
	User's maximum kinetic energy for particles (default 10 TeV)
G4double	m_UserMaxEnergyTransfer
	User's upper limit on maximum kinetic-energy loss (default infinity)
G4int	m_Nbins
	Number of bins in each energy loss, fluctuation, and multiple-scattering table (70, fixed)
G4int	m_NMaterials
	Number of materials in current geometry.
G4bool	m_Initialised
	UNUSED Flag to indicate that Initialisation() method has been called.

Detailed Description

Calculate energy loss, fluctuation, and multiple-scattering angle for extrapolator.

Definition at line 33 of file EnergyLossForExtrapolator.h.

Constructor & Destructor Documentation

EnergyLossForExtrapolator()

EnergyLossForExtrapolator

(

void

)

Constructor (WITHOUT GEANT4 verbosity flag)

Definition at line 34 of file EnergyLossForExtrapolator.cc.

                                                         :
  m_Particle(nullptr),
  m_Electron(nullptr),
  m_Positron(nullptr),
  m_MuonPlus(nullptr),
  m_MuonMinus(nullptr),
  m_PionPlus(nullptr),
  m_PionMinus(nullptr),
  m_KaonPlus(nullptr),
  m_KaonMinus(nullptr),
  m_Proton(nullptr),
  m_AntiProton(nullptr),
  m_Deuteron(nullptr),
  m_AntiDeuteron(nullptr),
  m_ProductionCuts(nullptr),
  m_DedxElectron(nullptr),
  m_DedxPositron(nullptr),
  m_DedxMuon(nullptr),
  m_DedxPion(nullptr),
  m_DedxKaon(nullptr),
  m_DedxProton(nullptr),
  m_DedxDeuteron(nullptr),
  m_RangeElectron(nullptr),
  m_RangePositron(nullptr),
  m_RangeMuon(nullptr),
  m_RangePion(nullptr),
  m_RangeKaon(nullptr),
  m_RangeProton(nullptr),
  m_RangeDeuteron(nullptr),
  m_InvRangeElectron(nullptr),
  m_InvRangePositron(nullptr),
  m_InvRangeMuon(nullptr),
  m_InvRangePion(nullptr),
  m_InvRangeKaon(nullptr),
  m_InvRangeProton(nullptr),
  m_InvRangeDeuteron(nullptr),
  m_MscatElectron(nullptr),
  m_Material(nullptr),
  m_MaterialIndex(0),
  m_ElectronDensity(0),
  m_RadLength(0),
  m_Mass(0),
  m_ChargeSq(0),
  m_KineticEnergy(0),
  m_Gamma(1.0),
  m_BetaGammaSq(0),
  m_BetaSq(0),
  m_Tmax(0),
  m_LinLossLimit(0.01),
  m_UserTmin(1.*CLHEP::MeV),
  m_UserTmax(10.*CLHEP::TeV),
  m_UserMaxEnergyTransfer(DBL_MAX),
  m_Nbins(70),
  m_NMaterials(0),
  m_Initialised(false)
{
  Initialisation();
}

~EnergyLossForExtrapolator()

~EnergyLossForExtrapolator

(

)

Destructor.

Definition at line 93 of file EnergyLossForExtrapolator.cc.

{
  m_DedxElectron->clearAndDestroy(); delete m_DedxElectron;
  m_DedxPositron->clearAndDestroy(); delete m_DedxPositron;
  m_DedxMuon->clearAndDestroy(); delete m_DedxMuon;
  m_DedxPion->clearAndDestroy(); delete m_DedxPion;
  m_DedxKaon->clearAndDestroy(); delete m_DedxKaon;
  m_DedxProton->clearAndDestroy(); delete m_DedxProton;
  m_DedxDeuteron->clearAndDestroy(); delete m_DedxDeuteron;
  m_RangeElectron->clearAndDestroy(); delete m_RangeElectron;
  m_RangePositron->clearAndDestroy(); delete m_RangePositron;
  m_RangeMuon->clearAndDestroy(); delete m_RangeMuon;
  m_RangePion->clearAndDestroy(); delete m_RangePion;
  m_RangeKaon->clearAndDestroy(); delete m_RangeKaon;
  m_RangeProton->clearAndDestroy(); delete m_RangeProton;
  m_RangeDeuteron->clearAndDestroy(); delete m_RangeDeuteron;
  m_InvRangeElectron->clearAndDestroy(); delete m_InvRangeElectron;
  m_InvRangePositron->clearAndDestroy(); delete m_InvRangePositron;
  m_InvRangeMuon->clearAndDestroy(); delete m_InvRangeMuon;
  m_InvRangePion->clearAndDestroy(); delete m_InvRangePion;
  m_InvRangeKaon->clearAndDestroy(); delete m_InvRangeKaon;
  m_InvRangeProton->clearAndDestroy(); delete m_InvRangeProton;
  m_InvRangeDeuteron->clearAndDestroy(); delete m_InvRangeDeuteron;
  m_MscatElectron->clearAndDestroy(); delete m_MscatElectron;
  delete m_ProductionCuts;
  for (const G4MaterialCutsCouple* couple : m_Couples) delete couple;
  m_Couples.clear();
}

Member Function Documentation

AverageScatteringAngle()

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

inline

Get kinetic energy after a step in given material by given particle.

Get kinetic energy before a step in given material by given particle Get average scattering angle after a step in given material by given particle

Definition at line 355 of file EnergyLossForExtrapolator.h.

    {
      G4double theta = 0.0;
      if (SetupKinematics(part, mat, kinEnergy)) {
        G4double t = stepLength / m_RadLength;
        G4double y = std::max(0.001, t);
        theta = 19.23 * CLHEP::MeV * std::sqrt(m_ChargeSq * t) * (1.0 + 0.038 * std::log(y)) / (m_BetaSq * m_Gamma * m_Mass);
      }
      return theta;
    }

ComputeDEDX()

G4double ComputeDEDX	(	G4double	kinEnergy,
		const G4ParticleDefinition *	part
	)

Get specific ionization energy loss for the given kinetic energy and particle.

Definition at line 339 of file EnergyLossForExtrapolator.cc.

{
  G4double x = 0.0;
  if (part == m_Electron) {
    x = ComputeValue(kinEnergy, m_DedxElectron);
  } else if (part == m_Positron) {
    x = ComputeValue(kinEnergy, m_DedxPositron);
  } else if (part == m_MuonPlus || part == m_MuonMinus) {
    x = ComputeValue(kinEnergy, m_DedxMuon);
  } else if (part == m_PionPlus || part == m_PionMinus) {
    x = ComputeValue(kinEnergy, m_DedxPion);
  } else if (part == m_KaonPlus || part == m_KaonMinus) {
    x = ComputeValue(kinEnergy, m_DedxKaon);
  } else if (part == m_Proton || part == m_AntiProton) {
    x = ComputeValue(kinEnergy, m_DedxProton);
  } else if (part == m_Deuteron || part == m_AntiDeuteron) {
    x = ComputeValue(kinEnergy, m_DedxDeuteron);
  } else {
    B2FATAL("EnergyLossForExtrapolator::ComputeDEDX has no table for particle " << part->GetParticleName());
  }
  return x;
}

ComputeElectronDEDX()

void ComputeElectronDEDX ( const G4ParticleDefinition *  part, G4PhysicsTable *  table  )

private

Fill the table with the specific ionization energy loss of an electron.

Definition at line 411 of file EnergyLossForExtrapolator.cc.

{
  G4MollerBhabhaModel* ioni = new G4MollerBhabhaModel();
  G4eBremsstrahlungRelModel* brem = new G4eBremsstrahlungRelModel();
  G4ParticleChange* ioniPC = new G4ParticleChange();
  ioni->SetParticleChange(ioniPC);
  G4ParticleChange* bremPC = new G4ParticleChange();
  brem->SetParticleChange(bremPC);
  ioni->Initialise(part, m_Cuts);
  brem->Initialise(part, m_Cuts);
  m_Mass = CLHEP::electron_mass_c2;
  m_ChargeSq = 1.0;
  m_Particle = part;
  B2DEBUG(20, "EnergyLossForExtrapolator::ComputeElectronDEDX"
          << LogVar("particle", part->GetParticleName())
         );
  for (G4int i = 0; i < m_NMaterials; i++) {
    const G4MaterialCutsCouple* couple = m_Couples[i];
    const G4Material* material = couple->GetMaterial();
    // Let's check this at run time (only in ComputeElectronDEDX: it's not necessary to always check this)
    assert((*G4Material::GetMaterialTable())[i] == material);
    B2DEBUG(20, "EnergyLossForExtrapolator::ComputeElectronDEDX()"
            << LogVar("material index", i)
            << LogVar("material name", material->GetName())
            << LogVar("density [g/cm3]", material->GetDensity() * CLHEP::cm3 / CLHEP::g)
           );
    G4PhysicsVector* aVector = (*table)[i];
    for (G4int j = 0; j <= m_Nbins; j++) {
      G4double e = aVector->Energy(j);
      G4double dedx = ioni->ComputeDEDXPerVolume(material, part, e, e)
                      + brem->ComputeDEDXPerVolume(material, part, e, e);
      B2DEBUG(20, "EnergyLossForExtrapolator::ComputeElectronDEDX()"
              << LogVar("bin", j)
              << LogVar("energy [MeV]", e / CLHEP::MeV)
              << LogVar("dE/dx [Mev/cm]", dedx * CLHEP::cm / CLHEP::MeV)
              << LogVar("dE/dx [Mev/(g/cm2)]", dedx / ((CLHEP::MeV * material->GetDensity()) / (CLHEP::g / CLHEP::cm2)))
             );
      aVector->PutValue(j, dedx);
    }
    aVector->FillSecondDerivatives();
  }
  delete ioni;
  delete ioniPC;
  delete brem;
  delete bremPC;
}

ComputeEnergy()

G4double ComputeEnergy	(	G4double	range,
		const G4ParticleDefinition *	part
	)

Get kinetic energy corresponding to the given range and particle.

Definition at line 387 of file EnergyLossForExtrapolator.cc.

{
  G4double x = 0.0;
  if (part == m_Electron) {
    x = ComputeValue(range, m_InvRangeElectron);
  } else if (part == m_Positron) {
    x = ComputeValue(range, m_InvRangePositron);
  } else if (part == m_MuonPlus || part == m_MuonMinus) {
    x = ComputeValue(range, m_InvRangeMuon);
  } else if (part == m_PionPlus || part == m_PionMinus) {
    x = ComputeValue(range, m_InvRangePion);
  } else if (part == m_KaonPlus || part == m_KaonMinus) {
    x = ComputeValue(range, m_InvRangeKaon);
  } else if (part == m_Proton || part == m_AntiProton) {
    x = ComputeValue(range, m_InvRangeProton);
  } else if (part == m_Deuteron || part == m_AntiDeuteron) {
    x = ComputeValue(range, m_InvRangeDeuteron);
  } else {
    B2FATAL("EnergyLossForExtrapolator::ComputeEnergy has no table for particle " << part->GetParticleName());
  }
  return x;
}

ComputeHadronDEDX()

void ComputeHadronDEDX ( const G4ParticleDefinition *  part, G4PhysicsTable *  table  )

private

Fill the table with the specific ionization energy loss of a hadron.

Definition at line 512 of file EnergyLossForExtrapolator.cc.

{
  G4BetheBlochModel* ioni = new G4BetheBlochModel();
  G4ParticleChange* ioniPC = new G4ParticleChange();
  ioni->SetParticleChange(ioniPC);
  ioni->Initialise(part, m_Cuts);
  m_Mass = part->GetPDGMass();
  double q = part->GetPDGCharge() / CLHEP::eplus;
  m_ChargeSq = q * q;
  m_Particle = part;
  B2DEBUG(20, "EnergyLossForExtrapolator::ComputeHadronDEDX"
          << LogVar("particle", part->GetParticleName())
         );
  for (G4int i = 0; i < m_NMaterials; i++) {
    const G4MaterialCutsCouple* couple = m_Couples[i];
    const G4Material* material = couple->GetMaterial();
    B2DEBUG(20, "EnergyLossForExtrapolator::ComputeHadronDEDX()"
            << LogVar("material index", i)
            << LogVar("material name", material->GetName())
            << LogVar("density [g/cm3]", material->GetDensity() * CLHEP::cm3 / CLHEP::g)
           );
    G4PhysicsVector* aVector = (*table)[i];
    for (G4int j = 0; j <= m_Nbins; j++) {
      G4double e = aVector->Energy(j);
      G4double dedx = ioni->ComputeDEDXPerVolume(material, part, e, e);
      aVector->PutValue(j, dedx);
      B2DEBUG(20, "EnergyLossForExtrapolator::ComputeHadronDEDX()"
              << LogVar("bin", j)
              << LogVar("energy [MeV]", e / CLHEP::MeV)
              << LogVar("dE/dx [Mev/cm]", dedx * CLHEP::cm / CLHEP::MeV)
              << LogVar("dE/dx [Mev/(g/cm2)]", dedx / ((CLHEP::MeV * material->GetDensity()) / (CLHEP::g / CLHEP::cm2)))
             );
    }
    aVector->FillSecondDerivatives();
  }
  delete ioni;
  delete ioniPC;
}

ComputeMuonDEDX()

void ComputeMuonDEDX ( const G4ParticleDefinition *  part, G4PhysicsTable *  table  )

private

Fill the table with the specific ionization energy loss of a muon.

Definition at line 459 of file EnergyLossForExtrapolator.cc.

{
  G4BetheBlochModel* ioni = new G4BetheBlochModel();
  G4MuPairProductionModel* pair = new G4MuPairProductionModel();
  G4MuBremsstrahlungModel* brem = new G4MuBremsstrahlungModel();
  G4ParticleChange* ioniPC = new G4ParticleChange();
  ioni->SetParticleChange(ioniPC);
  G4ParticleChange* pairPC = new G4ParticleChange();
  pair->SetParticleChange(pairPC);
  G4ParticleChange* bremPC = new G4ParticleChange();
  brem->SetParticleChange(bremPC);
  ioni->Initialise(part, m_Cuts);
  pair->Initialise(part, m_Cuts);
  brem->Initialise(part, m_Cuts);
  m_Mass = part->GetPDGMass();
  m_ChargeSq = 1.0;
  m_Particle = part;
  B2DEBUG(20, "EnergyLossForExtrapolator::ComputeMuonDEDX"
          << LogVar("particle", part->GetParticleName())
         );
  for (G4int i = 0; i < m_NMaterials; i++) {
    const G4MaterialCutsCouple* couple = m_Couples[i];
    const G4Material* material = couple->GetMaterial();
    B2DEBUG(20, "EnergyLossForExtrapolator::ComputeMuonDEDX()"
            << LogVar("material index", i)
            << LogVar("material name", material->GetName())
            << LogVar("density [g/cm3]", material->GetDensity() * CLHEP::cm3 / CLHEP::g)
           );
    G4PhysicsVector* aVector = (*table)[i];
    for (G4int j = 0; j <= m_Nbins; j++) {
      G4double e = aVector->Energy(j);
      G4double dedx = ioni->ComputeDEDXPerVolume(material, part, e, e)
                      + pair->ComputeDEDXPerVolume(material, part, e, e)
                      + brem->ComputeDEDXPerVolume(material, part, e, e);
      aVector->PutValue(j, dedx);
      B2DEBUG(20, "EnergyLossForExtrapolator::ComputeMuonDEDX()"
              << LogVar("bin", j)
              << LogVar("energy [MeV]", e / CLHEP::MeV)
              << LogVar("dE/dx [Mev/cm]", dedx * CLHEP::cm / CLHEP::MeV)
              << LogVar("dE/dx [Mev/(g/cm2)]", dedx / ((CLHEP::MeV * material->GetDensity()) / (CLHEP::g / CLHEP::cm2)))
             );
    }
    aVector->FillSecondDerivatives();
  }
  delete ioni;
  delete ioniPC;
  delete pair;
  delete pairPC;
  delete brem;
  delete bremPC;
}

ComputeRange()

G4double ComputeRange	(	G4double	kinEnergy,
		const G4ParticleDefinition *	part
	)

Get range for the given kinetic energy and particle.

Definition at line 363 of file EnergyLossForExtrapolator.cc.

{
  G4double x = 0.0;
  if (part == m_Electron) {
    x = ComputeValue(kinEnergy, m_RangeElectron);
  } else if (part == m_Positron) {
    x = ComputeValue(kinEnergy, m_RangePositron);
  } else if (part == m_MuonPlus || part == m_MuonMinus) {
    x = ComputeValue(kinEnergy, m_RangeMuon);
  } else if (part == m_PionPlus || part == m_PionMinus) {
    x = ComputeValue(kinEnergy, m_RangePion);
  } else if (part == m_KaonPlus || part == m_KaonMinus) {
    x = ComputeValue(kinEnergy, m_RangeKaon);
  } else if (part == m_Proton || part == m_AntiProton) {
    x = ComputeValue(kinEnergy, m_RangeProton);
  } else if (part == m_Deuteron || part == m_AntiDeuteron) {
    x = ComputeValue(kinEnergy, m_RangeDeuteron);
  } else {
    B2FATAL("EnergyLossForExtrapolator::ComputeRange has no table for particle " << part->GetParticleName());
  }
  return x;
}

ComputeTransportXS()

void ComputeTransportXS ( const G4ParticleDefinition *  part, G4PhysicsTable *  table  )

private

Fill the table with the multiple-scattering cross section of a particle.

Definition at line 552 of file EnergyLossForExtrapolator.cc.

{
  G4WentzelVIModel* msc = new G4WentzelVIModel();
  G4ParticleChange* mscPC = new G4ParticleChange();
  msc->SetParticleChange(mscPC);
  msc->SetPolarAngleLimit(CLHEP::pi);
  msc->Initialise(part, m_Cuts);
  m_Mass = part->GetPDGMass();
  double q = part->GetPDGCharge() / CLHEP::eplus;
  m_ChargeSq = q * q;
  m_Particle = part;
  const G4MaterialTable* mtable = G4Material::GetMaterialTable();
  B2DEBUG(20, "EnergyLossForExtrapolator::ComputeTransportXS"
          << LogVar("particle", part->GetParticleName())
         );
  for (G4int i = 0; i < m_NMaterials; i++) {
    const G4Material* material = (*mtable)[i];
    msc->SetCurrentCouple(m_Couples[i]);
    B2DEBUG(20, "EnergyLossForExtrapolator::ComputeTransportXS()"
            << LogVar("material index", i)
            << LogVar("material name", material->GetName())
           );
    G4PhysicsVector* aVector = (*table)[i];
    for (G4int j = 0; j <= m_Nbins; j++) {
      G4double e = aVector->Energy(j);
      G4double xs = msc->CrossSectionPerVolume(material, part, e);
      aVector->PutValue(j, xs);
      B2DEBUG(20, "EnergyLossForExtrapolator::ComputeTransportXS()"
              << LogVar("bin", j)
              << LogVar("energy [MeV]", e / CLHEP::MeV)
              << LogVar("xs [1/mm]", xs * CLHEP::mm)
             );
    }
    aVector->FillSecondDerivatives();
  }
  delete msc;
  delete mscPC;
}

ComputeTrueStep()

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

inline

Get average scattering angle after a step in given material by given particle.

Get true step length for given particle and kinetic energy

Definition at line 372 of file EnergyLossForExtrapolator.h.

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

ComputeValue()

G4double ComputeValue ( G4double  x, const G4PhysicsTable *  table  )

inlineprivate

Get the tabulated energy-loss, fluctuation, or scattering value for the given input.

Definition at line 399 of file EnergyLossForExtrapolator.h.

    {
      G4double res = 0.0;
      G4bool b;
      if (table) res = ((*table)[m_MaterialIndex])->GetValue(x, b);
      return res;
    }

EnergyAfterStep()

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

Get kinetic energy after a step in given material by given particle.

Definition at line 122 of file EnergyLossForExtrapolator.cc.

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

EnergyBeforeStep()

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

Get kinetic energy before a step in given material by given particle.

Definition at line 144 of file EnergyLossForExtrapolator.cc.

{
  //- if (!isInitialised) Initialisation();
  G4double kinEnergyFinal = kinEnergy;
 
  if (SetupKinematics(part, mat, kinEnergy)) {
    G4double step = TrueStepLength(kinEnergy, stepLength, mat, part);
    G4double r  = ComputeRange(kinEnergy, part);
 
    if (step < m_LinLossLimit * r) {
      kinEnergyFinal += step * ComputeDEDX(kinEnergy, part);
    } else {
      G4double r1 = r + step;
      kinEnergyFinal = ComputeEnergy(r1, part);
    }
  }
  return kinEnergyFinal;
}

Initialisation()

void Initialisation ( )

private

Initialize tables used to calculate energy loss, fluctuation, and scattering for electrons, positrons, muons, pions, kaons, protons and deuterons in all materials.

Definition at line 231 of file EnergyLossForExtrapolator.cc.

{
  m_Initialised = true;
  B2DEBUG(20, "EnergyLossForExtrapolator::Initialisation");
  m_Particle = 0;
  m_Material = 0;
  m_KineticEnergy = 0.0;
 
  m_Electron  = G4ParticleTable::GetParticleTable()->FindParticle("g4e_e-");
  m_Positron  = G4ParticleTable::GetParticleTable()->FindParticle("g4e_e+");
  m_MuonPlus  = G4ParticleTable::GetParticleTable()->FindParticle("g4e_mu+");
  m_MuonMinus = G4ParticleTable::GetParticleTable()->FindParticle("g4e_mu-");
  m_PionPlus  = G4ParticleTable::GetParticleTable()->FindParticle("g4e_pi+");
  m_PionMinus = G4ParticleTable::GetParticleTable()->FindParticle("g4e_pi-");
  m_KaonPlus  = G4ParticleTable::GetParticleTable()->FindParticle("g4e_kaon+");
  m_KaonMinus = G4ParticleTable::GetParticleTable()->FindParticle("g4e_kaon-");
  m_Proton  = G4ParticleTable::GetParticleTable()->FindParticle("g4e_proton");
  m_AntiProton = G4ParticleTable::GetParticleTable()->FindParticle("g4e_anti_proton");
  m_Deuteron = G4ParticleTable::GetParticleTable()->FindParticle("g4e_deuteron");
  m_AntiDeuteron = G4ParticleTable::GetParticleTable()->FindParticle("g4e_anti_deuteron");
 
  m_NMaterials = G4Material::GetNumberOfMaterials();
  const G4MaterialTable* mtable = G4Material::GetMaterialTable();
  m_ProductionCuts = new G4ProductionCuts();
 
  m_Couples.resize(m_NMaterials, 0);
  m_Cuts.resize(m_NMaterials, DBL_MAX);
 
  for (G4int i = 0; i < m_NMaterials; i++) {
    m_Couples[i] = new G4MaterialCutsCouple((*mtable)[i], m_ProductionCuts);
  }
 
  m_DedxElectron     = PrepareTable();
  m_DedxPositron     = PrepareTable();
  m_DedxMuon         = PrepareTable();
  m_DedxPion         = PrepareTable();
  m_DedxKaon         = PrepareTable();
  m_DedxProton       = PrepareTable();
  m_DedxDeuteron     = PrepareTable();
  m_RangeElectron    = PrepareTable();
  m_RangePositron    = PrepareTable();
  m_RangeMuon        = PrepareTable();
  m_RangePion        = PrepareTable();
  m_RangeKaon        = PrepareTable();
  m_RangeProton      = PrepareTable();
  m_RangeDeuteron    = PrepareTable();
  m_InvRangeElectron = PrepareTable();
  m_InvRangePositron = PrepareTable();
  m_InvRangeMuon     = PrepareTable();
  m_InvRangePion     = PrepareTable();
  m_InvRangeKaon     = PrepareTable();
  m_InvRangeProton   = PrepareTable();
  m_InvRangeDeuteron = PrepareTable();
  m_MscatElectron    = PrepareTable();
 
  G4LossTableBuilder& builder = *(G4LossTableManager::Instance()->GetTableBuilder());
  builder.SetBaseMaterialActive(false);
 
  B2DEBUG(20, "EnergyLossForExtrapolator Builds electron tables");
  ComputeElectronDEDX(m_Electron, m_DedxElectron);
  builder.BuildRangeTable(m_DedxElectron, m_RangeElectron);
  builder.BuildInverseRangeTable(m_RangeElectron, m_InvRangeElectron);
 
  B2DEBUG(20, "EnergyLossForExtrapolator Builds positron tables");
  ComputeElectronDEDX(m_Positron, m_DedxPositron);
  builder.BuildRangeTable(m_DedxPositron, m_RangePositron);
  builder.BuildInverseRangeTable(m_RangePositron, m_InvRangePositron);
 
  B2DEBUG(20, "EnergyLossForExtrapolator Builds muon tables");
  ComputeMuonDEDX(m_MuonPlus, m_DedxMuon);
  builder.BuildRangeTable(m_DedxMuon, m_RangeMuon);
  builder.BuildInverseRangeTable(m_RangeMuon, m_InvRangeMuon);
 
  B2DEBUG(20, "EnergyLossForExtrapolator Builds pion tables");
  ComputeHadronDEDX(m_PionPlus, m_DedxPion);
  builder.BuildRangeTable(m_DedxPion, m_RangePion);
  builder.BuildInverseRangeTable(m_RangePion, m_InvRangePion);
 
  B2DEBUG(20, "EnergyLossForExtrapolator Builds kaon tables");
  ComputeHadronDEDX(m_KaonPlus, m_DedxKaon);
  builder.BuildRangeTable(m_DedxKaon, m_RangeKaon);
  builder.BuildInverseRangeTable(m_RangeKaon, m_InvRangeKaon);
 
  B2DEBUG(20, "EnergyLossForExtrapolator Builds proton tables");
  ComputeHadronDEDX(m_Proton, m_DedxProton);
  builder.BuildRangeTable(m_DedxProton, m_RangeProton);
  builder.BuildInverseRangeTable(m_RangeProton, m_InvRangeProton);
 
  B2DEBUG(20, "EnergyLossForExtrapolator Builds deuteron tables");
  ComputeHadronDEDX(m_Deuteron, m_DedxDeuteron);
  builder.BuildRangeTable(m_DedxDeuteron, m_RangeDeuteron);
  builder.BuildInverseRangeTable(m_RangeDeuteron, m_InvRangeDeuteron);
 
  ComputeTransportXS(m_Electron, m_MscatElectron);
}

PrepareTable()

G4PhysicsTable * PrepareTable ( )

private

Create a new table to store one type of kinematics data for a particle.

Definition at line 327 of file EnergyLossForExtrapolator.cc.

{
  G4PhysicsTable* table = new G4PhysicsTable();
 
  for (G4int i = 0; i < m_NMaterials; i++) {
 
    G4PhysicsVector* v = new G4PhysicsLogVector(m_UserTmin, m_UserTmax, m_Nbins, true);
    table->push_back(v);
  }
  return table;
}

SetMaxEnergyTransfer()

void SetMaxEnergyTransfer ( G4double  val )

inline

Change the maximum energy loss or gain for this class (default is infinity)

Definition at line 431 of file EnergyLossForExtrapolator.h.

    {
      m_UserMaxEnergyTransfer = val;
    }

SetMaxKinEnergy()

void SetMaxKinEnergy ( G4double  val )

inline

Change the maximum particle kinetic energy for this class (default is 10 TeV)

Definition at line 424 of file EnergyLossForExtrapolator.h.

    {
      m_UserTmax = val;
    }

SetMinKinEnergy()

void SetMinKinEnergy ( G4double  val )

inline

Get energy dispersion for a step in given material by given particle.

Get energy dispersion for a step in given material by given particle Change the GEANT4 verbosity for this class Change the minimum particle kinetic energy for this class (default is 1 MeV)

Definition at line 417 of file EnergyLossForExtrapolator.h.

    {
      m_UserTmin = val;
    }

SetupKinematics()

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

private

Save current particle properties, kinetic energy and material in internal cached state.

Definition at line 187 of file EnergyLossForExtrapolator.cc.

{
  if (!part || !mat || kinEnergy < CLHEP::keV) return false;
  //- if (!isInitialised) Initialisation();
  G4bool flag = false;
  if (part != m_Particle) {
    flag = true;
    m_Particle = part;
    m_Mass = part->GetPDGMass();
    G4double q = part->GetPDGCharge() / CLHEP::eplus;
    m_ChargeSq = q * q;
  }
  if (mat != m_Material) {
    G4int i = mat->GetIndex();
    if (i >= m_NMaterials) {
      B2WARNING("EnergyLossForExtrapolator: index i= " << i << " is out of table - NO extrapolation");
    } else {
      flag = true;
      m_Material = mat;
      m_ElectronDensity = mat->GetElectronDensity();
      m_RadLength = mat->GetRadlen();
      m_MaterialIndex = i;
    }
  }
  if (flag || kinEnergy != m_KineticEnergy) {
    m_KineticEnergy = kinEnergy;
    G4double tau  = kinEnergy / m_Mass;
 
    m_Gamma = tau + 1.0;
    m_BetaGammaSq = tau * (tau + 2.0);
    m_BetaSq = m_BetaGammaSq / (m_Gamma * m_Gamma);
    m_Tmax  = kinEnergy;
    if (part == m_Electron) m_Tmax *= 0.5;
    else if (part != m_Positron) {
      G4double r = CLHEP::electron_mass_c2 / m_Mass;
      m_Tmax = 2.0 * m_BetaGammaSq * CLHEP::electron_mass_c2 / (1.0 + 2.0 * m_Gamma * r + r * r);
    }
    if (m_Tmax > m_UserMaxEnergyTransfer) m_Tmax = m_UserMaxEnergyTransfer;
  }
  return true;
}

TrueStepLength()

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

Get true step length for given particle and kinetic energy.

Definition at line 166 of file EnergyLossForExtrapolator.cc.

{
  G4double res = stepLength;
  //- if (!isInitialised) Initialisation();
  if (SetupKinematics(part, mat, kinEnergy)) {
    if (part == m_Electron || part == m_Positron) {
      G4double x = stepLength * ComputeValue(kinEnergy, m_MscatElectron);
      if (x < 0.2) res *= (1.0 + 0.5 * x + x * x / 3.0);
      else if (x < 0.9999) res = -std::log(1.0 - x) * stepLength / x;
      else res = ComputeRange(kinEnergy, part);
 
    } else {
      res = ComputeTrueStep(mat, part, kinEnergy, stepLength);
    }
  }
  return res;
}

Member Data Documentation

m_AntiDeuteron

const G4ParticleDefinition* m_AntiDeuteron

private

Pointer to definition of the antideuteron.

Definition at line 180 of file EnergyLossForExtrapolator.h.

m_AntiProton

const G4ParticleDefinition* m_AntiProton

private

Pointer to definition of the antiproton.

Definition at line 174 of file EnergyLossForExtrapolator.h.

m_BetaGammaSq

G4double m_BetaGammaSq

private

Cached particle's beta*gamma squared.

Definition at line 282 of file EnergyLossForExtrapolator.h.

m_BetaSq

G4double m_BetaSq

private

Cached particle's beta squared.

Definition at line 285 of file EnergyLossForExtrapolator.h.

m_ChargeSq

G4double m_ChargeSq

private

Cached charge-squared (in units of e)

Definition at line 273 of file EnergyLossForExtrapolator.h.

m_Couples

std::vector<const G4MaterialCutsCouple*> m_Couples

private

List of material-cuts pairings.

Definition at line 189 of file EnergyLossForExtrapolator.h.

m_Cuts

G4DataVector m_Cuts

private

Vector of particle cuts.

Definition at line 183 of file EnergyLossForExtrapolator.h.

m_DedxDeuteron

G4PhysicsTable* m_DedxDeuteron

private

Pointer to the deuteron's specific ionization energy loss vs KE table.

Definition at line 210 of file EnergyLossForExtrapolator.h.

m_DedxElectron

G4PhysicsTable* m_DedxElectron

private

Pointer to the electron's specific ionization energy loss vs KE table.

Definition at line 192 of file EnergyLossForExtrapolator.h.

m_DedxKaon

G4PhysicsTable* m_DedxKaon

private

Pointer to the kaon's specific ionization energy loss vs KE table.

Definition at line 204 of file EnergyLossForExtrapolator.h.

m_DedxMuon

G4PhysicsTable* m_DedxMuon

private

Pointer to the muon's specific ionization energy loss vs KE table.

Definition at line 198 of file EnergyLossForExtrapolator.h.

m_DedxPion

G4PhysicsTable* m_DedxPion

private

Pointer to the pion's specific ionization energy loss vs KE table.

Definition at line 201 of file EnergyLossForExtrapolator.h.

m_DedxPositron

G4PhysicsTable* m_DedxPositron

private

Pointer to the positron's specific ionization energy loss vs KE table.

Definition at line 195 of file EnergyLossForExtrapolator.h.

m_DedxProton

G4PhysicsTable* m_DedxProton

private

Pointer to the proton's specific ionization energy loss vs KE table.

Definition at line 207 of file EnergyLossForExtrapolator.h.

m_Deuteron

const G4ParticleDefinition* m_Deuteron

private

Pointer to definition of the deuteron.

Definition at line 177 of file EnergyLossForExtrapolator.h.

m_Electron

const G4ParticleDefinition* m_Electron

private

Pointer to definition of the electron.

Definition at line 147 of file EnergyLossForExtrapolator.h.

m_ElectronDensity

G4double m_ElectronDensity

private

Cached material electron density.

Definition at line 264 of file EnergyLossForExtrapolator.h.

m_Gamma

G4double m_Gamma

private

Cached particle's gamma value.

Definition at line 279 of file EnergyLossForExtrapolator.h.

m_Initialised

G4bool m_Initialised

private

UNUSED Flag to indicate that Initialisation() method has been called.

Definition at line 309 of file EnergyLossForExtrapolator.h.

m_InvRangeDeuteron

G4PhysicsTable* m_InvRangeDeuteron

private

Pointer to the deuteron's inverse-range vs KE table.

Definition at line 252 of file EnergyLossForExtrapolator.h.

m_InvRangeElectron

G4PhysicsTable* m_InvRangeElectron

private

Pointer to the electron's inverse-range vs KE table.

Definition at line 234 of file EnergyLossForExtrapolator.h.

m_InvRangeKaon

G4PhysicsTable* m_InvRangeKaon

private

Pointer to the kaon's inverse-range vs KE table.

Definition at line 246 of file EnergyLossForExtrapolator.h.

m_InvRangeMuon

G4PhysicsTable* m_InvRangeMuon

private

Pointer to the muon's inverse-range vs KE table.

Definition at line 240 of file EnergyLossForExtrapolator.h.

m_InvRangePion

G4PhysicsTable* m_InvRangePion

private

Pointer to the pion's inverse-range vs KE table.

Definition at line 243 of file EnergyLossForExtrapolator.h.

m_InvRangePositron

G4PhysicsTable* m_InvRangePositron

private

Pointer to the positron's inverse-range vs KE table.

Definition at line 237 of file EnergyLossForExtrapolator.h.

m_InvRangeProton

G4PhysicsTable* m_InvRangeProton

private

Pointer to the proton's inverse-range vs KE table.

Definition at line 249 of file EnergyLossForExtrapolator.h.

m_KaonMinus

const G4ParticleDefinition* m_KaonMinus

private

Pointer to definition of the negative kaon.

Definition at line 168 of file EnergyLossForExtrapolator.h.

m_KaonPlus

const G4ParticleDefinition* m_KaonPlus

private

Pointer to definition of the positive kaon.

Definition at line 165 of file EnergyLossForExtrapolator.h.

m_KineticEnergy

G4double m_KineticEnergy

private

Cached particle kinetic energy.

Definition at line 276 of file EnergyLossForExtrapolator.h.

m_LinLossLimit

G4double m_LinLossLimit

private

Step-length limit in units of range (0.01); not modifiable by user.

Definition at line 291 of file EnergyLossForExtrapolator.h.

m_Mass

G4double m_Mass

private

Cached particle mass.

Definition at line 270 of file EnergyLossForExtrapolator.h.

m_Material

const G4Material* m_Material

private

Pointer to internally cached material.

Definition at line 258 of file EnergyLossForExtrapolator.h.

m_MaterialIndex

G4int m_MaterialIndex

private

Cached material index.

Definition at line 261 of file EnergyLossForExtrapolator.h.

m_MscatElectron

G4PhysicsTable* m_MscatElectron

private

Pointer to the electron's multiple-scattering cross section vs KE table.

Definition at line 255 of file EnergyLossForExtrapolator.h.

m_MuonMinus

const G4ParticleDefinition* m_MuonMinus

private

Pointer to definition of the negative muon.

Definition at line 156 of file EnergyLossForExtrapolator.h.

m_MuonPlus

const G4ParticleDefinition* m_MuonPlus

private

Pointer to definition of the positive muon.

Definition at line 153 of file EnergyLossForExtrapolator.h.

m_Nbins

G4int m_Nbins

private

Number of bins in each energy loss, fluctuation, and multiple-scattering table (70, fixed)

Definition at line 303 of file EnergyLossForExtrapolator.h.

m_NMaterials

G4int m_NMaterials

private

Number of materials in current geometry.

Definition at line 306 of file EnergyLossForExtrapolator.h.

m_Particle

const G4ParticleDefinition* m_Particle

private

Pointer to definition of the currently cached particle.

Definition at line 144 of file EnergyLossForExtrapolator.h.

m_PionMinus

const G4ParticleDefinition* m_PionMinus

private

Pointer to definition of the negative pion.

Definition at line 162 of file EnergyLossForExtrapolator.h.

m_PionPlus

const G4ParticleDefinition* m_PionPlus

private

Pointer to definition of the positive pion.

Definition at line 159 of file EnergyLossForExtrapolator.h.

m_Positron

const G4ParticleDefinition* m_Positron

private

Pointer to definition of the positron.

Definition at line 150 of file EnergyLossForExtrapolator.h.

m_ProductionCuts

G4ProductionCuts* m_ProductionCuts

private

Pointer to the internal cache of default G4ProductionCuts.

Definition at line 186 of file EnergyLossForExtrapolator.h.

m_Proton

const G4ParticleDefinition* m_Proton

private

Pointer to definition of the proton.

Definition at line 171 of file EnergyLossForExtrapolator.h.

m_RadLength

G4double m_RadLength

private

Cached material radiation length.

Definition at line 267 of file EnergyLossForExtrapolator.h.

m_RangeDeuteron

G4PhysicsTable* m_RangeDeuteron

private

Pointer to the deuteron's range vs KE table.

Definition at line 231 of file EnergyLossForExtrapolator.h.

m_RangeElectron

G4PhysicsTable* m_RangeElectron

private

Pointer to the electron's range vs KE table.

Definition at line 213 of file EnergyLossForExtrapolator.h.

m_RangeKaon

G4PhysicsTable* m_RangeKaon

private

Pointer to the kaon's range vs KE table.

Definition at line 225 of file EnergyLossForExtrapolator.h.

m_RangeMuon

G4PhysicsTable* m_RangeMuon

private

Pointer to the muon's range vs KE table.

Definition at line 219 of file EnergyLossForExtrapolator.h.

m_RangePion

G4PhysicsTable* m_RangePion

private

Pointer to the pion's range vs KE table.

Definition at line 222 of file EnergyLossForExtrapolator.h.

m_RangePositron

G4PhysicsTable* m_RangePositron

private

Pointer to the positron's range vs KE table.

Definition at line 216 of file EnergyLossForExtrapolator.h.

m_RangeProton

G4PhysicsTable* m_RangeProton

private

Pointer to the proton's range vs KE table.

Definition at line 228 of file EnergyLossForExtrapolator.h.

m_Tmax

G4double m_Tmax

private

Cached particle's maximum kinetic-energy loss.

Definition at line 288 of file EnergyLossForExtrapolator.h.

m_UserMaxEnergyTransfer

G4double m_UserMaxEnergyTransfer

private

User's upper limit on maximum kinetic-energy loss (default infinity)

Definition at line 300 of file EnergyLossForExtrapolator.h.

m_UserTmax

G4double m_UserTmax

private

User's maximum kinetic energy for particles (default 10 TeV)

Definition at line 297 of file EnergyLossForExtrapolator.h.

m_UserTmin

G4double m_UserTmin

private

User's minimum kinetic energy for particles (default 1 MeV)

Definition at line 294 of file EnergyLossForExtrapolator.h.

---

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

• simulation/kernel/include/EnergyLossForExtrapolator.h
• simulation/kernel/src/EnergyLossForExtrapolator.cc