| 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 // G4SPSEneDistribution << 26 ///////////////////////////////////////////////////////////////////////////////
>> 27 //
>> 28 // MODULE: G4SPSEneDistribution.hh
>> 29 //
>> 30 // Version: 1.0
>> 31 // Date: 5/02/04
>> 32 // Author: Fan Lei
>> 33 // Organisation: QinetiQ ltd.
>> 34 // Customer: ESA/ESTEC
>> 35 //
>> 36 ///////////////////////////////////////////////////////////////////////////////
>> 37 //
>> 38 // CHANGE HISTORY
>> 39 // --------------
>> 40 //
>> 41 //
>> 42 // Version 1.0, 05/02/2004, Fan Lei, Created.
>> 43 // Based on the G4GeneralParticleSource class in Geant4 v6.0
>> 44 //
>> 45 //
>> 46 // 26/03/2014, Andrew Green.
>> 47 // Modification to used STL vectors instead of C-style arrays. This should save some space,
>> 48 // particularly when the blackbody function is not used. Also moved to dynamically allocated
>> 49 // memory in the LinearInterpolation, ExpInterpolation and LogInterpolation functions. Again,
>> 50 // this will save space if these functions are unused.
>> 51 //
>> 52 // 06/06/2014 A Dotti
>> 53 // For thread safety: this is a shared object,
>> 54 // mutex has been added to control access to shared resources (data members).
>> 55 // in Getters and Setters, mutex is NOT used in GenerateOne because it is
>> 56 // assumed that properties are not changed during event loop.
>> 57 //
>> 58 ///////////////////////////////////////////////////////////////////////////////
>> 59 //
27 // 60 //
28 // Class Description: 61 // Class Description:
29 // 62 //
30 // To generate the energy of a primary vertex << 63 // To generate the energy of a primary vertex according to the defined distribution
31 // defined distribution. This is a shared clas << 64 //
32 // Only one thread should use the set-methods << 65 ///////////////////////////////////////////////////////////////////////////////
33 // Note that this is exactly what is achieved << 66 //
34 // If you use the set methods to set defaults << 67 // MEMBER FUNCTIONS
35 // care that only one thread is executing them << 68 // ----------------
36 // In addition take care of calling these meth << 69 //
37 // started. Do not use the setters during the << 70 // G4SPSEneDistribution ()
>> 71 // Constructor: Initializes variables
>> 72 //
>> 73 // ~G4SPSEneDistribution ()
>> 74 // Destructor:
>> 75 //
>> 76 // void SetEnergyDisType(G4String)
>> 77 // Allows the user to choose the energy distribution type. The arguments
>> 78 // are Mono (mono-energetic), Lin (linear), Pow (power-law), Exp
>> 79 // (exponential), Gauss (gaussian), Brem (bremsstrahlung), BBody (black-body), Cdg
>> 80 // (cosmic diffuse gamma-ray), User (user-defined), Arb (arbitrary
>> 81 // point-wise), Epn (energy per nucleon).
>> 82 //
>> 83 // void SetEmin(G4double)
>> 84 // Sets the minimum energy.
>> 85 //
>> 86 // void SetEmax(G4double)
>> 87 // Sets the maximum energy.
>> 88 //
>> 89 // void SetMonoEnergy(G4double)
>> 90 // Sets energy for mono-energetic distribution.
>> 91 //
>> 92 // void SetAlpha(G4double)
>> 93 // Sets alpha for a power-law distribution.
>> 94 //
>> 95 // void SetTemp(G4double)
>> 96 // Sets Temperature for a Brem or BBody distributions.
>> 97 //
>> 98 // void SetEzero(G4double)
>> 99 // Sets Ezero for an exponential distribution.
>> 100 //
>> 101 // void SetGradient(G4double)
>> 102 // Sets gradient for a linear distribution.
>> 103 //
>> 104 // void SetInterCept(G4double)
>> 105 // Sets intercept for a linear distribution.
>> 106 //
>> 107 // void UserEnergyHisto(G4ThreeVector)
>> 108 // Allows user to defined a histogram for the energy distribution.
>> 109 //
>> 110 // void ArbEnergyHisto(G4ThreeVector)
>> 111 // Allows the user to define an Arbitrary set of points for the
>> 112 // energy distribution.
>> 113 //
>> 114 // void EpnEnergyHisto(G4ThreeVector)
>> 115 // Allows the user to define an Energy per nucleon histogram.
>> 116 //
>> 117 // void Calculate()
>> 118 // Controls the calculation of Integral PDF for the Cdg and BBody
>> 119 // distributions.
>> 120 //
>> 121 // void InputEnergySpectra(G4bool)
>> 122 // Allows the user to choose between momentum and energy histograms
>> 123 // for user-defined histograms and arbitrary point-wise spectr.
>> 124 // The default is true (energy).
>> 125 //
>> 126 // void InputDifferentialSpectra(G4bool)
>> 127 // Allows the user to choose between integral and differential
>> 128 // distributions when using the arbitrary point-wise option.
>> 129 //
>> 130 // void ArbInterpolate(G4String)
>> 131 // ArbInterpolate allows the user to specify the type of function to
>> 132 // interpolate the Arbitrary points spectrum with.
>> 133 //
>> 134 // void SetBiasRndm (G4SPSRandomGenerator* a)
>> 135 // Sets the biased random number generator
>> 136 //
>> 137 // G4double GenerateOne(G4ParticleDefinition*);
>> 138 // Generate one random energy for the specified particle
>> 139 //
>> 140 // void ReSetHist(G4String);
>> 141 // Re-sets the histogram for user defined distribution
>> 142 //
>> 143 // void SetVerbosity(G4int)
>> 144 // Sets the verbosity level.
>> 145 //
>> 146 ///////////////////////////////////////////////////////////////////////////////
38 147
39 // Author: Fan Lei, QinetiQ ltd. << 148 #ifndef G4SPSEneDistribution_h
40 // Customer: ESA/ESTEC << 149 #define G4SPSEneDistribution_h 1
41 // History: <<
42 // - 05/02/2004, Fan Lei - Created. <<
43 // Based on the G4GeneralParticleSource cl <<
44 // - 26/03/2014, Andrew Green. <<
45 // Modification to use STL vectors instead <<
46 // Also moved to dynamically allocated mem <<
47 // ExpInterpolation() and LogInterpolation <<
48 // - 06/06/2014, Andrea Dotti. <<
49 // For thread safety: this is a shared obj <<
50 // Added mutex to control access to shared <<
51 // in Getters and Setters, mutex is NOT us <<
52 // is assumed that properties are not chan <<
53 // - 24/11/2017, Fan Lei <<
54 // Added cutoff power-law distribution opti <<
55 // to that of the BlackBody one. <<
56 // ------------------------------------------- <<
57 #ifndef G4SPSEneDistribution_hh <<
58 #define G4SPSEneDistribution_hh 1 <<
59 150
60 #include "G4PhysicsFreeVector.hh" << 151 #include "G4PhysicsOrderedFreeVector.hh"
61 #include "G4ParticleMomentum.hh" 152 #include "G4ParticleMomentum.hh"
62 #include "G4ParticleDefinition.hh" 153 #include "G4ParticleDefinition.hh"
63 #include "G4DataInterpolation.hh" 154 #include "G4DataInterpolation.hh"
64 #include "G4Threading.hh" 155 #include "G4Threading.hh"
65 #include "G4Cache.hh" 156 #include "G4Cache.hh"
66 #include <vector> 157 #include <vector>
67 158
68 #include "G4SPSRandomGenerator.hh" 159 #include "G4SPSRandomGenerator.hh"
69 160
70 class G4SPSEneDistribution << 161 /** Andrea Dotti Feb 2015
71 { << 162 * Important: This is a shared class between threads.
72 public: << 163 * Only one thread should use the set-methods here.
73 << 164 * Note that this is exactly what is achieved using UI commands.
74 G4SPSEneDistribution(); << 165 * If you use the set methods to set defaults in your
75 // Constructor: initializes variables << 166 * application take care that only one thread is executing them.
76 ~G4SPSEneDistribution(); << 167 * In addition take care of calling these methods before the run is started
77 // Destructor << 168 * Do not use these setters during the event loop
78 << 169 */
79 void SetEnergyDisType(const G4String&); << 170
80 // Allows the user to choose the energy << 171 class G4SPSEneDistribution {
81 // The arguments are: Mono (mono-energet << 172 public:
82 // Pow (power-law), Exp (exponential), G << 173 G4SPSEneDistribution();//
83 // Brem (bremsstrahlung), BBody (black-b << 174 ~G4SPSEneDistribution();//
84 // Cdg (cosmic diffuse gamma-ray), User << 175
85 // Arb (arbitrary point-wise), Epn (ener << 176 void SetEnergyDisType(G4String);//
86 << 177 G4String GetEnergyDisType();//
87 const G4String& GetEnergyDisType(); << 178 void SetEmin(G4double);//
88 << 179 G4double GetEmin();//
89 void SetEmin(G4double); << 180 G4double GetArbEmin();//
90 // Sets the minimum energy << 181 void SetEmax(G4double);//
91 << 182 G4double GetEmax();//
92 G4double GetEmin() const; << 183 G4double GetArbEmax();//
93 G4double GetArbEmin(); << 184 void SetMonoEnergy(G4double);//
94 << 185 void SetAlpha(G4double);//
95 void SetEmax(G4double); << 186 void SetBiasAlpha(G4double);//
96 // Sets the maximum energy << 187 void SetTemp(G4double);//
97 << 188 void SetBeamSigmaInE(G4double);////
98 G4double GetEmax() const; << 189 void SetEzero(G4double);//
99 G4double GetArbEmax(); << 190 void SetGradient(G4double);//
100 << 191 void SetInterCept(G4double);//
101 void SetMonoEnergy(G4double); << 192 void UserEnergyHisto(G4ThreeVector);//
102 // Sets energy for mono-energetic distri << 193 void ArbEnergyHisto(G4ThreeVector);//
103 << 194 void ArbEnergyHistoFile(G4String);//
104 void SetAlpha(G4double); << 195 void EpnEnergyHisto(G4ThreeVector);//
105 // Sets alpha for a power-law distributi << 196
106 << 197 void InputEnergySpectra(G4bool);//
107 void SetBiasAlpha(G4double); << 198 void InputDifferentialSpectra(G4bool);//
108 << 199 void ArbInterpolate(G4String);//
109 void SetTemp(G4double); << 200 G4String GetIntType();//
110 // Sets Temperature for a Brem or BBody <<
111 <<
112 void SetBeamSigmaInE(G4double); <<
113 <<
114 void SetEzero(G4double); <<
115 // Sets Ezero for an exponential distrib <<
116 <<
117 void SetGradient(G4double); <<
118 // Sets gradient for a linear distributi <<
119 <<
120 void SetInterCept(G4double); <<
121 // Sets intercept for a linear distribut <<
122 <<
123 void UserEnergyHisto(const G4ThreeVector&) <<
124 // Allows user to defined a histogram fo <<
125 <<
126 void ArbEnergyHisto(const G4ThreeVector&); <<
127 // Allows the user to define an Arbitrar <<
128 // energy distribution <<
129 <<
130 void ArbEnergyHistoFile(const G4String&); <<
131 <<
132 void EpnEnergyHisto(const G4ThreeVector&); <<
133 // Allows the user to define an Energy p <<
134 <<
135 void InputEnergySpectra(G4bool); <<
136 // Allows the user to choose between mom <<
137 // for user-defined histograms and arbit <<
138 // The default is true (energy) <<
139 <<
140 void InputDifferentialSpectra(G4bool); <<
141 // Allows the user to choose between int <<
142 // distributions when using the arbitrar <<
143 <<
144 void ArbInterpolate(const G4String&); <<
145 // Allows the user to specify the type o <<
146 // interpolate the Arbitrary points spec <<
147 <<
148 const G4String& GetIntType(); <<
149 201
150 void Calculate(); << 202 void Calculate();//
151 // Controls the calculation of Integral <<
152 // distributions <<
153 <<
154 void SetBiasRndm(G4SPSRandomGenerator* a); <<
155 // Sets the biased random number generat <<
156 <<
157 void ReSetHist(const G4String&); <<
158 // Resets the histogram for user defined <<
159 <<
160 void SetVerbosity(G4int a); <<
161 // Sets the verbosity level <<
162 <<
163 G4double GetWeight() const; <<
164 <<
165 G4double GetMonoEnergy(); <<
166 // Mono-energetic energy <<
167 203
168 G4double GetSE(); << 204 void SetBiasRndm(G4SPSRandomGenerator* a);//
169 // Standard deviation for Gaussian distr << 205 // method to re-set the histograms
>> 206 void ReSetHist(G4String);//
>> 207 // Set the verbosity level.
>> 208 void SetVerbosity(G4int a);//
>> 209
>> 210 //x
>> 211 G4double GetWeight();
>> 212
>> 213 G4double GetMonoEnergy(); //Mono-energteic energy
>> 214 G4double GetSE();// Standard deviation for Gaussion distrbution in energy
>> 215 G4double Getalpha(); // alpha (pow)
>> 216 G4double GetEzero(); // E0 (exp)
>> 217 G4double GetTemp(); // Temp (bbody,brem)
>> 218 G4double Getgrad(); // gradient and intercept for linear spectra
>> 219 G4double Getcept(); //
>> 220
>> 221 G4PhysicsOrderedFreeVector GetUserDefinedEnergyHisto(); //
>> 222 G4PhysicsOrderedFreeVector GetArbEnergyHisto(); //
>> 223
>> 224 G4double GenerateOne(G4ParticleDefinition*);
>> 225 G4double GetProbability (G4double);
>> 226
>> 227
>> 228 private:
>> 229 void LinearInterpolation();//
>> 230 void LogInterpolation();//
>> 231 void ExpInterpolation();//
>> 232 void SplineInterpolation();//
>> 233 void CalculateCdgSpectrum();//
>> 234 void CalculateBbodySpectrum();//
>> 235
>> 236 // The following methods generate energies according to the spectral
>> 237 // parameters defined above.
>> 238 void GenerateMonoEnergetic();//G4double& outputEne);//
>> 239 void GenerateBiasPowEnergies();//G4double& outputEne,G4double& outputWeight);//
>> 240 void GenerateGaussEnergies();//
>> 241 void GenerateBremEnergies();//
>> 242 void GenerateBbodyEnergies();//
>> 243 void GenerateCdgEnergies();//
>> 244 void GenUserHistEnergies();//
>> 245 void GenEpnHistEnergies();//
>> 246 void GenArbPointEnergies();//<<<<<<<<<<< DOES NOT WORK, REQUIRES UPDATE OF DATA MEMBERS.
>> 247 void GenerateExpEnergies(G4bool);//
>> 248 void GenerateLinearEnergies(G4bool);//
>> 249 void GeneratePowEnergies(G4bool);//
170 250
171 G4double Getalpha() const; << 251 // converts energy per nucleon to energy.
172 // Alpha (pow) << 252 void ConvertEPNToEnergy();
173 <<
174 G4double GetEzero() const; <<
175 // E0 (exp) <<
176 <<
177 G4double GetTemp(); <<
178 // Temp (bbody,brem) <<
179 <<
180 G4double Getgrad() const; <<
181 // Gradient and intercept for linear spe <<
182 <<
183 G4double Getcept() const; <<
184 <<
185 G4PhysicsFreeVector GetUserDefinedEnergyHi <<
186 <<
187 G4PhysicsFreeVector GetArbEnergyHisto(); <<
188 <<
189 G4double GenerateOne(G4ParticleDefinition* <<
190 // Generate one random energy for the s <<
191 <<
192 G4double GetProbability (G4double); <<
193 <<
194 G4double GetArbEneWeight(G4double); <<
195 <<
196 inline void ApplyEnergyWeight(G4bool val) <<
197 inline G4bool IfApplyEnergyWeight() const <<
198 <<
199 private: <<
200 <<
201 void LinearInterpolation(); <<
202 void LogInterpolation(); <<
203 void ExpInterpolation(); <<
204 void SplineInterpolation(); <<
205 void CalculateCdgSpectrum(); <<
206 void CalculateBbodySpectrum(); <<
207 void CalculateCPowSpectrum(); <<
208 <<
209 // The following methods generate energies <<
210 // to the spectral parameters defined abov <<
211 <<
212 void GenerateMonoEnergetic(); <<
213 void GenerateBiasPowEnergies(); <<
214 void GenerateGaussEnergies(); <<
215 void GenerateBremEnergies(); <<
216 void GenerateBbodyEnergies(); <<
217 void GenerateCdgEnergies(); <<
218 void GenUserHistEnergies(); <<
219 void GenEpnHistEnergies(); <<
220 void GenArbPointEnergies(); // NOTE: REQUI <<
221 void GenerateExpEnergies(G4bool); <<
222 void GenerateLinearEnergies(G4bool); <<
223 void GeneratePowEnergies(G4bool); <<
224 void GenerateCPowEnergies(); <<
225 <<
226 void ConvertEPNToEnergy(); <<
227 // Converts energy per nucleon to energy <<
228 253
229 void BBInitHists(); << 254 void InitHists();//
230 void CPInitHists(); <<
231 <<
232 private: // Non invariant data members beco <<
233 255
234 G4String EnergyDisType; // energy dis type << 256 private:
235 G4double weight; // particle weight //// N <<
236 G4double MonoEnergy; //Mono-energteic ener <<
237 G4double SE; // Standard deviation for Gau <<
238 257
239 G4double Emin, Emax; // emin and emax //// << 258 G4String EnergyDisType; // energy dis type Variable - Mono,Lin,Exp,etc
240 G4double alpha, Ezero;// alpha (pow), E0 ( << 259 G4double weight; // particle weight //// NOT INVARIANT
>> 260 G4double MonoEnergy; //Mono-energteic energy
>> 261 G4double SE; // Standard deviation for Gaussion distrbution in energy
>> 262 //Non invariant data members become G4Cache
>> 263 G4double Emin, Emax; // emin and emax ////// NOT INVARIANT
>> 264 G4double alpha, Ezero;// alpha (pow), E0 (exp) ////// NOT INVARIANT
241 G4double Temp; // Temp (bbody,brem) 265 G4double Temp; // Temp (bbody,brem)
242 G4double biasalpha; // biased power index << 266 G4double biasalpha; // biased power index
243 G4double grad, cept; // gradient and inter << 267 G4double grad, cept; // gradient and intercept for linear spectra ////// NOT INVARIANT
244 G4double prob_norm; // normalisation facto 268 G4double prob_norm; // normalisation factor use in calculate the probability
245 G4bool Biased = false; // biased to power- << 269 G4bool Biased; // true - biased to power-law
246 G4bool EnergySpec = true; // energy spectr << 270 G4bool EnergySpec; // true - energy spectra, false - momentum spectra
247 G4bool DiffSpec = true; // differential sp << 271 G4bool DiffSpec; // true - differential spec, false integral spec
248 << 272 //G4bool ApplyRig; // false no rigidity cutoff, true then apply one
249 G4PhysicsFreeVector UDefEnergyH; // energy << 273 //G4double ERig; // energy of rigidity cutoff
250 G4PhysicsFreeVector IPDFEnergyH; << 274 G4PhysicsOrderedFreeVector UDefEnergyH; // energy hist data
251 G4bool IPDFEnergyExist = false, IPDFArbExi << 275 G4PhysicsOrderedFreeVector IPDFEnergyH;
252 G4PhysicsFreeVector ArbEnergyH; // Arb x,y << 276 G4bool IPDFEnergyExist, IPDFArbExist, Epnflag;
253 G4PhysicsFreeVector IPDFArbEnergyH; // IPD << 277 G4PhysicsOrderedFreeVector ArbEnergyH; // Arb x,y histogram
254 G4PhysicsFreeVector EpnEnergyH; << 278 G4PhysicsOrderedFreeVector IPDFArbEnergyH; // IPDF for Arb
255 G4double CDGhist[3]; // cumulative histo f << 279 G4PhysicsOrderedFreeVector EpnEnergyH;
>> 280 G4double CDGhist[3]; // cumulative histo for cdg
>> 281
>> 282 //AG: Begin edit to use STL vectors.
>> 283 // G4double BBHist[10001], Bbody_x[10001];
>> 284 std::vector<G4double>* BBHist;
>> 285 std::vector<G4double>* Bbody_x;
>> 286 G4bool histInit;
>> 287 G4bool histCalcd;
256 288
257 std::vector<G4double>* BBHist = nullptr; << 289 //AG: Edit here to use dynamic memory, will save space inless these functions are used.
258 std::vector<G4double>* Bbody_x = nullptr; << 290 G4String IntType; // Interpolation type
259 G4bool BBhistInit = false; << 291 // G4double Arb_grad[1024], Arb_cept[1024]; // grad and cept for 1024 segments AG: Switched to DMA
260 G4bool BBhistCalcd = false; << 292 G4double* Arb_grad;
261 << 293 G4double* Arb_cept;
262 // For cutoff power-law << 294 G4bool Arb_grad_cept_flag;
263 // << 295 // G4double Arb_alpha[1024], Arb_Const[1024]; // alpha and constants AG: Switched to DMA
264 std::vector<G4double>* CPHist = nullptr; << 296 G4double* Arb_alpha;
265 std::vector<G4double>* CP_x = nullptr; << 297 G4double* Arb_Const;
266 G4bool CPhistInit = false; << 298 G4bool Arb_alpha_Const_flag;
267 G4bool CPhistCalcd = false; << 299 // G4double Arb_ezero[1024]; // ezero AG: Switched to DMA
268 << 300 G4double* Arb_ezero;
269 G4String IntType; // Interpolation type << 301 G4bool Arb_ezero_flag;
270 G4double* Arb_grad = nullptr; << 302 G4double ArbEmin, ArbEmax; // Emin and Emax for the whole arb distribution used primarily for debug.
271 G4double* Arb_cept = nullptr; << 303
272 G4bool Arb_grad_cept_flag = false; << 304 G4double particle_energy;
273 G4double* Arb_alpha = nullptr; << 305
274 G4double* Arb_Const = nullptr; << 306 G4SPSRandomGenerator* eneRndm;
275 G4bool Arb_alpha_Const_flag = false; <<
276 G4double* Arb_ezero = nullptr; <<
277 G4bool Arb_ezero_flag = false; <<
278 <<
279 G4bool applyEvergyWeight = false; <<
280 <<
281 G4double ArbEmin, ArbEmax; <<
282 // Emin and Emax for the whole arb distr <<
283 <<
284 G4double particle_energy; <<
285 <<
286 G4SPSRandomGenerator* eneRndm = nullptr; <<
287 <<
288 G4int verbosityLevel; <<
289 <<
290 G4PhysicsFreeVector ZeroPhysVector; // for <<
291 <<
292 std::vector<G4DataInterpolation*> SplineIn <<
293 // Holds Spline stuff required for sampl <<
294 G4DataInterpolation* Splinetemp = nullptr; <<
295 // Holds a temp Spline used for calculat <<
296 307
297 G4Mutex mutex; // protect access to shared << 308 // Verbosity
>> 309 G4int verbosityLevel;
>> 310
>> 311 G4PhysicsOrderedFreeVector ZeroPhysVector; // for re-set only
>> 312
>> 313 std::vector<G4DataInterpolation*> SplineInt;//[1024]; // holds Spline stuff required for sampling
>> 314 G4DataInterpolation *Splinetemp; // holds a temp Spline used for calculating area
298 315
299 // Thread local data (non-invariant during << 316 G4Mutex mutex; // protect access to shared resources
300 // These are copied from master one at the << 317 //Thread local data (non-invariant during event loop).
301 // generation of each event << 318 //These are copied from master one at the beginning of generation
302 // << 319 //of each event
303 struct threadLocal_t << 320 struct threadLocal_t {
304 { << 321 G4double Emin;
305 G4double Emin; << 322 G4double Emax;
306 G4double Emax; << 323 G4double alpha;
307 G4double alpha; << 324 G4double Ezero;
308 G4double Ezero; << 325 G4double grad;
309 G4double grad; << 326 G4double cept;
310 G4double cept; << 327 G4ParticleDefinition* particle_definition;
311 G4ParticleDefinition* particle_definitio << 328 G4double weight;
312 G4double weight; << 329 G4double particle_energy;
313 G4double particle_energy; <<
314 }; 330 };
315 G4Cache<threadLocal_t> threadLocalData; 331 G4Cache<threadLocal_t> threadLocalData;
316 }; 332 };
317 333
318 #endif 334 #endif
>> 335
319 336