Geant4 Cross Reference

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


  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: G4VMultipleScattering.hh 106714 2017-10-20 09:38:06Z gcosmo $
 26 //                                                 27 //
 27 // -------------------------------------------     28 // -------------------------------------------------------------------
 28 //                                                 29 //
 29 // GEANT4 Class header file                        30 // GEANT4 Class header file
 30 //                                                 31 //
 31 //                                                 32 //
 32 // File name:     G4VMultipleScattering            33 // File name:     G4VMultipleScattering
 33 //                                                 34 //
 34 // Author:        Vladimir Ivanchenko on base      35 // Author:        Vladimir Ivanchenko on base of Laszlo Urban code
 35 //                                                 36 //
 36 // Creation date: 12.03.2002                       37 // Creation date: 12.03.2002
 37 //                                                 38 //
 38 // Modifications:                                  39 // Modifications:
 39 //                                                 40 //
 40 // 16-07-03 Update GetRange interface (V.Ivanc     41 // 16-07-03 Update GetRange interface (V.Ivanchenko)
                                                   >>  42 //
                                                   >>  43 //
                                                   >>  44 // Class Description:
                                                   >>  45 //
                                                   >>  46 // It is the generic process of multiple scattering it includes common
                                                   >>  47 // part of calculations for all charged particles
                                                   >>  48 //
 41 // 26-11-03 bugfix in AlongStepDoIt (L.Urban)      49 // 26-11-03 bugfix in AlongStepDoIt (L.Urban)
 42 // 25-05-04 add protection against case when r     50 // 25-05-04 add protection against case when range is less than steplimit (VI)
                                                   >>  51 // 30-06-04 make destructor virtual (V.Ivanchenko)
 43 // 27-08-04 Add InitialiseForRun method (V.Iva     52 // 27-08-04 Add InitialiseForRun method (V.Ivanchneko)
 44 // 08-11-04 Migration to new interface of Stor     53 // 08-11-04 Migration to new interface of Store/Retrieve tables (V.Ivanchenko)
                                                   >>  54 // 15-04-05 optimize internal interfaces (V.Ivanchenko)
 45 // 15-04-05 remove boundary flag (V.Ivanchenko     55 // 15-04-05 remove boundary flag (V.Ivanchenko)
 46 // 07-10-05 error in a protection in GetContin     56 // 07-10-05 error in a protection in GetContinuousStepLimit corrected (L.Urban)
 47 // 27-10-05 introduce virtual function MscStep     57 // 27-10-05 introduce virtual function MscStepLimitation() (V.Ivanchenko)
 48 // 26-01-06 Rename GetRange -> GetRangeFromRes     58 // 26-01-06 Rename GetRange -> GetRangeFromRestricteDEDX (V.Ivanchenko)
 49 // 17-02-06 Save table of transport cross sect     59 // 17-02-06 Save table of transport cross sections not mfp (V.Ivanchenko)
 50 // 07-03-06 Move step limit calculation to mod     60 // 07-03-06 Move step limit calculation to model (V.Ivanchenko)
 51 // 13-05-06 Add method to access model by inde     61 // 13-05-06 Add method to access model by index (V.Ivanchenko)
 52 // 12-02-07 Add get/set skin (V.Ivanchenko)        62 // 12-02-07 Add get/set skin (V.Ivanchenko)
 53 // 27-10-07 Virtual functions moved to source      63 // 27-10-07 Virtual functions moved to source (V.Ivanchenko)
 54 // 15-07-08 Reorder class members for further      64 // 15-07-08 Reorder class members for further multi-thread development (VI)
 55 // 07-04-09 Moved msc methods from G4VEmModel      65 // 07-04-09 Moved msc methods from G4VEmModel to G4VMscModel (VI) 
 56 //                                                 66 //
 57 // Class Description:                          << 
 58 //                                             << 
 59 // It is the generic process of multiple scatt << 
 60 // part of calculations for all charged partic << 
 61                                                    67 
 62 // -------------------------------------------     68 // -------------------------------------------------------------------
 63 //                                                 69 //
 64                                                    70 
 65 #ifndef G4VMultipleScattering_h                    71 #ifndef G4VMultipleScattering_h
 66 #define G4VMultipleScattering_h 1                  72 #define G4VMultipleScattering_h 1
 67                                                    73 
 68 #include "G4VContinuousDiscreteProcess.hh"         74 #include "G4VContinuousDiscreteProcess.hh"
 69 #include "globals.hh"                              75 #include "globals.hh"
 70 #include "G4Material.hh"                           76 #include "G4Material.hh"
 71 #include "G4ParticleChangeForMSC.hh"               77 #include "G4ParticleChangeForMSC.hh"
 72 #include "G4Track.hh"                              78 #include "G4Track.hh"
 73 #include "G4Step.hh"                               79 #include "G4Step.hh"
 74 #include "G4EmModelManager.hh"                     80 #include "G4EmModelManager.hh"
 75 #include "G4VMscModel.hh"                          81 #include "G4VMscModel.hh"
 76 #include "G4EmParameters.hh"                       82 #include "G4EmParameters.hh"
 77 #include "G4MscStepLimitType.hh"                   83 #include "G4MscStepLimitType.hh"
 78                                                    84 
 79 class G4ParticleDefinition;                        85 class G4ParticleDefinition;
 80 class G4VEnergyLossProcess;                        86 class G4VEnergyLossProcess;
 81 class G4LossTableManager;                          87 class G4LossTableManager;
 82 class G4SafetyHelper;                              88 class G4SafetyHelper;
 83                                                    89 
 84 //....oooOO0OOooo........oooOO0OOooo........oo     90 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 85                                                    91 
 86 class G4VMultipleScattering : public G4VContin     92 class G4VMultipleScattering : public G4VContinuousDiscreteProcess
 87 {                                                  93 {
 88 public:                                            94 public:
 89                                                    95 
 90   explicit G4VMultipleScattering(const G4Strin <<  96   G4VMultipleScattering(const G4String& name = "msc",
 91                                  G4ProcessType <<  97                         G4ProcessType type = fElectromagnetic);
 92                                                    98 
 93   ~G4VMultipleScattering() override;           <<  99   virtual ~G4VMultipleScattering();
 94                                                   100 
 95   //------------------------------------------    101   //------------------------------------------------------------------------
 96   // Virtual methods to be implemented for the    102   // Virtual methods to be implemented for the concrete model
 97   //------------------------------------------    103   //------------------------------------------------------------------------
 98                                                   104 
 99   void ProcessDescription(std::ostream& outFil << 105   virtual G4bool IsApplicable(const G4ParticleDefinition& p) override = 0;
100                                                   106 
101   virtual void InitialiseProcess(const G4Parti << 107   // obsolete
                                                   >> 108   virtual void PrintInfo() {};
102                                                   109 
103   // Print out of generic class parameters     << 110   virtual void ProcessDescription(std::ostream& outFile) const override;
104   void StreamInfo(std::ostream& outFile, const << 
105                   G4bool rst = false) const;   << 
106                                                   111 
107 protected:                                        112 protected:
108                                                   113 
109   virtual void StreamProcessInfo(std::ostream& << 114   virtual void InitialiseProcess(const G4ParticleDefinition*) = 0;
                                                   >> 115 
                                                   >> 116   virtual void StreamProcessInfo(std::ostream&, G4String) const {};
110                                                   117 
111 public:                                           118 public:
112                                                   119 
113   //------------------------------------------    120   //------------------------------------------------------------------------
114   // Generic methods common to all ContinuousD    121   // Generic methods common to all ContinuousDiscrete processes
115   //------------------------------------------    122   //------------------------------------------------------------------------
116                                                   123 
117   // Initialise for build of tables               124   // Initialise for build of tables
118   void PreparePhysicsTable(const G4ParticleDef    125   void PreparePhysicsTable(const G4ParticleDefinition&) override;
119                                                   126 
120   // Build physics table during initialisation    127   // Build physics table during initialisation
121   void BuildPhysicsTable(const G4ParticleDefin    128   void BuildPhysicsTable(const G4ParticleDefinition&) override;
122                                                   129 
123   // Store PhysicsTable in a file.                130   // Store PhysicsTable in a file.
124   // Return false in case of failure at I/O       131   // Return false in case of failure at I/O
125   G4bool StorePhysicsTable(const G4ParticleDef    132   G4bool StorePhysicsTable(const G4ParticleDefinition*,
126                            const G4String& dir    133                            const G4String& directory,
127                            G4bool ascii = fals    134                            G4bool ascii = false) override;
128                                                   135 
129   // Retrieve Physics from a file.                136   // Retrieve Physics from a file.
130   // (return true if the Physics Table can be     137   // (return true if the Physics Table can be build by using file)
131   // (return false if the process has no funct    138   // (return false if the process has no functionality or in case of failure)
132   // File name should is constructed as proces    139   // File name should is constructed as processName+particleName and the
133   // should be placed under the directory spec << 140   // should be placed under the directory specifed by the argument.
134   G4bool RetrievePhysicsTable(const G4Particle    141   G4bool RetrievePhysicsTable(const G4ParticleDefinition*,
135                               const G4String&     142                               const G4String& directory,
136                               G4bool ascii) ov    143                               G4bool ascii) override;
137                                                   144 
138   // This is called in the beginning of tracki    145   // This is called in the beginning of tracking for a new track
139   void StartTracking(G4Track*) override;          146   void StartTracking(G4Track*) override;
140                                                   147 
141   // The function overloads the corresponding     148   // The function overloads the corresponding function of the base
142   // class.It limits the step near to boundari    149   // class.It limits the step near to boundaries only
143   // and invokes the method GetMscContinuousSt    150   // and invokes the method GetMscContinuousStepLimit at every step.
144   G4double AlongStepGetPhysicalInteractionLeng    151   G4double AlongStepGetPhysicalInteractionLength(
145                                         const     152                                         const G4Track&,
146                                         G4doub    153                                         G4double  previousStepSize,
147                                         G4doub    154                                         G4double  currentMinimalStep,
148                                         G4doub    155                                         G4double& currentSafety,
149                                         G4GPIL    156                                         G4GPILSelection* selection) override;
150                                                   157 
151   // The function overloads the corresponding     158   // The function overloads the corresponding function of the base
152   // class.                                       159   // class.
153   G4double PostStepGetPhysicalInteractionLengt    160   G4double PostStepGetPhysicalInteractionLength(
154                                       const G4    161                                       const G4Track&,
155                                       G4double    162                                       G4double  previousStepSize,
156                                       G4ForceC    163                                       G4ForceCondition* condition) override;
157                                                   164 
158   // Along step actions                           165   // Along step actions
159   G4VParticleChange* AlongStepDoIt(const G4Tra    166   G4VParticleChange* AlongStepDoIt(const G4Track&, const G4Step&) override;
160                                                   167 
                                                   >> 168   // Post step actions
                                                   >> 169   G4VParticleChange* PostStepDoIt(const G4Track&, const G4Step&) override;
                                                   >> 170 
161   // This method does not used for tracking, i    171   // This method does not used for tracking, it is intended only for tests
162   G4double ContinuousStepLimit(const G4Track&     172   G4double ContinuousStepLimit(const G4Track& track,
163                                G4double previo    173                                G4double previousStepSize,
164                                G4double curren    174                                G4double currentMinimalStep,
165                                G4double& curre    175                                G4double& currentSafety);
166                                                   176 
167   // hide assignment operator                  << 
168   G4VMultipleScattering(G4VMultipleScattering  << 
169   G4VMultipleScattering & operator=(const G4VM << 
170                                                << 
171   //------------------------------------------    177   //------------------------------------------------------------------------
172   // Specific methods to set, access, modify m    178   // Specific methods to set, access, modify models
173   //------------------------------------------    179   //------------------------------------------------------------------------
174                                                   180 
175   // Select model in run time                     181   // Select model in run time
176   inline G4VEmModel* SelectModel(G4double kinE    182   inline G4VEmModel* SelectModel(G4double kinEnergy, size_t idx);
177                                                   183 
178 public:                                           184 public:
179                                                   185 
180   // Add model for region, smaller value of or    186   // Add model for region, smaller value of order defines which
181   // model will be selected for a given energy    187   // model will be selected for a given energy interval  
182   void AddEmModel(G4int order, G4VMscModel*, c << 188   void AddEmModel(G4int order, G4VEmModel*, const G4Region* region = nullptr);
183                                                   189 
184   // Assign a model to a process local list, t    190   // Assign a model to a process local list, to enable the list in run time 
185   // the derived process should execute AddEmM    191   // the derived process should execute AddEmModel(..) for all such models
186   void SetEmModel(G4VMscModel*, G4int idx = 0) << 192   void SetEmModel(G4VMscModel*, size_t index = 0);
187                                                   193   
188   // return a model from the local list           194   // return a model from the local list
189   inline G4VMscModel* EmModel(size_t index = 0 << 195   G4VMscModel* EmModel(size_t index = 0) const;
190                                                << 
191   // Access to run time models                 << 
192   inline G4int NumberOfModels() const;         << 
193                                                   196 
194   inline G4VMscModel* GetModelByIndex(G4int id << 197   // Access to run time models by index
                                                   >> 198   inline G4VEmModel* GetModelByIndex(G4int idx = 0, G4bool ver = false) const;
195                                                   199 
196   //------------------------------------------    200   //------------------------------------------------------------------------
197   // Get/Set parameters for simulation of mult    201   // Get/Set parameters for simulation of multiple scattering
198   //------------------------------------------    202   //------------------------------------------------------------------------
199                                                   203 
200   inline G4bool LateralDisplasmentFlag() const << 204   void SetIonisation(G4VEnergyLossProcess*);
201                                                   205   
                                                   >> 206   inline G4bool LateralDisplasmentFlag() const;
                                                   >> 207   inline void SetLateralDisplasmentFlag(G4bool val);
                                                   >> 208 
202   inline G4double Skin() const;                   209   inline G4double Skin() const;
                                                   >> 210   inline void SetSkin(G4double val);
203                                                   211   
204   inline G4double RangeFactor() const;            212   inline G4double RangeFactor() const;
                                                   >> 213   inline void SetRangeFactor(G4double val);
205                                                   214   
206   inline G4double GeomFactor() const;             215   inline G4double GeomFactor() const;
207                                                   216  
208   inline G4double PolarAngleLimit() const;        217   inline G4double PolarAngleLimit() const;
209                                                << 
210   inline G4bool UseBaseMaterial() const;       << 
211                                                   218  
212   inline G4MscStepLimitType StepLimitType() co    219   inline G4MscStepLimitType StepLimitType() const;
213   inline void SetStepLimitType(G4MscStepLimitT    220   inline void SetStepLimitType(G4MscStepLimitType val);
214                                                   221 
215   inline G4double LowestKinEnergy() const;        222   inline G4double LowestKinEnergy() const;
216   inline void SetLowestKinEnergy(G4double val)    223   inline void SetLowestKinEnergy(G4double val);
217                                                   224 
218   inline const G4ParticleDefinition* FirstPart    225   inline const G4ParticleDefinition* FirstParticle() const;
219                                                   226 
220   //------------------------------------------    227   //------------------------------------------------------------------------
221   // Run time methods                             228   // Run time methods
222   //------------------------------------------    229   //------------------------------------------------------------------------
223                                                   230 
224 protected:                                        231 protected:
225                                                   232 
226   // This method is not used for tracking, it     233   // This method is not used for tracking, it returns mean free path value
227   G4double GetMeanFreePath(const G4Track& trac    234   G4double GetMeanFreePath(const G4Track& track,
228                            G4double,              235                            G4double,
229                            G4ForceCondition* c    236                            G4ForceCondition* condition) override;
230                                                   237 
231   // This method is not used for tracking, it     238   // This method is not used for tracking, it returns step limit
232   G4double GetContinuousStepLimit(const G4Trac    239   G4double GetContinuousStepLimit(const G4Track& track,
233                                   G4double pre    240                                   G4double previousStepSize,
234                                   G4double cur    241                                   G4double currentMinimalStep,
235                                   G4double& cu << 242                                   G4double& currentSafety) override ;
                                                   >> 243 
                                                   >> 244   // return number of already added models
                                                   >> 245   inline G4int NumberOfModels() const;
236                                                   246 
237 private:                                          247 private:
238                                                   248 
                                                   >> 249   // hide  assignment operator
                                                   >> 250   G4VMultipleScattering(G4VMultipleScattering &) = delete;
                                                   >> 251   G4VMultipleScattering & 
                                                   >> 252     operator=(const G4VMultipleScattering &right) = delete;
                                                   >> 253 
                                                   >> 254   // Print out of generic class parameters
                                                   >> 255   void StreamInfo(std::ostream& outFile, const G4ParticleDefinition&,
                                                   >> 256                   G4String endOfLine=G4String("\n")) const;
                                                   >> 257 
239   // ======== Parameters of the class fixed at    258   // ======== Parameters of the class fixed at construction =========
240                                                   259 
241   G4EmModelManager*           modelManager;       260   G4EmModelManager*           modelManager;
242   G4LossTableManager*         emManager;          261   G4LossTableManager*         emManager;
243   G4EmParameters*             theParameters;      262   G4EmParameters*             theParameters;  
244                                                   263 
245   // ======== Parameters of the class fixed at    264   // ======== Parameters of the class fixed at initialisation =======
246                                                   265 
247   G4SafetyHelper*             safetyHelper = n << 266   G4SafetyHelper*             safetyHelper;
248   const G4ParticleDefinition* firstParticle =  << 267 
249   const G4ParticleDefinition* currParticle = n << 
250                                                << 
251   std::vector<G4VMscModel*>   mscModels;          268   std::vector<G4VMscModel*>   mscModels;
                                                   >> 269   G4int                       numberOfModels;
                                                   >> 270 
                                                   >> 271   const G4ParticleDefinition* firstParticle;
                                                   >> 272   const G4ParticleDefinition* currParticle;
252                                                   273 
253   G4double                    facrange = 0.04; << 274   G4MscStepLimitType          stepLimit;
                                                   >> 275 
                                                   >> 276   G4double                    facrange;
254   G4double                    lowestKinEnergy;    277   G4double                    lowestKinEnergy;
255                                                   278 
                                                   >> 279   G4bool                      latDisplacement;
                                                   >> 280   G4bool                      isIon;
                                                   >> 281   G4bool                      fDispBeyondSafety;
                                                   >> 282 
256   // ======== Cached values - may be state dep    283   // ======== Cached values - may be state dependent ================
257                                                   284 
258 protected:                                        285 protected:
259                                                   286 
260   G4ParticleChangeForMSC      fParticleChange;    287   G4ParticleChangeForMSC      fParticleChange;
261                                                   288 
262 private:                                          289 private:
263                                                   290 
264   G4ThreeVector               fNewPosition;    << 291   // cache
265   G4ThreeVector               fNewDirection;   << 292   G4VMscModel*                currentModel;
266                                                << 293   G4VEnergyLossProcess*       fIonisation;
267   G4VMscModel*                currentModel = n << 
268   G4VEnergyLossProcess*       fIonisation = nu << 
269                                                   294 
270   G4double                    geomMin;            295   G4double                    geomMin;
271   G4double                    minDisplacement2    296   G4double                    minDisplacement2;
272   G4double                    physStepLimit =  << 297   G4double                    physStepLimit;
273   G4double                    tPathLength = 0. << 298   G4double                    tPathLength;
274   G4double                    gPathLength = 0. << 299   G4double                    gPathLength;
275                                                << 300 
276   G4MscStepLimitType          stepLimit = fUse << 301   G4ThreeVector               fNewPosition;
277   G4int                       numberOfModels = << 302   G4ThreeVector               fNewDirection;
278                                                << 303   G4bool                      fPositionChanged;
279   G4bool                      latDisplacement  << 304   G4bool                      isActive;
280   G4bool                      isIon = false;   << 
281   G4bool                      fPositionChanged << 
282   G4bool                      isActive = false << 
283   G4bool                      baseMat = false; << 
284 };                                                305 };
285                                                   306 
286 // ======== Run time inline methods ==========    307 // ======== Run time inline methods ================
287                                                   308 
288 //....oooOO0OOooo........oooOO0OOooo........oo    309 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
289                                                   310 
290 inline G4VEmModel*                                311 inline G4VEmModel* 
291 G4VMultipleScattering::SelectModel(G4double ki    312 G4VMultipleScattering::SelectModel(G4double kinEnergy, size_t coupleIndex)
292 {                                                 313 {
293   return modelManager->SelectModel(kinEnergy,     314   return modelManager->SelectModel(kinEnergy, coupleIndex);
294 }                                                 315 }
295                                                   316 
296 //....oooOO0OOooo........oooOO0OOooo........oo    317 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
297                                                   318 
298 inline  G4bool G4VMultipleScattering::LateralD    319 inline  G4bool G4VMultipleScattering::LateralDisplasmentFlag() const
299 {                                                 320 {
300   return latDisplacement;                         321   return latDisplacement;
301 }                                                 322 }
302                                                   323 
303 //....oooOO0OOooo........oooOO0OOooo........oo    324 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
304                                                   325 
                                                   >> 326 inline  void G4VMultipleScattering::SetLateralDisplasmentFlag(G4bool val)
                                                   >> 327 {
                                                   >> 328   latDisplacement = val;
                                                   >> 329 }
                                                   >> 330 
                                                   >> 331 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
                                                   >> 332 
305 inline  G4double G4VMultipleScattering::Skin()    333 inline  G4double G4VMultipleScattering::Skin() const
306 {                                                 334 {
307   return theParameters->MscSkin();                335   return theParameters->MscSkin();
308 }                                                 336 }
309                                                   337 
310 //....oooOO0OOooo........oooOO0OOooo........oo    338 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
311                                                   339 
                                                   >> 340 inline  void G4VMultipleScattering::SetSkin(G4double val)
                                                   >> 341 {
                                                   >> 342   theParameters->SetMscSkin(val);
                                                   >> 343 }
                                                   >> 344 
                                                   >> 345 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
                                                   >> 346 
312 inline  G4double G4VMultipleScattering::RangeF    347 inline  G4double G4VMultipleScattering::RangeFactor() const
313 {                                                 348 {
314   return facrange;                                349   return facrange;
315 }                                                 350 }
316                                                   351 
317 //....oooOO0OOooo........oooOO0OOooo........oo    352 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
318                                                   353 
                                                   >> 354 inline  void G4VMultipleScattering::SetRangeFactor(G4double val)
                                                   >> 355 {
                                                   >> 356   if(val > 0.0 && val < 1.0) { 
                                                   >> 357     facrange = val;
                                                   >> 358     theParameters->SetMscRangeFactor(val);
                                                   >> 359   }
                                                   >> 360 }
                                                   >> 361 
                                                   >> 362 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
                                                   >> 363 
319 inline  G4double G4VMultipleScattering::GeomFa    364 inline  G4double G4VMultipleScattering::GeomFactor() const
320 {                                                 365 {
321   return theParameters->MscGeomFactor();          366   return theParameters->MscGeomFactor();
322 }                                                 367 }
323                                                   368 
324 //....oooOO0OOooo........oooOO0OOooo........oo    369 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
325                                                   370 
326 inline  G4double G4VMultipleScattering::PolarA    371 inline  G4double G4VMultipleScattering::PolarAngleLimit() const
327 {                                                 372 {
328   return theParameters->MscThetaLimit();          373   return theParameters->MscThetaLimit();
329 }                                                 374 }
330                                                   375 
331 //....oooOO0OOooo........oooOO0OOooo........oo    376 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
332                                                   377 
333 inline G4MscStepLimitType G4VMultipleScatterin    378 inline G4MscStepLimitType G4VMultipleScattering::StepLimitType() const
334 {                                                 379 {
335   return stepLimit;                               380   return stepLimit;
336 }                                                 381 }
337                                                   382 
338 //....oooOO0OOooo........oooOO0OOooo........oo    383 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
339                                                   384 
340 inline void G4VMultipleScattering::SetStepLimi    385 inline void G4VMultipleScattering::SetStepLimitType(G4MscStepLimitType val) 
341 {                                                 386 {
                                                   >> 387   stepLimit = val;
                                                   >> 388   if(val == fMinimal) { SetRangeFactor(0.2); }
342   theParameters->SetMscStepLimitType(val);        389   theParameters->SetMscStepLimitType(val);
343 }                                                 390 }
344                                                   391 
345 //....oooOO0OOooo........oooOO0OOooo........oo    392 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
346                                                   393 
347 inline G4double G4VMultipleScattering::LowestK    394 inline G4double G4VMultipleScattering::LowestKinEnergy() const
348 {                                                 395 {
349   return lowestKinEnergy;                         396   return lowestKinEnergy;
350 }                                                 397 }
351                                                   398 
352 //....oooOO0OOooo........oooOO0OOooo........oo    399 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
353                                                   400 
354 inline void G4VMultipleScattering::SetLowestKi    401 inline void G4VMultipleScattering::SetLowestKinEnergy(G4double val)
355 {                                                 402 {
356   lowestKinEnergy = val;                          403   lowestKinEnergy = val;
357 }                                                 404 }
358                                                   405 
359 //....oooOO0OOooo........oooOO0OOooo........oo    406 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
360                                                   407 
361 inline const G4ParticleDefinition* G4VMultiple    408 inline const G4ParticleDefinition* G4VMultipleScattering::FirstParticle() const
362 {                                                 409 {
363   return firstParticle;                           410   return firstParticle;
364 }                                                 411 }
365                                                   412 
366 //....oooOO0OOooo........oooOO0OOooo........oo    413 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
367                                                   414 
368 inline G4VMscModel* G4VMultipleScattering::EmM << 
369 {                                              << 
370   return (index < mscModels.size()) ? mscModel << 
371 }                                              << 
372                                                << 
373 //....oooOO0OOooo........oooOO0OOooo........oo << 
374                                                << 
375 inline G4int G4VMultipleScattering::NumberOfMo    415 inline G4int G4VMultipleScattering::NumberOfModels() const
376 {                                                 416 {
377   return numberOfModels;                       << 417   return modelManager->NumberOfModels();
378 }                                                 418 }
379                                                   419 
380 //....oooOO0OOooo........oooOO0OOooo........oo    420 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
381                                                   421 
382 inline G4VMscModel*                            << 422 inline G4VEmModel* 
383 G4VMultipleScattering::GetModelByIndex(G4int i    423 G4VMultipleScattering::GetModelByIndex(G4int idx, G4bool ver) const
384 {                                                 424 {
385   // static cast is possible inside this class << 425   return modelManager->GetModel(idx, ver);
386   return static_cast<G4VMscModel*>(modelManage << 
387 }                                              << 
388                                                << 
389 //....oooOO0OOooo........oooOO0OOooo........oo << 
390                                                << 
391 inline G4bool G4VMultipleScattering::UseBaseMa << 
392 {                                              << 
393   return baseMat;                              << 
394 }                                                 426 }
395                                                   427 
396 //....oooOO0OOooo........oooOO0OOooo........oo    428 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
397                                                   429 
398 #endif                                            430 #endif
399                                                   431