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.3)


  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 97432 2016-06-03 07:23:39Z 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   virtual void PrintInfo() = 0;
102                                                   108 
103   // Print out of generic class parameters     << 109   virtual void ProcessDescription(std::ostream& outFile) const; // = 0;
104   void StreamInfo(std::ostream& outFile, const << 
105                   G4bool rst = false) const;   << 
106                                                   110 
107 protected:                                        111 protected:
108                                                   112 
109   virtual void StreamProcessInfo(std::ostream& << 113   virtual void InitialiseProcess(const G4ParticleDefinition*) = 0;
110                                                   114 
111 public:                                           115 public:
112                                                   116 
113   //------------------------------------------    117   //------------------------------------------------------------------------
114   // Generic methods common to all ContinuousD    118   // Generic methods common to all ContinuousDiscrete processes
115   //------------------------------------------    119   //------------------------------------------------------------------------
116                                                   120 
117   // Initialise for build of tables               121   // Initialise for build of tables
118   void PreparePhysicsTable(const G4ParticleDef    122   void PreparePhysicsTable(const G4ParticleDefinition&) override;
119                                                   123 
120   // Build physics table during initialisation    124   // Build physics table during initialisation
121   void BuildPhysicsTable(const G4ParticleDefin    125   void BuildPhysicsTable(const G4ParticleDefinition&) override;
122                                                   126 
                                                   >> 127   // Print out of generic class parameters
                                                   >> 128   void PrintInfoDefinition();
                                                   >> 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
185   // the derived process should execute AddEmM << 191   void SetEmModel(G4VMscModel*, G4int index = 1);
186   void SetEmModel(G4VMscModel*, G4int idx = 0) << 
187                                                   192   
188   // return a model from the local list        << 193   // return the assigned model
189   inline G4VMscModel* EmModel(size_t index = 0 << 194   G4VMscModel* EmModel(G4int index = 1) const;
190                                                << 
191   // Access to run time models                 << 
192   inline G4int NumberOfModels() const;         << 
193                                                   195 
194   inline G4VMscModel* GetModelByIndex(G4int id << 196   // Access to models by index
                                                   >> 197   G4VEmModel* GetModelByIndex(G4int idx = 0, G4bool ver = false) const;
195                                                   198 
196   //------------------------------------------    199   //------------------------------------------------------------------------
197   // Get/Set parameters for simulation of mult    200   // Get/Set parameters for simulation of multiple scattering
198   //------------------------------------------    201   //------------------------------------------------------------------------
199                                                   202 
200   inline G4bool LateralDisplasmentFlag() const << 203   void SetIonisation(G4VEnergyLossProcess*);
201                                                   204   
                                                   >> 205   inline G4bool LateralDisplasmentFlag() const;
                                                   >> 206   inline void SetLateralDisplasmentFlag(G4bool val);
                                                   >> 207 
202   inline G4double Skin() const;                   208   inline G4double Skin() const;
                                                   >> 209   inline void SetSkin(G4double val);
203                                                   210   
204   inline G4double RangeFactor() const;            211   inline G4double RangeFactor() const;
                                                   >> 212   inline void SetRangeFactor(G4double val);
205                                                   213   
206   inline G4double GeomFactor() const;             214   inline G4double GeomFactor() const;
                                                   >> 215   //inline void SetGeomFactor(G4double val);
207                                                   216  
208   inline G4double PolarAngleLimit() const;        217   inline G4double PolarAngleLimit() const;
209                                                << 218   // inline void SetPolarAngleLimit(G4double val);
210   inline G4bool UseBaseMaterial() const;       << 
211                                                   219  
212   inline G4MscStepLimitType StepLimitType() co    220   inline G4MscStepLimitType StepLimitType() const;
213   inline void SetStepLimitType(G4MscStepLimitT    221   inline void SetStepLimitType(G4MscStepLimitType val);
214                                                   222 
215   inline G4double LowestKinEnergy() const;        223   inline G4double LowestKinEnergy() const;
216   inline void SetLowestKinEnergy(G4double val)    224   inline void SetLowestKinEnergy(G4double val);
217                                                   225 
218   inline const G4ParticleDefinition* FirstPart    226   inline const G4ParticleDefinition* FirstParticle() const;
219                                                   227 
220   //------------------------------------------    228   //------------------------------------------------------------------------
221   // Run time methods                             229   // Run time methods
222   //------------------------------------------    230   //------------------------------------------------------------------------
223                                                   231 
224 protected:                                        232 protected:
225                                                   233 
226   // This method is not used for tracking, it     234   // This method is not used for tracking, it returns mean free path value
227   G4double GetMeanFreePath(const G4Track& trac    235   G4double GetMeanFreePath(const G4Track& track,
228                            G4double,              236                            G4double,
229                            G4ForceCondition* c    237                            G4ForceCondition* condition) override;
230                                                   238 
231   // This method is not used for tracking, it     239   // This method is not used for tracking, it returns step limit
232   G4double GetContinuousStepLimit(const G4Trac    240   G4double GetContinuousStepLimit(const G4Track& track,
233                                   G4double pre    241                                   G4double previousStepSize,
234                                   G4double cur    242                                   G4double currentMinimalStep,
235                                   G4double& cu << 243                                   G4double& currentSafety) override ;
                                                   >> 244 
                                                   >> 245   // return number of already added models
                                                   >> 246   inline size_t NumberOfModels() const;
236                                                   247 
237 private:                                          248 private:
238                                                   249 
                                                   >> 250   // hide  assignment operator
                                                   >> 251   G4VMultipleScattering(G4VMultipleScattering &) = delete;
                                                   >> 252   G4VMultipleScattering & 
                                                   >> 253     operator=(const G4VMultipleScattering &right) = delete;
                                                   >> 254 
239   // ======== Parameters of the class fixed at    255   // ======== Parameters of the class fixed at construction =========
240                                                   256 
241   G4EmModelManager*           modelManager;       257   G4EmModelManager*           modelManager;
242   G4LossTableManager*         emManager;          258   G4LossTableManager*         emManager;
243   G4EmParameters*             theParameters;      259   G4EmParameters*             theParameters;  
244                                                   260 
245   // ======== Parameters of the class fixed at    261   // ======== Parameters of the class fixed at initialisation =======
246                                                   262 
247   G4SafetyHelper*             safetyHelper = n << 263   G4SafetyHelper*             safetyHelper;
248   const G4ParticleDefinition* firstParticle =  << 264 
249   const G4ParticleDefinition* currParticle = n << 
250                                                << 
251   std::vector<G4VMscModel*>   mscModels;          265   std::vector<G4VMscModel*>   mscModels;
                                                   >> 266   G4int                       numberOfModels;
                                                   >> 267 
                                                   >> 268   const G4ParticleDefinition* firstParticle;
                                                   >> 269   const G4ParticleDefinition* currParticle;
252                                                   270 
253   G4double                    facrange = 0.04; << 271   G4MscStepLimitType          stepLimit;
                                                   >> 272 
                                                   >> 273   G4double                    facrange;
254   G4double                    lowestKinEnergy;    274   G4double                    lowestKinEnergy;
255                                                   275 
                                                   >> 276   G4bool                      latDisplacement;
                                                   >> 277   G4bool                      isIon;
                                                   >> 278   G4bool                      fDispBeyondSafety;
                                                   >> 279 
256   // ======== Cached values - may be state dep    280   // ======== Cached values - may be state dependent ================
257                                                   281 
258 protected:                                        282 protected:
259                                                   283 
260   G4ParticleChangeForMSC      fParticleChange;    284   G4ParticleChangeForMSC      fParticleChange;
261                                                   285 
262 private:                                          286 private:
263                                                   287 
264   G4ThreeVector               fNewPosition;    << 288   // cache
265   G4ThreeVector               fNewDirection;   << 289   G4VMscModel*                currentModel;
266                                                << 290   G4VEnergyLossProcess*       fIonisation;
267   G4VMscModel*                currentModel = n << 
268   G4VEnergyLossProcess*       fIonisation = nu << 
269                                                   291 
270   G4double                    geomMin;            292   G4double                    geomMin;
271   G4double                    minDisplacement2    293   G4double                    minDisplacement2;
272   G4double                    physStepLimit =  << 294   G4double                    physStepLimit;
273   G4double                    tPathLength = 0. << 295   G4double                    tPathLength;
274   G4double                    gPathLength = 0. << 296   G4double                    gPathLength;
275                                                << 297 
276   G4MscStepLimitType          stepLimit = fUse << 298   G4ThreeVector               fNewPosition;
277   G4int                       numberOfModels = << 299   G4ThreeVector               fNewDirection;
278                                                << 300   G4bool                      fPositionChanged;
279   G4bool                      latDisplacement  << 301   G4bool                      isActive;
280   G4bool                      isIon = false;   << 
281   G4bool                      fPositionChanged << 
282   G4bool                      isActive = false << 
283   G4bool                      baseMat = false; << 
284 };                                                302 };
285                                                   303 
286 // ======== Run time inline methods ==========    304 // ======== Run time inline methods ================
287                                                   305 
288 //....oooOO0OOooo........oooOO0OOooo........oo    306 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
289                                                   307 
290 inline G4VEmModel*                                308 inline G4VEmModel* 
291 G4VMultipleScattering::SelectModel(G4double ki    309 G4VMultipleScattering::SelectModel(G4double kinEnergy, size_t coupleIndex)
292 {                                                 310 {
293   return modelManager->SelectModel(kinEnergy,     311   return modelManager->SelectModel(kinEnergy, coupleIndex);
294 }                                                 312 }
295                                                   313 
296 //....oooOO0OOooo........oooOO0OOooo........oo    314 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
297                                                   315 
298 inline  G4bool G4VMultipleScattering::LateralD    316 inline  G4bool G4VMultipleScattering::LateralDisplasmentFlag() const
299 {                                                 317 {
300   return latDisplacement;                         318   return latDisplacement;
301 }                                                 319 }
302                                                   320 
303 //....oooOO0OOooo........oooOO0OOooo........oo    321 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
304                                                   322 
                                                   >> 323 inline  void G4VMultipleScattering::SetLateralDisplasmentFlag(G4bool val)
                                                   >> 324 {
                                                   >> 325   latDisplacement = val;
                                                   >> 326 }
                                                   >> 327 
                                                   >> 328 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
                                                   >> 329 
305 inline  G4double G4VMultipleScattering::Skin()    330 inline  G4double G4VMultipleScattering::Skin() const
306 {                                                 331 {
307   return theParameters->MscSkin();                332   return theParameters->MscSkin();
308 }                                                 333 }
309                                                   334 
310 //....oooOO0OOooo........oooOO0OOooo........oo    335 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
311                                                   336 
                                                   >> 337 inline  void G4VMultipleScattering::SetSkin(G4double val)
                                                   >> 338 {
                                                   >> 339   theParameters->SetMscSkin(val);
                                                   >> 340 }
                                                   >> 341 
                                                   >> 342 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
                                                   >> 343 
312 inline  G4double G4VMultipleScattering::RangeF    344 inline  G4double G4VMultipleScattering::RangeFactor() const
313 {                                                 345 {
314   return facrange;                                346   return facrange;
315 }                                                 347 }
316                                                   348 
317 //....oooOO0OOooo........oooOO0OOooo........oo    349 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
318                                                   350 
                                                   >> 351 inline  void G4VMultipleScattering::SetRangeFactor(G4double val)
                                                   >> 352 {
                                                   >> 353   if(val > 0.0 && val < 1.0) { 
                                                   >> 354     facrange = val;
                                                   >> 355     theParameters->SetMscRangeFactor(val);
                                                   >> 356   }
                                                   >> 357 }
                                                   >> 358 
                                                   >> 359 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
                                                   >> 360 
319 inline  G4double G4VMultipleScattering::GeomFa    361 inline  G4double G4VMultipleScattering::GeomFactor() const
320 {                                                 362 {
321   return theParameters->MscGeomFactor();          363   return theParameters->MscGeomFactor();
322 }                                                 364 }
323                                                   365 
324 //....oooOO0OOooo........oooOO0OOooo........oo    366 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
325                                                   367 
326 inline  G4double G4VMultipleScattering::PolarA    368 inline  G4double G4VMultipleScattering::PolarAngleLimit() const
327 {                                                 369 {
328   return theParameters->MscThetaLimit();          370   return theParameters->MscThetaLimit();
329 }                                                 371 }
330                                                   372 
331 //....oooOO0OOooo........oooOO0OOooo........oo    373 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
332                                                   374 
333 inline G4MscStepLimitType G4VMultipleScatterin    375 inline G4MscStepLimitType G4VMultipleScattering::StepLimitType() const
334 {                                                 376 {
335   return stepLimit;                               377   return stepLimit;
336 }                                                 378 }
337                                                   379 
338 //....oooOO0OOooo........oooOO0OOooo........oo    380 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
339                                                   381 
340 inline void G4VMultipleScattering::SetStepLimi    382 inline void G4VMultipleScattering::SetStepLimitType(G4MscStepLimitType val) 
341 {                                                 383 {
                                                   >> 384   stepLimit = val;
                                                   >> 385   if(val == fMinimal) { SetRangeFactor(0.2); }
342   theParameters->SetMscStepLimitType(val);        386   theParameters->SetMscStepLimitType(val);
343 }                                                 387 }
344                                                   388 
345 //....oooOO0OOooo........oooOO0OOooo........oo    389 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
346                                                   390 
347 inline G4double G4VMultipleScattering::LowestK    391 inline G4double G4VMultipleScattering::LowestKinEnergy() const
348 {                                                 392 {
349   return lowestKinEnergy;                         393   return lowestKinEnergy;
350 }                                                 394 }
351                                                   395 
352 //....oooOO0OOooo........oooOO0OOooo........oo    396 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
353                                                   397 
354 inline void G4VMultipleScattering::SetLowestKi    398 inline void G4VMultipleScattering::SetLowestKinEnergy(G4double val)
355 {                                                 399 {
356   lowestKinEnergy = val;                          400   lowestKinEnergy = val;
357 }                                                 401 }
358                                                   402 
359 //....oooOO0OOooo........oooOO0OOooo........oo    403 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
360                                                   404 
361 inline const G4ParticleDefinition* G4VMultiple    405 inline const G4ParticleDefinition* G4VMultipleScattering::FirstParticle() const
362 {                                                 406 {
363   return firstParticle;                           407   return firstParticle;
364 }                                                 408 }
365                                                   409 
366 //....oooOO0OOooo........oooOO0OOooo........oo    410 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
367                                                   411 
368 inline G4VMscModel* G4VMultipleScattering::EmM << 412 inline size_t G4VMultipleScattering::NumberOfModels() const
369 {                                              << 
370   return (index < mscModels.size()) ? mscModel << 
371 }                                              << 
372                                                << 
373 //....oooOO0OOooo........oooOO0OOooo........oo << 
374                                                << 
375 inline G4int G4VMultipleScattering::NumberOfMo << 
376 {                                              << 
377   return numberOfModels;                       << 
378 }                                              << 
379                                                << 
380 //....oooOO0OOooo........oooOO0OOooo........oo << 
381                                                << 
382 inline G4VMscModel*                            << 
383 G4VMultipleScattering::GetModelByIndex(G4int i << 
384 {                                              << 
385   // static cast is possible inside this class << 
386   return static_cast<G4VMscModel*>(modelManage << 
387 }                                              << 
388                                                << 
389 //....oooOO0OOooo........oooOO0OOooo........oo << 
390                                                << 
391 inline G4bool G4VMultipleScattering::UseBaseMa << 
392 {                                                 413 {
393   return baseMat;                              << 414   return modelManager->NumberOfModels();
394 }                                                 415 }
395                                                   416 
396 //....oooOO0OOooo........oooOO0OOooo........oo    417 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
397                                                   418 
398 #endif                                            419 #endif
399                                                   420