| 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.39 2006/06/29 19:54:51 gunter Exp $
>> 27 // GEANT4 tag $Name: geant4-08-02 $
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 (V.Ivanchenko)
>> 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) <<
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 // 63 //
59 // It is the generic process of multiple scatt <<
60 // part of calculations for all charged partic <<
61 64
62 // ------------------------------------------- 65 // -------------------------------------------------------------------
63 // 66 //
64 67
65 #ifndef G4VMultipleScattering_h 68 #ifndef G4VMultipleScattering_h
66 #define G4VMultipleScattering_h 1 69 #define G4VMultipleScattering_h 1
67 70
68 #include "G4VContinuousDiscreteProcess.hh" 71 #include "G4VContinuousDiscreteProcess.hh"
>> 72 #include "G4LossTableManager.hh"
69 #include "globals.hh" 73 #include "globals.hh"
70 #include "G4Material.hh" 74 #include "G4Material.hh"
>> 75 #include "G4MaterialCutsCouple.hh"
71 #include "G4ParticleChangeForMSC.hh" 76 #include "G4ParticleChangeForMSC.hh"
72 #include "G4Track.hh" 77 #include "G4Track.hh"
73 #include "G4Step.hh" 78 #include "G4Step.hh"
74 #include "G4EmModelManager.hh" 79 #include "G4EmModelManager.hh"
75 #include "G4VMscModel.hh" << 80 #include "G4VEmModel.hh"
76 #include "G4EmParameters.hh" <<
77 #include "G4MscStepLimitType.hh" <<
78 81
79 class G4ParticleDefinition; 82 class G4ParticleDefinition;
80 class G4VEnergyLossProcess; << 83 class G4DataVector;
81 class G4LossTableManager; << 84 class G4PhysicsTable;
82 class G4SafetyHelper; << 85 class G4PhysicsVector;
83 86
84 //....oooOO0OOooo........oooOO0OOooo........oo 87 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
85 88
86 class G4VMultipleScattering : public G4VContin 89 class G4VMultipleScattering : public G4VContinuousDiscreteProcess
87 { 90 {
88 public: 91 public:
89 92
90 explicit G4VMultipleScattering(const G4Strin << 93 G4VMultipleScattering(const G4String& name = "msc",
91 G4ProcessType << 94 G4ProcessType type = fElectromagnetic);
92 95
93 ~G4VMultipleScattering() override; << 96 virtual ~G4VMultipleScattering();
94 97
95 //------------------------------------------ 98 //------------------------------------------------------------------------
96 // Virtual methods to be implemented for the 99 // Virtual methods to be implemented for the concrete model
97 //------------------------------------------ 100 //------------------------------------------------------------------------
98 101
99 void ProcessDescription(std::ostream& outFil << 102 virtual G4bool IsApplicable(const G4ParticleDefinition& p) = 0;
100 << 103 // True for all charged particles
101 virtual void InitialiseProcess(const G4Parti <<
102 104
103 // Print out of generic class parameters << 105 virtual void PrintInfo() = 0;
104 void StreamInfo(std::ostream& outFile, const <<
105 G4bool rst = false) const; <<
106 106
107 protected: 107 protected:
108 108
109 virtual void StreamProcessInfo(std::ostream& << 109 virtual void InitialiseProcess(const G4ParticleDefinition*) = 0;
110 110
>> 111 //------------------------------------------------------------------------
>> 112 // Methods with standard implementation; may be overwritten if needed
>> 113 //------------------------------------------------------------------------
111 public: 114 public:
112 115
>> 116 // Initialise for build of tables
>> 117 virtual void PreparePhysicsTable(const G4ParticleDefinition&);
>> 118
>> 119 // Build physics table during initialisation
>> 120 virtual void BuildPhysicsTable(const G4ParticleDefinition&);
>> 121
>> 122 // set boolean flag steppingAlgorithm
>> 123 // ( true/false : standard or 7.1 style process)
>> 124 virtual void MscStepLimitation(G4bool algorithm, G4double factor = -1.);
>> 125
113 //------------------------------------------ 126 //------------------------------------------------------------------------
114 // Generic methods common to all ContinuousD << 127 // Generic methods common to all models
115 //------------------------------------------ 128 //------------------------------------------------------------------------
116 129
117 // Initialise for build of tables << 130 virtual G4VParticleChange* AlongStepDoIt(const G4Track&, const G4Step&);
118 void PreparePhysicsTable(const G4ParticleDef <<
119 131
120 // Build physics table during initialisation << 132 virtual G4VParticleChange* PostStepDoIt(const G4Track&, const G4Step&);
121 void BuildPhysicsTable(const G4ParticleDefin << 133
>> 134 // The function overloads the corresponding function of the base
>> 135 // class.It limits the step near to boundaries only
>> 136 // and invokes the method GetContinuousStepLimit at every step.
>> 137 G4double AlongStepGetPhysicalInteractionLength(
>> 138 const G4Track&,
>> 139 G4double previousStepSize,
>> 140 G4double currentMinimalStep,
>> 141 G4double& currentSafety,
>> 142 G4GPILSelection* selection);
>> 143
>> 144 // Print out of generic class parameters
>> 145 void PrintInfoDefinition();
>> 146
>> 147 void SetBinning(G4int nbins);
>> 148 G4int Binning() const;
>> 149 // Print out of the class parameters
>> 150
>> 151 void SetMinKinEnergy(G4double e);
>> 152 G4double MinKinEnergy() const;
>> 153 // Print out of the class parameters
>> 154
>> 155 void SetMaxKinEnergy(G4double e);
>> 156 G4double MaxKinEnergy() const;
>> 157
>> 158 // Build empty Physics Vector
>> 159 G4PhysicsVector* PhysicsVector(const G4MaterialCutsCouple*);
122 160
123 // Store PhysicsTable in a file. 161 // Store PhysicsTable in a file.
124 // Return false in case of failure at I/O 162 // Return false in case of failure at I/O
125 G4bool StorePhysicsTable(const G4ParticleDef 163 G4bool StorePhysicsTable(const G4ParticleDefinition*,
126 const G4String& dir 164 const G4String& directory,
127 G4bool ascii = fals << 165 G4bool ascii = false);
128 166
129 // Retrieve Physics from a file. 167 // Retrieve Physics from a file.
130 // (return true if the Physics Table can be 168 // (return true if the Physics Table can be build by using file)
131 // (return false if the process has no funct 169 // (return false if the process has no functionality or in case of failure)
132 // File name should is constructed as proces 170 // File name should is constructed as processName+particleName and the
133 // should be placed under the directory spec << 171 // should be placed under the directory specifed by the argument.
134 G4bool RetrievePhysicsTable(const G4Particle 172 G4bool RetrievePhysicsTable(const G4ParticleDefinition*,
135 const G4String& 173 const G4String& directory,
136 G4bool ascii) ov << 174 G4bool ascii);
137 175
138 // This is called in the beginning of tracki << 176 void AddEmModel(G4int, G4VEmModel*, const G4Region* region = 0);
139 void StartTracking(G4Track*) override; <<
140 177
141 // The function overloads the corresponding << 178 // This method does not used for tracking, it is intended only for tests
142 // class.It limits the step near to boundari << 179 virtual G4double ContinuousStepLimit(const G4Track& track,
143 // and invokes the method GetMscContinuousSt << 180 G4double previousStepSize,
144 G4double AlongStepGetPhysicalInteractionLeng << 181 G4double currentMinimalStep,
145 const << 182 G4double& currentSafety);
146 G4doub <<
147 G4doub <<
148 G4doub <<
149 G4GPIL <<
150 183
151 // The function overloads the corresponding << 184 G4bool LateralDisplasmentFlag() const;
152 // class. << 185 void SetLateralDisplasmentFlag(G4bool val);
153 G4double PostStepGetPhysicalInteractionLengt << 186 // lateral displacement to be/not to be computed
154 const G4 <<
155 G4double <<
156 G4ForceC <<
157 187
158 // Along step actions << 188 void SetBuildLambdaTable(G4bool val);
159 G4VParticleChange* AlongStepDoIt(const G4Tra <<
160 189
161 // This method does not used for tracking, i << 190 G4PhysicsTable* LambdaTable() const;
162 G4double ContinuousStepLimit(const G4Track& <<
163 G4double previo <<
164 G4double curren <<
165 G4double& curre <<
166 <<
167 // hide assignment operator <<
168 G4VMultipleScattering(G4VMultipleScattering <<
169 G4VMultipleScattering & operator=(const G4VM <<
170 191
171 //------------------------------------------ << 192 G4VEmModel* SelectModelForMaterial(G4double kinEnergy, size_t& idxRegion) const;
172 // Specific methods to set, access, modify m <<
173 //------------------------------------------ <<
174 193
175 // Select model in run time << 194 // Define particle definition
176 inline G4VEmModel* SelectModel(G4double kinE << 195 const G4ParticleDefinition* Particle() const;
>> 196 void SetParticle(const G4ParticleDefinition*);
177 197
178 public: << 198 // Access to models
>> 199 G4VEmModel* GetModelByIndex(G4int idx = 0);
179 200
180 // Add model for region, smaller value of or << 201 protected:
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 202
191 // Access to run time models << 203 // This method is used for tracking, it returns mean free path value
192 inline G4int NumberOfModels() const; << 204 G4double GetMeanFreePath(const G4Track& track,
>> 205 G4double,
>> 206 G4ForceCondition* condition);
193 207
194 inline G4VMscModel* GetModelByIndex(G4int id << 208 G4double GetLambda(const G4ParticleDefinition* p, G4double& kineticEnergy);
195 209
196 //------------------------------------------ << 210 // This method is used for tracking, it returns step limit
197 // Get/Set parameters for simulation of mult << 211 virtual G4double GetContinuousStepLimit(const G4Track& track,
198 //------------------------------------------ << 212 G4double previousStepSize,
>> 213 G4double currentMinimalStep,
>> 214 G4double& currentSafety);
199 215
200 inline G4bool LateralDisplasmentFlag() const << 216 G4VEmModel* SelectModel(G4double kinEnergy);
201 << 217 // Select concrete model
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 218
215 inline G4double LowestKinEnergy() const; << 219 const G4MaterialCutsCouple* CurrentMaterialCutsCouple() const;
216 inline void SetLowestKinEnergy(G4double val) << 220 // Return current G4MaterialCutsCouple
217 221
218 inline const G4ParticleDefinition* FirstPart << 222 void DefineMaterial(const G4MaterialCutsCouple* couple);
>> 223 // define current material
219 224
220 //------------------------------------------ << 225 private:
221 // Run time methods <<
222 //------------------------------------------ <<
223 226
224 protected: << 227 // hide assignment operator
225 228
226 // This method is not used for tracking, it << 229 G4VMultipleScattering(G4VMultipleScattering &);
227 G4double GetMeanFreePath(const G4Track& trac << 230 G4VMultipleScattering & operator=(const G4VMultipleScattering &right);
228 G4double, <<
229 G4ForceCondition* c <<
230 231
231 // This method is not used for tracking, it << 232 // =====================================================================
232 G4double GetContinuousStepLimit(const G4Trac <<
233 G4double pre <<
234 G4double cur <<
235 G4double& cu <<
236 233
237 private: << 234 protected:
>> 235
>> 236 G4GPILSelection valueGPILSelectionMSC;
>> 237 G4ParticleChangeForMSC fParticleChange;
238 238
239 // ======== Parameters of the class fixed at << 239 private:
240 240
241 G4EmModelManager* modelManager; 241 G4EmModelManager* modelManager;
242 G4LossTableManager* emManager; << 242 G4VEmModel* currentModel;
243 G4EmParameters* theParameters; << 243 G4PhysicsTable* theLambdaTable;
244 244
245 // ======== Parameters of the class fixed at << 245 // cache
>> 246 const G4ParticleDefinition* firstParticle;
>> 247 const G4ParticleDefinition* currentParticle;
>> 248 const G4MaterialCutsCouple* currentCouple;
>> 249 size_t currentMaterialIndex;
246 250
247 G4SafetyHelper* safetyHelper = n << 251 G4int nBins;
248 const G4ParticleDefinition* firstParticle = <<
249 const G4ParticleDefinition* currParticle = n <<
250 <<
251 std::vector<G4VMscModel*> mscModels; <<
252 252
253 G4double facrange = 0.04; << 253 G4double minKinEnergy;
254 G4double lowestKinEnergy; << 254 G4double maxKinEnergy;
255 255
256 // ======== Cached values - may be state dep << 256 G4bool latDisplasment;
>> 257 G4bool buildLambdaTable;
>> 258 };
257 259
258 protected: << 260 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 261 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
259 262
260 G4ParticleChangeForMSC fParticleChange; << 263 inline void G4VMultipleScattering::DefineMaterial(const G4MaterialCutsCouple* couple)
>> 264 {
>> 265 if(couple != currentCouple) {
>> 266 currentCouple = couple;
>> 267 currentMaterialIndex = couple->GetIndex();
>> 268 }
>> 269 }
261 270
262 private: << 271 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 272
>> 273 inline G4double G4VMultipleScattering::GetMeanFreePath(const G4Track&,
>> 274 G4double,
>> 275 G4ForceCondition* cond)
>> 276 {
>> 277 *cond = Forced;
>> 278 return DBL_MAX;
>> 279 }
263 280
264 G4ThreeVector fNewPosition; << 281 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
265 G4ThreeVector fNewDirection; <<
266 282
267 G4VMscModel* currentModel = n << 283 inline G4double G4VMultipleScattering::AlongStepGetPhysicalInteractionLength(
268 G4VEnergyLossProcess* fIonisation = nu << 284 const G4Track& track,
>> 285 G4double previousStepSize,
>> 286 G4double currentMinimalStep,
>> 287 G4double& currentSafety,
>> 288 G4GPILSelection* selection)
>> 289 {
>> 290 // get Step limit proposed by the process
>> 291 valueGPILSelectionMSC = NotCandidateForSelection;
>> 292 G4double steplength = GetContinuousStepLimit(track,previousStepSize,
>> 293 currentMinimalStep,currentSafety);
>> 294 // G4cout << "StepLimit= " << steplength << G4endl;
>> 295 // set return value for G4GPILSelection
>> 296 *selection = valueGPILSelectionMSC;
>> 297 return steplength;
>> 298 }
269 299
270 G4double geomMin; << 300 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
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 }; <<
285 301
286 // ======== Run time inline methods ========== << 302 inline G4double G4VMultipleScattering::GetContinuousStepLimit(
>> 303 const G4Track& track,
>> 304 G4double,
>> 305 G4double currentMinimalStep,
>> 306 G4double&)
>> 307 {
>> 308 DefineMaterial(track.GetMaterialCutsCouple());
>> 309 currentModel = SelectModel(track.GetKineticEnergy());
>> 310 G4double tPathLength =
>> 311 currentModel->ComputeTruePathLengthLimit(track, theLambdaTable, currentMinimalStep);
>> 312 if (tPathLength < currentMinimalStep) valueGPILSelectionMSC = CandidateForSelection;
>> 313 // G4cout << "tPathLength= " << tPathLength << " currentMinimalStep= " << currentMinimalStep<< G4endl;
>> 314 return currentModel->ComputeGeomPathLength(tPathLength);
>> 315 }
287 316
288 //....oooOO0OOooo........oooOO0OOooo........oo 317 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
289 318
290 inline G4VEmModel* << 319 inline G4double G4VMultipleScattering::ContinuousStepLimit(
291 G4VMultipleScattering::SelectModel(G4double ki << 320 const G4Track& track,
>> 321 G4double previousStepSize,
>> 322 G4double currentMinimalStep,
>> 323 G4double& currentSafety)
292 { 324 {
293 return modelManager->SelectModel(kinEnergy, << 325 return GetContinuousStepLimit(track,previousStepSize,currentMinimalStep,
>> 326 currentSafety);
294 } 327 }
295 328
296 //....oooOO0OOooo........oooOO0OOooo........oo 329 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
297 330
298 inline G4bool G4VMultipleScattering::LateralD << 331 inline G4double G4VMultipleScattering::GetLambda(const G4ParticleDefinition* p, G4double& e)
>> 332 {
>> 333 G4double x;
>> 334 if(theLambdaTable) {
>> 335 G4bool b;
>> 336 x = ((*theLambdaTable)[currentMaterialIndex])->GetValue(e, b);
>> 337 } else {
>> 338 x = currentModel->CrossSection(currentCouple,p,e);
>> 339 }
>> 340 if(x > DBL_MIN) x = 1./x;
>> 341 else x = DBL_MAX;
>> 342 return x;
>> 343 }
>> 344
>> 345 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 346
>> 347 inline G4VParticleChange* G4VMultipleScattering::AlongStepDoIt(
>> 348 const G4Track&,
>> 349 const G4Step& step)
>> 350 {
>> 351 fParticleChange.ProposeTrueStepLength(
>> 352 currentModel->ComputeTrueStepLength(step.GetStepLength()));
>> 353 return &fParticleChange;
>> 354 }
>> 355
>> 356 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 357
>> 358 inline G4VParticleChange* G4VMultipleScattering::PostStepDoIt(const G4Track& track,
>> 359 const G4Step& step)
299 { 360 {
300 return latDisplacement; << 361 fParticleChange.Initialize(track);
>> 362 currentModel->SampleSecondaries(currentCouple,track.GetDynamicParticle(),
>> 363 step.GetStepLength(),step.GetPostStepPoint()->GetSafety());
>> 364 return &fParticleChange;
301 } 365 }
302 366
303 //....oooOO0OOooo........oooOO0OOooo........oo 367 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
304 368
305 inline G4double G4VMultipleScattering::Skin() << 369 inline G4VEmModel* G4VMultipleScattering::SelectModel(G4double kinEnergy)
306 { 370 {
307 return theParameters->MscSkin(); << 371 return modelManager->SelectModel(kinEnergy, currentMaterialIndex);
308 } 372 }
309 373
310 //....oooOO0OOooo........oooOO0OOooo........oo 374 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
311 375
312 inline G4double G4VMultipleScattering::RangeF << 376 inline G4VEmModel* G4VMultipleScattering::SelectModelForMaterial(
>> 377 G4double kinEnergy, size_t& idxRegion) const
313 { 378 {
314 return facrange; << 379 return modelManager->SelectModel(kinEnergy, idxRegion);
315 } 380 }
316 381
317 //....oooOO0OOooo........oooOO0OOooo........oo 382 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
318 383
319 inline G4double G4VMultipleScattering::GeomFa << 384 inline void G4VMultipleScattering::SetBinning(G4int nbins)
320 { 385 {
321 return theParameters->MscGeomFactor(); << 386 nBins = nbins;
322 } 387 }
323 388
324 //....oooOO0OOooo........oooOO0OOooo........oo 389 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
325 390
326 inline G4double G4VMultipleScattering::PolarA << 391 inline G4int G4VMultipleScattering::Binning() const
327 { 392 {
328 return theParameters->MscThetaLimit(); << 393 return nBins;
329 } 394 }
330 395
331 //....oooOO0OOooo........oooOO0OOooo........oo 396 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
332 397
333 inline G4MscStepLimitType G4VMultipleScatterin << 398 inline void G4VMultipleScattering::SetMinKinEnergy(G4double e)
334 { 399 {
335 return stepLimit; << 400 minKinEnergy = e;
336 } 401 }
337 402
338 //....oooOO0OOooo........oooOO0OOooo........oo 403 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
339 404
340 inline void G4VMultipleScattering::SetStepLimi << 405 inline G4double G4VMultipleScattering::MinKinEnergy() const
341 { 406 {
342 theParameters->SetMscStepLimitType(val); << 407 return minKinEnergy;
343 } 408 }
344 409
345 //....oooOO0OOooo........oooOO0OOooo........oo 410 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
346 411
347 inline G4double G4VMultipleScattering::LowestK << 412 inline void G4VMultipleScattering::SetMaxKinEnergy(G4double e)
348 { 413 {
349 return lowestKinEnergy; << 414 maxKinEnergy = e;
350 } 415 }
351 416
352 //....oooOO0OOooo........oooOO0OOooo........oo 417 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
353 418
354 inline void G4VMultipleScattering::SetLowestKi << 419 inline G4double G4VMultipleScattering::MaxKinEnergy() const
355 { 420 {
356 lowestKinEnergy = val; << 421 return maxKinEnergy;
357 } 422 }
358 423
359 //....oooOO0OOooo........oooOO0OOooo........oo 424 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
360 425
361 inline const G4ParticleDefinition* G4VMultiple << 426 inline G4bool G4VMultipleScattering::LateralDisplasmentFlag() const
362 { 427 {
363 return firstParticle; << 428 return latDisplasment;
364 } 429 }
365 430
366 //....oooOO0OOooo........oooOO0OOooo........oo 431 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
367 432
368 inline G4VMscModel* G4VMultipleScattering::EmM << 433 inline void G4VMultipleScattering::SetLateralDisplasmentFlag(G4bool val)
369 { 434 {
370 return (index < mscModels.size()) ? mscModel << 435 latDisplasment = val;
371 } 436 }
372 437
373 //....oooOO0OOooo........oooOO0OOooo........oo 438 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
374 439
375 inline G4int G4VMultipleScattering::NumberOfMo << 440 inline void G4VMultipleScattering::SetBuildLambdaTable(G4bool val)
376 { 441 {
377 return numberOfModels; << 442 buildLambdaTable = val;
378 } 443 }
379 444
380 //....oooOO0OOooo........oooOO0OOooo........oo 445 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
381 446
382 inline G4VMscModel* << 447 inline const G4ParticleDefinition* G4VMultipleScattering::Particle() const
383 G4VMultipleScattering::GetModelByIndex(G4int i <<
384 { 448 {
385 // static cast is possible inside this class << 449 return currentParticle;
386 return static_cast<G4VMscModel*>(modelManage <<
387 } 450 }
388 451
389 //....oooOO0OOooo........oooOO0OOooo........oo 452 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
390 453
391 inline G4bool G4VMultipleScattering::UseBaseMa << 454 inline G4PhysicsTable* G4VMultipleScattering::LambdaTable() const
>> 455 {
>> 456 return theLambdaTable;
>> 457 }
>> 458
>> 459 inline
>> 460 const G4MaterialCutsCouple* G4VMultipleScattering::CurrentMaterialCutsCouple() const
>> 461 {
>> 462 return currentCouple;
>> 463 }
>> 464
>> 465 inline G4VEmModel* G4VMultipleScattering::GetModelByIndex(G4int idx)
392 { 466 {
393 return baseMat; << 467 return modelManager->GetModel(idx);
394 } 468 }
395 469
396 //....oooOO0OOooo........oooOO0OOooo........oo 470 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
397 471
398 #endif 472 #endif
399 473