RandomNumbers Class Reference

The class for handling the random number generation. More...

#include <RandomNumbers.h>

Static Public Member Functions
static void	initialize ()
	Initialize the random number generator with a unique random seed;.
static void	initialize (const std::string &seed)
	Initialize the random number generator.
static bool	isInitialized ()
	Truth that the random number generator has been initialized.
static void	initializeBeginRun ()
	Initialize run independent random generator for begin run.
static void	initializeEndRun ()
	Initialize run independent random generator for end run.
static void	initializeEvent (bool force=false)
	Initialize event information.
static void	useEventDependent ()
	Set Event dependent Random Generator as current one.
static RandomGenerator &	getEventRandomGenerator ()
	return reference to the event dependent random generator
static void	barrier ()
	Increase random barrier.
static void	setSeed (const std::string &seed)
	Sets the seed for the random number generator.
static std::string	getSeed ()
	Get the random number generator seed.
static void	exposePythonAPI ()
	Exposes methods of the RandomNumbers class to Python.

Static Private Attributes
static RandomGenerator *	s_evtRng {nullptr}
	event dependent random generator to be used for event processing
static RandomGenerator *	s_runRng {nullptr}
	event independent random generator to be used for begin/end run processing
static std::string	s_initialSeed
	The random number generator seed set by the user.
static int	s_barrierOffset
	barrier index offset to be used in begin/endRun.

Detailed Description

The class for handling the random number generation.

Definition at line 23 of file RandomNumbers.h.

Member Function Documentation

barrier()

void barrier ( )

static

Increase random barrier.

current random generator will be reseeded with a different "barrier index" which makes it's state independent from previous calls

Definition at line 69 of file RandomNumbers.cc.

{
  auto* gen = dynamic_cast<RandomGenerator*>(gRandom);
  if (!gen) {
    B2ERROR("Random Generator gRandom is not Belle2::RandomGenerator, cannot increase barrier");
  } else {
    gen->barrier();
  }
}

exposePythonAPI()

void exposePythonAPI ( )

static

Exposes methods of the RandomNumbers class to Python.

Definition at line 150 of file RandomNumbers.cc.

{
  using namespace boost::python;
 
  //don't show c++ signature in python doc to keep it simple
  docstring_options options(true, true, false);
  //Expose RandomNumbers class
  def("set_random_seed", &setPythonSeed, args("seed"), R"DOCSTRING(
Set the random seed. The argument can be any object and will be converted to a
string using the builtin str() function and will be used to initialize the
random generator.)DOCSTRING");
  def("get_random_seed", &RandomNumbers::getSeed, "Return the current random seed");
}

getEventRandomGenerator()

static RandomGenerator & getEventRandomGenerator ( )

inlinestatic

return reference to the event dependent random generator

Definition at line 73 of file RandomNumbers.h.

{ return *s_evtRng; }

getSeed()

static std::string getSeed ( )

inlinestatic

Get the random number generator seed.

Returns

The initial random number generator seed.

Definition at line 92 of file RandomNumbers.h.

{return s_initialSeed;};

initialize() [1/2]

void initialize ( )

static

Initialize the random number generator with a unique random seed;.

Definition at line 32 of file RandomNumbers.cc.

{
  //use std::random_device to get non deterministic initial seed to be used if
  //user doesn't set one
  std::random_device random_device;
  std::stringstream seed;
  for (int i = 0; i < 8; ++i) {
    seed << std::hex << random_device();
  }
  initialize(seed.str());
}

initialize() [2/2]

void initialize ( const std::string &  seed )

static

Initialize the random number generator.

Parameters

seed	The random number generator seed.

Definition at line 44 of file RandomNumbers.cc.

{
  s_initialSeed = seed;
  if (!s_evtRng) {
    s_evtRng = new RandomGenerator("event generator");
  }
  if (!s_runRng) {
    s_runRng = new RandomGenerator("independent generator");
  }
  auto* gen = dynamic_cast<RandomGenerator*>(gRandom);
  if (!gen) {
    delete gRandom;
    B2DEBUG(100, "Replacing gRandom from " << gRandom << " to " << gen);
  }
  gRandom = s_evtRng;
  s_evtRng->setMode(RandomGenerator::c_independent);
  s_evtRng->setSeed((const unsigned char*)seed.c_str(), seed.size());
  s_runRng->setSeed((const unsigned char*)seed.c_str(), seed.size());
}

initializeBeginRun()

void initializeBeginRun ( )

static

Initialize run independent random generator for begin run.

Called by EventProcessor, should not be called by other users

Definition at line 85 of file RandomNumbers.cc.

{
  gRandom = s_runRng;
  s_runRng->setMode(RandomGenerator::c_runDependent);
  //This might be called in in main or output process. In that case we don't
  //know how many random barriers came before but we can look at the s_evtRng
  //as this was passed from the previous process and contains the current
  //barrier number in the event flow. We save it in intializeEvent so let's use
  //it now.
  s_runRng->setBarrier(s_barrierOffset);
};

initializeEndRun()

void initializeEndRun ( )

static

Initialize run independent random generator for end run.

Called by EventProcessor, should not be called by other users

Definition at line 97 of file RandomNumbers.cc.

{
  gRandom = s_runRng;
  s_runRng->setMode(RandomGenerator::c_runDependent);
  //We set the barrier index to it's minimum possible value: usually barrier
  //index starts at 0 but for endRun we set it to a negative number large
  //enough that there is no realistic chance that beginRun had the same barrier
  //index.
  s_runRng->setBarrier(INT_MIN + s_barrierOffset);
}

initializeEvent()

void initializeEvent ( bool  force = false )

static

Initialize event information.

Called by EventProcessor, should not be called by other users

Parameters

force

if true force initialization even in parallel processing mode for all processes and ignore the generator state that might have been passed in the event stream. This is only used on HLT event processor

Definition at line 108 of file RandomNumbers.cc.

{
  useEventDependent();
  //we pass the random generator to other processes in multiprocessing so we only
  //want to initialize it in the input process (or if there is no multi processing)a
  //However on HLT we do things differently and so we need to initialize on all
  //worker processes. So the HLT event processor can request initialization in
  //all cases.
  if (force || !ProcHandler::parallelProcessingUsed() or ProcHandler::isInputProcess()) {
    // when in event loop we want an error if there is no EventMetaData
    s_evtRng->setMode(RandomGenerator::c_eventDependent);
    s_evtRng->initialize();
  }
  //Ok, now we either have reset the barrier to 0 if we are an input process or
  //have decided to keep the state from the previous process. In any case, this
  //is the start barrier we want to use for begin/end of run processing so we
  //keep it.
  s_barrierOffset = s_evtRng->getBarrier();
}

isInitialized()

bool isInitialized ( )

static

Truth that the random number generator has been initialized.

Definition at line 64 of file RandomNumbers.cc.

{
  return (s_evtRng != nullptr);
}

setSeed()

void setSeed ( const std::string &  seed )

static

Sets the seed for the random number generator.

Parameters

seed	The random number generator seed.

Definition at line 79 of file RandomNumbers.cc.

{
  initialize(seed);
  B2INFO("The random number seed is set to \"" << seed << '"');
}

useEventDependent()

void useEventDependent ( )

static

Set Event dependent Random Generator as current one.

Called by EventProcessor, should not be called by other users

Definition at line 128 of file RandomNumbers.cc.

{
  gRandom = s_evtRng;
}

Member Data Documentation

s_barrierOffset

int s_barrierOffset

staticprivate

barrier index offset to be used in begin/endRun.

Obtained from event dependent generator

Definition at line 113 of file RandomNumbers.h.

s_evtRng

RandomGenerator * s_evtRng {nullptr}

staticprivate

event dependent random generator to be used for event processing

Definition at line 106 of file RandomNumbers.h.

s_initialSeed

std::string s_initialSeed

staticprivate

The random number generator seed set by the user.

initialized to a non-deterministic 64byte hex string if not set by user

Definition at line 111 of file RandomNumbers.h.

s_runRng

RandomGenerator * s_runRng {nullptr}

staticprivate

event independent random generator to be used for begin/end run processing

Definition at line 108 of file RandomNumbers.h.

---

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

• framework/core/include/RandomNumbers.h
• framework/core/src/RandomNumbers.cc