Geant4-11
Data Structures | Public Member Functions | Private Types | Private Member Functions | Private Attributes
G4IonDEDXHandler Class Reference

#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 *)
 
G4IonDEDXHandleroperator= (const G4IonDEDXHandler &r)=delete
 
void PrintDEDXTable (const G4ParticleDefinition *, const G4Material *, G4double, G4double, G4int, G4bool logScaleEnergy=true)
 
 ~G4IonDEDXHandler ()
 

Private Types

typedef std::list< G4CacheEntryCacheEntryList
 
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

G4VIonDEDXScalingAlgorithmalgorithm
 
CacheEntryList cacheEntries
 
CacheIterPointerMap cacheKeyPointers
 
G4int maxCacheEntries
 
DEDXTable stoppingPowerTable
 
DEDXTableBraggRule stoppingPowerTableBragg
 
G4VIonDEDXTabletable
 
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

Definition at line 160 of file G4IonDEDXHandler.hh.

◆ DEDXTableBraggRule

Definition at line 164 of file G4IonDEDXHandler.hh.

◆ G4CacheEntry

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

70 :
71 table(ionTable),
72 algorithm(ionAlgorithm),
74 useSplines(splines),
75 maxCacheEntries(maxCacheSize) {
76
77 if(table == nullptr) {
78 G4cerr << "G4IonDEDXHandler::G4IonDEDXHandler() "
79 << " Pointer to G4VIonDEDXTable object is null-pointer."
80 << G4endl;
81 }
82
83 if(algorithm == nullptr) {
84 G4cerr << "G4IonDEDXHandler::G4IonDEDXHandler() "
85 << " Pointer to G4VIonDEDXScalingAlgorithm object is null-pointer."
86 << G4endl;
87 }
88
89 if(maxCacheEntries <= 0) {
90 G4cerr << "G4IonDEDXHandler::G4IonDEDXHandler() "
91 << " Cache size <=0. Resetting to 5."
92 << G4endl;
94 }
95}
G4GLOB_DLL std::ostream G4cerr
#define G4endl
Definition: G4ios.hh:57
G4VIonDEDXTable * table
G4VIonDEDXScalingAlgorithm * algorithm
const char * name(G4int ptype)

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

◆ ~G4IonDEDXHandler()

G4IonDEDXHandler::~G4IonDEDXHandler ( )

Definition at line 99 of file G4IonDEDXHandler.cc.

99 {
100
101 ClearCache();
102
103 // All stopping power vectors built according to Bragg's addivitiy rule
104 // are deleted. All other stopping power vectors are expected to be
105 // deleted by their creator class (sub-class of G4VIonDEDXTable).
106 // DEDXTableBraggRule::iterator iter = stoppingPowerTableBragg.begin();
107 // DEDXTableBraggRule::iterator iter_end = stoppingPowerTableBragg.end();
108
109 // for(;iter != iter_end; iter++) delete iter -> second;
111
112 stoppingPowerTable.clear();
113
114 if(table != nullptr)
115 delete table;
116 if(algorithm != nullptr)
117 delete algorithm;
118}
DEDXTable stoppingPowerTable
DEDXTableBraggRule stoppingPowerTableBragg

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.

197 { // Target material
198
199 G4int atomicNumberIon = particle -> GetAtomicNumber();
200
201 G4bool isApplicable = BuildDEDXTable(atomicNumberIon, material);
202
203 return isApplicable;
204}
bool G4bool
Definition: G4Types.hh:86
int G4int
Definition: G4Types.hh:85
G4bool BuildDEDXTable(const G4ParticleDefinition *, const G4Material *)
string material
Definition: eplot.py:19

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.

211 { // Target material
212
213 G4bool isApplicable = true;
214
215 if(table == 0 || algorithm == 0) {
216 isApplicable = false;
217 return isApplicable;
218 }
219
220 G4int atomicNumberBase =
221 algorithm -> AtomicNumberBaseIon(atomicNumberIon, material);
222
223 // Checking if vector is already built, and returns if this is indeed
224 // the case
225 G4IonKey key = std::make_pair(atomicNumberBase, material);
226
227 auto iter = stoppingPowerTable.find(key);
228 if(iter != stoppingPowerTable.end()) return isApplicable;
229
230 // Checking if table contains stopping power vector for given material name
231 // or chemical formula
232 const G4String& chemFormula = material -> GetChemicalFormula();
233 const G4String& materialName = material -> GetName();
234
235 isApplicable = table -> BuildPhysicsVector(atomicNumberBase, chemFormula);
236
237 if(isApplicable) {
238 stoppingPowerTable[key] =
239 table -> GetPhysicsVector(atomicNumberBase, chemFormula);
240 return isApplicable;
241 }
242
243 isApplicable = table -> BuildPhysicsVector(atomicNumberBase, materialName);
244 if(isApplicable) {
245 stoppingPowerTable[key] =
246 table -> GetPhysicsVector(atomicNumberBase, materialName);
247 return isApplicable;
248 }
249
250 // Building the stopping power vector based on Bragg's additivity rule
251 const G4ElementVector* elementVector = material -> GetElementVector() ;
252
253 std::vector<G4PhysicsVector*> dEdxTable;
254
255 size_t nmbElements = material -> GetNumberOfElements();
256
257 for(size_t i = 0; i < nmbElements; i++) {
258
259 G4int atomicNumberMat = G4int((*elementVector)[i] -> GetZ());
260
261 isApplicable = table -> BuildPhysicsVector(atomicNumberBase, atomicNumberMat);
262
263 if(isApplicable) {
264
265 G4PhysicsVector* dEdx =
266 table -> GetPhysicsVector(atomicNumberBase, atomicNumberMat);
267 dEdxTable.push_back(dEdx);
268 }
269 else {
270
271 dEdxTable.clear();
272 break;
273 }
274 }
275
276 if(isApplicable) {
277
278 if(dEdxTable.size() > 0) {
279
280 size_t nmbdEdxBins = dEdxTable[0] -> GetVectorLength();
281 G4double lowerEdge = dEdxTable[0] -> GetLowEdgeEnergy(0);
282 G4double upperEdge = dEdxTable[0] -> GetLowEdgeEnergy(nmbdEdxBins-1);
283
284 G4PhysicsFreeVector* dEdxBragg =
285 new G4PhysicsFreeVector(nmbdEdxBins,
286 lowerEdge,
287 upperEdge,
288 useSplines);
289
290 const G4double* massFractionVector = material -> GetFractionVector();
291
292 G4bool b;
293 for(size_t j = 0; j < nmbdEdxBins; j++) {
294
295 G4double edge = dEdxTable[0] -> GetLowEdgeEnergy(j);
296
297 G4double value = 0.0;
298 for(size_t i = 0; i < nmbElements; i++) {
299
300 value += (dEdxTable[i] -> GetValue(edge ,b)) *
301 massFractionVector[i];
302 }
303
304 dEdxBragg -> PutValues(j, edge, value);
305 }
306 if (useSplines)
307 dEdxBragg -> FillSecondDerivatives();
308
309#ifdef PRINT_DEBUG
310 G4cout << "G4IonDEDXHandler::BuildPhysicsVector() for ion with Z="
311 << atomicNumberBase << " in "
312 << material -> GetName()
313 << G4endl;
314
315 G4cout << *dEdxBragg;
316#endif
317
318 stoppingPowerTable[key] = dEdxBragg;
319 stoppingPowerTableBragg[key] = dEdxBragg;
320 }
321 }
322
323 ClearCache();
324
325 return isApplicable;
326}
std::vector< const G4Element * > G4ElementVector
double G4double
Definition: G4Types.hh:83
G4GLOB_DLL std::ostream G4cout
std::pair< G4int, const G4Material * > G4IonKey

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.

426 {
427
428 CacheIterPointerMap::iterator iter = cacheKeyPointers.begin();
429 CacheIterPointerMap::iterator iter_end = cacheKeyPointers.end();
430
431 for(;iter != iter_end; iter++) {
432 void* pointerIter = iter -> second;
433 CacheEntryList::iterator* listPointerIter =
434 (CacheEntryList::iterator*) pointerIter;
435
436 delete listPointerIter;
437 }
438
439 cacheEntries.clear();
440 cacheKeyPointers.clear();
441}
static constexpr double second
Definition: G4SIunits.hh:137
CacheIterPointerMap cacheKeyPointers
CacheEntryList cacheEntries

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.

380 { // Target material
381
382 G4CacheKey key = std::make_pair(particle, material);
383
384 G4CacheEntry entry;
385 CacheEntryList::iterator* pointerIter =
386 (CacheEntryList::iterator*) cacheKeyPointers[key];
387
388 if(!pointerIter) {
389 entry.value = UpdateCacheValue(particle, material);
390
391 entry.key = key;
392 cacheEntries.push_front(entry);
393
394 CacheEntryList::iterator* pointerIter1 =
395 new CacheEntryList::iterator();
396 *pointerIter1 = cacheEntries.begin();
397 cacheKeyPointers[key] = pointerIter1;
398
399 if(G4int(cacheEntries.size()) > maxCacheEntries) {
400
401 G4CacheEntry lastEntry = cacheEntries.back();
402
403 void* pointerIter2 = cacheKeyPointers[lastEntry.key];
404 CacheEntryList::iterator* listPointerIter =
405 (CacheEntryList::iterator*) pointerIter2;
406
407 cacheEntries.erase(*listPointerIter);
408
409 delete listPointerIter;
410 cacheKeyPointers.erase(lastEntry.key);
411 }
412 }
413 else {
414 entry = *(*pointerIter);
415 // Cache entries are currently not re-ordered.
416 // Uncomment for activating re-ordering:
417 // cacheEntries.erase(*pointerIter);
418 // cacheEntries.push_front(entry);
419 // *pointerIter = cacheEntries.begin();
420 }
421 return entry.value;
422}
std::pair< const G4ParticleDefinition *, const G4Material * > G4CacheKey
struct G4IonDEDXHandler::CacheEntry G4CacheEntry
G4CacheValue UpdateCacheValue(const G4ParticleDefinition *, const G4Material *)

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.

151 { // Kinetic energy of projectile
152
153 G4double dedx = 0.0;
154
155 G4CacheValue value = GetCacheValue(particle, material);
156
157 if(kineticEnergy <= 0.0) dedx = 0.0;
158 else if(value.dedxVector != 0) {
159
160 G4bool b;
161 G4double factor = value.density;
162
163 factor *= algorithm -> ScalingFactorDEDX(particle,
164 material,
165 kineticEnergy);
166 G4double scaledKineticEnergy = kineticEnergy * value.energyScaling;
167
168 if(scaledKineticEnergy < value.lowerEnergyEdge) {
169
170 factor *= std::sqrt(scaledKineticEnergy / value.lowerEnergyEdge);
171 scaledKineticEnergy = value.lowerEnergyEdge;
172 }
173
174 dedx = factor * value.dedxVector -> GetValue(scaledKineticEnergy, b);
175
176 if(dedx < 0.0) dedx = 0.0;
177 }
178 else dedx = 0.0;
179
180#ifdef PRINT_DEBUG
181 G4cout << "G4IonDEDXHandler::GetDEDX() E = "
182 << kineticEnergy / MeV << " MeV * "
183 << value.energyScaling << " = "
184 << kineticEnergy * value.energyScaling / MeV
185 << " MeV, dE/dx = " << dedx / MeV * cm << " MeV/cm"
186 << ", material = " << material -> GetName()
187 << G4endl;
188#endif
189
190 return dedx;
191}
static constexpr double MeV
Definition: G4SIunits.hh:200
static constexpr double cm
Definition: G4SIunits.hh:99
G4CacheValue GetCacheValue(const G4ParticleDefinition *, const G4Material *)
G4double lowerEnergyEdge
G4double density
G4PhysicsVector * dedxVector
G4double energyScaling

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.

520 { // Target material
521
522 G4double edge = 0.0;
523
524 G4CacheValue value = GetCacheValue(particle, material);
525
526 if(value.energyScaling > 0)
527 edge = value.lowerEnergyEdge / value.energyScaling;
528
529 return edge;
530}

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

Referenced by PrintDEDXTable().

◆ GetName()

G4String G4IonDEDXHandler::GetName ( )

Definition at line 550 of file G4IonDEDXHandler.cc.

550 {
551
552 return tableName;
553}

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.

536 { // Target material
537
538 G4double edge = 0.0;
539
540 G4CacheValue value = GetCacheValue(particle, material);
541
542 if(value.energyScaling > 0)
543 edge = value.upperEnergyEdge / value.energyScaling;
544
545 return edge;
546}
G4double upperEnergyEdge

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.

124 { // Target material
125
126 G4bool isApplicable = true;
127
128 if(table == nullptr || algorithm == nullptr) {
129 isApplicable = false;
130 }
131 else {
132
133 G4int atomicNumberIon = particle -> GetAtomicNumber();
134 G4int atomicNumberBase =
135 algorithm -> AtomicNumberBaseIon(atomicNumberIon, material);
136
137 G4IonKey key = std::make_pair(atomicNumberBase, material);
138
139 DEDXTable::iterator iter = stoppingPowerTable.find(key);
140 if(iter == stoppingPowerTable.end()) isApplicable = false;
141 }
142
143 return isApplicable;
144}

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.

451 { // Logarithmic scaling of energy
452
453 G4double atomicMassNumber = particle -> GetAtomicMass();
454 G4double materialDensity = material -> GetDensity();
455
456 G4cout << "# dE/dx table for " << particle -> GetParticleName()
457 << " in material " << material -> GetName()
458 << " of density " << materialDensity / g * cm3
459 << " g/cm3"
460 << G4endl
461 << "# Projectile mass number A1 = " << atomicMassNumber
462 << G4endl
463 << "# Energy range (per nucleon) of tabulation: "
464 << GetLowerEnergyEdge(particle, material) / atomicMassNumber / MeV
465 << " - "
466 << GetUpperEnergyEdge(particle, material) / atomicMassNumber / MeV
467 << " MeV"
468 << G4endl
469 << "# ------------------------------------------------------"
470 << G4endl;
471 G4cout << "#"
472 << std::setw(13) << std::right << "E"
473 << std::setw(14) << "E/A1"
474 << std::setw(14) << "dE/dx"
475 << std::setw(14) << "1/rho*dE/dx"
476 << G4endl;
477 G4cout << "#"
478 << std::setw(13) << std::right << "(MeV)"
479 << std::setw(14) << "(MeV)"
480 << std::setw(14) << "(MeV/cm)"
481 << std::setw(14) << "(MeV*cm2/mg)"
482 << G4endl
483 << "# ------------------------------------------------------"
484 << G4endl;
485
486 //G4CacheValue value = GetCacheValue(particle, material);
487
488 G4double energyLowerBoundary = lowerBoundary * atomicMassNumber;
489 G4double energyUpperBoundary = upperBoundary * atomicMassNumber;
490
491 if(logScaleEnergy) {
492
493 energyLowerBoundary = std::log(energyLowerBoundary);
494 energyUpperBoundary = std::log(energyUpperBoundary);
495 }
496
497 G4double deltaEnergy = (energyUpperBoundary - energyLowerBoundary) /
498 G4double(nmbBins);
499
500 G4cout.precision(6);
501 for(int i = 0; i < nmbBins + 1; i++) {
502
503 G4double energy = energyLowerBoundary + i * deltaEnergy;
504 if(logScaleEnergy) energy = G4Exp(energy);
505
506 G4double loss = GetDEDX(particle, material, energy);
507
508 G4cout << std::setw(14) << std::right << energy / MeV
509 << std::setw(14) << energy / atomicMassNumber / MeV
510 << std::setw(14) << loss / MeV * cm
511 << std::setw(14) << loss / materialDensity / (MeV*cm2/(0.001*g))
512 << G4endl;
513 }
514}
G4double G4Exp(G4double initial_x)
Exponential Function double precision.
Definition: G4Exp.hh:179
static constexpr double cm3
Definition: G4SIunits.hh:101
static constexpr double cm2
Definition: G4SIunits.hh:100
static constexpr double g
Definition: G4SIunits.hh:168
G4double GetLowerEnergyEdge(const G4ParticleDefinition *, const G4Material *)
G4double GetUpperEnergyEdge(const G4ParticleDefinition *, const G4Material *)
G4double GetDEDX(const G4ParticleDefinition *, const G4Material *, G4double)
G4double energy(const ThreeVector &p, const G4double m)

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.

332 { // Target material
333
334 G4CacheValue value;
335
336 G4int atomicNumberIon = particle -> GetAtomicNumber();
337 G4int atomicNumberBase =
338 algorithm -> AtomicNumberBaseIon(atomicNumberIon, material);
339
340 G4IonKey key = std::make_pair(atomicNumberBase, material);
341
342 DEDXTable::iterator iter = stoppingPowerTable.find(key);
343
344 if(iter != stoppingPowerTable.end()) {
345 value.dedxVector = iter -> second;
346
347 G4double nmbNucleons = G4double(particle -> GetAtomicMass());
348 value.energyScaling =
349 algorithm -> ScalingFactorEnergy(particle, material) / nmbNucleons;
350
351 size_t nmbdEdxBins = value.dedxVector -> GetVectorLength();
352 value.lowerEnergyEdge = value.dedxVector -> GetLowEdgeEnergy(0);
353
354 value.upperEnergyEdge =
355 value.dedxVector -> GetLowEdgeEnergy(nmbdEdxBins-1);
356 value.density = material -> GetDensity();
357 }
358 else {
359 value.dedxVector = 0;
360 value.energyScaling = 0.0;
361 value.lowerEnergyEdge = 0.0;
362 value.upperEnergyEdge = 0.0;
363 value.density = 0.0;
364 }
365
366#ifdef PRINT_DEBUG
367 G4cout << "G4IonDEDXHandler::UpdateCacheValue() for "
368 << particle -> GetParticleName() << " in "
369 << material -> GetName()
370 << G4endl;
371#endif
372
373 return value;
374}

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

◆ 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

◆ stoppingPowerTableBragg

DEDXTableBraggRule G4IonDEDXHandler::stoppingPowerTableBragg
private

Definition at line 165 of file G4IonDEDXHandler.hh.

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

◆ table

G4VIonDEDXTable* G4IonDEDXHandler::table
private

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