Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/utils/include/G4VEmProcess.hh

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/electromagnetic/utils/include/G4VEmProcess.hh (Version 11.3.0) and /processes/electromagnetic/utils/include/G4VEmProcess.hh (Version 11.2.2)


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