Classes | Public Types | Public Member Functions | Static Public Attributes | Private Member Functions | Private Attributes | Friends | List of all members
art::RandomNumberGenerator Class Reference

#include "/cvmfs/nova.opensciencegrid.org/externals/art/v3_05_01/source/art/Framework/Services/Optional/RandomNumberGenerator.h"

Classes

struct  Config
 
struct  ScheduleData
 

Public Types

enum  EngineSource { EngineSource::Seed = 1, EngineSource::File = 2, EngineSource::Product = 3 }
 
using base_engine_t = CLHEP::HepRandomEngine
 
using seed_t = long
 
using Parameters = ServiceTable< Config >
 

Public Member Functions

 RandomNumberGenerator (Parameters const &, ActivityRegistry &)
 
 RandomNumberGenerator (RandomNumberGenerator const &)=delete
 
 RandomNumberGenerator (RandomNumberGenerator &&)=delete
 
RandomNumberGeneratoroperator= (RandomNumberGenerator const &)=delete
 
RandomNumberGeneratoroperator= (RandomNumberGenerator &&)=delete
 
std::string const & defaultEngineKind () const noexcept
 

Static Public Attributes

static long constexpr maxCLHEPSeed {900000000}
 
static long constexpr useDefaultSeed {-1}
 

Private Member Functions

CLHEP::HepRandomEnginecreateEngine (ScheduleID sid, std::string const &module_label, long seed, std::string const &kind_of_engine_to_make, std::string const &engine_label={})
 
void validate_ (std::string const &user_specified_engine_kind, long user_specified_seed) noexcept(false)
 
void takeSnapshot_ (ScheduleID)
 
void restoreSnapshot_ (ScheduleID, Event const &)
 
std::vector< RNGsnapshot > const & accessSnapshot_ (ScheduleID) const
 
void saveToFile_ ()
 
void restoreFromFile_ ()
 
void print_ () const
 
bool invariant_holds_ (ScheduleID)
 
void preProcessEvent (Event const &, ScheduleContext)
 
void postProcessEvent (Event const &, ScheduleContext)
 
void postBeginJob ()
 
void postEndJob ()
 

Private Attributes

hep::concurrency::RecursiveMutex mutex_ {"art::rng::mutex_"}
 
std::string const defaultEngineKind_
 
std::string const restoreStateLabel_
 
std::string const saveToFilename_
 
std::string const restoreFromFilename_
 
bool const debug_
 
unsigned const nPrint_
 
bool engine_creation_is_okay_ {true}
 
PerScheduleContainer< ScheduleDatadata_
 

Friends

class EventProcessor
 
class detail::EngineCreator
 
class RandomNumberSaver
 

Detailed Description

Definition at line 162 of file RandomNumberGenerator.h.

Member Typedef Documentation

Definition at line 174 of file RandomNumberGenerator.h.

Definition at line 233 of file RandomNumberGenerator.h.

Definition at line 175 of file RandomNumberGenerator.h.

Member Enumeration Documentation

Enumerator
Seed 
File 
Product 

Definition at line 170 of file RandomNumberGenerator.h.

170 { Seed = 1, File = 2, Product = 3 };
const int File

Constructor & Destructor Documentation

art::RandomNumberGenerator::RandomNumberGenerator ( Parameters const &  config,
ActivityRegistry actReg 
)

Definition at line 121 of file RandomNumberGenerator_service.cc.

References gen_hdf5record::config, data_, debug_, art::Globals::instance(), nPrint_, postBeginJob(), postEndJob(), preProcessEvent(), restoreFromFilename_, restoreStateLabel_, and saveToFilename_.

123  : defaultEngineKind_{config().defaultEngineKind()}
124  , restoreStateLabel_{config().restoreStateLabel()}
125  , saveToFilename_{config().saveTo()}
126  , restoreFromFilename_{config().restoreFrom()}
127  , debug_{config().debug()}
128  , nPrint_{config().nPrint()}
129  {
130  actReg.sPostBeginJob.watch(this, &RandomNumberGenerator::postBeginJob);
131  actReg.sPostEndJob.watch(this, &RandomNumberGenerator::postEndJob);
132  actReg.sPreProcessEvent.watch(this,
134  data_.resize(Globals::instance()->nschedules());
135  }
std::string const restoreFromFilename_
PerScheduleContainer< ScheduleData > data_
void preProcessEvent(Event const &, ScheduleContext)
static Globals * instance()
art::RandomNumberGenerator::RandomNumberGenerator ( RandomNumberGenerator const &  )
delete
art::RandomNumberGenerator::RandomNumberGenerator ( RandomNumberGenerator &&  )
delete

Member Function Documentation

vector< RNGsnapshot > const & art::RandomNumberGenerator::accessSnapshot_ ( ScheduleID  sid) const
private

Definition at line 262 of file RandomNumberGenerator_service.cc.

References data_, and mutex_.

263  {
264  RecursiveMutexSentry sentry{mutex_, __func__};
265  return data_[sid].snapshot_;
266  }
PerScheduleContainer< ScheduleData > data_
hep::concurrency::RecursiveMutex mutex_
CLHEP::HepRandomEngine & art::RandomNumberGenerator::createEngine ( ScheduleID  sid,
std::string const &  module_label,
long  seed,
std::string const &  kind_of_engine_to_make,
std::string const &  engine_label = {} 
)
private

Definition at line 138 of file RandomNumberGenerator_service.cc.

References ana::assert(), data_, defaultEngineKind_, engine_creation_is_okay_, art::ScheduleID::id(), invariant_holds_(), label, mutex_, Seed, CLHEP::HepRandom::setTheEngine(), CLHEP::HepRandom::setTheSeed(), useDefaultSeed, and validate_().

143  {
144  RecursiveMutexSentry sentry{mutex_, __func__};
146  throw cet::exception("RANDOM")
147  << "RNGservice::createEngine():\n"
148  << "Attempt to create engine \"" << engine_label << "\" is too late.\n";
149  }
150  if (sid.id() >= data_.size()) {
151  throw cet::exception("RANDOM")
152  << "RNGservice::createEngine():\n"
153  << "Attempt to create engine with out-of-range ScheduleID: " << sid
154  << "\n";
155  }
156  string const& label = qualify_engine_label(sid, module_label, engine_label);
157  if (data_[sid].tracker_.find(label) != data_[sid].tracker_.cend()) {
158  throw cet::exception("RANDOM")
159  << "RNGservice::createEngine():\n"
160  << "Engine \"" << label << "\" has already been created.\n";
161  }
162  string engineKind{requested_engine_kind};
163  if (requested_engine_kind.empty()) {
164  engineKind = defaultEngineKind_;
165  }
166 
167  validate_(engineKind, seed);
168 
169  shared_ptr<CLHEP::HepRandomEngine> eptr;
170  if (engineKind == "G4Engine"s) {
171  eptr = engine_factory(defaultEngineKind_, seed);
172  // We set CLHEP's random-number engine to be of type
173  // defaultEngineKind_.
174  CLHEP::HepRandom::setTheEngine(eptr.get());
177  }
178  } else if (engineKind == "NonRandomEngine"s) {
179  eptr = std::make_shared<CLHEP::NonRandomEngine>();
180  } else {
181  eptr = engine_factory(engineKind, seed);
182  }
183  if (!eptr) {
184  throw cet::exception("RANDOM")
185  << "RNGservice::createEngine():\n"
186  << "Engine \"" << label << "\" could not be created.\n";
187  }
188  data_[sid].dict_[label] = eptr;
189  data_[sid].tracker_[label] = EngineSource::Seed;
190  data_[sid].kind_[label] = engineKind;
191  mf::LogInfo{"RANDOM"} << "Instantiated " << engineKind << " engine \""
192  << label << "\" with "
193  << ((seed == useDefaultSeed) ? "default seed " :
194  "seed ")
195  << seed << '.';
196  assert(invariant_holds_(sid) &&
197  "RNGservice::createEngine() invariant failed");
198  return *eptr;
199  }
PerScheduleContainer< ScheduleData > data_
::xsd::cxx::tree::exception< char > exception
Definition: Database.h:225
static void setTheSeed(long seed, int lux=3)
static void setTheEngine(HepRandomEngine *theNewEngine)
const char * label
static long constexpr useDefaultSeed
const XML_Char * s
Definition: expat.h:262
unsigned int seed
Definition: runWimpSim.h:102
hep::concurrency::RecursiveMutex mutex_
void validate_(std::string const &user_specified_engine_kind, long user_specified_seed) noexcept(false)
assert(nhit_max >=nhit_nbins)
std::string const& art::RandomNumberGenerator::defaultEngineKind ( ) const
inlinenoexcept

Definition at line 243 of file RandomNumberGenerator.h.

References seed, and string.

244  {
245  return defaultEngineKind_;
246  }
bool art::RandomNumberGenerator::invariant_holds_ ( ScheduleID  sid)
private

Definition at line 114 of file RandomNumberGenerator_service.cc.

Referenced by createEngine(), restoreFromFile_(), and restoreSnapshot_().

115  {
116  RecursiveMutexSentry sentry{mutex_, __func__};
117  return (data_[sid].dict_.size() == data_[sid].tracker_.size()) &&
118  (data_[sid].dict_.size() == data_[sid].kind_.size());
119  }
PerScheduleContainer< ScheduleData > data_
hep::concurrency::RecursiveMutex mutex_
RandomNumberGenerator& art::RandomNumberGenerator::operator= ( RandomNumberGenerator const &  )
delete
RandomNumberGenerator& art::RandomNumberGenerator::operator= ( RandomNumberGenerator &&  )
delete
void art::RandomNumberGenerator::postBeginJob ( )
private

Definition at line 423 of file RandomNumberGenerator_service.cc.

References engine_creation_is_okay_, mutex_, and restoreFromFile_().

Referenced by RandomNumberGenerator().

424  {
425  RecursiveMutexSentry sentry{mutex_, __func__};
427  engine_creation_is_okay_ = false;
428  }
hep::concurrency::RecursiveMutex mutex_
void art::RandomNumberGenerator::postEndJob ( )
private

Definition at line 441 of file RandomNumberGenerator_service.cc.

References data_, DEFINE_ART_SERVICE, msf_helper::iteration, mutex_, saveToFile_(), and takeSnapshot_().

Referenced by RandomNumberGenerator().

442  {
443  // For normal termination, we wish to save the state at the *end* of
444  // processing, not at the beginning of the last event.
445  RecursiveMutexSentry sentry{mutex_, __func__};
446  ScheduleIteration iteration(data_.size());
447  iteration.for_each_schedule(
448  [this](ScheduleID const sid) { takeSnapshot_(sid); });
449  saveToFile_();
450  }
PerScheduleContainer< ScheduleData > data_
hep::concurrency::RecursiveMutex mutex_
void art::RandomNumberGenerator::postProcessEvent ( Event const &  ,
ScheduleContext   
)
private
void art::RandomNumberGenerator::preProcessEvent ( Event const &  e,
ScheduleContext  sc 
)
private

Definition at line 431 of file RandomNumberGenerator_service.cc.

References art::ScheduleContext::id(), mutex_, restoreSnapshot_(), and takeSnapshot_().

Referenced by RandomNumberGenerator().

433  {
434  auto const sid = sc.id();
435  RecursiveMutexSentry sentry{mutex_, __func__};
436  takeSnapshot_(sid);
437  restoreSnapshot_(sid, e);
438  }
void restoreSnapshot_(ScheduleID, Event const &)
hep::concurrency::RecursiveMutex mutex_
Float_t e
Definition: plot.C:35
void art::RandomNumberGenerator::print_ ( ) const
private

Definition at line 238 of file RandomNumberGenerator_service.cc.

References d, data_, debug_, cet::for_all_with_index(), MECModelEnuComparisons::i, mutex_, nPrint_, and ss.

239  {
240  RecursiveMutexSentry sentry{mutex_, __func__};
241  static unsigned ncalls = 0;
242  if (!debug_ || (++ncalls > nPrint_)) {
243  return;
244  }
245  auto print_per_stream = [](size_t const i, auto const& d) {
246  mf::LogInfo log{"RANDOM"};
247  if (d.snapshot_.empty()) {
248  log << "No snapshot has yet been made.\n";
249  return;
250  }
251  log << "Snapshot information:";
252  for (auto const& ss : d.snapshot_) {
253  log << "\nEngine: " << ss.label() << " Kind: " << ss.ekind()
254  << " Schedule ID: " << i << " State size: " << ss.state().size();
255  }
256  log << "\n";
257  };
258  cet::for_all_with_index(data_, print_per_stream);
259  }
void for_all_with_index(FwdCont &, Func)
Float_t ss
Definition: plot.C:24
PerScheduleContainer< ScheduleData > data_
Definition: log.py:1
hep::concurrency::RecursiveMutex mutex_
Float_t d
Definition: plot.C:236
void art::RandomNumberGenerator::restoreFromFile_ ( )
private

Definition at line 362 of file RandomNumberGenerator_service.cc.

References ana::assert(), CET_ASSERT_ONLY_ONE_THREAD, art::errors::Configuration, confusionMatrixTree::count, d, data_, File, infile, invariant_holds_(), label, art::errors::LogicError, mutex_, plot_validation_datamc::p1, plot_validation_datamc::p2, restoreFromFilename_, Seed, and submit_hadd::u.

Referenced by postBeginJob().

363  {
364  RecursiveMutexSentry sentry{mutex_, __func__};
365  if (restoreFromFilename_.empty()) {
366  return;
367  }
369  // access the file:
370  ifstream infile{restoreFromFilename_.c_str()};
371  if (!infile) {
372  throw cet::exception("RANDOM")
373  << "RNGservice::restoreFromFile_():\n"
374  << "Can't open file \"" << restoreFromFilename_
375  << "\" to initialize engines\n";
376  }
377  // restore engines:
378  for (string label{}; infile >> label;) {
379  // Get schedule ID from engine label
380  assert(count(label.cbegin(), label.cend(), ':') == 2u);
381  auto const p1 = label.find_first_of(':');
382  auto const p2 = label.find_last_of(':');
383  ScheduleID const sid{
384  static_cast<ScheduleID::size_type>(stoi(label.substr(p1 + 1, p2)))};
385  auto d = data_[sid].dict_.find(label);
386  if (d == data_[sid].dict_.end()) {
387  throw Exception(errors::Configuration, "RANDOM")
388  << "Attempt to restore an engine with label " << label
389  << " not configured in this job.\n";
390  }
391  assert((data_[sid].tracker_.find(label) != data_[sid].tracker_.cend()) &&
392  "RNGservice::restoreFromFile_()");
393  EngineSource& how{data_[sid].tracker_[label]};
394  if (how == EngineSource::Seed) {
395  auto& eptr = d->second;
396  assert(eptr && "RNGservice::restoreFromFile_()");
397  if (!eptr->get(infile)) {
398  throw cet::exception("RANDOM")
399  << "RNGservice::restoreFromFile_():\n"
400  << "Failed during restore of state of engine for label " << label
401  << "from file \"" << restoreFromFilename_ << "\"\n";
402  }
403  how = EngineSource::File;
404  } else if (how == EngineSource::File) {
405  throw Exception(errors::Configuration, "RANDOM")
406  << "Engine state file contains two engine states with the same "
407  "label: "
408  << label << "\n.";
409  } else {
410  throw Exception(errors::LogicError, "RANDOM")
411  << "Internal error: attempt to restore an engine state " << label
412  << " from file\n"
413  << "which was originally initialized via an unknown or impossible "
414  "method.\n";
415  }
416  assert(invariant_holds_(sid) &&
417  "RNGservice::restoreFromFile_() invariant failure");
418  }
419  }
#define CET_ASSERT_ONLY_ONE_THREAD()
std::string const restoreFromFilename_
PerScheduleContainer< ScheduleData > data_
::xsd::cxx::tree::exception< char > exception
Definition: Database.h:225
const char * label
string infile
hep::concurrency::RecursiveMutex mutex_
Float_t d
Definition: plot.C:236
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
id_type size_type
Definition: ScheduleID.h:25
assert(nhit_max >=nhit_nbins)
void art::RandomNumberGenerator::restoreSnapshot_ ( ScheduleID  sid,
Event const &  event 
)
private

Definition at line 287 of file RandomNumberGenerator_service.cc.

References ana::assert(), data_, lem_server::ep, File, invariant_holds_(), label, test_ParserArtEvents::log, mutex_, Product, restoreStateLabel_, train_latest_snapshot::snapshot, and confusionMatrixTree::t.

Referenced by preProcessEvent().

289  {
290  RecursiveMutexSentry sentry{mutex_, __func__};
291  if (restoreStateLabel_.empty()) {
292  return;
293  }
294  // access the saved-states product:
295  auto const& saved =
296  *event.getValidHandle<vector<RNGsnapshot>>(restoreStateLabel_);
297  // restore engines from saved-states product:
298  for (auto const& snapshot : saved) {
299  string const& label = snapshot.label();
300  mf::LogInfo log("RANDOM");
301  log << "RNGservice::restoreSnapshot_(): label \"" << label << "\"";
302  auto t = data_[sid].tracker_.find(label);
303  if (t == data_[sid].tracker_.end()) {
304  log << " could not be restored;\n"
305  << "no established engine bears this label.\n";
306  continue;
307  }
308  if (t->second == EngineSource::File) {
309  throw cet::exception("RANDOM")
310  << "RNGservice::restoreSnapshot_():\n"
311  << "The state of engine \"" << label
312  << "\" has been previously read from a file;\n"
313  << "it is therefore not restorable from a snapshot product.\n";
314  }
315  shared_ptr<CLHEP::HepRandomEngine> ep{data_[sid].dict_[label]};
316  assert(ep && "RNGservice::restoreSnapshot_()");
317  data_[sid].tracker_[label] = EngineSource::Product;
318  auto const& est = snapshot.restoreState();
319  if (ep->get(est)) {
320  log << " successfully restored.\n";
321  } else {
322  throw cet::exception("RANDOM")
323  << "RNGservice::restoreSnapshot_():\n"
324  << "Failed during restore of state of engine for \"" << label
325  << "\"\n";
326  }
327  }
328  assert(invariant_holds_(sid) && "RNGsnapshot::restoreSnapshot_()");
329  }
PerScheduleContainer< ScheduleData > data_
::xsd::cxx::tree::exception< char > exception
Definition: Database.h:225
Definition: log.py:1
const char * label
hep::concurrency::RecursiveMutex mutex_
assert(nhit_max >=nhit_nbins)
void art::RandomNumberGenerator::saveToFile_ ( )
private

Definition at line 332 of file RandomNumberGenerator_service.cc.

References ana::assert(), CET_ASSERT_ONLY_ONE_THREAD, d, data_, mutex_, outfile, gammaraytel::pr, and saveToFilename_.

Referenced by postEndJob().

333  {
334  RecursiveMutexSentry sentry{mutex_, __func__};
335  if (saveToFilename_.empty()) {
336  return;
337  }
339  // access the file:
340  ofstream outfile{saveToFilename_.c_str()};
341  if (!outfile) {
342  mf::LogWarning("RANDOM")
343  << "Can't create/access file \"" << saveToFilename_ << "\"\n";
344  }
345  // save each engine:
346  for (auto const& d : data_) {
347  for (auto const& pr : d.dict_) {
348  outfile << pr.first << '\n';
349  auto const& eptr = pr.second;
350  assert(eptr && "RNGservice::saveToFile_()");
351  eptr->put(outfile);
352  if (!outfile) {
353  mf::LogWarning("RANDOM")
354  << "This module's engine has not been saved;\n"
355  << "file \"" << saveToFilename_ << "\" is likely now corrupted.\n";
356  }
357  }
358  }
359  }
#define CET_ASSERT_ONLY_ONE_THREAD()
PerScheduleContainer< ScheduleData > data_
hep::concurrency::RecursiveMutex mutex_
Float_t d
Definition: plot.C:236
MaybeLogger_< ELseverityLevel::ELsev_warning, false > LogWarning
assert(nhit_max >=nhit_nbins)
FILE * outfile
Definition: dump_event.C:13
void art::RandomNumberGenerator::takeSnapshot_ ( ScheduleID  sid)
private

Definition at line 269 of file RandomNumberGenerator_service.cc.

References ana::assert(), data_, label, mutex_, and gammaraytel::pr.

Referenced by postEndJob(), and preProcessEvent().

270  {
271  RecursiveMutexSentry sentry{mutex_, __func__};
272  mf::LogDebug log{"RANDOM"};
273  log << "RNGservice::takeSnapshot_() of the following engine labels:\n";
274  data_[sid].snapshot_.clear();
275  for (auto const& pr : data_[sid].dict_) {
276  string const& label = pr.first;
277  shared_ptr<CLHEP::HepRandomEngine> const& eptr = pr.second;
278  assert(eptr && "RNGservice::takeSnapshot_()");
279  data_[sid].snapshot_.emplace_back(
280  data_[sid].kind_[label], label, eptr->put());
281  log << " | " << label;
282  }
283  log << " |\n";
284  }
PerScheduleContainer< ScheduleData > data_
Definition: log.py:1
const char * label
hep::concurrency::RecursiveMutex mutex_
assert(nhit_max >=nhit_nbins)
void art::RandomNumberGenerator::validate_ ( std::string const &  user_specified_engine_kind,
long  user_specified_seed 
)
privatenoexcept

Definition at line 202 of file RandomNumberGenerator_service.cc.

References defaultEngineKind_, maxCLHEPSeed, and useDefaultSeed.

Referenced by createEngine().

205  {
206  // The only time a user-specified seed can be negative is for
207  // indicating to this service that the default seed for the
208  // requested engine kind should be used.
209  if (user_specified_seed == useDefaultSeed)
210  return;
211 
212  if (user_specified_seed < 0) {
213  throw cet::exception("RANGE") << "RNGservice::throw_if_invalid_seed():\n"
214  << "Seed " << user_specified_seed
215  << " is not permitted to be negative.\n";
216  }
217 
218  if (user_specified_seed <= maxCLHEPSeed)
219  return;
220 
221  // For now, only MixMaxRng engines can be constructed with a seed
222  // value greater than maxCLHEPSeed.
223  if (user_specified_engine_kind == "MixMaxRng"s)
224  return;
225 
226  if (user_specified_engine_kind == "G4Engine"s &&
227  defaultEngineKind_ == "MixMaxRng"s)
228  return;
229 
230  throw cet::exception("RANGE")
231  << "RNGservice::throw_if_invalid_seed():\n"
232  << "Seed " << user_specified_seed << " exceeds permitted maximum of "
233  << maxCLHEPSeed << " for engine type " << user_specified_engine_kind
234  << ".\n";
235  }
static long constexpr maxCLHEPSeed
::xsd::cxx::tree::exception< char > exception
Definition: Database.h:225
static long constexpr useDefaultSeed
const XML_Char * s
Definition: expat.h:262

Friends And Related Function Documentation

friend class detail::EngineCreator
friend

Definition at line 165 of file RandomNumberGenerator.h.

friend class EventProcessor
friend

Definition at line 164 of file RandomNumberGenerator.h.

friend class RandomNumberSaver
friend

Definition at line 166 of file RandomNumberGenerator.h.

Member Data Documentation

PerScheduleContainer<ScheduleData> art::RandomNumberGenerator::data_
private
bool const art::RandomNumberGenerator::debug_
private

Definition at line 297 of file RandomNumberGenerator.h.

Referenced by print_(), and RandomNumberGenerator().

std::string const art::RandomNumberGenerator::defaultEngineKind_
private

Definition at line 285 of file RandomNumberGenerator.h.

Referenced by createEngine(), and validate_().

bool art::RandomNumberGenerator::engine_creation_is_okay_ {true}
private

Definition at line 301 of file RandomNumberGenerator.h.

Referenced by createEngine(), and postBeginJob().

long constexpr art::RandomNumberGenerator::maxCLHEPSeed {900000000}
static

Definition at line 172 of file RandomNumberGenerator.h.

Referenced by validate_().

hep::concurrency::RecursiveMutex art::RandomNumberGenerator::mutex_ {"art::rng::mutex_"}
mutableprivate
unsigned const art::RandomNumberGenerator::nPrint_
private

Definition at line 298 of file RandomNumberGenerator.h.

Referenced by print_(), and RandomNumberGenerator().

std::string const art::RandomNumberGenerator::restoreFromFilename_
private

Definition at line 294 of file RandomNumberGenerator.h.

Referenced by RandomNumberGenerator(), and restoreFromFile_().

std::string const art::RandomNumberGenerator::restoreStateLabel_
private

Definition at line 288 of file RandomNumberGenerator.h.

Referenced by RandomNumberGenerator(), and restoreSnapshot_().

std::string const art::RandomNumberGenerator::saveToFilename_
private

Definition at line 291 of file RandomNumberGenerator.h.

Referenced by RandomNumberGenerator(), and saveToFile_().

long constexpr art::RandomNumberGenerator::useDefaultSeed {-1}
static

Definition at line 173 of file RandomNumberGenerator.h.

Referenced by createEngine(), and validate_().


The documentation for this class was generated from the following files: