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