WeightManager.h

Go to the documentation of this file.

#ifndef WEIGHTMANAGER_H
#define WEIGHTMANAGER_H

#include "art/Framework/Principal/fwd.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "fhiclcpp/ParameterSet.h"
#include "lardataobj/Simulation/sim.h"
#include "nurandom/RandomUtils/NuRandomService.h"

#include "MCEventWeight.h"
#include "WeightCalc.h"
#include "WeightCalcFactory.h"
#include "Weight_t.h"

namespace evwgh {
  class WeightManager {
  public:
    WeightManager(const std::string name = "WeightManager");

    const std::string& Name() const;

    template <typename EngineCreator>
    size_t Configure(fhicl::ParameterSet const& cfg, EngineCreator engineCreator);

    MCEventWeight Run(art::Event& e, const int inu);

    std::map<std::string, Weight_t*> GetWeightCalcMap() { return fWeightCalcMap; }

    void Reset() { _configured = false; }

    void PrintConfig();

  private:
    std::map<std::string, Weight_t*> fWeightCalcMap; 
    bool _configured{false};                         
    std::string _name;                               
  };

  template <typename EngineCreator>
  size_t WeightManager::Configure(fhicl::ParameterSet const& p, EngineCreator createEngine)
  {

    ::art::ServiceHandle<rndm::NuRandomService> seedservice;

    // Get list of weight functions
    auto const rw_func = p.get<std::vector<std::string>>("weight_functions");

    // Loop over all the functions and register them
    auto const module_label = p.get<std::string>("module_label");
    for (auto const& func : rw_func) {
      auto const ps_func = p.get<fhicl::ParameterSet>(func);
      std::string func_type = ps_func.get<std::string>("type");

      WeightCalc* wcalc = WeightCalcFactory::Create(func_type + "WeightCalc");
      if (wcalc == nullptr)
        throw cet::exception(__FUNCTION__)
          << "Function " << func << " requested in fcl file has not been registered!" << std::endl;
      if (fWeightCalcMap.find(func) != fWeightCalcMap.end())
        throw cet::exception(__FUNCTION__)
          << "Function " << func << " has been requested multiple times in fcl file!" << std::endl;

      // Create random engine for each rw function (name=func) (and seed it with random_seed set in the fcl)
      CLHEP::HepRandomEngine& engine = seedservice->registerAndSeedEngine(
        createEngine("HepJamesRandom", func), "HepJamesRandom", func, ps_func, "random_seed");
      wcalc->SetName(func);
      wcalc->Configure(p, engine);
      Weight_t* winfo = new Weight_t();
      winfo->fWeightCalcType = func_type;
      winfo->fWeightCalc = wcalc;
      winfo->fNmultisims = ps_func.get<int>("number_of_multisims", 0);

      fWeightCalcMap.emplace(func, winfo);
    }

    _configured = true;
    return fWeightCalcMap.size();
  }

}

#endif