| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
>> 26 // $Id: G4IonParametrisedLossModel.hh,v 1.8 2010/11/04 12:21:47 vnivanch Exp $
>> 27 // GEANT4 tag $Name: geant4-09-04 $
26 // 28 //
27 // =========================================== 29 // ===========================================================================
28 // GEANT4 class header file 30 // GEANT4 class header file
29 // 31 //
30 // Class: G4IonParametrisedLoss 32 // Class: G4IonParametrisedLossModel
31 // 33 //
32 // Base class: G4VEmModel (utils) 34 // Base class: G4VEmModel (utils)
33 // 35 //
34 // Author: Anton Lechner (Anton. 36 // Author: Anton Lechner (Anton.Lechner@cern.ch)
35 // 37 //
36 // First implementation: 10. 11. 2008 38 // First implementation: 10. 11. 2008
37 // 39 //
38 // Modifications: 03. 02. 2009 - Bug fix itera 40 // Modifications: 03. 02. 2009 - Bug fix iterators (AL)
39 // 11. 03. 2009 - Introduced ne 41 // 11. 03. 2009 - Introduced new table handler(G4IonDEDXHandler)
40 // and modified 42 // and modified method to add/remove tables
41 // (tables are n 43 // (tables are now built in init. phase),
42 // Minor bug fix 44 // Minor bug fix in ComputeDEDXPerVolume (AL)
43 // 12. 11. 2009 - Added functio 45 // 12. 11. 2009 - Added function for switching off scaling
44 // of heavy ions 46 // of heavy ions from ICRU 73 data
45 // 20. 11. 2009 - Added set-met 47 // 20. 11. 2009 - Added set-method for energy loss limit (AL)
46 // 24. 11. 2009 - Bug fix: Rang 48 // 24. 11. 2009 - Bug fix: Range calculation corrected if same
47 // materials app 49 // materials appears with different cuts in diff.
48 // regions (adde 50 // regions (added UpdateRangeCache function and
49 // modified Buil 51 // modified BuildRangeVector, ComputeLossForStep
50 // functions acc 52 // functions accordingly, added new cache param.,
51 // changed typde 53 // changed typdef of IonMatCouple).
52 // - Removed GetRa 54 // - Removed GetRange function (AL)
53 // 55 //
54 // Class description: 56 // Class description:
55 // Model for computing the energy loss of i 57 // Model for computing the energy loss of ions by employing a
56 // parameterisation of dE/dx tables (defaul 58 // parameterisation of dE/dx tables (default ICRU 73 tables). For
57 // ion-material combinations and/or project 59 // ion-material combinations and/or projectile energies not covered
58 // by this model, the G4BraggIonModel and G 60 // by this model, the G4BraggIonModel and G4BetheBloch models are
59 // employed. 61 // employed.
60 // 62 //
61 // Comments: 63 // Comments:
62 // 64 //
63 // =========================================== 65 // ===========================================================================
64 66
65 67
66 #ifndef G4IONPARAMETRISEDLOSSMODEL_HH 68 #ifndef G4IONPARAMETRISEDLOSSMODEL_HH
67 #define G4IONPARAMETRISEDLOSSMODEL_HH 69 #define G4IONPARAMETRISEDLOSSMODEL_HH
68 70
>> 71 #include "G4VEmModel.hh"
>> 72 #include "G4EmCorrections.hh"
>> 73 #include "G4IonDEDXHandler.hh"
69 #include <iomanip> 74 #include <iomanip>
70 #include <list> 75 #include <list>
71 #include <map> 76 #include <map>
72 #include <utility> 77 #include <utility>
73 #include <CLHEP/Units/PhysicalConstants.h> <<
74 <<
75 #include "G4VEmModel.hh" <<
76 #include "G4EmCorrections.hh" <<
77 #include "G4IonDEDXHandler.hh" <<
78 78
79 class G4BraggIonModel; 79 class G4BraggIonModel;
80 class G4BetheBlochModel; 80 class G4BetheBlochModel;
81 class G4ParticleChangeForLoss; 81 class G4ParticleChangeForLoss;
82 class G4VIonDEDXTable; 82 class G4VIonDEDXTable;
83 class G4VIonDEDXScalingAlgorithm; 83 class G4VIonDEDXScalingAlgorithm;
84 class G4PhysicsFreeVector; << 84 class G4LPhysicsFreeVector;
85 class G4MaterialCutsCouple; 85 class G4MaterialCutsCouple;
86 86
87 typedef std::list<G4IonDEDXHandler*> LossTable 87 typedef std::list<G4IonDEDXHandler*> LossTableList;
88 typedef std::pair<const G4ParticleDefinition*, 88 typedef std::pair<const G4ParticleDefinition*,
89 const G4MaterialCutsCouple*> 89 const G4MaterialCutsCouple*> IonMatCouple;
90 90
>> 91
91 class G4IonParametrisedLossModel : public G4VE 92 class G4IonParametrisedLossModel : public G4VEmModel {
92 93
93 public: 94 public:
94 explicit G4IonParametrisedLossModel(const G << 95 G4IonParametrisedLossModel(const G4ParticleDefinition* particle = 0,
95 const G4String& name = "ParamIC << 96 const G4String& name = "ParamICRU73");
96 97
97 virtual ~G4IonParametrisedLossModel(); 98 virtual ~G4IonParametrisedLossModel();
98 99
99 void Initialise( << 100 virtual void Initialise(
100 const G4ParticleDefinition*, // Projecti << 101 const G4ParticleDefinition*, // Projectile
101 const G4DataVector&) override; // Cut en << 102 const G4DataVector&); // Cut energies
102 << 103
103 G4double MinEnergyCut( << 104 virtual G4double MinEnergyCut(
104 const G4ParticleDefinition*, // Project << 105 const G4ParticleDefinition*, // Projectile
105 const G4MaterialCutsCouple*) override; << 106 const G4MaterialCutsCouple*);
106 << 107
107 G4double ComputeCrossSectionPerAtom( << 108 virtual G4double ComputeCrossSectionPerAtom(
108 const G4ParticleDefinition*, // << 109 const G4ParticleDefinition*, // Projectile
109 G4double, // Kinetic energy of << 110 G4double, // Kinetic energy of projectile
110 G4double, // Atomic number << 111 G4double, // Atomic number
111 G4double, // Mass number << 112 G4double, // Mass number
112 G4double, // Energy cut for sec << 113 G4double, // Energy cut for secondary prod.
113 G4double) override; // Maximum e << 114 G4double); // Maximum energy of secondaries
114 << 115
115 G4double CrossSectionPerVolume( << 116 virtual G4double CrossSectionPerVolume(
116 const G4Mater 117 const G4Material*, // Target material
117 const G4ParticleDefinition*, // Proje 118 const G4ParticleDefinition*, // Projectile
118 G4double, // Kinetic energy 119 G4double, // Kinetic energy
119 G4double, // Energy cut for secondar 120 G4double, // Energy cut for secondary prod.
120 G4double) override; // Maximum energy << 121 G4double); // Maximum energy of secondaries
121 122
122 G4double ComputeDEDXPerVolume( << 123 virtual G4double ComputeDEDXPerVolume(
123 const G4Material*, // Target material << 124 const G4Material*, // Target material
124 const G4ParticleDefinition*, // Projec << 125 const G4ParticleDefinition*, // Projectile
125 G4double, // Kinetic energy of projec << 126 G4double, // Kinetic energy of projectile
126 G4double) override; // Energy cut for << 127 G4double); // Energy cut for secondary prod.
127 << 128
128 // Function, which computes the continuous 129 // Function, which computes the continuous energy loss (due to electronic
129 // stopping) for a given pre-step energy an 130 // stopping) for a given pre-step energy and step length by using
130 // range vs energy (and energy vs range) ta 131 // range vs energy (and energy vs range) tables
131 G4double ComputeLossForStep( 132 G4double ComputeLossForStep(
132 const G4Mater 133 const G4MaterialCutsCouple*, // Mat-cuts couple
133 const G4ParticleDefinition*, // Proje 134 const G4ParticleDefinition*, // Projectile
134 G4double, // Kinetic energy of proje 135 G4double, // Kinetic energy of projectile
135 G4double); // Length of current step 136 G4double); // Length of current step
136 137
137 // Function, which computes the mean energy 138 // Function, which computes the mean energy transfer rate to delta rays
138 inline G4double DeltaRayMeanEnergyTransferR 139 inline G4double DeltaRayMeanEnergyTransferRate(
139 const G4Mater 140 const G4Material*, // Target Material
140 const G4ParticleDefinition*, // 141 const G4ParticleDefinition*, // Projectile
141 G4double, // Kinetic energy of proje 142 G4double, // Kinetic energy of projectile
142 G4double); // Energy cut for secondar 143 G4double); // Energy cut for secondary prod.
143 144
144 145
145 void SampleSecondaries(std::vector<G4Dynami << 146 virtual void SampleSecondaries(std::vector<G4DynamicParticle*>*,
146 const G4MaterialCutsCouple*, << 147 const G4MaterialCutsCouple*,
147 const G4DynamicParticle*, << 148 const G4DynamicParticle*,
148 G4double, // Energy cut for secondary << 149 G4double, // Energy cut for secondary prod.
149 G4double) override; // Maximum energy << 150 G4double); // Maximum energy of secondaries
150 151
151 G4double GetChargeSquareRatio( << 152 virtual G4double GetChargeSquareRatio(
152 const G4Parti 153 const G4ParticleDefinition*, // Projectile
153 const G4Material*, // Target Materia 154 const G4Material*, // Target Material
154 G4double) override; // Kinetic energy << 155 G4double); // Kinetic energy of projectile
155 156
156 G4double GetParticleCharge( << 157 virtual G4double GetParticleCharge(
157 const G4ParticleDefinition*, // Pr << 158 const G4ParticleDefinition*, // Projectile
158 const G4Material*, // Target Mate << 159 const G4Material*, // Target Material
159 G4double) override; // Kinetic ene << 160 G4double); // Kinetic energy of projectile
160 << 161
161 void CorrectionsAlongStep( << 162 virtual void CorrectionsAlongStep(
162 const G4MaterialC << 163 const G4MaterialCutsCouple*,// Mat.-Cut couple
163 const G4DynamicParticle*, // Dyn. << 164 const G4DynamicParticle*, // Dyn. particle
164 const G4double&, << 165 G4double&, // Energy loss in current step
165 G4double&) override; // Ener << 166 G4double&,
>> 167 G4double); // Length of current step
166 168
167 // Function which allows to add additional 169 // Function which allows to add additional stopping power tables
168 // in combination with a scaling algorithm, 170 // in combination with a scaling algorithm, which may depend on dynamic
169 // information like the current particle en 171 // information like the current particle energy (the table and scaling
170 // algorithm are used via a handler class, 172 // algorithm are used via a handler class, which performs e.g.caching or
171 // which applies the scaling of energy and 173 // which applies the scaling of energy and dE/dx values)
172 G4bool AddDEDXTable(const G4String& name, 174 G4bool AddDEDXTable(const G4String& name,
173 G4VIonDEDXTable* table, 175 G4VIonDEDXTable* table,
174 G4VIonDEDXScalingAlgorith << 176 G4VIonDEDXScalingAlgorithm* algorithm = 0);
175 177
176 G4bool RemoveDEDXTable(const G4String& name 178 G4bool RemoveDEDXTable(const G4String& name);
177 179
178 // Function which allows to switch off scal 180 // Function which allows to switch off scaling of stopping powers of heavy
179 // ions from existing ICRU 73 data 181 // ions from existing ICRU 73 data
180 // void DeactivateICRU73Scaling(); << 182 void DeactivateICRU73Scaling();
181 183
182 // Function checking the applicability of p 184 // Function checking the applicability of physics tables to ion-material
183 // combinations (Note: the energy range of 185 // combinations (Note: the energy range of tables is not checked)
184 inline LossTableList::iterator IsApplicable 186 inline LossTableList::iterator IsApplicable(
185 const G4ParticleDefiniti 187 const G4ParticleDefinition*, // Projectile (ion)
186 const G4Material*); 188 const G4Material*); // Target material
187 189
188 // Function printing a dE/dx table for a gi 190 // Function printing a dE/dx table for a given ion-material combination
189 // and a specified energy grid 191 // and a specified energy grid
190 void PrintDEDXTable( 192 void PrintDEDXTable(
191 const G4ParticleDefiniti 193 const G4ParticleDefinition*, // Projectile (ion)
192 const G4Material*, // Ab 194 const G4Material*, // Absorber material
193 G4double, // Mi 195 G4double, // Minimum energy per nucleon
194 G4double, // Ma 196 G4double, // Maximum energy per nucleon
195 G4int, // Nu 197 G4int, // Number of bins
196 G4bool); // Lo 198 G4bool); // Logarithmic scaling of energy
197 199
198 // Function printing a dE/dx table for a gi 200 // Function printing a dE/dx table for a given ion-material combination
199 // and a specified energy grid 201 // and a specified energy grid
200 void PrintDEDXTableHandlers( 202 void PrintDEDXTableHandlers(
201 const G4ParticleDefiniti 203 const G4ParticleDefinition*, // Projectile (ion)
202 const G4Material*, // Ab 204 const G4Material*, // Absorber material
203 G4double, // Mi 205 G4double, // Minimum energy per nucleon
204 G4double, // Ma 206 G4double, // Maximum energy per nucleon
205 G4int, // Nu 207 G4int, // Number of bins
206 G4bool); // Lo 208 G4bool); // Logarithmic scaling of energy
207 209
208 // Function for setting energy loss limit f 210 // Function for setting energy loss limit for stopping power integration
209 inline void SetEnergyLossLimit(G4double ion 211 inline void SetEnergyLossLimit(G4double ionEnergyLossLimit);
210 212
211 protected: 213 protected:
>> 214
>> 215 virtual
212 G4double MaxSecondaryEnergy(const G4Particl 216 G4double MaxSecondaryEnergy(const G4ParticleDefinition*,
213 G4double) override; // Kinetic << 217 G4double); // Kinetic energy of projectile
214 218
215 private: 219 private:
216 // Function which updates parameters concer 220 // Function which updates parameters concerning the dE/dx calculation
217 // (the parameters are only updated if the 221 // (the parameters are only updated if the particle, the material or
218 // the associated energy cut has changed) 222 // the associated energy cut has changed)
219 void UpdateDEDXCache( 223 void UpdateDEDXCache(
220 const G4ParticleDefinition*, 224 const G4ParticleDefinition*, // Projectile (ion)
221 const G4Material*, 225 const G4Material*, // Target material
222 G4double cutEnergy); 226 G4double cutEnergy); // Energy cut
223 227
224 // Function which updates parameters concer 228 // Function which updates parameters concerning the range calculation
225 // (the parameters are only updated if the 229 // (the parameters are only updated if the particle, the material or
226 // the associated energy cut has changed) 230 // the associated energy cut has changed)
227 void UpdateRangeCache( 231 void UpdateRangeCache(
228 const G4ParticleDefinition*, 232 const G4ParticleDefinition*, // Projectile (ion)
229 const G4MaterialCutsCouple*) 233 const G4MaterialCutsCouple*); // Target material
230 234
231 // Function, which updates parameters conce 235 // Function, which updates parameters concering particle properties
232 inline void UpdateCache( 236 inline void UpdateCache(
233 const G4ParticleDefinition*) 237 const G4ParticleDefinition*); // Projectile (ion)
234 238
235 // Function, which builds range vs energy ( 239 // Function, which builds range vs energy (and energy vs range) vectors
236 // for a given particle, material and energ 240 // for a given particle, material and energy cut
237 void BuildRangeVector( 241 void BuildRangeVector(
238 const G4ParticleDefinition*, 242 const G4ParticleDefinition*, // Projectile (ion)
239 const G4MaterialCutsCouple*) 243 const G4MaterialCutsCouple*); // Material cuts couple
240 244
241 // Assignment operator and copy constructor 245 // Assignment operator and copy constructor are hidden:
242 G4IonParametrisedLossModel & operator=( 246 G4IonParametrisedLossModel & operator=(
243 const G4IonParam 247 const G4IonParametrisedLossModel &right);
244 G4IonParametrisedLossModel(const G4IonParam 248 G4IonParametrisedLossModel(const G4IonParametrisedLossModel &);
245 249
246 // ######################################## 250 // ######################################################################
247 // # Models and dE/dx tables for computing 251 // # Models and dE/dx tables for computing the energy loss
248 // # 252 // #
249 // ######################################## 253 // ######################################################################
250 254
251 // G4BraggIonModel and G4BetheBlochModel ar 255 // G4BraggIonModel and G4BetheBlochModel are used for ion-target
252 // combinations and/or projectile energies 256 // combinations and/or projectile energies not covered by parametrisations
253 // adopted by this model: 257 // adopted by this model:
254 G4BraggIonModel* braggIonModel; 258 G4BraggIonModel* braggIonModel;
255 G4BetheBlochModel* betheBlochModel; 259 G4BetheBlochModel* betheBlochModel;
256 260
257 // List of dE/dx tables plugged into the mo 261 // List of dE/dx tables plugged into the model
258 LossTableList lossTableList; 262 LossTableList lossTableList;
259 263
260 // ######################################## 264 // ######################################################################
261 // # Maps of Range vs Energy and Energy vs 265 // # Maps of Range vs Energy and Energy vs Range vectors
262 // # 266 // #
263 // ######################################## 267 // ######################################################################
264 268
265 typedef std::map<IonMatCouple, G4PhysicsFre << 269 typedef std::map<IonMatCouple, G4LPhysicsFreeVector*> RangeEnergyTable;
266 RangeEnergyTable r; 270 RangeEnergyTable r;
267 271
268 typedef std::map<IonMatCouple, G4PhysicsFre << 272 typedef std::map<IonMatCouple, G4LPhysicsFreeVector*> EnergyRangeTable;
269 EnergyRangeTable E; 273 EnergyRangeTable E;
270 274
271 // ######################################## 275 // ######################################################################
272 // # Energy grid definitions (e.g. used for 276 // # Energy grid definitions (e.g. used for computing range-energy
273 // # tables) 277 // # tables)
274 // ######################################## 278 // ######################################################################
275 279
276 G4double lowerEnergyEdgeIntegr; 280 G4double lowerEnergyEdgeIntegr;
277 G4double upperEnergyEdgeIntegr; 281 G4double upperEnergyEdgeIntegr;
278 282
279 size_t nmbBins; 283 size_t nmbBins;
280 size_t nmbSubBins; 284 size_t nmbSubBins;
281 285
282 // ######################################## 286 // ######################################################################
283 // # Particle change for loss 287 // # Particle change for loss
284 // # 288 // #
285 // ######################################## 289 // ######################################################################
286 290
287 // Pointer to particle change object, which 291 // Pointer to particle change object, which is used to set e.g. the
288 // energy loss and secondary delta-electron 292 // energy loss and secondary delta-electron
289 // used indicating if model is initialized 293 // used indicating if model is initialized
290 G4ParticleChangeForLoss* particleChangeLoss 294 G4ParticleChangeForLoss* particleChangeLoss;
291 295
292 // ######################################## 296 // ######################################################################
293 // # Corrections and energy loss limit 297 // # Corrections and energy loss limit
294 // # 298 // #
295 // ######################################## 299 // ######################################################################
296 300
297 // Pointer to an G4EmCorrections object, wh 301 // Pointer to an G4EmCorrections object, which is used to compute the
298 // effective ion charge, and other correcti 302 // effective ion charge, and other corrections (like high order corrections
299 // to stopping powers) 303 // to stopping powers)
300 G4EmCorrections* corrections; 304 G4EmCorrections* corrections;
301 305
302 // Corrections factor for effective charge, 306 // Corrections factor for effective charge, computed for each particle
303 // step 307 // step
304 G4double corrFactor; 308 G4double corrFactor;
305 309
306 // Parameter indicating the maximal fractio 310 // Parameter indicating the maximal fraction of kinetic energy, which
307 // a particle may loose along a step, in or 311 // a particle may loose along a step, in order that the simple relation
308 // (dE/dx)*l can still be applied to comput 312 // (dE/dx)*l can still be applied to compute the energy loss (l = step
309 // length) 313 // length)
310 G4double energyLossLimit; 314 G4double energyLossLimit;
311 315
312 // ######################################## 316 // ######################################################################
313 // # Cut energies and properties of generic 317 // # Cut energies and properties of generic ion
314 // # 318 // #
315 // ######################################## 319 // ######################################################################
316 320
317 // Vector containing the current cut energi 321 // Vector containing the current cut energies (the vector index matches
318 // the material-cuts couple index): 322 // the material-cuts couple index):
319 G4DataVector cutEnergies; 323 G4DataVector cutEnergies;
320 324
321 // Pointer to generic ion and mass of gener 325 // Pointer to generic ion and mass of generic ion
322 const G4ParticleDefinition* genericIon; << 326 G4ParticleDefinition* genericIon;
323 G4double genericIonPDGMass; 327 G4double genericIonPDGMass;
324 328
325 // ######################################## 329 // ######################################################################
326 // # "Most-recently-used" cache parameters 330 // # "Most-recently-used" cache parameters
327 // # 331 // #
328 // ######################################## 332 // ######################################################################
329 333
330 // Cached key (particle) and value informat 334 // Cached key (particle) and value information for a faster
331 // access of particle-related information 335 // access of particle-related information
332 const G4ParticleDefinition* cacheParticle; 336 const G4ParticleDefinition* cacheParticle; // Key: Current projectile
333 G4double cacheMass; 337 G4double cacheMass; // Projectile mass
334 G4double cacheElecMassRatio; 338 G4double cacheElecMassRatio; // Electron-mass ratio
335 G4double cacheChargeSquare; 339 G4double cacheChargeSquare; // Charge squared
336 340
337 // Cached parameters needed during range co 341 // Cached parameters needed during range computations:
338 const G4ParticleDefinition* rangeCacheParti 342 const G4ParticleDefinition* rangeCacheParticle; // Key: 1) Current ion,
339 const G4MaterialCutsCouple* rangeCacheMatCu 343 const G4MaterialCutsCouple* rangeCacheMatCutsCouple; // 2) Mat-cuts-couple
340 G4PhysicsVector* rangeCacheEnergyRange; 344 G4PhysicsVector* rangeCacheEnergyRange; // Energy vs range vector
341 G4PhysicsVector* rangeCacheRangeEnergy; 345 G4PhysicsVector* rangeCacheRangeEnergy; // Range vs energy vector
342 346
343 // Cached parameters needed during dE/dx co 347 // Cached parameters needed during dE/dx computations:
344 const G4ParticleDefinition* dedxCachePartic 348 const G4ParticleDefinition* dedxCacheParticle; // Key: 1) Current ion,
345 const G4Material* dedxCacheMaterial; 349 const G4Material* dedxCacheMaterial; // 2) material and
346 G4double dedxCacheEnergyCut; 350 G4double dedxCacheEnergyCut; // 3) cut energy
347 LossTableList::iterator dedxCacheIter; 351 LossTableList::iterator dedxCacheIter; // Responsible dE/dx table
348 G4double dedxCacheTransitionEnergy; // 352 G4double dedxCacheTransitionEnergy; // Transition energy between
349 // 353 // parameterization and
350 // 354 // Bethe-Bloch model
351 G4double dedxCacheTransitionFactor; // 355 G4double dedxCacheTransitionFactor; // Factor for smoothing the dE/dx
352 // 356 // values in the transition region
353 G4double dedxCacheGenIonMassRatio; // 357 G4double dedxCacheGenIonMassRatio; // Ratio of generic ion mass
354 // 358 // and current particle mass
355 G4bool isInitialised; <<
356 }; 359 };
357 360
358 361
359 #include "G4IonParametrisedLossModel.icc" 362 #include "G4IonParametrisedLossModel.icc"
360 363
361 #endif 364 #endif
362 365