| Geant4 Cross Reference |
>> 1 // $Id:$
1 // -*- C++ -*- 2 // -*- C++ -*-
2 // 3 //
3 // ------------------------------------------- 4 // -----------------------------------------------------------------------
4 // HEP Random 5 // HEP Random
5 // --- HepRandom --- 6 // --- HepRandom ---
6 // class implementation f 7 // class implementation file
7 // ------------------------------------------- 8 // -----------------------------------------------------------------------
8 // This file is part of Geant4 (simulation too 9 // This file is part of Geant4 (simulation toolkit for HEP).
9 10
10 // =========================================== 11 // =======================================================================
11 // Gabriele Cosmo - Created: 5th September 199 12 // Gabriele Cosmo - Created: 5th September 1995
12 // - Minor corrections: 31st Oc 13 // - Minor corrections: 31st October 1996
13 // - Added methods for engine s 14 // - Added methods for engine status: 19th November 1996
14 // - HepRandom defined as singl 15 // - HepRandom defined as singleton, constructors are
15 // kept public for backward c 16 // kept public for backward compatibility: 27th Feb 1998
16 // - Relocated Poisson and Gaus 17 // - Relocated Poisson and Gauss data and simplified
17 // initialisation of static g 18 // initialisation of static generator: 5th Jan 1999
18 // =========================================== 19 // =======================================================================
19 20
20 #include "CLHEP/Random/MixMaxRng.h" << 21 #include "CLHEP/Random/JamesRandom.h"
21 #include "CLHEP/Random/Random.h" 22 #include "CLHEP/Random/Random.h"
22 #include "CLHEP/Random/StaticRandomStates.h" 23 #include "CLHEP/Random/StaticRandomStates.h"
23 #include "CLHEP/Utility/memory.h" 24 #include "CLHEP/Utility/memory.h"
24 #include "CLHEP/Utility/thread_local.h" <<
25 #include "CLHEP/Utility/use_atomic.h" <<
26 25
27 // ----------------------------- 26 // -----------------------------
28 // Static members initialisation 27 // Static members initialisation
29 // ----------------------------- 28 // -----------------------------
30 29
31 #include "CLHEP/Random/SeedTable.h" 30 #include "CLHEP/Random/SeedTable.h"
32 31
33 #include <assert.h> <<
34 #include <iostream> <<
35 #include <type_traits> <<
36 #include <string> <<
37 <<
38 namespace CLHEP { 32 namespace CLHEP {
39 33
40 namespace { <<
41 34
42 struct defaults { << 35 namespace {
43 36
44 defaults() << 37 struct defaults {
45 : theGenerator( &theDefaultGenerator, << 38 defaults( HepRandom & g, HepJamesRandom & e )
46 , theEngine ( &theDefaultEngine, do_ << 39 : theGenerator( &g, do_nothing_deleter() )
47 { } << 40 , theEngine ( &e, do_nothing_deleter() )
48 << 41 { }
49 defaults(defaults const& other) = delete <<
50 defaults const& operator=(defaults const <<
51 <<
52 void resetEngine( HepRandomEngine * new <<
53 theEngine.reset( newEngine ); <<
54 } <<
55 <<
56 void resetEngine( HepRandomEngine & new <<
57 theEngine.reset( &newEngine, do_nothin <<
58 } <<
59 <<
60 bool ensureInitialized() { <<
61 assert( theGenerator.get() != 0 && th <<
62 return true; <<
63 } <<
64 <<
65 ~defaults() <<
66 { } <<
67 <<
68 private: <<
69 <<
70 HepRandom theDefaultGenerator; <<
71 MixMaxRng theDefaultEngine; <<
72 <<
73 public: <<
74 <<
75 std::shared_ptr<HepRandom > theGen <<
76 std::shared_ptr<HepRandomEngine> theEng <<
77 }; // defaults <<
78 <<
79 <<
80 #ifdef CLHEP_USE_ATOMIC <<
81 <<
82 // The ThreadSafeDefaultCache is used only <<
83 // It is a singly linked list that is inte <<
84 // type "defaults" per thread. <<
85 <<
86 class ThreadSafeDefaultsCache { <<
87 public: <<
88 <<
89 ThreadSafeDefaultsCache(); <<
90 <<
91 // The destructor deletes the objects of <<
92 ~ThreadSafeDefaultsCache(); <<
93 <<
94 // Creates new objects and adds them to <<
95 defaults* createNewDefaults(); <<
96 <<
97 // Note that there are no other function <<
98 <<
99 private: <<
100 <<
101 class DefaultsNode { <<
102 public: <<
103 DefaultsNode(DefaultsNode* iNext); <<
104 DefaultsNode const* next() const { ret <<
105 void setNext(DefaultsNode* v) { next_ <<
106 defaults* addressOfDefaults() { return <<
107 private: <<
108 DefaultsNode* next_; <<
109 defaults defaults_; <<
110 }; <<
111 <<
112 // points to first node in the linked li <<
113 std::atomic<DefaultsNode*> front_; <<
114 }; <<
115 <<
116 ThreadSafeDefaultsCache::ThreadSafeDefault <<
117 front_(nullptr) { <<
118 } <<
119 <<
120 defaults* ThreadSafeDefaultsCache::createN <<
121 DefaultsNode* expected = front_.load(); <<
122 DefaultsNode* newNode = new DefaultsNode <<
123 while (!front_.compare_exchange_strong(e <<
124 // another thread changed front_ befor <<
125 newNode->setNext(expected); <<
126 } <<
127 return newNode->addressOfDefaults(); <<
128 } <<
129 <<
130 ThreadSafeDefaultsCache::DefaultsNode::Def <<
131 next_(iNext), <<
132 defaults_() { <<
133 } <<
134 <<
135 ThreadSafeDefaultsCache::~ThreadSafeDefaul <<
136 DefaultsNode const* node = front_.load() <<
137 while (node) { <<
138 DefaultsNode const* next = node->next( <<
139 delete node; <<
140 node = next; <<
141 } <<
142 } <<
143 <<
144 defaults & theDefaults() { <<
145 <<
146 // We need to have different engines on <<
147 // the engines are not thread safe. One <<
148 // using the same engine on different th <<
149 // Originally we had the defaults object <<
150 // but that was failing because on Mac O <<
151 // support for thread locals yet. Objec <<
152 // in thread local storage were causing <<
153 // a container of them that is a functio <<
154 // and the thread local contains only a <<
155 // container. <<
156 static ThreadSafeDefaultsCache defaultsF <<
157 <<
158 // A pointer for each thread to defaults <<
159 static CLHEP_THREAD_LOCAL defaults* theD <<
160 <<
161 return *theDefaults; <<
162 } <<
163 #else <<
164 <<
165 // This version is used with old compilers <<
166 // In that case, the code should not be ex <<
167 defaults & theDefaults() { <<
168 static defaults theDefaults; <<
169 return theDefaults; <<
170 } <<
171 42
172 #endif << 43 void resetEngine( HepRandomEngine * newEngine ) {
>> 44 theEngine.reset( newEngine );
>> 45 }
173 46
174 } // namespace << 47 void resetEngine( HepRandomEngine & newEngine ) {
>> 48 theEngine.reset( &newEngine, do_nothing_deleter() );
>> 49 }
>> 50
>> 51 bool ensureInitialized() {
>> 52 assert( theGenerator.get() != 0 && theEngine.get() != 0 );
>> 53 return true;
>> 54 }
>> 55
>> 56 ~defaults()
>> 57 { }
>> 58
>> 59 shared_ptr<HepRandom > theGenerator;
>> 60 shared_ptr<HepRandomEngine> theEngine;
>> 61 }; // defaults
>> 62
>> 63 inline
>> 64 defaults & theDefaults() {
>> 65 static HepRandom theDefaultGenerator;
>> 66 static HepJamesRandom theDefaultEngine;
>> 67 static defaults theDefaults(theDefaultGenerator, theDefaultEngine);
>> 68 return theDefaults;
>> 69 }
>> 70
>> 71 } // namespace
175 72
176 //---------------------------- HepRandom ----- 73 //---------------------------- HepRandom ---------------------------------
177 74
178 HepRandom::HepRandom() 75 HepRandom::HepRandom()
179 { } 76 { }
180 77
181 HepRandom::HepRandom(long seed) 78 HepRandom::HepRandom(long seed)
182 { 79 {
183 setTheSeed(seed); 80 setTheSeed(seed);
184 } 81 }
185 82
186 HepRandom::HepRandom(HepRandomEngine & algorit 83 HepRandom::HepRandom(HepRandomEngine & algorithm)
187 { 84 {
188 theDefaults().resetEngine( algorithm ); 85 theDefaults().resetEngine( algorithm );
189 } 86 }
190 87
191 HepRandom::HepRandom(HepRandomEngine * algorit 88 HepRandom::HepRandom(HepRandomEngine * algorithm)
192 { 89 {
193 theDefaults().resetEngine( algorithm ); 90 theDefaults().resetEngine( algorithm );
194 } 91 }
195 92
196 HepRandom::~HepRandom() << 93 HepRandom::~HepRandom()
197 { } 94 { }
198 95
199 double HepRandom::flat() 96 double HepRandom::flat()
200 { 97 {
201 return theDefaults().theEngine->flat(); 98 return theDefaults().theEngine->flat();
202 } 99 }
203 100
204 void HepRandom::flatArray(const int size, doub 101 void HepRandom::flatArray(const int size, double* vect)
205 { 102 {
206 theDefaults().theEngine->flatArray(size,vect 103 theDefaults().theEngine->flatArray(size,vect);
207 } 104 }
208 105
209 double HepRandom::operator()() { 106 double HepRandom::operator()() {
210 return flat(); 107 return flat();
211 } 108 }
212 109
213 std::string HepRandom::name() const {return "H 110 std::string HepRandom::name() const {return "HepRandom";}
214 HepRandomEngine & HepRandom::engine() { 111 HepRandomEngine & HepRandom::engine() {
215 std::cerr << "HepRandom::engine() called -- 112 std::cerr << "HepRandom::engine() called -- there is no assigned engine!\n";
216 return *theDefaults().theEngine.get(); 113 return *theDefaults().theEngine.get();
217 } << 114 }
218 115
219 std::ostream & operator<< (std::ostream & os, 116 std::ostream & operator<< (std::ostream & os, const HepRandom & dist) {
220 return dist.put(os); 117 return dist.put(os);
221 } 118 }
222 119
223 std::istream & operator>> (std::istream & is, 120 std::istream & operator>> (std::istream & is, HepRandom & dist) {
224 return dist.get(is); 121 return dist.get(is);
225 } 122 }
226 123
227 std::ostream & HepRandom::put(std::ostream & o 124 std::ostream & HepRandom::put(std::ostream & os) const {return os;}
228 std::istream & HepRandom::get(std::istream & i 125 std::istream & HepRandom::get(std::istream & is) {return is;}
229 126
230 // -------------------------- 127 // --------------------------
231 // Static methods definitions 128 // Static methods definitions
232 // -------------------------- 129 // --------------------------
233 130
234 void HepRandom::setTheSeed(long seed, int lux) 131 void HepRandom::setTheSeed(long seed, int lux)
235 { 132 {
236 theDefaults().theEngine->setSeed(seed,lux); 133 theDefaults().theEngine->setSeed(seed,lux);
237 } 134 }
238 135
239 long HepRandom::getTheSeed() 136 long HepRandom::getTheSeed()
240 { 137 {
241 return theDefaults().theEngine->getSeed(); 138 return theDefaults().theEngine->getSeed();
242 } 139 }
243 140
244 void HepRandom::setTheSeeds(const long* seeds, 141 void HepRandom::setTheSeeds(const long* seeds, int aux)
245 { 142 {
246 theDefaults().theEngine->setSeeds(seeds,aux) 143 theDefaults().theEngine->setSeeds(seeds,aux);
247 } 144 }
248 145
249 const long* HepRandom::getTheSeeds () 146 const long* HepRandom::getTheSeeds ()
250 { 147 {
251 return theDefaults().theEngine->getSeeds(); 148 return theDefaults().theEngine->getSeeds();
252 } 149 }
253 150
254 void HepRandom::getTheTableSeeds(long* seeds, 151 void HepRandom::getTheTableSeeds(long* seeds, int index)
255 { 152 {
256 if ((index >= 0) && (index < 215)) { 153 if ((index >= 0) && (index < 215)) {
257 seeds[0] = seedTable[index][0]; 154 seeds[0] = seedTable[index][0];
258 seeds[1] = seedTable[index][1]; 155 seeds[1] = seedTable[index][1];
259 } 156 }
260 else seeds = NULL; 157 else seeds = NULL;
261 } 158 }
262 159
263 HepRandom * HepRandom::getTheGenerator() 160 HepRandom * HepRandom::getTheGenerator()
264 { 161 {
265 return theDefaults().theGenerator.get(); 162 return theDefaults().theGenerator.get();
266 } 163 }
267 164
268 HepRandomEngine * HepRandom::getTheEngine() 165 HepRandomEngine * HepRandom::getTheEngine()
269 { 166 {
270 return theDefaults().theEngine.get(); 167 return theDefaults().theEngine.get();
271 } 168 }
272 169
273 void HepRandom::setTheEngine (HepRandomEngine* 170 void HepRandom::setTheEngine (HepRandomEngine* theNewEngine)
274 { 171 {
275 theDefaults().theEngine.reset( theNewEngine, 172 theDefaults().theEngine.reset( theNewEngine, do_nothing_deleter() );
276 } 173 }
277 174
278 void HepRandom::saveEngineStatus( const char f 175 void HepRandom::saveEngineStatus( const char filename[] )
279 { 176 {
280 theDefaults().theEngine->saveStatus( filenam 177 theDefaults().theEngine->saveStatus( filename );
281 } << 178 }
282 179
283 void HepRandom::restoreEngineStatus( const cha 180 void HepRandom::restoreEngineStatus( const char filename[] )
284 { 181 {
285 theDefaults().theEngine->restoreStatus( file 182 theDefaults().theEngine->restoreStatus( filename );
286 } << 183 }
287 184
288 std::ostream& HepRandom::saveFullState ( std:: 185 std::ostream& HepRandom::saveFullState ( std::ostream & os ) {
289 os << *getTheEngine(); 186 os << *getTheEngine();
290 return os; 187 return os;
291 } 188 }
292 189
293 std::istream& HepRandom::restoreFullState ( st 190 std::istream& HepRandom::restoreFullState ( std::istream & is ) {
294 is >> *getTheEngine(); 191 is >> *getTheEngine();
295 return is; 192 return is;
296 } 193 }
297 194
298 std::ostream& HepRandom::saveStaticRandomState 195 std::ostream& HepRandom::saveStaticRandomStates ( std::ostream & os ) {
299 return StaticRandomStates::save(os); 196 return StaticRandomStates::save(os);
300 } 197 }
301 198
302 std::istream& HepRandom::restoreStaticRandomSt 199 std::istream& HepRandom::restoreStaticRandomStates ( std::istream & is ) {
303 return StaticRandomStates::restore(is); 200 return StaticRandomStates::restore(is);
304 } 201 }
305 202
306 void HepRandom::showEngineStatus() 203 void HepRandom::showEngineStatus()
307 { 204 {
308 theDefaults().theEngine->showStatus(); 205 theDefaults().theEngine->showStatus();
309 } << 206 }
310 207
311 int HepRandom::createInstance() 208 int HepRandom::createInstance()
312 { 209 {
313 return static_cast<int>( theDefaults().ensur 210 return static_cast<int>( theDefaults().ensureInitialized() );
314 } 211 }
315 212
316 } // namespace CLHEP 213 } // namespace CLHEP
317 214