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 6.0)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
                                                   >>  23 // $Id: G4VMultipleScattering.hh,v 1.15 2003/11/26 10:01:13 urban Exp $
                                                   >>  24 // GEANT4 tag $Name: geant4-06-00 $
 26 //                                                 25 //
 27 // -------------------------------------------     26 // -------------------------------------------------------------------
 28 //                                                 27 //
 29 // GEANT4 Class header file                        28 // GEANT4 Class header file
 30 //                                                 29 //
 31 //                                                 30 //
 32 // File name:     G4VMultipleScattering            31 // File name:     G4VMultipleScattering
 33 //                                                 32 //
 34 // Author:        Vladimir Ivanchenko on base      33 // Author:        Vladimir Ivanchenko on base of Laszlo Urban code
 35 //                                                 34 //
 36 // Creation date: 12.03.2002                       35 // Creation date: 12.03.2002
 37 //                                                 36 //
 38 // Modifications:                                  37 // Modifications:
 39 //                                                 38 //
 40 // 16-07-03 Update GetRange interface (V.Ivanc     39 // 16-07-03 Update GetRange interface (V.Ivanchenko)
 41 // 26-11-03 bugfix in AlongStepDoIt (L.Urban)  <<  40 //
 42 // 25-05-04 add protection against case when r << 
 43 // 27-08-04 Add InitialiseForRun method (V.Iva << 
 44 // 08-11-04 Migration to new interface of Stor << 
 45 // 15-04-05 remove boundary flag (V.Ivanchenko << 
 46 // 07-10-05 error in a protection in GetContin << 
 47 // 27-10-05 introduce virtual function MscStep << 
 48 // 26-01-06 Rename GetRange -> GetRangeFromRes << 
 49 // 17-02-06 Save table of transport cross sect << 
 50 // 07-03-06 Move step limit calculation to mod << 
 51 // 13-05-06 Add method to access model by inde << 
 52 // 12-02-07 Add get/set skin (V.Ivanchenko)    << 
 53 // 27-10-07 Virtual functions moved to source  << 
 54 // 15-07-08 Reorder class members for further  << 
 55 // 07-04-09 Moved msc methods from G4VEmModel  << 
 56 //                                                 41 //
 57 // Class Description:                              42 // Class Description:
 58 //                                                 43 //
 59 // It is the generic process of multiple scatt     44 // It is the generic process of multiple scattering it includes common
 60 // part of calculations for all charged partic     45 // part of calculations for all charged particles
                                                   >>  46 //
                                                   >>  47 // 26-11-03 bugfix in AlongStepDoIt (L.Urban)
 61                                                    48 
 62 // -------------------------------------------     49 // -------------------------------------------------------------------
 63 //                                                 50 //
 64                                                    51 
 65 #ifndef G4VMultipleScattering_h                    52 #ifndef G4VMultipleScattering_h
 66 #define G4VMultipleScattering_h 1                  53 #define G4VMultipleScattering_h 1
 67                                                    54 
 68 #include "G4VContinuousDiscreteProcess.hh"         55 #include "G4VContinuousDiscreteProcess.hh"
                                                   >>  56 #include "G4LossTableManager.hh"
 69 #include "globals.hh"                              57 #include "globals.hh"
 70 #include "G4Material.hh"                           58 #include "G4Material.hh"
                                                   >>  59 #include "G4MaterialCutsCouple.hh"
 71 #include "G4ParticleChangeForMSC.hh"               60 #include "G4ParticleChangeForMSC.hh"
 72 #include "G4Track.hh"                              61 #include "G4Track.hh"
 73 #include "G4Step.hh"                           << 
 74 #include "G4EmModelManager.hh"                     62 #include "G4EmModelManager.hh"
 75 #include "G4VMscModel.hh"                      <<  63 #include "G4VEmModel.hh"
 76 #include "G4EmParameters.hh"                   << 
 77 #include "G4MscStepLimitType.hh"               << 
 78                                                    64 
                                                   >>  65 class G4Step;
 79 class G4ParticleDefinition;                        66 class G4ParticleDefinition;
 80 class G4VEnergyLossProcess;                    <<  67 class G4DataVector;
 81 class G4LossTableManager;                      <<  68 class G4Navigator;
 82 class G4SafetyHelper;                          <<  69 class G4PhysicsTable;
                                                   >>  70 class G4PhysicsVector;
 83                                                    71 
 84 //....oooOO0OOooo........oooOO0OOooo........oo     72 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 85                                                    73 
 86 class G4VMultipleScattering : public G4VContin     74 class G4VMultipleScattering : public G4VContinuousDiscreteProcess
 87 {                                                  75 {
 88 public:                                            76 public:
 89                                                    77 
 90   explicit G4VMultipleScattering(const G4Strin <<  78   G4VMultipleScattering(const G4String& name = "msc",
 91                                  G4ProcessType <<  79                               G4ProcessType type = fElectromagnetic);
 92                                                << 
 93   ~G4VMultipleScattering() override;           << 
 94                                                << 
 95   //------------------------------------------ << 
 96   // Virtual methods to be implemented for the << 
 97   //------------------------------------------ << 
 98                                                    80 
 99   void ProcessDescription(std::ostream& outFil <<  81  ~G4VMultipleScattering();
100                                                    82 
101   virtual void InitialiseProcess(const G4Parti <<  83   virtual G4bool IsApplicable(const G4ParticleDefinition& p) = 0;
                                                   >>  84     // True for all charged particles
102                                                    85 
103   // Print out of generic class parameters     <<  86   virtual void BuildPhysicsTable(const G4ParticleDefinition&);
104   void StreamInfo(std::ostream& outFile, const <<  87     // Build physics table during initialisation
105                   G4bool rst = false) const;   << 
106                                                    88 
107 protected:                                     <<  89   G4VParticleChange* AlongStepDoIt(const G4Track&, const G4Step&);
108                                                << 
109   virtual void StreamProcessInfo(std::ostream& << 
110                                                    90 
111 public:                                        <<  91   G4VParticleChange* PostStepDoIt(const G4Track&, const G4Step&);
112                                                    92 
113   //------------------------------------------ << 
114   // Generic methods common to all ContinuousD << 
115   //------------------------------------------ << 
116                                                << 
117   // Initialise for build of tables            << 
118   void PreparePhysicsTable(const G4ParticleDef << 
119                                                << 
120   // Build physics table during initialisation << 
121   void BuildPhysicsTable(const G4ParticleDefin << 
122                                                << 
123   // Store PhysicsTable in a file.             << 
124   // Return false in case of failure at I/O    << 
125   G4bool StorePhysicsTable(const G4ParticleDef << 
126                            const G4String& dir << 
127                            G4bool ascii = fals << 
128                                                << 
129   // Retrieve Physics from a file.             << 
130   // (return true if the Physics Table can be  << 
131   // (return false if the process has no funct << 
132   // File name should is constructed as proces << 
133   // should be placed under the directory spec << 
134   G4bool RetrievePhysicsTable(const G4Particle << 
135                               const G4String&  << 
136                               G4bool ascii) ov << 
137                                                << 
138   // This is called in the beginning of tracki << 
139   void StartTracking(G4Track*) override;       << 
140                                                << 
141   // The function overloads the corresponding  << 
142   // class.It limits the step near to boundari << 
143   // and invokes the method GetMscContinuousSt << 
144   G4double AlongStepGetPhysicalInteractionLeng     93   G4double AlongStepGetPhysicalInteractionLength(
145                                         const  <<  94                                             const G4Track&,
146                                         G4doub <<  95                                                   G4double  previousStepSize,
147                                         G4doub <<  96                                                   G4double  currentMinimalStep,
148                                         G4doub <<  97                                                   G4double& currentSafety,
149                                         G4GPIL <<  98                                                   G4GPILSelection* selection);
150                                                <<  99      // The function overloads the corresponding function of the base
151   // The function overloads the corresponding  << 100      // class.It limits the step near to boundaries only
152   // class.                                    << 101      // and invokes the method GetContinuousStepLimit at every step.
153   G4double PostStepGetPhysicalInteractionLengt << 102 
154                                       const G4 << 103   virtual void PrintInfoDefinition();
155                                       G4double << 104   // Print out of the class parameters
156                                       G4ForceC << 105 
                                                   >> 106   void SetBinning(G4int nbins);
                                                   >> 107   G4int Binning() const;
                                                   >> 108     // Print out of the class parameters
                                                   >> 109 
                                                   >> 110   void SetMinKinEnergy(G4double e);
                                                   >> 111   G4double MinKinEnergy() const;
                                                   >> 112     // Print out of the class parameters
                                                   >> 113 
                                                   >> 114   void SetMaxKinEnergy(G4double e);
                                                   >> 115   G4double MaxKinEnergy() const;
                                                   >> 116     // Print out of the class parameters
                                                   >> 117 
                                                   >> 118   G4bool StorePhysicsTable(G4ParticleDefinition*,
                                                   >> 119                      const G4String& directory,
                                                   >> 120                            G4bool ascii = false);
                                                   >> 121     // Store PhysicsTable in a file.
                                                   >> 122     // Return false in case of failure at I/O
                                                   >> 123 
                                                   >> 124   G4bool RetrievePhysicsTable(G4ParticleDefinition*,
                                                   >> 125                         const G4String& directory,
                                                   >> 126                               G4bool ascii);
                                                   >> 127     // Retrieve Physics from a file.
                                                   >> 128     // (return true if the Physics Table can be build by using file)
                                                   >> 129     // (return false if the process has no functionality or in case of failure)
                                                   >> 130     // File name should is constructed as processName+particleName and the
                                                   >> 131     // should be placed under the directory specifed by the argument.
157                                                   132 
158   // Along step actions                        << 133   void AddEmModel(G4int, G4VEmModel*, const G4Region* region = 0);
159   G4VParticleChange* AlongStepDoIt(const G4Tra << 
160                                                   134 
161   // This method does not used for tracking, i << 
162   G4double ContinuousStepLimit(const G4Track&     135   G4double ContinuousStepLimit(const G4Track& track,
163                                G4double previo << 136                                      G4double previousStepSize,
164                                G4double curren << 137                                      G4double currentMinimalStep,
165                                G4double& curre << 138                                      G4double& currentSafety);
166                                                << 139   // This method does not used for tracking, it is intended only for tests
167   // hide assignment operator                  << 
168   G4VMultipleScattering(G4VMultipleScattering  << 
169   G4VMultipleScattering & operator=(const G4VM << 
170                                                << 
171   //------------------------------------------ << 
172   // Specific methods to set, access, modify m << 
173   //------------------------------------------ << 
174                                                   140 
175   // Select model in run time                  << 141   G4bool LateralDisplasmentFlag() const;
176   inline G4VEmModel* SelectModel(G4double kinE << 142   void SetLateralDisplasmentFlag(G4bool val);
                                                   >> 143      // lateral displacement to be/not to be computed
                                                   >> 144 
                                                   >> 145   G4bool BoundaryAlgorithmFlag() const;
                                                   >> 146   void SetBoundary(G4bool val);
                                                   >> 147      // boundary algorith is/isnt active
                                                   >> 148 
                                                   >> 149   void SetBuildLambdaTable(G4bool val);
                                                   >> 150 
                                                   >> 151   virtual G4double TruePathLengthLimit(const G4Track& track,
                                                   >> 152                                              G4double& lambda,
                                                   >> 153                                              G4double currentMinimalStep) = 0;
177                                                   154 
178 public:                                        << 
179                                                << 
180   // Add model for region, smaller value of or << 
181   // model will be selected for a given energy << 
182   void AddEmModel(G4int order, G4VMscModel*, c << 
183                                                << 
184   // Assign a model to a process local list, t << 
185   // the derived process should execute AddEmM << 
186   void SetEmModel(G4VMscModel*, G4int idx = 0) << 
187                                                << 
188   // return a model from the local list        << 
189   inline G4VMscModel* EmModel(size_t index = 0 << 
190                                                << 
191   // Access to run time models                 << 
192   inline G4int NumberOfModels() const;         << 
193                                                << 
194   inline G4VMscModel* GetModelByIndex(G4int id << 
195                                                << 
196   //------------------------------------------ << 
197   // Get/Set parameters for simulation of mult << 
198   //------------------------------------------ << 
199                                                << 
200   inline G4bool LateralDisplasmentFlag() const << 
201                                                << 
202   inline G4double Skin() const;                << 
203                                                << 
204   inline G4double RangeFactor() const;         << 
205                                                << 
206   inline G4double GeomFactor() const;          << 
207                                                << 
208   inline G4double PolarAngleLimit() const;     << 
209                                                << 
210   inline G4bool UseBaseMaterial() const;       << 
211                                                << 
212   inline G4MscStepLimitType StepLimitType() co << 
213   inline void SetStepLimitType(G4MscStepLimitT << 
214                                                << 
215   inline G4double LowestKinEnergy() const;     << 
216   inline void SetLowestKinEnergy(G4double val) << 
217                                                << 
218   inline const G4ParticleDefinition* FirstPart << 
219                                                << 
220   //------------------------------------------ << 
221   // Run time methods                          << 
222   //------------------------------------------ << 
223                                                   155 
224 protected:                                        156 protected:
225                                                   157 
226   // This method is not used for tracking, it  << 158   virtual void InitialiseProcess(const G4ParticleDefinition&) = 0;
                                                   >> 159 
227   G4double GetMeanFreePath(const G4Track& trac    160   G4double GetMeanFreePath(const G4Track& track,
228                            G4double,           << 161                                  G4double,
229                            G4ForceCondition* c << 162                                  G4ForceCondition* condition);
                                                   >> 163   // This method is used for tracking, it returns mean free path value
                                                   >> 164 
                                                   >> 165   G4double GetLambda(const G4ParticleDefinition* p, G4double& kineticEnergy);
230                                                   166 
231   // This method is not used for tracking, it  << 
232   G4double GetContinuousStepLimit(const G4Trac    167   G4double GetContinuousStepLimit(const G4Track& track,
233                                   G4double pre << 168                                         G4double previousStepSize,
234                                   G4double cur << 169                                         G4double currentMinimalStep,
235                                   G4double& cu << 170                                         G4double& currentSafety);
                                                   >> 171   // This method is used for tracking, it returns step limit
236                                                   172 
237 private:                                       << 173   virtual G4PhysicsVector* PhysicsVector(const G4MaterialCutsCouple*);
                                                   >> 174   // Build empty Physics Vector
238                                                   175 
239   // ======== Parameters of the class fixed at << 176   void SelectModel(G4double& kinEnergy);
                                                   >> 177   // Select concrete model
240                                                   178 
241   G4EmModelManager*           modelManager;    << 179   size_t CurrentMaterialCutsCoupleIndex() const {return currentMaterialIndex;};
242   G4LossTableManager*         emManager;       << 180   // Return current index
243   G4EmParameters*             theParameters;   << 
244                                                   181 
245   // ======== Parameters of the class fixed at << 182   G4double CurrentRange() const {return currentRange;};
246                                                   183 
247   G4SafetyHelper*             safetyHelper = n << 184 private:
248   const G4ParticleDefinition* firstParticle =  << 
249   const G4ParticleDefinition* currParticle = n << 
250                                                << 
251   std::vector<G4VMscModel*>   mscModels;       << 
252                                                   185 
253   G4double                    facrange = 0.04; << 186   void DefineMaterial(const G4MaterialCutsCouple* couple);
254   G4double                    lowestKinEnergy; << 187   // define current material
255                                                   188 
256   // ======== Cached values - may be state dep << 189   // hide  assignment operator
257                                                   190 
258 protected:                                     << 191   G4VMultipleScattering(G4VMultipleScattering &);
                                                   >> 192   G4VMultipleScattering & operator=(const G4VMultipleScattering &right);
259                                                   193 
260   G4ParticleChangeForMSC      fParticleChange; << 194 // =====================================================================
261                                                   195 
262 private:                                          196 private:
263                                                   197 
264   G4ThreeVector               fNewPosition;    << 198   G4ParticleChangeForMSC      fParticleChange;
265   G4ThreeVector               fNewDirection;   << 199   G4EmModelManager*           modelManager;
                                                   >> 200   G4Navigator*                navigator;
                                                   >> 201   G4VEmModel*                 currentModel;
266                                                   202 
267   G4VMscModel*                currentModel = n << 203   // tables and vectors
268   G4VEnergyLossProcess*       fIonisation = nu << 204   G4PhysicsTable*             theLambdaTable;
269                                                   205 
270   G4double                    geomMin;         << 206   // cash
271   G4double                    minDisplacement2 << 207   const G4ParticleDefinition* currentParticle;
272   G4double                    physStepLimit =  << 208   const G4MaterialCutsCouple* currentCouple;
273   G4double                    tPathLength = 0. << 209   size_t                      currentMaterialIndex;
274   G4double                    gPathLength = 0. << 210 
275                                                << 211   G4int                       nBins;
276   G4MscStepLimitType          stepLimit = fUse << 212 
277   G4int                       numberOfModels = << 213   G4double                    minKinEnergy;
278                                                << 214   G4double                    maxKinEnergy;
279   G4bool                      latDisplacement  << 215 
280   G4bool                      isIon = false;   << 216   G4double                    trueStepLength;
281   G4bool                      fPositionChanged << 217   G4double                    truePathLength;
282   G4bool                      isActive = false << 218   G4double                    geomPathLength;
283   G4bool                      baseMat = false; << 219   G4double                    lambda0;
                                                   >> 220   G4double                    currentRange;
                                                   >> 221 
                                                   >> 222   G4GPILSelection             valueGPILSelectionMSC;
                                                   >> 223   G4bool                      boundary;
                                                   >> 224   G4bool                      latDisplasment;
                                                   >> 225   G4bool                      buildLambdaTable;
284 };                                                226 };
285                                                   227 
286 // ======== Run time inline methods ========== << 228 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
                                                   >> 229 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
                                                   >> 230 
                                                   >> 231 inline void G4VMultipleScattering::DefineMaterial(const G4MaterialCutsCouple* couple)
                                                   >> 232 {
                                                   >> 233   if(couple != currentCouple) {
                                                   >> 234     currentCouple   = couple;
                                                   >> 235     currentMaterialIndex = couple->GetIndex();
                                                   >> 236   }
                                                   >> 237 }
287                                                   238 
288 //....oooOO0OOooo........oooOO0OOooo........oo    239 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
289                                                   240 
290 inline G4VEmModel*                             << 241 inline G4double G4VMultipleScattering::GetMeanFreePath(const G4Track&,
291 G4VMultipleScattering::SelectModel(G4double ki << 242                                                              G4double,
                                                   >> 243                                                              G4ForceCondition* cond)
292 {                                                 244 {
293   return modelManager->SelectModel(kinEnergy,  << 245   *cond = Forced;
                                                   >> 246   return DBL_MAX;
                                                   >> 247 }
                                                   >> 248 
                                                   >> 249 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
                                                   >> 250 
                                                   >> 251 inline G4double G4VMultipleScattering::AlongStepGetPhysicalInteractionLength(
                                                   >> 252                              const G4Track& track,
                                                   >> 253                              G4double previousStepSize,
                                                   >> 254                              G4double currentMinimalStep,
                                                   >> 255                              G4double& currentSafety,
                                                   >> 256                              G4GPILSelection* selection)
                                                   >> 257 {
                                                   >> 258   // get Step limit proposed by the process
                                                   >> 259   valueGPILSelectionMSC = NotCandidateForSelection;
                                                   >> 260   G4double steplength = GetContinuousStepLimit(track,previousStepSize,
                                                   >> 261                                               currentMinimalStep,currentSafety);
                                                   >> 262   // set return value for G4GPILSelection
                                                   >> 263   *selection = valueGPILSelectionMSC;
                                                   >> 264   return  steplength;
294 }                                                 265 }
295                                                   266 
296 //....oooOO0OOooo........oooOO0OOooo........oo    267 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
297                                                   268 
298 inline  G4bool G4VMultipleScattering::LateralD << 269 inline G4double G4VMultipleScattering::GetContinuousStepLimit(
                                                   >> 270                                           const G4Track& track,
                                                   >> 271                                                 G4double,
                                                   >> 272                                                 G4double currentMinimalStep,
                                                   >> 273                                                 G4double&)
                                                   >> 274 {
                                                   >> 275   DefineMaterial(track.GetMaterialCutsCouple());
                                                   >> 276   G4double e = track.GetKineticEnergy();
                                                   >> 277   SelectModel(e);
                                                   >> 278   const G4ParticleDefinition* p = track.GetDefinition();
                                                   >> 279   lambda0 = GetLambda(p, e);
                                                   >> 280   currentRange = G4LossTableManager::Instance()->GetRange(p,e,currentCouple);
                                                   >> 281   truePathLength = TruePathLengthLimit(track,lambda0,currentMinimalStep);
                                                   >> 282   //G4cout << "StepLimit: tpl= " << truePathLength << " lambda0= "
                                                   >> 283   //       << lambda0 << " range= " << currentRange
                                                   >> 284   //       << " currentMinStep= " << currentMinimalStep << G4endl;
                                                   >> 285   if (truePathLength < currentMinimalStep) valueGPILSelectionMSC = CandidateForSelection;
                                                   >> 286   geomPathLength = currentModel->GeomPathLength(theLambdaTable,currentCouple,
                                                   >> 287            p,e,lambda0,currentRange,truePathLength);
                                                   >> 288   if(geomPathLength > lambda0) geomPathLength = lambda0;
                                                   >> 289   return geomPathLength;
                                                   >> 290 }
                                                   >> 291 
                                                   >> 292 
                                                   >> 293 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
                                                   >> 294 
                                                   >> 295 inline G4double G4VMultipleScattering::ContinuousStepLimit(
                                                   >> 296                                        const G4Track& track,
                                                   >> 297                                        G4double previousStepSize,
                                                   >> 298                                        G4double currentMinimalStep,
                                                   >> 299                                        G4double& currentSafety)
299 {                                                 300 {
300   return latDisplacement;                      << 301   return GetContinuousStepLimit(track,previousStepSize,currentMinimalStep,
                                                   >> 302                                       currentSafety);
301 }                                                 303 }
302                                                   304 
303 //....oooOO0OOooo........oooOO0OOooo........oo    305 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
304                                                   306 
305 inline  G4double G4VMultipleScattering::Skin() << 307 inline G4double G4VMultipleScattering::GetLambda(const G4ParticleDefinition* p, G4double& e)
306 {                                                 308 {
307   return theParameters->MscSkin();             << 309   G4double x;
                                                   >> 310   if(theLambdaTable) {
                                                   >> 311     G4bool b;
                                                   >> 312     x = ((*theLambdaTable)[currentMaterialIndex])->GetValue(e, b);
                                                   >> 313 
                                                   >> 314   } else {
                                                   >> 315     x = currentModel->CrossSection(currentCouple,p,e,0.0,1.0);
                                                   >> 316   }
                                                   >> 317   return x;
308 }                                                 318 }
309                                                   319 
310 //....oooOO0OOooo........oooOO0OOooo........oo    320 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
311                                                   321 
312 inline  G4double G4VMultipleScattering::RangeF << 322 inline G4VParticleChange* G4VMultipleScattering::AlongStepDoIt(
                                                   >> 323                                                         const G4Track& track,
                                                   >> 324                                                         const G4Step& step)
313 {                                                 325 {
314   return facrange;                             << 326   fParticleChange.Initialize(track);
                                                   >> 327   G4double geomStepLength = step.GetStepLength();
                                                   >> 328   if((geomStepLength == geomPathLength) && (truePathLength <= currentRange))
                                                   >> 329      trueStepLength = truePathLength;
                                                   >> 330   else  
                                                   >> 331      trueStepLength = currentModel->TrueStepLength(geomStepLength);
                                                   >> 332   fParticleChange.SetTrueStepLength(trueStepLength);
                                                   >> 333   return &fParticleChange;
315 }                                                 334 }
316                                                   335 
317 //....oooOO0OOooo........oooOO0OOooo........oo    336 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
318                                                   337 
319 inline  G4double G4VMultipleScattering::GeomFa << 338 inline void G4VMultipleScattering::SelectModel(G4double& kinEnergy)
320 {                                                 339 {
321   return theParameters->MscGeomFactor();       << 340   currentModel = modelManager->SelectModel(kinEnergy, currentMaterialIndex);
322 }                                                 341 }
323                                                   342 
324 //....oooOO0OOooo........oooOO0OOooo........oo    343 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
325                                                   344 
326 inline  G4double G4VMultipleScattering::PolarA << 345 inline void G4VMultipleScattering::SetBinning(G4int nbins)
327 {                                                 346 {
328   return theParameters->MscThetaLimit();       << 347   nBins = nbins;
329 }                                                 348 }
330                                                   349 
331 //....oooOO0OOooo........oooOO0OOooo........oo    350 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
332                                                   351 
333 inline G4MscStepLimitType G4VMultipleScatterin << 352 inline G4int G4VMultipleScattering::Binning() const
334 {                                                 353 {
335   return stepLimit;                            << 354   return nBins;
336 }                                                 355 }
337                                                   356 
338 //....oooOO0OOooo........oooOO0OOooo........oo    357 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
339                                                   358 
340 inline void G4VMultipleScattering::SetStepLimi << 359 inline void G4VMultipleScattering::SetMinKinEnergy(G4double e)
341 {                                                 360 {
342   theParameters->SetMscStepLimitType(val);     << 361   minKinEnergy = e;
343 }                                                 362 }
344                                                   363 
345 //....oooOO0OOooo........oooOO0OOooo........oo    364 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
346                                                   365 
347 inline G4double G4VMultipleScattering::LowestK << 366 inline G4double G4VMultipleScattering::MinKinEnergy() const
348 {                                                 367 {
349   return lowestKinEnergy;                      << 368   return minKinEnergy;
350 }                                                 369 }
351                                                   370 
352 //....oooOO0OOooo........oooOO0OOooo........oo    371 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
353                                                   372 
354 inline void G4VMultipleScattering::SetLowestKi << 373 inline void G4VMultipleScattering::SetMaxKinEnergy(G4double e)
355 {                                                 374 {
356   lowestKinEnergy = val;                       << 375   maxKinEnergy = e;
357 }                                                 376 }
358                                                   377 
359 //....oooOO0OOooo........oooOO0OOooo........oo    378 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
360                                                   379 
361 inline const G4ParticleDefinition* G4VMultiple << 380 inline G4double G4VMultipleScattering::MaxKinEnergy() const
                                                   >> 381 {
                                                   >> 382   return maxKinEnergy;
                                                   >> 383 }
                                                   >> 384 
                                                   >> 385 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
                                                   >> 386 
                                                   >> 387 inline  G4bool G4VMultipleScattering::LateralDisplasmentFlag() const
362 {                                                 388 {
363   return firstParticle;                        << 389   return latDisplasment;
364 }                                                 390 }
365                                                   391 
366 //....oooOO0OOooo........oooOO0OOooo........oo    392 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
367                                                   393 
368 inline G4VMscModel* G4VMultipleScattering::EmM << 394 inline  void G4VMultipleScattering::SetLateralDisplasmentFlag(G4bool val)
369 {                                                 395 {
370   return (index < mscModels.size()) ? mscModel << 396   latDisplasment = val;
371 }                                                 397 }
372                                                   398 
373 //....oooOO0OOooo........oooOO0OOooo........oo    399 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
374                                                   400 
375 inline G4int G4VMultipleScattering::NumberOfMo << 401 inline  G4bool G4VMultipleScattering::BoundaryAlgorithmFlag() const
376 {                                                 402 {
377   return numberOfModels;                       << 403   return boundary;
378 }                                                 404 }
379                                                   405 
380 //....oooOO0OOooo........oooOO0OOooo........oo    406 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
381                                                   407 
382 inline G4VMscModel*                            << 408 inline  void G4VMultipleScattering::SetBoundary(G4bool val)
383 G4VMultipleScattering::GetModelByIndex(G4int i << 
384 {                                                 409 {
385   // static cast is possible inside this class << 410   boundary = val;
386   return static_cast<G4VMscModel*>(modelManage << 
387 }                                                 411 }
388                                                   412 
389 //....oooOO0OOooo........oooOO0OOooo........oo    413 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
390                                                   414 
391 inline G4bool G4VMultipleScattering::UseBaseMa << 415 inline  void G4VMultipleScattering::SetBuildLambdaTable(G4bool val)
392 {                                                 416 {
393   return baseMat;                              << 417   buildLambdaTable = val;
394 }                                                 418 }
395                                                   419 
396 //....oooOO0OOooo........oooOO0OOooo........oo    420 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
397                                                   421 
398 #endif                                            422 #endif
399                                                   423