| 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 class G4SPSEneDistribution {
71 { << 162 public:
72 public: << 163 G4SPSEneDistribution();//
73 << 164 ~G4SPSEneDistribution();//
74 G4SPSEneDistribution(); << 165
75 // Constructor: initializes variables << 166 void SetEnergyDisType(G4String);//
76 ~G4SPSEneDistribution(); << 167 G4String GetEnergyDisType();//
77 // Destructor << 168 void SetEmin(G4double);//
78 << 169 G4double GetEmin();//
79 void SetEnergyDisType(const G4String&); << 170 G4double GetArbEmin();//
80 // Allows the user to choose the energy << 171 void SetEmax(G4double);//
81 // The arguments are: Mono (mono-energet << 172 G4double GetEmax();//
82 // Pow (power-law), Exp (exponential), G << 173 G4double GetArbEmax();//
83 // Brem (bremsstrahlung), BBody (black-b << 174 void SetMonoEnergy(G4double);//
84 // Cdg (cosmic diffuse gamma-ray), User << 175 void SetAlpha(G4double);//
85 // Arb (arbitrary point-wise), Epn (ener << 176 void SetBiasAlpha(G4double);//
86 << 177 void SetTemp(G4double);//
87 const G4String& GetEnergyDisType(); << 178 void SetBeamSigmaInE(G4double);////
88 << 179 void SetEzero(G4double);//
89 void SetEmin(G4double); << 180 void SetGradient(G4double);//
90 // Sets the minimum energy << 181 void SetInterCept(G4double);//
91 << 182 void UserEnergyHisto(G4ThreeVector);//
92 G4double GetEmin() const; << 183 void ArbEnergyHisto(G4ThreeVector);//
93 G4double GetArbEmin(); << 184 void ArbEnergyHistoFile(G4String);//
94 << 185 void EpnEnergyHisto(G4ThreeVector);//
95 void SetEmax(G4double); << 186
96 // Sets the maximum energy << 187 void InputEnergySpectra(G4bool);//
97 << 188 void InputDifferentialSpectra(G4bool);//
98 G4double GetEmax() const; << 189 void ArbInterpolate(G4String);//
99 G4double GetArbEmax(); << 190 G4String GetIntType();//
100 <<
101 void SetMonoEnergy(G4double); <<
102 // Sets energy for mono-energetic distri <<
103 <<
104 void SetAlpha(G4double); <<
105 // Sets alpha for a power-law distributi <<
106 <<
107 void SetBiasAlpha(G4double); <<
108 <<
109 void SetTemp(G4double); <<
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 191
150 void Calculate(); << 192 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 193
168 G4double GetSE(); << 194 void SetBiasRndm(G4SPSRandomGenerator* a);//
169 // Standard deviation for Gaussian distr << 195 // method to re-set the histograms
>> 196 void ReSetHist(G4String);//
>> 197 // Set the verbosity level.
>> 198 void SetVerbosity(G4int a);//
>> 199
>> 200 //x
>> 201 G4double GetWeight();
>> 202
>> 203 G4double GetMonoEnergy(); //Mono-energteic energy
>> 204 G4double GetSE();// Standard deviation for Gaussion distrbution in energy
>> 205 G4double Getalpha(); // alpha (pow)
>> 206 G4double GetEzero(); // E0 (exp)
>> 207 G4double GetTemp(); // Temp (bbody,brem)
>> 208 G4double Getgrad(); // gradient and intercept for linear spectra
>> 209 G4double Getcept(); //
>> 210
>> 211 G4PhysicsOrderedFreeVector GetUserDefinedEnergyHisto(); //
>> 212 G4PhysicsOrderedFreeVector GetArbEnergyHisto(); //
>> 213
>> 214 G4double GenerateOne(G4ParticleDefinition*);
>> 215 G4double GetProbability (G4double);
>> 216
>> 217
>> 218 private:
>> 219 void LinearInterpolation();//
>> 220 void LogInterpolation();//
>> 221 void ExpInterpolation();//
>> 222 void SplineInterpolation();//
>> 223 void CalculateCdgSpectrum();//
>> 224 void CalculateBbodySpectrum();//
>> 225
>> 226 // The following methods generate energies according to the spectral
>> 227 // parameters defined above.
>> 228 void GenerateMonoEnergetic();//G4double& outputEne);//
>> 229 void GenerateBiasPowEnergies();//G4double& outputEne,G4double& outputWeight);//
>> 230 void GenerateGaussEnergies();//
>> 231 void GenerateBremEnergies();//
>> 232 void GenerateBbodyEnergies();//
>> 233 void GenerateCdgEnergies();//
>> 234 void GenUserHistEnergies();//
>> 235 void GenEpnHistEnergies();//
>> 236 void GenArbPointEnergies();//<<<<<<<<<<< DOES NOT WORK, REQUIRES UPDATE OF DATA MEMBERS.
>> 237 void GenerateExpEnergies(G4bool);//
>> 238 void GenerateLinearEnergies(G4bool);//
>> 239 void GeneratePowEnergies(G4bool);//
170 240
171 G4double Getalpha() const; << 241 // converts energy per nucleon to energy.
172 // Alpha (pow) << 242 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 243
229 void BBInitHists(); << 244 void InitHists();//
230 void CPInitHists(); <<
231 <<
232 private: // Non invariant data members beco <<
233 245
234 G4String EnergyDisType; // energy dis type << 246 private:
235 G4double weight; // particle weight //// N <<
236 G4double MonoEnergy; //Mono-energteic ener <<
237 G4double SE; // Standard deviation for Gau <<
238 247
239 G4double Emin, Emax; // emin and emax //// << 248 G4String EnergyDisType; // energy dis type Variable - Mono,Lin,Exp,etc
240 G4double alpha, Ezero;// alpha (pow), E0 ( << 249 G4double weight; // particle weight //// NOT INVARIANT
>> 250 G4double MonoEnergy; //Mono-energteic energy
>> 251 G4double SE; // Standard deviation for Gaussion distrbution in energy
>> 252 //Non invariant data members become G4Cache
>> 253 G4double Emin, Emax; // emin and emax ////// NOT INVARIANT
>> 254 G4double alpha, Ezero;// alpha (pow), E0 (exp) ////// NOT INVARIANT
241 G4double Temp; // Temp (bbody,brem) 255 G4double Temp; // Temp (bbody,brem)
242 G4double biasalpha; // biased power index << 256 G4double biasalpha; // biased power index
243 G4double grad, cept; // gradient and inter << 257 G4double grad, cept; // gradient and intercept for linear spectra ////// NOT INVARIANT
244 G4double prob_norm; // normalisation facto 258 G4double prob_norm; // normalisation factor use in calculate the probability
245 G4bool Biased = false; // biased to power- << 259 G4bool Biased; // true - biased to power-law
246 G4bool EnergySpec = true; // energy spectr << 260 G4bool EnergySpec; // true - energy spectra, false - momentum spectra
247 G4bool DiffSpec = true; // differential sp << 261 G4bool DiffSpec; // true - differential spec, false integral spec
248 << 262 //G4bool ApplyRig; // false no rigidity cutoff, true then apply one
249 G4PhysicsFreeVector UDefEnergyH; // energy << 263 //G4double ERig; // energy of rigidity cutoff
250 G4PhysicsFreeVector IPDFEnergyH; << 264 G4PhysicsOrderedFreeVector UDefEnergyH; // energy hist data
251 G4bool IPDFEnergyExist = false, IPDFArbExi << 265 G4PhysicsOrderedFreeVector IPDFEnergyH;
252 G4PhysicsFreeVector ArbEnergyH; // Arb x,y << 266 G4bool IPDFEnergyExist, IPDFArbExist, Epnflag;
253 G4PhysicsFreeVector IPDFArbEnergyH; // IPD << 267 G4PhysicsOrderedFreeVector ArbEnergyH; // Arb x,y histogram
254 G4PhysicsFreeVector EpnEnergyH; << 268 G4PhysicsOrderedFreeVector IPDFArbEnergyH; // IPDF for Arb
255 G4double CDGhist[3]; // cumulative histo f << 269 G4PhysicsOrderedFreeVector EpnEnergyH;
>> 270 G4double CDGhist[3]; // cumulative histo for cdg
>> 271
>> 272 //AG: Begin edit to use STL vectors.
>> 273 // G4double BBHist[10001], Bbody_x[10001];
>> 274 std::vector<G4double>* BBHist;
>> 275 std::vector<G4double>* Bbody_x;
>> 276 G4bool histInit;
>> 277 G4bool histCalcd;
256 278
257 std::vector<G4double>* BBHist = nullptr; << 279 //AG: Edit here to use dynamic memory, will save space inless these functions are used.
258 std::vector<G4double>* Bbody_x = nullptr; << 280 G4String IntType; // Interpolation type
259 G4bool BBhistInit = false; << 281 // G4double Arb_grad[1024], Arb_cept[1024]; // grad and cept for 1024 segments AG: Switched to DMA
260 G4bool BBhistCalcd = false; << 282 G4double* Arb_grad;
261 << 283 G4double* Arb_cept;
262 // For cutoff power-law << 284 G4bool Arb_grad_cept_flag;
263 // << 285 // G4double Arb_alpha[1024], Arb_Const[1024]; // alpha and constants AG: Switched to DMA
264 std::vector<G4double>* CPHist = nullptr; << 286 G4double* Arb_alpha;
265 std::vector<G4double>* CP_x = nullptr; << 287 G4double* Arb_Const;
266 G4bool CPhistInit = false; << 288 G4bool Arb_alpha_Const_flag;
267 G4bool CPhistCalcd = false; << 289 // G4double Arb_ezero[1024]; // ezero AG: Switched to DMA
268 << 290 G4double* Arb_ezero;
269 G4String IntType; // Interpolation type << 291 G4bool Arb_ezero_flag;
270 G4double* Arb_grad = nullptr; << 292 G4double ArbEmin, ArbEmax; // Emin and Emax for the whole arb distribution used primarily for debug.
271 G4double* Arb_cept = nullptr; << 293
272 G4bool Arb_grad_cept_flag = false; << 294 G4double particle_energy;
273 G4double* Arb_alpha = nullptr; << 295
274 G4double* Arb_Const = nullptr; << 296 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 297
297 G4Mutex mutex; // protect access to shared << 298 // Verbosity
>> 299 G4int verbosityLevel;
>> 300
>> 301 G4PhysicsOrderedFreeVector ZeroPhysVector; // for re-set only
>> 302
>> 303 std::vector<G4DataInterpolation*> SplineInt;//[1024]; // holds Spline stuff required for sampling
>> 304 G4DataInterpolation *Splinetemp; // holds a temp Spline used for calculating area
298 305
299 // Thread local data (non-invariant during << 306 G4Mutex mutex; // protect access to shared resources
300 // These are copied from master one at the << 307 //Thread local data (non-invariant during event loop).
301 // generation of each event << 308 //These are copied from master one at the beginning of generation
302 // << 309 //of each event
303 struct threadLocal_t << 310 struct threadLocal_t {
304 { << 311 G4double Emin;
305 G4double Emin; << 312 G4double Emax;
306 G4double Emax; << 313 G4double alpha;
307 G4double alpha; << 314 G4double Ezero;
308 G4double Ezero; << 315 G4double grad;
309 G4double grad; << 316 G4double cept;
310 G4double cept; << 317 G4ParticleDefinition* particle_definition;
311 G4ParticleDefinition* particle_definitio << 318 G4double weight;
312 G4double weight; << 319 G4double particle_energy;
313 G4double particle_energy; <<
314 }; 320 };
315 G4Cache<threadLocal_t> threadLocalData; 321 G4Cache<threadLocal_t> threadLocalData;
316 }; 322 };
317 323
318 #endif 324 #endif
>> 325
319 326