RandomNumberControl Class Reference

class RandomNumberControl More...

Inheritance diagram for RandomNumberControl:

Collaboration diagram for RandomNumberControl:

Public Types
using	FullPrecRealType = QMCTraits::FullPrecRealType
using	uint_type = RandomBase< FullPrecRealType >::uint_type
Public Types inherited from OhmmsElementBase
enum	{ useLIBXML = 0, useLIBXMLPP, usePLAIN }
	enumeration to choose the xml parser More...

Public Member Functions
	RandomNumberControl (const char *aname="random")
	constructors and destructors More...
bool	get (std::ostream &os) const override
	generic output More...
bool	put (std::istream &is) override
	generic input More...
bool	put (xmlNodePtr cur) override
	read from an xmlNode More...
void	reset () override
	reset the generator More...
xmlNodePtr	initialize (xmlXPathContextPtr)
Public Member Functions inherited from OhmmsElementBase
	OhmmsElementBase (const char *aname="none")
	constructor with a name More...
virtual	~OhmmsElementBase ()
	destructor More...
const std::string &	getName () const
	return the name More...
void	setName (const std::string &aname)
	set name More...
void	setIOMode (int imode)
	set iomode More...
virtual bool	add (xmlNodePtr parent)
	add a xmlNode to the children list of parent More...
void	put (const std::string &s)
	read from string More...
virtual void	begin_node (std::ostream &os) const
	write the start of a node More...
virtual void	end_node (std::ostream &os) const
	write the end of a node More...

Static Public Member Functions
static void	test ()
static void	make_seeds ()
	reset the generator More...
static void	make_children ()
static void	read (const std::string &fname, Communicate *comm)
	read in parallel or serial More...
static void	write (const std::string &fname, Communicate *comm)
	write in parallel or serial More...
static void	write (const RefVector< RandomBase< FullPrecRealType >> &rng, const std::string &fname, Communicate *comm)
	write in parallel or serial More...
static void	read_parallel (hdf_archive &hin, Communicate *comm)
	read random state from a hdf file in parallel More...
static void	write_parallel (const RefVector< RandomBase< FullPrecRealType >> &rng, hdf_archive &hout, Communicate *comm)
	write random state to a hdf file in parallel More...
static void	read_rank_0 (hdf_archive &hin, Communicate *comm)
	rank 0 reads random states from a hdf file and distributes them to all the other ranks More...
static void	write_rank_0 (const RefVector< RandomBase< FullPrecRealType >> &rng, hdf_archive &hout, Communicate *comm)
	rank 0 gathers the random states from all the other ranks and write them to a hdf file More...

Static Public Attributes
static PrimeNumberSet< uint_type >	PrimeNumbers
	initialize the static data members More...
static UPtrVector< RandomBase< FullPrecRealType > >	Children

Private Attributes
bool	NeverBeenInitialized
xmlNodePtr	myCur

Static Private Attributes
static uint_type	Offset = 11u

Additional Inherited Members
Protected Attributes inherited from OhmmsElementBase
int	myIOMode
	the type of IO mode: default is useLIBXML More...
std::string	myName
	the name of the node, corresponds to the xml tag More...

Detailed Description

class RandomNumberControl

Encapsulate data to initialize and save the status of the random number generator

Default: myName = "random" 2007-12-01 Use PrimeNumbers to generate random seeds.

Definition at line 39 of file RandomNumberControl.h.

Member Typedef Documentation

FullPrecRealType

using FullPrecRealType = QMCTraits::FullPrecRealType

Definition at line 42 of file RandomNumberControl.h.

uint_type

using uint_type = RandomBase<FullPrecRealType>::uint_type

Definition at line 43 of file RandomNumberControl.h.

Constructor & Destructor Documentation

RandomNumberControl()

RandomNumberControl

(

const char *

aname = "random"

)

constructors and destructors

Definition at line 36 of file RandomNumberControl.cpp.

    : OhmmsElementBase(aname), NeverBeenInitialized(true), myCur(NULL) //, Offset(5)
{}

Member Function Documentation

get()

bool get ( std::ostream &  os ) const

overridevirtual

generic output

Implements OhmmsElementBase.

Definition at line 41 of file RandomNumberControl.cpp.

References RandomNumberControl::Children, omp_get_max_threads(), and Random.

{
  if (omp_get_max_threads() > 1)
  {
    for (int ip = 0; ip < omp_get_max_threads(); ip++)
    {
      Children[ip]->write(os);
      os << std::endl;
    }
  }
  else
  {
    Random.write(os);
  }
  return true;
}

initialize()

xmlNodePtr initialize

(

xmlXPathContextPtr

acontext

)

Definition at line 98 of file RandomNumberControl.cpp.

References RandomNumberControl::myCur, and RandomNumberControl::put().

Referenced by QMCMain::execute(), qmcplusplus::TEST_CASE(), and QMCMain::validateXML().

{
  OhmmsXPathObject rg_request("//random", acontext);
  put(rg_request[0]);
  return myCur;
}

make_children()

void make_children ( )

static

Definition at line 80 of file RandomNumberControl.cpp.

References RandomNumberControl::Children, OHMMS::Controller, PrimeNumberSet< UIntType >::get(), qmcplusplus::n, RandomNumberControl::Offset, omp_get_max_threads(), RandomNumberControl::PrimeNumbers, qmcplusplus::rank, Communicate::rank(), and Communicate::size().

Referenced by RandomNumberControl::make_seeds(), and RandomNumberControl::put().

{
  int nthreads = omp_get_max_threads();
  int n        = nthreads - Children.size();
  while (n)
  {
    Children.push_back(std::make_unique<RandomGenerator>());
    n--;
  }
  int rank       = OHMMS::Controller->rank();
  int nprocs     = OHMMS::Controller->size();
  int baseoffset = Offset + nprocs + nthreads * rank;
  std::vector<uint_type> myprimes;
  PrimeNumbers.get(baseoffset, nthreads, myprimes);
  for (int ip = 0; ip < nthreads; ip++)
    Children[ip]->init(myprimes[ip]);
}

make_seeds()

void make_seeds ( )

static

reset the generator

Definition at line 65 of file RandomNumberControl.cpp.

References qmcplusplus::bcast(), OHMMS::Controller, PrimeNumberSet< UIntType >::get(), RandomNumberControl::make_children(), RandomNumberControl::Offset, omp_get_max_threads(), RandomNumberControl::PrimeNumbers, Random, Communicate::rank(), and Communicate::size().

Referenced by QMCDriverNew::createRngsStepContexts(), QMCDriver::process(), RandomNumberControl::reset(), and qmcplusplus::TEST_CASE().

{
  int pid         = OHMMS::Controller->rank();
  int nprocs      = OHMMS::Controller->size();
  uint_type iseed = static_cast<uint_type>(std::time(0)) % 1024;
  mpi::bcast(*OHMMS::Controller, iseed);
  //OHMMS::Controller->bcast(iseed);//broadcast the seed
  Offset = iseed;
  std::vector<uint_type> mySeeds;
  RandomNumberControl::PrimeNumbers.get(Offset, nprocs * (omp_get_max_threads() + 2), mySeeds);
  Random.init(mySeeds[pid]);
  //change children as well
  make_children();
}

put() [1/2]

bool put ( std::istream &  is )

overridevirtual

generic input

Implements OhmmsElementBase.

Definition at line 59 of file RandomNumberControl.cpp.

Referenced by RandomNumberControl::initialize().

{ return true; }

put() [2/2]

bool put ( xmlNodePtr  cur )

overridevirtual

read from an xmlNode

Implements OhmmsElementBase.

Definition at line 148 of file RandomNumberControl.cpp.

References OhmmsAttributeSet::add(), qmcplusplus::app_log(), qmcplusplus::app_summary(), qmcplusplus::bcast(), OHMMS::Controller, PrimeNumberSet< UIntType >::get(), RandomNumberControl::make_children(), RandomNumberControl::NeverBeenInitialized, RandomNumberControl::Offset, omp_get_max_threads(), RandomNumberControl::PrimeNumbers, OhmmsAttributeSet::put(), Random, Communicate::rank(), RandomNumberControl::reset(), and Communicate::size().

{
  if (NeverBeenInitialized)
  {
    bool init_mpi = true;
    int offset_in = -1; // default is to generate by Wall-clock
    if (cur != NULL)
    {
      std::string pname("yes");
      OhmmsAttributeSet oAttrib;
      oAttrib.add(pname, "parallel");
      oAttrib.add(offset_in, "seed");
      oAttrib.put(cur);
      if (pname == "0" || pname == "false" || pname == "no")
        init_mpi = false;
    }
    int nprocs = 1;
    int pid    = 0;
    if (init_mpi)
    {
      pid    = OHMMS::Controller->rank();
      nprocs = OHMMS::Controller->size();
    }

    app_summary() << std::endl;
    app_summary() << " Random Number" << std::endl;
    app_summary() << " -------------" << std::endl;
    if (offset_in < 0)
    {
      offset_in = static_cast<int>(static_cast<uint_type>(std::time(0)) % 1024);
      app_summary() << "  Offset for the random number seeds based on time: " << offset_in << std::endl;
      mpi::bcast(*OHMMS::Controller, offset_in);
    }
    else
    {
      offset_in %= 1024;
      app_summary() << "  Offset for the random number seeds from input file (mod 1024): " << offset_in << std::endl;
    }
    app_summary() << std::endl;
    Offset = offset_in;
    std::vector<uint_type> mySeeds;
    //allocate twice of what is required
    PrimeNumbers.get(Offset, nprocs * (omp_get_max_threads() + 2), mySeeds);
    Random.init(mySeeds[pid]);
    app_log() << "  Range of prime numbers to use as seeds over processors and threads = " << mySeeds[0] << "-"
              << mySeeds[nprocs * omp_get_max_threads()] << std::endl;
    app_log() << std::endl;

    make_children();
    NeverBeenInitialized = false;
  }
  else
    reset();
  return true;
}

read()

void read ( const std::string &  fname, Communicate *  comm  )

static

read in parallel or serial

Parameters

fname	file name
comm	communicator

Definition at line 206 of file RandomNumberControl.cpp.

References qmcplusplus::comm, hdf_archive::is_parallel(), hdf_archive::open(), RandomNumberControl::read_parallel(), and RandomNumberControl::read_rank_0().

Referenced by QMCMain::setMCWalkers(), and qmcplusplus::TEST_CASE().

{
  std::string h5name = fname + ".random.h5";
  hdf_archive hin(comm, true); //attempt to read in parallel
  hin.open(h5name, H5F_ACC_RDONLY);
  if (hin.is_parallel())
    read_parallel(hin, comm);
  else
    read_rank_0(hin, comm);
}

read_parallel()

void read_parallel ( hdf_archive &  hin, Communicate *  comm  )

static

read random state from a hdf file in parallel

Parameters

hin	hdf_archive set to parallel
comm	communicator

Definition at line 237 of file RandomNumberControl.cpp.

References qmcplusplus::app_log(), RandomNumberControl::Children, hdf_archive::close(), qmcplusplus::comm, qmcplusplus::hdf::main_state, omp_get_max_threads(), hdf_archive::pop(), hdf_archive::push(), Random, Communicate::rank(), hdf_archive::read(), and Communicate::size().

Referenced by RandomNumberControl::read().

{
  // cast integer to size_t
  const size_t nthreads  = static_cast<size_t>(omp_get_max_threads());
  const size_t comm_size = static_cast<size_t>(comm->size());
  const size_t comm_rank = static_cast<size_t>(comm->rank());

  std::vector<uint_type> vt, mt;
  TinyVector<int, 3> shape_now(comm->size(), nthreads, Random.state_size()); //cur configuration
  TinyVector<int, 3> shape_hdf5(3, 0);                                       //configuration when file was written

  //grab shape and Random.state_size() used to create hdf5 file
  hin.push(hdf::main_state);
  hin.read(shape_hdf5, "nprocs_nthreads_statesize");

  //if hdf5 file's shape and the current shape don't match, abort read
  if (shape_hdf5[0] != shape_now[0] || shape_hdf5[1] != shape_now[1] || shape_hdf5[2] != shape_now[2])
  {
    app_log() << "Mismatched random number generators."
              << "\n  Number of procs in streams : old=" << shape_hdf5[0] << " new= " << shape_now[0]
              << "\n  Number of threads in streams : old=" << shape_hdf5[1] << " new= " << shape_now[1]
              << "\n  State size per stream : old=" << shape_hdf5[2] << " new= " << shape_now[2]
              << "\n  Using the random streams generated at the initialization.\n";
    return;
  }
  app_log() << "  Restart from the random number streams from the previous configuration.\n";

  vt.resize(nthreads * Random.state_size()); //buffer for children[ip]
  mt.resize(Random.state_size());            //buffer for single thread Random object of random nums

  std::array<size_t, 2> shape{comm_size * nthreads, Random.state_size()}; //global dims of children dataset
  std::array<size_t, 2> counts{nthreads, Random.state_size()};            //local dimensions of dataset
  std::array<size_t, 2> offsets{comm_rank * nthreads, 0};                 //offsets for each process to read in

  hin.push("random"); //group that holds children[ip] random nums
  hyperslab_proxy<std::vector<uint_type>, 2> slab(vt, shape, counts, offsets);
  hin.read(slab, Random.EngineName);

  hin.pop();
  hin.push("random_master"); //group that holds Random_th random nums
  shape[0]   = comm->size(); //reset shape, counts and offset for non-multiple threads
  counts[0]  = 1;
  offsets[0] = comm->rank();
  hyperslab_proxy<std::vector<uint_type>, 2> slab2(mt, shape, counts, offsets);
  hin.read(slab2, Random.EngineName);
  hin.close();

  std::vector<uint_type>::iterator vt_it(vt.begin());
  for (int ip = 0; ip < nthreads; ip++, vt_it += shape[1])
  {
    std::vector<uint_type> c(vt_it, vt_it + shape[1]);
    Children[ip]->load(c); //load random nums back to program from buffer
  }
  Random.load(mt); //load random nums back to prog from buffer
}

read_rank_0()

void read_rank_0 ( hdf_archive &  hin, Communicate *  comm  )

static

rank 0 reads random states from a hdf file and distributes them to all the other ranks

Parameters

hin	hdf_archive set to serial
comm	communicator

Definition at line 338 of file RandomNumberControl.cpp.

References qmcplusplus::app_log(), qmcplusplus::bcast(), RandomNumberControl::Children, hdf_archive::close(), qmcplusplus::comm, copy(), qmcplusplus::hdf::main_state, omp_get_max_threads(), hdf_archive::pop(), hdf_archive::push(), Random, Communicate::rank(), hdf_archive::read(), hdf_archive::readSlabReshaped(), and Communicate::size().

Referenced by RandomNumberControl::read().

{
  // cast integer to size_t
  const size_t nthreads  = static_cast<size_t>(omp_get_max_threads());
  const size_t comm_size = static_cast<size_t>(comm->size());
  const size_t comm_rank = static_cast<size_t>(comm->rank());

  std::vector<uint_type> vt, vt_tot, mt, mt_tot;
  TinyVector<size_t, 3> shape_now(comm_size, nthreads, Random.state_size()); //current configuration
  TinyVector<size_t, 3> shape_hdf5;                                          //configuration when hdf5 file was written
  std::array<size_t, 2> shape{comm_size * nthreads, Random.state_size()};    //dimensions of children dataset

  //grab configuration of threads/procs and Random.state_size() in hdf5 file
  if (comm->rank() == 0)
  {
    hin.push(hdf::main_state);
    hin.read(shape_hdf5, "nprocs_nthreads_statesize");
  }

  mpi::bcast(*comm, shape_hdf5);

  //if hdf5 file's configuration and current configuration don't match, abort read
  if (shape_hdf5[0] != shape_now[0] || shape_hdf5[1] != shape_now[1] || shape_hdf5[2] != shape_now[2])
  {
    app_log() << "Mismatched random number generators."
              << "\n  Number of procs in streams : old=" << shape_hdf5[0] << " new= " << shape_now[0]
              << "\n  Number of threads in streams : old=" << shape_hdf5[1] << " new= " << shape_now[1]
              << "\n  State size per stream : old=" << shape_hdf5[2] << " new= " << shape_now[2]
              << "\n  Using the random streams generated at the initialization.\n";
    return;
  }
  app_log() << "  Restart from the random number streams from the previous configuration.\n";

  vt.resize(nthreads * Random.state_size()); //buffer for random nums in children of each thread
  mt.resize(Random.state_size());            //buffer for random numbers from single Random object

  if (comm->rank() == 0)
  {
    hin.push("random"); //group for children[ip] (Random.object for each thread)
    vt_tot.resize(nthreads * Random.state_size() * comm->size());
    hin.readSlabReshaped(vt_tot, shape, Random.EngineName);
    hin.pop();

    shape[0] = comm->size(); //reset shape to one thread per process
    mt_tot.resize(Random.state_size() * comm->size());
    hin.push("random_master"); //group for single Random object
    hin.readSlabReshaped(mt_tot, shape, Random.EngineName);
    hin.close();
  }

  if (comm->size() > 1)
  {
    mpi::scatter(*comm, vt_tot, vt); //divide big buffer into on for each proc
    mpi::scatter(*comm, mt_tot, mt);
  }
  else
  {
    copy(vt_tot.begin(), vt_tot.end(), vt.begin());
    copy(mt_tot.begin(), mt_tot.end(), mt.begin());
  }

  std::vector<uint_type>::iterator vt_it(vt.begin());
  for (int i = 0; i < nthreads; i++, vt_it += shape[1])
  {
    std::vector<uint_type> c(vt_it, vt_it + shape[1]);
    Children[i]->load(c); //read seeds for each thread from buffer back into object
  }
  Random.load(mt); //read seeds back into object
}

reset()

void reset ( )

overridevirtual

reset the generator

Implements OhmmsElementBase.

Definition at line 62 of file RandomNumberControl.cpp.

References RandomNumberControl::make_seeds().

Referenced by RandomNumberControl::put().

{ make_seeds(); }

test()

void test ( )

static

Definition at line 105 of file RandomNumberControl.cpp.

References qmcplusplus::app_log(), RandomNumberControl::Children, OHMMS::Controller, qmcplusplus::n, omp_get_max_threads(), and Communicate::size().

Referenced by QMCMain::executeQMCSection().

{
  /* Add random number generator tester
  */
  int nthreads = omp_get_max_threads();
  std::vector<double> avg(nthreads), avg2(nthreads);
#pragma omp parallel for
  for (int ip = 0; ip < nthreads; ++ip)
  {
    const int n = 1000000;
    double sum = 0.0, sum2 = 0.0;
    auto& myrand(*Children[ip]);
    for (int i = 0; i < n; ++i)
    {
      double r = myrand();
      sum += r;
      sum2 += r * r;
    }
    avg[ip]  = sum / static_cast<double>(n);
    avg2[ip] = sum2 / static_cast<double>(n);
  }
  std::vector<double> avg_tot(nthreads * OHMMS::Controller->size()), avg2_tot(nthreads * OHMMS::Controller->size());
  mpi::gather(*OHMMS::Controller, avg, avg_tot);
  mpi::gather(*OHMMS::Controller, avg2, avg2_tot);
  double avg_g  = 0.0;
  double avg2_g = 0.0;
  for (int i = 0, ii = 0; i < OHMMS::Controller->size(); ++i)
  {
    for (int ip = 0; ip < nthreads; ++ip, ++ii)
    {
      app_log() << "RNGTest " << std::setw(4) << i << std::setw(4) << ip << std::setw(20) << avg_tot[ii]
                << std::setw(20) << avg2_tot[ii] - avg_tot[ii] * avg_tot[ii] << std::endl;
      avg_g += avg_tot[ii];
      avg2_g += avg2_tot[ii];
    }
  }
  avg_g /= static_cast<double>(nthreads * OHMMS::Controller->size());
  avg2_g /= static_cast<double>(nthreads * OHMMS::Controller->size());
  app_log() << "RNGTest " << std::setw(4) << OHMMS::Controller->size() << std::setw(4) << nthreads << std::setw(20)
            << avg_g << std::setw(20) << avg2_g - avg_g * avg_g << std::endl;
  app_log().flush();
}

write() [1/2]

void write ( const std::string &  fname, Communicate *  comm  )

static

write in parallel or serial

Parameters

fname	file name
comm	communicator

Definition at line 217 of file RandomNumberControl.cpp.

References RandomNumberControl::Children, qmcplusplus::comm, and qmcplusplus::convertUPtrToRefVector().

Referenced by QMCDriverNew::finalize(), QMCDriver::finalize(), QMCDriverNew::recordBlock(), QMCDriver::recordBlock(), and qmcplusplus::TEST_CASE().

{
  write(convertUPtrToRefVector(Children), fname, comm);
}

write() [2/2]

void write ( const RefVector< RandomBase< FullPrecRealType >> &  rng, const std::string &  fname, Communicate *  comm  )

static

write in parallel or serial

Parameters

rng	random number generators
fname	file name
comm	communicator

Definition at line 223 of file RandomNumberControl.cpp.

References qmcplusplus::comm, hdf_archive::create(), hdf_archive::is_parallel(), RandomNumberControl::write_parallel(), and RandomNumberControl::write_rank_0().

{
  std::string h5name = fname + ".random.h5";
  hdf_archive hout(comm, true); //attempt to write in parallel
  hout.create(h5name);
  if (hout.is_parallel())
    write_parallel(rng, hout, comm);
  else
    write_rank_0(rng, hout, comm);
}

write_parallel()

void write_parallel ( const RefVector< RandomBase< FullPrecRealType >> &  rng, hdf_archive &  hout, Communicate *  comm  )

static

write random state to a hdf file in parallel

Parameters

hdf_archive	set to parallel
comm	communicator

Definition at line 294 of file RandomNumberControl.cpp.

References hdf_archive::close(), qmcplusplus::comm, qmcplusplus::hdf::main_state, omp_get_max_threads(), hdf_archive::pop(), hdf_archive::push(), Random, Communicate::rank(), Communicate::size(), and hdf_archive::write().

Referenced by RandomNumberControl::write().

{
  // cast integer to size_t
  const size_t nthreads  = static_cast<size_t>(omp_get_max_threads());
  const size_t comm_size = static_cast<size_t>(comm->size());
  const size_t comm_rank = static_cast<size_t>(comm->rank());

  std::vector<uint_type> vt, mt;
  TinyVector<int, 3> shape_hdf5(comm->size(), nthreads, Random.state_size()); //configuration at write time
  vt.reserve(nthreads * Random.state_size()); //buffer for random numbers from children[ip] of each thread
  mt.reserve(Random.state_size());            //buffer for random numbers from single Random object

  std::vector<uint_type> c;
  for (int ip = 0; ip < nthreads; ++ip)
  {
    rng[ip].get().save(c);
    vt.insert(vt.end(), c.begin(), c.end()); //get nums from each thread into buffer
  }
  Random.save(mt); //get nums for single random object (no threads)

  std::array<size_t, 2> shape{comm_size * nthreads, Random.state_size()}; //global dimensions
  std::array<size_t, 2> counts{nthreads, Random.state_size()};            //local dimensions
  std::array<size_t, 2> offsets{comm_rank * nthreads, 0};                 //offset for the file write

  hout.push(hdf::main_state);
  hout.write(shape_hdf5, "nprocs_nthreads_statesize"); //save the shape of the data at write

  hout.push("random"); //group for children[ip]
  hyperslab_proxy<std::vector<uint_type>, 2> slab(vt, shape, counts, offsets);
  hout.write(slab, Random.EngineName); //write to hdf5file
  hout.pop();

  shape[0]   = comm->size(); //adjust shape, counts, offset for just one thread
  counts[0]  = 1;
  offsets[0] = comm->rank();
  hout.push("random_master"); //group for random object without threads
  hyperslab_proxy<std::vector<uint_type>, 2> slab2(mt, shape, counts, offsets);
  hout.write(slab2, Random.EngineName); //write data to hdf5 file
  hout.close();
}

write_rank_0()

void write_rank_0 ( const RefVector< RandomBase< FullPrecRealType >> &  rng, hdf_archive &  hout, Communicate *  comm  )

static

rank 0 gathers the random states from all the other ranks and write them to a hdf file

Parameters

hin	hdf_archive object set to serial
comm	communicator

Definition at line 409 of file RandomNumberControl.cpp.

References hdf_archive::close(), qmcplusplus::comm, qmcplusplus::hdf::main_state, omp_get_max_threads(), hdf_archive::pop(), hdf_archive::push(), Random, Communicate::rank(), Communicate::size(), hdf_archive::write(), and hdf_archive::writeSlabReshaped().

Referenced by RandomNumberControl::write().

{
  // cast integer to size_t
  const size_t nthreads  = static_cast<size_t>(omp_get_max_threads());
  const size_t comm_size = static_cast<size_t>(comm->size());
  const size_t comm_rank = static_cast<size_t>(comm->rank());

  std::vector<uint_type> vt, vt_tot, mt, mt_tot;
  std::array<size_t, 2> shape{comm_size * nthreads, Random.state_size()};     //dimensions of children dataset
  TinyVector<size_t, 3> shape_hdf5(comm_size, nthreads, Random.state_size()); //configuration at write time
  vt.reserve(nthreads * Random.state_size()); //buffer for children[ip] (Random object of seeds for each thread)
  mt.reserve(Random.state_size()); //buffer for single Random object of seeds, one per proc regardless of thread num

  for (int i = 0; i < nthreads; ++i)
  {
    std::vector<uint_type> c;
    rng[i].get().save(c);
    vt.insert(vt.end(), c.begin(), c.end()); //copy children[nthreads] seeds to buffer
  }
  Random.save(mt); //copy random_th seeds to buffer

  if (comm->size() > 1)
  {
    vt_tot.resize(vt.size() * comm->size());
    mt_tot.resize(mt.size() * comm->size());
    mpi::gather(*comm, vt, vt_tot); //gather into one big buffer for master write
    mpi::gather(*comm, mt, mt_tot);
  }
  else
  {
    vt_tot = vt;
    mt_tot = mt;
  }

  if (comm->rank() == 0)
  {
    hout.push(hdf::main_state);
    hout.write(shape_hdf5, "nprocs_nthreads_statesize"); //configuration at write time to file

    hout.push("random"); //group for children[ip]
    hout.writeSlabReshaped(vt_tot, shape, Random.EngineName);
    hout.pop();

    shape[0] = comm->size();    //reset dims for single thread use
    hout.push("random_master"); //group for random_th object
    hout.writeSlabReshaped(mt_tot, shape, Random.EngineName);
    hout.close();
  }
}

Member Data Documentation

Children

UPtrVector< RandomBase< QMCTraits::FullPrecRealType > > Children

static

Definition at line 46 of file RandomNumberControl.h.

Referenced by DMCFactory::create(), VMCFactory::create(), QMCDriverNew::createRngsStepContexts(), RandomNumberControl::get(), RandomNumberControl::make_children(), QMCFixedSampleLinearOptimize::processOptXML(), RandomNumberControl::read_parallel(), RandomNumberControl::read_rank_0(), CSVMC::resetRun(), RMC::resetRun(), RMC::run(), CSVMC::run(), RandomNumberControl::test(), qmcplusplus::TEST_CASE(), RandomNumberControl::write(), and QMCDriverNew::~QMCDriverNew().

myCur

xmlNodePtr myCur

private

Definition at line 103 of file RandomNumberControl.h.

Referenced by RandomNumberControl::initialize().

NeverBeenInitialized

bool NeverBeenInitialized

private

Definition at line 102 of file RandomNumberControl.h.

Referenced by RandomNumberControl::put().

Offset

RandomBase< QMCTraits::FullPrecRealType >::uint_type Offset = 11u

staticprivate

Definition at line 104 of file RandomNumberControl.h.

Referenced by RandomNumberControl::make_children(), RandomNumberControl::make_seeds(), and RandomNumberControl::put().

PrimeNumbers

PrimeNumberSet< RandomBase< QMCTraits::FullPrecRealType >::uint_type > PrimeNumbers

static

initialize the static data members

Definition at line 44 of file RandomNumberControl.h.

Referenced by RandomNumberControl::make_children(), RandomNumberControl::make_seeds(), and RandomNumberControl::put().

---

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

• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/Utilities/RandomNumberControl.h
• /home/pk7/projects/qmc/for_cron_doxygen/qmcpack/src/Utilities/RandomNumberControl.cpp