Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/utils/include/G4EmModelManager.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/G4EmModelManager.hh (Version 11.3.0) and /processes/electromagnetic/utils/include/G4EmModelManager.hh (Version 9.4.p4)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
                                                   >>  26 // $Id: G4EmModelManager.hh,v 1.34 2009-08-11 10:29:30 vnivanch Exp $
                                                   >>  27 // GEANT4 tag $Name: not supported by cvs2svn $
 26 //                                                 28 //
 27 // -------------------------------------------     29 // -------------------------------------------------------------------
 28 //                                                 30 //
 29 // GEANT4 Class header file                        31 // GEANT4 Class header file
 30 //                                                 32 //
 31 // File name:     G4EmModelManager                 33 // File name:     G4EmModelManager
 32 //                                                 34 //
 33 // Author:        Vladimir Ivanchenko              35 // Author:        Vladimir Ivanchenko
 34 //                                                 36 //
 35 // Creation date: 07.05.2002                       37 // Creation date: 07.05.2002
 36 //                                                 38 //
 37 // Modifications:                                  39 // Modifications:
 38 //                                                 40 //
 39 // 03-12-02 V.Ivanchenko fix a bug in model se     41 // 03-12-02 V.Ivanchenko fix a bug in model selection
 40 // 20-01-03 Migrade to cut per region (V.Ivanc     42 // 20-01-03 Migrade to cut per region (V.Ivanchenko)
 41 // 27-01-03 Make models region aware (V.Ivanch     43 // 27-01-03 Make models region aware (V.Ivanchenko)
 42 // 13-02-03 The set of models is defined for r     44 // 13-02-03 The set of models is defined for region (V.Ivanchenko)
 43 // 26-03-03 Add GetDEDXDispersion (V.Ivanchenk     45 // 26-03-03 Add GetDEDXDispersion (V.Ivanchenko)
 44 // 13-04-03 Add startFromNull (V.Ivanchenko)       46 // 13-04-03 Add startFromNull (V.Ivanchenko)
 45 // 13-05-03 Add calculation of precise range (     47 // 13-05-03 Add calculation of precise range (V.Ivanchenko)
 46 // 21-07-03 Add UpdateEmModel method (V.Ivanch     48 // 21-07-03 Add UpdateEmModel method (V.Ivanchenko)
 47 // 03-11-03 Substitute STL vector for G4Region     49 // 03-11-03 Substitute STL vector for G4RegionModels (V.Ivanchenko)
 48 // 11-04-05 Remove access to fluctuation model     50 // 11-04-05 Remove access to fluctuation models (V.Ivanchenko)
 49 // 10-01-06 PreciseRange -> CSDARange (V.Ivant     51 // 10-01-06 PreciseRange -> CSDARange (V.Ivantchenko)
 50 // 20-01-06 Introduce G4EmTableType and reduci     52 // 20-01-06 Introduce G4EmTableType and reducing number of methods (VI)
 51 // 13-05-06 Add GetModel by index method (VI)      53 // 13-05-06 Add GetModel by index method (VI)
 52 // 15-03-07 Add maxCutInRange (V.Ivanchenko)       54 // 15-03-07 Add maxCutInRange (V.Ivanchenko)
 53 // 08-04-08 Simplify Select method for only on     55 // 08-04-08 Simplify Select method for only one G4RegionModel (VI)
 54 // 03-08-09 Removed unused members and simplif     56 // 03-08-09 Removed unused members and simplify model search if only one
 55 //          model is used (VI)                     57 //          model is used (VI)
 56 // 14-07-11 Use pointer to the vector of cuts  << 
 57 //                                                 58 //
 58 // Class Description:                              59 // Class Description:
 59 //                                                 60 //
 60 // It is the unified energy loss process it ca     61 // It is the unified energy loss process it calculates the continuous
 61 // energy loss for charged particles using a s     62 // energy loss for charged particles using a set of Energy Loss
 62 // models valid for different energy regions.      63 // models valid for different energy regions. There are a possibility
 63 // to create and access to dE/dx and range tab     64 // to create and access to dE/dx and range tables, or to calculate
 64 // that information on fly.                        65 // that information on fly.
 65                                                    66 
 66 // -------------------------------------------     67 // -------------------------------------------------------------------
 67 //                                                 68 //
 68                                                    69 
                                                   >>  70 
 69 #ifndef G4EmModelManager_h                         71 #ifndef G4EmModelManager_h
 70 #define G4EmModelManager_h 1                       72 #define G4EmModelManager_h 1
 71                                                    73 
 72 //....oooOO0OOooo........oooOO0OOooo........oo     74 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 73                                                    75 
 74 #include "globals.hh"                              76 #include "globals.hh"
 75 #include "G4DataVector.hh"                         77 #include "G4DataVector.hh"
 76 #include "G4EmTableType.hh"                        78 #include "G4EmTableType.hh"
 77 #include "G4EmProcessSubType.hh"                   79 #include "G4EmProcessSubType.hh"
 78 #include "G4Region.hh"                             80 #include "G4Region.hh"
 79                                                    81 
 80 #include "G4VEmModel.hh"                       << 
 81 #include "G4VEmFluctuationModel.hh"            << 
 82 #include "G4DynamicParticle.hh"                << 
 83 #include <iostream>                            << 
 84                                                << 
 85 class G4RegionModels                               82 class G4RegionModels
 86 {                                                  83 {
 87                                                    84 
 88 friend class G4EmModelManager;                     85 friend class G4EmModelManager;
 89                                                    86 
                                                   >>  87 public:
                                                   >>  88 
 90 private:                                           89 private:
 91                                                    90 
 92   G4RegionModels(G4int nMod, std::vector<G4int     91   G4RegionModels(G4int nMod, std::vector<G4int>& indx, 
 93                  G4DataVector& lowE, const G4R <<  92      G4DataVector& lowE, const G4Region* reg);
 94                                                    93 
 95   ~G4RegionModels();                               94   ~G4RegionModels();
 96                                                    95 
 97   inline G4int SelectIndex(G4double e) const {     96   inline G4int SelectIndex(G4double e) const {
 98     G4int idx = 0;                                 97     G4int idx = 0;
 99     if (nModelsForRegion>1) {                      98     if (nModelsForRegion>1) {
100       idx = nModelsForRegion;                      99       idx = nModelsForRegion;
101       // Loop checking, 03-Aug-2015, Vladimir  << 
102       do {--idx;} while (idx > 0 && e <= lowKi    100       do {--idx;} while (idx > 0 && e <= lowKineticEnergy[idx]);
103     }                                             101     }
104     return theListOfModelIndexes[idx];            102     return theListOfModelIndexes[idx];
105   };                                              103   };
106                                                   104 
107   inline G4int ModelIndex(G4int n) const {        105   inline G4int ModelIndex(G4int n) const {
108     return theListOfModelIndexes[n];              106     return theListOfModelIndexes[n];
109   };                                              107   };
110                                                   108 
111   inline G4int NumberOfModels() const {           109   inline G4int NumberOfModels() const {
112     return nModelsForRegion;                      110     return nModelsForRegion;
113   };                                              111   };
114                                                   112 
115   inline G4double LowEdgeEnergy(G4int n) const    113   inline G4double LowEdgeEnergy(G4int n) const {
116     return lowKineticEnergy[n];                   114     return lowKineticEnergy[n];
117   };                                              115   };
118                                                   116 
119   inline const G4Region* Region() const {         117   inline const G4Region* Region() const {
120     return theRegion;                             118     return theRegion;
121   };                                              119   };
122                                                   120 
123   G4RegionModels(G4RegionModels &) = delete;   << 
124   G4RegionModels & operator=(const G4RegionMod << 
125                                                << 
126   const G4Region*    theRegion;                   121   const G4Region*    theRegion;
127   G4int              nModelsForRegion;            122   G4int              nModelsForRegion;
128   G4int*             theListOfModelIndexes;       123   G4int*             theListOfModelIndexes;
129   G4double*          lowKineticEnergy;            124   G4double*          lowKineticEnergy;
130                                                   125 
131 };                                                126 };
132                                                   127 
133 //....oooOO0OOooo........oooOO0OOooo........oo << 128 #include "G4VEmModel.hh"
                                                   >> 129 #include "G4VEmFluctuationModel.hh"
                                                   >> 130 #include "G4DynamicParticle.hh"
134                                                   131 
135 class G4Region;                                   132 class G4Region;
136 class G4ParticleDefinition;                       133 class G4ParticleDefinition;
137 class G4PhysicsVector;                            134 class G4PhysicsVector;
138 class G4MaterialCutsCouple;                       135 class G4MaterialCutsCouple;
139                                                   136 
140 //....oooOO0OOooo........oooOO0OOooo........oo    137 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
141                                                   138 
142 class G4EmModelManager                            139 class G4EmModelManager
143 {                                                 140 {
144 public:                                           141 public:
145                                                   142 
146   G4EmModelManager();                             143   G4EmModelManager();
147                                                   144 
148   ~G4EmModelManager();                            145   ~G4EmModelManager();
149                                                   146 
150   void Clear();                                   147   void Clear();
151                                                   148 
152   const G4DataVector* Initialise(const G4Parti << 149   const G4DataVector* Initialise(const G4ParticleDefinition*,
153                                  const G4Parti << 150                                  const G4ParticleDefinition*,
154                                  G4int verb);  << 151                G4double,
                                                   >> 152                                        G4int);
155                                                   153 
156   void FillDEDXVector(G4PhysicsVector*, const     154   void FillDEDXVector(G4PhysicsVector*, const G4MaterialCutsCouple*, 
157                       G4EmTableType t = fRestr << 155           G4EmTableType t = fRestricted);
158                                                   156 
159   void FillLambdaVector(G4PhysicsVector*, cons    157   void FillLambdaVector(G4PhysicsVector*, const G4MaterialCutsCouple*, 
160                         G4bool startFromNull = << 158                         G4bool startFromNull = true, G4EmTableType t = fRestricted);
161                         G4EmTableType t = fRes << 
162                                                   159 
163   void AddEmModel(G4int, G4VEmModel*, G4VEmFlu << 160   G4VEmModel* GetModel(G4int, G4bool ver = false);
164                   const G4Region* r);          << 
165                                                   161 
166   // Get model pointer from the model list     << 162   void AddEmModel(G4int, G4VEmModel*, G4VEmFluctuationModel*, const G4Region*);
167   G4VEmModel* GetModel(G4int idx, G4bool ver = << 163   
                                                   >> 164   void UpdateEmModel(const G4String&, G4double, G4double);
168                                                   165 
169   // Get model pointer from the model list for << 166   void DumpModelList(G4int verb);
170   // no check on material cuts couple index    << 
171   G4VEmModel* GetRegionModel(G4int idx, std::s << 
172                                                   167 
173   // total number of models for material cut c << 168   inline G4VEmModel* SelectModel(G4double& energy, size_t& index);
174   // no check on material cuts couple index    << 
175   G4int NumberOfRegionModels(std::size_t index << 
176                                                   169 
177   // Automatic documentation                   << 
178   void DumpModelList(std::ostream& out, G4int  << 
179                                                << 
180   // Select model for given material cuts coup << 
181   inline G4VEmModel* SelectModel(G4double ener << 
182                                                << 
183   // Access to cuts                            << 
184   inline const G4DataVector* Cuts() const;        170   inline const G4DataVector* Cuts() const;
185                                                   171 
186   // Set flag of fluorescence                  << 172   inline const G4DataVector* SubCutoff() const;
187   inline void SetFluoFlag(G4bool val);         << 
188                                                   173 
189   // total number of models                    << 
190   inline G4int NumberOfModels() const;            174   inline G4int NumberOfModels() const;
191                                                   175 
                                                   >> 176 private:
                                                   >> 177 
                                                   >> 178   inline G4double ComputeDEDX(G4VEmModel* model,
                                                   >> 179             const G4MaterialCutsCouple*,
                                                   >> 180             G4double kinEnergy,
                                                   >> 181             G4double cutEnergy,
                                                   >> 182             G4double minEnergy);
                                                   >> 183 
192   // hide  assignment operator                    184   // hide  assignment operator
193   G4EmModelManager(G4EmModelManager &) = delet << 
194   G4EmModelManager & operator=(const G4EmModel << 
195                                                   185 
196 private:                                       << 186   G4EmModelManager(G4EmModelManager &);
                                                   >> 187   G4EmModelManager & operator=(const G4EmModelManager &right);
197                                                   188 
198   const G4ParticleDefinition* particle = nullp << 189 // =====================================================================
199   const G4DataVector*         theCuts = nullpt << 
200   G4DataVector*               theCutsNew = nul << 
201                                                   190 
202   // may be changed in run time                << 191 private:
203   G4RegionModels*             currRegionModel  << 
204   G4VEmModel*                 currModel = null << 
205                                                   192 
206   G4int                       nEmModels = 0;   << 193   G4DataVector                theCuts;
207   G4int                       nRegions = 0;    << 194   G4DataVector                theSubCuts;
208                                                   195 
209   G4int                       verboseLevel = 0 << 196   std::vector<G4VEmModel*>                models;
210   G4bool                      severalModels =  << 197   std::vector<G4VEmFluctuationModel*>     flucModels;
211   G4bool                      fluoFlag = false << 198   std::vector<const G4Region*>            regions;
212                                                << 199   std::vector<G4int>                      orderOfModels;
213   std::vector<G4VEmModel*>             models; << 200   std::vector<G4int>                      isUsed;
214   std::vector<G4VEmFluctuationModel*>  flucMod << 201 
215   std::vector<const G4Region*>         regions << 202   G4int                       nEmModels;
216   std::vector<G4int>                   orderOf << 203   G4int                       nRegions;
217   std::vector<G4int>                   isUsed; << 
218                                                   204 
219   std::vector<G4int>            idxOfRegionMod    205   std::vector<G4int>            idxOfRegionModels;
220   std::vector<G4RegionModels*>  setOfRegionMod    206   std::vector<G4RegionModels*>  setOfRegionModels;
                                                   >> 207 
                                                   >> 208   G4double                    maxSubCutInRange;
                                                   >> 209 
                                                   >> 210   const G4ParticleDefinition* particle;
                                                   >> 211 
                                                   >> 212   G4int                       verboseLevel;
                                                   >> 213   G4bool                      severalModels;
                                                   >> 214 
                                                   >> 215   // may be changed in run time
                                                   >> 216   G4RegionModels*             currRegionModel;
                                                   >> 217   G4VEmModel*                 currModel;
221 };                                                218 };
222                                                   219 
223 //....oooOO0OOooo........oooOO0OOooo........oo    220 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
224 //....oooOO0OOooo........oooOO0OOooo........oo    221 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
225                                                   222 
226 inline                                         << 223 inline G4VEmModel* G4EmModelManager::SelectModel(G4double& kinEnergy, 
227 G4VEmModel* G4EmModelManager::SelectModel(G4do << 224              size_t& index)
228 {                                                 225 {
229   if(severalModels) {                             226   if(severalModels) {
230     if(nRegions > 1) {                            227     if(nRegions > 1) {
231       currRegionModel = setOfRegionModels[idxO    228       currRegionModel = setOfRegionModels[idxOfRegionModels[index]];
232     }                                             229     }
233     currModel = models[currRegionModel->Select    230     currModel = models[currRegionModel->SelectIndex(kinEnergy)];
234   }                                               231   }
235   return currModel;                               232   return currModel;
236 }                                                 233 }
237                                                   234 
238 //....oooOO0OOooo........oooOO0OOooo........oo    235 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
239                                                   236 
240 inline const G4DataVector* G4EmModelManager::C    237 inline const G4DataVector* G4EmModelManager::Cuts() const
241 {                                                 238 {
242   return theCuts;                              << 239   return &theCuts;
243 }                                                 240 }
244                                                   241 
245 //....oooOO0OOooo........oooOO0OOooo........oo    242 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
246                                                   243 
247 inline void G4EmModelManager::SetFluoFlag(G4bo << 244 inline const G4DataVector* G4EmModelManager::SubCutoff() const
248 {                                                 245 {
249   fluoFlag = val;                              << 246   return &theSubCuts;
250 }                                                 247 }
251                                                   248 
252 //....oooOO0OOooo........oooOO0OOooo........oo    249 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
253                                                   250 
254 inline G4int G4EmModelManager::NumberOfModels(    251 inline G4int G4EmModelManager::NumberOfModels() const
255 {                                                 252 {
256   return nEmModels;                               253   return nEmModels;
                                                   >> 254 }
                                                   >> 255 
                                                   >> 256 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
                                                   >> 257 
                                                   >> 258 inline G4double 
                                                   >> 259 G4EmModelManager::ComputeDEDX(G4VEmModel* model,
                                                   >> 260             const G4MaterialCutsCouple* couple,
                                                   >> 261             G4double e,
                                                   >> 262             G4double cut,
                                                   >> 263             G4double emin)
                                                   >> 264 {
                                                   >> 265   G4double dedx = 0.0;
                                                   >> 266   if(model && cut > emin) {
                                                   >> 267     dedx = model->ComputeDEDX(couple,particle,e,cut); 
                                                   >> 268     if(emin > 0.0) {dedx -= model->ComputeDEDX(couple,particle,e,emin);} 
                                                   >> 269   }
                                                   >> 270   return dedx;
257 }                                                 271 }
258                                                   272 
259 //....oooOO0OOooo........oooOO0OOooo........oo    273 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
260                                                   274 
261 #endif                                            275 #endif
262                                                   276 
263                                                   277