Add random number engine encapsulation.

This allows manipulation of the seed in parallel to allow
parallel/sequential reproducibility

src/main.cpp

-#include <utils/PugsUtils.hpp>
-
 #include <language/PugsParser.hpp>
 #include <mesh/DiamondDualConnectivityManager.hpp>
 #include <mesh/DiamondDualMeshManager.hpp>
 #include <mesh/MeshDataManager.hpp>
 #include <mesh/SynchronizerManager.hpp>
+#include <utils/PugsUtils.hpp>
+#include <utils/RandomEngine.hpp>
 
 int
 main(int argc, char* argv[])
@@ -12,6 +12,7 @@ main(int argc, char* argv[])
   std::string filename = initialize(argc, argv);
 
   SynchronizerManager::create();
+  RandomEngine::create();
   MeshDataManager::create();
   DiamondDualConnectivityManager::create();
   DiamondDualMeshManager::create();
@@ -21,7 +22,10 @@ main(int argc, char* argv[])
   DiamondDualMeshManager::destroy();
   DiamondDualConnectivityManager::destroy();
   MeshDataManager::destroy();
+  RandomEngine::destroy();
   SynchronizerManager::destroy();
+
   finalize();
+
   return 0;
 }

src/utils/CMakeLists.txt

@@ -12,6 +12,7 @@ add_library(
   Partitioner.cpp
   PETScWrapper.cpp
   PugsUtils.cpp
+  RandomEngine.cpp
   RevisionInfo.cpp
   SignalManager.cpp
   SLEPcWrapper.cpp)

src/utils/RandomEngine.cpp

+
+#include <utils/Messenger.hpp>
+#include <utils/RandomEngine.hpp>
+
+std::unique_ptr<RandomEngine> RandomEngine::m_instance;
+
+void
+RandomEngine::create()
+{
+  m_instance = std::unique_ptr<RandomEngine>(new RandomEngine);
+}
+
+void
+RandomEngine::destroy()
+{
+  m_instance.reset();
+}
+
+RandomEngine::RandomEngine()
+{
+  m_initial_seed = std::random_device{}();
+  parallel::broadcast(m_initial_seed, 0);
+
+  m_random_engine = std::default_random_engine(m_initial_seed);
+
+  std::cout << " * setting " << rang::fgB::green << "random seed" << rang::style::reset << " to " << rang::fgB::yellow
+            << m_initial_seed << rang::style::reset << '\n';
+}
+
+void
+RandomEngine::setRandomSeed(const uint64_t random_seed)
+{
+  m_initial_seed  = random_seed;
+  m_random_engine = std::default_random_engine(m_initial_seed);
+
+  std::cout << " * setting " << rang::fgB::green << "random seed" << rang::style::reset << " to " << rang::fgB::yellow
+            << m_initial_seed << rang::style::reset << '\n';
+}
+
+void
+RandomEngine::resetRandomSeed()
+{
+  m_instance = std::unique_ptr<RandomEngine>(new RandomEngine);
+}

src/utils/RandomEngine.hpp

+#ifndef RANDOM_ENGINE_HPP
+#define RANDOM_ENGINE_HPP
+
+#include <utils/PugsAssert.hpp>
+#include <utils/PugsMacros.hpp>
+
+#include <memory>
+#include <random>
+
+class RandomEngine
+{
+ private:
+  static std::unique_ptr<RandomEngine> m_instance;
+
+  uint64_t m_initial_seed;
+  std::default_random_engine m_random_engine;
+
+  RandomEngine();
+
+ public:
+  void setRandomSeed(const uint64_t random_seed);
+  void resetRandomSeed();
+
+  static void create();
+
+  PUGS_INLINE
+  std::default_random_engine&
+  engine()
+  {
+    return m_random_engine;
+  }
+
+  PUGS_INLINE
+  static RandomEngine&
+  instance()
+  {
+    Assert(m_instance.get() != nullptr, "undefined random engine instance");
+    return *m_instance;
+  }
+
+  static void destroy();
+
+  RandomEngine(const RandomEngine&) = delete;
+  RandomEngine(RandomEngine&&)      = delete;
+
+  ~RandomEngine() = default;
+};
+
+#endif   // RANDOM_ENGINE_HPP