Scheduler.h

Go to the documentation of this file.

#ifndef RDFAnalysis_Scheduler_H
#define RDFAnalysis_Scheduler_H

// Package includes
#include "RDFAnalysis/Node.h"
#include "RDFAnalysis/SchedulerBase.h"
#include "RDFAnalysis/ScheduleNamer.h"

namespace RDFAnalysis {
  template <typename Detail>
    class Scheduler : public SchedulerBase {
      public:
        using detail_t = Detail;
        using node_t = Node<Detail>;

        Scheduler(node_t* root) : m_root(root), m_namer(root->namer() ) {}

        node_t* root() { return m_root; }

        ScheduleNode& schedule(const std::string& graphFile = "");

        struct Region {
          node_t* node;

          std::vector<SysResultPtr<TObject>> objects;
        }; //> end struct Region
        
        std::map<std::string, Region>& regions() { return m_regions; }
        
        const std::map<std::string, Region>& regions() const
        { return m_regions; }

        void registerVariableImpl(
            const std::string& name,
            std::function<void(node_t*)> action,
            const std::set<std::string>& variables = {},
            const std::set<std::string>& filters = {},
            float cost = 0);

        template <typename F>
          enable_ifn_string_t<F, void> registerVariable(
              const std::string& name, 
              F f,
              const ColumnNames_t& columns = {},
              const std::set<std::string>& filters = {},
              float cost = 0);

        void registerVariable(
            const std::string& name,
            const std::string& expression,
            const std::set<std::string>& filters = {},
            float cost = 0);

        void registerVariable(
            const std::string& name,
            const std::string& expression,
            const ColumnNames_t& columns,
            const std::set<std::string>& filters,
            float cost = 0);


        template <std::size_t N>
          void registerVariablesImpl(
              const std::array<std::string, N>& names,
              std::function<void(node_t*)> action,
              const std::set<std::string>& variables = {},
              const std::set<std::string>& filters = {},
              float cost = 0);

        template <std::size_t N, typename F>
          enable_ifn_string_t<F, void> registerVariables(
              const std::array<std::string, N>& names,
              F f,
              const ColumnNames_t& columns,
              const std::set<std::string>& filters = {},
              float cost = 0);

        void registerFilterImpl(
            const std::string& name,
            std::function<node_t*(node_t*)> action,
            const std::set<std::string>& variables = {},
            const std::set<std::string>& filters = {},
            float cost = 0);

      template <typename F>
        std::enable_if_t<std::is_convertible<typename ROOT::TTraits::CallableTraits<F>::ret_type, std::tuple<bool, float>>::value, void> registerFilter(
            F f,
            const ColumnNames_t& columns,
            const std::string& name,
            const std::string& cutflowName = "",
            WeightStrategy strategy = WeightStrategy::Default,
            const std::set<std::string>& filters = {},
            float cost = 0);

      template <typename F>
        std::enable_if_t<std::is_convertible<typename ROOT::TTraits::CallableTraits<F>::ret_type, bool>::value, void> registerFilter(
            F f,
            const ColumnNames_t& columns,
            const std::string& name,
            const std::string& cutflowName = "",
            const std::string& weight = "",
            WeightStrategy strategy = WeightStrategy::Default,
            const std::set<std::string>& filters = {},
            float cost = 0);

      void registerFilter(
          const std::string& expression,
          const std::string& name,
          const std::string& cutflowName = "",
          const std::string& weight = "",
          WeightStrategy strategy = WeightStrategy::Default,
          const std::set<std::string>& filters = {},
          float cost = 0);

      template <typename F, typename W>
        std::enable_if_t<!std::is_convertible<F, std::string>::value && !std::is_convertible<W, std::string>::value, void> registerFilter(
            F f,
            const ColumnNames_t& columns,
            const std::string& name,
            const std::string& cutflowName,
            W w,
            const ColumnNames_t& weightColumns = {},
            WeightStrategy strategy = WeightStrategy::Default,
            const std::set<std::string>& filters = {},
            float cost = 0);

      template <typename W>
        enable_ifn_string_t<W, void> registerFilter(
            const std::string& expression,
            const std::string& name,
            const std::string& cutflowName,
            W w,
            const ColumnNames_t& weightColumns = {},
            WeightStrategy strategy = WeightStrategy::Default,
            const std::set<std::string>& filters = {},
            float cost = 0);
        
        void registerFillImpl(
            const std::string& name,
            std::function<SysResultPtr<TObject>(node_t*)> action,
            const std::set<std::string>& variables = {},
            const std::set<std::string>& filters = {});

      template <typename T>
        void registerFill(
            const T& model,
            const ColumnNames_t& columns,
            const std::string& weight = "",
            WeightStrategy strategy = WeightStrategy::Default,
            const std::set<std::string>& filters = {});

      protected:
        std::map<std::string, std::function<node_t*(node_t*)>> m_filters;
        std::map<std::string, std::function<void(node_t*)>> m_variables;
        std::map<std::string, std::function<SysResultPtr<TObject>(node_t*)>> m_fills;
        node_t* m_root;
        ScheduleNamer m_namer;
        std::map<std::string, Region> m_regions;
        void addNode(const ScheduleNode& source, 
                     node_t* target,
                     const std::string& currentRegion = "");
    }; //> end class Scheduler
} //> end namespace RDFAnalysis
#include "RDFAnalysis/Scheduler.icc"
#endif //> !RDFAnalysis_Scheduler_H