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