Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/utils/include/G4VEnergyLossProcess.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/G4VEnergyLossProcess.hh (Version 11.3.0) and /processes/electromagnetic/utils/include/G4VEnergyLossProcess.hh (Version 6.0.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
                                                   >>  23 // $Id: G4VEnergyLossProcess.hh,v 1.3 2004/01/14 18:01:57 vnivanch Exp $
                                                   >>  24 // GEANT4 tag $Name: geant4-06-00-patch-01 $
 26 //                                                 25 //
 27 // -------------------------------------------     26 // -------------------------------------------------------------------
 28 //                                                 27 //
 29 // GEANT4 Class header file                        28 // GEANT4 Class header file
 30 //                                                 29 //
 31 //                                                 30 //
 32 // File name:     G4VEnergyLossProcess             31 // File name:     G4VEnergyLossProcess
 33 //                                                 32 //
 34 // Author:        Vladimir Ivanchenko on base      33 // Author:        Vladimir Ivanchenko on base of Laszlo Urban code
 35 //                                                 34 //
 36 // Creation date: 03.01.2002                       35 // Creation date: 03.01.2002
 37 //                                                 36 //
 38 // Modifications: Vladimir Ivanchenko          <<  37 // Modifications:
                                                   >>  38 //
                                                   >>  39 // 26-12-02 Secondary production moved to derived classes (V.Ivanchenko)
                                                   >>  40 // 20-01-03 Migrade to cut per region (V.Ivanchenko)
                                                   >>  41 // 24-01-03 Make models region aware (V.Ivanchenko)
                                                   >>  42 // 05-02-03 Fix compilation warnings (V.Ivanchenko)
                                                   >>  43 // 13-02-03 SubCutoffProcessors defined for regions (V.Ivanchenko)
                                                   >>  44 // 17-02-03 Fix problem of store/restore tables (V.Ivanchenko)
                                                   >>  45 // 26-02-03 Region dependent step limit (V.Ivanchenko)
                                                   >>  46 // 26-03-03 Add GetDEDXDispersion (V.Ivanchenko)
                                                   >>  47 // 09-04-03 Fix problem of negative range limit for non integral (V.Ivanchenko)
                                                   >>  48 // 13-05-03 Add calculation of precise range (V.Ivanchenko)
                                                   >>  49 // 21-07-03 Add UpdateEmModel method (V.Ivanchenko)
                                                   >>  50 // 12-11-03 G4EnergyLossSTD -> G4EnergyLossProcess (V.Ivanchenko)
                                                   >>  51 // 14-01-04 Activate precise range calculation (V.Ivanchenko)
 39 //                                                 52 //
 40 // Class Description:                              53 // Class Description:
 41 //                                                 54 //
 42 // It is the unified energy loss process it ca     55 // It is the unified energy loss process it calculates the continuous
 43 // energy loss for charged particles using a s     56 // energy loss for charged particles using a set of Energy Loss
 44 // models valid for different energy regions.      57 // models valid for different energy regions. There are a possibility
 45 // to create and access to dE/dx and range tab     58 // to create and access to dE/dx and range tables, or to calculate
 46 // that information on fly.                        59 // that information on fly.
 47                                                    60 
 48 // -------------------------------------------     61 // -------------------------------------------------------------------
 49 //                                                 62 //
 50                                                    63 
 51 #ifndef G4VEnergyLossProcess_h                     64 #ifndef G4VEnergyLossProcess_h
 52 #define G4VEnergyLossProcess_h 1                   65 #define G4VEnergyLossProcess_h 1
 53                                                    66 
 54 #include "G4VContinuousDiscreteProcess.hh"         67 #include "G4VContinuousDiscreteProcess.hh"
 55 #include "globals.hh"                              68 #include "globals.hh"
 56 #include "G4Material.hh"                           69 #include "G4Material.hh"
 57 #include "G4MaterialCutsCouple.hh"                 70 #include "G4MaterialCutsCouple.hh"
 58 #include "G4Track.hh"                              71 #include "G4Track.hh"
 59 #include "G4EmModelManager.hh"                     72 #include "G4EmModelManager.hh"
 60 #include "G4ParticleChangeForLoss.hh"          <<  73 #include "G4UnitsTable.hh"
 61 #include "G4EmTableType.hh"                    << 
 62 #include "G4EmSecondaryParticleType.hh"        << 
 63 #include "G4PhysicsTable.hh"                   << 
 64 #include "G4PhysicsVector.hh"                  << 
 65                                                    74 
 66 class G4Step;                                      75 class G4Step;
 67 class G4ParticleDefinition;                        76 class G4ParticleDefinition;
 68 class G4EmParameters;                          << 
 69 class G4VEmModel;                                  77 class G4VEmModel;
 70 class G4VEmFluctuationModel;                       78 class G4VEmFluctuationModel;
 71 class G4DataVector;                                79 class G4DataVector;
                                                   >>  80 class G4VParticleChange;
                                                   >>  81 class G4PhysicsTable;
                                                   >>  82 class G4PhysicsVector;
                                                   >>  83 class G4VSubCutoffProcessor;
 72 class G4Region;                                    84 class G4Region;
 73 class G4SafetyHelper;                          << 
 74 class G4VAtomDeexcitation;                     << 
 75 class G4VSubCutProducer;                       << 
 76 class G4EmBiasingManager;                      << 
 77 class G4LossTableManager;                      << 
 78 class G4EmDataHandler;                         << 
 79                                                    85 
 80 //....oooOO0OOooo........oooOO0OOooo........oo     86 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 81                                                    87 
 82 class G4VEnergyLossProcess : public G4VContinu     88 class G4VEnergyLossProcess : public G4VContinuousDiscreteProcess
 83 {                                                  89 {
 84 public:                                            90 public:
 85                                                    91 
 86   G4VEnergyLossProcess(const G4String& name =      92   G4VEnergyLossProcess(const G4String& name = "EnergyLoss",
 87                        G4ProcessType type = fE <<  93                          G4ProcessType type = fElectromagnetic);
 88                                                    94 
 89   ~G4VEnergyLossProcess() override;            <<  95  ~G4VEnergyLossProcess();
 90                                                    96 
 91   //------------------------------------------ <<  97   void Initialise();
 92   // Virtual methods to be implemented in conc << 
 93   //------------------------------------------ << 
 94                                                    98 
 95 protected:                                     <<  99   G4VParticleChange* AlongStepDoIt(const G4Track&, const G4Step&);
 96                                                   100 
 97   // description of specific process parameter << 101   G4VParticleChange* PostStepDoIt(const G4Track&, const G4Step&);
 98   virtual void StreamProcessInfo(std::ostream& << 
 99                                                   102 
100   virtual void InitialiseEnergyLossProcess(con << 103   virtual std::vector<G4Track*>* SecondariesAlongStep(
101                                            con << 104                              const G4Step&,
                                                   >> 105                  G4double& tmax,
                                                   >> 106                  G4double& eloss,
                                                   >> 107                                    G4double& kinEnergy) = 0;
102                                                   108 
103 public:                                        << 109   virtual void SecondariesPostStep(
                                                   >> 110                                    G4VEmModel*,
                                                   >> 111                              const G4MaterialCutsCouple*,
                                                   >> 112                              const G4DynamicParticle*,
                                                   >> 113                                    G4double& tcut,
                                                   >> 114                                    G4double& kinEnergy) = 0;
104                                                   115 
105   // used as low energy limit LambdaTable      << 116   virtual G4bool IsApplicable(const G4ParticleDefinition& p) = 0;
106   virtual G4double MinPrimaryEnergy(const G4Pa << 117     // True for all charged particles
107                                     const G4Ma << 
108                                                   118 
109   // print documentation in html format        << 119   virtual
110   void ProcessDescription(std::ostream& outFil << 120   void BuildPhysicsTable(const G4ParticleDefinition&);
                                                   >> 121   // Build physics table during initialisation
111                                                   122 
112   // prepare all tables                        << 123   virtual void PrintInfoDefinition();
113   void PreparePhysicsTable(const G4ParticleDef << 
114                                                << 
115   // build all tables                          << 
116   void BuildPhysicsTable(const G4ParticleDefin << 
117                                                << 
118   // build a table                             << 
119   G4PhysicsTable* BuildDEDXTable(G4EmTableType << 
120                                                << 
121   // build a table                             << 
122   G4PhysicsTable* BuildLambdaTable(G4EmTableTy << 
123                                                << 
124   // Called before tracking of each new G4Trac << 
125   void StartTracking(G4Track*) override;       << 
126                                                << 
127   // Step limit from AlongStep                 << 
128   G4double AlongStepGetPhysicalInteractionLeng << 
129                                   const G4Trac << 
130                                   G4double  pr << 
131                                   G4double  cu << 
132                                   G4double& cu << 
133                                   G4GPILSelect << 
134                                                << 
135   // Step limit from cross section             << 
136   G4double PostStepGetPhysicalInteractionLengt << 
137                                   const G4Trac << 
138                                   G4double pre << 
139                                   G4ForceCondi << 
140                                                << 
141   // AlongStep computations                    << 
142   G4VParticleChange* AlongStepDoIt(const G4Tra << 
143                                                << 
144   // PostStep sampling of secondaries          << 
145   G4VParticleChange* PostStepDoIt(const G4Trac << 
146                                                << 
147   // Store all PhysicsTable in files.          << 
148   // Return false in case of any fatal failure << 
149   G4bool StorePhysicsTable(const G4ParticleDef << 
150                            const G4String& dir << 
151                            G4bool ascii = fals << 
152                                                << 
153   // Retrieve all Physics from a files.        << 
154   // Return true if all the Physics Table are  << 
155   // Return false if any fatal failure.        << 
156   G4bool RetrievePhysicsTable(const G4Particle << 
157                               const G4String&  << 
158                               G4bool ascii) ov << 
159                                                << 
160 private:                                       << 
161                                                   124 
162   // summary printout after initialisation     << 125   // Print out of the class parameters
163   void StreamInfo(std::ostream& out, const G4P << 
164                   G4bool rst=false) const;     << 
165                                                << 
166   //------------------------------------------ << 
167   // Public interface to cross section, mfp an << 
168   // These methods are not used in run time    << 
169   //------------------------------------------ << 
170                                                   126 
171 public:                                        << 127   G4PhysicsTable* BuildDEDXTable();
172                                                   128 
173   // access to dispersion of restricted energy << 129   G4PhysicsTable* BuildDEDXTableForPreciseRange();
174   G4double GetDEDXDispersion(const G4MaterialC << 
175                              const G4DynamicPa << 
176                              G4double length); << 
177                                                   130 
178   // Access to cross section table             << 131   G4PhysicsTable* BuildLambdaTable();
179   G4double CrossSectionPerVolume(G4double kine << 
180                                  const G4Mater << 
181   G4double CrossSectionPerVolume(G4double kine << 
182                                  const G4Mater << 
183                                  G4double logK << 
184                                                   132 
185   // access to cross section                   << 133   G4PhysicsTable* BuildLambdaSubTable();
186   G4double MeanFreePath(const G4Track& track); << 
187                                                   134 
188   // access to step limit                      << 135   void SetParticles(const G4ParticleDefinition*,
189   G4double ContinuousStepLimit(const G4Track&  << 136                     const G4ParticleDefinition*);
190                                G4double previo << 
191                                G4double curren << 
192                                G4double& curre << 
193                                                   137 
194 protected:                                     << 138   void SetParticle(const G4ParticleDefinition* p);
                                                   >> 139   void SetBaseParticle(const G4ParticleDefinition* p);
                                                   >> 140   void SetSecondaryParticle(const G4ParticleDefinition* p);
195                                                   141 
196   // implementation of the pure virtual method << 142   const G4ParticleDefinition* Particle() const;
197   G4double GetMeanFreePath(const G4Track& trac << 143   const G4ParticleDefinition* BaseParticle() const;
198                            G4double previousSt << 144   const G4ParticleDefinition* SecondaryParticle() const;
199                            G4ForceCondition* c << 145   // Particle definition
200                                                   146 
201   // implementation of the pure virtual method << 147   void SetDEDXBinning(G4int nbins);
202   G4double GetContinuousStepLimit(const G4Trac << 148   // Binning for dEdx, range, and inverse range tables
203                                   G4double pre << 
204                                   G4double cur << 
205                                   G4double& cu << 
206                                                << 
207   // creation of an empty vector for cross sec << 
208   G4PhysicsVector* LambdaPhysicsVector(const G << 
209                                        G4doubl << 
210                                                << 
211   inline std::size_t CurrentMaterialCutsCouple << 
212                                                << 
213   //------------------------------------------ << 
214   // Specific methods to set, access, modify m << 
215   //------------------------------------------ << 
216                                                << 
217   // Select model in run time                  << 
218   inline void SelectModel(G4double kinEnergy); << 
219                                                << 
220 public:                                        << 
221   // Select model by energy and couple index   << 
222   // Not for run time processing               << 
223   inline G4VEmModel* SelectModelForMaterial(G4 << 
224                                             st << 
225                                                << 
226   // Add EM model coupled with fluctuation mod << 
227   // of order defines which pair of models wil << 
228   // energy interval                           << 
229   void AddEmModel(G4int, G4VEmModel*,          << 
230                   G4VEmFluctuationModel* fluc  << 
231                   const G4Region* region = nul << 
232                                                << 
233   // Assign a model to a process local list, t << 
234   // the derived process should execute AddEmM << 
235   void SetEmModel(G4VEmModel*, G4int index=0); << 
236                                                << 
237   // Access to models                          << 
238   inline std::size_t NumberOfModels() const;   << 
239                                                << 
240   // Return a model from the local list        << 
241   inline G4VEmModel* EmModel(std::size_t index << 
242                                                << 
243   // Access to models from G4EmModelManager li << 
244   inline G4VEmModel* GetModelByIndex(std::size << 
245                                                << 
246   // Assign a fluctuation model to a process   << 
247   inline void SetFluctModel(G4VEmFluctuationMo << 
248                                                << 
249   // Return the assigned fluctuation model     << 
250   inline G4VEmFluctuationModel* FluctModel() c << 
251                                                << 
252   //------------------------------------------ << 
253   // Define and access particle type           << 
254   //------------------------------------------ << 
255                                                << 
256 protected:                                     << 
257   inline void SetParticle(const G4ParticleDefi << 
258   inline void SetSecondaryParticle(const G4Par << 
259                                                << 
260 public:                                        << 
261   inline void SetBaseParticle(const G4Particle << 
262   inline const G4ParticleDefinition* Particle( << 
263   inline const G4ParticleDefinition* BaseParti << 
264   inline const G4ParticleDefinition* Secondary << 
265                                                << 
266   // hide  assignment operator                 << 
267   G4VEnergyLossProcess(G4VEnergyLossProcess &) << 
268   G4VEnergyLossProcess & operator=(const G4VEn << 
269                                                << 
270   //------------------------------------------ << 
271   // Get/set parameters to configure the proce << 
272   //------------------------------------------ << 
273                                                << 
274   // Add subcut processor for the region       << 
275   void ActivateSubCutoff(const G4Region* regio << 
276                                                   149 
277   // Activate biasing                          << 150   void SetDEDXBinningForPreciseRange(G4int nbins);
278   void SetCrossSectionBiasingFactor(G4double f << 151   // Binning for dEdx, range, and inverse range tables
279                                                   152 
280   void ActivateForcedInteraction(G4double leng << 153   void SetLambdaBinning(G4int nbins);
281                                  const G4Strin << 154   // Binning for lambda table
282                                  G4bool flag = << 
283                                                   155 
284   void ActivateSecondaryBiasing(const G4String << 156   void SetMinKinEnergy(G4double e);
285                                 G4double energ << 157   G4double MinKinEnergy() const;
                                                   >> 158   // Min kinetic energy for tables
286                                                   159 
287   inline void SetLossFluctuations(G4bool val); << 160   void SetMaxKinEnergy(G4double e);
                                                   >> 161   G4double MaxKinEnergy() const;
                                                   >> 162   // Max kinetic energy for tables
288                                                   163 
289   inline void SetSpline(G4bool val);           << 164   void SetMaxKinEnergyForPreciseRange(G4double e);
290   inline void SetCrossSectionType(G4CrossSecti << 165   // Max kinetic energy for tables
291   inline G4CrossSectionType CrossSectionType() << 
292                                                   166 
293   // Set/Get flag "isIonisation"               << 167   G4bool StorePhysicsTable(G4ParticleDefinition*,
294   void SetIonisation(G4bool val);              << 168                      const G4String& directory,
295   inline G4bool IsIonisationProcess() const;   << 169                            G4bool ascii = false);
                                                   >> 170     // Store PhysicsTable in a file.
                                                   >> 171     // Return false in case of failure at I/O
                                                   >> 172 
                                                   >> 173   G4bool RetrievePhysicsTable(G4ParticleDefinition*,
                                                   >> 174                         const G4String& directory,
                                                   >> 175                               G4bool ascii);
                                                   >> 176     // Retrieve Physics from a file.
                                                   >> 177     // (return true if the Physics Table can be build by using file)
                                                   >> 178     // (return false if the process has no functionality or in case of failure)
                                                   >> 179     // File name should is constructed as processName+particleName and the
                                                   >> 180     // should be placed under the directory specifed by the argument.
                                                   >> 181 
                                                   >> 182   void AddEmModel(G4int, G4VEmModel*, G4VEmFluctuationModel* fluc = 0,
                                                   >> 183                                 const G4Region* region = 0);
                                                   >> 184   // Add EM model coupled with fluctuation model for the region
                                                   >> 185 
                                                   >> 186   void UpdateEmModel(const G4String&, G4double, G4double);
                                                   >> 187   // Define new energy range for thhe model identified by the name
                                                   >> 188 
                                                   >> 189   void AddSubCutoffProcessor(G4VSubCutoffProcessor*, const G4Region* region = 0);
                                                   >> 190   // Add subcutoff processor for the region
296                                                   191 
297   // Redefine parameteters for stepping contro << 192   virtual void SetSubCutoff(G4bool) {};
298   void SetLinearLossLimit(G4double val);       << 
299   void SetStepFunction(G4double v1, G4double v << 
300   void SetLowestEnergyLimit(G4double);         << 
301                                                   193 
302   inline G4int NumberOfSubCutoffRegions() cons << 194   void SetDEDXTable(G4PhysicsTable* p);
                                                   >> 195   G4PhysicsTable* DEDXTable() const {return theDEDXTable;};
303                                                   196 
304   //------------------------------------------ << 197   void SetRangeTable(G4PhysicsTable* p);
305   // Specific methods to path Physics Tables t << 198   G4PhysicsTable* RangeTable() const {return theRangeTable;};
306   //------------------------------------------ << 
307                                                   199 
308   void SetDEDXTable(G4PhysicsTable* p, G4EmTab << 
309   void SetCSDARangeTable(G4PhysicsTable* pRang << 
310   void SetRangeTableForLoss(G4PhysicsTable* p)    200   void SetRangeTableForLoss(G4PhysicsTable* p);
311   void SetInverseRangeTable(G4PhysicsTable* p) << 201   G4PhysicsTable* RangeTableForLoss() const {return theRangeTableForLoss;};
312   void SetLambdaTable(G4PhysicsTable* p);      << 
313                                                   202 
314   void SetTwoPeaksXS(std::vector<G4TwoPeaksXS* << 203   void SetInverseRangeTable(G4PhysicsTable* p);
315   void SetEnergyOfCrossSectionMax(std::vector< << 204   G4PhysicsTable* InverseRangeTable() const {return theInverseRangeTable;};
316                                                   205 
317   //------------------------------------------ << 206   void SetSecondaryRangeTable(G4PhysicsTable* p);
318   // Specific methods to define custom Physics << 
319   //------------------------------------------ << 
320                                                   207 
321   // Binning for dEdx, range, inverse range an << 208   void SetLambdaTable(G4PhysicsTable* p);
322   void SetDEDXBinning(G4int nbins);            << 209   G4PhysicsTable* LambdaTable() {return theLambdaTable;};
323                                                   210 
324   // Min kinetic energy for tables             << 211   void SetSubLambdaTable(G4PhysicsTable* p);
325   void SetMinKinEnergy(G4double e);            << 212   G4PhysicsTable* SubLambdaTable() {return theSubLambdaTable;};
326   inline G4double MinKinEnergy() const;        << 
327                                                   213 
328   // Max kinetic energy for tables             << 214   G4double GetDEDX(G4double& kineticEnergy, const G4MaterialCutsCouple* couple);
329   void SetMaxKinEnergy(G4double e);            << 
330   inline G4double MaxKinEnergy() const;        << 
331                                                   215 
332   // Biasing parameters                        << 216   G4double GetRange(G4double& kineticEnergy, const G4MaterialCutsCouple* couple);
333   inline G4double CrossSectionBiasingFactor()  << 
334                                                   217 
335   // Return values for given G4MaterialCutsCou << 218   G4double GetKineticEnergy(G4double& range, const G4MaterialCutsCouple* couple);
336   inline G4double GetDEDX(G4double kineticEner << 
337   inline G4double GetCSDADEDX(G4double kinetic << 
338                               const G4Material << 
339   inline G4double GetDEDX(G4double kineticEner << 
340                           G4double logKineticE << 
341   inline G4double GetRange(G4double kineticEne << 
342   inline G4double GetRange(G4double kineticEne << 
343                            G4double logKinetic << 
344   inline G4double GetCSDARange(G4double kineti << 
345                                const G4Materia << 
346   inline G4double GetKineticEnergy(G4double ra << 
347                                    const G4Mat << 
348   inline G4double GetLambda(G4double kineticEn << 
349   inline G4double GetLambda(G4double kineticEn << 
350                             G4double logKineti << 
351                                                << 
352   inline G4bool TablesAreBuilt() const;        << 
353                                                << 
354   // Access to specific tables                 << 
355   inline G4PhysicsTable* DEDXTable() const;    << 
356   inline G4PhysicsTable* DEDXunRestrictedTable << 
357   inline G4PhysicsTable* IonisationTable() con << 
358   inline G4PhysicsTable* CSDARangeTable() cons << 
359   inline G4PhysicsTable* RangeTableForLoss() c << 
360   inline G4PhysicsTable* InverseRangeTable() c << 
361   inline G4PhysicsTable* LambdaTable() const;  << 
362   inline std::vector<G4TwoPeaksXS*>* TwoPeaksX << 
363   inline std::vector<G4double>* EnergyOfCrossS << 
364                                                << 
365   inline G4bool UseBaseMaterial() const;       << 
366                                                << 
367   //------------------------------------------ << 
368   // Run time method for simulation of ionisat << 
369   //------------------------------------------ << 
370                                                   219 
371   // access atom on which interaction happens  << 220   G4double GetLambda(G4double kineticEnergy, const G4MaterialCutsCouple* couple);
372   const G4Element* GetCurrentElement() const;  << 221   // It returns the MeanFreePath of the process
373                                                   222 
374   // Set scaling parameters for ions is needed << 223   G4double GetDEDXDispersion(const G4MaterialCutsCouple *couple,
375   void SetDynamicMassCharge(G4double massratio << 224                              const G4DynamicParticle* dp,
                                                   >> 225                                    G4double& length);
376                                                   226 
377 private:                                       << 227   G4double MicroscopicCrossSection(G4double kineticEnergy,
                                                   >> 228                              const G4MaterialCutsCouple* couple);
                                                   >> 229   // It returns the MeanFreePath of the process for a (energy, material)
378                                                   230 
379   void FillSecondariesAlongStep(G4double weigh << 231   void SetLinearLossLimit(G4double val) {linLossLimit = val;};
380                                                   232 
381   void PrintWarning(const G4String&, G4double  << 233   void SetLossFluctuations(G4bool val) {lossFluctuationFlag = val;};
382                                                   234 
383   // define material and indexes               << 235   void SetIntegral(G4bool val);
384   inline void DefineMaterial(const G4MaterialC << 236   G4bool IsIntegral() const {return integral;}
385                                                   237 
386   //------------------------------------------ << 238   void SetRandomStep(G4bool val) {rndmStepFlag = val;};
387   // Compute values using scaling relation, ma << 
388   //------------------------------------------ << 
389   inline G4double GetDEDXForScaledEnergy(G4dou << 
390   inline G4double GetDEDXForScaledEnergy(G4dou << 
391                                          G4dou << 
392   inline G4double GetIonisationForScaledEnergy << 
393   inline G4double GetScaledRangeForScaledEnerg << 
394   inline G4double GetScaledRangeForScaledEnerg << 
395                                                << 
396                                                << 
397   inline G4double GetLimitScaledRangeForScaled << 
398   inline G4double GetLimitScaledRangeForScaled << 
399                                                << 
400                                                << 
401   inline G4double ScaledKinEnergyForLoss(G4dou << 
402   inline G4double GetLambdaForScaledEnergy(G4d << 
403   inline G4double GetLambdaForScaledEnergy(G4d << 
404                                            G4d << 
405                                                << 
406   inline G4double LogScaledEkin(const G4Track& << 
407                                                << 
408   void ComputeLambdaForScaledEnergy(G4double s << 
409                                     const G4Tr << 
410                                                   239 
411   G4bool IsRegionForCubcutProcessor(const G4Tr << 240   void SetMinSubRange(G4double val) {minSubRange = val;};
412                                                   241 
413 protected:                                     << 242   void SetStepLimits(G4double v1, G4double v2);
414                                                << 243   void SetStepFunction(G4double v1, G4double v2);
415   G4ParticleChangeForLoss     fParticleChange; << 
416   const G4Material*           currentMaterial  << 
417   const G4MaterialCutsCouple* currentCouple =  << 
418                                                   244 
419 private:                                       << 245   G4bool TablesAreBuilt() const {return  tablesAreBuilt;};
420                                                   246 
421   G4LossTableManager*         lManager;        << 247   G4int NumberOfSubCutoffRegions() const {return nSCoffRegions;};
422   G4EmModelManager*           modelManager;    << 
423   G4VEmModel*                 currentModel = n << 
424   G4EmBiasingManager*         biasManager = nu << 
425   G4SafetyHelper*             safetyHelper;    << 
426   G4EmParameters*             theParameters;   << 
427   G4VEmFluctuationModel*      fluctModel = nul << 
428   G4VAtomDeexcitation*        atomDeexcitation << 
429   G4VSubCutProducer*          subcutProducer = << 
430                                                << 
431   const G4ParticleDefinition* particle = nullp << 
432   const G4ParticleDefinition* baseParticle = n << 
433   const G4ParticleDefinition* secondaryParticl << 
434   G4EmDataHandler* theData = nullptr;          << 
435                                                << 
436   G4PhysicsTable* theDEDXTable = nullptr;      << 
437   G4PhysicsTable* theDEDXunRestrictedTable = n << 
438   G4PhysicsTable* theIonisationTable = nullptr << 
439   G4PhysicsTable* theRangeTableForLoss = nullp << 
440   G4PhysicsTable* theCSDARangeTable = nullptr; << 
441   G4PhysicsTable* theInverseRangeTable = nullp << 
442   G4PhysicsTable* theLambdaTable = nullptr;    << 
443                                                << 
444   std::vector<const G4Region*>* scoffRegions = << 
445   std::vector<G4VEmModel*>*     emModels = nul << 
446   const std::vector<G4int>*     theDensityIdx  << 
447   const std::vector<G4double>*  theDensityFact << 
448   const G4DataVector*           theCuts = null << 
449                                                   248 
450   std::vector<G4double>* theEnergyOfCrossSecti << 249   G4double MeanFreePath(const G4Track& track,
451   std::vector<G4TwoPeaksXS*>* fXSpeaks = nullp << 250                               G4double previousStepSize,
                                                   >> 251                               G4ForceCondition* condition);
452                                                   252 
453   G4double lowestKinEnergy;                    << 253   G4double ContinuousStepLimit(const G4Track& track,
454   G4double minKinEnergy;                       << 254                                      G4double previousStepSize,
455   G4double maxKinEnergy;                       << 255                                      G4double currentMinimumStep,
456   G4double maxKinEnergyCSDA;                   << 256                                      G4double& currentSafety);
457                                                   257 
458   G4double linLossLimit = 0.01;                << 258   void      ResetNumberOfInteractionLengthLeft();
459   G4double dRoverRange = 0.2;                  << 259   // reset (determine the value of)NumberOfInteractionLengthLeft
460   G4double finalRange;                         << 
461   G4double lambdaFactor = 0.8;                 << 
462   G4double invLambdaFactor;                    << 
463   G4double biasFactor = 1.0;                   << 
464                                                << 
465   G4double massRatio = 1.0;                    << 
466   G4double logMassRatio = 0.0;                 << 
467   G4double fFactor = 1.0;                      << 
468   G4double reduceFactor = 1.0;                 << 
469   G4double chargeSqRatio = 1.0;                << 
470   G4double fRange = 0.0;                       << 
471   G4double fRangeEnergy = 0.0;                 << 
472                                                   260 
473 protected:                                        261 protected:
474                                                   262 
475   G4double preStepLambda = 0.0;                << 263   virtual
476   G4double preStepKinEnergy = 0.0;             << 264   G4double GetMeanFreePath(const G4Track& track,
477   G4double preStepScaledEnergy = 0.0;          << 265                                          G4double previousStepSize,
478   G4double mfpKinEnergy = 0.0;                 << 266                                          G4ForceCondition* condition);
479                                                << 
480   std::size_t currentCoupleIndex = 0;          << 
481                                                   267 
482 private:                                       << 268   virtual
                                                   >> 269   G4double GetContinuousStepLimit(const G4Track& track,
                                                   >> 270                                                 G4double previousStepSize,
                                                   >> 271                                                 G4double currentMinimumStep,
                                                   >> 272                                                 G4double& currentSafety);
483                                                   273 
484   G4int nBins;                                 << 274   virtual
485   G4int nBinsCSDA;                             << 275   const G4ParticleDefinition* DefineBaseParticle(
486   G4int numberOfModels = 0;                    << 276           const G4ParticleDefinition*) {return 0;};
487   G4int nSCoffRegions = 0;                     << 
488   G4int secID = _DeltaElectron;                << 
489   G4int tripletID = _TripletElectron;          << 
490   G4int biasID = _DeltaEBelowCut;              << 
491   G4int epixeID = _ePIXE;                      << 
492   G4int gpixeID = _GammaPIXE;                  << 
493   G4int mainSecondaries = 1;                   << 
494                                                << 
495   std::size_t basedCoupleIndex = 0;            << 
496   std::size_t coupleIdxRange = 0;              << 
497   std::size_t idxDEDX = 0;                     << 
498   std::size_t idxDEDXunRestricted = 0;         << 
499   std::size_t idxIonisation = 0;               << 
500   std::size_t idxRange = 0;                    << 
501   std::size_t idxCSDA = 0;                     << 
502   std::size_t idxSecRange = 0;                 << 
503   std::size_t idxInverseRange = 0;             << 
504   std::size_t idxLambda = 0;                   << 
505                                                << 
506   G4GPILSelection aGPILSelection;              << 
507   G4CrossSectionType fXSType = fEmOnePeak;     << 
508                                                << 
509   G4bool lossFluctuationFlag = true;           << 
510   G4bool useCutAsFinalRange = false;           << 
511   G4bool tablesAreBuilt = false;               << 
512   G4bool spline = true;                        << 
513   G4bool isIon = false;                        << 
514   G4bool isIonisation = false;                 << 
515   G4bool useDeexcitation = false;              << 
516   G4bool biasFlag = false;                     << 
517   G4bool weightFlag = false;                   << 
518   G4bool isMaster = false;                     << 
519   G4bool baseMat = false;                      << 
520   G4bool actLinLossLimit = false;              << 
521   G4bool actLossFluc = false;                  << 
522   G4bool actBinning = false;                   << 
523   G4bool actMinKinEnergy = false;              << 
524   G4bool actMaxKinEnergy = false;              << 
525                                                   277 
526   std::vector<G4DynamicParticle*> secParticles << 278   virtual
527   std::vector<G4Track*> scTracks;              << 279   G4PhysicsVector* DEDXPhysicsVector(const G4MaterialCutsCouple*);
528 };                                             << 
529                                                   280 
530 // ======== Run time inline methods ========== << 281   virtual
                                                   >> 282   G4PhysicsVector* DEDXPhysicsVectorForPreciseRange(const G4MaterialCutsCouple*);
531                                                   283 
532 inline std::size_t G4VEnergyLossProcess::Curre << 284   virtual
533 {                                              << 285   G4PhysicsVector* LambdaPhysicsVector(const G4MaterialCutsCouple*);
534   return currentCoupleIndex;                   << 
535 }                                              << 
536                                                   286 
537 //....oooOO0OOooo........oooOO0OOooo........oo << 287   virtual
                                                   >> 288   G4PhysicsVector* SubLambdaPhysicsVector(const G4MaterialCutsCouple*);
538                                                   289 
539 inline void G4VEnergyLossProcess::SelectModel( << 290   virtual G4double MinPrimaryEnergy(const G4ParticleDefinition*,
540 {                                              << 291                                     const G4Material*, G4double cut) = 0;
541   currentModel = modelManager->SelectModel(kin << 
542   currentModel->SetCurrentCouple(currentCouple << 
543 }                                              << 
544                                                   292 
545 //....oooOO0OOooo........oooOO0OOooo........oo << 293   virtual G4double MaxSecondaryEnergy(const G4DynamicParticle* dp) = 0;
546                                                   294 
547 inline G4VEmModel* G4VEnergyLossProcess::Selec << 295   G4VEmModel* SelectModel(G4double& kinEnergy);
548                    G4double kinEnergy, std::si << 
549 {                                              << 
550   return modelManager->SelectModel(kinEnergy,  << 
551 }                                              << 
552                                                   296 
553 //....oooOO0OOooo........oooOO0OOooo........oo << 297   G4VSubCutoffProcessor* SubCutoffProcessor(size_t index);
554                                                   298 
555 inline void                                    << 299   size_t CurrentMaterialCutsCoupleIndex() const {return currentMaterialIndex;};
556 G4VEnergyLossProcess::DefineMaterial(const G4M << 
557 {                                              << 
558   if(couple != currentCouple) {                << 
559     currentCouple = couple;                    << 
560     currentMaterial = couple->GetMaterial();   << 
561     basedCoupleIndex = currentCoupleIndex = co << 
562     fFactor = chargeSqRatio*biasFactor;        << 
563     mfpKinEnergy = DBL_MAX;                    << 
564     idxLambda = 0;                             << 
565     if(baseMat) {                              << 
566       basedCoupleIndex = (*theDensityIdx)[curr << 
567       fFactor *= (*theDensityFactor)[currentCo << 
568     }                                          << 
569     reduceFactor = 1.0/(fFactor*massRatio);    << 
570   }                                            << 
571 }                                              << 
572                                                   300 
573 //....oooOO0OOooo........oooOO0OOooo........oo << 301   void SetMassRatio(G4double val) {massRatio = val;};
574                                                   302 
575 inline G4double G4VEnergyLossProcess::GetDEDXF << 303   void SetReduceFactor(G4double val) {reduceFactor = val;};
576 {                                              << 
577   /*                                           << 
578   G4cout << "G4VEnergyLossProcess::GetDEDX: Id << 
579            << basedCoupleIndex << " E(MeV)= "  << 
580          << " Emin= " << minKinEnergy << "  Fa << 
581          << "  " << theDEDXTable << G4endl; */ << 
582   G4double x = fFactor*(*theDEDXTable)[basedCo << 
583   if(e < minKinEnergy) { x *= std::sqrt(e/minK << 
584   return x;                                    << 
585 }                                              << 
586                                                   304 
587 //....oooOO0OOooo........oooOO0OOooo........oo << 305   void SetChargeSquare(G4double val) {chargeSquare = val;};
588                                                   306 
589 inline                                         << 307   void SetChargeSquareRatio(G4double val) {chargeSqRatio = val;};
590 G4double G4VEnergyLossProcess::GetDEDXForScale << 
591 {                                              << 
592   /*                                           << 
593   G4cout << "G4VEnergyLossProcess::GetDEDX: Id << 
594            << basedCoupleIndex << " E(MeV)= "  << 
595          << " Emin= " << minKinEnergy << "  Fa << 
596          << "  " << theDEDXTable << G4endl; */ << 
597   G4double x = fFactor*(*theDEDXTable)[basedCo << 
598   if(e < minKinEnergy) { x *= std::sqrt(e/minK << 
599   return x;                                    << 
600 }                                              << 
601                                                   308 
602 //....oooOO0OOooo........oooOO0OOooo........oo << 309 private:
603                                                   310 
604 inline G4double G4VEnergyLossProcess::GetIonis << 311   void Clear();
605 {                                              << 
606   G4double x =                                 << 
607     fFactor*(*theIonisationTable)[basedCoupleI << 
608   if(e < minKinEnergy) { x *= std::sqrt(e/minK << 
609   return x;                                    << 
610 }                                              << 
611                                                   312 
612 //....oooOO0OOooo........oooOO0OOooo........oo << 313   void DefineMaterial(const G4MaterialCutsCouple* couple);
613                                                   314 
614 inline G4double G4VEnergyLossProcess::GetScale << 315   G4double GetRangeForLoss(G4double& kineticEnergy, const G4MaterialCutsCouple* couple);
615 {                                              << 
616   //G4cout << "G4VEnergyLossProcess::GetScaled << 
617   //         << basedCoupleIndex << " E(MeV)=  << 
618   //         << " lastIdx= " << lastIdx << "   << 
619   if(currentCoupleIndex != coupleIdxRange || f << 
620     coupleIdxRange = currentCoupleIndex;       << 
621     fRangeEnergy = e;                          << 
622     fRange = reduceFactor*((*theRangeTableForL << 
623     if (fRange < 0.0) { fRange = 0.0; }        << 
624     else if (e < minKinEnergy) { fRange *= std << 
625   }                                            << 
626   //G4cout << "G4VEnergyLossProcess::GetScaled << 
627   //         << basedCoupleIndex << " E(MeV)=  << 
628   //         << " R=  " << computedRange << "  << 
629   return fRange;                               << 
630 }                                              << 
631                                                << 
632 inline G4double                                << 
633 G4VEnergyLossProcess::GetScaledRangeForScaledE << 
634 {                                              << 
635   //G4cout << "G4VEnergyLossProcess::GetScaled << 
636   //         << basedCoupleIndex << " E(MeV)=  << 
637   //         << " lastIdx= " << lastIdx << "   << 
638   if(currentCoupleIndex != coupleIdxRange || f << 
639     coupleIdxRange = currentCoupleIndex;       << 
640     fRangeEnergy = e;                          << 
641     fRange = reduceFactor*((*theRangeTableForL << 
642     if (fRange < 0.0) { fRange = 0.0; }        << 
643     else if (e < minKinEnergy) { fRange *= std << 
644   }                                            << 
645   //G4cout << "G4VEnergyLossProcess::GetScaled << 
646   //         << basedCoupleIndex << " E(MeV)=  << 
647   //         << " R=  " << fRange << "  " << t << 
648   return fRange;                               << 
649 }                                              << 
650                                                   316 
651 //....oooOO0OOooo........oooOO0OOooo........oo << 317   // hide  assignment operator
652                                                   318 
653 inline G4double                                << 319   G4VEnergyLossProcess(G4VEnergyLossProcess &);
654 G4VEnergyLossProcess::GetLimitScaledRangeForSc << 320   G4VEnergyLossProcess & operator=(const G4VEnergyLossProcess &right);
655 {                                              << 
656   G4double x = ((*theCSDARangeTable)[basedCoup << 
657   if (x < 0.0) { x = 0.0; }                    << 
658   else if (e < minKinEnergy) { x *= std::sqrt( << 
659   return x;                                    << 
660 }                                              << 
661                                                   321 
662 //....oooOO0OOooo........oooOO0OOooo........oo << 322 // =====================================================================
663                                                   323 
664 inline G4double                                << 324 private:
665 G4VEnergyLossProcess::GetLimitScaledRangeForSc << 
666                                                << 
667 {                                              << 
668   G4double x = ((*theCSDARangeTable)[basedCoup << 
669   if (x < 0.0) { x = 0.0; }                    << 
670   else if (e < minKinEnergy) { x *= std::sqrt( << 
671   return x;                                    << 
672 }                                              << 
673                                                   325 
674 //....oooOO0OOooo........oooOO0OOooo........oo << 326   G4EmModelManager*                     modelManager;
                                                   >> 327   std::vector<G4VSubCutoffProcessor*>   scoffProcessors;
                                                   >> 328   std::vector<const G4Region*>          scoffRegions;
                                                   >> 329   G4int                                 nSCoffRegions;
                                                   >> 330   std::vector<G4int>                    idxSCoffRegions;
                                                   >> 331 
                                                   >> 332   // tables and vectors
                                                   >> 333   G4PhysicsTable*  theDEDXTable;
                                                   >> 334   G4PhysicsTable*  theRangeTable;
                                                   >> 335   G4PhysicsTable*  theRangeTableForLoss;
                                                   >> 336   G4PhysicsTable*  theSecondaryRangeTable;
                                                   >> 337   G4PhysicsTable*  theInverseRangeTable;
                                                   >> 338   G4PhysicsTable*  theLambdaTable;
                                                   >> 339   G4PhysicsTable*  theSubLambdaTable;
                                                   >> 340   G4double*        theDEDXAtMaxEnergy;
                                                   >> 341   G4double*        theRangeAtMaxEnergy;
                                                   >> 342 
                                                   >> 343   const G4DataVector*         theCuts;
                                                   >> 344 
                                                   >> 345   const G4ParticleDefinition* particle;
                                                   >> 346   const G4ParticleDefinition* baseParticle;
                                                   >> 347   const G4ParticleDefinition* secondaryParticle;
                                                   >> 348 
                                                   >> 349   // cash
                                                   >> 350   const G4Material*           currentMaterial;
                                                   >> 351   const G4MaterialCutsCouple* currentCouple;
                                                   >> 352   size_t                      currentMaterialIndex;
                                                   >> 353   G4double                    minStepLimit;
                                                   >> 354 
                                                   >> 355   G4int    nDEDXBins;
                                                   >> 356   G4int    nDEDXBinsForRange;
                                                   >> 357   G4int    nLambdaBins;
675                                                   358 
676 inline G4double G4VEnergyLossProcess::ScaledKi << 359   G4double faclow;
677 {                                              << 360   G4double minKinEnergy;
678   //G4cout << "G4VEnergyLossProcess::GetEnergy << 361   G4double maxKinEnergy;
679   //         << basedCoupleIndex << " R(mm)= " << 362   G4double maxKinEnergyForRange;
680   //         << theInverseRangeTable << G4endl << 363   G4double lowKinEnergy;
681   G4PhysicsVector* v = (*theInverseRangeTable) << 
682   G4double rmin = v->Energy(0);                << 
683   G4double e = 0.0;                            << 
684   if(r >= rmin) { e = v->Value(r, idxInverseRa << 
685   else if(r > 0.0) {                           << 
686     G4double x = r/rmin;                       << 
687     e = minKinEnergy*x*x;                      << 
688   }                                            << 
689   return e;                                    << 
690 }                                              << 
691                                                   364 
692 //....oooOO0OOooo........oooOO0OOooo........oo << 365   G4double massRatio;
                                                   >> 366   G4double reduceFactor;
                                                   >> 367   G4double chargeSquare;
                                                   >> 368   G4double chargeSqRatio;
                                                   >> 369 
                                                   >> 370   G4double preStepLambda;
                                                   >> 371   G4double fRange;
                                                   >> 372   G4double preStepKinEnergy;
                                                   >> 373   G4double preStepScaledEnergy;
                                                   >> 374   G4double linLossLimit;
                                                   >> 375   G4double minSubRange;
                                                   >> 376   G4double dRoverRange;
                                                   >> 377   G4double finalRange;
                                                   >> 378   G4double defaultRoverRange;
                                                   >> 379   G4double defaultIntegralRange;
693                                                   380 
694 inline G4double G4VEnergyLossProcess::GetLambd << 381   G4bool lossFluctuationFlag;
695 {                                              << 382   G4bool rndmStepFlag;
696   return fFactor*((*theLambdaTable)[basedCoupl << 383   G4bool hasRestProcess;
697 }                                              << 384   G4bool tablesAreBuilt;
                                                   >> 385   G4bool integral;
                                                   >> 386   G4bool meanFreePath;
                                                   >> 387 };
698                                                   388 
699 //....oooOO0OOooo........oooOO0OOooo........oo    389 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
700                                                << 
701 inline G4double                                << 
702 G4VEnergyLossProcess::GetLambdaForScaledEnergy << 
703 {                                              << 
704   return fFactor*((*theLambdaTable)[basedCoupl << 
705 }                                              << 
706                                                << 
707 //....oooOO0OOooo........oooOO0OOooo........oo    390 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
708                                                   391 
709 inline G4double G4VEnergyLossProcess::LogScale << 392 inline void G4VEnergyLossProcess::DefineMaterial(const G4MaterialCutsCouple* couple)
710 {                                                 393 {
711   return track.GetDynamicParticle()->GetLogKin << 394   if(couple != currentCouple) {
                                                   >> 395     currentCouple   = couple;
                                                   >> 396     currentMaterial = couple->GetMaterial();
                                                   >> 397     currentMaterialIndex = couple->GetIndex();
                                                   >> 398     minStepLimit = std::min(finalRange,
                                                   >> 399            currentCouple->GetProductionCuts()->GetProductionCut(idxG4ElectronCut));
                                                   >> 400     if(integral && !meanFreePath) ResetNumberOfInteractionLengthLeft();
                                                   >> 401   }
712 }                                                 402 }
713                                                   403 
714 //....oooOO0OOooo........oooOO0OOooo........oo    404 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
715                                                   405 
716 inline G4double                                << 406 inline G4double G4VEnergyLossProcess::GetDEDX(G4double& kineticEnergy,
717 G4VEnergyLossProcess::GetDEDX(G4double kinEner << 407                                     const G4MaterialCutsCouple* couple)
718                               const G4Material << 
719 {                                                 408 {
720   DefineMaterial(couple);                         409   DefineMaterial(couple);
721   return GetDEDXForScaledEnergy(kinEnergy*mass << 410   G4bool b;
                                                   >> 411   return ((*theDEDXTable)[currentMaterialIndex]->
                                                   >> 412           GetValue(kineticEnergy*massRatio, b))*chargeSqRatio;
722 }                                                 413 }
723                                                   414 
724 //....oooOO0OOooo........oooOO0OOooo........oo    415 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
725                                                   416 
726 inline G4double                                << 417 inline G4double G4VEnergyLossProcess::GetRange(G4double& kineticEnergy,
727 G4VEnergyLossProcess::GetDEDX(G4double kinEner << 418                                             const G4MaterialCutsCouple* couple)
728                               const G4Material << 
729                               G4double logKinE << 
730 {                                                 419 {
731   DefineMaterial(couple);                         420   DefineMaterial(couple);
732   return GetDEDXForScaledEnergy(kinEnergy*mass << 421   G4bool b;
                                                   >> 422   G4double x;
                                                   >> 423   G4double e = kineticEnergy*massRatio;
                                                   >> 424   if (e < maxKinEnergyForRange) {
                                                   >> 425     x = ((*theRangeTable)[currentMaterialIndex])->GetValue(e, b);
                                                   >> 426   } else {
                                                   >> 427     x = theRangeAtMaxEnergy[currentMaterialIndex] +
                                                   >> 428       (e - maxKinEnergyForRange)/theDEDXAtMaxEnergy[currentMaterialIndex];
                                                   >> 429   }
                                                   >> 430   return x*reduceFactor;
733 }                                                 431 }
734                                                   432 
735 //....oooOO0OOooo........oooOO0OOooo........oo    433 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
736                                                   434 
737 inline G4double                                << 435 inline G4double G4VEnergyLossProcess::GetRangeForLoss(G4double& kineticEnergy,
738 G4VEnergyLossProcess::GetRange(G4double kinEne << 436                                             const G4MaterialCutsCouple* couple)
739                                const G4Materia << 
740 {                                                 437 {
741   DefineMaterial(couple);                         438   DefineMaterial(couple);
742   return GetScaledRangeForScaledEnergy(kinEner << 439   G4bool b;
                                                   >> 440   G4double e = kineticEnergy*massRatio;
                                                   >> 441   G4double x = ((*theRangeTableForLoss)[currentMaterialIndex])->GetValue(e, b);
                                                   >> 442   return x*reduceFactor;
743 }                                                 443 }
744                                                   444 
745 //....oooOO0OOooo........oooOO0OOooo........oo    445 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
746                                                   446 
747 inline G4double                                << 447 inline G4double G4VEnergyLossProcess::GetKineticEnergy(G4double& range,
748 G4VEnergyLossProcess::GetRange(G4double kinEne << 448                                              const G4MaterialCutsCouple* couple)
749                                const G4Materia << 
750                                G4double logKin << 
751 {                                                 449 {
752   DefineMaterial(couple);                         450   DefineMaterial(couple);
753   return GetScaledRangeForScaledEnergy(kinEner << 451   G4bool b;
                                                   >> 452   return ((*theInverseRangeTable)[currentMaterialIndex]->
                                                   >> 453          GetValue(range/reduceFactor, b))/massRatio;
754 }                                                 454 }
755                                                   455 
756 //....oooOO0OOooo........oooOO0OOooo........oo    456 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
757                                                   457 
758 inline G4double                                << 458 inline G4double G4VEnergyLossProcess::GetDEDXDispersion(
759 G4VEnergyLossProcess::GetCSDARange(G4double ki << 459                                   const G4MaterialCutsCouple *couple,
760                                    const G4Mat << 460                                   const G4DynamicParticle* dp,
                                                   >> 461                                         G4double& length)
761 {                                                 462 {
762   DefineMaterial(couple);                         463   DefineMaterial(couple);
763   return (nullptr == theCSDARangeTable) ? DBL_ << 464   G4double tmax = MaxSecondaryEnergy(dp);
764     GetLimitScaledRangeForScaledEnergy(kinetic << 465   tmax = std::min(tmax,(*theCuts)[currentMaterialIndex]);
                                                   >> 466   return modelManager->GetDEDXDispersion(currentMaterial, dp, tmax, length,
                                                   >> 467                        currentMaterialIndex);
765 }                                                 468 }
766                                                   469 
767 //....oooOO0OOooo........oooOO0OOooo........oo    470 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
768                                                   471 
769 inline G4double                                << 472 inline G4double G4VEnergyLossProcess::GetMeanFreePath(const G4Track& track,
770 G4VEnergyLossProcess::GetKineticEnergy(G4doubl << 473                                                         G4double,
771                                        const G << 474                                                         G4ForceCondition* cond)
772 {                                                 475 {
773   DefineMaterial(couple);                      << 476   *cond = NotForced;
774   return ScaledKinEnergyForLoss(range/reduceFa << 
775 }                                              << 
776                                                   477 
777 //....oooOO0OOooo........oooOO0OOooo........oo << 478   DefineMaterial(track.GetMaterialCutsCouple());
778                                                << 479   preStepKinEnergy = track.GetKineticEnergy();
779 inline G4double                                << 480   preStepScaledEnergy = preStepKinEnergy*massRatio;
780 G4VEnergyLossProcess::GetLambda(G4double kinEn << 481   if (meanFreePath) {
781                                 const G4Materi << 482     G4bool b;
782 {                                              << 483     preStepLambda = (((*theLambdaTable)[currentMaterialIndex])->
783   DefineMaterial(couple);                      << 484                       GetValue(preStepScaledEnergy, b)) * chargeSqRatio;
784   return (nullptr != theLambdaTable) ?         << 485     if (integral) meanFreePath = false;
785     GetLambdaForScaledEnergy(kinEnergy*massRat << 486   }
                                                   >> 487   G4double x = DBL_MAX;
                                                   >> 488   if(0.0 < preStepLambda) x = 1.0/preStepLambda;
                                                   >> 489 //  G4cout << GetProcessName() << ": e= " << preStepKinEnergy << " mfp= " << x << G4endl;
                                                   >> 490   return x;
786 }                                                 491 }
787                                                   492 
788 //....oooOO0OOooo........oooOO0OOooo........oo    493 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
789                                                   494 
790 inline G4double                                << 495 inline G4double G4VEnergyLossProcess::GetContinuousStepLimit(const G4Track&,
791 G4VEnergyLossProcess::GetLambda(G4double kinEn << 496                                   G4double, G4double currentMinStep, G4double&)
792                                 const G4Materi << 
793                                 G4double logKi << 
794 {                                                 497 {
795   DefineMaterial(couple);                      << 498   G4double x = DBL_MAX;
796   return (nullptr != theLambdaTable) ?         << 
797     GetLambdaForScaledEnergy(kinEnergy*massRat << 
798     :  0.0;                                    << 
799 }                                              << 
800                                                << 
801 // ======== Get/Set inline methods used at ini << 
802                                                << 
803 inline void G4VEnergyLossProcess::SetFluctMode << 
804 {                                              << 
805   fluctModel = p;                              << 
806 }                                              << 
807                                                   499 
808 //....oooOO0OOooo........oooOO0OOooo........oo << 500   if (theRangeTable) {
                                                   >> 501     //G4bool b;
                                                   >> 502     //    fRange = ((*theRangeTableForLoss)[currentMaterialIndex])->
                                                   >> 503     //        GetValue(preStepScaledEnergy, b)*reduceFactor;
                                                   >> 504     fRange = GetRange(preStepKinEnergy, currentCouple);
                                                   >> 505 
                                                   >> 506     x = fRange;
                                                   >> 507     G4double y = x*dRoverRange;
                                                   >> 508     if(x > minStepLimit && y < currentMinStep ) {
                                                   >> 509       if (integral) x = std::max(y,minStepLimit);
                                                   >> 510       else {
                                                   >> 511         x = y + minStepLimit*(1.0 - dRoverRange)*(2.0 - minStepLimit/fRange);
                                                   >> 512         if(x > fRange) x = fRange;
                                                   >> 513         if(rndmStepFlag) x = minStepLimit + (x-minStepLimit)*G4UniformRand();
                                                   >> 514       }
                                                   >> 515     }
                                                   >> 516   }
809                                                   517 
810 inline G4VEmFluctuationModel* G4VEnergyLossPro << 518   return x;
811 {                                              << 
812   return fluctModel;                           << 
813 }                                                 519 }
814                                                   520 
815 //....oooOO0OOooo........oooOO0OOooo........oo    521 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
816                                                   522 
817 inline void G4VEnergyLossProcess::SetParticle( << 523 inline void G4VEnergyLossProcess::ResetNumberOfInteractionLengthLeft()
818 {                                                 524 {
819   particle = p;                                << 525   meanFreePath = true;
                                                   >> 526   G4VProcess::ResetNumberOfInteractionLengthLeft();
820 }                                                 527 }
821                                                   528 
822 //....oooOO0OOooo........oooOO0OOooo........oo << 
823                                                << 
824 inline void                                    << 
825 G4VEnergyLossProcess::SetSecondaryParticle(con << 
826 {                                              << 
827   secondaryParticle = p;                       << 
828 }                                              << 
829                                                   529 
830 //....oooOO0OOooo........oooOO0OOooo........oo    530 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
831                                                   531 
832 inline void                                    << 532 inline G4VEmModel* G4VEnergyLossProcess::SelectModel(G4double& kinEnergy)
833 G4VEnergyLossProcess::SetBaseParticle(const G4 << 
834 {                                                 533 {
835   baseParticle = p;                            << 534   return modelManager->SelectModel(kinEnergy, currentMaterialIndex);
836 }                                                 535 }
837                                                   536 
838 //....oooOO0OOooo........oooOO0OOooo........oo    537 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
839                                                   538 
840 inline const G4ParticleDefinition* G4VEnergyLo    539 inline const G4ParticleDefinition* G4VEnergyLossProcess::Particle() const
841 {                                                 540 {
842   return particle;                                541   return particle;
843 }                                                 542 }
844                                                   543 
845 //....oooOO0OOooo........oooOO0OOooo........oo    544 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
846                                                   545 
847 inline const G4ParticleDefinition* G4VEnergyLo    546 inline const G4ParticleDefinition* G4VEnergyLossProcess::BaseParticle() const
848 {                                                 547 {
849   return baseParticle;                            548   return baseParticle;
850 }                                                 549 }
851                                                   550 
852 //....oooOO0OOooo........oooOO0OOooo........oo    551 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
853                                                   552 
854 inline const G4ParticleDefinition*             << 553 inline const G4ParticleDefinition* G4VEnergyLossProcess::SecondaryParticle() const
855 G4VEnergyLossProcess::SecondaryParticle() cons << 
856 {                                                 554 {
857   return secondaryParticle;                       555   return secondaryParticle;
858 }                                                 556 }
859                                                   557 
860 //....oooOO0OOooo........oooOO0OOooo........oo    558 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
861                                                   559 
862 inline void G4VEnergyLossProcess::SetLossFluct << 560 inline void G4VEnergyLossProcess::SetDEDXBinning(G4int nbins)
863 {                                              << 
864   lossFluctuationFlag = val;                   << 
865   actLossFluc = true;                          << 
866 }                                              << 
867                                                << 
868 //....oooOO0OOooo........oooOO0OOooo........oo << 
869                                                << 
870 inline void G4VEnergyLossProcess::SetSpline(G4 << 
871 {                                                 561 {
872   spline = val;                                << 562   nDEDXBins = nbins;
873 }                                                 563 }
874                                                   564 
875 //....oooOO0OOooo........oooOO0OOooo........oo    565 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
876                                                   566 
877 inline void G4VEnergyLossProcess::SetCrossSect << 567 inline void G4VEnergyLossProcess::SetDEDXBinningForPreciseRange(G4int nbins)
878 {                                                 568 {
879   fXSType = val;                               << 569   nDEDXBinsForRange = nbins;
880 }                                              << 
881                                                << 
882 //....oooOO0OOooo........oooOO0OOooo........oo << 
883                                                << 
884 inline G4CrossSectionType G4VEnergyLossProcess << 
885 {                                              << 
886   return fXSType;                              << 
887 }                                                 570 }
888                                                   571 
889 //....oooOO0OOooo........oooOO0OOooo........oo    572 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
890                                                   573 
891 inline G4bool G4VEnergyLossProcess::IsIonisati << 574 inline void G4VEnergyLossProcess::SetLambdaBinning(G4int nbins)
892 {                                                 575 {
893   return isIonisation;                         << 576   nLambdaBins = nbins;
894 }                                              << 
895                                                << 
896 //....oooOO0OOooo........oooOO0OOooo........oo << 
897                                                << 
898 inline G4int G4VEnergyLossProcess::NumberOfSub << 
899 {                                              << 
900   return nSCoffRegions;                        << 
901 }                                                 577 }
902                                                   578 
903 //....oooOO0OOooo........oooOO0OOooo........oo    579 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
904                                                   580 
905 inline G4double G4VEnergyLossProcess::MinKinEn    581 inline G4double G4VEnergyLossProcess::MinKinEnergy() const
906 {                                                 582 {
907   return minKinEnergy;                            583   return minKinEnergy;
908 }                                                 584 }
909                                                   585 
910 //....oooOO0OOooo........oooOO0OOooo........oo    586 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
911                                                   587 
912 inline G4double G4VEnergyLossProcess::MaxKinEn << 588 inline void G4VEnergyLossProcess::SetMinKinEnergy(G4double e)
913 {                                              << 
914   return maxKinEnergy;                         << 
915 }                                              << 
916                                                << 
917 //....oooOO0OOooo........oooOO0OOooo........oo << 
918                                                << 
919 inline G4double G4VEnergyLossProcess::CrossSec << 
920 {                                              << 
921   return biasFactor;                           << 
922 }                                              << 
923                                                << 
924 //....oooOO0OOooo........oooOO0OOooo........oo << 
925                                                << 
926 inline G4bool G4VEnergyLossProcess::TablesAreB << 
927 {                                                 589 {
928   return tablesAreBuilt;                       << 590   minKinEnergy = e;
                                                   >> 591   lowKinEnergy = minKinEnergy*faclow;
929 }                                                 592 }
930                                                   593 
931 //....oooOO0OOooo........oooOO0OOooo........oo    594 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
932                                                   595 
933 inline G4PhysicsTable* G4VEnergyLossProcess::D << 596 inline void G4VEnergyLossProcess::SetMaxKinEnergy(G4double e)
934 {                                                 597 {
935   return theDEDXTable;                         << 598   maxKinEnergy = e;
                                                   >> 599   if(e < maxKinEnergyForRange) maxKinEnergyForRange = e;
936 }                                                 600 }
937                                                   601 
938 //....oooOO0OOooo........oooOO0OOooo........oo    602 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
939                                                   603 
940 inline G4PhysicsTable* G4VEnergyLossProcess::D << 604 inline void G4VEnergyLossProcess::SetMaxKinEnergyForPreciseRange(G4double e)
941 {                                                 605 {
942   return theDEDXunRestrictedTable;             << 606   maxKinEnergyForRange = e;
943 }                                                 607 }
944                                                   608 
945 //....oooOO0OOooo........oooOO0OOooo........oo    609 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
946                                                   610 
947 inline G4PhysicsTable* G4VEnergyLossProcess::I << 611 inline G4double G4VEnergyLossProcess::MaxKinEnergy() const
948 {                                              << 
949   return theIonisationTable;                   << 
950 }                                              << 
951                                                << 
952 //....oooOO0OOooo........oooOO0OOooo........oo << 
953                                                << 
954 inline G4PhysicsTable* G4VEnergyLossProcess::C << 
955 {                                              << 
956   return theCSDARangeTable;                    << 
957 }                                              << 
958                                                << 
959 //....oooOO0OOooo........oooOO0OOooo........oo << 
960                                                << 
961 inline G4PhysicsTable* G4VEnergyLossProcess::R << 
962 {                                              << 
963   return theRangeTableForLoss;                 << 
964 }                                              << 
965                                                << 
966 //....oooOO0OOooo........oooOO0OOooo........oo << 
967                                                << 
968 inline G4PhysicsTable* G4VEnergyLossProcess::I << 
969 {                                              << 
970   return theInverseRangeTable;                 << 
971 }                                              << 
972                                                << 
973 //....oooOO0OOooo........oooOO0OOooo........oo << 
974                                                << 
975 inline G4PhysicsTable* G4VEnergyLossProcess::L << 
976 {                                              << 
977   return theLambdaTable;                       << 
978 }                                              << 
979                                                << 
980 //....oooOO0OOooo........oooOO0OOooo........oo << 
981                                                << 
982 inline G4bool G4VEnergyLossProcess::UseBaseMat << 
983 {                                              << 
984   return baseMat;                              << 
985 }                                              << 
986                                                << 
987 //....oooOO0OOooo........oooOO0OOooo........oo << 
988                                                << 
989 inline std::vector<G4double>*                  << 
990 G4VEnergyLossProcess::EnergyOfCrossSectionMax( << 
991 {                                              << 
992   return theEnergyOfCrossSectionMax;           << 
993 }                                              << 
994                                                << 
995 //....oooOO0OOooo........oooOO0OOooo........oo << 
996                                                << 
997 inline std::vector<G4TwoPeaksXS*>* G4VEnergyLo << 
998 {                                              << 
999   return fXSpeaks;                             << 
1000 }                                             << 
1001                                               << 
1002 //....oooOO0OOooo........oooOO0OOooo........o << 
1003                                               << 
1004 inline std::size_t G4VEnergyLossProcess::Numb << 
1005 {                                                612 {
1006   return numberOfModels;                      << 613   return maxKinEnergy;
1007 }                                                614 }
1008                                                  615 
1009 //....oooOO0OOooo........oooOO0OOooo........o    616 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1010                                                  617 
1011 inline G4VEmModel* G4VEnergyLossProcess::EmMo << 618 inline G4double G4VEnergyLossProcess::GetLambda(G4double kineticEnergy,
                                                   >> 619                                       const G4MaterialCutsCouple* couple)
1012 {                                                620 {
1013   return (index < emModels->size()) ? (*emMod << 621   DefineMaterial(couple);
                                                   >> 622   G4double x = DBL_MAX;
                                                   >> 623   G4bool b;
                                                   >> 624   if(theLambdaTable) {
                                                   >> 625     G4double y = (((*theLambdaTable)[currentMaterialIndex])->
                                                   >> 626                     GetValue(kineticEnergy*massRatio, b));
                                                   >> 627     if(y > 0.0) x = 1.0/y;
                                                   >> 628   }
                                                   >> 629   return x;
1014 }                                                630 }
1015                                                  631 
1016 //....oooOO0OOooo........oooOO0OOooo........o    632 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1017                                                  633 
1018 inline G4VEmModel*                            << 634 inline G4VSubCutoffProcessor* G4VEnergyLossProcess::SubCutoffProcessor(size_t index)
1019 G4VEnergyLossProcess::GetModelByIndex(std::si << 
1020 {                                                635 {
1021   return modelManager->GetModel((G4int)idx, v << 636   G4VSubCutoffProcessor* p = 0;
                                                   >> 637   if( nSCoffRegions ) p = scoffProcessors[idxSCoffRegions[index]];
                                                   >> 638   return p;
1022 }                                                639 }
1023                                                  640 
1024 //....oooOO0OOooo........oooOO0OOooo........o    641 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1025                                                  642 
1026 #endif                                           643 #endif
1027                                                  644