MooseRandom.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
// MOOSE includes
#include "MooseError.h"
#include "DataIO.h"
 
#include <unordered_map>
 
// External library includes
#include "randistrs.h"
 
class MooseRandom
{
public:
  static inline void seed(unsigned int seed) { mt_seed32new(seed); }
 
  static inline Real rand() { return mt_ldrand(); }
 
  static inline Real randNormal(Real mean, Real sigma) { return rd_normal(mean, sigma); }
 
  static inline Real randNormal() { return randNormal(0.0, 1.0); }
 
  static inline uint32_t randl() { return mt_lrand(); }
 
  inline void seed(std::size_t i, unsigned int seed) { mts_seed32new(&(_states[i].first), seed); }
 
  inline Real rand(std::size_t i)
  {
    // mooseAssert(_states.find(i) != _states.end(), "No random state initialized for id: " << i);
    return mts_ldrand(&(_states[i].first));
  }
 
  inline Real randNormal(std::size_t i, Real mean, Real sigma)
  {
    mooseAssert(_states.find(i) != _states.end(), "No random state initialized for id: " << i);
    return rds_normal(&(_states[i].first), mean, sigma);
  }
 
  inline Real randNormal(std::size_t i) { return randNormal(i, 0.0, 1.0); }
 
  inline uint32_t randl(std::size_t i)
  {
    mooseAssert(_states.find(i) != _states.end(), "No random state initialized for id: " << i);
    return mts_lrand(&(_states[i].first));
  }
 
  inline uint32_t randl(std::size_t i, uint32_t lower, uint32_t upper)
  {
    mooseAssert(_states.find(i) != _states.end(), "No random state initialized for id: " << i);
    return rds_iuniform(&(_states[i].first), lower, upper);
  }
 
  void saveState()
  {
    _saved = true;
    std::for_each(_states.begin(),
                  _states.end(),
                  [](std::pair<const std::size_t, std::pair<mt_state, mt_state>> & pair)
                  { pair.second.second = pair.second.first; });
  }
 
  void restoreState()
  {
    mooseAssert(_saved, "saveState() must be called prior to restoreState().");
    std::for_each(_states.begin(),
                  _states.end(),
                  [](std::pair<const std::size_t, std::pair<mt_state, mt_state>> & pair)
                  { pair.second.first = pair.second.second; });
  }
 
  inline std::size_t size() { return _states.size(); }
 
private:
  std::unordered_map<std::size_t, std::pair<mt_state, mt_state>> _states;
 
  // for restart capability
  friend void dataStore<MooseRandom>(std::ostream & stream, MooseRandom & v, void * context);
  friend void dataLoad<MooseRandom>(std::istream & stream, MooseRandom & v, void * context);
 
  bool _saved = false;
};
 
template <>
inline void
dataStore(std::ostream & stream, MooseRandom & v, void * context)
{
  storeHelper(stream, v._states, context);
}
template <>
inline void
dataLoad(std::istream & stream, MooseRandom & v, void * context)
{
  loadHelper(stream, v._states, context);
}