CLHEP VERSION Reference Documentation
   
CLHEP Home Page     CLHEP Documentation     CLHEP Bug Reports

testSaveEngineStatus.cc
Go to the documentation of this file.
1 // ----------------------------------------------------------------------
2 #include "CLHEP/Random/Randomize.h"
3 #include "CLHEP/Random/NonRandomEngine.h"
4 #include "CLHEP/Random/defs.h"
5 #include <iostream>
6 #include <iomanip>
7 #include <vector>
8 
9 #define CLEAN_OUTPUT
10 #ifdef CLEAN_OUTPUT
11  std::ofstream output("testSaveEngineStatus.cout");
12 #else
13  std::ostream & output = std::cout;
14 #endif
15 
16 // Normally on for routine validation:
17 
18 #define TEST_ORIGINAL_SAVE
19 
20 // Normally off for routine validation:
21 
22 #ifdef TURNOFF
23 #define TEST_MISSING_FILES
24 #define CREATE_OLD_SAVES
25 #define VERIFY_OLD_SAVES
26 #endif
27 
28 #define VERBOSER
29 #define VERBOSER2
30 
31 using namespace CLHEP;
32 
37 
38 // Absolutely Safe Equals Without Registers Screwing Us Up
39 bool equals01(const std::vector<double> &ab) {
40  return ab[1]==ab[0];
41 }
42 bool equals(double a, double b) {
43  std::vector<double> ab(2);
44  ab[0]=a; ab[1]=b;
45  return (equals01(ab));
46 }
47 
48 // ------------------- The following should all FAIL ------------
49 
50 int saveStepX() {
51  double r = RandGauss::shoot();
52  output << "r(1) = " << r << std::endl;
54  r = RandGauss::shoot();
55  output << "r(2) = " << r << std::endl;
56  remembered_r2 = r;
57  r = RandGauss::shoot();
58  output << "r(3) = " << r << std::endl;
59  for (int i=0; i < 1001; i++) {
60  r = RandGauss::shoot();
61  }
62  r = RandGauss::shoot();
63  remembered_r1005 = r;
64  output << "r1005= " << r << std::endl;
65  r = RandGauss::shoot();
66  return 0;
67 }
68 
69 int restoreStepX() {
71  double r = RandGauss::shoot();
72  output << "restored r(2) = " << r << std::endl;
73  if ( ! equals(r,remembered_r2) ) {
74  output << "THIS DOES NOT MATCH REMEMBERED VALUE BUT THAT IS EXPECTED\n";
75  }
76  r = RandGauss::shoot();
77  output << "restored r(3) = " << r << std::endl;
78  for (int i=0; i < 1001; i++) {
79  r = RandGauss::shoot();
80  }
81  r = RandGauss::shoot();
82  output << "restored r1005= " << r << std::endl;
83  if ( !equals(r,remembered_r1005) ) {
84  output << "THIS DOES NOT MATCH REMEMBERED VALUE BUT THAT IS EXPECTED\n";
85  }
86  return 0;
87 }
88 
89 int BsaveStepX() {
90  int r = RandFlat::shootBit();
91  output << "r(1) = " << r << std::endl;
93  r = RandFlat::shootBit();
94  output << "r(2) = " << r << std::endl;
95  remembered_r2 = r;
96  r = RandFlat::shootBit();
97  output << "r(3) = " << r << std::endl;
98  double d;
99  for (int i=0; i < 1001; i++) {
100  d = RandFlat::shoot();
101  if (d > 1) output <<
102  "This line inserted so clever compilers don't warn about not using d\n";
103  }
104  r = RandFlat::shootBit();
105  remembered_r1005 = r;
106  output << "r1005= " << r << std::endl;
107  r = RandFlat::shootBit();
108  return 0;
109 }
110 
113  int r = RandFlat::shootBit();
114  output << "restored r(2) = " << r << std::endl;
115  if ( r != remembered_r2 ) {
116  output << "THIS DOES NOT MATCH REMEMBERED VALUE BUT THAT IS EXPECTED\n";
117  }
118  r = RandFlat::shootBit();
119  output << "restored r(3) = " << r << std::endl;
120  for (int i=0; i < 1001; i++) {
121  r = RandFlat::shootBit();
122  }
123  r = RandFlat::shootBit();
124  output << "restored r1005= " << r << std::endl;
125  if ( r != remembered_r1005 ) {
126  output << "THIS DOES NOT MATCH REMEMBERED VALUE BUT THAT IS EXPECTED\n";
127  }
128  return 0;
129 }
130 
131 // ------------------- The following should all WORK ------------
132 
133 int saveStep() {
134  int stat=0;
135  double r = RandGauss::shoot();
136  output << "r(1) = " << r << std::endl;
138  r = RandGauss::shoot();
139  output << "r(2) = " << r << std::endl;
140  remembered_r2 = r;
141  r = RandGauss::shoot();
142  output << "r(3) = " << r << std::endl;
143  for (int i=0; i < 1001; i++) {
144  r = RandGauss::shoot();
145  }
146  r = RandGauss::shoot();
147  remembered_r1005 = r;
148  output << "r1005= " << r << std::endl;
149  r = RandGauss::shoot();
150  return stat;
151 }
152 
153 int restoreStep() {
154  int stat=0;
156  double r = RandGauss::shoot();
157  output << "restored r(2) = " << r << std::endl;
158  if ( !equals(r,remembered_r2) ) {
159  std::cout << "restored r(2) = " << r << std::endl;
160  std::cout << "????? THIS DOES NOT MATCH REMEMBERED VALUE!\n";
161  #ifdef CLEAN_OUTPUT
162  output << "restored r(2) = " << r << std::endl;
163  output << "????? THIS DOES NOT MATCH REMEMBERED VALUE!\n";
164  #endif
165  stat += 1;
166  }
167  r = RandGauss::shoot();
168  output << "restored r(3) = " << r << std::endl;
169  for (int i=0; i < 1001; i++) {
170  r = RandGauss::shoot();
171  }
172  r = RandGauss::shoot();
173  output << "restored r1005= " << r << std::endl;
174  if ( !equals(r,remembered_r1005) ) {
175  std::cout << "restored r1005= " << r << std::endl;
176  std::cout << "????? THIS DOES NOT MATCH REMEMBERED VALUE!\n";
177  #ifdef CLEAN_OUTPUT
178  output << "restored r1005= " << r << std::endl;
179  output << "????? THIS DOES NOT MATCH REMEMBERED VALUE!\n";
180  #endif
181  stat += 2;
182  }
183  return stat;
184 }
185 
186 int BsaveStep() {
187  int stat=0;
188  int r = RandFlat::shootBit();
189  output << "r(1) = " << r << std::endl;
191  r = RandFlat::shootBit();
192  output << "r(2) = " << r << std::endl;
193  remembered_r2 = r;
194  r = RandFlat::shootBit();
195  output << "r(3) = " << r << std::endl;
196  for (int i=0; i < 1001; i++) {
197  r = RandFlat::shootBit();
198  }
199  r = RandFlat::shootBit();
200  remembered_r1005 = r;
201  output << "r1005 = " << r << std::endl;
202  r = RandFlat::shootBit();
203  remembered_r1006 = r;
204  output << "r1006 = " << r << std::endl;
205  r = RandFlat::shootBit();
206  remembered_r1007 = r;
207  output << "r1007 = " << r << std::endl;
208  r = RandFlat::shootBit();
209  return stat;
210 }
211 
213  int stat=0;
215  int r = RandFlat::shootBit();
216  output << "restored r(2) = " << r << std::endl;
217  if ( r != remembered_r2 ) {
218  stat += 4;
219  std::cout << "restored r(2) = " << r << std::endl;
220  std::cout << "????? THIS DOES NOT MATCH REMEMBERED VALUE!\n";
221  #ifdef CLEAN_OUTPUT
222  output << "restored r(2) = " << r << std::endl;
223  output << "????? THIS DOES NOT MATCH REMEMBERED VALUE!\n";
224  #endif
225  }
226  r = RandFlat::shootBit();
227  output << "restored r(3) = " << r << std::endl;
228  for (int i=0; i < 1001; i++) {
229  r = RandFlat::shootBit();
230  }
231  r = RandFlat::shootBit();
232  output << "restored r1005= " << r << std::endl;
233  if ( r != remembered_r1005 ) {
234  stat += 8;
235  std::cout << "restored r1005= " << r << std::endl;
236  std::cout << "????? THIS DOES NOT MATCH REMEMBERED VALUE!\n";
237  #ifdef CLEAN_OUTPUT
238  output << "restored r1005= " << r << std::endl;
239  output << "????? THIS DOES NOT MATCH REMEMBERED VALUE!\n";
240  #endif
241  }
242  r = RandFlat::shootBit();
243  output << "restored r1006= " << r << std::endl;
244  if ( r != remembered_r1006 ) {
245  stat += 16;
246  std::cout << "restored r1006= " << r << std::endl;
247  std::cout << "????? THIS DOES NOT MATCH REMEMBERED VALUE!\n";
248  #ifdef CLEAN_OUTPUT
249  output << "restored r1006= " << r << std::endl;
250  output << "????? THIS DOES NOT MATCH REMEMBERED VALUE!\n";
251  #endif
252  }
253  r = RandFlat::shootBit();
254  output << "restored r1007= " << r << std::endl;
255  if ( r != remembered_r1007 ) {
256  stat += 32;
257  std::cout << "restored r1007= " << r << std::endl;
258  std::cout << "????? THIS DOES NOT MATCH REMEMBERED VALUE!\n";
259  #ifdef CLEAN_OUTPUT
260  output << "restored r1007= " << r << std::endl;
261  output << "????? THIS DOES NOT MATCH REMEMBERED VALUE!\n";
262  #endif
263  }
264  return stat;
265 }
266 
267 // --- The following should work, by failing in an expected way -------
268 
269 template <class E, class D>
271  int stat = 0;
272  HepRandomEngine * old = D::getTheEngine();
273  E e(123);
274  output << "File-not-found test restoring "<<D::distributionName()<<":\n";
275  D::setTheEngine(&e);
276  D::restoreEngineStatus("noSuchFile");
277  D::setTheEngine(old); // If we don't do this, then the static engine shared
278  // by every shoot() method reamins e -- which is about
279  // to go out of scope and be destructed!
280  return stat;
281 }
282 
283 template <class E>
285  int stat = 0;
286  stat |= fileNotThere <E, RandBinomial>();
287  stat |= fileNotThere <E, RandBit>();
288  stat |= fileNotThere <E, RandBreitWigner>();
289  stat |= fileNotThere <E, RandChiSquare>();
290  stat |= fileNotThere <E, RandExponential>();
291  stat |= fileNotThere <E, RandFlat>();
292  stat |= fileNotThere <E, RandGamma>();
293  stat |= fileNotThere <E, RandGauss>();
294  stat |= fileNotThere <E, RandGaussQ>();
295  stat |= fileNotThere <E, RandGaussT>();
296  stat |= fileNotThere <E, RandLandau>();
297  stat |= fileNotThere <E, RandPoisson>();
298  stat |= fileNotThere <E, RandPoissonQ>();
299  stat |= fileNotThere <E, RandPoissonT>();
300  stat |= fileNotThere <E, RandSkewNormal>();
301  stat |= fileNotThere <E, RandStudentT>();
302  return stat;
303 }
304 
305 int missingFile() {
306  int stat = 0;
307  stat |= fileNotThereEngine<DRand48Engine>();
308  stat |= fileNotThereEngine<DualRand>();
309  stat |= fileNotThereEngine<Hurd160Engine>();
310  stat |= fileNotThereEngine<Hurd288Engine>();
311  stat |= fileNotThereEngine<HepJamesRandom>();
312  stat |= fileNotThereEngine<MTwistEngine>();
313  stat |= fileNotThereEngine<RandEngine>();
314  stat |= fileNotThereEngine<RanecuEngine>();
315  stat |= fileNotThereEngine<Ranlux64Engine>();
316  stat |= fileNotThereEngine<RanluxEngine>();
317  stat |= fileNotThereEngine<RanshiEngine>();
318  stat |= fileNotThereEngine<TripleRand>();
319  return stat;
320 }
321 
322 // -- The following was used to capture old-form engine states (sans name) --
323 
324 template <class E, class D>
325 int saveEngine(const char* filename) {
326  int stat = 0;
327  HepRandomEngine * old = D::getTheEngine();
328  E e(123);
329  D::setTheEngine(&e);
330  double r=0;
331  for (int i=0; i<3; i++) r += D::shoot();
332  D::saveEngineStatus(filename);
333  if (r == -99999999.1) stat = 999; // This prevents clever compilers from
334  // deducing that r is never needed
335  D::setTheEngine(old); // If we don't do this, then the static engine shared
336  // by every shoot() method reamins e -- which is about
337  // to go out of scope and be destructed!
338  return stat;
339 }
340 
341 // -- The following checks on static engine restores, from old and new forms --
342 
343 template <class E, class D>
344 int checkSaveEngine(const char* filename) {
345  int stat = 0;
346  HepRandomEngine * old = D::getTheEngine();
347 
348  // Generate save with current format (default file name is fine)
349  E e(123);
350  D::setTheEngine(&e);
351  double r=0;
352  for (int i=0; i<3; i++) r += D::shoot();
353  D::saveEngineStatus();
354 
355  // Figure out what the key variate value should be
356  double keyValue = D::shoot();
357 
358  // Restore state based on old file, and check for proper value
359  D::restoreEngineStatus(filename);
360  if (!equals(D::shoot(), keyValue)) {
361  std::cout << "???? Value mismatch from file " << filename << "\n";
362  #ifdef CLEAN_OUTPUT
363  output << "???? Value mismatch from file " << filename << "\n";
364  #endif
365  stat |= 64;
366  }
367 
368  // Restore state based on that save, and check for proper value
369  D::restoreEngineStatus();
370  if (!equals(D::shoot(),keyValue)) {
371  std::cout << "???? Value mismatch from new-format file \n";
372  #ifdef CLEAN_OUTPUT
373  output << "???? Value mismatch from new-format file \n";
374  #endif
375  stat |= 128;
376  }
377 
378  D::setTheEngine(old);
379  return stat;
380 }
381 
382 // ---------------------------------------------
383 // ---------------------------------------------
384 // ---------------------------------------------
385 
386 
387 int main() {
388  int stat = 0;
389 
390 #ifdef TEST_ORIGINAL_SAVE
391  output << "=====================================\n";
392  output << " Part I \n";
393  output << "Original tests of static save/restore\n";
394  output << "=====================================\n\n";
395 
396  output << "Using old method or HepRandom::saveEngineStatus:\n";
397  output << "All these tests should have a chance of failure.\n";
398 
401 
402  stat |= saveStepX();
403  stat |= restoreStepX();
404  stat |= BsaveStepX();
405  stat |= BrestoreStepX();
406 
407  output << "Using the class-specific RandGauss::saveEngineStatus:\n";
408  output << "All these tests should work properly.\n";
409 
410  stat |= saveStep();
411  stat |= restoreStep();
412  stat |= BsaveStep();
413  stat |= BrestoreStep();
414 #endif
415 
416 #ifdef TEST_MISSING_FILES
417  output << "\n=======================================\n";
418  output << " Part Ia \n";
419  output << "Test of behavior when a file is missing \n";
420  output << "=======================================\n\n";
421 
422  output << "Testing restoreEngineStatus with missing file:\n";
423  output << "Expect a number of <Failure to find or open> messages!\n";
424  stat |= missingFile();
425 #endif
426 
427 #ifdef CREATE_OLD_SAVES
428  stat |= saveEngine<DRand48Engine, RandPoisson>("DRand48Engine.oldsav");
429  stat |= saveEngine<DualRand, RandPoisson>("DualRand.oldsav");
430  stat |= saveEngine<Hurd160Engine, RandPoisson>("Hurd160Engine.oldsav");
431  stat |= saveEngine<Hurd288Engine, RandPoisson>("Hurd288Engine.oldsav");
432  stat |= saveEngine<HepJamesRandom,RandPoisson>("HepJamesRandom.oldsav");
433  stat |= saveEngine<MTwistEngine, RandPoisson>("MTwistEngine.oldsav");
434  stat |= saveEngine<RanecuEngine, RandPoisson>("RanecuEngine.oldsav");
435  stat |= saveEngine<Ranlux64Engine,RandPoisson>("Ranlux64Engine.oldsav");
436  stat |= saveEngine<RanluxEngine, RandPoisson>("RanluxEngine.oldsav");
437  stat |= saveEngine<RanshiEngine, RandPoisson>("RanshiEngine.oldsav");
438  stat |= saveEngine<TripleRand, RandPoisson>("TripleRand.oldsav");
439 #endif
440 
441 #ifdef VERIFY_OLD_SAVES
442  output << "\n==============================================\n";
443  output << " Part Ib \n";
444  output << " Verification that changes wont invalidate \n";
445  output << "invalidate engine saves from previous versions \n";
446  output << "==============================================\n\n";
447 
448  stat |= checkSaveEngine<DRand48Engine, RandPoisson>("DRand48Engine.oldsav");
449  stat |= checkSaveEngine<DualRand, RandPoisson>("DualRand.oldsav");
450  stat |= checkSaveEngine<Hurd160Engine, RandPoisson>("Hurd160Engine.oldsav");
451  stat |= checkSaveEngine<Hurd288Engine, RandPoisson>("Hurd288Engine.oldsav");
452  stat |= checkSaveEngine<HepJamesRandom,RandPoisson>("HepJamesRandom.oldsav");
453  stat |= checkSaveEngine<MTwistEngine, RandPoisson>("MTwistEngine.oldsav");
454  stat |= checkSaveEngine<Ranlux64Engine,RandPoisson>("Ranlux64Engine.oldsav");
455  stat |= checkSaveEngine<RanluxEngine, RandPoisson>("RanluxEngine.oldsav");
456  stat |= checkSaveEngine<RanshiEngine, RandPoisson>("RanshiEngine.oldsav");
457  stat |= checkSaveEngine<TripleRand, RandPoisson>("TripleRand.oldsav");
458  stat |= checkSaveEngine<RanecuEngine, RandPoisson>("RanecuEngine.oldsav");
459 #endif
460 
461  output << "\n=============================================\n\n";
462 
463  if (stat != 0) {
464  std::cout << "One or more problems detected: stat = " << stat << "\n";
465  output << "One or more problems detected: stat = " << stat << "\n";
466  } else {
467  output << "testSaveEngineStatus passed with no problems detected.\n";
468  }
469 
470  if (stat == 0) return 0;
471  if (stat > 0) return -(stat|1);
472  return stat|1;
473 }
474 
virtual std::string name() const =0
static HepRandomEngine * getTheEngine()
Definition: Random.cc:166
static void restoreEngineStatus(const char filename[]="Config.conf")
Definition: Random.cc:181
static void saveEngineStatus(const char filename[]="Config.conf")
Definition: Random.cc:176
static int shootBit()
static void restoreEngineStatus(const char filename[]="Config.conf")
Definition: RandFlat.cc:119
static void saveEngineStatus(const char filename[]="Config.conf")
Definition: RandFlat.cc:104
static double shoot()
Definition: RandFlat.cc:60
static void restoreEngineStatus(const char filename[]="Config.conf")
Definition: RandGauss.cc:190
static double shoot()
Definition: RandGauss.cc:61
static void saveEngineStatus(const char filename[]="Config.conf")
Definition: RandGauss.cc:170
@ b
@ a
int saveStepX()
int restoreStep()
int saveEngine(const char *filename)
int missingFile()
int BrestoreStep()
int fileNotThereEngine()
int BsaveStep()
double remembered_r2
double remembered_r1007
double remembered_r1006
int checkSaveEngine(const char *filename)
int BsaveStepX()
int restoreStepX()
bool equals(double a, double b)
bool equals01(const std::vector< double > &ab)
int saveStep()
int fileNotThere()
double remembered_r1005
std::ofstream output("testSaveEngineStatus.cout")
int main()
int BrestoreStepX()