| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
26 // G4SPSRandomGenerator << 23 ///////////////////////////////////////////////////////////////////////////////
>> 24 //
>> 25 // MODULE: G4SPSRandomGenerator.hh
>> 26 //
>> 27 // Version: 1.0
>> 28 // Date: 5/02/04
>> 29 // Author: Fan Lei
>> 30 // Organisation: QinetiQ ltd.
>> 31 // Customer: ESA/ESTEC
>> 32 //
>> 33 ///////////////////////////////////////////////////////////////////////////////
>> 34 //
>> 35 // CHANGE HISTORY
>> 36 // --------------
>> 37 //
>> 38 // 26/10/2004 F Lei
>> 39 // Created separated the theta, phi generators for position distributions.
>> 40 //
>> 41 // Version 1.0, 05/02/2004, Fan Lei, Created.
>> 42 // Based on the G4GeneralParticleSource class in Geant4 v6.0
>> 43 //
>> 44 ///////////////////////////////////////////////////////////////////////////////
27 // 45 //
28 // Class Description: 46 // Class Description:
29 // 47 //
30 // Special random number generator used by G4G 48 // Special random number generator used by G4GeneralParticleSource to allow
31 // biasing applied at the lowest level for all 49 // biasing applied at the lowest level for all distributions.
32 // This is a shared class between threads. << 50 //
33 // Only one thread should use the set-methods << 51 ///////////////////////////////////////////////////////////////////////////////
34 // Note that this is exactly what is achieved << 52 //
35 // If you use the set methods to set defaults << 53 // MEMBER FUNCTIONS
36 // application take care that only one thread << 54 // ----------------
37 // In addition take care of calling these meth << 55 //
38 // Do not use the setters during the event loo << 56 // G4SPSRandomGenerator ()
39 << 57 // Constructor: Initializes variables
40 // Author: Fan Lei, QinetiQ ltd. << 58 //
41 // Customer: ESA/ESTEC << 59 // ~G4SPSRandomGenerator ()
42 // History: << 60 // Destructor:
43 // - 05/02/2004, Fan Lei - Created. << 61 //
44 // Based on the G4GeneralParticleSource cl << 62 // void SetXBias(G4ThreeVector)
45 // - 06/06/2014, Andrea Dotti << 63 // Allows the user to re-distribute the random
46 // Added a mutex to protect access to shar << 64 // numbers used to generate x co-ordinates.
47 // Getters and Setters are mutex'd but not << 65 //
48 // because it is assumed these are called << 66 // void SetYBias(G4ThreeVector)
49 // during which the status of this class i << 67 // Allows the user to re-distribute the random
50 // ------------------------------------------- << 68 // numbers used to generate y co-ordinates.
51 #ifndef G4SPSRandomGenerator_hh << 69 //
52 #define G4SPSRandomGenerator_hh 1 << 70 // void SetZBias(G4ThreeVector)
>> 71 // Allows the user to re-distribute the random
>> 72 // numbers used to generate z co-ordinates.
>> 73 //
>> 74 // void SetThetaBias(G4ThreeVector)
>> 75 // Allows the user to re-distribute the random
>> 76 // numbers used to generate values of theta.
>> 77 //
>> 78 // void SetPhiBias(G4ThreeVector)
>> 79 // Allows the user to re-distribute the random
>> 80 // numbers used to generate values of phi.
>> 81 //
>> 82 // void SetPosThetaBias(G4ThreeVector)
>> 83 // Allows the user to re-distribute the random
>> 84 // numbers used to generate values of theta for position distribution.
>> 85 //
>> 86 // void SetPosPhiBias(G4ThreeVector)
>> 87 // Allows the user to re-distribute the random
>> 88 // numbers used to generate values of phi for position distribution.
>> 89 //
>> 90 // void SetEnergyBias(G4ThreeVector)
>> 91 // Allows the user to re-distribute the random
>> 92 // numbers used to generate the energies.
>> 93 //
>> 94 // G4double GenRandX()
>> 95 // Generates the random number for x, with or without biasing.
>> 96 //
>> 97 // G4double GenRandY()
>> 98 // Generates the random number for y, with or without biasing.
>> 99 //
>> 100 // G4double GenRandZ()
>> 101 // Generates the random number for z, with or without biasing.
>> 102 //
>> 103 // G4double GenRandTheta()
>> 104 // Generates the random number for theta, with or without biasing.
>> 105 //
>> 106 // G4double GenRandPhi()
>> 107 // Generates the random number for phi, with or without biasing.
>> 108 //
>> 109 // G4double GenRandEnergy()
>> 110 // Generates the random number for energy, with or without biasing.
>> 111 //
>> 112 // G4double GenRandPosTheta()
>> 113 // Generates the random number for theta, with or without biasing for position distribution.
>> 114 //
>> 115 // G4double GenRandPosPhi()
>> 116 // Generates the random number for phi, with or without biasing for position distribution.
>> 117 //
>> 118 // inline G4double GetBiasWeight()
>> 119 // Returns the weight change after biasing
>> 120 //
>> 121 // void ReSetHist(G4String);
>> 122 // Re-sets the histogram for user defined distribution
>> 123 //
>> 124 // void SetVerbosity(G4int)
>> 125 // Sets the verbosity level.
>> 126 //
>> 127 ///////////////////////////////////////////////////////////////////////////////
>> 128 //
>> 129 #ifndef G4SPSRandomGenerator_h
>> 130 #define G4SPSRandomGenerator_h 1
53 131
54 #include "G4PhysicsFreeVector.hh" << 132 #include "G4PhysicsOrderedFreeVector.hh"
55 #include "G4DataInterpolation.hh" 133 #include "G4DataInterpolation.hh"
56 #include "G4ThreeVector.hh" <<
57 #include "G4Threading.hh" <<
58 #include "G4Cache.hh" <<
59 134
60 class G4SPSRandomGenerator 135 class G4SPSRandomGenerator
61 { 136 {
62 public: << 137 public:
>> 138 G4SPSRandomGenerator ();
>> 139 ~G4SPSRandomGenerator ();
>> 140
>> 141 // static G4SPSRandomGenerator* getInstance ();
>> 142
>> 143 // Biasing Methods
>> 144 void SetXBias(G4ThreeVector);
>> 145 void SetYBias(G4ThreeVector);
>> 146 void SetZBias(G4ThreeVector);
>> 147 void SetThetaBias(G4ThreeVector);
>> 148 void SetPhiBias(G4ThreeVector);
>> 149 void SetEnergyBias(G4ThreeVector);
>> 150 void SetPosThetaBias(G4ThreeVector);
>> 151 void SetPosPhiBias(G4ThreeVector);
>> 152 G4double GenRandX();
>> 153 G4double GenRandY();
>> 154 G4double GenRandZ();
>> 155 G4double GenRandTheta();
>> 156 G4double GenRandPhi();
>> 157 G4double GenRandEnergy();
>> 158 G4double GenRandPosTheta();
>> 159 G4double GenRandPosPhi();
63 160
64 G4SPSRandomGenerator(); << 161 inline G4double GetBiasWeight()
65 // Constructor: initializes variables << 162 { return bweights[0]*bweights[1]*bweights[2]*bweights[3]*bweights[4]*bweights[5]*bweights[6]*bweights[7];};
>> 163
>> 164 // method to re-set the histograms
>> 165 void ReSetHist(G4String);
66 166
67 ~G4SPSRandomGenerator(); << 167 // Set the verbosity level.
68 // Destructor << 168 void SetVerbosity(G4int a) {verbosityLevel = a; } ;
69 169
70 // Biasing Methods << 170 private:
71 <<
72 void SetXBias(const G4ThreeVector&); <<
73 // Allows the user to re-distribute the <<
74 // numbers used to generate x co-ordinat <<
75 <<
76 void SetYBias(const G4ThreeVector&); <<
77 // Allows the user to re-distribute the <<
78 // numbers used to generate y co-ordinat <<
79 <<
80 void SetZBias(const G4ThreeVector&); <<
81 // Allows the user to re-distribute the <<
82 // numbers used to generate z co-ordinat <<
83 <<
84 void SetThetaBias(const G4ThreeVector&); <<
85 // Allows the user to re-distribute the <<
86 // numbers used to generate values of th <<
87 <<
88 void SetPhiBias(const G4ThreeVector&); <<
89 // Allows the user to re-distribute the <<
90 // numbers used to generate values of ph <<
91 <<
92 void SetEnergyBias(const G4ThreeVector&); <<
93 // Allows the user to re-distribute the ra <<
94 // numbers used to generate the energies <<
95 <<
96 void SetPosThetaBias(const G4ThreeVector&) <<
97 // Allows the user to re-distribute the <<
98 // numbers used to generate values of th <<
99 <<
100 void SetPosPhiBias(const G4ThreeVector&); <<
101 // Allows the user to re-distribute the <<
102 // numbers used to generate values of ph <<
103 <<
104 G4double GenRandX(); <<
105 // Generates the random number for x, wi <<
106 <<
107 G4double GenRandY(); <<
108 // Generates the random number for y, wi <<
109 <<
110 G4double GenRandZ(); <<
111 // Generates the random number for z, wi <<
112 <<
113 G4double GenRandTheta(); <<
114 // Generates the random number for theta <<
115 <<
116 G4double GenRandPhi(); <<
117 // Generates the random number for phi, <<
118 <<
119 G4double GenRandEnergy(); <<
120 // Generates the random number for energ <<
121 <<
122 G4double GenRandPosTheta(); <<
123 // Generates the random number for theta <<
124 // for position distribution <<
125 <<
126 G4double GenRandPosPhi(); <<
127 // Generates the random number for phi, <<
128 // for position distribution <<
129 <<
130 void SetIntensityWeight(G4double weight); <<
131 <<
132 G4double GetBiasWeight() const ; <<
133 // Returns the weight change after biasi <<
134 <<
135 // method to re-set the histograms <<
136 void ReSetHist(const G4String&); <<
137 // Resets the histogram for user defined <<
138 <<
139 void SetVerbosity(G4int a); <<
140 // Sets the verbosity level <<
141 <<
142 private: <<
143 <<
144 // Encapsulate in a struct to guarantee th <<
145 // initial state is set via constructor <<
146 // <<
147 struct a_check <<
148 { <<
149 G4bool val; <<
150 a_check() { val = false; } <<
151 }; <<
152 <<
153 // See .cc for an explanation of this in m <<
154 // <<
155 G4Cache<a_check> local_IPDFXBias; <<
156 G4bool XBias, IPDFXBias; <<
157 G4PhysicsFreeVector XBiasH; <<
158 G4PhysicsFreeVector IPDFXBiasH; <<
159 G4Cache<a_check> local_IPDFYBias; <<
160 G4bool YBias, IPDFYBias; <<
161 G4PhysicsFreeVector YBiasH; <<
162 G4PhysicsFreeVector IPDFYBiasH; <<
163 G4Cache<a_check> local_IPDFZBias; <<
164 G4bool ZBias, IPDFZBias; <<
165 G4PhysicsFreeVector ZBiasH; <<
166 G4PhysicsFreeVector IPDFZBiasH; <<
167 G4Cache<a_check> local_IPDFThetaBias; <<
168 G4bool ThetaBias, IPDFThetaBias; <<
169 G4PhysicsFreeVector ThetaBiasH; <<
170 G4PhysicsFreeVector IPDFThetaBiasH; <<
171 G4Cache<a_check> local_IPDFPhiBias; <<
172 G4bool PhiBias, IPDFPhiBias; <<
173 G4PhysicsFreeVector PhiBiasH; <<
174 G4PhysicsFreeVector IPDFPhiBiasH; <<
175 G4Cache<a_check> local_IPDFEnergyBias; <<
176 G4bool EnergyBias, IPDFEnergyBias; <<
177 G4PhysicsFreeVector EnergyBiasH; <<
178 G4PhysicsFreeVector IPDFEnergyBiasH; <<
179 G4Cache<a_check> local_IPDFPosThetaBias; <<
180 G4bool PosThetaBias, IPDFPosThetaBias; <<
181 G4PhysicsFreeVector PosThetaBiasH; <<
182 G4PhysicsFreeVector IPDFPosThetaBiasH; <<
183 G4Cache<a_check> local_IPDFPosPhiBias; <<
184 G4bool PosPhiBias, IPDFPosPhiBias; <<
185 G4PhysicsFreeVector PosPhiBiasH; <<
186 G4PhysicsFreeVector IPDFPosPhiBiasH; <<
187 <<
188 struct bweights_t <<
189 { <<
190 G4double w[9]; <<
191 bweights_t(); <<
192 G4double& operator[] (const int i); <<
193 }; <<
194 G4Cache<bweights_t> bweights; <<
195 // record x,y,z,theta,phi,energy,posThet <<
196 171
197 G4int verbosityLevel; << 172 // static G4SPSRandomGenerator *instance;
198 // Verbosity << 173
199 << 174 G4bool XBias, IPDFXBias;
200 G4Mutex mutex; << 175 G4PhysicsOrderedFreeVector XBiasH;
201 // Protect shared resources << 176 G4PhysicsOrderedFreeVector IPDFXBiasH;
>> 177 G4bool YBias, IPDFYBias;
>> 178 G4PhysicsOrderedFreeVector YBiasH;
>> 179 G4PhysicsOrderedFreeVector IPDFYBiasH;
>> 180 G4bool ZBias, IPDFZBias;
>> 181 G4PhysicsOrderedFreeVector ZBiasH;
>> 182 G4PhysicsOrderedFreeVector IPDFZBiasH;
>> 183 G4bool ThetaBias, IPDFThetaBias;
>> 184 G4PhysicsOrderedFreeVector ThetaBiasH;
>> 185 G4PhysicsOrderedFreeVector IPDFThetaBiasH;
>> 186 G4bool PhiBias, IPDFPhiBias;
>> 187 G4PhysicsOrderedFreeVector PhiBiasH;
>> 188 G4PhysicsOrderedFreeVector IPDFPhiBiasH;
>> 189 G4bool EnergyBias, IPDFEnergyBias;
>> 190 G4PhysicsOrderedFreeVector EnergyBiasH;
>> 191 G4PhysicsOrderedFreeVector IPDFEnergyBiasH;
>> 192 G4bool PosThetaBias, IPDFPosThetaBias;
>> 193 G4PhysicsOrderedFreeVector PosThetaBiasH;
>> 194 G4PhysicsOrderedFreeVector IPDFPosThetaBiasH;
>> 195 G4bool PosPhiBias, IPDFPosPhiBias;
>> 196 G4PhysicsOrderedFreeVector PosPhiBiasH;
>> 197 G4PhysicsOrderedFreeVector IPDFPosPhiBiasH;
>> 198
>> 199 G4double bweights[8]; //record x,y,z,theta,phi,energy,posThet, posPhi weights
>> 200
>> 201 // Verbosity
>> 202 G4int verbosityLevel;
>> 203
>> 204 G4PhysicsOrderedFreeVector ZeroPhysVector ; // for re-set only
>> 205
202 }; 206 };
203 207
>> 208
204 #endif 209 #endif
>> 210
>> 211
>> 212
>> 213
205 214