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 9.6.p1)


  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$
 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"                   << 
 77 #include "G4MscStepLimitType.hh"                   82 #include "G4MscStepLimitType.hh"
 78                                                    83 
 79 class G4ParticleDefinition;                        84 class G4ParticleDefinition;
 80 class G4VEnergyLossProcess;                        85 class G4VEnergyLossProcess;
 81 class G4LossTableManager;                          86 class G4LossTableManager;
 82 class G4SafetyHelper;                              87 class G4SafetyHelper;
 83                                                    88 
 84 //....oooOO0OOooo........oooOO0OOooo........oo     89 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 85                                                    90 
 86 class G4VMultipleScattering : public G4VContin     91 class G4VMultipleScattering : public G4VContinuousDiscreteProcess
 87 {                                                  92 {
 88 public:                                            93 public:
 89                                                    94 
 90   explicit G4VMultipleScattering(const G4Strin <<  95   G4VMultipleScattering(const G4String& name = "msc",
 91                                  G4ProcessType <<  96       G4ProcessType type = fElectromagnetic);
 92                                                    97 
 93   ~G4VMultipleScattering() override;           <<  98   virtual ~G4VMultipleScattering();
 94                                                    99 
 95   //------------------------------------------    100   //------------------------------------------------------------------------
 96   // Virtual methods to be implemented for the    101   // Virtual methods to be implemented for the concrete model
 97   //------------------------------------------    102   //------------------------------------------------------------------------
 98                                                   103 
 99   void ProcessDescription(std::ostream& outFil << 104   virtual G4bool IsApplicable(const G4ParticleDefinition& p) = 0;
100                                                << 
101   virtual void InitialiseProcess(const G4Parti << 
102                                                   105 
103   // Print out of generic class parameters     << 106   virtual void PrintInfo() = 0;
104   void StreamInfo(std::ostream& outFile, const << 
105                   G4bool rst = false) const;   << 
106                                                   107 
107 protected:                                        108 protected:
108                                                   109 
109   virtual void StreamProcessInfo(std::ostream& << 110   virtual void InitialiseProcess(const G4ParticleDefinition*) = 0;
110                                                   111 
111 public:                                           112 public:
112                                                   113 
113   //------------------------------------------    114   //------------------------------------------------------------------------
114   // Generic methods common to all ContinuousD    115   // Generic methods common to all ContinuousDiscrete processes
115   //------------------------------------------    116   //------------------------------------------------------------------------
116                                                   117 
117   // Initialise for build of tables               118   // Initialise for build of tables
118   void PreparePhysicsTable(const G4ParticleDef << 119   void PreparePhysicsTable(const G4ParticleDefinition&);
119                                                << 120   
120   // Build physics table during initialisation    121   // Build physics table during initialisation
121   void BuildPhysicsTable(const G4ParticleDefin << 122   void BuildPhysicsTable(const G4ParticleDefinition&);
                                                   >> 123 
                                                   >> 124   // Print out of generic class parameters
                                                   >> 125   void PrintInfoDefinition();
122                                                   126 
123   // Store PhysicsTable in a file.                127   // Store PhysicsTable in a file.
124   // Return false in case of failure at I/O       128   // Return false in case of failure at I/O
125   G4bool StorePhysicsTable(const G4ParticleDef    129   G4bool StorePhysicsTable(const G4ParticleDefinition*,
126                            const G4String& dir    130                            const G4String& directory,
127                            G4bool ascii = fals << 131          G4bool ascii = false);
128                                                   132 
129   // Retrieve Physics from a file.                133   // Retrieve Physics from a file.
130   // (return true if the Physics Table can be     134   // (return true if the Physics Table can be build by using file)
131   // (return false if the process has no funct    135   // (return false if the process has no functionality or in case of failure)
132   // File name should is constructed as proces    136   // File name should is constructed as processName+particleName and the
133   // should be placed under the directory spec << 137   // should be placed under the directory specifed by the argument.
134   G4bool RetrievePhysicsTable(const G4Particle    138   G4bool RetrievePhysicsTable(const G4ParticleDefinition*,
135                               const G4String&     139                               const G4String& directory,
136                               G4bool ascii) ov << 140             G4bool ascii);
137                                                   141 
138   // This is called in the beginning of tracki    142   // This is called in the beginning of tracking for a new track
139   void StartTracking(G4Track*) override;       << 143   void StartTracking(G4Track*);
140                                                   144 
141   // The function overloads the corresponding     145   // The function overloads the corresponding function of the base
142   // class.It limits the step near to boundari    146   // class.It limits the step near to boundaries only
143   // and invokes the method GetMscContinuousSt    147   // and invokes the method GetMscContinuousStepLimit at every step.
144   G4double AlongStepGetPhysicalInteractionLeng    148   G4double AlongStepGetPhysicalInteractionLength(
145                                         const  << 149                                             const G4Track&,
146                                         G4doub << 150               G4double  previousStepSize,
147                                         G4doub << 151               G4double  currentMinimalStep,
148                                         G4doub << 152               G4double& currentSafety,
149                                         G4GPIL << 153               G4GPILSelection* selection);
150                                                   154 
151   // The function overloads the corresponding     155   // The function overloads the corresponding function of the base
152   // class.                                       156   // class.
153   G4double PostStepGetPhysicalInteractionLengt    157   G4double PostStepGetPhysicalInteractionLength(
154                                       const G4 << 158                                             const G4Track&,
155                                       G4double << 159               G4double  previousStepSize,
156                                       G4ForceC << 160               G4ForceCondition* condition);
157                                                   161 
158   // Along step actions                           162   // Along step actions
159   G4VParticleChange* AlongStepDoIt(const G4Tra << 163   G4VParticleChange* AlongStepDoIt(const G4Track&, const G4Step&);
                                                   >> 164 
                                                   >> 165   // Post step actions
                                                   >> 166   G4VParticleChange* PostStepDoIt(const G4Track&, const G4Step&);
160                                                   167 
161   // This method does not used for tracking, i    168   // This method does not used for tracking, it is intended only for tests
162   G4double ContinuousStepLimit(const G4Track&     169   G4double ContinuousStepLimit(const G4Track& track,
163                                G4double previo << 170              G4double previousStepSize,
164                                G4double curren << 171              G4double currentMinimalStep,
165                                G4double& curre << 172              G4double& currentSafety);
166                                                << 
167   // hide assignment operator                  << 
168   G4VMultipleScattering(G4VMultipleScattering  << 
169   G4VMultipleScattering & operator=(const G4VM << 
170                                                   173 
171   //------------------------------------------    174   //------------------------------------------------------------------------
172   // Specific methods to set, access, modify m    175   // Specific methods to set, access, modify models
173   //------------------------------------------    176   //------------------------------------------------------------------------
174                                                   177 
175   // Select model in run time                     178   // Select model in run time
176   inline G4VEmModel* SelectModel(G4double kinE    179   inline G4VEmModel* SelectModel(G4double kinEnergy, size_t idx);
177                                                   180 
178 public:                                           181 public:
179                                                   182 
180   // Add model for region, smaller value of or    183   // Add model for region, smaller value of order defines which
181   // model will be selected for a given energy    184   // model will be selected for a given energy interval  
182   void AddEmModel(G4int order, G4VMscModel*, c << 185   void AddEmModel(G4int order, G4VEmModel*, const G4Region* region = 0);
183                                                   186 
184   // Assign a model to a process local list, t << 187   // Assign a model to a process - obsolete method will be removed
185   // the derived process should execute AddEmM << 188   void SetModel(G4VMscModel*, G4int index = 1);
186   void SetEmModel(G4VMscModel*, G4int idx = 0) << 
187                                                   189   
188   // return a model from the local list        << 190   // return the assigned model - obsolete method will be removed
189   inline G4VMscModel* EmModel(size_t index = 0 << 191   G4VMscModel* Model(G4int index = 1);
190                                                   192 
191   // Access to run time models                 << 193   // Assign a model to a process
192   inline G4int NumberOfModels() const;         << 194   void SetEmModel(G4VMscModel*, G4int index = 1);
                                                   >> 195   
                                                   >> 196   // return the assigned model
                                                   >> 197   G4VMscModel* EmModel(G4int index = 1);
193                                                   198 
194   inline G4VMscModel* GetModelByIndex(G4int id << 199   // Access to models by index
                                                   >> 200   G4VEmModel* GetModelByIndex(G4int idx = 0, G4bool ver = false) const;
195                                                   201 
196   //------------------------------------------    202   //------------------------------------------------------------------------
197   // Get/Set parameters for simulation of mult    203   // Get/Set parameters for simulation of multiple scattering
198   //------------------------------------------    204   //------------------------------------------------------------------------
199                                                   205 
                                                   >> 206   void SetIonisation(G4VEnergyLossProcess*);
                                                   >> 207 
200   inline G4bool LateralDisplasmentFlag() const    208   inline G4bool LateralDisplasmentFlag() const;
201                                                << 209   inline void SetLateralDisplasmentFlag(G4bool val);
                                                   >> 210 
202   inline G4double Skin() const;                   211   inline G4double Skin() const;
203                                                << 212   inline void SetSkin(G4double val);
                                                   >> 213 
204   inline G4double RangeFactor() const;            214   inline G4double RangeFactor() const;
205                                                << 215   inline void SetRangeFactor(G4double val);
                                                   >> 216 
206   inline G4double GeomFactor() const;             217   inline G4double GeomFactor() const;
207                                                << 218   inline void SetGeomFactor(G4double val);
                                                   >> 219 
208   inline G4double PolarAngleLimit() const;        220   inline G4double PolarAngleLimit() const;
                                                   >> 221   inline void SetPolarAngleLimit(G4double val);
209                                                   222 
210   inline G4bool UseBaseMaterial() const;       << 
211                                                << 
212   inline G4MscStepLimitType StepLimitType() co    223   inline G4MscStepLimitType StepLimitType() const;
213   inline void SetStepLimitType(G4MscStepLimitT    224   inline void SetStepLimitType(G4MscStepLimitType val);
214                                                   225 
215   inline G4double LowestKinEnergy() const;     << 
216   inline void SetLowestKinEnergy(G4double val) << 
217                                                << 
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);
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);
236                                                   244 
237 private:                                          245 private:
238                                                   246 
                                                   >> 247   // hide  assignment operator
                                                   >> 248   G4VMultipleScattering(G4VMultipleScattering &);
                                                   >> 249   G4VMultipleScattering & operator=(const G4VMultipleScattering &right);
                                                   >> 250 
239   // ======== Parameters of the class fixed at    251   // ======== Parameters of the class fixed at construction =========
240                                                   252 
241   G4EmModelManager*           modelManager;       253   G4EmModelManager*           modelManager;
242   G4LossTableManager*         emManager;          254   G4LossTableManager*         emManager;
243   G4EmParameters*             theParameters;   << 255   G4double                    geomMin;
244                                                   256 
245   // ======== Parameters of the class fixed at    257   // ======== Parameters of the class fixed at initialisation =======
246                                                   258 
247   G4SafetyHelper*             safetyHelper = n << 259   G4SafetyHelper*             safetyHelper;
248   const G4ParticleDefinition* firstParticle =  << 260 
249   const G4ParticleDefinition* currParticle = n << 
250                                                << 
251   std::vector<G4VMscModel*>   mscModels;          261   std::vector<G4VMscModel*>   mscModels;
                                                   >> 262   G4int                       numberOfModels;
                                                   >> 263 
                                                   >> 264   const G4ParticleDefinition* firstParticle;
                                                   >> 265   const G4ParticleDefinition* currParticle;
252                                                   266 
253   G4double                    facrange = 0.04; << 267   G4MscStepLimitType          stepLimit;
                                                   >> 268 
                                                   >> 269   G4double                    skin;
                                                   >> 270   G4double                    facrange;
                                                   >> 271   G4double                    facgeom;
                                                   >> 272   G4double                    polarAngleLimit;
254   G4double                    lowestKinEnergy;    273   G4double                    lowestKinEnergy;
255                                                   274 
256   // ======== Cached values - may be state dep << 275   G4bool                      latDisplasment;
                                                   >> 276   G4bool                      isIon;
                                                   >> 277 
                                                   >> 278   // ======== Cashed values - may be state dependent ================
257                                                   279 
258 protected:                                        280 protected:
259                                                   281 
                                                   >> 282   G4GPILSelection             valueGPILSelectionMSC;
260   G4ParticleChangeForMSC      fParticleChange;    283   G4ParticleChangeForMSC      fParticleChange;
261                                                   284 
262 private:                                          285 private:
263                                                   286 
264   G4ThreeVector               fNewPosition;    << 287   // cache
265   G4ThreeVector               fNewDirection;   << 288   G4VMscModel*                currentModel;
                                                   >> 289   G4VEnergyLossProcess*       fIonisation;
                                                   >> 290 
                                                   >> 291   G4double                    physStepLimit;
                                                   >> 292   G4double                    tPathLength;
                                                   >> 293   G4double                    gPathLength;
266                                                   294 
267   G4VMscModel*                currentModel = n << 295   G4ThreeVector               fNewPosition;
268   G4VEnergyLossProcess*       fIonisation = nu << 296   G4bool                      fPositionChanged;
                                                   >> 297   G4bool                      isActive;
269                                                   298 
270   G4double                    geomMin;         << 299   G4int                       warn;
271   G4double                    minDisplacement2 << 
272   G4double                    physStepLimit =  << 
273   G4double                    tPathLength = 0. << 
274   G4double                    gPathLength = 0. << 
275                                                << 
276   G4MscStepLimitType          stepLimit = fUse << 
277   G4int                       numberOfModels = << 
278                                                << 
279   G4bool                      latDisplacement  << 
280   G4bool                      isIon = false;   << 
281   G4bool                      fPositionChanged << 
282   G4bool                      isActive = false << 
283   G4bool                      baseMat = false; << 
284 };                                                300 };
285                                                   301 
286 // ======== Run time inline methods ==========    302 // ======== Run time inline methods ================
287                                                   303 
288 //....oooOO0OOooo........oooOO0OOooo........oo    304 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
289                                                   305 
290 inline G4VEmModel*                                306 inline G4VEmModel* 
291 G4VMultipleScattering::SelectModel(G4double ki    307 G4VMultipleScattering::SelectModel(G4double kinEnergy, size_t coupleIndex)
292 {                                                 308 {
293   return modelManager->SelectModel(kinEnergy,     309   return modelManager->SelectModel(kinEnergy, coupleIndex);
294 }                                                 310 }
295                                                   311 
296 //....oooOO0OOooo........oooOO0OOooo........oo    312 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
297                                                   313 
298 inline  G4bool G4VMultipleScattering::LateralD    314 inline  G4bool G4VMultipleScattering::LateralDisplasmentFlag() const
299 {                                                 315 {
300   return latDisplacement;                      << 316   return latDisplasment;
301 }                                              << 
302                                                << 
303 //....oooOO0OOooo........oooOO0OOooo........oo << 
304                                                << 
305 inline  G4double G4VMultipleScattering::Skin() << 
306 {                                              << 
307   return theParameters->MscSkin();             << 
308 }                                                 317 }
309                                                   318 
310 //....oooOO0OOooo........oooOO0OOooo........oo    319 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
311                                                   320 
312 inline  G4double G4VMultipleScattering::RangeF << 321 inline  void G4VMultipleScattering::SetLateralDisplasmentFlag(G4bool val)
313 {                                                 322 {
314   return facrange;                             << 323   latDisplasment = val;
315 }                                                 324 }
316                                                   325 
317 //....oooOO0OOooo........oooOO0OOooo........oo    326 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
318                                                   327 
319 inline  G4double G4VMultipleScattering::GeomFa << 328 inline  G4double G4VMultipleScattering::Skin() const
320 {                                                 329 {
321   return theParameters->MscGeomFactor();       << 330   return skin;
322 }                                                 331 }
323                                                   332 
324 //....oooOO0OOooo........oooOO0OOooo........oo    333 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
325                                                   334 
326 inline  G4double G4VMultipleScattering::PolarA << 335 inline  void G4VMultipleScattering::SetSkin(G4double val)
327 {                                                 336 {
328   return theParameters->MscThetaLimit();       << 337   if(val < 1.0) { skin = 0.0; }
                                                   >> 338   else          { skin = val; }
329 }                                                 339 }
330                                                   340 
331 //....oooOO0OOooo........oooOO0OOooo........oo    341 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
332                                                   342 
333 inline G4MscStepLimitType G4VMultipleScatterin << 343 inline  G4double G4VMultipleScattering::RangeFactor() const
334 {                                                 344 {
335   return stepLimit;                            << 345   return facrange;
336 }                                                 346 }
337                                                   347 
338 //....oooOO0OOooo........oooOO0OOooo........oo    348 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
339                                                   349 
340 inline void G4VMultipleScattering::SetStepLimi << 350 inline  void G4VMultipleScattering::SetRangeFactor(G4double val)
341 {                                                 351 {
342   theParameters->SetMscStepLimitType(val);     << 352   if(val > 0.0) facrange = val;
343 }                                                 353 }
344                                                   354 
345 //....oooOO0OOooo........oooOO0OOooo........oo    355 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
346                                                   356 
347 inline G4double G4VMultipleScattering::LowestK << 357 inline  G4double G4VMultipleScattering::GeomFactor() const
348 {                                                 358 {
349   return lowestKinEnergy;                      << 359   return facgeom;
350 }                                                 360 }
351                                                   361 
352 //....oooOO0OOooo........oooOO0OOooo........oo    362 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
353                                                   363 
354 inline void G4VMultipleScattering::SetLowestKi << 364 inline  void G4VMultipleScattering::SetGeomFactor(G4double val)
355 {                                                 365 {
356   lowestKinEnergy = val;                       << 366   if(val > 0.0) facgeom = val;
357 }                                                 367 }
358                                                   368 
359 //....oooOO0OOooo........oooOO0OOooo........oo    369 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
360                                                   370 
361 inline const G4ParticleDefinition* G4VMultiple << 371 inline  G4double G4VMultipleScattering::PolarAngleLimit() const
362 {                                                 372 {
363   return firstParticle;                        << 373   return polarAngleLimit;
364 }                                                 374 }
365                                                   375 
366 //....oooOO0OOooo........oooOO0OOooo........oo    376 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
367                                                   377 
368 inline G4VMscModel* G4VMultipleScattering::EmM << 378 inline  void G4VMultipleScattering::SetPolarAngleLimit(G4double val)
369 {                                                 379 {
370   return (index < mscModels.size()) ? mscModel << 380   if(val < 0.0)            { polarAngleLimit = 0.0; }
                                                   >> 381   else if(val > CLHEP::pi) { polarAngleLimit = CLHEP::pi; }
                                                   >> 382   else                     { polarAngleLimit = val; }
371 }                                                 383 }
372                                                   384 
373 //....oooOO0OOooo........oooOO0OOooo........oo    385 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
374                                                   386 
375 inline G4int G4VMultipleScattering::NumberOfMo << 387 inline G4MscStepLimitType G4VMultipleScattering::StepLimitType() const
376 {                                                 388 {
377   return numberOfModels;                       << 389   return stepLimit;
378 }                                                 390 }
379                                                   391 
380 //....oooOO0OOooo........oooOO0OOooo........oo    392 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
381                                                   393 
382 inline G4VMscModel*                            << 394 inline void G4VMultipleScattering::SetStepLimitType(G4MscStepLimitType val) 
383 G4VMultipleScattering::GetModelByIndex(G4int i << 
384 {                                                 395 {
385   // static cast is possible inside this class << 396   stepLimit = val;
386   return static_cast<G4VMscModel*>(modelManage << 397   if(val == fMinimal) { facrange = 0.2; }
387 }                                                 398 }
388                                                   399 
389 //....oooOO0OOooo........oooOO0OOooo........oo    400 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
390                                                   401 
391 inline G4bool G4VMultipleScattering::UseBaseMa << 402 inline const G4ParticleDefinition* G4VMultipleScattering::FirstParticle() const
392 {                                                 403 {
393   return baseMat;                              << 404   return firstParticle;
394 }                                                 405 }
395                                                   406 
396 //....oooOO0OOooo........oooOO0OOooo........oo    407 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
397                                                   408 
398 #endif                                            409 #endif
399                                                   410