RandomEngineRegistry.cc

Go to the documentation of this file.

#include <map>
#include <string>
#include <sstream>
#include <stdio.h>
#include <fwk/RandomEngineRegistry.h>
#include <fwk/CentralConfig.h>
#include <utl/RandomEngine.h>
#include <utl/AugerException.h>
#include <utl/ErrorLogger.h>
#include <utl/Reader.h>

#include <CLHEP/Random/Randomize.h>

using namespace CLHEP;
using namespace utl;
using namespace std;


namespace fwk {

  void
  RandomEngineRegistry::RegisterOne(const RandomEngineID id, RandomEngine* const engine)
  {
    const bool ok = fRegistry->insert(make_pair(id, engine)).second;
    if (!ok) {
      ostringstream msg;
      msg << "Double insertion of random engine with id " << id;
      WARNING(msg);
    }
  }


  RandomEngine&
  RandomEngineRegistry::Get(const RandomEngineID id)
  {
    if (!fRegistry)
      Init();

    Registry::iterator it = fRegistry->find(id);
    if (it == fRegistry->end()) {
      ostringstream msg;
      msg << "Random engine with id " << id << " does not exist.";
      ERROR(msg);
      throw InvalidRandomEngineException(msg.str());
    }
    return *(it->second);
  }


  RandomEngineRegistry::~RandomEngineRegistry()
  {
    if (fRegistry)
      for (const auto& r : *fRegistry)
        delete r.second;
  }


  void
  RandomEngineRegistry::Init()
  {
    if (!fRegistry)
      fRegistry = new Registry;
    else {
      string msg("Calling Init, "
                 "but RandomEngineRegistry already initialized.");
      ERROR(msg);
      throw InitSequenceException(msg);
    }

    long seed[2] = { 0 };

    Branch topB = CentralConfig::GetInstance()->GetTopBranch("RandomEngineRegistry");

    if (topB) {
      topB.GetChild("DetectorSeed").GetData(seed[0]);
      topB.GetChild("PhysicsSeed").GetData(seed[1]);
    } else {
      WARNING("RandomEngine branch not found. Random seeds will be generated.");
    }

    if (seed[0] == seed[1] && seed[0] > 0) {
      ostringstream msg;
      msg << "DetectorSeed = " << seed[0] <<" = PhysicsSeed: This can lead to unwanted correlations!";
      ERROR(msg);
      throw InvalidConfigurationException(msg.str());
    }

    long randomSeed[2] = { 0 };
    GenerateSeeds(randomSeed, 2);
    for (int i = 0; i < 2; ++i)
      if (seed[i] <= 0)
        seed[i] = randomSeed[i];

    RandomEngine* const detectorengine = new RandomEngine(seed[0]);
    RegisterOne(eDetector, detectorengine);
    RegisterOne(ePhysics, new RandomEngine(seed[1]));

    ostringstream info;
    info << "Seeds of random streams: "
            "eDetector = " << seed[0] << ", "
            "ePhysics = " << seed[1] << '.';
    INFO(info);

    // set the default CLHEP engine for GEANT4 to be the eDetector engine
    HepRandom::setTheEngine(&detectorengine->GetEngine());
  }


  void
  RandomEngineRegistry::GenerateSeeds(long* const seed, const int n)
    const
  {
    FILE* const fd = fopen("/dev/urandom", "r");
    if (fd) {
      int i;
      for (i = 0; i < n; ++i) {
        size_t len;
        int s;
        do {
          len = fread(&s, sizeof(s), 1, fd);
        } while (len && !s);
        if (!len)
          break;
        seed[i] = abs(s);
      }
      fclose(fd);
      if (i == n)
        return;
    }

    WARNING("Unable to open /dev/random, using current time instead.");
    time_t s = time(nullptr);
    for (int i = 0; i < n; ++i)
      seed[i] = abs(int(s++));
  }

}