#include <G4IonDEDXHandler.hh>

Data Structures
struct	CacheEntry

Public Member Functions
G4bool	BuildDEDXTable (const G4ParticleDefinition , const G4Material )

G4bool	BuildDEDXTable (G4int atomicNumberIon, const G4Material *)

void	ClearCache ()

	G4IonDEDXHandler (const G4IonDEDXHandler &)=delete

	G4IonDEDXHandler (G4VIonDEDXTable tables, G4VIonDEDXScalingAlgorithm algorithm, const G4String &name, G4int maxCacheSize=5, G4bool splines=true)

G4double	GetDEDX (const G4ParticleDefinition , const G4Material , G4double)

G4double	GetLowerEnergyEdge (const G4ParticleDefinition , const G4Material )

G4String	GetName ()

G4double	GetUpperEnergyEdge (const G4ParticleDefinition , const G4Material )

G4bool	IsApplicable (const G4ParticleDefinition , const G4Material )

G4IonDEDXHandler &	operator= (const G4IonDEDXHandler &r)=delete

void	PrintDEDXTable (const G4ParticleDefinition , const G4Material , G4double, G4double, G4int, G4bool logScaleEnergy=true)

	~G4IonDEDXHandler ()

Private Types
typedef std::list< G4CacheEntry >	CacheEntryList

typedef std::map< G4CacheKey, void * >	CacheIterPointerMap

typedef std::map< G4IonKey, G4PhysicsVector * >	DEDXTable

typedef std::map< G4IonKey, G4PhysicsVector * >	DEDXTableBraggRule

typedef struct G4IonDEDXHandler::CacheEntry	G4CacheEntry

typedef std::pair< const G4ParticleDefinition , const G4Material >	G4CacheKey

typedef std::pair< G4int, const G4Material * >	G4IonKey

Private Member Functions
G4CacheValue	GetCacheValue (const G4ParticleDefinition , const G4Material )

G4CacheValue	UpdateCacheValue (const G4ParticleDefinition , const G4Material )

Private Attributes
G4VIonDEDXScalingAlgorithm *	algorithm

CacheEntryList	cacheEntries

CacheIterPointerMap	cacheKeyPointers

G4int	maxCacheEntries

DEDXTable	stoppingPowerTable

DEDXTableBraggRule	stoppingPowerTableBragg

G4VIonDEDXTable *	table

G4String	tableName

G4bool	useSplines

Detailed Description

Definition at line 79 of file G4IonDEDXHandler.hh.

Member Typedef Documentation

◆ CacheEntryList

typedef std::list<G4CacheEntry> G4IonDEDXHandler::CacheEntryList

private

Definition at line 185 of file G4IonDEDXHandler.hh.

◆ CacheIterPointerMap

typedef std::map<G4CacheKey, void*> G4IonDEDXHandler::CacheIterPointerMap

private

Definition at line 188 of file G4IonDEDXHandler.hh.

◆ DEDXTable

typedef std::map<G4IonKey, G4PhysicsVector*> G4IonDEDXHandler::DEDXTable

private

Definition at line 160 of file G4IonDEDXHandler.hh.

◆ DEDXTableBraggRule

typedef std::map<G4IonKey, G4PhysicsVector*> G4IonDEDXHandler::DEDXTableBraggRule

private

Definition at line 164 of file G4IonDEDXHandler.hh.

◆ G4CacheEntry

typedef struct G4IonDEDXHandler::CacheEntry G4IonDEDXHandler::G4CacheEntry

private

◆ G4CacheKey

typedef std::pair<const G4ParticleDefinition*, const G4Material*> G4IonDEDXHandler::G4CacheKey

private

Definition at line 177 of file G4IonDEDXHandler.hh.

◆ G4IonKey

typedef std::pair<G4int, const G4Material*> G4IonDEDXHandler::G4IonKey

private

Definition at line 159 of file G4IonDEDXHandler.hh.

Constructor & Destructor Documentation

◆ G4IonDEDXHandler() [1/2]

G4IonDEDXHandler::G4IonDEDXHandler	(	G4VIonDEDXTable *	tables,
		G4VIonDEDXScalingAlgorithm *	algorithm,
		const G4String &	name,
		G4int	maxCacheSize = `5`,
		G4bool	splines = `true`
	)

explicit

Definition at line 65 of file G4IonDEDXHandler.cc.

                                   :
  table(ionTable),
  algorithm(ionAlgorithm),
  tableName(name),
  useSplines(splines),
  maxCacheEntries(maxCacheSize) {
 
  if(table == nullptr) {
     G4cerr << "G4IonDEDXHandler::G4IonDEDXHandler() "
            << " Pointer to G4VIonDEDXTable object is null-pointer."
            << G4endl;
  }
 
  if(algorithm == nullptr) {
     G4cerr << "G4IonDEDXHandler::G4IonDEDXHandler() "
            << " Pointer to G4VIonDEDXScalingAlgorithm object is null-pointer."
            << G4endl;
  }
 
  if(maxCacheEntries <= 0) {
     G4cerr << "G4IonDEDXHandler::G4IonDEDXHandler() "
            << " Cache size <=0. Resetting to 5."
            << G4endl;
     maxCacheEntries = 5;
  }
}

References algorithm, G4cerr, G4endl, maxCacheEntries, and table.

◆ ~G4IonDEDXHandler()

G4IonDEDXHandler::~G4IonDEDXHandler ( )

Definition at line 99 of file G4IonDEDXHandler.cc.

                                    {
 
  ClearCache();
 
  // All stopping power vectors built according to Bragg's addivitiy rule
  // are deleted. All other stopping power vectors are expected to be
  // deleted by their creator class (sub-class of G4VIonDEDXTable).
  // DEDXTableBraggRule::iterator iter = stoppingPowerTableBragg.begin();
  // DEDXTableBraggRule::iterator iter_end = stoppingPowerTableBragg.end();
 
  //  for(;iter != iter_end; iter++) delete iter -> second;
  stoppingPowerTableBragg.clear();
 
  stoppingPowerTable.clear();
 
  if(table != nullptr) 
    delete table;
  if(algorithm != nullptr) 
    delete algorithm;
}

References algorithm, ClearCache(), stoppingPowerTable, stoppingPowerTableBragg, and table.

◆ G4IonDEDXHandler() [2/2]

G4IonDEDXHandler::G4IonDEDXHandler ( const G4IonDEDXHandler & )

delete

Member Function Documentation

◆ BuildDEDXTable() [1/2]

G4bool G4IonDEDXHandler::BuildDEDXTable	(	const G4ParticleDefinition *	particle,
		const G4Material *	material
	)

Definition at line 195 of file G4IonDEDXHandler.cc.

                                             {          // Target material
 
  G4int atomicNumberIon = particle -> GetAtomicNumber();
 
  G4bool isApplicable = BuildDEDXTable(atomicNumberIon, material);
 
  return isApplicable;
}

References BuildDEDXTable(), and eplot::material.

Referenced by BuildDEDXTable().

◆ BuildDEDXTable() [2/2]

G4bool G4IonDEDXHandler::BuildDEDXTable	(	G4int	atomicNumberIon,
		const G4Material *	material
	)

Definition at line 209 of file G4IonDEDXHandler.cc.

                                             {         // Target material
 
  G4bool isApplicable = true;
 
  if(table == 0 || algorithm == 0) {
     isApplicable = false;
     return isApplicable;
  }
 
  G4int atomicNumberBase =
                algorithm -> AtomicNumberBaseIon(atomicNumberIon, material);
 
  // Checking if vector is already built, and returns if this is indeed
  // the case
  G4IonKey key = std::make_pair(atomicNumberBase, material);
 
  auto iter = stoppingPowerTable.find(key);
  if(iter != stoppingPowerTable.end()) return isApplicable;
 
  // Checking if table contains stopping power vector for given material name
  // or chemical formula
  const G4String& chemFormula = material -> GetChemicalFormula();
  const G4String& materialName = material -> GetName();
 
  isApplicable = table -> BuildPhysicsVector(atomicNumberBase, chemFormula);
 
  if(isApplicable) {
     stoppingPowerTable[key] =
              table -> GetPhysicsVector(atomicNumberBase, chemFormula);
     return isApplicable;
  }
 
  isApplicable = table -> BuildPhysicsVector(atomicNumberBase, materialName);
  if(isApplicable) {
     stoppingPowerTable[key] =
              table -> GetPhysicsVector(atomicNumberBase, materialName);
     return isApplicable;
  }
 
  // Building the stopping power vector based on Bragg's additivity rule
  const G4ElementVector* elementVector = material -> GetElementVector() ;
 
  std::vector<G4PhysicsVector*> dEdxTable;
 
  size_t nmbElements = material -> GetNumberOfElements();
 
  for(size_t i = 0; i < nmbElements; i++) {
 
      G4int atomicNumberMat = G4int((*elementVector)[i] -> GetZ());
 
      isApplicable = table -> BuildPhysicsVector(atomicNumberBase, atomicNumberMat);
 
      if(isApplicable) {
 
         G4PhysicsVector* dEdx =
                  table -> GetPhysicsVector(atomicNumberBase, atomicNumberMat);
         dEdxTable.push_back(dEdx);
      }
      else {
 
         dEdxTable.clear();
         break;
      }
  }
 
  if(isApplicable) {
 
     if(dEdxTable.size() > 0) {
 
        size_t nmbdEdxBins = dEdxTable[0] -> GetVectorLength();
        G4double lowerEdge = dEdxTable[0] -> GetLowEdgeEnergy(0);
        G4double upperEdge = dEdxTable[0] -> GetLowEdgeEnergy(nmbdEdxBins-1);
 
        G4PhysicsFreeVector* dEdxBragg =
      new G4PhysicsFreeVector(nmbdEdxBins,
                  lowerEdge,
                  upperEdge,
                  useSplines);
 
        const G4double* massFractionVector = material -> GetFractionVector();
 
        G4bool b;
        for(size_t j = 0; j < nmbdEdxBins; j++) {
 
            G4double edge = dEdxTable[0] -> GetLowEdgeEnergy(j);
 
            G4double value = 0.0;
        for(size_t i = 0; i < nmbElements; i++) {
 
                value += (dEdxTable[i] -> GetValue(edge ,b)) *
                                                       massFractionVector[i];
        }
 
            dEdxBragg -> PutValues(j, edge, value);
    }
    if (useSplines)
      dEdxBragg -> FillSecondDerivatives();
 
#ifdef PRINT_DEBUG
        G4cout << "G4IonDEDXHandler::BuildPhysicsVector() for ion with Z="
               << atomicNumberBase << " in "
               << material -> GetName()
               << G4endl;
 
        G4cout << *dEdxBragg;
#endif
 
    stoppingPowerTable[key] = dEdxBragg;
    stoppingPowerTableBragg[key] = dEdxBragg;
     }
  }
 
  ClearCache();
 
  return isApplicable;
}

References algorithm, ClearCache(), G4cout, G4endl, GetName(), eplot::material, stoppingPowerTable, stoppingPowerTableBragg, table, and useSplines.

◆ ClearCache()

void G4IonDEDXHandler::ClearCache ( )

Definition at line 426 of file G4IonDEDXHandler.cc.

                                  {
 
  CacheIterPointerMap::iterator iter = cacheKeyPointers.begin();
  CacheIterPointerMap::iterator iter_end = cacheKeyPointers.end();
 
  for(;iter != iter_end; iter++) {
      void* pointerIter = iter -> second;
      CacheEntryList::iterator* listPointerIter =
                          (CacheEntryList::iterator*) pointerIter;
 
      delete listPointerIter;
  }
 
  cacheEntries.clear();
  cacheKeyPointers.clear();
}

References cacheEntries, cacheKeyPointers, and second.

Referenced by BuildDEDXTable(), and ~G4IonDEDXHandler().

◆ GetCacheValue()

G4CacheValue G4IonDEDXHandler::GetCacheValue	(	const G4ParticleDefinition *	particle,
		const G4Material *	material
	)

private

Definition at line 378 of file G4IonDEDXHandler.cc.

                                          {          // Target material
 
  G4CacheKey key = std::make_pair(particle, material);
 
  G4CacheEntry entry;
  CacheEntryList::iterator* pointerIter =
                  (CacheEntryList::iterator*) cacheKeyPointers[key];
 
  if(!pointerIter) {
      entry.value = UpdateCacheValue(particle, material);
 
      entry.key = key;
      cacheEntries.push_front(entry);
 
      CacheEntryList::iterator* pointerIter1 =
                                   new CacheEntryList::iterator();
      *pointerIter1 = cacheEntries.begin();
      cacheKeyPointers[key] = pointerIter1;
 
      if(G4int(cacheEntries.size()) > maxCacheEntries) {
 
     G4CacheEntry lastEntry = cacheEntries.back();
 
         void* pointerIter2 = cacheKeyPointers[lastEntry.key];
         CacheEntryList::iterator* listPointerIter =
                          (CacheEntryList::iterator*) pointerIter2;
 
         cacheEntries.erase(*listPointerIter);
 
         delete listPointerIter;
         cacheKeyPointers.erase(lastEntry.key);
      }
  }
  else {
      entry = *(*pointerIter);
      // Cache entries are currently not re-ordered.
      // Uncomment for activating re-ordering:
      //      cacheEntries.erase(*pointerIter);
      //      cacheEntries.push_front(entry);
      //      *pointerIter = cacheEntries.begin();
  }
  return entry.value;
}

References cacheEntries, cacheKeyPointers, G4IonDEDXHandler::CacheEntry::key, eplot::material, maxCacheEntries, UpdateCacheValue(), and G4IonDEDXHandler::CacheEntry::value.

Referenced by GetDEDX(), GetLowerEnergyEdge(), and GetUpperEnergyEdge().

◆ GetDEDX()

G4double G4IonDEDXHandler::GetDEDX	(	const G4ParticleDefinition *	particle,
		const G4Material *	material,
		G4double	kineticEnergy
	)

Definition at line 148 of file G4IonDEDXHandler.cc.

                                         {     // Kinetic energy of projectile
 
  G4double dedx = 0.0;
 
  G4CacheValue value = GetCacheValue(particle, material);
 
  if(kineticEnergy <= 0.0) dedx = 0.0;
  else if(value.dedxVector != 0) {
 
     G4bool b;
     G4double factor = value.density;
 
     factor *= algorithm -> ScalingFactorDEDX(particle,
                                             material,
                                             kineticEnergy);
     G4double scaledKineticEnergy = kineticEnergy * value.energyScaling;
 
     if(scaledKineticEnergy < value.lowerEnergyEdge) {
 
        factor *= std::sqrt(scaledKineticEnergy / value.lowerEnergyEdge);
        scaledKineticEnergy = value.lowerEnergyEdge;
     }
 
     dedx = factor * value.dedxVector -> GetValue(scaledKineticEnergy, b);
 
     if(dedx < 0.0) dedx = 0.0;
  }
  else dedx = 0.0;
 
#ifdef PRINT_DEBUG
     G4cout << "G4IonDEDXHandler::GetDEDX() E = "
            << kineticEnergy / MeV << " MeV * "
            << value.energyScaling << " = "
            << kineticEnergy * value.energyScaling / MeV
            << " MeV, dE/dx = " << dedx / MeV * cm << " MeV/cm"
            << ", material = " << material -> GetName()
            << G4endl;
#endif
 
  return dedx;
}

References algorithm, cm, CacheValue::dedxVector, CacheValue::density, CacheValue::energyScaling, G4cout, G4endl, GetCacheValue(), GetName(), CacheValue::lowerEnergyEdge, eplot::material, and MeV.

Referenced by PrintDEDXTable().

◆ GetLowerEnergyEdge()

G4double G4IonDEDXHandler::GetLowerEnergyEdge	(	const G4ParticleDefinition *	particle,
		const G4Material *	material
	)

Definition at line 518 of file G4IonDEDXHandler.cc.

                                             {          // Target material
 
  G4double edge = 0.0;
 
  G4CacheValue value = GetCacheValue(particle, material);
 
  if(value.energyScaling > 0)
          edge = value.lowerEnergyEdge / value.energyScaling;
 
  return edge;
}

References CacheValue::energyScaling, GetCacheValue(), CacheValue::lowerEnergyEdge, and eplot::material.

Referenced by PrintDEDXTable().

◆ GetName()

G4String G4IonDEDXHandler::GetName ( )

Definition at line 550 of file G4IonDEDXHandler.cc.

                                   {
 
  return tableName;
}

References tableName.

Referenced by BuildDEDXTable(), GetDEDX(), PrintDEDXTable(), and UpdateCacheValue().

◆ GetUpperEnergyEdge()

G4double G4IonDEDXHandler::GetUpperEnergyEdge	(	const G4ParticleDefinition *	particle,
		const G4Material *	material
	)

Definition at line 534 of file G4IonDEDXHandler.cc.

                                             {          // Target material
 
  G4double edge = 0.0;
 
  G4CacheValue value = GetCacheValue(particle, material);
 
  if(value.energyScaling > 0)
          edge = value.upperEnergyEdge / value.energyScaling;
 
  return edge;
}

References CacheValue::energyScaling, GetCacheValue(), eplot::material, and CacheValue::upperEnergyEdge.

Referenced by PrintDEDXTable().

◆ IsApplicable()

G4bool G4IonDEDXHandler::IsApplicable	(	const G4ParticleDefinition *	particle,
		const G4Material *	material
	)

Definition at line 122 of file G4IonDEDXHandler.cc.

                                             {          // Target material
 
  G4bool isApplicable = true;
 
  if(table == nullptr || algorithm == nullptr) {
     isApplicable = false;
  }
  else {
 
     G4int atomicNumberIon = particle -> GetAtomicNumber();
     G4int atomicNumberBase =
                algorithm -> AtomicNumberBaseIon(atomicNumberIon, material);
 
     G4IonKey key = std::make_pair(atomicNumberBase, material);
 
     DEDXTable::iterator iter = stoppingPowerTable.find(key);
     if(iter == stoppingPowerTable.end()) isApplicable = false;
  }
 
  return isApplicable;
}

References algorithm, eplot::material, stoppingPowerTable, and table.

◆ operator=()

G4IonDEDXHandler & G4IonDEDXHandler::operator= ( const G4IonDEDXHandler & r )

delete

◆ PrintDEDXTable()

void G4IonDEDXHandler::PrintDEDXTable	(	const G4ParticleDefinition *	particle,
		const G4Material *	material,
		G4double	lowerBoundary,
		G4double	upperBoundary,
		G4int	nmbBins,
		G4bool	logScaleEnergy = `true`
	)

Definition at line 445 of file G4IonDEDXHandler.cc.

                                         {     // Logarithmic scaling of energy
 
  G4double atomicMassNumber = particle -> GetAtomicMass();
  G4double materialDensity = material -> GetDensity();
 
  G4cout << "# dE/dx table for " << particle -> GetParticleName()
         << " in material " << material -> GetName()
         << " of density " << materialDensity / g * cm3
         << " g/cm3"
         << G4endl
         << "# Projectile mass number A1 = " << atomicMassNumber
         << G4endl
         << "# Energy range (per nucleon) of tabulation: "
         << GetLowerEnergyEdge(particle, material) / atomicMassNumber / MeV
         << " - "
         << GetUpperEnergyEdge(particle, material) / atomicMassNumber / MeV
         << " MeV"
         << G4endl
         << "# ------------------------------------------------------"
         << G4endl;
  G4cout << "#"
         << std::setw(13) << std::right << "E"
         << std::setw(14) << "E/A1"
         << std::setw(14) << "dE/dx"
         << std::setw(14) << "1/rho*dE/dx"
         << G4endl;
  G4cout << "#"
         << std::setw(13) << std::right << "(MeV)"
         << std::setw(14) << "(MeV)"
         << std::setw(14) << "(MeV/cm)"
         << std::setw(14) << "(MeV*cm2/mg)"
         << G4endl
         << "# ------------------------------------------------------"
         << G4endl;
 
  //G4CacheValue value = GetCacheValue(particle, material);
 
  G4double energyLowerBoundary = lowerBoundary * atomicMassNumber;
  G4double energyUpperBoundary = upperBoundary * atomicMassNumber;
 
  if(logScaleEnergy) {
 
     energyLowerBoundary = std::log(energyLowerBoundary);
     energyUpperBoundary = std::log(energyUpperBoundary);
  }
 
  G4double deltaEnergy = (energyUpperBoundary - energyLowerBoundary) /
                                                           G4double(nmbBins);
 
  G4cout.precision(6);
  for(int i = 0; i < nmbBins + 1; i++) {
 
      G4double energy = energyLowerBoundary + i * deltaEnergy;
      if(logScaleEnergy) energy = G4Exp(energy);
 
      G4double loss = GetDEDX(particle, material, energy);
 
      G4cout << std::setw(14) << std::right << energy / MeV
             << std::setw(14) << energy / atomicMassNumber / MeV
             << std::setw(14) << loss / MeV * cm
             << std::setw(14) << loss / materialDensity / (MeV*cm2/(0.001*g))
             << G4endl;
  }
}

References cm, cm2, cm3, G4INCL::KinematicsUtils::energy(), g, G4cout, G4endl, G4Exp(), GetDEDX(), GetLowerEnergyEdge(), GetName(), GetUpperEnergyEdge(), eplot::material, and MeV.

◆ UpdateCacheValue()

G4CacheValue G4IonDEDXHandler::UpdateCacheValue	(	const G4ParticleDefinition *	particle,
		const G4Material *	material
	)

private

Definition at line 330 of file G4IonDEDXHandler.cc.

                                          {          // Target material
 
  G4CacheValue value;
 
  G4int atomicNumberIon = particle -> GetAtomicNumber();
  G4int atomicNumberBase =
                algorithm -> AtomicNumberBaseIon(atomicNumberIon, material);
 
  G4IonKey key = std::make_pair(atomicNumberBase, material);
 
  DEDXTable::iterator iter = stoppingPowerTable.find(key);
 
  if(iter != stoppingPowerTable.end()) {
     value.dedxVector = iter -> second;
 
     G4double nmbNucleons = G4double(particle -> GetAtomicMass());
     value.energyScaling =
           algorithm -> ScalingFactorEnergy(particle, material) / nmbNucleons;
 
     size_t nmbdEdxBins = value.dedxVector -> GetVectorLength();
     value.lowerEnergyEdge = value.dedxVector -> GetLowEdgeEnergy(0);
 
     value.upperEnergyEdge =
                       value.dedxVector -> GetLowEdgeEnergy(nmbdEdxBins-1);
     value.density = material -> GetDensity();
  }
  else {
     value.dedxVector = 0;
     value.energyScaling = 0.0;
     value.lowerEnergyEdge = 0.0;
     value.upperEnergyEdge = 0.0;
     value.density = 0.0;
  }
 
#ifdef PRINT_DEBUG
  G4cout << "G4IonDEDXHandler::UpdateCacheValue() for "
         << particle -> GetParticleName() << " in "
         << material -> GetName()
         << G4endl;
#endif
 
  return value;
}

References algorithm, CacheValue::dedxVector, CacheValue::density, CacheValue::energyScaling, G4cout, G4endl, GetName(), CacheValue::lowerEnergyEdge, eplot::material, second, stoppingPowerTable, and CacheValue::upperEnergyEdge.

Referenced by GetCacheValue().

Field Documentation

◆ algorithm

G4VIonDEDXScalingAlgorithm* G4IonDEDXHandler::algorithm

private

Definition at line 153 of file G4IonDEDXHandler.hh.

Referenced by BuildDEDXTable(), G4IonDEDXHandler(), GetDEDX(), IsApplicable(), UpdateCacheValue(), and ~G4IonDEDXHandler().

◆ cacheEntries

CacheEntryList G4IonDEDXHandler::cacheEntries

private

Definition at line 186 of file G4IonDEDXHandler.hh.

Referenced by ClearCache(), and GetCacheValue().

◆ cacheKeyPointers

CacheIterPointerMap G4IonDEDXHandler::cacheKeyPointers

private

Definition at line 189 of file G4IonDEDXHandler.hh.

Referenced by ClearCache(), and GetCacheValue().

◆ maxCacheEntries

G4int G4IonDEDXHandler::maxCacheEntries

private

Definition at line 202 of file G4IonDEDXHandler.hh.

Referenced by G4IonDEDXHandler(), and GetCacheValue().

◆ stoppingPowerTable

DEDXTable G4IonDEDXHandler::stoppingPowerTable

private

Definition at line 161 of file G4IonDEDXHandler.hh.

Referenced by BuildDEDXTable(), IsApplicable(), UpdateCacheValue(), and ~G4IonDEDXHandler().

◆ stoppingPowerTableBragg

DEDXTableBraggRule G4IonDEDXHandler::stoppingPowerTableBragg

private

Definition at line 165 of file G4IonDEDXHandler.hh.

Referenced by BuildDEDXTable(), and ~G4IonDEDXHandler().

◆ table

G4VIonDEDXTable* G4IonDEDXHandler::table

private

Definition at line 150 of file G4IonDEDXHandler.hh.

Referenced by BuildDEDXTable(), G4IonDEDXHandler(), IsApplicable(), and ~G4IonDEDXHandler().

◆ tableName

G4String G4IonDEDXHandler::tableName

private

Definition at line 156 of file G4IonDEDXHandler.hh.

Referenced by GetName().

◆ useSplines

G4bool G4IonDEDXHandler::useSplines

private

Definition at line 169 of file G4IonDEDXHandler.hh.

Referenced by BuildDEDXTable().

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

source/processes/electromagnetic/lowenergy/include/G4IonDEDXHandler.hh
source/processes/electromagnetic/lowenergy/src/G4IonDEDXHandler.cc

Data Structures

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ CacheEntryList

◆ CacheIterPointerMap

◆ DEDXTable

◆ DEDXTableBraggRule

◆ G4CacheEntry

◆ G4CacheKey

◆ G4IonKey

Constructor & Destructor Documentation

◆ G4IonDEDXHandler() [1/2]

◆ ~G4IonDEDXHandler()

◆ G4IonDEDXHandler() [2/2]

Member Function Documentation

◆ BuildDEDXTable() [1/2]

◆ BuildDEDXTable() [2/2]

◆ ClearCache()

◆ GetCacheValue()

◆ GetDEDX()

◆ GetLowerEnergyEdge()

◆ GetName()

◆ GetUpperEnergyEdge()

◆ IsApplicable()

◆ operator=()

◆ PrintDEDXTable()

◆ UpdateCacheValue()

Field Documentation

◆ algorithm

◆ cacheEntries

◆ cacheKeyPointers

◆ maxCacheEntries

◆ stoppingPowerTable

◆ stoppingPowerTableBragg

◆ table

◆ tableName

◆ useSplines