Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/utils/include/G4LossTableManager.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/G4LossTableManager.hh (Version 11.3.0) and /processes/electromagnetic/utils/include/G4LossTableManager.hh (Version 10.7.p3)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 // -------------------------------------------     26 // -------------------------------------------------------------------
 27 //                                                 27 //
 28 // GEANT4 Class header file                        28 // GEANT4 Class header file
 29 //                                                 29 //
 30 //                                                 30 //
 31 // File name:     G4LossTableManager               31 // File name:     G4LossTableManager
 32 //                                                 32 //
 33 // Author:        Vladimir Ivanchenko on base      33 // Author:        Vladimir Ivanchenko on base of G4LossTables class
 34 //                and Maria Grazia Pia ideas       34 //                and Maria Grazia Pia ideas
 35 //                                                 35 //
 36 // Creation date: 03.01.2002                       36 // Creation date: 03.01.2002
 37 //                                                 37 //
 38 // Modifications by V.Ivanchenko                   38 // Modifications by V.Ivanchenko  
 39 //                                                 39 //
 40 // Class Description:                              40 // Class Description:
 41 //                                                 41 //
 42 // A utility static class, responsable for the     42 // A utility static class, responsable for the energy loss tables
 43 // for each particle                               43 // for each particle
 44 //                                                 44 //
 45 // Energy loss processes have to register thei     45 // Energy loss processes have to register their tables with this
 46 // class. The responsibility of creating and d     46 // class. The responsibility of creating and deleting the tables
 47 // remains with the energy loss classes.           47 // remains with the energy loss classes.
 48                                                    48 
 49 // -------------------------------------------     49 // -------------------------------------------------------------------
 50 //                                                 50 //
 51                                                    51 
 52 #ifndef G4LossTableManager_h                       52 #ifndef G4LossTableManager_h
 53 #define G4LossTableManager_h 1                     53 #define G4LossTableManager_h 1
 54                                                    54 
 55 #include <map>                                     55 #include <map>
 56 #include <vector>                                  56 #include <vector>
 57 #include "globals.hh"                              57 #include "globals.hh"
 58 #include "G4ThreadLocalSingleton.hh"               58 #include "G4ThreadLocalSingleton.hh"
 59 #include "G4VEnergyLossProcess.hh"                 59 #include "G4VEnergyLossProcess.hh"
 60 #include "G4EmParameters.hh"                   << 
 61                                                    60 
 62 class G4PhysicsTable;                              61 class G4PhysicsTable;
 63 class G4MaterialCutsCouple;                        62 class G4MaterialCutsCouple;
 64 class G4ParticleDefinition;                        63 class G4ParticleDefinition;
 65 class G4Region;                                    64 class G4Region;
 66 class G4EmSaturation;                              65 class G4EmSaturation;
 67 class G4EmConfigurator;                            66 class G4EmConfigurator;
 68 class G4ElectronIonPair;                           67 class G4ElectronIonPair;
 69 class G4NIELCalculator;                            68 class G4NIELCalculator;
 70 class G4VMultipleScattering;                       69 class G4VMultipleScattering;
 71 class G4VEmProcess;                                70 class G4VEmProcess;
 72 class G4EmCorrections;                             71 class G4EmCorrections;
 73 class G4LossTableBuilder;                          72 class G4LossTableBuilder;
 74 class G4VAtomDeexcitation;                         73 class G4VAtomDeexcitation;
 75 class G4VSubCutProducer;                           74 class G4VSubCutProducer;
 76                                                    75 
 77 class G4LossTableManager                           76 class G4LossTableManager
 78 {                                                  77 {
 79                                                    78 
 80 friend class G4ThreadLocalSingleton<G4LossTabl     79 friend class G4ThreadLocalSingleton<G4LossTableManager>;
 81                                                    80 
 82 public:                                            81 public:
 83                                                    82 
 84   static G4LossTableManager* Instance();           83   static G4LossTableManager* Instance();
 85                                                    84 
 86   ~G4LossTableManager();                           85   ~G4LossTableManager();
 87                                                    86 
 88   //------------------------------------------     87   //-------------------------------------------------
 89   // initialisation before a new run               88   // initialisation before a new run
 90   //------------------------------------------     89   //-------------------------------------------------
 91                                                    90 
 92   void PreparePhysicsTable(const G4ParticleDef     91   void PreparePhysicsTable(const G4ParticleDefinition* aParticle,
 93                            G4VEnergyLossProces <<  92                            G4VEnergyLossProcess* p, G4bool theMaster);
 94                                                    93 
 95   void PreparePhysicsTable(const G4ParticleDef     94   void PreparePhysicsTable(const G4ParticleDefinition* aParticle,
 96                            G4VEmProcess* p);   <<  95                            G4VEmProcess* p, G4bool theMaster);
 97                                                    96 
 98   void PreparePhysicsTable(const G4ParticleDef     97   void PreparePhysicsTable(const G4ParticleDefinition* aParticle,
 99                            G4VMultipleScatteri <<  98                            G4VMultipleScattering* p, G4bool theMaster);
100                                                    99 
101   void BuildPhysicsTable(const G4ParticleDefin    100   void BuildPhysicsTable(const G4ParticleDefinition* aParticle);
102                                                   101 
103   void BuildPhysicsTable(const G4ParticleDefin    102   void BuildPhysicsTable(const G4ParticleDefinition* aParticle, 
104                          G4VEnergyLossProcess*    103                          G4VEnergyLossProcess* p);
105                                                   104 
106   void LocalPhysicsTables(const G4ParticleDefi    105   void LocalPhysicsTables(const G4ParticleDefinition* aParticle, 
107                           G4VEnergyLossProcess    106                           G4VEnergyLossProcess* p);
108                                                   107  
109   void DumpHtml();                                108   void DumpHtml();
110                                                   109 
111   //------------------------------------------    110   //-------------------------------------------------
112   // Run time access to DEDX, range, energy fo    111   // Run time access to DEDX, range, energy for a given particle, 
113   // energy, and G4MaterialCutsCouple             112   // energy, and G4MaterialCutsCouple
114   //------------------------------------------    113   //-------------------------------------------------
115                                                   114 
116   inline G4double GetDEDX(                        115   inline G4double GetDEDX(
117     const G4ParticleDefinition *aParticle,        116     const G4ParticleDefinition *aParticle,
118     G4double kineticEnergy,                       117     G4double kineticEnergy,
119     const G4MaterialCutsCouple *couple);          118     const G4MaterialCutsCouple *couple);
120                                                   119 
                                                   >> 120   inline G4double GetSubDEDX(
                                                   >> 121     const G4ParticleDefinition *aParticle,
                                                   >> 122     G4double kineticEnergy,
                                                   >> 123     const G4MaterialCutsCouple *couple);
                                                   >> 124 
121   inline G4double GetRange(                       125   inline G4double GetRange(
122     const G4ParticleDefinition *aParticle,        126     const G4ParticleDefinition *aParticle,
123     G4double kineticEnergy,                       127     G4double kineticEnergy,
124     const G4MaterialCutsCouple *couple);          128     const G4MaterialCutsCouple *couple);
125                                                   129 
126   inline G4double GetCSDARange(                   130   inline G4double GetCSDARange(
127     const G4ParticleDefinition *aParticle,        131     const G4ParticleDefinition *aParticle,
128     G4double kineticEnergy,                       132     G4double kineticEnergy,
129     const G4MaterialCutsCouple *couple);          133     const G4MaterialCutsCouple *couple);
130                                                   134 
131   inline G4double GetRangeFromRestricteDEDX(      135   inline G4double GetRangeFromRestricteDEDX(
132     const G4ParticleDefinition *aParticle,        136     const G4ParticleDefinition *aParticle,
133     G4double kineticEnergy,                       137     G4double kineticEnergy,
134     const G4MaterialCutsCouple *couple);          138     const G4MaterialCutsCouple *couple);
135                                                   139 
136   inline G4double GetEnergy(                      140   inline G4double GetEnergy(
137     const G4ParticleDefinition *aParticle,        141     const G4ParticleDefinition *aParticle,
138     G4double range,                               142     G4double range,
139     const G4MaterialCutsCouple *couple);          143     const G4MaterialCutsCouple *couple);
140                                                   144 
141   inline G4double GetDEDXDispersion(              145   inline G4double GetDEDXDispersion(
142     const G4MaterialCutsCouple *couple,           146     const G4MaterialCutsCouple *couple,
143     const G4DynamicParticle* dp,                  147     const G4DynamicParticle* dp,
144           G4double& length);                      148           G4double& length);
145                                                   149 
146   //------------------------------------------    150   //-------------------------------------------------
147   // Methods to be called only at initialisati    151   // Methods to be called only at initialisation
148   // and at the end of the job                    152   // and at the end of the job
149   //------------------------------------------    153   //-------------------------------------------------
150                                                   154 
151   void Register(G4VEnergyLossProcess* p);         155   void Register(G4VEnergyLossProcess* p);
152                                                   156 
153   void DeRegister(G4VEnergyLossProcess* p);       157   void DeRegister(G4VEnergyLossProcess* p);
154                                                   158 
155   void Register(G4VMultipleScattering* p);        159   void Register(G4VMultipleScattering* p);
156                                                   160 
157   void DeRegister(G4VMultipleScattering* p);      161   void DeRegister(G4VMultipleScattering* p);
158                                                   162 
159   void Register(G4VEmProcess* p);                 163   void Register(G4VEmProcess* p);
160                                                   164 
161   void DeRegister(G4VEmProcess* p);               165   void DeRegister(G4VEmProcess* p);
162                                                   166 
163   void Register(G4VProcess* p);                   167   void Register(G4VProcess* p);
164                                                   168 
165   void DeRegister(G4VProcess* p);                 169   void DeRegister(G4VProcess* p);
166                                                   170 
167   void Register(G4VEmModel* p);                   171   void Register(G4VEmModel* p);
168                                                   172 
169   void DeRegister(G4VEmModel* p);                 173   void DeRegister(G4VEmModel* p);
170                                                   174 
171   void Register(G4VEmFluctuationModel* p);        175   void Register(G4VEmFluctuationModel* p);
172                                                   176 
173   void DeRegister(G4VEmFluctuationModel* p);      177   void DeRegister(G4VEmFluctuationModel* p);
174                                                   178 
175   void RegisterExtraParticle(const G4ParticleD    179   void RegisterExtraParticle(const G4ParticleDefinition* aParticle, 
176                              G4VEnergyLossProc    180                              G4VEnergyLossProcess* p);
177                                                   181 
178   void SetVerbose(G4int val);                     182   void SetVerbose(G4int val);
179                                                   183 
180   void ResetParameters();                         184   void ResetParameters();
181                                                   185 
182   void SetAtomDeexcitation(G4VAtomDeexcitation    186   void SetAtomDeexcitation(G4VAtomDeexcitation*);
183                                                   187 
184   void SetSubCutProducer(G4VSubCutProducer*);     188   void SetSubCutProducer(G4VSubCutProducer*);
185                                                   189 
186   void SetNIELCalculator(G4NIELCalculator*);      190   void SetNIELCalculator(G4NIELCalculator*);
187                                                   191 
188   //------------------------------------------    192   //-------------------------------------------------
189   // Access methods                               193   // Access methods
190   //------------------------------------------    194   //-------------------------------------------------
191                                                   195 
192   inline G4bool IsMaster() const;                 196   inline G4bool IsMaster() const;
193                                                   197 
194   G4VEnergyLossProcess* GetEnergyLossProcess(c    198   G4VEnergyLossProcess* GetEnergyLossProcess(const G4ParticleDefinition*);
195                                                   199  
196   const std::vector<G4VEnergyLossProcess*>& Ge    200   const std::vector<G4VEnergyLossProcess*>& GetEnergyLossProcessVector();
197                                                   201 
198   const std::vector<G4VEmProcess*>& GetEmProce    202   const std::vector<G4VEmProcess*>& GetEmProcessVector();
199                                                   203 
200   const std::vector<G4VMultipleScattering*>& G    204   const std::vector<G4VMultipleScattering*>& GetMultipleScatteringVector();
201                                                   205 
202   G4EmSaturation* EmSaturation();                 206   G4EmSaturation* EmSaturation();
203                                                   207 
204   G4EmConfigurator* EmConfigurator();             208   G4EmConfigurator* EmConfigurator();
205                                                   209 
206   G4ElectronIonPair* ElectronIonPair();           210   G4ElectronIonPair* ElectronIonPair();
207                                                   211 
208   G4NIELCalculator* NIELCalculator();             212   G4NIELCalculator* NIELCalculator();
209                                                   213 
210   inline G4EmCorrections* EmCorrections();        214   inline G4EmCorrections* EmCorrections();
211                                                   215 
212   inline G4VAtomDeexcitation* AtomDeexcitation    216   inline G4VAtomDeexcitation* AtomDeexcitation();
213                                                   217 
214   inline G4VSubCutProducer* SubCutProducer();     218   inline G4VSubCutProducer* SubCutProducer();
215                                                   219 
216   inline G4LossTableBuilder* GetTableBuilder()    220   inline G4LossTableBuilder* GetTableBuilder();
217                                                   221 
218   inline void SetGammaGeneralProcess(G4VEmProc    222   inline void SetGammaGeneralProcess(G4VEmProcess*); 
219                                                   223 
220   inline G4VEmProcess* GetGammaGeneralProcess(    224   inline G4VEmProcess* GetGammaGeneralProcess(); 
221                                                   225 
222   inline void SetElectronGeneralProcess(G4VEmP    226   inline void SetElectronGeneralProcess(G4VEmProcess*); 
223                                                   227 
224   inline G4VEmProcess* GetElectronGeneralProce    228   inline G4VEmProcess* GetElectronGeneralProcess(); 
225                                                   229 
226   inline void SetPositronGeneralProcess(G4VEmP    230   inline void SetPositronGeneralProcess(G4VEmProcess*); 
227                                                   231 
228   inline G4VEmProcess* GetPositronGeneralProce    232   inline G4VEmProcess* GetPositronGeneralProcess(); 
229                                                   233 
230   G4LossTableManager(G4LossTableManager &) = d << 
231   G4LossTableManager & operator=(const G4LossT << 
232                                                << 
233 private:                                          234 private:
234                                                   235 
235   //------------------------------------------    236   //-------------------------------------------------
236   // Private methods and members                  237   // Private methods and members
237   //------------------------------------------    238   //-------------------------------------------------
238                                                   239 
239   G4LossTableManager();                           240   G4LossTableManager();
240                                                   241 
241   void Clear();                                   242   void Clear();
242                                                   243 
243   G4VEnergyLossProcess* BuildTables(const G4Pa    244   G4VEnergyLossProcess* BuildTables(const G4ParticleDefinition* aParticle);
244                                                   245 
245   void CopyTables(const G4ParticleDefinition*     246   void CopyTables(const G4ParticleDefinition* aParticle, 
246                   G4VEnergyLossProcess*);         247                   G4VEnergyLossProcess*);
247                                                   248 
248   void ParticleHaveNoLoss(const G4ParticleDefi    249   void ParticleHaveNoLoss(const G4ParticleDefinition* aParticle);
249                                                   250 
250   void CopyDEDXTables();                          251   void CopyDEDXTables();
251                                                   252 
252   void PrintEWarning(G4String, G4double);         253   void PrintEWarning(G4String, G4double);
253                                                   254 
                                                   >> 255   G4LossTableManager(G4LossTableManager &) = delete;
                                                   >> 256   G4LossTableManager & operator=(const G4LossTableManager &right) = delete;
                                                   >> 257 
254   static G4ThreadLocal G4LossTableManager* ins    258   static G4ThreadLocal G4LossTableManager* instance;
255                                                   259 
256   typedef const G4ParticleDefinition* PD;         260   typedef const G4ParticleDefinition* PD;
257                                                   261 
258   // cache                                     << 262   std::map<PD,G4VEnergyLossProcess*,std::less<PD> > loss_map;
259   G4VEnergyLossProcess* currentLoss{nullptr};  << 
260   PD currentParticle{nullptr};                 << 
261   PD theElectron;                              << 
262   PD theGenericIon{nullptr};                   << 
263   PD firstParticle{nullptr};                   << 
264                                                << 
265   G4LossTableBuilder* tableBuilder;            << 
266   G4EmCorrections* emCorrections;              << 
267   G4EmConfigurator* emConfigurator{nullptr};   << 
268   G4ElectronIonPair* emElectronIonPair{nullptr << 
269   G4NIELCalculator* nielCalculator{nullptr};   << 
270   G4VAtomDeexcitation* atomDeexcitation{nullpt << 
271   G4VSubCutProducer* subcutProducer{nullptr};  << 
272                                                << 
273   G4EmParameters* theParameters;               << 
274   G4VEmProcess* gGeneral{nullptr};             << 
275   G4VEmProcess* eGeneral{nullptr};             << 
276   G4VEmProcess* pGeneral{nullptr};             << 
277                                                << 
278   G4int verbose;                               << 
279   G4int n_loss{0};                             << 
280   G4int run{-1};                               << 
281                                                << 
282   G4bool all_tables_are_built{false};          << 
283   G4bool startInitialisation{false};           << 
284   G4bool resetParam{true};                     << 
285   G4bool isMaster{false};                      << 
286                                                   263 
287   std::vector<G4VEnergyLossProcess*> loss_vect    264   std::vector<G4VEnergyLossProcess*> loss_vector;
288   std::vector<PD> part_vector;                    265   std::vector<PD> part_vector;
289   std::vector<PD> base_part_vector;               266   std::vector<PD> base_part_vector;
                                                   >> 267   std::vector<G4bool> tables_are_built;
                                                   >> 268   std::vector<G4bool> isActive;
290   std::vector<G4PhysicsTable*> dedx_vector;       269   std::vector<G4PhysicsTable*> dedx_vector;
291   std::vector<G4PhysicsTable*> range_vector;      270   std::vector<G4PhysicsTable*> range_vector;
292   std::vector<G4PhysicsTable*> inv_range_vecto    271   std::vector<G4PhysicsTable*> inv_range_vector;
293   std::vector<G4bool> tables_are_built;        << 
294   std::vector<G4bool> isActive;                << 
295   std::vector<G4VMultipleScattering*> msc_vect    272   std::vector<G4VMultipleScattering*> msc_vector;
296   std::vector<G4VEmProcess*> emp_vector;          273   std::vector<G4VEmProcess*> emp_vector;
297   std::vector<G4VEmModel*> mod_vector;            274   std::vector<G4VEmModel*> mod_vector;
298   std::vector<G4VEmFluctuationModel*> fmod_vec    275   std::vector<G4VEmFluctuationModel*> fmod_vector;
299   std::vector<G4VProcess*> p_vector;              276   std::vector<G4VProcess*> p_vector;
300                                                   277 
301   std::map<PD,G4VEnergyLossProcess*,std::less< << 278   // cache
                                                   >> 279   G4VEnergyLossProcess* currentLoss;
                                                   >> 280   PD                    currentParticle;
                                                   >> 281   PD                    theElectron;
                                                   >> 282   PD                    theGenericIon;
                                                   >> 283   PD                    firstParticle;
                                                   >> 284 
                                                   >> 285   G4int n_loss;
                                                   >> 286   G4int run;
                                                   >> 287 
                                                   >> 288   G4bool all_tables_are_built;
                                                   >> 289   G4bool startInitialisation;
                                                   >> 290   G4bool isMaster;
                                                   >> 291   G4LossTableBuilder*         tableBuilder;
                                                   >> 292   G4EmCorrections*            emCorrections;
                                                   >> 293   G4EmConfigurator*           emConfigurator;
                                                   >> 294   G4ElectronIonPair*          emElectronIonPair;
                                                   >> 295   G4NIELCalculator*           nielCalculator;
                                                   >> 296   G4VAtomDeexcitation*        atomDeexcitation;
                                                   >> 297   G4VSubCutProducer*          subcutProducer;
                                                   >> 298 
                                                   >> 299   G4EmParameters*       theParameters;
                                                   >> 300   G4VEmProcess*         gGeneral;
                                                   >> 301   G4VEmProcess*           eGeneral;
                                                   >> 302   G4VEmProcess*           pGeneral;
                                                   >> 303 
                                                   >> 304   G4int verbose;
302 };                                                305 };
303                                                   306 
304 //....oooOO0OOooo........oooOO0OOooo........oo    307 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
305 //....oooOO0OOooo........oooOO0OOooo........oo    308 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
306                                                   309 
307 inline                                            310 inline
308 G4double G4LossTableManager::GetDEDX(const G4P    311 G4double G4LossTableManager::GetDEDX(const G4ParticleDefinition *aParticle,
309                                      G4double     312                                      G4double kineticEnergy,
310                                      const G4M    313                                      const G4MaterialCutsCouple *couple)
311 {                                                 314 {
312   if(aParticle != currentParticle) { GetEnergy    315   if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
313   return currentLoss ? currentLoss->GetDEDX(ki    316   return currentLoss ? currentLoss->GetDEDX(kineticEnergy, couple) : 0.0;
314 }                                                 317 }
315                                                   318 
316 //....oooOO0OOooo........oooOO0OOooo........oo    319 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
317                                                   320 
318 inline                                            321 inline
                                                   >> 322 G4double G4LossTableManager::GetSubDEDX(const G4ParticleDefinition *aParticle,
                                                   >> 323                                         G4double kineticEnergy,
                                                   >> 324                                         const G4MaterialCutsCouple *couple)
                                                   >> 325 {
                                                   >> 326   if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
                                                   >> 327   return currentLoss ? currentLoss->GetDEDXForSubsec(kineticEnergy, couple) : 0.0;
                                                   >> 328 }
                                                   >> 329 
                                                   >> 330 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
                                                   >> 331 
                                                   >> 332 inline
319 G4double G4LossTableManager::GetCSDARange(cons    333 G4double G4LossTableManager::GetCSDARange(const G4ParticleDefinition *aParticle,
320                                           G4do    334                                           G4double kineticEnergy,
321                                           cons    335                                           const G4MaterialCutsCouple *couple)
322 {                                                 336 {
323   if(aParticle != currentParticle) { GetEnergy    337   if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
324   return currentLoss ? currentLoss->GetCSDARan    338   return currentLoss ? currentLoss->GetCSDARange(kineticEnergy, couple) : DBL_MAX;
325 }                                                 339 }
326                                                   340 
327 //....oooOO0OOooo........oooOO0OOooo........oo    341 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
328                                                   342 
329 inline                                            343 inline
330 G4double G4LossTableManager::GetRangeFromRestr    344 G4double G4LossTableManager::GetRangeFromRestricteDEDX(
331                              const G4ParticleD    345                              const G4ParticleDefinition *aParticle,
332                              G4double kineticE    346                              G4double kineticEnergy,
333                              const G4MaterialC    347                              const G4MaterialCutsCouple *couple)
334 {                                                 348 {
335   if(aParticle != currentParticle) { GetEnergy    349   if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
336   return currentLoss ? currentLoss->GetRange(k << 350   return currentLoss ? currentLoss->GetRangeForLoss(kineticEnergy, couple) : DBL_MAX;
337 }                                                 351 }
338                                                   352 
339 //....oooOO0OOooo........oooOO0OOooo........oo    353 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
340                                                   354 
341 inline                                            355 inline
342 G4double G4LossTableManager::GetRange(const G4    356 G4double G4LossTableManager::GetRange(const G4ParticleDefinition *aParticle,
343                                       G4double    357                                       G4double kineticEnergy,
344                                       const G4    358                                       const G4MaterialCutsCouple *couple)
345 {                                                 359 {
346   if(aParticle != currentParticle) { GetEnergy    360   if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
347   return currentLoss ? currentLoss->GetRange(k    361   return currentLoss ? currentLoss->GetRange(kineticEnergy, couple) : DBL_MAX;
348 }                                                 362 }
349                                                   363 
350 //....oooOO0OOooo........oooOO0OOooo........oo    364 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
351                                                   365 
352 inline                                            366 inline
353 G4double G4LossTableManager::GetEnergy(const G    367 G4double G4LossTableManager::GetEnergy(const G4ParticleDefinition *aParticle,
354                                        G4doubl    368                                        G4double range,
355                                        const G    369                                        const G4MaterialCutsCouple *couple)
356 {                                                 370 {
357   if(aParticle != currentParticle) { GetEnergy    371   if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
358   return currentLoss ? currentLoss->GetKinetic    372   return currentLoss ? currentLoss->GetKineticEnergy(range, couple) : 0.0;
359 }                                                 373 }
360                                                   374 
361 //....oooOO0OOooo........oooOO0OOooo........oo    375 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
362                                                   376 
363 inline                                            377 inline
364 G4double G4LossTableManager::GetDEDXDispersion    378 G4double G4LossTableManager::GetDEDXDispersion(
365                              const G4MaterialC    379                              const G4MaterialCutsCouple *couple,
366                              const G4DynamicPa    380                              const G4DynamicParticle* dp,
367                              G4double& length)    381                              G4double& length)
368 {                                                 382 {
369   const G4ParticleDefinition* aParticle = dp->    383   const G4ParticleDefinition* aParticle = dp->GetParticleDefinition();
370   if(aParticle != currentParticle) { GetEnergy    384   if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
371   return currentLoss ? currentLoss->GetDEDXDis    385   return currentLoss ? currentLoss->GetDEDXDispersion(couple, dp, length) : 0.0;
372 }                                                 386 }
373                                                   387 
374 //....oooOO0OOooo........oooOO0OOooo........oo    388 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
375                                                   389 
376 inline G4bool G4LossTableManager::IsMaster() c    390 inline G4bool G4LossTableManager::IsMaster() const
377 {                                                 391 {
378   return isMaster;                                392   return isMaster;
379 }                                                 393 }
380                                                   394 
381 //....oooOO0OOooo........oooOO0OOooo........oo    395 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
382                                                   396 
383 inline G4EmCorrections* G4LossTableManager::Em    397 inline G4EmCorrections* G4LossTableManager::EmCorrections() 
384 {                                                 398 {
385   return emCorrections;                           399   return emCorrections;
386 }                                                 400 }
387                                                   401 
388 //....oooOO0OOooo........oooOO0OOooo........oo    402 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
389                                                   403 
390 inline G4VAtomDeexcitation* G4LossTableManager    404 inline G4VAtomDeexcitation* G4LossTableManager::AtomDeexcitation()
391 {                                                 405 {
392   return atomDeexcitation;                        406   return atomDeexcitation;
393 }                                                 407 }
394                                                   408 
395 //....oooOO0OOooo........oooOO0OOooo........oo    409 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
396                                                   410 
397 inline G4VSubCutProducer* G4LossTableManager::    411 inline G4VSubCutProducer* G4LossTableManager::SubCutProducer()
398 {                                                 412 { 
399   return subcutProducer;                          413   return subcutProducer;
400 }                                                 414 }
401                                                   415 
402 //....oooOO0OOooo........oooOO0OOooo........oo    416 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
403                                                   417 
404 inline G4LossTableBuilder* G4LossTableManager:    418 inline G4LossTableBuilder* G4LossTableManager::GetTableBuilder()
405 {                                                 419 {
406   return tableBuilder;                            420   return tableBuilder;
407 }                                                 421 }
408                                                   422 
409 //....oooOO0OOooo........oooOO0OOooo........oo    423 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
410                                                   424 
411 inline void G4LossTableManager::SetGammaGenera    425 inline void G4LossTableManager::SetGammaGeneralProcess(G4VEmProcess* ptr)
412 {                                                 426 {
413   gGeneral = ptr;                                 427   gGeneral = ptr;
414 }                                                 428 } 
415                                                   429 
416 //....oooOO0OOooo........oooOO0OOooo........oo    430 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
417                                                   431 
418 inline G4VEmProcess* G4LossTableManager::GetGa    432 inline G4VEmProcess* G4LossTableManager::GetGammaGeneralProcess()
419 {                                                 433 {
420   return gGeneral;                                434   return gGeneral;
421 }                                                 435 } 
422                                                   436 
423 //....oooOO0OOooo........oooOO0OOooo........oo    437 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
424                                                   438 
425 inline void G4LossTableManager::SetElectronGen    439 inline void G4LossTableManager::SetElectronGeneralProcess(G4VEmProcess* ptr)
426 {                                                 440 {
427   eGeneral = ptr;                                 441   eGeneral = ptr;
428 }                                                 442 } 
429                                                   443 
430 //....oooOO0OOooo........oooOO0OOooo........oo    444 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
431                                                   445 
432 inline G4VEmProcess* G4LossTableManager::GetEl    446 inline G4VEmProcess* G4LossTableManager::GetElectronGeneralProcess()
433 {                                                 447 {
434   return eGeneral;                                448   return eGeneral;
435 }                                                 449 } 
436                                                   450 
437 //....oooOO0OOooo........oooOO0OOooo........oo    451 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
438                                                   452 
439 inline void G4LossTableManager::SetPositronGen    453 inline void G4LossTableManager::SetPositronGeneralProcess(G4VEmProcess* ptr)
440 {                                                 454 {
441   pGeneral = ptr;                                 455   pGeneral = ptr;
442 }                                                 456 } 
443                                                   457 
444 //....oooOO0OOooo........oooOO0OOooo........oo    458 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
445                                                   459 
446 inline G4VEmProcess* G4LossTableManager::GetPo    460 inline G4VEmProcess* G4LossTableManager::GetPositronGeneralProcess()
447 {                                                 461 {
448   return pGeneral;                                462   return pGeneral;
449 }                                                 463 } 
450 //....oooOO0OOooo........oooOO0OOooo........oo    464 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
451                                                   465 
452 #endif                                            466 #endif
                                                   >> 467 
453                                                   468