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