[df] First integration of RHist filling

As the classes are experimental, using the method will print a warning
to inform the user.

Author: hahnjo

tree/dataframe/CMakeLists.txt

@@ -26,6 +26,10 @@ if (imt)
   list(APPEND RDATAFRAME_EXTRA_DEPS Imt)
 endif(imt)
 
+if (root7)
+  list(APPEND RDATAFRAME_EXTRA_DEPS ROOTHist)
+endif()
+
 set (EXTRA_DICT_OPTS)
 if (runtime_cxxmodules AND WIN32)
   set (EXTRA_DICT_OPTS NO_CXXMODULE)

tree/dataframe/inc/ROOT/RDF/ActionHelpers.hxx

@@ -32,6 +32,12 @@
 #include "ROOT/RDF/RActionImpl.hxx"
 #include "ROOT/RDF/RMergeableValue.hxx"
 
+#include "RConfigure.h" // for R__HAS_ROOT7
+#ifdef R__HAS_ROOT7
+#include <ROOT/RHist.hxx>
+#include <ROOT/RHistConcurrentFiller.hxx>
+#endif
+
 #include <algorithm>
 #include <array>
 #include <limits>
@@ -469,6 +475,52 @@ public:
    }
 };
 
+#ifdef R__HAS_ROOT7
+template <typename BinContentType>
+class R__CLING_PTRCHECK(off) RHistFillHelper : public ROOT::Detail::RDF::RActionImpl<RHistFillHelper<BinContentType>> {
+public:
+   using Result_t = ROOT::Experimental::RHist<BinContentType>;
+
+private:
+   std::unique_ptr<ROOT::Experimental::RHistConcurrentFiller<BinContentType>> fFiller;
+   std::vector<std::shared_ptr<ROOT::Experimental::RHistFillContext<BinContentType>>> fContexts;
+
+public:
+   RHistFillHelper(std::shared_ptr<ROOT::Experimental::RHist<BinContentType>> h, unsigned int nSlots)
+      : fFiller(new ROOT::Experimental::RHistConcurrentFiller<BinContentType>(h)), fContexts(nSlots)
+   {
+      for (unsigned int i = 0; i < nSlots; i++) {
+         fContexts[i] = fFiller->CreateFillContext();
+      }
+   }
+   RHistFillHelper(const RHistFillHelper &) = delete;
+   RHistFillHelper(RHistFillHelper &&) = default;
+   RHistFillHelper &operator=(const RHistFillHelper &) = delete;
+   RHistFillHelper &operator=(RHistFillHelper &&) = default;
+   ~RHistFillHelper() = default;
+
+   std::shared_ptr<Result_t> GetResultPtr() const { return fFiller.GetHist(); }
+
+   void Initialize() {}
+   void InitTask(TTreeReader *, unsigned int) {}
+
+   template <typename... ColumnTypes>
+   void Exec(unsigned int slot, const ColumnTypes &...columnValues)
+   {
+      fContexts[slot]->Fill(columnValues...);
+   }
+
+   void Finalize()
+   {
+      for (auto &&context : fContexts) {
+         context->Flush();
+      }
+   }
+
+   std::string GetActionName() { return "Hist"; }
+};
+#endif
+
 class R__CLING_PTRCHECK(off) FillTGraphHelper : public ROOT::Detail::RDF::RActionImpl<FillTGraphHelper> {
 public:
    using Result_t = ::TGraph;

tree/dataframe/inc/ROOT/RDF/InterfaceUtils.hxx

@@ -28,6 +28,7 @@
 #include <string_view>
 #include <ROOT/RDF/RVariation.hxx>
 #include <ROOT/TypeTraits.hxx>
+#include <RConfigure.h> // for R__HAS_ROOT7
 #include <TError.h> // gErrorIgnoreLevel
 #include <TH1.h>
 #include <TROOT.h> // IsImplicitMTEnabled
@@ -90,6 +91,7 @@ struct Histo2D{};
 struct Histo3D{};
 struct HistoND{};
 struct HistoNSparseD{};
+struct Hist{};
 struct Graph{};
 struct GraphAsymmErrors{};
 struct Profile1D{};
@@ -171,6 +173,20 @@ BuildAction(const ColumnNames_t &bl, const std::shared_ptr<ActionResultType> &h,
    }
 }
 
+#ifdef R__HAS_ROOT7
+// Action for RHist using RHistConcurrentFiller
+template <typename... ColTypes, typename BinContentType, typename PrevNodeType>
+std::unique_ptr<RActionBase>
+BuildAction(const ColumnNames_t &columnList, const std::shared_ptr<ROOT::Experimental::RHist<BinContentType>> &h,
+            const unsigned int nSlots, std::shared_ptr<PrevNodeType> prevNode, ActionTags::Hist,
+            const RColumnRegister &colRegister)
+{
+   using Helper_t = RHistFillHelper<BinContentType>;
+   using Action_t = RAction<Helper_t, PrevNodeType, TTraits::TypeList<ColTypes...>>;
+   return std::make_unique<Action_t>(Helper_t(h, nSlots), columnList, std::move(prevNode), colRegister);
+}
+#endif
+
 template <typename... ColTypes, typename PrevNodeType>
 std::unique_ptr<RActionBase>
 BuildAction(const ColumnNames_t &bl, const std::shared_ptr<TGraph> &g, const unsigned int nSlots,

tree/dataframe/inc/ROOT/RDF/RInterface.hxx

@@ -45,6 +45,11 @@
 #include "TProfile2D.h"
 #include "TStatistic.h"
 
+#include "RConfigure.h" // for R__HAS_ROOT7
+#ifdef R__HAS_ROOT7
+#include <ROOT/RHist.hxx>
+#endif
+
 #include <algorithm>
 #include <cstddef>
 #include <initializer_list>
@@ -2357,6 +2362,66 @@ public:
          columnList, h, h, fProxiedPtr, columnList.size());
    }
 
+#ifdef R__HAS_ROOT7
+   ////////////////////////////////////////////////////////////////////////////
+   /// \brief Fill and return an RHist (*lazy action*).
+   /// \tparam BinContentType The bin content type of the returned RHist.
+   /// \param[in] axes The returned histogram will be constructed using these axes.
+   /// \param[in] columnList A list containing the names of the columns that will be passed when calling `Fill`
+   /// \return the histogram wrapped in a RResultPtr.
+   ///
+   /// This action is *lazy*: upon invocation of this method the calculation is
+   /// booked but not executed. Also see RResultPtr.
+   ///
+   /// ### Example usage:
+   /// ~~~{.cpp}
+   /// ROOT::Experimental::RRegularAxis axis(10, {5.0, 15.0});
+   /// auto myHist = myDf.Hist({axis}, {"col0"});
+   /// ~~~
+   template <typename BinContentType = double, typename ColumnType = RDFDetail::RInferredType, typename... ColumnTypes>
+   RResultPtr<ROOT::Experimental::RHist<BinContentType>>
+   Hist(std::vector<ROOT::Experimental::RAxisVariant> axes, const ColumnNames_t &columnList)
+   {
+      std::shared_ptr h = std::make_shared<ROOT::Experimental::RHist<BinContentType>>(std::move(axes));
+      if (h->GetNDimensions() != columnList.size()) {
+         throw std::runtime_error("Wrong number of columns for the specified number of histogram axes.");
+      }
+
+      return Hist<ColumnType, ColumnTypes...>(h, columnList);
+   }
+
+   ////////////////////////////////////////////////////////////////////////////
+   /// \brief Fill the provided RHist (*lazy action*).
+   /// \param[in] h The histogram that should be filled.
+   /// \param[in] columnList A list containing the names of the columns that will be passed when calling `Fill`
+   /// \return the histogram wrapped in a RResultPtr.
+   ///
+   /// This action is *lazy*: upon invocation of this method the calculation is
+   /// booked but not executed. Also see RResultPtr.
+   ///
+   /// During execution of the computation graph, the passed histogram must only be accessed with methods that are
+   /// allowed during concurrent filling.
+   ///
+   /// ### Example usage:
+   /// ~~~{.cpp}
+   /// auto h = std::make_shared<ROOT::Experimental::RHist<double>>(10, {5.0, 15.0});
+   /// auto myHist = myDf.Hist(h, {"col0"});
+   /// ~~~
+   template <typename ColumnType = RDFDetail::RInferredType, typename... ColumnTypes, typename BinContentType>
+   RResultPtr<ROOT::Experimental::RHist<BinContentType>>
+   Hist(std::shared_ptr<ROOT::Experimental::RHist<BinContentType>> h, const ColumnNames_t &columnList)
+   {
+      RDFInternal::WarnHist();
+
+      if (h->GetNDimensions() != columnList.size()) {
+         throw std::runtime_error("Wrong number of columns for the passed histogram.");
+      }
+
+      return CreateAction<RDFInternal::ActionTags::Hist, ColumnType, ColumnTypes...>(columnList, h, h, fProxiedPtr,
+                                                                                     columnList.size());
+   }
+#endif
+
    ////////////////////////////////////////////////////////////////////////////
    /// \brief Fill and return a TGraph object (*lazy action*).
    /// \tparam X The type of the column used to fill the x axis.

tree/dataframe/inc/ROOT/RDF/Utils.hxx

@@ -65,6 +65,9 @@ struct RInferredType {
 namespace Internal {
 namespace RDF {
 
+/// Warn once about experimental filling of RHist.
+void WarnHist();
+
 using namespace ROOT::TypeTraits;
 using namespace ROOT::Detail::RDF;
 using namespace ROOT::RDF;

tree/dataframe/src/RDFUtils.cxx

@@ -29,6 +29,7 @@
 #include "TTree.h"
 
 #include <fstream>
+#include <mutex>
 #include <nlohmann/json.hpp> // nlohmann::json::parse
 #include <stdexcept>
 #include <string>
@@ -45,6 +46,18 @@ ROOT::RLogChannel &ROOT::Detail::RDF::RDFLogChannel()
    return c;
 }
 
+// A static function, not in an anonymous namespace, because the function name is included in the user-visible message.
+static void WarnHist()
+{
+   R__LOG_WARNING(RDFLogChannel()) << "Filling RHist is experimental and still under development.";
+}
+
+void ROOT::Internal::RDF::WarnHist()
+{
+   static std::once_flag once;
+   std::call_once(once, ::WarnHist);
+}
+
 namespace {
 using TypeInfoRef = std::reference_wrapper<const std::type_info>;
 struct TypeInfoRefHash {

tree/dataframe/test/CMakeLists.txt

@@ -139,6 +139,10 @@ if (imt)
    ROOT_ADD_GTEST(dataframe_concurrency dataframe_concurrency.cxx LIBRARIES ROOTDataFrame)
 endif()
 
+if (root7)
+   ROOT_ADD_GTEST(dataframe_hist dataframe_hist.cxx LIBRARIES ROOTDataFrame ROOTHist)
+endif()
+
 if(ARROW_FOUND)
   ROOT_ADD_GTEST(datasource_arrow datasource_arrow.cxx LIBRARIES ROOTDataFrame ${ARROW_SHARED_LIB})
   target_include_directories(datasource_arrow BEFORE PRIVATE ${ARROW_INCLUDE_DIR})