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 ////////////////////////////////////////////// << 26 // $Id: G4VEmAdjointModel.hh,v 1.5 2010-11-11 11:51:56 ldesorgh Exp $ 27 // Class: G4VEMAdjointModel << 27 // GEANT4 tag $Name: geant4-09-04-patch-01 $ 28 // Author: L. Desorgher << 28 // 29 // Organisation: SpaceIT GmbH << 29 ///////////////////////////////////////////////////////////////////////////////// >> 30 // Module: G4VEMAdjointModel >> 31 // Author: L. Desorgher >> 32 // Organisation: SpaceIT GmbH >> 33 // Contract: ESA contract 21435/08/NL/AT >> 34 // Customer: ESA/ESTEC >> 35 ///////////////////////////////////////////////////////////////////////////////// >> 36 // >> 37 // CHANGE HISTORY >> 38 // -------------- >> 39 // ChangeHistory: >> 40 // 10 September 2009 Move to a virtual class. L. Desorgher >> 41 // 1st April 2007 creation by L. Desorgher >> 42 // >> 43 //------------------------------------------------------------- >> 44 // Documentation: >> 45 // Base class for Adjoint EM model. It is based on the use of direct G4VEmModel. 30 // 46 // 31 // Base class for Adjoint EM model. It is bas << 47 32 // G4VEmModel. << 33 ////////////////////////////////////////////// << 34 48 35 #ifndef G4VEmAdjointModel_h 49 #ifndef G4VEmAdjointModel_h 36 #define G4VEmAdjointModel_h 1 50 #define G4VEmAdjointModel_h 1 37 51 38 #include "globals.hh" 52 #include "globals.hh" >> 53 #include "G4DynamicParticle.hh" >> 54 #include "G4ParticleDefinition.hh" >> 55 #include "G4MaterialCutsCouple.hh" >> 56 #include "G4Material.hh" >> 57 #include "G4Element.hh" >> 58 #include "G4ElementVector.hh" >> 59 #include "Randomize.hh" 39 #include "G4ParticleDefinition.hh" 60 #include "G4ParticleDefinition.hh" 40 #include "G4VEmModel.hh" 61 #include "G4VEmModel.hh" >> 62 #include "G4Electron.hh" >> 63 #include "G4Gamma.hh" >> 64 #include "G4ProductionCutsTable.hh" 41 65 42 class G4AdjointCSMatrix; << 66 class G4PhysicsTable; 43 class G4AdjointCSManager; << 44 class G4Material; << 45 class G4MaterialCutsCouple; << 46 class G4ParticleChange; << 47 class G4Region; 67 class G4Region; >> 68 class G4VParticleChange; >> 69 class G4ParticleChange; 48 class G4Track; 70 class G4Track; >> 71 class G4AdjointCSMatrix; 49 72 50 class G4VEmAdjointModel 73 class G4VEmAdjointModel 51 { 74 { 52 public: << 75 53 explicit G4VEmAdjointModel(const G4String& n << 76 public: // public methods >> 77 >> 78 G4VEmAdjointModel(const G4String& nam); 54 79 55 virtual ~G4VEmAdjointModel(); 80 virtual ~G4VEmAdjointModel(); 56 81 57 //------------------------------------------ 82 //------------------------------------------------------------------------ 58 // Virtual methods to be implemented for the 83 // Virtual methods to be implemented for the sample secondaries concrete model 59 //------------------------------------------ 84 //------------------------------------------------------------------------ 60 << 85 61 virtual void SampleSecondaries(const G4Track << 86 //virtual void Initialise()=0; 62 G4ParticleCha << 87 >> 88 virtual void SampleSecondaries(const G4Track& aTrack, >> 89 G4bool IsScatProjToProjCase, >> 90 G4ParticleChange* fParticleChange)=0; >> 91 63 92 64 //------------------------------------------ 93 //------------------------------------------------------------------------ 65 // Methods for adjoint processes << 94 // Methods for adjoint processes; may be overwritten if needed; 66 //------------------------------------------ 95 //------------------------------------------------------------------------ >> 96 67 97 68 virtual G4double AdjointCrossSection(const G 98 virtual G4double AdjointCrossSection(const G4MaterialCutsCouple* aCouple, 69 G4doubl << 99 G4double primEnergy, 70 G4bool << 100 G4bool IsScatProjToProjCase); 71 << 101 72 // The implementation of the DiffCrossSectio << 102 virtual G4double GetAdjointCrossSection(const G4MaterialCutsCouple* aCouple, 73 // energy loss process. For the photoelectri << 103 G4double primEnergy, 74 // the method should be redefined << 104 G4bool IsScatProjToProjCase); >> 105 75 virtual G4double DiffCrossSectionPerAtomPrim 106 virtual G4double DiffCrossSectionPerAtomPrimToSecond( 76 G4double kinEnergyProj, // kin energy of << 107 G4double kinEnergyProj, // kinetic energy of the primary particle before the interaction 77 G4double kinEnergyProd, // kinetic energy << 108 G4double kinEnergyProd, // kinetic energy of the secondary particle 78 G4double Z, G4double A = 0.); << 109 G4double Z, 79 << 110 G4double A = 0.); 80 virtual G4double DiffCrossSectionPerAtomPrim << 111 81 G4double kinEnergyProj, // kin energy << 112 virtual G4double DiffCrossSectionPerAtomPrimToScatPrim( 82 G4double kinEnergyScatProj, // kin energy << 113 G4double kinEnergyProj, // kinetic energy of the primary particle before the interaction 83 G4double Z, G4double A = 0.); << 114 G4double kinEnergyScatProj, // kinetic energy of the primary particle after the interaction 84 << 115 G4double Z, >> 116 G4double A = 0.); >> 117 >> 118 >> 119 85 virtual G4double DiffCrossSectionPerVolumePr 120 virtual G4double DiffCrossSectionPerVolumePrimToSecond( 86 const G4Material* aMaterial, << 121 const G4Material* aMaterial, 87 G4double kinEnergyProj, // kin energy of << 122 G4double kinEnergyProj, // kinetic energy of the primary particle before the interaction 88 G4double kinEnergyProd // kinetic energy << 123 G4double kinEnergyProd // kinetic energy of the secondary particle 89 ); << 124 ); 90 << 125 91 virtual G4double DiffCrossSectionPerVolumePr 126 virtual G4double DiffCrossSectionPerVolumePrimToScatPrim( 92 const G4Material* aMaterial, << 127 const G4Material* aMaterial, 93 G4double kinEnergyProj, // kin energy << 128 G4double kinEnergyProj, // kinetic energy of the primary particle before the interaction 94 G4double kinEnergyScatProj // kinetic ene << 129 G4double kinEnergyScatProj // kinetic energy of the primary particle after the interaction 95 ); << 130 ); 96 << 131 97 // Energy limits of adjoint secondary << 132 >> 133 //Energy limits of adjoint secondary 98 //------------------ 134 //------------------ 99 << 135 100 virtual G4double GetSecondAdjEnergyMaxForSca << 136 virtual G4double GetSecondAdjEnergyMaxForScatProjToProjCase(G4double PrimAdjEnergy); 101 G4double primAdjEnergy); << 137 virtual G4double GetSecondAdjEnergyMinForScatProjToProjCase(G4double PrimAdjEnergy,G4double Tcut=0); 102 << 138 virtual G4double GetSecondAdjEnergyMaxForProdToProjCase(G4double PrimAdjEnergy); 103 virtual G4double GetSecondAdjEnergyMinForSca << 139 virtual G4double GetSecondAdjEnergyMinForProdToProjCase(G4double PrimAdjEnergy); 104 G4double primAdjEnergy, G4double tcut = 0. << 140 105 << 141 106 virtual G4double GetSecondAdjEnergyMaxForPro << 142 107 << 143 //Other Methods 108 virtual G4double GetSecondAdjEnergyMinForPro << 109 << 110 // Other Methods << 111 //--------------- 144 //--------------- 112 << 145 113 void DefineCurrentMaterial(const G4MaterialC << 146 void DefineCurrentMaterial(const G4MaterialCutsCouple* couple); 114 << 147 115 std::vector<std::vector<double>*> << 148 116 ComputeAdjointCrossSectionVectorPerAtomForSe << 149 std::vector< std::vector< double>* > ComputeAdjointCrossSectionVectorPerAtomForSecond( 117 << 150 G4double kinEnergyProd, 118 << 151 G4double Z, 119 << 152 G4double A = 0., 120 std::vector<std::vector<double>*> << 153 G4int nbin_pro_decade=10 121 ComputeAdjointCrossSectionVectorPerAtomForSc << 154 ); 122 G4double kinEnergyProd, G4double Z, G4doub << 155 std::vector< std::vector< double>* > ComputeAdjointCrossSectionVectorPerAtomForScatProj( 123 G4int nbin_pro_decade = 10); << 156 G4double kinEnergyProd, 124 << 157 G4double Z, 125 std::vector<std::vector<double>*> << 158 G4double A = 0., 126 ComputeAdjointCrossSectionVectorPerVolumeFor << 159 G4int nbin_pro_decade=10 127 G4Material* aMaterial, G4double kinEnergyP << 160 ); 128 << 161 129 std::vector<std::vector<double>*> << 162 std::vector< std::vector< double>* > ComputeAdjointCrossSectionVectorPerVolumeForSecond( 130 ComputeAdjointCrossSectionVectorPerVolumeFor << 163 G4Material* aMaterial, 131 G4Material* aMaterial, G4double kinEnergyP << 164 G4double kinEnergyProd, 132 << 165 G4int nbin_pro_decade=10 133 inline void SetCSMatrices(std::vector<G4Adjo << 166 ); 134 std::vector<G4Adjo << 167 std::vector< std::vector< double>* > ComputeAdjointCrossSectionVectorPerVolumeForScatProj( 135 { << 168 G4Material* aMaterial, 136 fCSMatrixProdToProjBackScat = Vec1CSMatrix << 169 G4double kinEnergyProd, 137 fCSMatrixProjToProjBackScat = Vec2CSMatrix << 170 G4int nbin_pro_decade=10 >> 171 ); >> 172 >> 173 >> 174 >> 175 inline void SetCSMatrices(std::vector< G4AdjointCSMatrix* >* Vec1CSMatrix, std::vector< G4AdjointCSMatrix* >* Vec2CSMatrix){ >> 176 pOnCSMatrixForProdToProjBackwardScattering = Vec1CSMatrix; >> 177 pOnCSMatrixForScatProjToProjBackwardScattering = Vec2CSMatrix; >> 178 >> 179 138 }; 180 }; 139 << 181 140 inline G4ParticleDefinition* << 182 inline G4ParticleDefinition* GetAdjointEquivalentOfDirectPrimaryParticleDefinition(){return theAdjEquivOfDirectPrimPartDef;} 141 GetAdjointEquivalentOfDirectPrimaryParticleD << 183 142 { << 184 inline G4ParticleDefinition* GetAdjointEquivalentOfDirectSecondaryParticleDefinition(){return theAdjEquivOfDirectSecondPartDef;} 143 return fAdjEquivDirectPrimPart; << 185 144 } << 186 inline G4double GetHighEnergyLimit(){return HighEnergyLimit;} 145 << 187 146 inline G4ParticleDefinition* << 188 inline G4double GetLowEnergyLimit(){return LowEnergyLimit;} 147 GetAdjointEquivalentOfDirectSecondaryParticl << 189 148 { << 149 return fAdjEquivDirectSecondPart; << 150 } << 151 << 152 inline G4double GetHighEnergyLimit() const { << 153 << 154 inline G4double GetLowEnergyLimit() const { << 155 << 156 void SetHighEnergyLimit(G4double aVal); 190 void SetHighEnergyLimit(G4double aVal); 157 << 191 158 void SetLowEnergyLimit(G4double aVal); 192 void SetLowEnergyLimit(G4double aVal); 159 << 193 160 inline void DefineDirectEMModel(G4VEmModel* << 194 inline void DefineDirectEMModel(G4VEmModel* aModel){theDirectEMModel = aModel;} 161 << 195 162 void SetAdjointEquivalentOfDirectPrimaryPart << 196 void SetAdjointEquivalentOfDirectPrimaryParticleDefinition(G4ParticleDefinition* aPart); 163 G4ParticleDefinition* aPart); << 197 164 << 198 inline void SetAdjointEquivalentOfDirectSecondaryParticleDefinition(G4ParticleDefinition* aPart){ 165 inline void SetAdjointEquivalentOfDirectSeco << 199 theAdjEquivOfDirectSecondPartDef =aPart; 166 G4ParticleDefinition* aPart) << 167 { << 168 fAdjEquivDirectSecondPart = aPart; << 169 } << 170 << 171 inline void SetSecondPartOfSameType(G4bool a << 172 { << 173 fSecondPartSameType = aBool; << 174 } << 175 << 176 inline G4bool GetSecondPartOfSameType() cons << 177 << 178 inline void SetUseMatrix(G4bool aBool) { fUs << 179 << 180 inline void SetUseMatrixPerElement(G4bool aB << 181 { << 182 fUseMatrixPerElement = aBool; << 183 } << 184 << 185 inline void SetUseOnlyOneMatrixForAllElement << 186 { << 187 fOneMatrixForAllElements = aBool; << 188 } 200 } 189 << 201 190 inline void SetApplyCutInRange(G4bool aBool) << 202 inline void SetSecondPartOfSameType(G4bool aBool){second_part_of_same_type =aBool;} 191 << 203 192 inline G4bool GetUseMatrix() const { return << 204 inline G4bool GetSecondPartOfSameType(){return second_part_of_same_type;} 193 << 205 194 inline G4bool GetUseMatrixPerElement() const << 206 inline void SetUseMatrix(G4bool aBool) { UseMatrix = aBool;} 195 << 207 196 inline G4bool GetUseOnlyOneMatrixForAllEleme << 208 inline void SetUseMatrixPerElement(G4bool aBool){ UseMatrixPerElement = aBool;} 197 { << 209 inline void SetUseOnlyOneMatrixForAllElements(G4bool aBool){ UseOnlyOneMatrixForAllElements = aBool;} 198 return fOneMatrixForAllElements; << 210 199 } << 211 inline void SetApplyCutInRange(G4bool aBool){ ApplyCutInRange = aBool;} 200 << 212 inline G4bool GetUseMatrix() {return UseMatrix;} 201 inline G4bool GetApplyCutInRange() const { r << 213 inline G4bool GetUseMatrixPerElement(){ return UseMatrixPerElement;} 202 << 214 inline G4bool GetUseOnlyOneMatrixForAllElements(){ return UseOnlyOneMatrixForAllElements;} 203 inline const G4String& GetName() const { ret << 215 inline G4bool GetApplyCutInRange(){ return ApplyCutInRange;} 204 << 216 205 inline virtual void SetCSBiasingFactor(G4dou << 217 inline G4String GetName(){ return name;} 206 { << 218 inline virtual void SetCSBiasingFactor(G4double aVal) {CS_biasing_factor = aVal;} 207 fCsBiasingFactor = aVal; << 219 208 } << 220 protected: 209 << 221 210 inline void SetCorrectWeightForPostStepInMod << 222 //Some of them can be overriden by daughter classes 211 { << 223 212 fInModelWeightCorr = aBool; << 224 213 } << 214 << 215 inline void SetAdditionalWeightCorrectionFac << 216 G4double factor) << 217 { << 218 fOutsideWeightFactor = factor; << 219 } << 220 << 221 G4VEmAdjointModel(G4VEmAdjointModel&) = dele << 222 G4VEmAdjointModel& operator=(const G4VEmAdjo << 223 << 224 protected: << 225 G4double DiffCrossSectionFunction1(G4double 225 G4double DiffCrossSectionFunction1(G4double kinEnergyProj); 226 << 227 G4double DiffCrossSectionFunction2(G4double 226 G4double DiffCrossSectionFunction2(G4double kinEnergyProj); >> 227 G4double DiffCrossSectionPerVolumeFunctionForIntegrationOverEkinProj(G4double EkinProd); >> 228 >> 229 >> 230 >> 231 //General methods to sample secondary energy >> 232 //-------------------------------------- >> 233 G4double SampleAdjSecEnergyFromCSMatrix(size_t MatrixIndex,G4double prim_energy,G4bool IsScatProjToProjCase); >> 234 G4double SampleAdjSecEnergyFromCSMatrix(G4double prim_energy,G4bool IsScatProjToProjCase); >> 235 void SelectCSMatrix(G4bool IsScatProjToProjCase); >> 236 >> 237 virtual G4double SampleAdjSecEnergyFromDiffCrossSectionPerAtom(G4double prim_energy,G4bool IsScatProjToProjCase); >> 238 >> 239 >> 240 >> 241 //Post Step weight correction >> 242 //---------------------------- >> 243 virtual void CorrectPostStepWeight(G4ParticleChange* fParticleChange, >> 244 G4double old_weight, >> 245 G4double adjointPrimKinEnergy, >> 246 G4double projectileKinEnergy, >> 247 G4bool IsScatProjToProjCase); >> 248 >> 249 >> 250 >> 251 >> 252 >> 253 >> 254 protected: //attributes >> 255 >> 256 G4VEmModel* theDirectEMModel; >> 257 G4VParticleChange* pParticleChange; >> 258 >> 259 >> 260 >> 261 >> 262 //Name >> 263 //----- >> 264 >> 265 const G4String name; >> 266 >> 267 //Needed for CS integration at the initialisation phase >> 268 //----------------------------------------------------- >> 269 >> 270 G4int ASelectedNucleus; >> 271 G4int ZSelectedNucleus; >> 272 G4Material* SelectedMaterial; >> 273 G4double kinEnergyProdForIntegration; >> 274 G4double kinEnergyScatProjForIntegration; >> 275 G4double kinEnergyProjForIntegration; >> 276 >> 277 >> 278 //for the adjoint simulation we need for each element or material: >> 279 //an adjoint CS Matrix >> 280 //----------------------------- >> 281 >> 282 std::vector< G4AdjointCSMatrix* >* pOnCSMatrixForProdToProjBackwardScattering; >> 283 std::vector< G4AdjointCSMatrix* >* pOnCSMatrixForScatProjToProjBackwardScattering; >> 284 std::vector<G4double> CS_Vs_ElementForScatProjToProjCase; >> 285 std::vector<G4double> CS_Vs_ElementForProdToProjCase; >> 286 >> 287 G4double lastCS; >> 288 G4double lastAdjointCSForScatProjToProjCase; >> 289 G4double lastAdjointCSForProdToProjCase; >> 290 >> 291 >> 292 >> 293 >> 294 //particle definition >> 295 //------------------ >> 296 >> 297 G4ParticleDefinition* theAdjEquivOfDirectPrimPartDef; >> 298 G4ParticleDefinition* theAdjEquivOfDirectSecondPartDef; >> 299 G4ParticleDefinition* theDirectPrimaryPartDef; >> 300 G4bool second_part_of_same_type; >> 301 >> 302 >> 303 //Prestep energy >> 304 //------------- >> 305 G4double preStepEnergy; >> 306 >> 307 //Current couple material >> 308 //---------------------- >> 309 G4Material* currentMaterial; >> 310 G4MaterialCutsCouple* currentCouple; >> 311 size_t currentMaterialIndex; >> 312 size_t currentCoupleIndex; >> 313 G4double currentTcutForDirectPrim; >> 314 G4double currentTcutForDirectSecond; >> 315 G4bool ApplyCutInRange; >> 316 >> 317 >> 318 >> 319 >> 320 //For ions >> 321 //--------- >> 322 G4double mass_ratio_product; >> 323 G4double mass_ratio_projectile; >> 324 >> 325 >> 326 //Energy limits >> 327 //------------- >> 328 >> 329 G4double HighEnergyLimit; >> 330 G4double LowEnergyLimit; >> 331 >> 332 >> 333 >> 334 //Cross Section biasing factor >> 335 //--------------------------- >> 336 G4double CS_biasing_factor; >> 337 >> 338 >> 339 //Type of Model with Matrix or not >> 340 //-------------------------------- >> 341 G4bool UseMatrix; >> 342 G4bool UseMatrixPerElement; //other possibility is per Material >> 343 G4bool UseOnlyOneMatrixForAllElements; >> 344 >> 345 >> 346 //Index of Cross section matrices to be used >> 347 //------------ >> 348 size_t indexOfUsedCrossSectionMatrix; >> 349 >> 350 size_t model_index; >> 351 >> 352 >> 353 >> 354 >> 355 >> 356 228 357 229 // General methods to sample secondary energ << 358 230 G4double SampleAdjSecEnergyFromCSMatrix(std: << 231 G4do << 232 G4bo << 233 << 234 G4double SampleAdjSecEnergyFromCSMatrix(G4do << 235 G4bo << 236 << 237 void SelectCSMatrix(G4bool isScatProjToProj) << 238 << 239 virtual G4double SampleAdjSecEnergyFromDiffC << 240 G4double prim_energy, G4bool isScatProjToP << 241 << 242 // Post Step weight correction << 243 virtual void CorrectPostStepWeight(G4Particl << 244 G4double << 245 G4double << 246 G4double << 247 G4bool is << 248 << 249 G4AdjointCSManager* fCSManager; << 250 G4VEmModel* fDirectModel = nullptr; << 251 << 252 const G4String fName; << 253 << 254 G4Material* fSelectedMaterial = nullp << 255 G4Material* fCurrentMaterial = nullp << 256 G4MaterialCutsCouple* fCurrentCouple = nullp << 257 << 258 // particle definition << 259 G4ParticleDefinition* fAdjEquivDirectPrimPar << 260 G4ParticleDefinition* fAdjEquivDirectSecondP << 261 G4ParticleDefinition* fDirectPrimaryPart << 262 << 263 // adjoint CS matrix for each element or mat << 264 std::vector<G4AdjointCSMatrix*>* fCSMatrixPr << 265 std::vector<G4AdjointCSMatrix*>* fCSMatrixPr << 266 << 267 std::vector<G4double> fElementCSScatProjToPr << 268 std::vector<G4double> fElementCSProdToProj; << 269 << 270 G4double fKinEnergyProdForIntegration = << 271 G4double fKinEnergyScatProjForIntegration = << 272 << 273 G4double fLastCS = 0 << 274 G4double fLastAdjointCSForScatProjToProj = 0 << 275 G4double fLastAdjointCSForProdToProj = 0 << 276 << 277 G4double fPreStepEnergy = 0.; << 278 << 279 G4double fTcutPrim = 0.; << 280 G4double fTcutSecond = 0.; << 281 << 282 // Energy limits << 283 G4double fHighEnergyLimit = 0.; << 284 G4double fLowEnergyLimit = 0.; << 285 << 286 // Cross Section biasing factor << 287 G4double fCsBiasingFactor = 1.; << 288 << 289 // [1] This is needed for the forced interac << 290 // correction is given outside the model whi << 291 // the model. The weight should be fixed bef << 292 G4double fOutsideWeightFactor = 1.; << 293 << 294 // Needed for CS integration at the initiali << 295 G4int fASelectedNucleus = 0; << 296 G4int fZSelectedNucleus = 0; << 297 << 298 std::size_t fCSMatrixUsed = 0; // Index of << 299 << 300 G4bool fSecondPartSameType = false; << 301 G4bool fInModelWeightCorr = << 302 false; // correct_weight_for_post_step_in << 303 << 304 G4bool fApplyCutInRange = true; << 305 << 306 // Type of Model with Matrix or not << 307 G4bool fUseMatrix = false; << 308 G4bool fUseMatrixPerElement = false; // << 309 G4bool fOneMatrixForAllElements = false; << 310 }; 359 }; 311 360 >> 361 312 #endif 362 #endif >> 363 313 364