NuRandomService.h

Go to the documentation of this file.

#ifndef NUTOOLS_RANDOMUTILS_NuRandomService_H
#define NUTOOLS_RANDOMUTILS_NuRandomService_H 1

#ifndef NUTOOLS_RANDOMUTILS_NuRandomService_USECLHEP
#  define NUTOOLS_RANDOMUTILS_NuRandomService_USECLHEP 1
#endif // NUTOOLS_RANDOMUTILS_NuRandomService_USECLHEP

// ROOT libraries
#ifndef NUTOOLS_RANDOMUTILS_NuRandomService_USEROOT
#  define NUTOOLS_RANDOMUTILS_NuRandomService_USEROOT 0
#endif // NUTOOLS_RANDOMUTILS_NuRandomService_USEROOT


// C/C++ standard libraries
#include <string>
#include <utility> // std::forward()
#include <initializer_list>

// Some helper classes.
#include "nutools/RandomUtils/ArtState.h"
#include "nutools/RandomUtils/Providers/SeedMaster.h"

// CLHEP libraries
#if (NUTOOLS_RANDOMUTILS_NuRandomService_USECLHEP)
#  include "CLHEP/Random/RandomEngine.h"
#endif // NUTOOLS_RANDOMUTILS_NuRandomService_USECLHEP

// ROOT libraries
#if (NUTOOLS_RANDOMUTILS_NuRandomService_USEROOT)
#  include "TRandom.h"
#endif // NUTOOLS_RANDOMUTILS_NuRandomService_USEROOT

// From art and its tool chain.
#include "fhiclcpp/ParameterSet.h"
#include "art/Framework/Services/Optional/RandomNumberGenerator.h"
#include "art/Framework/Services/Registry/ServiceMacros.h"

// Forward declarations
namespace art {
  class ActivityRegistry;
  class ModuleDescription;
  class Run;
  class SubRun;
  class EngineCreator;
}

namespace rndm {
  
  class NuRandomService {
      public:
    using seed_t = art::RandomNumberGenerator::seed_t;
    
    using SeedMaster_t = SeedMaster<seed_t>; 
    
    using EngineId = SeedMaster_t::EngineId; 
    
    static constexpr seed_t InvalidSeed = SeedMaster_t::InvalidSeed;
    
    NuRandomService(const fhicl::ParameterSet&, art::ActivityRegistry&);
    
    // Accept compiler written d'tor.  Not copyable or assignable.
    // This class is not copyable or assignable: these methods are not implemented.
    NuRandomService(NuRandomService const&) = delete;
    NuRandomService const& operator=(NuRandomService const&) = delete;
    NuRandomService(NuRandomService&&) = delete;
    NuRandomService const& operator=(NuRandomService&&) = delete;
    ~NuRandomService() = default;
    
    static constexpr bool isSeedValid(seed_t seed)
      { return seed != InvalidSeed; }
    
    
    seed_t getSeed(std::string instanceName);
    
    seed_t getSeed();
    
    
    seed_t getGlobalSeed(std::string instanceName);
    
    
    seed_t getCurrentSeed(std::string instanceName) const
      { return seeds.getCurrentSeed(qualify_engine_label(instanceName)); }
    
    seed_t getCurrentSeed() const
      { return seeds.getCurrentSeed(qualify_engine_label()); }
    
    seed_t getGlobalCurrentSeed(std::string instanceName) const
      { return seeds.getCurrentSeed(qualify_global_engine(instanceName)); }
    
    

    seed_t createEngine
      (art::EngineCreator& module, std::string type, std::string instance = "");
    seed_t createEngine(art::EngineCreator& module);
    

    seed_t createEngine(
      art::EngineCreator& module, std::string type, std::string instance,
      fhicl::ParameterSet const& pset, std::string pname
      )
      { return createEngine(module, type, instance, pset, { pname }); }
    seed_t createEngine(
      art::EngineCreator& module, std::string type, std::string instance,
      fhicl::ParameterSet const& pset, std::initializer_list<std::string> pnames
      );
    seed_t createEngine(
      art::EngineCreator& module, std::string type,
      fhicl::ParameterSet const& pset, std::string pname
      )
      { return createEngine(module, type, "", pset, pname); }
    seed_t createEngine(
      art::EngineCreator& module, std::string type,
      fhicl::ParameterSet const& pset, std::initializer_list<std::string> pnames
      )
      { return createEngine(module, type, "", pset, pnames); }
    seed_t createEngine(
      art::EngineCreator& module,
      fhicl::ParameterSet const& pset, std::string pname
      )
      { return createEngine(module, pset, { pname }); }
    seed_t createEngine(
      art::EngineCreator& module,
      fhicl::ParameterSet const& pset, std::initializer_list<std::string> pnames
      );
    
    
    
    seed_t registerEngine
      (SeedMaster_t::Seeder_t seeder, std::string instance = "" );
    

    seed_t registerEngine(
      SeedMaster_t::Seeder_t seeder, std::string instance,
      fhicl::ParameterSet const& pset, std::string pname
      )
      { return registerEngine(seeder, instance, pset, { pname }); }
    seed_t registerEngine(
      SeedMaster_t::Seeder_t seeder, std::string instance,
      fhicl::ParameterSet const& pset, std::initializer_list<std::string> pnames
      );
    seed_t registerEngine(
      SeedMaster_t::Seeder_t seeder,
      fhicl::ParameterSet const& pset, std::string pname
      )
      { return registerEngine(seeder, "", pset, pname); }
    seed_t registerEngine(
      SeedMaster_t::Seeder_t seeder,
      fhicl::ParameterSet const& pset, std::initializer_list<std::string> pnames
      )
      { return registerEngine(seeder, "", pset, pnames); }
    
#if (NUTOOLS_RANDOMUTILS_NuRandomService_USECLHEP)

    seed_t registerEngine
      (CLHEP::HepRandomEngine& engine, std::string instance = "")
      { return registerEngine(CLHEPengineSeeder(engine), instance); }
    seed_t registerEngine(
      CLHEP::HepRandomEngine& engine, std::string instance,
      fhicl::ParameterSet const& pset, std::initializer_list<std::string> pnames
      )
      {
        return registerEngine
          (CLHEPengineSeeder(engine), instance, pset, pnames);
      }
#endif // NUTOOLS_RANDOMUTILS_NuRandomService_USECLHEP
    
    
    
    seed_t declareEngine(std::string instance = "");
    
    seed_t declareEngine
      (std::string instance, fhicl::ParameterSet const& pset, std::string pname)
      { return declareEngine(instance, pset, { pname }); }
    
    seed_t declareEngine(
      std::string instance,
      fhicl::ParameterSet const& pset, std::initializer_list<std::string> pnames
      );
    
    seed_t declareEngine(fhicl::ParameterSet const& pset, std::string pname)
      { return declareEngine("", pset, pname); }
    
    seed_t declareEngine(
      fhicl::ParameterSet const& pset, std::initializer_list<std::string> pnames
      )
      { return declareEngine("", pset, pnames); }
    

    seed_t defineEngine
      (SeedMaster_t::Seeder_t seeder, std::string instance = {});
    
    #if (NUTOOLS_RANDOMUTILS_NuRandomService_USECLHEP)

    seed_t defineEngine
      (CLHEP::HepRandomEngine& engine, std::string instance = {})
      { return defineEngine(CLHEPengineSeeder(engine), instance); }
    #endif // NUTOOLS_RANDOMUTILS_NuRandomService_USECLHEP
    
    
    template<class Stream>
    void print(Stream&& out) const
      { seeds.print(std::forward<Stream>(out)); }
    
    void print() const { print(mf::LogInfo("NuRandomService")); }
    
    static void RandomNumberGeneratorSeeder(EngineId const& id, seed_t seed);
    
#if (NUTOOLS_RANDOMUTILS_NuRandomService_USEROOT)
    class TRandomSeeder {
        public:
      TRandomSeeder(TRandom* engine): pRandom(engine) {}
      void operator() (EngineId const&, seed_t seed)
        { if (pRandom) pRandom->SetSeed(seed); }
        protected:
      TRandom* pRandom = nullptr;
    }; // class TRandomSeeder
#endif // NUTOOLS_RANDOMUTILS_NuRandomService_USEROOT
    
#if (NUTOOLS_RANDOMUTILS_NuRandomService_USECLHEP)
    class CLHEPengineSeeder {
        public:
      CLHEPengineSeeder(CLHEP::HepRandomEngine& e): engine(e) {}
      CLHEPengineSeeder(CLHEP::HepRandomEngine* e): engine(*e) {}
      void operator() (EngineId const&, seed_t seed)
        {
          engine.setSeed(seed, 0);
          LOG_DEBUG("CLHEPengineSeeder")
            << "CLHEP engine: '" << engine.name() << "'[" << ((void*) &engine)
            << "].setSeed(" << seed << ", 0)";
        }
        protected:
      CLHEP::HepRandomEngine& engine;
    }; // class CLHEPengineSeeder
#endif // NUTOOLS_RANDOMUTILS_NuRandomService_USECLHEP
    
  private:
    
    
    SeedMaster_t seeds;
    
    NuRandomServiceHelper::ArtState state;
    
    int verbosity = 0;
    bool bPrintEndOfJobSummary = false; 
    
    seed_t registerEngineID(
      EngineId const& id,
      SeedMaster_t::Seeder_t seeder = SeedMaster_t::Seeder_t()
      );
    
    seed_t defineEngineID(EngineId const& id, SeedMaster_t::Seeder_t seeder);


    bool hasEngine(EngineId const& id) const { return seeds.hasEngine(id); }
    
    // Main logic for computing and validating a seed.
    seed_t getSeed(EngineId const&);
    
    // Main logic for computing and validating a seed.
    seed_t getEventSeed(EngineId const&);
    
    seed_t reseedInstance(EngineId const& id);
    
    void reseedModule(std::string currentModule);
    void reseedModule();
    
    void reseedGlobal();
    
    seed_t prepareEngine(EngineId const& id, SeedMaster_t::Seeder_t seeder);
    
    // Helper functions for all policies
    void ensureValidState(bool bGlobal = false) const;
    
    EngineId qualify_engine_label
      (std::string moduleLabel, std::string instanceName) const;
    EngineId qualify_engine_label(std::string instanceName = "") const;
    EngineId qualify_global_engine(std::string instanceName = "") const
      { return EngineId(instanceName, EngineId::global); }
    
    static bool readSeedParameter
      (seed_t& seed, fhicl::ParameterSet const& pset, std::string pname)
      { return readSeedParameter(seed, pset, { pname }); }
    static bool readSeedParameter(
      seed_t& seed, fhicl::ParameterSet const& pset,
      std::initializer_list<std::string> pnames
      );
    
    seed_t querySeed(EngineId const& id);
    
    std::pair<seed_t, bool> findSeed(
      EngineId const& id,
      fhicl::ParameterSet const& pset, std::initializer_list<std::string> pnames
      );
    
    void freezeSeed(EngineId const& id, seed_t frozen_seed);
    
    void registerEngineAndSeeder
      (EngineId const& id, SeedMaster_t::Seeder_t seeder);
    
    seed_t seedEngine(EngineId const& id) { return seeds.reseed(id); }
    
    // Call backs that will be called by art.
    void preModuleConstruction (art::ModuleDescription const& md);
    void postModuleConstruction(art::ModuleDescription const&);
    void preModuleBeginRun     (art::ModuleDescription const& md);
    void postModuleBeginRun    (art::ModuleDescription const&);
    void preProcessEvent       (art::Event const& evt);
    void preModule             (art::ModuleDescription const& md);
    void postModule            (art::ModuleDescription const&);
    void postProcessEvent      (art::Event const&);
    void preModuleEndJob       (art::ModuleDescription const& md);
    void postModuleEndJob      (art::ModuleDescription const&);
    void postEndJob            ();
    
    
 }; // class NuRandomService
  
  
  
} // namespace rndm

DECLARE_ART_SERVICE(rndm::NuRandomService, LEGACY)

#endif // NUTOOLS_RANDOMUTILS_NuRandomService_H