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 10.5)


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