Node.h

Go to the documentation of this file.

#ifndef RDFAnalysis_Node_H
#define RDFAnalysis_Node_H

// Package includes
#include "RDFAnalysis/EmptyDetail.h"
#include "RDFAnalysis/NodeBase.h"
#include "RDFAnalysis/NodeFwd.h"

namespace RDFAnalysis {

  template <typename Detail>
  class Node : public NodeBase
  {
    public:
      // Typedefs
      using detail_t = Detail;

      template <typename F>
          enable_ifn_string_t<F, Node*> Define(
            const std::string& name,
            F f,
            const ColumnNames_t& columns = {})
          { 
            NodeBase::Define(name, f, columns);
            return this;
          }

      Node* Define(
          const std::string& name,
          const std::string& expression)
      {
        NodeBase::Define(name, expression);
        return this;
      }

      Node* Define(
          const std::string& name,
          const std::string& expression,
          const ColumnNames_t& columns)
      {
        NodeBase::Define(name, expression, columns);
        return this;
      }

      template <
        std::size_t N,
        typename F,
        typename Ret_t = typename ROOT::TTraits::CallableTraits<F>::ret_type>
        std::enable_if_t<N==std::tuple_size<Ret_t>::value, Node>* Define(
            const std::array<std::string, N>& names,
            F f,
            const ColumnNames_t& columns)
        {
          NodeBase::Define(names, f, columns);
          return this;
        }

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

      template <typename F>
        std::enable_if_t<std::is_convertible<typename ROOT::TTraits::CallableTraits<F>::ret_type, bool>::value, Node*> Filter(
            F f,
            const ColumnNames_t& columns = {},
            const std::string& name = "",
            const std::string& cutflowName = "",
            const std::string& weight = "",
            WeightStrategy strategy = WeightStrategy::Default);

      Node* Filter(
          const std::string& expression,
          const std::string& name = "",
          const std::string& cutflowName = "",
          const std::string& weight = "",
          WeightStrategy strategy = WeightStrategy::Default);

      template <typename F, typename W>
        std::enable_if_t<!std::is_convertible<F, std::string>::value && !std::is_convertible<W, std::string>::value, Node*> Filter(
            F f,
            const ColumnNames_t& columns,
            const std::string& name,
            const std::string& cutflowName,
            W w,
            const ColumnNames_t& weightColumns = {},
            WeightStrategy strategy = WeightStrategy::Default);

      template <typename W>
        enable_ifn_string_t<W, Node*> Filter(
            const std::string& expression,
            const std::string& name,
            const std::string& cutflowName,
            W w,
            const ColumnNames_t& weightColumns = {},
            WeightStrategy strategy = WeightStrategy::Default);

      auto children() { return as_range(m_children); }
      auto children() const { return as_range(m_children); }

      Detail& detail() { return m_detail; }
      const Detail& detail() const { return m_detail; }

      Node* parent() { return m_parent; }
      const Node* parent() const { return m_parent; }

      bool isRoot() const { return m_parent == nullptr; }

      static std::unique_ptr<Node> createROOT(
          const RNode& rnode,
          std::unique_ptr<IBranchNamer>&& namer,
          bool isMC,
          const std::string& name = "ROOT",
          const std::string& cutflowName = "Number of events",
          const std::string& weight = "",
          WeightStrategy strategy = WeightStrategy::Default)
      {
        return std::unique_ptr<Node>(
            new Node(rnode, std::move(namer), isMC, 
              name, cutflowName, weight, strategy) );
      }

      void run(ULong64_t printEvery);

      void run(ULong64_t printEvery, ULong64_t total);

      template <typename Monitor>
        void run(Monitor monitor);

    private:
      Node(
          const RNode& rnode,
          std::unique_ptr<IBranchNamer>&& namer,
          bool isMC,
          const std::string& name = "ROOT",
          const std::string& cutflowName = "Number of events",
          const std::string& weight = "",
          WeightStrategy strategy = WeightStrategy::Default);

      template <typename W>
        Node(
            const RNode& rnode,
            std::unique_ptr<IBranchNamer>&& namer,
            bool isMC,
            const std::string& name,
            const std::string& cutflowName,
            W w,
            const ColumnNames_t& columns,
            WeightStrategy strategy);

      Node(
          Node& parent,
          std::map<std::string, RNode>&& rnodes,
          const std::string& name,
          const std::string& cutflowName,
          const std::string& weight,
          WeightStrategy strategy);


      template <typename W>
        Node(
            Node& parent,
            std::map<std::string, RNode>&& rnodes,
            const std::string& name,
            const std::string& cutflowName,
            W w,
            const ColumnNames_t& columns,
            WeightStrategy strategy);

      Node* m_parent = nullptr;

      std::vector<std::unique_ptr<Node>> m_children;

      Detail m_detail;
  }; //> end class Node

} //> end namespace RDFAnalysis
#include "RDFAnalysis/Node.icc"
#endif //> !RDFAnalysis_Node_H