| 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: G4VEmProcess.hh 85011 2014-10-23 09:41:59Z gcosmo $
>> 27 //
26 // ------------------------------------------- 28 // -------------------------------------------------------------------
27 // 29 //
28 // GEANT4 Class header file 30 // GEANT4 Class header file
29 // 31 //
30 // 32 //
31 // File name: G4VEmProcess 33 // File name: G4VEmProcess
32 // 34 //
33 // Author: Vladimir Ivanchenko 35 // Author: Vladimir Ivanchenko
34 // 36 //
35 // Creation date: 01.10.2003 37 // Creation date: 01.10.2003
36 // 38 //
37 // Modifications: Vladimir Ivanchenko << 39 // Modifications:
>> 40 // 30-06-04 make destructor virtual (V.Ivanchenko)
>> 41 // 09-08-04 optimise integral option (V.Ivanchenko)
>> 42 // 11-08-04 add protected methods to access cuts (V.Ivanchenko)
>> 43 // 09-09-04 Bug fix for the integral mode with 2 peaks (V.Ivanchneko)
>> 44 // 16-09-04 Add flag for LambdaTable and method RecalculateLambda (VI)
>> 45 // 08-11-04 Migration to new interface of Store/Retrieve tables (V.Ivantchenko)
>> 46 // 08-04-05 Major optimisation of internal interfaces (V.Ivantchenko)
>> 47 // 18-04-05 Use G4ParticleChangeForGamma (V.Ivantchenko)
>> 48 // 09-05-05 Fix problem in logic when path boundary between materials (VI)
>> 49 // 11-01-06 add A to parameters of ComputeCrossSectionPerAtom (VI)
>> 50 // 01-02-06 put default value A=0. to keep compatibility with v5.2 (mma)
>> 51 // 13-05-06 Add method to access model by index (V.Ivanchenko)
>> 52 // 12-09-06 add SetModel() (mma)
>> 53 // 25-09-07 More accurate handling zero xsect in
>> 54 // PostStepGetPhysicalInteractionLength (V.Ivanchenko)
>> 55 // 27-10-07 Virtual functions moved to source (V.Ivanchenko)
>> 56 // 15-07-08 Reorder class members for further multi-thread development (VI)
>> 57 // 17-02-10 Added pointer currentParticle (VI)
38 // 58 //
39 // Class Description: 59 // Class Description:
40 // 60 //
41 // It is the base class - EM discrete and rest << 61 // It is the unified Discrete process
42 62
43 // ------------------------------------------- 63 // -------------------------------------------------------------------
44 // 64 //
45 65
46 #ifndef G4VEmProcess_h 66 #ifndef G4VEmProcess_h
47 #define G4VEmProcess_h 1 67 #define G4VEmProcess_h 1
48 68
49 #include <CLHEP/Units/SystemOfUnits.h> 69 #include <CLHEP/Units/SystemOfUnits.h>
50 70
51 #include "G4VDiscreteProcess.hh" 71 #include "G4VDiscreteProcess.hh"
52 #include "globals.hh" 72 #include "globals.hh"
53 #include "G4Material.hh" 73 #include "G4Material.hh"
54 #include "G4MaterialCutsCouple.hh" 74 #include "G4MaterialCutsCouple.hh"
55 #include "G4Track.hh" 75 #include "G4Track.hh"
>> 76 #include "G4EmModelManager.hh"
56 #include "G4UnitsTable.hh" 77 #include "G4UnitsTable.hh"
57 #include "G4ParticleDefinition.hh" 78 #include "G4ParticleDefinition.hh"
58 #include "G4ParticleChangeForGamma.hh" 79 #include "G4ParticleChangeForGamma.hh"
59 #include "G4EmParameters.hh" 80 #include "G4EmParameters.hh"
60 #include "G4EmDataHandler.hh" <<
61 #include "G4EmTableType.hh" <<
62 #include "G4EmModelManager.hh" <<
63 #include "G4EmSecondaryParticleType.hh" <<
64 81
65 class G4Step; 82 class G4Step;
66 class G4VEmModel; 83 class G4VEmModel;
67 class G4DataVector; 84 class G4DataVector;
68 class G4VParticleChange; 85 class G4VParticleChange;
69 class G4PhysicsTable; 86 class G4PhysicsTable;
70 class G4PhysicsVector; 87 class G4PhysicsVector;
71 class G4EmBiasingManager; 88 class G4EmBiasingManager;
72 class G4LossTableManager; 89 class G4LossTableManager;
73 90
74 //....oooOO0OOooo........oooOO0OOooo........oo 91 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
75 92
76 class G4VEmProcess : public G4VDiscreteProcess 93 class G4VEmProcess : public G4VDiscreteProcess
77 { 94 {
78 public: 95 public:
79 96
80 G4VEmProcess(const G4String& name, G4Process << 97 G4VEmProcess(const G4String& name,
>> 98 G4ProcessType type = fElectromagnetic);
81 99
82 ~G4VEmProcess() override; << 100 virtual ~G4VEmProcess();
83 101
84 //------------------------------------------ 102 //------------------------------------------------------------------------
85 // Virtual methods to be implemented in conc 103 // Virtual methods to be implemented in concrete processes
86 //------------------------------------------ 104 //------------------------------------------------------------------------
87 105
88 void ProcessDescription(std::ostream& outFil << 106 virtual G4bool IsApplicable(const G4ParticleDefinition& p) = 0;
89 107
90 protected: << 108 virtual void PrintInfo() = 0;
91 109
92 virtual void StreamProcessInfo(std::ostream& << 110 protected:
93 111
94 virtual void InitialiseProcess(const G4Parti 112 virtual void InitialiseProcess(const G4ParticleDefinition*) = 0;
95 113
96 //------------------------------------------ 114 //------------------------------------------------------------------------
>> 115 // Method with standard implementation; may be overwritten if needed
>> 116 //------------------------------------------------------------------------
>> 117
>> 118 virtual G4double MinPrimaryEnergy(const G4ParticleDefinition*,
>> 119 const G4Material*);
>> 120
>> 121 //------------------------------------------------------------------------
97 // Implementation of virtual methods common 122 // Implementation of virtual methods common to all Discrete processes
98 //------------------------------------------ 123 //------------------------------------------------------------------------
99 124
100 public: 125 public:
101 126
102 // Initialise for build of tables 127 // Initialise for build of tables
103 void PreparePhysicsTable(const G4ParticleDef << 128 void PreparePhysicsTable(const G4ParticleDefinition&);
104 129
105 // Build physics table during initialisation 130 // Build physics table during initialisation
106 void BuildPhysicsTable(const G4ParticleDefin << 131 void BuildPhysicsTable(const G4ParticleDefinition&);
107 132
108 // Called before tracking of each new G4Trac 133 // Called before tracking of each new G4Track
109 void StartTracking(G4Track*) override; << 134 void StartTracking(G4Track*);
110 135
111 // implementation of virtual method, specifi 136 // implementation of virtual method, specific for G4VEmProcess
112 G4double PostStepGetPhysicalInteractionLengt 137 G4double PostStepGetPhysicalInteractionLength(
113 const G4Track& tr 138 const G4Track& track,
114 G4double previo 139 G4double previousStepSize,
115 G4ForceCondition* << 140 G4ForceCondition* condition);
116 141
117 // implementation of virtual method, specifi 142 // implementation of virtual method, specific for G4VEmProcess
118 G4VParticleChange* PostStepDoIt(const G4Trac << 143 G4VParticleChange* PostStepDoIt(const G4Track&, const G4Step&);
119 144
120 // Store PhysicsTable in a file. 145 // Store PhysicsTable in a file.
121 // Return false in case of failure at I/O 146 // Return false in case of failure at I/O
122 G4bool StorePhysicsTable(const G4ParticleDef 147 G4bool StorePhysicsTable(const G4ParticleDefinition*,
123 const G4String& dir << 148 const G4String& directory,
124 G4bool ascii = fals << 149 G4bool ascii = false);
125 150
126 // Retrieve Physics from a file. 151 // Retrieve Physics from a file.
127 // (return true if the Physics Table can be 152 // (return true if the Physics Table can be build by using file)
128 // (return false if the process has no funct 153 // (return false if the process has no functionality or in case of failure)
129 // File name should is constructed as proces 154 // File name should is constructed as processName+particleName and the
130 // should be placed under the directory spec << 155 // should be placed under the directory specifed by the argument.
131 G4bool RetrievePhysicsTable(const G4Particle 156 G4bool RetrievePhysicsTable(const G4ParticleDefinition*,
132 const G4String& << 157 const G4String& directory,
133 G4bool ascii) ov << 158 G4bool ascii);
134 <<
135 // allowing check process name <<
136 virtual G4VEmProcess* GetEmProcess(const G4S <<
137 159
138 //------------------------------------------ 160 //------------------------------------------------------------------------
139 // Specific methods for Discrete EM post ste 161 // Specific methods for Discrete EM post step simulation
140 //------------------------------------------ 162 //------------------------------------------------------------------------
141 163
142 // The main method to access cross section p << 164 // It returns the cross section per volume for energy/ material
143 inline G4double GetLambda(G4double kinEnergy << 165 G4double CrossSectionPerVolume(G4double kineticEnergy,
144 const G4MaterialCu << 166 const G4MaterialCutsCouple* couple);
145 G4double logKinEne <<
146 <<
147 // It returns the cross section per volume f <<
148 G4double GetCrossSection(const G4double kinE <<
149 const G4MaterialCut <<
150 167
151 // It returns the cross section of the proce 168 // It returns the cross section of the process per atom
152 G4double ComputeCrossSectionPerAtom(G4double 169 G4double ComputeCrossSectionPerAtom(G4double kineticEnergy,
153 G4double << 170 G4double Z, G4double A=0.,
154 G4double << 171 G4double cut=0.0);
155 172
156 inline G4double MeanFreePath(const G4Track& << 173 G4double MeanFreePath(const G4Track& track);
>> 174
>> 175 // It returns cross section per volume
>> 176 inline G4double GetLambda(G4double& kinEnergy,
>> 177 const G4MaterialCutsCouple* couple);
157 178
158 //------------------------------------------ 179 //------------------------------------------------------------------------
159 // Specific methods to build and access Phys 180 // Specific methods to build and access Physics Tables
160 //------------------------------------------ 181 //------------------------------------------------------------------------
161 182
162 // Binning for lambda table 183 // Binning for lambda table
163 void SetLambdaBinning(G4int nbins); 184 void SetLambdaBinning(G4int nbins);
164 185
165 // Min kinetic energy for tables 186 // Min kinetic energy for tables
166 void SetMinKinEnergy(G4double e); 187 void SetMinKinEnergy(G4double e);
167 188
168 // Min kinetic energy for high energy table 189 // Min kinetic energy for high energy table
169 void SetMinKinEnergyPrim(G4double e); 190 void SetMinKinEnergyPrim(G4double e);
170 191
171 // Max kinetic energy for tables 192 // Max kinetic energy for tables
172 void SetMaxKinEnergy(G4double e); 193 void SetMaxKinEnergy(G4double e);
173 194
174 // Cross section table pointers 195 // Cross section table pointers
175 inline G4PhysicsTable* LambdaTable() const; 196 inline G4PhysicsTable* LambdaTable() const;
176 inline G4PhysicsTable* LambdaTablePrim() con 197 inline G4PhysicsTable* LambdaTablePrim() const;
177 inline void SetLambdaTable(G4PhysicsTable*); <<
178 inline void SetLambdaTablePrim(G4PhysicsTabl <<
179 <<
180 // Integral method type and peak positions <<
181 inline std::vector<G4double>* EnergyOfCrossS <<
182 inline void SetEnergyOfCrossSectionMax(std:: <<
183 inline G4CrossSectionType CrossSectionType() <<
184 inline void SetCrossSectionType(G4CrossSecti <<
185 198
186 //------------------------------------------ 199 //------------------------------------------------------------------------
187 // Define and access particle type 200 // Define and access particle type
188 //------------------------------------------ 201 //------------------------------------------------------------------------
189 202
190 inline const G4ParticleDefinition* Particle( 203 inline const G4ParticleDefinition* Particle() const;
191 inline const G4ParticleDefinition* Secondary 204 inline const G4ParticleDefinition* SecondaryParticle() const;
192 205
193 protected: <<
194 <<
195 //------------------------------------------ 206 //------------------------------------------------------------------------
196 // Specific methods to set, access, modify m 207 // Specific methods to set, access, modify models and basic parameters
197 //------------------------------------------ 208 //------------------------------------------------------------------------
198 << 209
>> 210 protected:
199 // Select model in run time 211 // Select model in run time
200 inline G4VEmModel* SelectModel(G4double kinE << 212 inline G4VEmModel* SelectModel(G4double& kinEnergy, size_t index);
201 213
202 public: 214 public:
203 << 215 // Select model by energy and region index
204 // Select model by energy and couple index <<
205 inline G4VEmModel* SelectModelForMaterial(G4 216 inline G4VEmModel* SelectModelForMaterial(G4double kinEnergy,
206 st << 217 size_t& idxRegion) const;
207 218
208 // Add model for region, smaller value of or 219 // Add model for region, smaller value of order defines which
209 // model will be selected for a given energy 220 // model will be selected for a given energy interval
210 void AddEmModel(G4int, G4VEmModel*, const G4 << 221 void AddEmModel(G4int, G4VEmModel*, const G4Region* region = 0);
211 222
212 // Assign a model to a process local list, t << 223 // return the assigned model
213 // the derived process should execute AddEmM << 224 G4VEmModel* EmModel(G4int index = 1) const;
214 void SetEmModel(G4VEmModel*, G4int index = 0 <<
215 225
216 inline G4int NumberOfModels() const; << 226 // Assign a model to a process
>> 227 void SetEmModel(G4VEmModel*, G4int index = 1);
217 228
218 // return a model from the local list << 229 // Define new energy range for the model identified by the name
219 inline G4VEmModel* EmModel(std::size_t index << 230 void UpdateEmModel(const G4String&, G4double, G4double);
220 <<
221 // Access to active model <<
222 inline const G4VEmModel* GetCurrentModel() c <<
223 231
224 // Access to models 232 // Access to models
225 inline G4VEmModel* GetModelByIndex(G4int idx << 233 G4VEmModel* GetModelByIndex(G4int idx = 0, G4bool ver = false) const;
226 234
227 // Access to the current G4Element << 235 // access atom on which interaction happens
228 const G4Element* GetCurrentElement() const; 236 const G4Element* GetCurrentElement() const;
229 237
230 // Biasing parameters 238 // Biasing parameters
231 void SetCrossSectionBiasingFactor(G4double f 239 void SetCrossSectionBiasingFactor(G4double f, G4bool flag = true);
232 inline G4double CrossSectionBiasingFactor() 240 inline G4double CrossSectionBiasingFactor() const;
233 241
234 // Activate forced interaction 242 // Activate forced interaction
235 void ActivateForcedInteraction(G4double leng 243 void ActivateForcedInteraction(G4double length = 0.0,
236 const G4Strin << 244 const G4String& r = "",
237 G4bool flag = << 245 G4bool flag = true);
238 246
239 void ActivateSecondaryBiasing(const G4String 247 void ActivateSecondaryBiasing(const G4String& region, G4double factor,
240 G4double energ << 248 G4double energyLimit);
241 << 249
242 inline void SetEmMasterProcess(const G4VEmPr << 250 inline void SetIntegral(G4bool val);
243 251
244 inline void SetBuildTableFlag(G4bool val); 252 inline void SetBuildTableFlag(G4bool val);
245 253
246 inline void CurrentSetup(const G4MaterialCut <<
247 <<
248 inline G4bool UseBaseMaterial() const; <<
249 <<
250 void BuildLambdaTable(); <<
251 <<
252 void StreamInfo(std::ostream& outFile, const <<
253 G4bool rst=false) const; <<
254 <<
255 // hide copy constructor and assignment oper <<
256 G4VEmProcess(G4VEmProcess &) = delete; <<
257 G4VEmProcess & operator=(const G4VEmProcess <<
258 <<
259 //------------------------------------------ 254 //------------------------------------------------------------------------
260 // Other generic methods 255 // Other generic methods
261 //------------------------------------------ 256 //------------------------------------------------------------------------
262 257
263 protected: 258 protected:
264 259
265 G4double GetMeanFreePath(const G4Track& trac 260 G4double GetMeanFreePath(const G4Track& track,
266 G4double previousSt << 261 G4double previousStepSize,
267 G4ForceCondition* c << 262 G4ForceCondition* condition);
268 263
269 G4PhysicsVector* LambdaPhysicsVector(const G 264 G4PhysicsVector* LambdaPhysicsVector(const G4MaterialCutsCouple*);
270 265
271 inline void DefineMaterial(const G4MaterialC <<
272 <<
273 inline G4int LambdaBinning() const; 266 inline G4int LambdaBinning() const;
274 267
275 inline G4double MinKinEnergy() const; 268 inline G4double MinKinEnergy() const;
276 269
277 inline G4double MaxKinEnergy() const; 270 inline G4double MaxKinEnergy() const;
278 271
279 // Single scattering parameters 272 // Single scattering parameters
280 inline G4double PolarAngleLimit() const; 273 inline G4double PolarAngleLimit() const;
281 274
>> 275 inline G4bool IsIntegral() const;
>> 276
>> 277 inline G4double RecalculateLambda(G4double kinEnergy,
>> 278 const G4MaterialCutsCouple* couple);
>> 279
282 inline G4ParticleChangeForGamma* GetParticle 280 inline G4ParticleChangeForGamma* GetParticleChange();
283 281
284 inline void SetParticle(const G4ParticleDefi 282 inline void SetParticle(const G4ParticleDefinition* p);
285 283
286 inline void SetSecondaryParticle(const G4Par 284 inline void SetSecondaryParticle(const G4ParticleDefinition* p);
287 285
288 inline std::size_t CurrentMaterialCutsCouple << 286 inline size_t CurrentMaterialCutsCoupleIndex() const;
289 <<
290 inline const G4MaterialCutsCouple* MaterialC <<
291 <<
292 inline G4bool ApplyCuts() const; <<
293 287
294 inline G4double GetGammaEnergyCut(); 288 inline G4double GetGammaEnergyCut();
295 289
296 inline G4double GetElectronEnergyCut(); 290 inline G4double GetElectronEnergyCut();
297 291
298 inline void SetStartFromNullFlag(G4bool val) 292 inline void SetStartFromNullFlag(G4bool val);
299 293
300 inline void SetSplineFlag(G4bool val); 294 inline void SetSplineFlag(G4bool val);
301 295
302 const G4Element* GetTargetElement() const; << 296 inline const G4Element* GetTargetElement() const;
303 <<
304 const G4Isotope* GetTargetIsotope() const; <<
305 297
306 // these two methods assume that vectors are << 298 inline const G4Isotope* GetTargetIsotope() const;
307 // and idx is within vector length <<
308 inline G4int DensityIndex(G4int idx) const; <<
309 inline G4double DensityFactor(G4int idx) con <<
310 299
311 private: 300 private:
312 301
>> 302 void Clear();
>> 303
>> 304 void BuildLambdaTable();
>> 305
>> 306 void PrintInfoProcess(const G4ParticleDefinition&);
>> 307
>> 308 void FindLambdaMax();
>> 309
313 void PrintWarning(G4String tit, G4double val 310 void PrintWarning(G4String tit, G4double val);
314 311
315 void ComputeIntegralLambda(G4double kinEnerg << 312 inline void DefineMaterial(const G4MaterialCutsCouple* couple);
316 313
317 inline G4double LogEkin(const G4Track&); << 314 inline void ComputeIntegralLambda(G4double kinEnergy);
318 315
319 inline G4double GetLambdaFromTable(G4double 316 inline G4double GetLambdaFromTable(G4double kinEnergy);
320 317
321 inline G4double GetLambdaFromTable(G4double <<
322 <<
323 inline G4double GetLambdaFromTablePrim(G4dou 318 inline G4double GetLambdaFromTablePrim(G4double kinEnergy);
324 319
325 inline G4double GetLambdaFromTablePrim(G4dou <<
326 <<
327 inline G4double GetCurrentLambda(G4double ki 320 inline G4double GetCurrentLambda(G4double kinEnergy);
328 321
329 inline G4double GetCurrentLambda(G4double ki <<
330 <<
331 inline G4double ComputeCurrentLambda(G4doubl 322 inline G4double ComputeCurrentLambda(G4double kinEnergy);
332 323
333 // ======== pointers ========= << 324 // copy constructor and hide assignment operator
334 << 325 G4VEmProcess(G4VEmProcess &);
335 G4EmModelManager* modelManager = << 326 G4VEmProcess & operator=(const G4VEmProcess &right);
336 const G4ParticleDefinition* particle = null << 327
337 const G4ParticleDefinition* currentParticle << 328 // ======== Parameters of the class fixed at construction =========
338 const G4ParticleDefinition* theGamma = null << 329
339 const G4ParticleDefinition* theElectron = n << 330 G4LossTableManager* lManager;
340 const G4ParticleDefinition* thePositron = n << 331 G4EmParameters* theParameters;
341 const G4ParticleDefinition* secondaryPartic << 332 G4EmModelManager* modelManager;
342 const G4VEmProcess* masterProc = nu << 333 G4EmBiasingManager* biasManager;
343 G4EmDataHandler* theData = nullp << 334 const G4ParticleDefinition* theGamma;
344 G4VEmModel* currentModel = << 335 const G4ParticleDefinition* theElectron;
345 G4LossTableManager* lManager = null << 336 const G4ParticleDefinition* thePositron;
346 G4EmParameters* theParameters = << 337 const G4ParticleDefinition* secondaryParticle;
347 const G4Material* baseMaterial = << 338
348 << 339 G4bool buildLambdaTable;
349 // ======== tables and vectors ======== << 340
350 G4PhysicsTable* theLambdaTable << 341 // ======== Parameters of the class fixed at initialisation =======
351 G4PhysicsTable* theLambdaTableP << 342
352 << 343 std::vector<G4VEmModel*> emModels;
353 const std::vector<G4double>* theCuts = nullp << 344 G4int numberOfModels;
354 const std::vector<G4double>* theCutsGamma = << 345
355 const std::vector<G4double>* theCutsElectron << 346 // tables and vectors
356 const std::vector<G4double>* theCutsPositron << 347 G4PhysicsTable* theLambdaTable;
357 << 348 G4PhysicsTable* theLambdaTablePrim;
358 protected: << 349 std::vector<G4double> theEnergyOfCrossSectionMax;
359 << 350 std::vector<G4double> theCrossSectionMax;
360 // ======== pointers ========= << 351
361 << 352 size_t idxLambda;
362 const G4MaterialCutsCouple* currentCouple = << 353 size_t idxLambdaPrim;
363 const G4Material* currentMaterial << 354
364 G4EmBiasingManager* biasManager = n << 355 const std::vector<G4double>* theCuts;
365 std::vector<G4double>* theEnergyOfCros << 356 const std::vector<G4double>* theCutsGamma;
366 << 357 const std::vector<G4double>* theCutsElectron;
367 private: << 358 const std::vector<G4double>* theCutsPositron;
368 << 359 const std::vector<G4double>* theDensityFactor;
369 const std::vector<G4double>* theDensityFacto << 360 const std::vector<G4int>* theDensityIdx;
370 const std::vector<G4int>* theDensityIdx = nu << 361
371 << 362 G4int nLambdaBins;
372 // ======== parameters ========= << 363
373 G4double minKinEnergy; << 364 G4double minKinEnergy;
374 G4double maxKinEnergy; << 365 G4double minKinEnergyPrim;
375 G4double minKinEnergyPrim = DBL_MAX; << 366 G4double maxKinEnergy;
376 G4double lambdaFactor = 0.8; << 367 G4double lambdaFactor;
377 G4double invLambdaFactor; << 368 G4double biasFactor;
378 G4double biasFactor = 1.0; << 369
379 G4double massRatio = 1.0; << 370 G4bool integral;
380 G4double fFactor = 1.0; << 371 G4bool applyCuts;
381 G4double fLambda = 0.0; << 372 G4bool startFromNull;
382 G4double fLambdaEnergy = 0.0; << 373 G4bool splineFlag;
383 << 374 G4bool actMinKinEnergy;
384 protected: << 375 G4bool actMaxKinEnergy;
385 << 376 G4bool actBinning;
386 G4double mfpKinEnergy = DBL_MAX; << 377 G4bool actSpline;
387 G4double preStepKinEnergy = 0.0; <<
388 G4double preStepLambda = 0.0; <<
389 378
390 private: << 379 // ======== Cashed values - may be state dependent ================
391 <<
392 G4CrossSectionType fXSType = fEmNoIntegral; <<
393 <<
394 G4int numberOfModels = 0; <<
395 G4int nLambdaBins = 84; <<
396 380
397 protected: 381 protected:
398 382
399 G4int mainSecondaries = 1; << 383 G4ParticleChangeForGamma fParticleChange;
400 G4int secID = _EM; <<
401 G4int fluoID = _Fluorescence; <<
402 G4int augerID = _AugerElectron; <<
403 G4int biasID = _EM; <<
404 G4int tripletID = _TripletElectron; <<
405 std::size_t currentCoupleIndex = 0; <<
406 std::size_t basedCoupleIndex = 0; <<
407 std::size_t coupleIdxLambda = 0; <<
408 std::size_t idxLambda = 0; <<
409 <<
410 G4bool isTheMaster = false; <<
411 G4bool baseMat = false; <<
412 384
413 private: 385 private:
414 386
415 G4bool buildLambdaTable = true; <<
416 G4bool applyCuts = false; <<
417 G4bool startFromNull = false; <<
418 G4bool splineFlag = true; <<
419 G4bool actMinKinEnergy = false; <<
420 G4bool actMaxKinEnergy = false; <<
421 G4bool actBinning = false; <<
422 G4bool isIon = false; <<
423 G4bool biasFlag = false; <<
424 G4bool weightFlag = false; <<
425 <<
426 protected: <<
427 <<
428 // ======== particle change ========= <<
429 std::vector<G4DynamicParticle*> secParticles 387 std::vector<G4DynamicParticle*> secParticles;
430 G4ParticleChangeForGamma fParticleChange; <<
431 388
432 private: << 389 G4VEmModel* currentModel;
433 390
434 // ======== local vectors ========= << 391 const G4ParticleDefinition* particle;
435 std::vector<G4VEmModel*> emModels; << 392 const G4ParticleDefinition* currentParticle;
436 393
>> 394 // cash
>> 395 const G4Material* baseMaterial;
>> 396 const G4Material* currentMaterial;
>> 397 const G4MaterialCutsCouple* currentCouple;
>> 398 size_t currentCoupleIndex;
>> 399 size_t basedCoupleIndex;
>> 400
>> 401 G4double mfpKinEnergy;
>> 402 G4double preStepKinEnergy;
>> 403 G4double preStepLambda;
>> 404 G4double fFactor;
>> 405 G4bool biasFlag;
>> 406 G4bool weightFlag;
>> 407
>> 408 G4int mainSecondaries;
>> 409 G4int secID;
>> 410 G4int fluoID;
>> 411 G4int augerID;
>> 412 G4int biasID;
437 }; 413 };
438 414
439 // ======== Run time inline methods ========== 415 // ======== Run time inline methods ================
440 416
441 //....oooOO0OOooo........oooOO0OOooo........oo << 417 inline size_t G4VEmProcess::CurrentMaterialCutsCoupleIndex() const
442 <<
443 inline std::size_t G4VEmProcess::CurrentMateri <<
444 { 418 {
445 return currentCoupleIndex; 419 return currentCoupleIndex;
446 } 420 }
447 421
448 //....oooOO0OOooo........oooOO0OOooo........oo 422 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
449 423
450 inline const G4MaterialCutsCouple* G4VEmProces <<
451 { <<
452 return currentCouple; <<
453 } <<
454 <<
455 //....oooOO0OOooo........oooOO0OOooo........oo <<
456 <<
457 inline G4double G4VEmProcess::GetGammaEnergyCu 424 inline G4double G4VEmProcess::GetGammaEnergyCut()
458 { 425 {
459 return (*theCutsGamma)[currentCoupleIndex]; 426 return (*theCutsGamma)[currentCoupleIndex];
460 } 427 }
461 428
462 //....oooOO0OOooo........oooOO0OOooo........oo 429 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
463 430
464 inline G4double G4VEmProcess::GetElectronEnerg 431 inline G4double G4VEmProcess::GetElectronEnergyCut()
465 { 432 {
466 return (*theCutsElectron)[currentCoupleIndex 433 return (*theCutsElectron)[currentCoupleIndex];
467 } 434 }
468 435
469 //....oooOO0OOooo........oooOO0OOooo........oo 436 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
470 437
471 inline void G4VEmProcess::DefineMaterial(const 438 inline void G4VEmProcess::DefineMaterial(const G4MaterialCutsCouple* couple)
472 { 439 {
473 if (couple != currentCouple) { << 440 if(couple != currentCouple) {
474 currentCouple = couple; << 441 currentCouple = couple;
475 baseMaterial = currentMaterial = couple->G << 442 currentMaterial = couple->GetMaterial();
476 basedCoupleIndex = currentCoupleIndex = co << 443 baseMaterial = currentMaterial->GetBaseMaterial();
477 fFactor = biasFactor; << 444 currentCoupleIndex = couple->GetIndex();
>> 445 basedCoupleIndex = (*theDensityIdx)[currentCoupleIndex];
>> 446 fFactor = biasFactor*(*theDensityFactor)[currentCoupleIndex];
>> 447 if(!baseMaterial) { baseMaterial = currentMaterial; }
478 mfpKinEnergy = DBL_MAX; 448 mfpKinEnergy = DBL_MAX;
479 if (baseMat) { << 449 idxLambda = idxLambdaPrim = 0;
480 basedCoupleIndex = (*theDensityIdx)[curr <<
481 if (nullptr != currentMaterial->GetBaseM <<
482 baseMaterial = currentMaterial->GetBas <<
483 fFactor *= (*theDensityFactor)[currentCo <<
484 } <<
485 } 450 }
486 } 451 }
487 452
488 //....oooOO0OOooo........oooOO0OOooo........oo 453 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
489 454
490 inline 455 inline
491 G4VEmModel* G4VEmProcess::SelectModel(G4double << 456 G4VEmModel* G4VEmProcess::SelectModel(G4double& kinEnergy, size_t index)
492 { 457 {
493 if(1 < numberOfModels) { 458 if(1 < numberOfModels) {
494 currentModel = modelManager->SelectModel(k << 459 currentModel = modelManager->SelectModel(kinEnergy, index);
495 } 460 }
496 currentModel->SetCurrentCouple(currentCouple 461 currentModel->SetCurrentCouple(currentCouple);
497 return currentModel; 462 return currentModel;
498 } 463 }
499 464
500 //....oooOO0OOooo........oooOO0OOooo........oo 465 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
501 466
502 inline 467 inline
503 G4VEmModel* G4VEmProcess::SelectModelForMateri 468 G4VEmModel* G4VEmProcess::SelectModelForMaterial(G4double kinEnergy,
504 << 469 size_t& idxRegion) const
505 { 470 {
506 return modelManager->SelectModel(kinEnergy, << 471 return modelManager->SelectModel(kinEnergy, idxRegion);
507 } 472 }
508 473
509 //....oooOO0OOooo........oooOO0OOooo........oo 474 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
510 475
511 inline G4double G4VEmProcess::GetLambdaFromTab 476 inline G4double G4VEmProcess::GetLambdaFromTable(G4double e)
512 { 477 {
513 return ((*theLambdaTable)[basedCoupleIndex]) 478 return ((*theLambdaTable)[basedCoupleIndex])->Value(e, idxLambda);
514 } 479 }
515 480
516 //....oooOO0OOooo........oooOO0OOooo........oo 481 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
517 482
518 inline G4double G4VEmProcess::LogEkin(const G4 <<
519 { <<
520 return track.GetDynamicParticle()->GetLogKin <<
521 } <<
522 <<
523 //....oooOO0OOooo........oooOO0OOooo........oo <<
524 <<
525 inline G4double G4VEmProcess::GetLambdaFromTab <<
526 { <<
527 return ((*theLambdaTable)[basedCoupleIndex]) <<
528 } <<
529 <<
530 //....oooOO0OOooo........oooOO0OOooo........oo <<
531 <<
532 inline G4double G4VEmProcess::GetLambdaFromTab 483 inline G4double G4VEmProcess::GetLambdaFromTablePrim(G4double e)
533 { 484 {
534 return ((*theLambdaTablePrim)[basedCoupleInd << 485 return ((*theLambdaTablePrim)[basedCoupleIndex])->Value(e, idxLambdaPrim)/e;
535 } <<
536 <<
537 //....oooOO0OOooo........oooOO0OOooo........oo <<
538 <<
539 inline G4double G4VEmProcess::GetLambdaFromTab <<
540 { <<
541 return ((*theLambdaTablePrim)[basedCoupleInd <<
542 } 486 }
543 487
544 //....oooOO0OOooo........oooOO0OOooo........oo 488 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
545 489
546 inline G4double G4VEmProcess::ComputeCurrentLa 490 inline G4double G4VEmProcess::ComputeCurrentLambda(G4double e)
547 { 491 {
548 return currentModel->CrossSectionPerVolume(b << 492 return currentModel->CrossSectionPerVolume(
>> 493 baseMaterial,currentParticle, e,(*theCuts)[currentCoupleIndex]);
549 } 494 }
550 495
551 //....oooOO0OOooo........oooOO0OOooo........oo 496 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
552 497
553 inline G4double G4VEmProcess::GetCurrentLambda 498 inline G4double G4VEmProcess::GetCurrentLambda(G4double e)
554 { 499 {
555 if(currentCoupleIndex != coupleIdxLambda || << 500 G4double x;
556 coupleIdxLambda = currentCoupleIndex; << 501 if(e >= minKinEnergyPrim) { x = GetLambdaFromTablePrim(e); }
557 fLambdaEnergy = e; << 502 else if(theLambdaTable) { x = GetLambdaFromTable(e); }
558 if(e >= minKinEnergyPrim) { fLambda = GetL << 503 else { x = ComputeCurrentLambda(e); }
559 else if(nullptr != theLambdaTable) { fLamb << 504 return fFactor*x;
560 else { fLambda = ComputeCurrentLambda(e); <<
561 fLambda *= fFactor; <<
562 } <<
563 return fLambda; <<
564 } <<
565 <<
566 //....oooOO0OOooo........oooOO0OOooo........oo <<
567 <<
568 inline G4double G4VEmProcess::GetCurrentLambda <<
569 { <<
570 if(currentCoupleIndex != coupleIdxLambda || <<
571 coupleIdxLambda = currentCoupleIndex; <<
572 fLambdaEnergy = e; <<
573 if(e >= minKinEnergyPrim) { fLambda = GetL <<
574 else if(nullptr != theLambdaTable) { fLamb <<
575 else { fLambda = ComputeCurrentLambda(e); <<
576 fLambda *= fFactor; <<
577 } <<
578 return fLambda; <<
579 } 505 }
580 506
581 //....oooOO0OOooo........oooOO0OOooo........oo 507 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
582 508
583 inline void << 509 inline G4double
584 G4VEmProcess::CurrentSetup(const G4MaterialCut << 510 G4VEmProcess::GetLambda(G4double& kinEnergy,
>> 511 const G4MaterialCutsCouple* couple)
585 { 512 {
586 DefineMaterial(couple); 513 DefineMaterial(couple);
587 SelectModel(energy*massRatio, currentCoupleI << 514 SelectModel(kinEnergy, currentCoupleIndex);
>> 515 return GetCurrentLambda(kinEnergy);
588 } 516 }
589 517
590 //....oooOO0OOooo........oooOO0OOooo........oo 518 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
591 519
592 inline G4double 520 inline G4double
593 G4VEmProcess::GetLambda(G4double kinEnergy, co << 521 G4VEmProcess::RecalculateLambda(G4double e, const G4MaterialCutsCouple* couple)
594 G4double logKinEnergy) <<
595 { 522 {
596 CurrentSetup(couple, kinEnergy); << 523 DefineMaterial(couple);
597 return GetCurrentLambda(kinEnergy, logKinEne << 524 SelectModel(e, currentCoupleIndex);
>> 525 return fFactor*ComputeCurrentLambda(e);
598 } 526 }
599 527
600 //....oooOO0OOooo........oooOO0OOooo........oo 528 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
601 529
602 G4double G4VEmProcess::MeanFreePath(const G4Tr << 530 inline void G4VEmProcess::ComputeIntegralLambda(G4double e)
603 { 531 {
604 const G4double kinEnergy = track.GetKineticE << 532 mfpKinEnergy = theEnergyOfCrossSectionMax[currentCoupleIndex];
605 CurrentSetup(track.GetMaterialCutsCouple(), << 533 if (e <= mfpKinEnergy) {
606 const G4double xs = GetCurrentLambda(kinEner << 534 preStepLambda = GetCurrentLambda(e);
607 track.GetDynamicP << 535
608 return (0.0 < xs) ? 1.0/xs : DBL_MAX; << 536 } else {
>> 537 G4double e1 = e*lambdaFactor;
>> 538 if(e1 > mfpKinEnergy) {
>> 539 preStepLambda = GetCurrentLambda(e);
>> 540 G4double preStepLambda1 = GetCurrentLambda(e1);
>> 541 if(preStepLambda1 > preStepLambda) {
>> 542 mfpKinEnergy = e1;
>> 543 preStepLambda = preStepLambda1;
>> 544 }
>> 545 } else {
>> 546 preStepLambda = fFactor*theCrossSectionMax[currentCoupleIndex];
>> 547 }
>> 548 }
609 } 549 }
610 550
611 // ======== Get/Set inline methods used at ini 551 // ======== Get/Set inline methods used at initialisation ================
612 552
613 inline G4bool G4VEmProcess::ApplyCuts() const <<
614 { <<
615 return applyCuts; <<
616 } <<
617 <<
618 //....oooOO0OOooo........oooOO0OOooo........oo 553 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
619 554
620 inline G4int G4VEmProcess::LambdaBinning() con 555 inline G4int G4VEmProcess::LambdaBinning() const
621 { 556 {
622 return nLambdaBins; 557 return nLambdaBins;
623 } 558 }
624 559
625 //....oooOO0OOooo........oooOO0OOooo........oo 560 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
626 561
627 inline G4double G4VEmProcess::MinKinEnergy() c 562 inline G4double G4VEmProcess::MinKinEnergy() const
628 { 563 {
629 return minKinEnergy; 564 return minKinEnergy;
630 } 565 }
631 566
632 //....oooOO0OOooo........oooOO0OOooo........oo 567 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
633 568
634 inline G4double G4VEmProcess::MaxKinEnergy() c 569 inline G4double G4VEmProcess::MaxKinEnergy() const
635 { 570 {
636 return maxKinEnergy; 571 return maxKinEnergy;
637 } 572 }
638 573
639 //....oooOO0OOooo........oooOO0OOooo........oo 574 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
640 575
>> 576 inline G4double G4VEmProcess::PolarAngleLimit() const
>> 577 {
>> 578 return theParameters->MscThetaLimit();
>> 579 }
>> 580
>> 581 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 582
641 inline G4double G4VEmProcess::CrossSectionBias 583 inline G4double G4VEmProcess::CrossSectionBiasingFactor() const
642 { 584 {
643 return biasFactor; 585 return biasFactor;
644 } 586 }
645 587
646 //....oooOO0OOooo........oooOO0OOooo........oo 588 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
647 589
648 inline G4PhysicsTable* G4VEmProcess::LambdaTab 590 inline G4PhysicsTable* G4VEmProcess::LambdaTable() const
649 { 591 {
650 return theLambdaTable; 592 return theLambdaTable;
651 } 593 }
652 594
653 //....oooOO0OOooo........oooOO0OOooo........oo 595 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
654 596
655 inline G4PhysicsTable* G4VEmProcess::LambdaTab 597 inline G4PhysicsTable* G4VEmProcess::LambdaTablePrim() const
656 { 598 {
657 return theLambdaTablePrim; 599 return theLambdaTablePrim;
658 } 600 }
659 601
660 //....oooOO0OOooo........oooOO0OOooo........oo 602 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
661 603
662 inline void G4VEmProcess::SetLambdaTable(G4Phy <<
663 { <<
664 theLambdaTable = ptr; <<
665 } <<
666 <<
667 //....oooOO0OOooo........oooOO0OOooo........oo <<
668 <<
669 inline void G4VEmProcess::SetLambdaTablePrim(G <<
670 { <<
671 theLambdaTablePrim = ptr; <<
672 } <<
673 <<
674 //....oooOO0OOooo........oooOO0OOooo........oo <<
675 <<
676 inline std::vector<G4double>* G4VEmProcess::En <<
677 { <<
678 return theEnergyOfCrossSectionMax; <<
679 } <<
680 <<
681 //....oooOO0OOooo........oooOO0OOooo........oo <<
682 <<
683 inline void <<
684 G4VEmProcess::SetEnergyOfCrossSectionMax(std:: <<
685 { <<
686 theEnergyOfCrossSectionMax = ptr; <<
687 } <<
688 <<
689 //....oooOO0OOooo........oooOO0OOooo........oo <<
690 <<
691 inline const G4ParticleDefinition* G4VEmProces 604 inline const G4ParticleDefinition* G4VEmProcess::Particle() const
692 { 605 {
693 return particle; 606 return particle;
694 } 607 }
695 608
696 //....oooOO0OOooo........oooOO0OOooo........oo 609 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
697 610
698 inline const G4ParticleDefinition* G4VEmProces 611 inline const G4ParticleDefinition* G4VEmProcess::SecondaryParticle() const
699 { 612 {
700 return secondaryParticle; 613 return secondaryParticle;
701 } 614 }
702 615
703 //....oooOO0OOooo........oooOO0OOooo........oo 616 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
704 617
705 inline void G4VEmProcess::SetCrossSectionType( << 618 inline void G4VEmProcess::SetIntegral(G4bool val)
706 { 619 {
707 fXSType = val; << 620 integral = val;
708 } 621 }
709 622
710 //....oooOO0OOooo........oooOO0OOooo........oo 623 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
711 624
712 inline G4CrossSectionType G4VEmProcess::CrossS << 625 inline G4bool G4VEmProcess::IsIntegral() const
713 { 626 {
714 return fXSType; << 627 return integral;
715 } 628 }
716 629
717 //....oooOO0OOooo........oooOO0OOooo........oo 630 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
718 631
719 inline void G4VEmProcess::SetBuildTableFlag(G4 632 inline void G4VEmProcess::SetBuildTableFlag(G4bool val)
720 { 633 {
721 buildLambdaTable = val; 634 buildLambdaTable = val;
722 } 635 }
723 636
724 //....oooOO0OOooo........oooOO0OOooo........oo 637 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
725 638
726 inline G4ParticleChangeForGamma* G4VEmProcess: 639 inline G4ParticleChangeForGamma* G4VEmProcess::GetParticleChange()
727 { 640 {
728 return &fParticleChange; 641 return &fParticleChange;
729 } 642 }
730 643
731 //....oooOO0OOooo........oooOO0OOooo........oo 644 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
732 645
733 inline void G4VEmProcess::SetParticle(const G4 646 inline void G4VEmProcess::SetParticle(const G4ParticleDefinition* p)
734 { 647 {
735 particle = p; 648 particle = p;
736 currentParticle = p; 649 currentParticle = p;
737 } 650 }
738 651
739 //....oooOO0OOooo........oooOO0OOooo........oo 652 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
740 653
741 inline void G4VEmProcess::SetSecondaryParticle 654 inline void G4VEmProcess::SetSecondaryParticle(const G4ParticleDefinition* p)
742 { 655 {
743 secondaryParticle = p; 656 secondaryParticle = p;
744 } 657 }
745 658
746 //....oooOO0OOooo........oooOO0OOooo........oo 659 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
747 660
748 inline void G4VEmProcess::SetStartFromNullFlag 661 inline void G4VEmProcess::SetStartFromNullFlag(G4bool val)
749 { 662 {
750 startFromNull = val; 663 startFromNull = val;
751 } 664 }
752 665
753 //....oooOO0OOooo........oooOO0OOooo........oo 666 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
754 667
755 inline void G4VEmProcess::SetSplineFlag(G4bool 668 inline void G4VEmProcess::SetSplineFlag(G4bool val)
756 { 669 {
757 splineFlag = val; 670 splineFlag = val;
>> 671 actSpline = true;
758 } 672 }
759 673
760 //....oooOO0OOooo........oooOO0OOooo........oo 674 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
761 675
762 inline G4int G4VEmProcess::DensityIndex(G4int << 676 inline const G4Element* G4VEmProcess::GetTargetElement() const
763 { <<
764 return (*theDensityIdx)[idx]; <<
765 } <<
766 <<
767 //....oooOO0OOooo........oooOO0OOooo........oo <<
768 <<
769 inline G4double G4VEmProcess::DensityFactor(G4 <<
770 { <<
771 return (*theDensityFactor)[idx]; <<
772 } <<
773 <<
774 //....oooOO0OOooo........oooOO0OOooo........oo <<
775 <<
776 inline G4bool G4VEmProcess::UseBaseMaterial() <<
777 { <<
778 return baseMat; <<
779 } <<
780 <<
781 //....oooOO0OOooo........oooOO0OOooo........oo <<
782 <<
783 inline const G4VEmModel* G4VEmProcess::GetCurr <<
784 { <<
785 return currentModel; <<
786 } <<
787 <<
788 //....oooOO0OOooo........oooOO0OOooo........oo <<
789 <<
790 inline void G4VEmProcess::SetEmMasterProcess(c <<
791 { <<
792 masterProc = ptr; <<
793 } <<
794 <<
795 //....oooOO0OOooo........oooOO0OOooo........oo <<
796 <<
797 inline G4int G4VEmProcess::NumberOfModels() co <<
798 { <<
799 return numberOfModels; <<
800 } <<
801 <<
802 //....oooOO0OOooo........oooOO0OOooo........oo <<
803 <<
804 inline G4VEmModel* G4VEmProcess::EmModel(std:: <<
805 { 677 {
806 return (index < emModels.size()) ? emModels[ << 678 return currentModel->GetCurrentElement();
807 } 679 }
808 680
809 //....oooOO0OOooo........oooOO0OOooo........oo 681 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
810 682
811 inline G4VEmModel* G4VEmProcess::GetModelByInd << 683 inline const G4Isotope* G4VEmProcess::GetTargetIsotope() const
812 { 684 {
813 return modelManager->GetModel(idx, ver); << 685 return currentModel->GetCurrentIsotope();
814 } 686 }
815 687
816 //....oooOO0OOooo........oooOO0OOooo........oo 688 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
817 689
818 #endif 690 #endif
819 691