| 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 // 26 //
27 // ------------------------------------------- 27 // ------------------------------------------------------------
28 // G4hImpactIonisation 28 // G4hImpactIonisation
29 // 29 //
>> 30 // $Id: G4hImpactIonisation.hh,v 1.2 2010/11/19 17:16:09 pia Exp $
>> 31 // GEANT4 tag $Name: geant4-09-04 $
30 // 32 //
31 // Author: Maria Grazia Pia (MariaGrazia.Pia@g 33 // Author: Maria Grazia Pia (MariaGrazia.Pia@ge.infn.it)
32 // 34 //
33 // 08 Sep 2008 - MGP - Created (initially base 35 // 08 Sep 2008 - MGP - Created (initially based on G4hLowEnergyIonisation)
34 // Added PIXE capabilities 36 // Added PIXE capabilities
35 // Partial clean-up of the 37 // Partial clean-up of the implementation (more needed)
36 // Calculation of Microsco 38 // Calculation of MicroscopicCrossSection delegated to specialised class
37 // 39 //
38 // ------------------------------------------- 40 // ------------------------------------------------------------
39 41
40 // Class Description: 42 // Class Description:
41 // Impact Ionisation process of charged hadron 43 // Impact Ionisation process of charged hadrons and ions
42 // Initially based on G4hLowEnergyIonisation, 44 // Initially based on G4hLowEnergyIonisation, to be subject to redesign
43 // and further evolution of physics capabiliti 45 // and further evolution of physics capabilities
44 // 46 //
45 // The physics model of G4hLowEnergyIonisation 47 // The physics model of G4hLowEnergyIonisation is described in
46 // CERN-OPEN-99-121 and CERN-OPEN-99-300. 48 // CERN-OPEN-99-121 and CERN-OPEN-99-300.
47 // 49 //
48 // Documentation available in: 50 // Documentation available in:
49 // M.G. Pia et al., PIXE Simulation With Geant 51 // M.G. Pia et al., PIXE Simulation With Geant4,
50 // IEEE Trans. Nucl. Sci., vol. 56, no. 6, pp. 52 // IEEE Trans. Nucl. Sci., vol. 56, no. 6, pp. 3614-3649, Dec. 2009.
51 53
52 // ------------------------------------------- 54 // ------------------------------------------------------------
53 55
54 #ifndef G4HIMPACTIONISATION 56 #ifndef G4HIMPACTIONISATION
55 #define G4HIMPACTIONISATION 1 57 #define G4HIMPACTIONISATION 1
56 << 58
57 #include <map> <<
58 #include <CLHEP/Units/PhysicalConstants.h> <<
59 <<
60 #include "globals.hh" 59 #include "globals.hh"
61 #include "G4hRDEnergyLoss.hh" 60 #include "G4hRDEnergyLoss.hh"
62 #include "G4DataVector.hh" 61 #include "G4DataVector.hh"
63 #include "G4AtomicDeexcitation.hh" 62 #include "G4AtomicDeexcitation.hh"
64 #include "G4PixeCrossSectionHandler.hh" 63 #include "G4PixeCrossSectionHandler.hh"
65 64
>> 65 #include <map>
>> 66
66 class G4VLowEnergyModel; 67 class G4VLowEnergyModel;
67 class G4VParticleChange; 68 class G4VParticleChange;
68 class G4ParticleDefinition; 69 class G4ParticleDefinition;
69 class G4PhysicsTable; 70 class G4PhysicsTable;
70 class G4MaterialCutsCouple; 71 class G4MaterialCutsCouple;
71 class G4Track; 72 class G4Track;
72 class G4Step; 73 class G4Step;
73 74
74 class G4hImpactIonisation : public G4hRDEnergy 75 class G4hImpactIonisation : public G4hRDEnergyLoss
75 { 76 {
76 public: // With description 77 public: // With description
77 78
78 G4hImpactIonisation(const G4String& processN 79 G4hImpactIonisation(const G4String& processName = "hImpactIoni");
79 // The ionisation process for hadrons/ions t 80 // The ionisation process for hadrons/ions to be include in the
80 // UserPhysicsList 81 // UserPhysicsList
81 82
82 ~G4hImpactIonisation(); 83 ~G4hImpactIonisation();
83 // Destructor 84 // Destructor
84 85
85 G4bool IsApplicable(const G4ParticleDefiniti 86 G4bool IsApplicable(const G4ParticleDefinition&);
86 // True for all charged hadrons/ions 87 // True for all charged hadrons/ions
87 88
88 void BuildPhysicsTable(const G4ParticleDefin 89 void BuildPhysicsTable(const G4ParticleDefinition& aParticleType) ;
89 // Build physics table during initialisation 90 // Build physics table during initialisation
90 91
91 G4double GetMeanFreePath(const G4Track& trac 92 G4double GetMeanFreePath(const G4Track& track,
92 G4double previousStepSize, 93 G4double previousStepSize,
93 enum G4ForceCondition* condition ); 94 enum G4ForceCondition* condition );
94 // Return MeanFreePath until delta-electron 95 // Return MeanFreePath until delta-electron production
95 96
96 void PrintInfoDefinition() const; 97 void PrintInfoDefinition() const;
97 // Print out of the class parameters 98 // Print out of the class parameters
98 99
99 void SetHighEnergyForProtonParametrisation(G 100 void SetHighEnergyForProtonParametrisation(G4double energy) {protonHighEnergy = energy;} ;
100 // Definition of the boundary proton energy. 101 // Definition of the boundary proton energy. For higher energies
101 // Bethe-Bloch formula is used, for lower en 102 // Bethe-Bloch formula is used, for lower energies a parametrisation
102 // of the energy losses is performed. Defaul 103 // of the energy losses is performed. Default is 2 MeV.
103 104
104 void SetLowEnergyForProtonParametrisation(G4 105 void SetLowEnergyForProtonParametrisation(G4double energy) {protonLowEnergy = energy;} ;
105 // Set of the boundary proton energy. For lo 106 // Set of the boundary proton energy. For lower energies
106 // the Free Electron Gas model is used for t 107 // the Free Electron Gas model is used for the energy losses.
107 // Default is 1 keV. 108 // Default is 1 keV.
108 109
109 void SetHighEnergyForAntiProtonParametrisati 110 void SetHighEnergyForAntiProtonParametrisation(G4double energy) {antiprotonHighEnergy = energy;} ;
110 // Set of the boundary antiproton energy. Fo 111 // Set of the boundary antiproton energy. For higher energies
111 // Bethe-Bloch formula is used, for lower en 112 // Bethe-Bloch formula is used, for lower energies parametrisation
112 // of the energy losses is performed. Defaul 113 // of the energy losses is performed. Default is 2 MeV.
113 114
114 void SetLowEnergyForAntiProtonParametrisatio 115 void SetLowEnergyForAntiProtonParametrisation(G4double energy) {antiprotonLowEnergy = energy;} ;
115 // Set of the boundary antiproton energy. Fo 116 // Set of the boundary antiproton energy. For lower energies
116 // the Free Electron Gas model is used for t 117 // the Free Electron Gas model is used for the energy losses.
117 // Default is 1 keV. 118 // Default is 1 keV.
118 119
119 G4double GetContinuousStepLimit(const G4Trac 120 G4double GetContinuousStepLimit(const G4Track& track,
120 G4double previousStepSize, 121 G4double previousStepSize,
121 G4double currentMinimumStep, 122 G4double currentMinimumStep,
122 G4double& currentSafety); 123 G4double& currentSafety);
123 // Calculation of the step limit due to ioni 124 // Calculation of the step limit due to ionisation losses
124 125
125 void SetElectronicStoppingPowerModel(const G 126 void SetElectronicStoppingPowerModel(const G4ParticleDefinition* aParticle,
126 const G 127 const G4String& dedxTable);
127 // This method defines the electron ionisati 128 // This method defines the electron ionisation parametrisation method
128 // via the name of the table. Default is "IC 129 // via the name of the table. Default is "ICRU_49p".
129 130
130 void SetNuclearStoppingPowerModel(const G4St 131 void SetNuclearStoppingPowerModel(const G4String& dedxTable)
131 {theNuclearTable = dedxTable; SetNuclearStop 132 {theNuclearTable = dedxTable; SetNuclearStoppingOn();};
132 // This method defines the nuclear ionisatio 133 // This method defines the nuclear ionisation parametrisation method
133 // via the name of the table. Default is "IC 134 // via the name of the table. Default is "ICRU_49".
134 135
135 // ---- MGP ---- The following design of On/ 136 // ---- MGP ---- The following design of On/Off is nonsense; to be modified
136 // in a following design iteration 137 // in a following design iteration
137 138
138 void SetNuclearStoppingOn() {nStopping = tru 139 void SetNuclearStoppingOn() {nStopping = true;};
139 // This method switch on calculation of the 140 // This method switch on calculation of the nuclear stopping power.
140 141
141 void SetNuclearStoppingOff() {nStopping = fa 142 void SetNuclearStoppingOff() {nStopping = false;};
142 // This method switch off calculation of the 143 // This method switch off calculation of the nuclear stopping power.
143 144
144 void SetBarkasOn() {theBarkas = true;}; 145 void SetBarkasOn() {theBarkas = true;};
145 // This method switch on calculation of the 146 // This method switch on calculation of the Barkas and Bloch effects.
146 147
147 void SetBarkasOff() {theBarkas = false;}; 148 void SetBarkasOff() {theBarkas = false;};
148 // This method switch off calculation of the 149 // This method switch off calculation of the Barkas and Bloch effects.
149 150
150 void SetPixe(const G4bool /* val */ ) {pixeI 151 void SetPixe(const G4bool /* val */ ) {pixeIsActive = true;};
151 // This method switches atomic relaxation on 152 // This method switches atomic relaxation on/off; currently always on
152 153
153 G4VParticleChange* AlongStepDoIt(const G4Tra 154 G4VParticleChange* AlongStepDoIt(const G4Track& trackData ,
154 const G4Ste 155 const G4Step& stepData ) ;
155 // Function to determine total energy deposi 156 // Function to determine total energy deposition on the step
156 157
157 G4VParticleChange* PostStepDoIt(const G4Trac 158 G4VParticleChange* PostStepDoIt(const G4Track& track,
158 const G4Step& Step ) ; 159 const G4Step& Step ) ;
159 // Simulation of delta-ray production. 160 // Simulation of delta-ray production.
160 161
161 G4double ComputeDEDX(const G4ParticleDefinit 162 G4double ComputeDEDX(const G4ParticleDefinition* aParticle,
162 const G4MaterialCutsCou 163 const G4MaterialCutsCouple* couple,
163 G4double kineticEnergy); 164 G4double kineticEnergy);
164 // This method returns electronic dE/dx for 165 // This method returns electronic dE/dx for protons or antiproton
165 166
166 void SetCutForSecondaryPhotons(G4double cut) 167 void SetCutForSecondaryPhotons(G4double cut);
167 // Set threshold energy for fluorescence 168 // Set threshold energy for fluorescence
168 169
169 void SetCutForAugerElectrons(G4double cut); 170 void SetCutForAugerElectrons(G4double cut);
170 // Set threshold energy for Auger electron p 171 // Set threshold energy for Auger electron production
171 172
172 void ActivateAugerElectronProduction(G4bool 173 void ActivateAugerElectronProduction(G4bool val);
173 // Set Auger electron production flag on/off 174 // Set Auger electron production flag on/off
174 175
175 // Accessors to configure PIXE 176 // Accessors to configure PIXE
176 void SetPixeCrossSectionK(const G4String& na 177 void SetPixeCrossSectionK(const G4String& name) { modelK = name; }
177 void SetPixeCrossSectionL(const G4String& na 178 void SetPixeCrossSectionL(const G4String& name) { modelL = name; }
178 void SetPixeCrossSectionM(const G4String& na 179 void SetPixeCrossSectionM(const G4String& name) { modelM = name; }
179 void SetPixeProjectileMinEnergy(G4double ene 180 void SetPixeProjectileMinEnergy(G4double energy) { eMinPixe = energy; }
180 void SetPixeProjectileMaxEnergy(G4double ene 181 void SetPixeProjectileMaxEnergy(G4double energy) { eMaxPixe = energy; }
181 182
182 protected: 183 protected:
183 184
184 private: 185 private:
185 186
186 void InitializeMe(); 187 void InitializeMe();
187 void InitializeParametrisation(); 188 void InitializeParametrisation();
188 void BuildLossTable(const G4ParticleDefiniti 189 void BuildLossTable(const G4ParticleDefinition& aParticleType);
189 // void BuildDataForFluorescence(const G4Par 190 // void BuildDataForFluorescence(const G4ParticleDefinition& aParticleType);
190 void BuildLambdaTable(const G4ParticleDefini 191 void BuildLambdaTable(const G4ParticleDefinition& aParticleType);
191 void SetProtonElectronicStoppingPowerModel(c 192 void SetProtonElectronicStoppingPowerModel(const G4String& dedxTable)
192 {protonTable = dedxTable ;}; 193 {protonTable = dedxTable ;};
193 // This method defines the ionisation parame 194 // This method defines the ionisation parametrisation method via its name
194 195
195 void SetAntiProtonElectronicStoppingPowerMod 196 void SetAntiProtonElectronicStoppingPowerModel(const G4String& dedxTable)
196 {antiprotonTable = dedxTable;}; 197 {antiprotonTable = dedxTable;};
197 198
198 G4double MicroscopicCrossSection(const G4Par 199 G4double MicroscopicCrossSection(const G4ParticleDefinition& aParticleType,
199 G4double kineticEnergy, 200 G4double kineticEnergy,
200 G4double atomicNumber, 201 G4double atomicNumber,
201 G4double deltaCutInEnergy) const; 202 G4double deltaCutInEnergy) const;
202 203
203 G4double GetConstraints(const G4DynamicParti 204 G4double GetConstraints(const G4DynamicParticle* particle,
204 const G4MaterialCuts 205 const G4MaterialCutsCouple* couple);
205 // Function to determine StepLimit 206 // Function to determine StepLimit
206 207
207 G4double ProtonParametrisedDEDX(const G4Mate 208 G4double ProtonParametrisedDEDX(const G4MaterialCutsCouple* couple,
208 G4double kineticEnergy) const; 209 G4double kineticEnergy) const;
209 210
210 G4double AntiProtonParametrisedDEDX(const G4 211 G4double AntiProtonParametrisedDEDX(const G4MaterialCutsCouple* couple,
211 G4double kineticEnergy) const; 212 G4double kineticEnergy) const;
212 213
213 G4double DeltaRaysEnergy(const G4MaterialCut 214 G4double DeltaRaysEnergy(const G4MaterialCutsCouple* couple,
214 G4double kineticEnergy, 215 G4double kineticEnergy,
215 G4double particleMass) const; 216 G4double particleMass) const;
216 // This method returns average energy loss d 217 // This method returns average energy loss due to delta-rays emission with
217 // energy higher than the cut energy for giv 218 // energy higher than the cut energy for given material.
218 219
219 G4double BarkasTerm(const G4Material* materi 220 G4double BarkasTerm(const G4Material* material,
220 G4double kineticEnergy) const; 221 G4double kineticEnergy) const;
221 // Function to compute the Barkas term for p 222 // Function to compute the Barkas term for protons
222 223
223 G4double BlochTerm(const G4Material* materia 224 G4double BlochTerm(const G4Material* material,
224 G4double kineticEnergy, 225 G4double kineticEnergy,
225 G4double cSquare) const; 226 G4double cSquare) const;
226 // Function to compute the Bloch term for pr 227 // Function to compute the Bloch term for protons
227 228
228 G4double ElectronicLossFluctuation(const G4D 229 G4double ElectronicLossFluctuation(const G4DynamicParticle* particle,
229 const G4M 230 const G4MaterialCutsCouple* material,
230 G4double meanLoss, 231 G4double meanLoss,
231 G4double step) const; 232 G4double step) const;
232 // Function to sample electronic losses 233 // Function to sample electronic losses
233 234
234 // hide assignment operator 235 // hide assignment operator
235 G4hImpactIonisation & operator=(const G4hImp 236 G4hImpactIonisation & operator=(const G4hImpactIonisation &right);
236 G4hImpactIonisation(const G4hImpactIonisatio 237 G4hImpactIonisation(const G4hImpactIonisation&);
237 238
238 private: 239 private:
239 // private data members ................... 240 // private data members ...............................
240 G4VLowEnergyModel* betheBlochModel; 241 G4VLowEnergyModel* betheBlochModel;
241 G4VLowEnergyModel* protonModel; 242 G4VLowEnergyModel* protonModel;
242 G4VLowEnergyModel* antiprotonModel; 243 G4VLowEnergyModel* antiprotonModel;
243 G4VLowEnergyModel* theIonEffChargeModel; 244 G4VLowEnergyModel* theIonEffChargeModel;
244 G4VLowEnergyModel* theNuclearStoppingModel; 245 G4VLowEnergyModel* theNuclearStoppingModel;
245 G4VLowEnergyModel* theIonChuFluctuationModel 246 G4VLowEnergyModel* theIonChuFluctuationModel;
246 G4VLowEnergyModel* theIonYangFluctuationMode 247 G4VLowEnergyModel* theIonYangFluctuationModel;
247 248
248 // std::map<G4int,G4double,std::less<G4int> 249 // std::map<G4int,G4double,std::less<G4int> > totalCrossSectionMap;
249 250
250 // name of parametrisation table of electron 251 // name of parametrisation table of electron stopping power
251 G4String protonTable; 252 G4String protonTable;
252 G4String antiprotonTable; 253 G4String antiprotonTable;
253 G4String theNuclearTable; 254 G4String theNuclearTable;
254 255
255 // interval of parametrisation of electron s 256 // interval of parametrisation of electron stopping power
256 G4double protonLowEnergy; 257 G4double protonLowEnergy;
257 G4double protonHighEnergy; 258 G4double protonHighEnergy;
258 G4double antiprotonLowEnergy; 259 G4double antiprotonLowEnergy;
259 G4double antiprotonHighEnergy; 260 G4double antiprotonHighEnergy;
260 261
261 // flag of parametrisation of nucleus stoppi 262 // flag of parametrisation of nucleus stopping power
262 G4bool nStopping; 263 G4bool nStopping;
263 G4bool theBarkas; 264 G4bool theBarkas;
264 265
265 G4DataVector cutForDelta; 266 G4DataVector cutForDelta;
266 G4DataVector cutForGamma; 267 G4DataVector cutForGamma;
267 G4double minGammaEnergy; 268 G4double minGammaEnergy;
268 G4double minElectronEnergy; 269 G4double minElectronEnergy;
269 G4PhysicsTable* theMeanFreePathTable; 270 G4PhysicsTable* theMeanFreePathTable;
270 271
271 const G4double paramStepLimit; // parameter 272 const G4double paramStepLimit; // parameter limits the step at low energy
272 273
273 G4double fdEdx; // computed in GetCon 274 G4double fdEdx; // computed in GetContraints
274 G4double fRangeNow ; // 275 G4double fRangeNow ; //
275 G4double charge; // 276 G4double charge; //
276 G4double chargeSquare; // 277 G4double chargeSquare; //
277 G4double initialMass; // mass to calculate 278 G4double initialMass; // mass to calculate Lambda tables
278 G4double fBarkas; 279 G4double fBarkas;
279 280
280 G4PixeCrossSectionHandler* pixeCrossSectionH 281 G4PixeCrossSectionHandler* pixeCrossSectionHandler;
281 G4AtomicDeexcitation atomicDeexcitation; 282 G4AtomicDeexcitation atomicDeexcitation;
282 G4String modelK; 283 G4String modelK;
283 G4String modelL; 284 G4String modelL;
284 G4String modelM; 285 G4String modelM;
285 G4double eMinPixe; 286 G4double eMinPixe;
286 G4double eMaxPixe; 287 G4double eMaxPixe;
287 288
288 G4bool pixeIsActive; 289 G4bool pixeIsActive;
289 290
290 }; 291 };
291 292
292 293
293 inline G4double G4hImpactIonisation::GetContin 294 inline G4double G4hImpactIonisation::GetContinuousStepLimit(const G4Track& track,
294 G4double, 295 G4double,
295 G4double currentMinimumStep, 296 G4double currentMinimumStep,
296 G4double&) 297 G4double&)
297 { 298 {
298 G4double step = GetConstraints(track.GetDyna 299 G4double step = GetConstraints(track.GetDynamicParticle(),track.GetMaterialCutsCouple()) ;
299 300
300 // ---- MGP ---- The following line, taken a 301 // ---- MGP ---- The following line, taken as is from G4hLowEnergyIonisation,
301 // is meaningless: currentMinimumStep is pas 302 // is meaningless: currentMinimumStep is passed by value,
302 // therefore any local modification to it ha 303 // therefore any local modification to it has no effect
303 304
304 if ((step > 0.) && (step < currentMinimumSte 305 if ((step > 0.) && (step < currentMinimumStep)) currentMinimumStep = step ;
305 306
306 return step ; 307 return step ;
307 } 308 }
308 309
309 310
310 inline G4bool G4hImpactIonisation::IsApplicabl 311 inline G4bool G4hImpactIonisation::IsApplicable(const G4ParticleDefinition& particle)
311 { 312 {
312 // ---- MGP ---- Better criterion for applic 313 // ---- MGP ---- Better criterion for applicability to be defined;
313 // now hard-coded particle mass > 0.1 * prot 314 // now hard-coded particle mass > 0.1 * proton_mass
314 315
315 return (particle.GetPDGCharge() != 0.0 && pa << 316 return (particle.GetPDGCharge() != 0.0 && particle.GetPDGMass() > proton_mass_c2*0.1);
316 } 317 }
317 318
318 #endif 319 #endif
319 320
320 321
321 322
322 323
323 324
324 325
325 326
326 327
327 328