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