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: G4VEmProcess.hh 74376 2013-10-04 08:25:47Z gcosmo $ >> 27 // 26 // ------------------------------------------- 28 // ------------------------------------------------------------------- 27 // 29 // 28 // GEANT4 Class header file 30 // GEANT4 Class header file 29 // 31 // 30 // 32 // 31 // File name: G4VEmProcess 33 // File name: G4VEmProcess 32 // 34 // 33 // Author: Vladimir Ivanchenko 35 // Author: Vladimir Ivanchenko 34 // 36 // 35 // Creation date: 01.10.2003 37 // Creation date: 01.10.2003 36 // 38 // 37 // Modifications: Vladimir Ivanchenko << 39 // Modifications: >> 40 // 30-06-04 make destructor virtual (V.Ivanchenko) >> 41 // 09-08-04 optimise integral option (V.Ivanchenko) >> 42 // 11-08-04 add protected methods to access cuts (V.Ivanchenko) >> 43 // 09-09-04 Bug fix for the integral mode with 2 peaks (V.Ivanchneko) >> 44 // 16-09-04 Add flag for LambdaTable and method RecalculateLambda (VI) >> 45 // 08-11-04 Migration to new interface of Store/Retrieve tables (V.Ivantchenko) >> 46 // 08-04-05 Major optimisation of internal interfaces (V.Ivantchenko) >> 47 // 18-04-05 Use G4ParticleChangeForGamma (V.Ivantchenko) >> 48 // 09-05-05 Fix problem in logic when path boundary between materials (VI) >> 49 // 11-01-06 add A to parameters of ComputeCrossSectionPerAtom (VI) >> 50 // 01-02-06 put default value A=0. to keep compatibility with v5.2 (mma) >> 51 // 13-05-06 Add method to access model by index (V.Ivanchenko) >> 52 // 12-09-06 add SetModel() (mma) >> 53 // 25-09-07 More accurate handling zero xsect in >> 54 // PostStepGetPhysicalInteractionLength (V.Ivanchenko) >> 55 // 27-10-07 Virtual functions moved to source (V.Ivanchenko) >> 56 // 15-07-08 Reorder class members for further multi-thread development (VI) >> 57 // 17-02-10 Added pointer currentParticle (VI) 38 // 58 // 39 // Class Description: 59 // Class Description: 40 // 60 // 41 // It is the base class - EM discrete and rest << 61 // It is the unified Discrete process 42 62 43 // ------------------------------------------- 63 // ------------------------------------------------------------------- 44 // 64 // 45 65 46 #ifndef G4VEmProcess_h 66 #ifndef G4VEmProcess_h 47 #define G4VEmProcess_h 1 67 #define G4VEmProcess_h 1 48 68 49 #include <CLHEP/Units/SystemOfUnits.h> 69 #include <CLHEP/Units/SystemOfUnits.h> 50 70 51 #include "G4VDiscreteProcess.hh" 71 #include "G4VDiscreteProcess.hh" 52 #include "globals.hh" 72 #include "globals.hh" 53 #include "G4Material.hh" 73 #include "G4Material.hh" 54 #include "G4MaterialCutsCouple.hh" 74 #include "G4MaterialCutsCouple.hh" 55 #include "G4Track.hh" 75 #include "G4Track.hh" >> 76 #include "G4EmModelManager.hh" 56 #include "G4UnitsTable.hh" 77 #include "G4UnitsTable.hh" 57 #include "G4ParticleDefinition.hh" 78 #include "G4ParticleDefinition.hh" 58 #include "G4ParticleChangeForGamma.hh" 79 #include "G4ParticleChangeForGamma.hh" 59 #include "G4EmParameters.hh" << 60 #include "G4EmDataHandler.hh" << 61 #include "G4EmTableType.hh" << 62 #include "G4EmModelManager.hh" << 63 #include "G4EmSecondaryParticleType.hh" << 64 80 65 class G4Step; 81 class G4Step; 66 class G4VEmModel; 82 class G4VEmModel; 67 class G4DataVector; 83 class G4DataVector; 68 class G4VParticleChange; 84 class G4VParticleChange; 69 class G4PhysicsTable; 85 class G4PhysicsTable; 70 class G4PhysicsVector; 86 class G4PhysicsVector; 71 class G4EmBiasingManager; 87 class G4EmBiasingManager; 72 class G4LossTableManager; 88 class G4LossTableManager; 73 89 74 //....oooOO0OOooo........oooOO0OOooo........oo 90 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 75 91 76 class G4VEmProcess : public G4VDiscreteProcess 92 class G4VEmProcess : public G4VDiscreteProcess 77 { 93 { 78 public: 94 public: 79 95 80 G4VEmProcess(const G4String& name, G4Process << 96 G4VEmProcess(const G4String& name, >> 97 G4ProcessType type = fElectromagnetic); 81 98 82 ~G4VEmProcess() override; << 99 virtual ~G4VEmProcess(); 83 100 84 //------------------------------------------ 101 //------------------------------------------------------------------------ 85 // Virtual methods to be implemented in conc 102 // Virtual methods to be implemented in concrete processes 86 //------------------------------------------ 103 //------------------------------------------------------------------------ 87 104 88 void ProcessDescription(std::ostream& outFil << 105 virtual G4bool IsApplicable(const G4ParticleDefinition& p) = 0; 89 106 90 protected: << 107 virtual void PrintInfo() = 0; 91 108 92 virtual void StreamProcessInfo(std::ostream& << 109 protected: 93 110 94 virtual void InitialiseProcess(const G4Parti 111 virtual void InitialiseProcess(const G4ParticleDefinition*) = 0; 95 112 96 //------------------------------------------ 113 //------------------------------------------------------------------------ >> 114 // Method with standard implementation; may be overwritten if needed >> 115 //------------------------------------------------------------------------ >> 116 >> 117 virtual G4double MinPrimaryEnergy(const G4ParticleDefinition*, >> 118 const G4Material*); >> 119 >> 120 //------------------------------------------------------------------------ 97 // Implementation of virtual methods common 121 // Implementation of virtual methods common to all Discrete processes 98 //------------------------------------------ 122 //------------------------------------------------------------------------ 99 123 100 public: 124 public: 101 125 102 // Initialise for build of tables 126 // Initialise for build of tables 103 void PreparePhysicsTable(const G4ParticleDef << 127 void PreparePhysicsTable(const G4ParticleDefinition&); 104 128 105 // Build physics table during initialisation 129 // Build physics table during initialisation 106 void BuildPhysicsTable(const G4ParticleDefin << 130 void BuildPhysicsTable(const G4ParticleDefinition&); 107 131 108 // Called before tracking of each new G4Trac 132 // Called before tracking of each new G4Track 109 void StartTracking(G4Track*) override; << 133 void StartTracking(G4Track*); 110 134 111 // implementation of virtual method, specifi 135 // implementation of virtual method, specific for G4VEmProcess 112 G4double PostStepGetPhysicalInteractionLengt 136 G4double PostStepGetPhysicalInteractionLength( 113 const G4Track& tr 137 const G4Track& track, 114 G4double previo 138 G4double previousStepSize, 115 G4ForceCondition* << 139 G4ForceCondition* condition); 116 140 117 // implementation of virtual method, specifi 141 // implementation of virtual method, specific for G4VEmProcess 118 G4VParticleChange* PostStepDoIt(const G4Trac << 142 G4VParticleChange* PostStepDoIt(const G4Track&, const G4Step&); 119 143 120 // Store PhysicsTable in a file. 144 // Store PhysicsTable in a file. 121 // Return false in case of failure at I/O 145 // Return false in case of failure at I/O 122 G4bool StorePhysicsTable(const G4ParticleDef 146 G4bool StorePhysicsTable(const G4ParticleDefinition*, 123 const G4String& dir << 147 const G4String& directory, 124 G4bool ascii = fals << 148 G4bool ascii = false); 125 149 126 // Retrieve Physics from a file. 150 // Retrieve Physics from a file. 127 // (return true if the Physics Table can be 151 // (return true if the Physics Table can be build by using file) 128 // (return false if the process has no funct 152 // (return false if the process has no functionality or in case of failure) 129 // File name should is constructed as proces 153 // File name should is constructed as processName+particleName and the 130 // should be placed under the directory spec << 154 // should be placed under the directory specifed by the argument. 131 G4bool RetrievePhysicsTable(const G4Particle 155 G4bool RetrievePhysicsTable(const G4ParticleDefinition*, 132 const G4String& << 156 const G4String& directory, 133 G4bool ascii) ov << 157 G4bool ascii); 134 << 135 // allowing check process name << 136 virtual G4VEmProcess* GetEmProcess(const G4S << 137 158 138 //------------------------------------------ 159 //------------------------------------------------------------------------ 139 // Specific methods for Discrete EM post ste 160 // Specific methods for Discrete EM post step simulation 140 //------------------------------------------ 161 //------------------------------------------------------------------------ 141 162 142 // The main method to access cross section p << 163 // It returns the cross section per volume for energy/ material 143 inline G4double GetLambda(G4double kinEnergy << 164 G4double CrossSectionPerVolume(G4double kineticEnergy, 144 const G4MaterialCu << 165 const G4MaterialCutsCouple* couple); 145 G4double logKinEne << 146 << 147 // It returns the cross section per volume f << 148 G4double GetCrossSection(const G4double kinE << 149 const G4MaterialCut << 150 166 151 // It returns the cross section of the proce 167 // It returns the cross section of the process per atom 152 G4double ComputeCrossSectionPerAtom(G4double 168 G4double ComputeCrossSectionPerAtom(G4double kineticEnergy, 153 G4double << 169 G4double Z, G4double A=0., 154 G4double << 170 G4double cut=0.0); >> 171 >> 172 G4double MeanFreePath(const G4Track& track); 155 173 156 inline G4double MeanFreePath(const G4Track& << 174 // It returns cross section per volume >> 175 inline G4double GetLambda(G4double& kinEnergy, >> 176 const G4MaterialCutsCouple* couple); 157 177 158 //------------------------------------------ 178 //------------------------------------------------------------------------ 159 // Specific methods to build and access Phys 179 // Specific methods to build and access Physics Tables 160 //------------------------------------------ 180 //------------------------------------------------------------------------ 161 181 162 // Binning for lambda table 182 // Binning for lambda table 163 void SetLambdaBinning(G4int nbins); << 183 inline void SetLambdaBinning(G4int nbins); >> 184 inline G4int LambdaBinning() const; 164 185 165 // Min kinetic energy for tables 186 // Min kinetic energy for tables 166 void SetMinKinEnergy(G4double e); 187 void SetMinKinEnergy(G4double e); 167 << 188 inline G4double MinKinEnergy() const; 168 // Min kinetic energy for high energy table << 169 void SetMinKinEnergyPrim(G4double e); << 170 189 171 // Max kinetic energy for tables 190 // Max kinetic energy for tables 172 void SetMaxKinEnergy(G4double e); 191 void SetMaxKinEnergy(G4double e); >> 192 inline G4double MaxKinEnergy() const; >> 193 >> 194 // Min kinetic energy for high energy table >> 195 inline void SetMinKinEnergyPrim(G4double e); 173 196 174 // Cross section table pointers 197 // Cross section table pointers 175 inline G4PhysicsTable* LambdaTable() const; 198 inline G4PhysicsTable* LambdaTable() const; 176 inline G4PhysicsTable* LambdaTablePrim() con 199 inline G4PhysicsTable* LambdaTablePrim() const; 177 inline void SetLambdaTable(G4PhysicsTable*); << 178 inline void SetLambdaTablePrim(G4PhysicsTabl << 179 << 180 // Integral method type and peak positions << 181 inline std::vector<G4double>* EnergyOfCrossS << 182 inline void SetEnergyOfCrossSectionMax(std:: << 183 inline G4CrossSectionType CrossSectionType() << 184 inline void SetCrossSectionType(G4CrossSecti << 185 200 186 //------------------------------------------ 201 //------------------------------------------------------------------------ 187 // Define and access particle type 202 // Define and access particle type 188 //------------------------------------------ 203 //------------------------------------------------------------------------ 189 204 190 inline const G4ParticleDefinition* Particle( 205 inline const G4ParticleDefinition* Particle() const; 191 inline const G4ParticleDefinition* Secondary 206 inline const G4ParticleDefinition* SecondaryParticle() const; 192 207 193 protected: << 194 << 195 //------------------------------------------ 208 //------------------------------------------------------------------------ 196 // Specific methods to set, access, modify m 209 // Specific methods to set, access, modify models and basic parameters 197 //------------------------------------------ 210 //------------------------------------------------------------------------ 198 << 211 >> 212 protected: 199 // Select model in run time 213 // Select model in run time 200 inline G4VEmModel* SelectModel(G4double kinE << 214 inline G4VEmModel* SelectModel(G4double& kinEnergy, size_t index); 201 215 202 public: 216 public: 203 << 217 // Select model by energy and region index 204 // Select model by energy and couple index << 205 inline G4VEmModel* SelectModelForMaterial(G4 218 inline G4VEmModel* SelectModelForMaterial(G4double kinEnergy, 206 st << 219 size_t& idxRegion) const; 207 220 208 // Add model for region, smaller value of or 221 // Add model for region, smaller value of order defines which 209 // model will be selected for a given energy 222 // model will be selected for a given energy interval 210 void AddEmModel(G4int, G4VEmModel*, const G4 << 223 void AddEmModel(G4int, G4VEmModel*, const G4Region* region = 0); 211 224 212 // Assign a model to a process local list, t << 225 // return the assigned model 213 // the derived process should execute AddEmM << 226 G4VEmModel* EmModel(G4int index = 1) const; 214 void SetEmModel(G4VEmModel*, G4int index = 0 << 215 227 216 inline G4int NumberOfModels() const; << 228 // Assign a model to a process >> 229 void SetEmModel(G4VEmModel*, G4int index = 1); 217 230 218 // return a model from the local list << 231 // Define new energy range for the model identified by the name 219 inline G4VEmModel* EmModel(std::size_t index << 232 void UpdateEmModel(const G4String&, G4double, G4double); 220 << 221 // Access to active model << 222 inline const G4VEmModel* GetCurrentModel() c << 223 233 224 // Access to models 234 // Access to models 225 inline G4VEmModel* GetModelByIndex(G4int idx << 235 G4VEmModel* GetModelByIndex(G4int idx = 0, G4bool ver = false) const; 226 236 227 // Access to the current G4Element << 237 // access atom on which interaction happens 228 const G4Element* GetCurrentElement() const; 238 const G4Element* GetCurrentElement() const; 229 239 230 // Biasing parameters 240 // Biasing parameters 231 void SetCrossSectionBiasingFactor(G4double f 241 void SetCrossSectionBiasingFactor(G4double f, G4bool flag = true); 232 inline G4double CrossSectionBiasingFactor() 242 inline G4double CrossSectionBiasingFactor() const; 233 243 234 // Activate forced interaction 244 // Activate forced interaction 235 void ActivateForcedInteraction(G4double leng 245 void ActivateForcedInteraction(G4double length = 0.0, 236 const G4Strin << 246 const G4String& r = "", 237 G4bool flag = << 247 G4bool flag = true); 238 248 239 void ActivateSecondaryBiasing(const G4String 249 void ActivateSecondaryBiasing(const G4String& region, G4double factor, 240 G4double energ << 250 G4double energyLimit); 241 << 251 242 inline void SetEmMasterProcess(const G4VEmPr << 243 252 244 inline void SetBuildTableFlag(G4bool val); << 253 // Single scattering parameters >> 254 inline void SetPolarAngleLimit(G4double a); >> 255 inline G4double PolarAngleLimit() const; 245 256 246 inline void CurrentSetup(const G4MaterialCut << 257 inline void SetLambdaFactor(G4double val); 247 258 248 inline G4bool UseBaseMaterial() const; << 259 inline void SetIntegral(G4bool val); >> 260 inline G4bool IsIntegral() const; 249 261 250 void BuildLambdaTable(); << 262 inline void SetApplyCuts(G4bool val); 251 263 252 void StreamInfo(std::ostream& outFile, const << 264 inline void SetBuildTableFlag(G4bool val); 253 G4bool rst=false) const; << 254 << 255 // hide copy constructor and assignment oper << 256 G4VEmProcess(G4VEmProcess &) = delete; << 257 G4VEmProcess & operator=(const G4VEmProcess << 258 265 259 //------------------------------------------ 266 //------------------------------------------------------------------------ 260 // Other generic methods 267 // Other generic methods 261 //------------------------------------------ 268 //------------------------------------------------------------------------ 262 269 263 protected: 270 protected: 264 271 265 G4double GetMeanFreePath(const G4Track& trac 272 G4double GetMeanFreePath(const G4Track& track, 266 G4double previousSt << 273 G4double previousStepSize, 267 G4ForceCondition* c << 274 G4ForceCondition* condition); 268 275 269 G4PhysicsVector* LambdaPhysicsVector(const G 276 G4PhysicsVector* LambdaPhysicsVector(const G4MaterialCutsCouple*); 270 277 271 inline void DefineMaterial(const G4MaterialC << 278 inline G4double RecalculateLambda(G4double kinEnergy, 272 << 279 const G4MaterialCutsCouple* couple); 273 inline G4int LambdaBinning() const; << 274 << 275 inline G4double MinKinEnergy() const; << 276 << 277 inline G4double MaxKinEnergy() const; << 278 << 279 // Single scattering parameters << 280 inline G4double PolarAngleLimit() const; << 281 280 282 inline G4ParticleChangeForGamma* GetParticle 281 inline G4ParticleChangeForGamma* GetParticleChange(); 283 282 284 inline void SetParticle(const G4ParticleDefi 283 inline void SetParticle(const G4ParticleDefinition* p); 285 284 286 inline void SetSecondaryParticle(const G4Par 285 inline void SetSecondaryParticle(const G4ParticleDefinition* p); 287 286 288 inline std::size_t CurrentMaterialCutsCouple << 287 inline size_t CurrentMaterialCutsCoupleIndex() const; 289 << 290 inline const G4MaterialCutsCouple* MaterialC << 291 << 292 inline G4bool ApplyCuts() const; << 293 288 294 inline G4double GetGammaEnergyCut(); 289 inline G4double GetGammaEnergyCut(); 295 290 296 inline G4double GetElectronEnergyCut(); 291 inline G4double GetElectronEnergyCut(); 297 292 298 inline void SetStartFromNullFlag(G4bool val) 293 inline void SetStartFromNullFlag(G4bool val); 299 294 300 inline void SetSplineFlag(G4bool val); 295 inline void SetSplineFlag(G4bool val); 301 296 302 const G4Element* GetTargetElement() const; << 297 private: 303 298 304 const G4Isotope* GetTargetIsotope() const; << 299 void Clear(); 305 300 306 // these two methods assume that vectors are << 301 void BuildLambdaTable(); 307 // and idx is within vector length << 308 inline G4int DensityIndex(G4int idx) const; << 309 inline G4double DensityFactor(G4int idx) con << 310 302 311 private: << 303 void PrintInfoProcess(const G4ParticleDefinition&); 312 304 313 void PrintWarning(G4String tit, G4double val << 305 void FindLambdaMax(); 314 306 315 void ComputeIntegralLambda(G4double kinEnerg << 307 inline void DefineMaterial(const G4MaterialCutsCouple* couple); 316 308 317 inline G4double LogEkin(const G4Track&); << 309 inline void ComputeIntegralLambda(G4double kinEnergy); 318 310 319 inline G4double GetLambdaFromTable(G4double 311 inline G4double GetLambdaFromTable(G4double kinEnergy); 320 312 321 inline G4double GetLambdaFromTable(G4double << 322 << 323 inline G4double GetLambdaFromTablePrim(G4dou 313 inline G4double GetLambdaFromTablePrim(G4double kinEnergy); 324 314 325 inline G4double GetLambdaFromTablePrim(G4dou << 326 << 327 inline G4double GetCurrentLambda(G4double ki 315 inline G4double GetCurrentLambda(G4double kinEnergy); 328 316 329 inline G4double GetCurrentLambda(G4double ki << 330 << 331 inline G4double ComputeCurrentLambda(G4doubl 317 inline G4double ComputeCurrentLambda(G4double kinEnergy); 332 318 333 // ======== pointers ========= << 319 // copy constructor and hide assignment operator 334 << 320 G4VEmProcess(G4VEmProcess &); 335 G4EmModelManager* modelManager = << 321 G4VEmProcess & operator=(const G4VEmProcess &right); 336 const G4ParticleDefinition* particle = null << 322 337 const G4ParticleDefinition* currentParticle << 323 // ======== Parameters of the class fixed at construction ========= 338 const G4ParticleDefinition* theGamma = null << 324 339 const G4ParticleDefinition* theElectron = n << 325 G4LossTableManager* lManager; 340 const G4ParticleDefinition* thePositron = n << 326 G4EmModelManager* modelManager; 341 const G4ParticleDefinition* secondaryPartic << 327 G4EmBiasingManager* biasManager; 342 const G4VEmProcess* masterProc = nu << 328 const G4ParticleDefinition* theGamma; 343 G4EmDataHandler* theData = nullp << 329 const G4ParticleDefinition* theElectron; 344 G4VEmModel* currentModel = << 330 const G4ParticleDefinition* thePositron; 345 G4LossTableManager* lManager = null << 331 const G4ParticleDefinition* secondaryParticle; 346 G4EmParameters* theParameters = << 332 347 const G4Material* baseMaterial = << 333 G4bool buildLambdaTable; 348 << 334 349 // ======== tables and vectors ======== << 335 // ======== Parameters of the class fixed at initialisation ======= 350 G4PhysicsTable* theLambdaTable << 336 351 G4PhysicsTable* theLambdaTableP << 337 std::vector<G4VEmModel*> emModels; 352 << 338 G4int numberOfModels; 353 const std::vector<G4double>* theCuts = nullp << 339 354 const std::vector<G4double>* theCutsGamma = << 340 // tables and vectors 355 const std::vector<G4double>* theCutsElectron << 341 G4PhysicsTable* theLambdaTable; 356 const std::vector<G4double>* theCutsPositron << 342 G4PhysicsTable* theLambdaTablePrim; 357 << 343 std::vector<G4double> theEnergyOfCrossSectionMax; 358 protected: << 344 std::vector<G4double> theCrossSectionMax; 359 << 345 360 // ======== pointers ========= << 346 size_t idxLambda; 361 << 347 size_t idxLambdaPrim; 362 const G4MaterialCutsCouple* currentCouple = << 348 363 const G4Material* currentMaterial << 349 const std::vector<G4double>* theCuts; 364 G4EmBiasingManager* biasManager = n << 350 const std::vector<G4double>* theCutsGamma; 365 std::vector<G4double>* theEnergyOfCros << 351 const std::vector<G4double>* theCutsElectron; 366 << 352 const std::vector<G4double>* theCutsPositron; 367 private: << 353 const std::vector<G4double>* theDensityFactor; 368 << 354 const std::vector<G4int>* theDensityIdx; 369 const std::vector<G4double>* theDensityFacto << 355 370 const std::vector<G4int>* theDensityIdx = nu << 356 G4int nLambdaBins; >> 357 >> 358 G4double minKinEnergy; >> 359 G4double minKinEnergyPrim; >> 360 G4double maxKinEnergy; >> 361 G4double lambdaFactor; >> 362 G4double polarAngleLimit; >> 363 G4double biasFactor; >> 364 >> 365 G4bool integral; >> 366 G4bool applyCuts; >> 367 G4bool startFromNull; >> 368 G4bool splineFlag; 371 369 372 // ======== parameters ========= << 370 // ======== Cashed values - may be state dependent ================ 373 G4double minKinEnergy; << 374 G4double maxKinEnergy; << 375 G4double minKinEnergyPrim = DBL_MAX; << 376 G4double lambdaFactor = 0.8; << 377 G4double invLambdaFactor; << 378 G4double biasFactor = 1.0; << 379 G4double massRatio = 1.0; << 380 G4double fFactor = 1.0; << 381 G4double fLambda = 0.0; << 382 G4double fLambdaEnergy = 0.0; << 383 371 384 protected: 372 protected: 385 373 386 G4double mfpKinEnergy = DBL_MAX; << 374 G4ParticleChangeForGamma fParticleChange; 387 G4double preStepKinEnergy = 0.0; << 388 G4double preStepLambda = 0.0; << 389 375 390 private: 376 private: 391 377 392 G4CrossSectionType fXSType = fEmNoIntegral; << 393 << 394 G4int numberOfModels = 0; << 395 G4int nLambdaBins = 84; << 396 << 397 protected: << 398 << 399 G4int mainSecondaries = 1; << 400 G4int secID = _EM; << 401 G4int fluoID = _Fluorescence; << 402 G4int augerID = _AugerElectron; << 403 G4int biasID = _EM; << 404 G4int tripletID = _TripletElectron; << 405 std::size_t currentCoupleIndex = 0; << 406 std::size_t basedCoupleIndex = 0; << 407 std::size_t coupleIdxLambda = 0; << 408 std::size_t idxLambda = 0; << 409 << 410 G4bool isTheMaster = false; << 411 G4bool baseMat = false; << 412 << 413 private: << 414 << 415 G4bool buildLambdaTable = true; << 416 G4bool applyCuts = false; << 417 G4bool startFromNull = false; << 418 G4bool splineFlag = true; << 419 G4bool actMinKinEnergy = false; << 420 G4bool actMaxKinEnergy = false; << 421 G4bool actBinning = false; << 422 G4bool isIon = false; << 423 G4bool biasFlag = false; << 424 G4bool weightFlag = false; << 425 << 426 protected: << 427 << 428 // ======== particle change ========= << 429 std::vector<G4DynamicParticle*> secParticles 378 std::vector<G4DynamicParticle*> secParticles; 430 G4ParticleChangeForGamma fParticleChange; << 431 379 432 private: << 380 G4VEmModel* currentModel; 433 381 434 // ======== local vectors ========= << 382 const G4ParticleDefinition* particle; 435 std::vector<G4VEmModel*> emModels; << 383 const G4ParticleDefinition* currentParticle; 436 384 >> 385 // cash >> 386 const G4Material* baseMaterial; >> 387 const G4Material* currentMaterial; >> 388 const G4MaterialCutsCouple* currentCouple; >> 389 size_t currentCoupleIndex; >> 390 size_t basedCoupleIndex; >> 391 >> 392 G4double mfpKinEnergy; >> 393 G4double preStepKinEnergy; >> 394 G4double preStepLambda; >> 395 G4double fFactor; >> 396 G4bool biasFlag; >> 397 G4bool weightFlag; >> 398 >> 399 G4int mainSecondaries; >> 400 G4int secID; >> 401 G4int fluoID; >> 402 G4int augerID; >> 403 G4int biasID; 437 }; 404 }; 438 405 439 // ======== Run time inline methods ========== 406 // ======== Run time inline methods ================ 440 407 441 //....oooOO0OOooo........oooOO0OOooo........oo << 408 inline size_t G4VEmProcess::CurrentMaterialCutsCoupleIndex() const 442 << 443 inline std::size_t G4VEmProcess::CurrentMateri << 444 { 409 { 445 return currentCoupleIndex; 410 return currentCoupleIndex; 446 } 411 } 447 412 448 //....oooOO0OOooo........oooOO0OOooo........oo 413 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 449 414 450 inline const G4MaterialCutsCouple* G4VEmProces << 451 { << 452 return currentCouple; << 453 } << 454 << 455 //....oooOO0OOooo........oooOO0OOooo........oo << 456 << 457 inline G4double G4VEmProcess::GetGammaEnergyCu 415 inline G4double G4VEmProcess::GetGammaEnergyCut() 458 { 416 { 459 return (*theCutsGamma)[currentCoupleIndex]; 417 return (*theCutsGamma)[currentCoupleIndex]; 460 } 418 } 461 419 462 //....oooOO0OOooo........oooOO0OOooo........oo 420 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 463 421 464 inline G4double G4VEmProcess::GetElectronEnerg 422 inline G4double G4VEmProcess::GetElectronEnergyCut() 465 { 423 { 466 return (*theCutsElectron)[currentCoupleIndex 424 return (*theCutsElectron)[currentCoupleIndex]; 467 } 425 } 468 426 469 //....oooOO0OOooo........oooOO0OOooo........oo 427 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 470 428 471 inline void G4VEmProcess::DefineMaterial(const 429 inline void G4VEmProcess::DefineMaterial(const G4MaterialCutsCouple* couple) 472 { 430 { 473 if (couple != currentCouple) { << 431 if(couple != currentCouple) { 474 currentCouple = couple; << 432 currentCouple = couple; 475 baseMaterial = currentMaterial = couple->G << 433 currentMaterial = couple->GetMaterial(); 476 basedCoupleIndex = currentCoupleIndex = co << 434 baseMaterial = currentMaterial->GetBaseMaterial(); 477 fFactor = biasFactor; << 435 currentCoupleIndex = couple->GetIndex(); >> 436 basedCoupleIndex = (*theDensityIdx)[currentCoupleIndex]; >> 437 fFactor = biasFactor*(*theDensityFactor)[currentCoupleIndex]; >> 438 if(!baseMaterial) { baseMaterial = currentMaterial; } 478 mfpKinEnergy = DBL_MAX; 439 mfpKinEnergy = DBL_MAX; 479 if (baseMat) { << 440 idxLambda = idxLambdaPrim = 0; 480 basedCoupleIndex = (*theDensityIdx)[curr << 481 if (nullptr != currentMaterial->GetBaseM << 482 baseMaterial = currentMaterial->GetBas << 483 fFactor *= (*theDensityFactor)[currentCo << 484 } << 485 } 441 } 486 } 442 } 487 443 488 //....oooOO0OOooo........oooOO0OOooo........oo 444 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 489 445 490 inline 446 inline 491 G4VEmModel* G4VEmProcess::SelectModel(G4double << 447 G4VEmModel* G4VEmProcess::SelectModel(G4double& kinEnergy, size_t index) 492 { 448 { 493 if(1 < numberOfModels) { 449 if(1 < numberOfModels) { 494 currentModel = modelManager->SelectModel(k << 450 currentModel = modelManager->SelectModel(kinEnergy, index); 495 } 451 } 496 currentModel->SetCurrentCouple(currentCouple 452 currentModel->SetCurrentCouple(currentCouple); 497 return currentModel; 453 return currentModel; 498 } 454 } 499 455 500 //....oooOO0OOooo........oooOO0OOooo........oo 456 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 501 457 502 inline 458 inline 503 G4VEmModel* G4VEmProcess::SelectModelForMateri 459 G4VEmModel* G4VEmProcess::SelectModelForMaterial(G4double kinEnergy, 504 << 460 size_t& idxRegion) const 505 { 461 { 506 return modelManager->SelectModel(kinEnergy, << 462 return modelManager->SelectModel(kinEnergy, idxRegion); 507 } 463 } 508 464 509 //....oooOO0OOooo........oooOO0OOooo........oo 465 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 510 466 511 inline G4double G4VEmProcess::GetLambdaFromTab 467 inline G4double G4VEmProcess::GetLambdaFromTable(G4double e) 512 { 468 { 513 return ((*theLambdaTable)[basedCoupleIndex]) 469 return ((*theLambdaTable)[basedCoupleIndex])->Value(e, idxLambda); 514 } 470 } 515 471 516 //....oooOO0OOooo........oooOO0OOooo........oo 472 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 517 473 518 inline G4double G4VEmProcess::LogEkin(const G4 << 519 { << 520 return track.GetDynamicParticle()->GetLogKin << 521 } << 522 << 523 //....oooOO0OOooo........oooOO0OOooo........oo << 524 << 525 inline G4double G4VEmProcess::GetLambdaFromTab << 526 { << 527 return ((*theLambdaTable)[basedCoupleIndex]) << 528 } << 529 << 530 //....oooOO0OOooo........oooOO0OOooo........oo << 531 << 532 inline G4double G4VEmProcess::GetLambdaFromTab 474 inline G4double G4VEmProcess::GetLambdaFromTablePrim(G4double e) 533 { 475 { 534 return ((*theLambdaTablePrim)[basedCoupleInd << 476 return ((*theLambdaTablePrim)[basedCoupleIndex])->Value(e, idxLambdaPrim)/e; 535 } << 536 << 537 //....oooOO0OOooo........oooOO0OOooo........oo << 538 << 539 inline G4double G4VEmProcess::GetLambdaFromTab << 540 { << 541 return ((*theLambdaTablePrim)[basedCoupleInd << 542 } 477 } 543 478 544 //....oooOO0OOooo........oooOO0OOooo........oo 479 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 545 480 546 inline G4double G4VEmProcess::ComputeCurrentLa 481 inline G4double G4VEmProcess::ComputeCurrentLambda(G4double e) 547 { 482 { 548 return currentModel->CrossSectionPerVolume(b << 483 return currentModel->CrossSectionPerVolume(baseMaterial,currentParticle, >> 484 e,(*theCuts)[currentCoupleIndex]); 549 } 485 } 550 486 551 //....oooOO0OOooo........oooOO0OOooo........oo 487 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 552 488 553 inline G4double G4VEmProcess::GetCurrentLambda 489 inline G4double G4VEmProcess::GetCurrentLambda(G4double e) 554 { 490 { 555 if(currentCoupleIndex != coupleIdxLambda || << 491 G4double x; 556 coupleIdxLambda = currentCoupleIndex; << 492 if(e >= minKinEnergyPrim) { x = GetLambdaFromTablePrim(e); } 557 fLambdaEnergy = e; << 493 else if(theLambdaTable) { x = GetLambdaFromTable(e); } 558 if(e >= minKinEnergyPrim) { fLambda = GetL << 494 else { x = ComputeCurrentLambda(e); } 559 else if(nullptr != theLambdaTable) { fLamb << 495 return fFactor*x; 560 else { fLambda = ComputeCurrentLambda(e); << 561 fLambda *= fFactor; << 562 } << 563 return fLambda; << 564 } << 565 << 566 //....oooOO0OOooo........oooOO0OOooo........oo << 567 << 568 inline G4double G4VEmProcess::GetCurrentLambda << 569 { << 570 if(currentCoupleIndex != coupleIdxLambda || << 571 coupleIdxLambda = currentCoupleIndex; << 572 fLambdaEnergy = e; << 573 if(e >= minKinEnergyPrim) { fLambda = GetL << 574 else if(nullptr != theLambdaTable) { fLamb << 575 else { fLambda = ComputeCurrentLambda(e); << 576 fLambda *= fFactor; << 577 } << 578 return fLambda; << 579 } 496 } 580 497 581 //....oooOO0OOooo........oooOO0OOooo........oo 498 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 582 499 583 inline void << 500 inline G4double 584 G4VEmProcess::CurrentSetup(const G4MaterialCut << 501 G4VEmProcess::GetLambda(G4double& kinEnergy, >> 502 const G4MaterialCutsCouple* couple) 585 { 503 { 586 DefineMaterial(couple); 504 DefineMaterial(couple); 587 SelectModel(energy*massRatio, currentCoupleI << 505 SelectModel(kinEnergy, currentCoupleIndex); >> 506 return GetCurrentLambda(kinEnergy); 588 } 507 } 589 508 590 //....oooOO0OOooo........oooOO0OOooo........oo 509 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 591 510 592 inline G4double 511 inline G4double 593 G4VEmProcess::GetLambda(G4double kinEnergy, co << 512 G4VEmProcess::RecalculateLambda(G4double e, const G4MaterialCutsCouple* couple) 594 G4double logKinEnergy) << 595 { 513 { 596 CurrentSetup(couple, kinEnergy); << 514 DefineMaterial(couple); 597 return GetCurrentLambda(kinEnergy, logKinEne << 515 SelectModel(e, currentCoupleIndex); >> 516 return fFactor*ComputeCurrentLambda(e); 598 } 517 } 599 518 600 //....oooOO0OOooo........oooOO0OOooo........oo 519 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 601 520 602 G4double G4VEmProcess::MeanFreePath(const G4Tr << 521 inline void G4VEmProcess::ComputeIntegralLambda(G4double e) 603 { 522 { 604 const G4double kinEnergy = track.GetKineticE << 523 mfpKinEnergy = theEnergyOfCrossSectionMax[currentCoupleIndex]; 605 CurrentSetup(track.GetMaterialCutsCouple(), << 524 if (e <= mfpKinEnergy) { 606 const G4double xs = GetCurrentLambda(kinEner << 525 preStepLambda = GetCurrentLambda(e); 607 track.GetDynamicP << 526 608 return (0.0 < xs) ? 1.0/xs : DBL_MAX; << 527 } else { >> 528 G4double e1 = e*lambdaFactor; >> 529 if(e1 > mfpKinEnergy) { >> 530 preStepLambda = GetCurrentLambda(e); >> 531 G4double preStepLambda1 = GetCurrentLambda(e1); >> 532 if(preStepLambda1 > preStepLambda) { >> 533 mfpKinEnergy = e1; >> 534 preStepLambda = preStepLambda1; >> 535 } >> 536 } else { >> 537 preStepLambda = fFactor*theCrossSectionMax[currentCoupleIndex]; >> 538 } >> 539 } 609 } 540 } 610 541 611 // ======== Get/Set inline methods used at ini 542 // ======== Get/Set inline methods used at initialisation ================ 612 543 613 inline G4bool G4VEmProcess::ApplyCuts() const << 544 inline void G4VEmProcess::SetLambdaBinning(G4int nbins) 614 { 545 { 615 return applyCuts; << 546 nLambdaBins = nbins; 616 } 547 } 617 548 618 //....oooOO0OOooo........oooOO0OOooo........oo 549 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 619 550 620 inline G4int G4VEmProcess::LambdaBinning() con 551 inline G4int G4VEmProcess::LambdaBinning() const 621 { 552 { 622 return nLambdaBins; 553 return nLambdaBins; 623 } 554 } 624 555 625 //....oooOO0OOooo........oooOO0OOooo........oo 556 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 626 557 627 inline G4double G4VEmProcess::MinKinEnergy() c 558 inline G4double G4VEmProcess::MinKinEnergy() const 628 { 559 { 629 return minKinEnergy; 560 return minKinEnergy; 630 } 561 } 631 562 632 //....oooOO0OOooo........oooOO0OOooo........oo 563 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 633 564 634 inline G4double G4VEmProcess::MaxKinEnergy() c 565 inline G4double G4VEmProcess::MaxKinEnergy() const 635 { 566 { 636 return maxKinEnergy; 567 return maxKinEnergy; 637 } 568 } 638 569 639 //....oooOO0OOooo........oooOO0OOooo........oo 570 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 640 571 641 inline G4double G4VEmProcess::CrossSectionBias << 572 inline void G4VEmProcess::SetMinKinEnergyPrim(G4double e) 642 { 573 { 643 return biasFactor; << 574 minKinEnergyPrim = e; 644 } 575 } 645 576 646 //....oooOO0OOooo........oooOO0OOooo........oo 577 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 647 578 648 inline G4PhysicsTable* G4VEmProcess::LambdaTab << 579 inline void G4VEmProcess::SetPolarAngleLimit(G4double val) 649 { 580 { 650 return theLambdaTable; << 581 if(val < 0.0) { polarAngleLimit = 0.0; } >> 582 else if(val > CLHEP::pi) { polarAngleLimit = CLHEP::pi; } >> 583 else { polarAngleLimit = val; } 651 } 584 } 652 585 653 //....oooOO0OOooo........oooOO0OOooo........oo 586 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 654 587 655 inline G4PhysicsTable* G4VEmProcess::LambdaTab << 588 inline G4double G4VEmProcess::PolarAngleLimit() const 656 { 589 { 657 return theLambdaTablePrim; << 590 return polarAngleLimit; 658 } 591 } 659 592 660 //....oooOO0OOooo........oooOO0OOooo........oo 593 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 661 594 662 inline void G4VEmProcess::SetLambdaTable(G4Phy << 595 inline G4double G4VEmProcess::CrossSectionBiasingFactor() const 663 { 596 { 664 theLambdaTable = ptr; << 597 return biasFactor; 665 } 598 } 666 599 667 //....oooOO0OOooo........oooOO0OOooo........oo 600 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 668 601 669 inline void G4VEmProcess::SetLambdaTablePrim(G << 602 inline G4PhysicsTable* G4VEmProcess::LambdaTable() const 670 { 603 { 671 theLambdaTablePrim = ptr; << 604 return theLambdaTable; 672 } 605 } 673 606 674 //....oooOO0OOooo........oooOO0OOooo........oo 607 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 675 608 676 inline std::vector<G4double>* G4VEmProcess::En << 609 inline G4PhysicsTable* G4VEmProcess::LambdaTablePrim() const 677 { 610 { 678 return theEnergyOfCrossSectionMax; << 611 return theLambdaTablePrim; 679 } 612 } 680 613 681 //....oooOO0OOooo........oooOO0OOooo........oo 614 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 682 615 683 inline void << 616 inline const G4ParticleDefinition* G4VEmProcess::Particle() const 684 G4VEmProcess::SetEnergyOfCrossSectionMax(std:: << 685 { 617 { 686 theEnergyOfCrossSectionMax = ptr; << 618 return particle; 687 } 619 } 688 620 689 //....oooOO0OOooo........oooOO0OOooo........oo 621 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 690 622 691 inline const G4ParticleDefinition* G4VEmProces << 623 inline const G4ParticleDefinition* G4VEmProcess::SecondaryParticle() const 692 { 624 { 693 return particle; << 625 return secondaryParticle; 694 } 626 } 695 627 696 //....oooOO0OOooo........oooOO0OOooo........oo 628 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 697 629 698 inline const G4ParticleDefinition* G4VEmProces << 630 inline void G4VEmProcess::SetLambdaFactor(G4double val) 699 { 631 { 700 return secondaryParticle; << 632 if(val > 0.0 && val <= 1.0) { lambdaFactor = val; } >> 633 } >> 634 >> 635 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... >> 636 >> 637 inline void G4VEmProcess::SetIntegral(G4bool val) >> 638 { >> 639 if(particle && particle != theGamma) { integral = val; } 701 } 640 } 702 641 703 //....oooOO0OOooo........oooOO0OOooo........oo 642 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 704 643 705 inline void G4VEmProcess::SetCrossSectionType( << 644 inline G4bool G4VEmProcess::IsIntegral() const 706 { 645 { 707 fXSType = val; << 646 return integral; 708 } 647 } 709 648 710 //....oooOO0OOooo........oooOO0OOooo........oo 649 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 711 650 712 inline G4CrossSectionType G4VEmProcess::CrossS << 651 inline void G4VEmProcess::SetApplyCuts(G4bool val) 713 { 652 { 714 return fXSType; << 653 applyCuts = val; 715 } 654 } 716 655 717 //....oooOO0OOooo........oooOO0OOooo........oo 656 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 718 657 719 inline void G4VEmProcess::SetBuildTableFlag(G4 658 inline void G4VEmProcess::SetBuildTableFlag(G4bool val) 720 { 659 { 721 buildLambdaTable = val; 660 buildLambdaTable = val; 722 } 661 } 723 662 724 //....oooOO0OOooo........oooOO0OOooo........oo 663 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 725 664 726 inline G4ParticleChangeForGamma* G4VEmProcess: 665 inline G4ParticleChangeForGamma* G4VEmProcess::GetParticleChange() 727 { 666 { 728 return &fParticleChange; 667 return &fParticleChange; 729 } 668 } 730 669 731 //....oooOO0OOooo........oooOO0OOooo........oo 670 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 732 671 733 inline void G4VEmProcess::SetParticle(const G4 672 inline void G4VEmProcess::SetParticle(const G4ParticleDefinition* p) 734 { 673 { 735 particle = p; 674 particle = p; 736 currentParticle = p; 675 currentParticle = p; 737 } 676 } 738 677 739 //....oooOO0OOooo........oooOO0OOooo........oo 678 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 740 679 741 inline void G4VEmProcess::SetSecondaryParticle 680 inline void G4VEmProcess::SetSecondaryParticle(const G4ParticleDefinition* p) 742 { 681 { 743 secondaryParticle = p; 682 secondaryParticle = p; 744 } 683 } 745 684 746 //....oooOO0OOooo........oooOO0OOooo........oo 685 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 747 686 748 inline void G4VEmProcess::SetStartFromNullFlag 687 inline void G4VEmProcess::SetStartFromNullFlag(G4bool val) 749 { 688 { 750 startFromNull = val; 689 startFromNull = val; 751 } 690 } 752 691 753 //....oooOO0OOooo........oooOO0OOooo........oo 692 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 754 693 755 inline void G4VEmProcess::SetSplineFlag(G4bool 694 inline void G4VEmProcess::SetSplineFlag(G4bool val) 756 { 695 { 757 splineFlag = val; 696 splineFlag = val; 758 } << 759 << 760 //....oooOO0OOooo........oooOO0OOooo........oo << 761 << 762 inline G4int G4VEmProcess::DensityIndex(G4int << 763 { << 764 return (*theDensityIdx)[idx]; << 765 } << 766 << 767 //....oooOO0OOooo........oooOO0OOooo........oo << 768 << 769 inline G4double G4VEmProcess::DensityFactor(G4 << 770 { << 771 return (*theDensityFactor)[idx]; << 772 } << 773 << 774 //....oooOO0OOooo........oooOO0OOooo........oo << 775 << 776 inline G4bool G4VEmProcess::UseBaseMaterial() << 777 { << 778 return baseMat; << 779 } << 780 << 781 //....oooOO0OOooo........oooOO0OOooo........oo << 782 << 783 inline const G4VEmModel* G4VEmProcess::GetCurr << 784 { << 785 return currentModel; << 786 } << 787 << 788 //....oooOO0OOooo........oooOO0OOooo........oo << 789 << 790 inline void G4VEmProcess::SetEmMasterProcess(c << 791 { << 792 masterProc = ptr; << 793 } << 794 << 795 //....oooOO0OOooo........oooOO0OOooo........oo << 796 << 797 inline G4int G4VEmProcess::NumberOfModels() co << 798 { << 799 return numberOfModels; << 800 } << 801 << 802 //....oooOO0OOooo........oooOO0OOooo........oo << 803 << 804 inline G4VEmModel* G4VEmProcess::EmModel(std:: << 805 { << 806 return (index < emModels.size()) ? emModels[ << 807 } << 808 << 809 //....oooOO0OOooo........oooOO0OOooo........oo << 810 << 811 inline G4VEmModel* G4VEmProcess::GetModelByInd << 812 { << 813 return modelManager->GetModel(idx, ver); << 814 } 697 } 815 698 816 //....oooOO0OOooo........oooOO0OOooo........oo 699 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... 817 700 818 #endif 701 #endif 819 702