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.63 2010-03-10 18:29:51 vnivanch Exp $ >> 27 // GEANT4 tag $Name: not supported by cvs2svn $ 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 64 // 27-10-07 Virtual functions moved to source (V.Ivanchenko) 54 // 15-07-08 Reorder class members for further 65 // 15-07-08 Reorder class members for further multi-thread development (VI) 55 // 07-04-09 Moved msc methods from G4VEmModel 66 // 07-04-09 Moved msc methods from G4VEmModel to G4VMscModel (VI) 56 // 67 // 57 // Class Description: << 58 // << 59 // It is the generic process of multiple scatt << 60 // part of calculations for all charged partic << 61 68 62 // ------------------------------------------- 69 // ------------------------------------------------------------------- 63 // 70 // 64 71 65 #ifndef G4VMultipleScattering_h 72 #ifndef G4VMultipleScattering_h 66 #define G4VMultipleScattering_h 1 73 #define G4VMultipleScattering_h 1 67 74 68 #include "G4VContinuousDiscreteProcess.hh" 75 #include "G4VContinuousDiscreteProcess.hh" 69 #include "globals.hh" 76 #include "globals.hh" 70 #include "G4Material.hh" 77 #include "G4Material.hh" >> 78 #include "G4MaterialCutsCouple.hh" 71 #include "G4ParticleChangeForMSC.hh" 79 #include "G4ParticleChangeForMSC.hh" 72 #include "G4Track.hh" 80 #include "G4Track.hh" 73 #include "G4Step.hh" 81 #include "G4Step.hh" 74 #include "G4EmModelManager.hh" 82 #include "G4EmModelManager.hh" 75 #include "G4VMscModel.hh" 83 #include "G4VMscModel.hh" 76 #include "G4EmParameters.hh" << 77 #include "G4MscStepLimitType.hh" 84 #include "G4MscStepLimitType.hh" 78 85 79 class G4ParticleDefinition; 86 class G4ParticleDefinition; 80 class G4VEnergyLossProcess; << 87 class G4DataVector; 81 class G4LossTableManager; << 88 class G4PhysicsTable; 82 class G4SafetyHelper; << 89 class G4PhysicsVector; 83 90 84 //....oooOO0OOooo........oooOO0OOooo........oo 91 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 85 92 86 class G4VMultipleScattering : public G4VContin 93 class G4VMultipleScattering : public G4VContinuousDiscreteProcess 87 { 94 { 88 public: 95 public: 89 96 90 explicit G4VMultipleScattering(const G4Strin << 97 G4VMultipleScattering(const G4String& name = "msc", 91 G4ProcessType << 98 G4ProcessType type = fElectromagnetic); 92 99 93 ~G4VMultipleScattering() override; << 100 virtual ~G4VMultipleScattering(); 94 101 95 //------------------------------------------ 102 //------------------------------------------------------------------------ 96 // Virtual methods to be implemented for the 103 // Virtual methods to be implemented for the concrete model 97 //------------------------------------------ 104 //------------------------------------------------------------------------ 98 105 99 void ProcessDescription(std::ostream& outFil << 106 virtual G4bool IsApplicable(const G4ParticleDefinition& p) = 0; 100 107 101 virtual void InitialiseProcess(const G4Parti << 108 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 109 107 protected: 110 protected: 108 111 109 virtual void StreamProcessInfo(std::ostream& << 112 virtual void InitialiseProcess(const G4ParticleDefinition*) = 0; 110 113 111 public: 114 public: 112 115 113 //------------------------------------------ 116 //------------------------------------------------------------------------ 114 // Generic methods common to all ContinuousD 117 // Generic methods common to all ContinuousDiscrete processes 115 //------------------------------------------ 118 //------------------------------------------------------------------------ 116 119 117 // Initialise for build of tables 120 // Initialise for build of tables 118 void PreparePhysicsTable(const G4ParticleDef << 121 void PreparePhysicsTable(const G4ParticleDefinition&); 119 << 122 120 // Build physics table during initialisation 123 // Build physics table during initialisation 121 void BuildPhysicsTable(const G4ParticleDefin << 124 void BuildPhysicsTable(const G4ParticleDefinition&); >> 125 >> 126 // Print out of generic class parameters >> 127 void PrintInfoDefinition(); 122 128 123 // Store PhysicsTable in a file. 129 // Store PhysicsTable in a file. 124 // Return false in case of failure at I/O 130 // Return false in case of failure at I/O 125 G4bool StorePhysicsTable(const G4ParticleDef 131 G4bool StorePhysicsTable(const G4ParticleDefinition*, 126 const G4String& dir 132 const G4String& directory, 127 G4bool ascii = fals << 133 G4bool ascii = false); 128 134 129 // Retrieve Physics from a file. 135 // Retrieve Physics from a file. 130 // (return true if the Physics Table can be 136 // (return true if the Physics Table can be build by using file) 131 // (return false if the process has no funct 137 // (return false if the process has no functionality or in case of failure) 132 // File name should is constructed as proces 138 // File name should is constructed as processName+particleName and the 133 // should be placed under the directory spec << 139 // should be placed under the directory specifed by the argument. 134 G4bool RetrievePhysicsTable(const G4Particle 140 G4bool RetrievePhysicsTable(const G4ParticleDefinition*, 135 const G4String& 141 const G4String& directory, 136 G4bool ascii) ov << 142 G4bool ascii); 137 << 138 // This is called in the beginning of tracki << 139 void StartTracking(G4Track*) override; << 140 143 141 // The function overloads the corresponding 144 // The function overloads the corresponding function of the base 142 // class.It limits the step near to boundari 145 // class.It limits the step near to boundaries only 143 // and invokes the method GetMscContinuousSt 146 // and invokes the method GetMscContinuousStepLimit at every step. 144 G4double AlongStepGetPhysicalInteractionLeng 147 G4double AlongStepGetPhysicalInteractionLength( 145 const << 148 const G4Track&, 146 G4doub << 149 G4double previousStepSize, 147 G4doub << 150 G4double currentMinimalStep, 148 G4doub << 151 G4double& currentSafety, 149 G4GPIL << 152 G4GPILSelection* selection); 150 153 151 // The function overloads the corresponding 154 // The function overloads the corresponding function of the base 152 // class. 155 // class. 153 G4double PostStepGetPhysicalInteractionLengt 156 G4double PostStepGetPhysicalInteractionLength( 154 const G4 << 157 const G4Track&, 155 G4double << 158 G4double previousStepSize, 156 G4ForceC << 159 G4ForceCondition* condition); 157 160 158 // Along step actions 161 // Along step actions 159 G4VParticleChange* AlongStepDoIt(const G4Tra << 162 G4VParticleChange* AlongStepDoIt(const G4Track&, const G4Step&); >> 163 >> 164 // Post step actions >> 165 G4VParticleChange* PostStepDoIt(const G4Track&, const G4Step&); 160 166 161 // This method does not used for tracking, i 167 // This method does not used for tracking, it is intended only for tests 162 G4double ContinuousStepLimit(const G4Track& 168 G4double ContinuousStepLimit(const G4Track& track, 163 G4double previo << 169 G4double previousStepSize, 164 G4double curren << 170 G4double currentMinimalStep, 165 G4double& curre << 171 G4double& currentSafety); 166 << 172 167 // hide assignment operator << 173 //------------------------------------------------------------------------ 168 G4VMultipleScattering(G4VMultipleScattering << 174 // Specific methods to build and access Physics Tables 169 G4VMultipleScattering & operator=(const G4VM << 175 //------------------------------------------------------------------------ >> 176 >> 177 // Build empty Physics Vector >> 178 G4PhysicsVector* PhysicsVector(const G4MaterialCutsCouple*); >> 179 >> 180 inline void SetBinning(G4int nbins); >> 181 inline G4int Binning() const; >> 182 >> 183 inline void SetMinKinEnergy(G4double e); >> 184 inline G4double MinKinEnergy() const; >> 185 >> 186 inline void SetMaxKinEnergy(G4double e); >> 187 inline G4double MaxKinEnergy() const; >> 188 >> 189 inline void SetBuildLambdaTable(G4bool val); >> 190 >> 191 inline G4PhysicsTable* LambdaTable() const; >> 192 >> 193 // access particle type >> 194 inline const G4ParticleDefinition* Particle() const; 170 195 171 //------------------------------------------ 196 //------------------------------------------------------------------------ 172 // Specific methods to set, access, modify m 197 // Specific methods to set, access, modify models 173 //------------------------------------------ 198 //------------------------------------------------------------------------ 174 199 >> 200 protected: 175 // Select model in run time 201 // Select model in run time 176 inline G4VEmModel* SelectModel(G4double kinE << 202 inline G4VEmModel* SelectModel(G4double kinEnergy); 177 203 178 public: 204 public: >> 205 // Select model in run time >> 206 inline G4VEmModel* SelectModelForMaterial(G4double kinEnergy, >> 207 size_t& idxRegion) const; 179 208 180 // Add model for region, smaller value of or 209 // Add model for region, smaller value of order defines which 181 // model will be selected for a given energy 210 // model will be selected for a given energy interval 182 void AddEmModel(G4int order, G4VMscModel*, c << 211 void AddEmModel(G4int order, G4VEmModel*, const G4Region* region = 0); 183 212 184 // Assign a model to a process local list, t << 213 // Assign a model to a process 185 // the derived process should execute AddEmM << 214 void SetModel(G4VMscModel*, G4int index = 1); 186 void SetEmModel(G4VMscModel*, G4int idx = 0) << 187 215 188 // return a model from the local list << 216 // return the assigned model 189 inline G4VMscModel* EmModel(size_t index = 0 << 217 G4VMscModel* Model(G4int index = 1); 190 << 191 // Access to run time models << 192 inline G4int NumberOfModels() const; << 193 218 194 inline G4VMscModel* GetModelByIndex(G4int id << 219 // Access to models by index >> 220 G4VEmModel* GetModelByIndex(G4int idx = 0, G4bool ver = false) const; 195 221 196 //------------------------------------------ 222 //------------------------------------------------------------------------ 197 // Get/Set parameters for simulation of mult 223 // Get/Set parameters for simulation of multiple scattering 198 //------------------------------------------ 224 //------------------------------------------------------------------------ 199 225 200 inline G4bool LateralDisplasmentFlag() const 226 inline G4bool LateralDisplasmentFlag() const; 201 << 227 inline void SetLateralDisplasmentFlag(G4bool val); >> 228 202 inline G4double Skin() const; 229 inline G4double Skin() const; 203 << 230 inline void SetSkin(G4double val); >> 231 204 inline G4double RangeFactor() const; 232 inline G4double RangeFactor() const; 205 << 233 inline void SetRangeFactor(G4double val); >> 234 206 inline G4double GeomFactor() const; 235 inline G4double GeomFactor() const; 207 << 236 inline void SetGeomFactor(G4double val); >> 237 208 inline G4double PolarAngleLimit() const; 238 inline G4double PolarAngleLimit() const; >> 239 inline void SetPolarAngleLimit(G4double val); 209 240 210 inline G4bool UseBaseMaterial() const; << 211 << 212 inline G4MscStepLimitType StepLimitType() co 241 inline G4MscStepLimitType StepLimitType() const; 213 inline void SetStepLimitType(G4MscStepLimitT 242 inline void SetStepLimitType(G4MscStepLimitType val); 214 243 215 inline G4double LowestKinEnergy() const; << 216 inline void SetLowestKinEnergy(G4double val) << 217 << 218 inline const G4ParticleDefinition* FirstPart << 219 << 220 //------------------------------------------ 244 //------------------------------------------------------------------------ 221 // Run time methods 245 // Run time methods 222 //------------------------------------------ 246 //------------------------------------------------------------------------ 223 247 224 protected: 248 protected: 225 249 226 // This method is not used for tracking, it 250 // This method is not used for tracking, it returns mean free path value 227 G4double GetMeanFreePath(const G4Track& trac 251 G4double GetMeanFreePath(const G4Track& track, 228 G4double, << 252 G4double, 229 G4ForceCondition* c << 253 G4ForceCondition* condition); 230 254 231 // This method is not used for tracking, it 255 // This method is not used for tracking, it returns step limit 232 G4double GetContinuousStepLimit(const G4Trac 256 G4double GetContinuousStepLimit(const G4Track& track, 233 G4double pre << 257 G4double previousStepSize, 234 G4double cur << 258 G4double currentMinimalStep, 235 G4double& cu << 259 G4double& currentSafety); >> 260 >> 261 // This method returns inversed transport cross section >> 262 inline G4double GetLambda(const G4ParticleDefinition* p, >> 263 G4double& kineticEnergy); >> 264 >> 265 // defines current material in run time >> 266 inline void DefineMaterial(const G4MaterialCutsCouple* couple); >> 267 >> 268 inline const G4MaterialCutsCouple* CurrentMaterialCutsCouple() const; 236 269 237 private: 270 private: 238 271 >> 272 // hide assignment operator >> 273 G4VMultipleScattering(G4VMultipleScattering &); >> 274 G4VMultipleScattering & operator=(const G4VMultipleScattering &right); >> 275 239 // ======== Parameters of the class fixed at 276 // ======== Parameters of the class fixed at construction ========= 240 277 241 G4EmModelManager* modelManager; 278 G4EmModelManager* modelManager; 242 G4LossTableManager* emManager; << 279 G4bool buildLambdaTable; 243 G4EmParameters* theParameters; << 244 280 245 // ======== Parameters of the class fixed at 281 // ======== Parameters of the class fixed at initialisation ======= 246 282 247 G4SafetyHelper* safetyHelper = n << 248 const G4ParticleDefinition* firstParticle = << 249 const G4ParticleDefinition* currParticle = n << 250 << 251 std::vector<G4VMscModel*> mscModels; 283 std::vector<G4VMscModel*> mscModels; 252 284 253 G4double facrange = 0.04; << 285 G4PhysicsTable* theLambdaTable; 254 G4double lowestKinEnergy; << 286 const G4ParticleDefinition* firstParticle; >> 287 >> 288 const std::vector<G4double>* theDensityFactor; >> 289 const std::vector<G4int>* theDensityIdx; >> 290 >> 291 G4MscStepLimitType stepLimit; >> 292 >> 293 G4double minKinEnergy; >> 294 G4double maxKinEnergy; >> 295 G4double skin; >> 296 G4double facrange; >> 297 G4double facgeom; >> 298 G4double polarAngleLimit; 255 299 256 // ======== Cached values - may be state dep << 300 G4int nBins; >> 301 >> 302 G4bool latDisplasment; >> 303 G4bool isIon; >> 304 >> 305 // ======== Cashed values - may be state dependent ================ 257 306 258 protected: 307 protected: 259 308 >> 309 G4GPILSelection valueGPILSelectionMSC; 260 G4ParticleChangeForMSC fParticleChange; 310 G4ParticleChangeForMSC fParticleChange; 261 311 262 private: 312 private: 263 313 264 G4ThreeVector fNewPosition; << 314 G4VMscModel* currentModel; 265 G4ThreeVector fNewDirection; << 266 315 267 G4VMscModel* currentModel = n << 316 // cache 268 G4VEnergyLossProcess* fIonisation = nu << 317 const G4ParticleDefinition* currentParticle; >> 318 const G4MaterialCutsCouple* currentCouple; >> 319 size_t currentCoupleIndex; >> 320 size_t basedCoupleIndex; 269 321 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 }; 322 }; 285 323 286 // ======== Run time inline methods ========== 324 // ======== Run time inline methods ================ 287 325 >> 326 inline const G4MaterialCutsCouple* >> 327 G4VMultipleScattering::CurrentMaterialCutsCouple() const >> 328 { >> 329 return currentCouple; >> 330 } >> 331 288 //....oooOO0OOooo........oooOO0OOooo........oo 332 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 289 333 290 inline G4VEmModel* << 334 inline 291 G4VMultipleScattering::SelectModel(G4double ki << 335 void G4VMultipleScattering::DefineMaterial(const G4MaterialCutsCouple* couple) 292 { 336 { 293 return modelManager->SelectModel(kinEnergy, << 337 if(couple != currentCouple) { >> 338 currentCouple = couple; >> 339 currentCoupleIndex = couple->GetIndex(); >> 340 basedCoupleIndex = (*theDensityIdx)[currentCoupleIndex]; >> 341 } 294 } 342 } 295 343 296 //....oooOO0OOooo........oooOO0OOooo........oo 344 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 297 345 298 inline G4bool G4VMultipleScattering::LateralD << 346 inline >> 347 G4double G4VMultipleScattering::GetLambda(const G4ParticleDefinition* p, >> 348 G4double& e) 299 { 349 { 300 return latDisplacement; << 350 G4double x; >> 351 if(theLambdaTable) { >> 352 x = (*theDensityFactor)[currentCoupleIndex]* >> 353 ((*theLambdaTable)[basedCoupleIndex])->Value(e); >> 354 } else { >> 355 x = currentModel->CrossSection(currentCouple,p,e); >> 356 } >> 357 if(x > 0.0) { x = 1./x; } >> 358 else { x = DBL_MAX; } >> 359 return x; 301 } 360 } 302 361 303 //....oooOO0OOooo........oooOO0OOooo........oo 362 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 304 363 305 inline G4double G4VMultipleScattering::Skin() << 364 inline G4VEmModel* G4VMultipleScattering::SelectModel(G4double kinEnergy) 306 { 365 { 307 return theParameters->MscSkin(); << 366 return modelManager->SelectModel(kinEnergy, currentCoupleIndex); 308 } 367 } 309 368 310 //....oooOO0OOooo........oooOO0OOooo........oo 369 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 311 370 312 inline G4double G4VMultipleScattering::RangeF << 371 inline G4VEmModel* G4VMultipleScattering::SelectModelForMaterial( >> 372 G4double kinEnergy, size_t& idxRegion) const 313 { 373 { 314 return facrange; << 374 return modelManager->SelectModel(kinEnergy, idxRegion); >> 375 } >> 376 >> 377 // ======== Get/Set inline methods used at initialisation ================ >> 378 >> 379 inline void G4VMultipleScattering::SetBinning(G4int nbins) >> 380 { >> 381 nBins = nbins; 315 } 382 } 316 383 317 //....oooOO0OOooo........oooOO0OOooo........oo 384 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 318 385 319 inline G4double G4VMultipleScattering::GeomFa << 386 inline G4int G4VMultipleScattering::Binning() const 320 { 387 { 321 return theParameters->MscGeomFactor(); << 388 return nBins; 322 } 389 } 323 390 324 //....oooOO0OOooo........oooOO0OOooo........oo 391 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 325 392 326 inline G4double G4VMultipleScattering::PolarA << 393 inline void G4VMultipleScattering::SetMinKinEnergy(G4double e) 327 { 394 { 328 return theParameters->MscThetaLimit(); << 395 minKinEnergy = e; 329 } 396 } 330 397 331 //....oooOO0OOooo........oooOO0OOooo........oo 398 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 332 399 333 inline G4MscStepLimitType G4VMultipleScatterin << 400 inline G4double G4VMultipleScattering::MinKinEnergy() const 334 { 401 { 335 return stepLimit; << 402 return minKinEnergy; 336 } 403 } 337 404 338 //....oooOO0OOooo........oooOO0OOooo........oo 405 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 339 406 340 inline void G4VMultipleScattering::SetStepLimi << 407 inline void G4VMultipleScattering::SetMaxKinEnergy(G4double e) >> 408 { >> 409 maxKinEnergy = e; >> 410 } >> 411 >> 412 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... >> 413 >> 414 inline G4double G4VMultipleScattering::MaxKinEnergy() const >> 415 { >> 416 return maxKinEnergy; >> 417 } >> 418 >> 419 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... >> 420 >> 421 inline void G4VMultipleScattering::SetBuildLambdaTable(G4bool val) >> 422 { >> 423 buildLambdaTable = val; >> 424 } >> 425 >> 426 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... >> 427 >> 428 inline G4PhysicsTable* G4VMultipleScattering::LambdaTable() const >> 429 { >> 430 return theLambdaTable; >> 431 } >> 432 >> 433 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... >> 434 >> 435 inline const G4ParticleDefinition* G4VMultipleScattering::Particle() const >> 436 { >> 437 return currentParticle; >> 438 } >> 439 >> 440 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... >> 441 >> 442 inline G4bool G4VMultipleScattering::LateralDisplasmentFlag() const >> 443 { >> 444 return latDisplasment; >> 445 } >> 446 >> 447 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... >> 448 >> 449 inline void G4VMultipleScattering::SetLateralDisplasmentFlag(G4bool val) >> 450 { >> 451 latDisplasment = val; >> 452 } >> 453 >> 454 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... >> 455 >> 456 inline G4double G4VMultipleScattering::Skin() const >> 457 { >> 458 return skin; >> 459 } >> 460 >> 461 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... >> 462 >> 463 inline void G4VMultipleScattering::SetSkin(G4double val) 341 { 464 { 342 theParameters->SetMscStepLimitType(val); << 465 if(val < 1.0) { skin = 0.0; } >> 466 else { skin = val; } 343 } 467 } 344 468 345 //....oooOO0OOooo........oooOO0OOooo........oo 469 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 346 470 347 inline G4double G4VMultipleScattering::LowestK << 471 inline G4double G4VMultipleScattering::RangeFactor() const 348 { 472 { 349 return lowestKinEnergy; << 473 return facrange; 350 } 474 } 351 475 352 //....oooOO0OOooo........oooOO0OOooo........oo 476 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 353 477 354 inline void G4VMultipleScattering::SetLowestKi << 478 inline void G4VMultipleScattering::SetRangeFactor(G4double val) 355 { 479 { 356 lowestKinEnergy = val; << 480 if(val > 0.0) facrange = val; 357 } 481 } 358 482 359 //....oooOO0OOooo........oooOO0OOooo........oo 483 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 360 484 361 inline const G4ParticleDefinition* G4VMultiple << 485 inline G4double G4VMultipleScattering::GeomFactor() const 362 { 486 { 363 return firstParticle; << 487 return facgeom; 364 } 488 } 365 489 366 //....oooOO0OOooo........oooOO0OOooo........oo 490 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 367 491 368 inline G4VMscModel* G4VMultipleScattering::EmM << 492 inline void G4VMultipleScattering::SetGeomFactor(G4double val) 369 { 493 { 370 return (index < mscModels.size()) ? mscModel << 494 if(val > 0.0) facgeom = val; 371 } 495 } 372 496 373 //....oooOO0OOooo........oooOO0OOooo........oo 497 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 374 498 375 inline G4int G4VMultipleScattering::NumberOfMo << 499 inline G4double G4VMultipleScattering::PolarAngleLimit() const 376 { 500 { 377 return numberOfModels; << 501 return polarAngleLimit; 378 } 502 } 379 503 380 //....oooOO0OOooo........oooOO0OOooo........oo 504 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 381 505 382 inline G4VMscModel* << 506 inline void G4VMultipleScattering::SetPolarAngleLimit(G4double val) 383 G4VMultipleScattering::GetModelByIndex(G4int i << 384 { 507 { 385 // static cast is possible inside this class << 508 if(val < 0.0) { polarAngleLimit = 0.0; } 386 return static_cast<G4VMscModel*>(modelManage << 509 else if(val > CLHEP::pi) { polarAngleLimit = CLHEP::pi; } >> 510 else { polarAngleLimit = val; } 387 } 511 } 388 512 389 //....oooOO0OOooo........oooOO0OOooo........oo 513 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 390 514 391 inline G4bool G4VMultipleScattering::UseBaseMa << 515 inline G4MscStepLimitType G4VMultipleScattering::StepLimitType() const >> 516 { >> 517 return stepLimit; >> 518 } >> 519 >> 520 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... >> 521 >> 522 inline void G4VMultipleScattering::SetStepLimitType(G4MscStepLimitType val) 392 { 523 { 393 return baseMat; << 524 stepLimit = val; >> 525 if(val == fMinimal) { facrange = 0.2; } 394 } 526 } 395 527 396 //....oooOO0OOooo........oooOO0OOooo........oo 528 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 397 529 398 #endif 530 #endif 399 531