| 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,v 1.46 2007/06/11 14:56:51 vnivanch Exp $
>> 27 // GEANT4 tag $Name: geant4-09-00 $
26 // 28 //
27 // ------------------------------------------- 29 // -------------------------------------------------------------------
28 // 30 //
29 // GEANT4 Class header file 31 // GEANT4 Class header file
30 // 32 //
31 // 33 //
32 // File name: G4VMultipleScattering 34 // File name: G4VMultipleScattering
33 // 35 //
34 // Author: Vladimir Ivanchenko on base 36 // Author: Vladimir Ivanchenko on base of Laszlo Urban code
35 // 37 //
36 // Creation date: 12.03.2002 38 // Creation date: 12.03.2002
37 // 39 //
38 // Modifications: 40 // Modifications:
39 // 41 //
40 // 16-07-03 Update GetRange interface (V.Ivanc 42 // 16-07-03 Update GetRange interface (V.Ivanchenko)
>> 43 //
>> 44 //
>> 45 // Class Description:
>> 46 //
>> 47 // It is the generic process of multiple scattering it includes common
>> 48 // part of calculations for all charged particles
>> 49 //
41 // 26-11-03 bugfix in AlongStepDoIt (L.Urban) 50 // 26-11-03 bugfix in AlongStepDoIt (L.Urban)
42 // 25-05-04 add protection against case when r 51 // 25-05-04 add protection against case when range is less than steplimit (VI)
>> 52 // 30-06-04 make destructor virtual (V.Ivanchenko)
43 // 27-08-04 Add InitialiseForRun method (V.Iva 53 // 27-08-04 Add InitialiseForRun method (V.Ivanchneko)
44 // 08-11-04 Migration to new interface of Stor 54 // 08-11-04 Migration to new interface of Store/Retrieve tables (V.Ivanchenko)
>> 55 // 15-04-05 optimize internal interfaces (V.Ivanchenko)
45 // 15-04-05 remove boundary flag (V.Ivanchenko 56 // 15-04-05 remove boundary flag (V.Ivanchenko)
46 // 07-10-05 error in a protection in GetContin 57 // 07-10-05 error in a protection in GetContinuousStepLimit corrected (L.Urban)
47 // 27-10-05 introduce virtual function MscStep 58 // 27-10-05 introduce virtual function MscStepLimitation() (V.Ivanchenko)
48 // 26-01-06 Rename GetRange -> GetRangeFromRes 59 // 26-01-06 Rename GetRange -> GetRangeFromRestricteDEDX (V.Ivanchenko)
49 // 17-02-06 Save table of transport cross sect 60 // 17-02-06 Save table of transport cross sections not mfp (V.Ivanchenko)
50 // 07-03-06 Move step limit calculation to mod 61 // 07-03-06 Move step limit calculation to model (V.Ivanchenko)
51 // 13-05-06 Add method to access model by inde 62 // 13-05-06 Add method to access model by index (V.Ivanchenko)
52 // 12-02-07 Add get/set skin (V.Ivanchenko) 63 // 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 // <<
57 // Class Description: <<
58 // 64 //
59 // It is the generic process of multiple scatt <<
60 // part of calculations for all charged partic <<
61 65
62 // ------------------------------------------- 66 // -------------------------------------------------------------------
63 // 67 //
64 68
65 #ifndef G4VMultipleScattering_h 69 #ifndef G4VMultipleScattering_h
66 #define G4VMultipleScattering_h 1 70 #define G4VMultipleScattering_h 1
67 71
68 #include "G4VContinuousDiscreteProcess.hh" 72 #include "G4VContinuousDiscreteProcess.hh"
>> 73 #include "G4LossTableManager.hh"
69 #include "globals.hh" 74 #include "globals.hh"
70 #include "G4Material.hh" 75 #include "G4Material.hh"
>> 76 #include "G4MaterialCutsCouple.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 "G4VEmModel.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 G4DataVector;
81 class G4LossTableManager; << 86 class G4PhysicsTable;
82 class G4SafetyHelper; << 87 class G4PhysicsVector;
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;
>> 105 // True for all charged particles
100 106
101 virtual void InitialiseProcess(const G4Parti << 107 virtual void PrintInfo() = 0;
102 <<
103 // Print out of generic class parameters <<
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
>> 113 //------------------------------------------------------------------------
>> 114 // Methods with standard implementation; may be overwritten if needed
>> 115 //------------------------------------------------------------------------
111 public: 116 public:
112 117
113 //------------------------------------------ 118 //------------------------------------------------------------------------
114 // Generic methods common to all ContinuousD 119 // Generic methods common to all ContinuousDiscrete processes
115 //------------------------------------------ 120 //------------------------------------------------------------------------
116 121
117 // Initialise for build of tables 122 // Initialise for build of tables
118 void PreparePhysicsTable(const G4ParticleDef << 123 virtual void PreparePhysicsTable(const G4ParticleDefinition&);
119 << 124
120 // Build physics table during initialisation 125 // Build physics table during initialisation
121 void BuildPhysicsTable(const G4ParticleDefin << 126 virtual void BuildPhysicsTable(const G4ParticleDefinition&);
>> 127
>> 128 // Print out of generic class parameters
>> 129 void PrintInfoDefinition();
>> 130
>> 131 inline virtual G4VParticleChange* AlongStepDoIt(const G4Track&, const G4Step&);
>> 132
>> 133 inline virtual G4VParticleChange* PostStepDoIt(const G4Track&, const G4Step&);
122 134
123 // Store PhysicsTable in a file. 135 // Store PhysicsTable in a file.
124 // Return false in case of failure at I/O 136 // Return false in case of failure at I/O
125 G4bool StorePhysicsTable(const G4ParticleDef 137 G4bool StorePhysicsTable(const G4ParticleDefinition*,
126 const G4String& dir 138 const G4String& directory,
127 G4bool ascii = fals << 139 G4bool ascii = false);
128 140
129 // Retrieve Physics from a file. 141 // Retrieve Physics from a file.
130 // (return true if the Physics Table can be 142 // (return true if the Physics Table can be build by using file)
131 // (return false if the process has no funct 143 // (return false if the process has no functionality or in case of failure)
132 // File name should is constructed as proces 144 // File name should is constructed as processName+particleName and the
133 // should be placed under the directory spec << 145 // should be placed under the directory specifed by the argument.
134 G4bool RetrievePhysicsTable(const G4Particle 146 G4bool RetrievePhysicsTable(const G4ParticleDefinition*,
135 const G4String& 147 const G4String& directory,
136 G4bool ascii) ov << 148 G4bool ascii);
>> 149
>> 150 //------------------------------------------------------------------------
>> 151 // Specific methods for multiple scattering
>> 152 //------------------------------------------------------------------------
137 153
138 // This is called in the beginning of tracki << 154 // Build empty Physics Vector
139 void StartTracking(G4Track*) override; << 155 G4PhysicsVector* PhysicsVector(const G4MaterialCutsCouple*);
140 156
141 // The function overloads the corresponding 157 // The function overloads the corresponding function of the base
142 // class.It limits the step near to boundari 158 // class.It limits the step near to boundaries only
143 // and invokes the method GetMscContinuousSt 159 // and invokes the method GetMscContinuousStepLimit at every step.
144 G4double AlongStepGetPhysicalInteractionLeng << 160 inline virtual G4double AlongStepGetPhysicalInteractionLength(
145 const << 161 const G4Track&,
146 G4doub << 162 G4double previousStepSize,
147 G4doub << 163 G4double currentMinimalStep,
148 G4doub << 164 G4double& currentSafety,
149 G4GPIL << 165 G4GPILSelection* selection);
150 166
151 // The function overloads the corresponding 167 // The function overloads the corresponding function of the base
152 // class. 168 // class.
153 G4double PostStepGetPhysicalInteractionLengt << 169 inline virtual G4double PostStepGetPhysicalInteractionLength(
154 const G4 << 170 const G4Track&,
155 G4double << 171 G4double previousStepSize,
156 G4ForceC << 172 G4ForceCondition* condition);
157 <<
158 // Along step actions <<
159 G4VParticleChange* AlongStepDoIt(const G4Tra <<
160 173
161 // This method does not used for tracking, i 174 // This method does not used for tracking, it is intended only for tests
162 G4double ContinuousStepLimit(const G4Track& << 175 inline virtual G4double ContinuousStepLimit(const G4Track& track,
163 G4double previo << 176 G4double previousStepSize,
164 G4double curren << 177 G4double currentMinimalStep,
165 G4double& curre << 178 G4double& currentSafety);
166 <<
167 // hide assignment operator <<
168 G4VMultipleScattering(G4VMultipleScattering <<
169 G4VMultipleScattering & operator=(const G4VM <<
170 179
171 //------------------------------------------ 180 //------------------------------------------------------------------------
172 // Specific methods to set, access, modify m << 181 // Specific methods to build and access Physics Tables
173 //------------------------------------------ 182 //------------------------------------------------------------------------
174 183
175 // Select model in run time << 184 inline void SetBinning(G4int nbins);
176 inline G4VEmModel* SelectModel(G4double kinE << 185 inline G4int Binning() const;
177 186
178 public: << 187 inline void SetMinKinEnergy(G4double e);
>> 188 inline G4double MinKinEnergy() const;
>> 189 // Print out of the class parameters
179 190
180 // Add model for region, smaller value of or << 191 inline void SetMaxKinEnergy(G4double e);
181 // model will be selected for a given energy << 192 inline G4double MaxKinEnergy() const;
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 193
191 // Access to run time models << 194 inline void SetBuildLambdaTable(G4bool val);
192 inline G4int NumberOfModels() const; <<
193 195
194 inline G4VMscModel* GetModelByIndex(G4int id << 196 inline G4PhysicsTable* LambdaTable() const;
195 197
196 //------------------------------------------ 198 //------------------------------------------------------------------------
197 // Get/Set parameters for simulation of mult << 199 // Define and access particle type
198 //------------------------------------------ 200 //------------------------------------------------------------------------
199 201
200 inline G4bool LateralDisplasmentFlag() const << 202 inline const G4ParticleDefinition* Particle() const;
201 << 203 inline void SetParticle(const G4ParticleDefinition*);
202 inline G4double Skin() const; << 204
203 << 205 //------------------------------------------------------------------------
204 inline G4double RangeFactor() const; << 206 // Specific methods to set, access, modify models
205 << 207 //------------------------------------------------------------------------
206 inline G4double GeomFactor() const; << 208
207 << 209 void AddEmModel(G4int, G4VEmModel*, const G4Region* region = 0);
208 inline G4double PolarAngleLimit() const; << 210
>> 211 inline G4VEmModel* SelectModelForMaterial(G4double kinEnergy, size_t& idxRegion) const;
>> 212
>> 213 // Access to models
>> 214 inline G4VEmModel* GetModelByIndex(G4int idx = 0);
>> 215
>> 216 //------------------------------------------------------------------------
>> 217 // Parameters for simulation of multiple scattering
>> 218 //------------------------------------------------------------------------
>> 219
>> 220 inline void SetLateralDisplasmentFlag(G4bool val);
>> 221 // lateral displacement to be/not to be computed
>> 222
>> 223 inline void SetSkin(G4double val);
>> 224 // skin parameter
>> 225
>> 226 inline void SetRangeFactor(G4double val);
>> 227 // FactorRange parameter
>> 228
>> 229 inline void SetGeomFactor(G4double val);
>> 230 // FactorRange parameter
209 231
210 inline G4bool UseBaseMaterial() const; <<
211 <<
212 inline G4MscStepLimitType StepLimitType() co <<
213 inline void SetStepLimitType(G4MscStepLimitT 232 inline void SetStepLimitType(G4MscStepLimitType val);
>> 233 // FactorRange parameter
214 234
215 inline G4double LowestKinEnergy() const; << 235 protected:
216 inline void SetLowestKinEnergy(G4double val) <<
217 236
218 inline const G4ParticleDefinition* FirstPart << 237 // This method is used for tracking, it returns mean free path value
>> 238 inline virtual G4double GetMeanFreePath(const G4Track& track,
>> 239 G4double,
>> 240 G4ForceCondition* condition);
219 241
220 //------------------------------------------ 242 //------------------------------------------------------------------------
221 // Run time methods 243 // Run time methods
222 //------------------------------------------ 244 //------------------------------------------------------------------------
223 245
224 protected: << 246 inline G4double GetLambda(const G4ParticleDefinition* p, G4double& kineticEnergy);
225 247
226 // This method is not used for tracking, it << 248 // This method is used for tracking, it returns step limit
227 G4double GetMeanFreePath(const G4Track& trac << 249 inline G4double GetMscContinuousStepLimit(const G4Track& track,
228 G4double, << 250 G4double previousStepSize,
229 G4ForceCondition* c << 251 G4double currentMinimalStep,
>> 252 G4double& currentSafety);
230 253
231 // This method is not used for tracking, it 254 // This method is not used for tracking, it returns step limit
232 G4double GetContinuousStepLimit(const G4Trac << 255 inline virtual G4double GetContinuousStepLimit(const G4Track& track,
233 G4double pre << 256 G4double previousStepSize,
234 G4double cur << 257 G4double currentMinimalStep,
235 G4double& cu << 258 G4double& currentSafety);
236 259
237 private: << 260 inline G4VEmModel* SelectModel(G4double kinEnergy);
>> 261 // Select concrete model
238 262
239 // ======== Parameters of the class fixed at << 263 inline const G4MaterialCutsCouple* CurrentMaterialCutsCouple() const;
>> 264 // Return current G4MaterialCutsCouple
240 265
241 G4EmModelManager* modelManager; << 266 inline void DefineMaterial(const G4MaterialCutsCouple* couple);
242 G4LossTableManager* emManager; << 267 // define current material
243 G4EmParameters* theParameters; <<
244 268
245 // ======== Parameters of the class fixed at << 269 //------------------------------------------------------------------------
>> 270 // Parameters for simulation of multiple scattering
>> 271 //------------------------------------------------------------------------
246 272
247 G4SafetyHelper* safetyHelper = n << 273 inline G4double Skin() const;
248 const G4ParticleDefinition* firstParticle = <<
249 const G4ParticleDefinition* currParticle = n <<
250 <<
251 std::vector<G4VMscModel*> mscModels; <<
252 274
253 G4double facrange = 0.04; << 275 inline G4double RangeFactor() const;
254 G4double lowestKinEnergy; <<
255 276
256 // ======== Cached values - may be state dep << 277 inline G4double GeomFactor() const;
>> 278
>> 279 inline G4MscStepLimitType StepLimitType() const;
>> 280
>> 281 inline G4bool LateralDisplasmentFlag() const;
>> 282
>> 283 private:
>> 284
>> 285 // hide assignment operator
>> 286
>> 287 G4VMultipleScattering(G4VMultipleScattering &);
>> 288 G4VMultipleScattering & operator=(const G4VMultipleScattering &right);
>> 289
>> 290 // =====================================================================
257 291
258 protected: 292 protected:
259 293
>> 294 G4GPILSelection valueGPILSelectionMSC;
260 G4ParticleChangeForMSC fParticleChange; 295 G4ParticleChangeForMSC fParticleChange;
261 296
262 private: 297 private:
263 298
264 G4ThreeVector fNewPosition; << 299 G4EmModelManager* modelManager;
265 G4ThreeVector fNewDirection; << 300 G4VEmModel* currentModel;
>> 301 G4PhysicsTable* theLambdaTable;
266 302
267 G4VMscModel* currentModel = n << 303 // cache
268 G4VEnergyLossProcess* fIonisation = nu << 304 const G4ParticleDefinition* firstParticle;
>> 305 const G4ParticleDefinition* currentParticle;
>> 306 const G4MaterialCutsCouple* currentCouple;
>> 307 size_t currentMaterialIndex;
>> 308
>> 309 G4int nBins;
>> 310
>> 311 G4MscStepLimitType stepLimit;
>> 312
>> 313 G4double minKinEnergy;
>> 314 G4double maxKinEnergy;
>> 315 G4double skin;
>> 316 G4double facrange;
>> 317 G4double facgeom;
269 318
270 G4double geomMin; << 319 G4bool latDisplasment;
271 G4double minDisplacement2 << 320 G4bool buildLambdaTable;
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 }; 321 };
285 322
286 // ======== Run time inline methods ========== << 323 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 324 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 325
>> 326 inline void G4VMultipleScattering::DefineMaterial(const G4MaterialCutsCouple* couple)
>> 327 {
>> 328 if(couple != currentCouple) {
>> 329 currentCouple = couple;
>> 330 currentMaterialIndex = couple->GetIndex();
>> 331 }
>> 332 }
287 333
288 //....oooOO0OOooo........oooOO0OOooo........oo 334 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
289 335
290 inline G4VEmModel* << 336 inline G4double G4VMultipleScattering::PostStepGetPhysicalInteractionLength(
291 G4VMultipleScattering::SelectModel(G4double ki << 337 const G4Track&, G4double, G4ForceCondition* condition)
292 { 338 {
293 return modelManager->SelectModel(kinEnergy, << 339 *condition = Forced;
>> 340 return DBL_MAX;
294 } 341 }
295 342
296 //....oooOO0OOooo........oooOO0OOooo........oo 343 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
297 344
298 inline G4bool G4VMultipleScattering::LateralD << 345 inline G4double G4VMultipleScattering::GetMeanFreePath(
>> 346 const G4Track&, G4double, G4ForceCondition* condition)
>> 347 {
>> 348 *condition = Forced;
>> 349 return DBL_MAX;
>> 350 }
>> 351
>> 352 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
>> 353
>> 354 inline G4double G4VMultipleScattering::AlongStepGetPhysicalInteractionLength(
>> 355 const G4Track& track,
>> 356 G4double previousStepSize,
>> 357 G4double currentMinimalStep,
>> 358 G4double& currentSafety,
>> 359 G4GPILSelection* selection)
299 { 360 {
300 return latDisplacement; << 361 // get Step limit proposed by the process
>> 362 valueGPILSelectionMSC = NotCandidateForSelection;
>> 363 G4double steplength = GetMscContinuousStepLimit(track,previousStepSize,
>> 364 currentMinimalStep,currentSafety);
>> 365 // G4cout << "StepLimit= " << steplength << G4endl;
>> 366 // set return value for G4GPILSelection
>> 367 *selection = valueGPILSelectionMSC;
>> 368 return steplength;
301 } 369 }
302 370
303 //....oooOO0OOooo........oooOO0OOooo........oo 371 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
304 372
305 inline G4double G4VMultipleScattering::Skin() << 373 inline G4double G4VMultipleScattering::GetMscContinuousStepLimit(
>> 374 const G4Track& track,
>> 375 G4double,
>> 376 G4double currentMinimalStep,
>> 377 G4double&)
306 { 378 {
307 return theParameters->MscSkin(); << 379 G4double x = currentMinimalStep;
>> 380 G4double e = track.GetKineticEnergy();
>> 381 DefineMaterial(track.GetMaterialCutsCouple());
>> 382 currentModel = SelectModel(e);
>> 383 if(x > 0.0 && e > 0.0) {
>> 384 G4double tPathLength =
>> 385 currentModel->ComputeTruePathLengthLimit(track, theLambdaTable, x);
>> 386 if (tPathLength < x) valueGPILSelectionMSC = CandidateForSelection;
>> 387 x = currentModel->ComputeGeomPathLength(tPathLength);
>> 388 // G4cout << "tPathLength= " << tPathLength
>> 389 // << " stepLimit= " << x
>> 390 // << " currentMinimalStep= " << currentMinimalStep<< G4endl;
>> 391 }
>> 392 return x;
308 } 393 }
309 394
310 //....oooOO0OOooo........oooOO0OOooo........oo 395 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
311 396
312 inline G4double G4VMultipleScattering::RangeF << 397 inline G4double G4VMultipleScattering::GetContinuousStepLimit(
>> 398 const G4Track& track,
>> 399 G4double previousStepSize,
>> 400 G4double currentMinimalStep,
>> 401 G4double& currentSafety)
313 { 402 {
314 return facrange; << 403 return GetMscContinuousStepLimit(track,previousStepSize,currentMinimalStep,
>> 404 currentSafety);
315 } 405 }
316 406
317 //....oooOO0OOooo........oooOO0OOooo........oo 407 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
318 408
319 inline G4double G4VMultipleScattering::GeomFa << 409 inline G4double G4VMultipleScattering::ContinuousStepLimit(
>> 410 const G4Track& track,
>> 411 G4double previousStepSize,
>> 412 G4double currentMinimalStep,
>> 413 G4double& currentSafety)
320 { 414 {
321 return theParameters->MscGeomFactor(); << 415 return GetMscContinuousStepLimit(track,previousStepSize,currentMinimalStep,
>> 416 currentSafety);
322 } 417 }
323 418
324 //....oooOO0OOooo........oooOO0OOooo........oo 419 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
325 420
326 inline G4double G4VMultipleScattering::PolarA << 421 inline G4double G4VMultipleScattering::GetLambda(const G4ParticleDefinition* p, G4double& e)
327 { 422 {
328 return theParameters->MscThetaLimit(); << 423 G4double x;
>> 424 if(theLambdaTable) {
>> 425 G4bool b;
>> 426 x = ((*theLambdaTable)[currentMaterialIndex])->GetValue(e, b);
>> 427 } else {
>> 428 x = currentModel->CrossSection(currentCouple,p,e);
>> 429 }
>> 430 if(x > DBL_MIN) x = 1./x;
>> 431 else x = DBL_MAX;
>> 432 return x;
329 } 433 }
330 434
331 //....oooOO0OOooo........oooOO0OOooo........oo 435 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
332 436
333 inline G4MscStepLimitType G4VMultipleScatterin << 437 inline G4VParticleChange* G4VMultipleScattering::AlongStepDoIt(
>> 438 const G4Track&,
>> 439 const G4Step& step)
334 { 440 {
335 return stepLimit; << 441 fParticleChange.ProposeTrueStepLength(
>> 442 currentModel->ComputeTrueStepLength(step.GetStepLength()));
>> 443 return &fParticleChange;
336 } 444 }
337 445
338 //....oooOO0OOooo........oooOO0OOooo........oo 446 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
339 447
340 inline void G4VMultipleScattering::SetStepLimi << 448 inline G4VParticleChange* G4VMultipleScattering::PostStepDoIt(const G4Track& track,
>> 449 const G4Step& step)
>> 450 {
>> 451 fParticleChange.Initialize(track);
>> 452 std::vector<G4DynamicParticle*>* p=0;
>> 453 currentModel->SampleSecondaries(p, currentCouple,
>> 454 track.GetDynamicParticle(),
>> 455 step.GetStepLength(),
>> 456 step.GetPostStepPoint()->GetSafety());
>> 457 return &fParticleChange;
>> 458 }
>> 459
>> 460 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 461
>> 462 inline G4VEmModel* G4VMultipleScattering::SelectModel(G4double kinEnergy)
>> 463 {
>> 464 return modelManager->SelectModel(kinEnergy, currentMaterialIndex);
>> 465 }
>> 466
>> 467 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 468
>> 469 inline G4VEmModel* G4VMultipleScattering::SelectModelForMaterial(
>> 470 G4double kinEnergy, size_t& idxRegion) const
341 { 471 {
342 theParameters->SetMscStepLimitType(val); << 472 return modelManager->SelectModel(kinEnergy, idxRegion);
343 } 473 }
344 474
345 //....oooOO0OOooo........oooOO0OOooo........oo 475 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
346 476
347 inline G4double G4VMultipleScattering::LowestK << 477 inline void G4VMultipleScattering::SetBinning(G4int nbins)
348 { 478 {
349 return lowestKinEnergy; << 479 nBins = nbins;
350 } 480 }
351 481
352 //....oooOO0OOooo........oooOO0OOooo........oo 482 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
353 483
354 inline void G4VMultipleScattering::SetLowestKi << 484 inline G4int G4VMultipleScattering::Binning() const
355 { 485 {
356 lowestKinEnergy = val; << 486 return nBins;
357 } 487 }
358 488
359 //....oooOO0OOooo........oooOO0OOooo........oo 489 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
360 490
361 inline const G4ParticleDefinition* G4VMultiple << 491 inline void G4VMultipleScattering::SetMinKinEnergy(G4double e)
362 { 492 {
363 return firstParticle; << 493 minKinEnergy = e;
364 } 494 }
365 495
366 //....oooOO0OOooo........oooOO0OOooo........oo 496 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
367 497
368 inline G4VMscModel* G4VMultipleScattering::EmM << 498 inline G4double G4VMultipleScattering::MinKinEnergy() const
369 { 499 {
370 return (index < mscModels.size()) ? mscModel << 500 return minKinEnergy;
371 } 501 }
372 502
373 //....oooOO0OOooo........oooOO0OOooo........oo 503 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
374 504
375 inline G4int G4VMultipleScattering::NumberOfMo << 505 inline void G4VMultipleScattering::SetMaxKinEnergy(G4double e)
376 { 506 {
377 return numberOfModels; << 507 maxKinEnergy = e;
378 } 508 }
379 509
380 //....oooOO0OOooo........oooOO0OOooo........oo 510 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
381 511
382 inline G4VMscModel* << 512 inline G4double G4VMultipleScattering::MaxKinEnergy() const
383 G4VMultipleScattering::GetModelByIndex(G4int i <<
384 { 513 {
385 // static cast is possible inside this class << 514 return maxKinEnergy;
386 return static_cast<G4VMscModel*>(modelManage <<
387 } 515 }
388 516
389 //....oooOO0OOooo........oooOO0OOooo........oo 517 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
390 518
391 inline G4bool G4VMultipleScattering::UseBaseMa << 519 inline G4bool G4VMultipleScattering::LateralDisplasmentFlag() const
>> 520 {
>> 521 return latDisplasment;
>> 522 }
>> 523
>> 524 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 525
>> 526 inline void G4VMultipleScattering::SetLateralDisplasmentFlag(G4bool val)
>> 527 {
>> 528 latDisplasment = val;
>> 529 }
>> 530
>> 531 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 532
>> 533 inline G4double G4VMultipleScattering::Skin() const
>> 534 {
>> 535 return skin;
>> 536 }
>> 537
>> 538 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 539
>> 540 inline void G4VMultipleScattering::SetSkin(G4double val)
>> 541 {
>> 542 if(val <= 0.99999) {
>> 543 skin = 0.0;
>> 544 stepLimit = fUseSafety;
>> 545 } else {
>> 546 skin = val;
>> 547 stepLimit = fUseDistanceToBoundary;
>> 548 }
>> 549 }
>> 550
>> 551 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 552
>> 553 inline G4double G4VMultipleScattering::RangeFactor() const
>> 554 {
>> 555 return facrange;
>> 556 }
>> 557
>> 558 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 559
>> 560 inline void G4VMultipleScattering::SetRangeFactor(G4double val)
>> 561 {
>> 562 if(val > 0.0) facrange = val;
>> 563 }
>> 564
>> 565 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 566
>> 567 inline G4double G4VMultipleScattering::GeomFactor() const
>> 568 {
>> 569 return facgeom;
>> 570 }
>> 571
>> 572 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 573
>> 574 inline void G4VMultipleScattering::SetGeomFactor(G4double val)
>> 575 {
>> 576 if(val > 0.0) facgeom = val;
>> 577 }
>> 578
>> 579 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 580
>> 581 inline G4MscStepLimitType G4VMultipleScattering::StepLimitType() const
>> 582 {
>> 583 return stepLimit;
>> 584 }
>> 585
>> 586 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 587
>> 588 inline void G4VMultipleScattering::SetStepLimitType(G4MscStepLimitType val)
>> 589 {
>> 590 stepLimit = val;
>> 591 if(val == fMinimal) {
>> 592 skin = 0;
>> 593 facrange = 0.2;
>> 594 } else if(val == fUseSafety) {
>> 595 skin = 0;
>> 596 }
>> 597 }
>> 598
>> 599 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 600
>> 601 inline void G4VMultipleScattering::SetBuildLambdaTable(G4bool val)
>> 602 {
>> 603 buildLambdaTable = val;
>> 604 }
>> 605
>> 606 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 607
>> 608 inline const G4ParticleDefinition* G4VMultipleScattering::Particle() const
>> 609 {
>> 610 return currentParticle;
>> 611 }
>> 612
>> 613 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 614
>> 615 inline G4PhysicsTable* G4VMultipleScattering::LambdaTable() const
>> 616 {
>> 617 return theLambdaTable;
>> 618 }
>> 619
>> 620 inline
>> 621 const G4MaterialCutsCouple* G4VMultipleScattering::CurrentMaterialCutsCouple() const
>> 622 {
>> 623 return currentCouple;
>> 624 }
>> 625
>> 626 inline G4VEmModel* G4VMultipleScattering::GetModelByIndex(G4int idx)
392 { 627 {
393 return baseMat; << 628 return modelManager->GetModel(idx);
394 } 629 }
395 630
396 //....oooOO0OOooo........oooOO0OOooo........oo 631 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
397 632
398 #endif 633 #endif
399 634