PerEventPolicy.h

Go to the documentation of this file.

#ifndef NURANDOM_RANDOMUTILS_PROVIDERS_PEREVENTPOLICY_H
#define NURANDOM_RANDOMUTILS_PROVIDERS_PEREVENTPOLICY_H 1

// C/C++ standard libraries
#include <string>
#include <memory> // std::unique_ptr<>
#include <type_traits> // std::make_signed<>

// From art and its tool chain
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "fhiclcpp/ParameterSet.h"
#include "canvas/Utilities/Exception.h"

// Some helper classes
#include "nurandom/RandomUtils/Providers/PolicyFactory.h" // makeRandomSeedPolicy
#include "nurandom/RandomUtils/Providers/RandomSeedPolicyBase.h"
#include "nurandom/RandomUtils/Providers/EngineId.h"
#include "nurandom/RandomUtils/Providers/EventSeedInputData.h"


namespace rndm {
  
  namespace details {
    
    template <typename SEED>
    class PerEventPolicy: public RandomSeedPolicyBase<SEED> {
        public:
      using base_t = RandomSeedPolicyBase<SEED>;
      using this_t = PerEventPolicy<SEED>;
      using seed_t = typename base_t::seed_t;
      
      using EventData_t = NuRandomServiceHelper::EventSeedInputData;
      
      typedef enum {
        saEventTimestamp_v1,             
        NAlgos,                          
        saUndefined,                     
        saDefault = saEventTimestamp_v1  
      } SeedAlgo_t; 
      
      PerEventPolicy(fhicl::ParameterSet const& pset): base_t("perEvent")
        { this_t::configure(pset); }
      
      virtual bool yieldsUniqueSeeds() const override { return false; }
      
      
      virtual void configure(fhicl::ParameterSet const& pset) override;
      
      virtual void print(std::ostream& out) const override;
      
      
      static constexpr const char* DefaultVersion = "v1";
      
      
      template <typename Hashable>
      static seed_t SeedFromHash(Hashable const& info)
        { return makeValid(std::hash<Hashable>()(info)); }
      
      static std::string UniqueEventIDString(EventData_t const& info);
      
      static std::string UniqueEventString(EventData_t const& info);
      
      
        private:
      
      using SeedOffset_t = typename std::make_signed<seed_t>::type;
      
      SeedAlgo_t algo; 
      
      SeedOffset_t offset; 
      
      PolicyStruct_t<seed_t> initSeedPolicy;
      
      virtual seed_t createSeed(SeedMasterHelper::EngineId const& id) override;
      
      virtual seed_t createEventSeed
        (SeedMasterHelper::EngineId const& id, EventData_t const& info)
        override;
      
      template <typename T>
      static seed_t makeValid(T value) { return ValidSeed<seed_t>(value); }
      
      static seed_t EventTimestamp_v1
        (SeedMasterHelper::EngineId const& id, EventData_t const& info);
      
      
      static const std::vector<std::string> algoNames;
      
      static std::vector<std::string> InitAlgoNames();
    }; // class PerEventPolicy<>
    
    
    
    //--------------------------------------------------------------------------
    //---  PerEventPolicy template implementation
    //---
    template <typename SEED>
    std::vector<std::string> PerEventPolicy<SEED>::InitAlgoNames() {
      
      std::vector<std::string> names((size_t) NAlgos);
      
      names[saEventTimestamp_v1] = "EventTimestamp_v1";
      
      return names;
    } // PerEventPolicy<SEED>::InitAlgoNames()
    
    
    template <typename SEED>
    const std::vector<std::string> PerEventPolicy<SEED>::algoNames
      = PerEventPolicy<SEED>::InitAlgoNames();
    
    
    //--------------------------------------------------------------------------
    template <typename SEED>
    std::string PerEventPolicy<SEED>::UniqueEventIDString
      (EventData_t const& info)
    {
      return "Run: " + std::to_string(info.runNumber)
        + " Subrun: " + std::to_string(info.subRunNumber)
        + " Event: "  + std::to_string(info.eventNumber)
        ;
    } // PerEventPolicy<SEED>::UniqueEventIDString()
    
    
    template <typename SEED>
    std::string PerEventPolicy<SEED>::UniqueEventString
      (EventData_t const& info)
    {
      return UniqueEventIDString(info)
        + " Timestamp: " + std::to_string(info.time);
    } // PerEventPolicy<SEED>::UniqueEventString()
    
    
    template <typename SEED>
    auto PerEventPolicy<SEED>::EventTimestamp_v1
      (SeedMasterHelper::EngineId const& id, EventData_t const& info)
      -> seed_t
    {
      if (!info.isTimeValid) {
        throw art::Exception(art::errors::InvalidNumber)
          << "Input event has an invalid timestamp,"
          " random seed per-event policy EventTimestamp_v1 can't be used.\n";
      }
      std::string s = UniqueEventString(info)
        + " Process: " + info.processName
        + " Module: " + id.moduleLabel;
      if (!id.instanceName.empty())
        s.append(" Instance: ").append(id.instanceName);
      seed_t seed = SeedFromHash(s);
      MF_LOG_DEBUG("PerEventPolicy") << "Seed from: '" << s << "': " << seed;
      return seed;
    } // PerEventPolicy<SEED>::EventTimestamp_v1()
    
    
    //--------------------------------------------------------------------------
    template <typename SEED>
    void PerEventPolicy<SEED>::configure(fhicl::ParameterSet const& pset) {
      // set the per-event algorithm
      algo = saUndefined;
      std::string algorithm_name
         = pset.get<std::string>("algorithm", "default");
      
      if (algorithm_name == "default") algo = saDefault;
      else {
        for (size_t iAlgo = 0; iAlgo < (size_t) NAlgos; ++iAlgo) {
          if (algorithm_name != algoNames[iAlgo]) continue;
          algo = (SeedAlgo_t) iAlgo;
          break;
        } // for
      }
      if (algo == saUndefined) {
        throw art::Exception(art::errors::Configuration)
          << "No valid event random seed algorithm specified!\n";
      }
      
      // read an optional overall offset
      offset = pset.get<SeedOffset_t>("offset", 0);
      
      // EventTimestamp_v1 does not require specific configuration
      
      
      // set the pre-event algorithm
      auto const& initSeedConfig
        = pset.get<fhicl::ParameterSet>("initSeedPolicy", {});
      if (!initSeedConfig.is_empty()) {
        try {
          initSeedPolicy = makeRandomSeedPolicy<seed_t>(initSeedConfig);
        }
        catch(cet::exception const& e) {
          throw cet::exception{ "PerEventPolicy", "", e }
            << "Error creating the pre-event policy of `perEvent` random policy"
            " from configuration:\n"
            << initSeedConfig.to_indented_string(2);
        }
      } // if pre-event policy
      
    } // PerEventPolicy<SEED>::configure()
    
    
    //--------------------------------------------------------------------------
    template <typename SEED>
    void PerEventPolicy<SEED>::print(std::ostream& out) const {
      base_t::print(out);
      out
        << "\n  algorithm version: " << algoNames[algo];
      if (offset != 0)
        out << "\n  constant offset:   " << offset;
      if (initSeedPolicy) {
        out << "\n  special policy for random seeds before the event: '"
          << policyName(initSeedPolicy.policy)
          << "'\n" << std::string(60, '-');
        initSeedPolicy->print(out);
        out << "\n" << std::string(60, '-');
      }
    } // PerEventPolicy<SEED>::print()
    
    
    //--------------------------------------------------------------------------
    template <typename SEED>
    typename PerEventPolicy<SEED>::seed_t PerEventPolicy<SEED>::createSeed
      (SeedMasterHelper::EngineId const& id)
    { return initSeedPolicy? initSeedPolicy->getSeed(id): base_t::InvalidSeed; }
    
    
    //--------------------------------------------------------------------------
    template <typename SEED>
    typename PerEventPolicy<SEED>::seed_t PerEventPolicy<SEED>::createEventSeed
        (SeedMasterHelper::EngineId const& id, EventData_t const& info)
    {
      seed_t seed = base_t::InvalidSeed;
      switch (algo) {
        case saEventTimestamp_v1:
          seed = EventTimestamp_v1(id, info);
          break;
        case saUndefined:
          throw art::Exception(art::errors::Configuration)
            << "Per-event random number seeder not configured!\n";
        default:
          throw art::Exception(art::errors::LogicError)
            << "Unsupported per-event random number seeder (#"
            << ((int) algo) << ")\n";
      } // switch
      return seed + offset;
    } // PerEventPolicy<SEED>::createEventSeed()
    
    
  } // namespace details
  
} // namespace rndm


#endif // NURANDOM_RANDOMUTILS_PROVIDERS_PEREVENTPOLICY_H