[df] Implement weighted filling of RHist

This needs one indirection to construct the std::tuple and separate
the weight argument.

Author: hahnjo

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

@@ -36,6 +36,7 @@
 #ifdef R__HAS_ROOT7
 #include <ROOT/RHist.hxx>
 #include <ROOT/RHistConcurrentFiller.hxx>
+#include <ROOT/RWeight.hxx>
 #endif
 
 #include <algorithm>
@@ -46,6 +47,7 @@
 #include <stdexcept>
 #include <string>
 #include <string_view>
+#include <tuple>
 #include <type_traits>
 #include <utility> // std::index_sequence
 #include <vector>
@@ -476,8 +478,9 @@ public:
 };
 
 #ifdef R__HAS_ROOT7
-template <typename BinContentType>
-class R__CLING_PTRCHECK(off) RHistFillHelper : public ROOT::Detail::RDF::RActionImpl<RHistFillHelper<BinContentType>> {
+template <typename BinContentType, bool WithWeight = false>
+class R__CLING_PTRCHECK(off) RHistFillHelper
+   : public ROOT::Detail::RDF::RActionImpl<RHistFillHelper<BinContentType, WithWeight>> {
 public:
    using Result_t = ROOT::Experimental::RHist<BinContentType>;
 
@@ -504,10 +507,23 @@ public:
    void Initialize() {}
    void InitTask(TTreeReader *, unsigned int) {}
 
+   template <typename... ColumnTypes, const std::size_t... I>
+   void ExecWithWeight(unsigned int slot, const std::tuple<ColumnTypes...> &columnValues, std::index_sequence<I...>)
+   {
+      std::tuple args{std::get<I>(columnValues)...};
+      ROOT::Experimental::RWeight weight(std::get<sizeof...(ColumnTypes) - 1>(columnValues));
+      fContexts[slot]->Fill(args, weight);
+   }
+
    template <typename... ColumnTypes>
    void Exec(unsigned int slot, const ColumnTypes &...columnValues)
    {
-      fContexts[slot]->Fill(columnValues...);
+      if constexpr (WithWeight) {
+         auto t = std::forward_as_tuple(columnValues...);
+         ExecWithWeight(slot, t, std::make_index_sequence<sizeof...(ColumnTypes) - 1>());
+      } else {
+         fContexts[slot]->Fill(columnValues...);
+      }
    }
 
    void Finalize()

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

@@ -92,6 +92,7 @@ struct Histo3D{};
 struct HistoND{};
 struct HistoNSparseD{};
 struct Hist{};
+struct HistWithWeight{};
 struct Graph{};
 struct GraphAsymmErrors{};
 struct Profile1D{};
@@ -185,6 +186,18 @@ BuildAction(const ColumnNames_t &columnList, const std::shared_ptr<ROOT::Experim
    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);
 }
+
+// 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::HistWithWeight,
+            const RColumnRegister &colRegister)
+{
+   using Helper_t = RHistFillHelper<BinContentType, true>;
+   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>

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

@@ -47,7 +47,9 @@
 
 #include "RConfigure.h" // for R__HAS_ROOT7
 #ifdef R__HAS_ROOT7
+#include <ROOT/RBinWithError.hxx>
 #include <ROOT/RHist.hxx>
+#include <ROOT/RHistEngine.hxx>
 #endif
 
 #include <algorithm>
@@ -2420,6 +2422,82 @@ public:
       return CreateAction<RDFInternal::ActionTags::Hist, ColumnType, ColumnTypes...>(columnList, h, h, fProxiedPtr,
                                                                                      columnList.size());
    }
+
+   ////////////////////////////////////////////////////////////////////////////
+   /// \brief Fill and return an RHist with weights (*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`
+   /// \param[in] wName The name of the column that will provide the weights.
+   /// \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.
+   ///
+   /// This overload is not available for integral bin content types (see \ref RHistEngine::SupportsWeightedFilling).
+   ///
+   /// ### Example usage:
+   /// ~~~{.cpp}
+   /// ROOT::Experimental::RRegularAxis axis(10, {5.0, 15.0});
+   /// auto myHist = myDf.Hist({axis}, {"col0"}, "colW");
+   /// ~~~
+   template <typename BinContentType = ROOT::Experimental::RBinWithError,
+             typename ColumnType = RDFDetail::RInferredType, typename... ColumnTypes>
+   RResultPtr<ROOT::Experimental::RHist<BinContentType>>
+   Hist(std::vector<ROOT::Experimental::RAxisVariant> axes, const ColumnNames_t &columnList, std::string_view wName)
+   {
+      static_assert(ROOT::Experimental::RHistEngine<BinContentType>::SupportsWeightedFilling,
+                    "weighted filling is not supported for integral bin content types");
+
+      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, wName);
+   }
+
+   ////////////////////////////////////////////////////////////////////////////
+   /// \brief Fill the provided RHist with weights (*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`
+   /// \param[in] wName The name of the column that will provide the weights.
+   /// \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.
+   ///
+   /// This overload is not available for integral bin content types (see \ref RHistEngine::SupportsWeightedFilling).
+   ///
+   /// 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"}, "colW");
+   /// ~~~
+   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,
+        std::string_view wName)
+   {
+      static_assert(ROOT::Experimental::RHistEngine<BinContentType>::SupportsWeightedFilling,
+                    "weighted filling is not supported for integral bin content types");
+
+      RDFInternal::WarnHist();
+
+      if (h->GetNDimensions() != columnList.size()) {
+         throw std::runtime_error("Wrong number of columns for the passed histogram.");
+      }
+
+      // Add the weight column to the list of argument columns to pass it through the infrastructure.
+      ColumnNames_t columnListWithWeights(columnList);
+      columnListWithWeights.push_back(std::string(wName));
+
+      return CreateAction<RDFInternal::ActionTags::HistWithWeight, ColumnType, ColumnTypes...>(
+         columnListWithWeights, h, h, fProxiedPtr, columnListWithWeights.size());
+   }
 #endif
 
    ////////////////////////////////////////////////////////////////////////////

tree/dataframe/test/dataframe_hist.cxx

@@ -3,6 +3,7 @@
 #include <ROOT/TestSupport.hxx>
 #include <ROOT/RDataFrame.hxx>
 #include <ROOT/RDFHelpers.hxx>
+#include <ROOT/RBinWithError.hxx>
 #include <ROOT/RHist.hxx>
 #include <ROOT/RRegularAxis.hxx>
 #include <ROOT/RVariableBinAxis.hxx>
@@ -14,6 +15,7 @@
 #include <vector>
 
 using ROOT::RDataFrame;
+using ROOT::Experimental::RBinWithError;
 using ROOT::Experimental::RHist;
 using ROOT::Experimental::RRegularAxis;
 using ROOT::Experimental::RVariableBinAxis;
@@ -180,6 +182,91 @@ TEST_P(RDFHist, InvalidNumberOfArgumentsJit)
    EXPECT_THROW(dfX.Hist(hist, {"x", "x"}), std::runtime_error);
 }
 
+TEST_P(RDFHist, Weight)
+{
+   RDataFrame df(10);
+   const RRegularAxis axis(10, {5.0, 15.0});
+   auto hist = df.Define("x", [](ULong64_t e) { return e + 5.5; }, {"rdfentry_"})
+                  .Define("w", [](ULong64_t e) { return 0.1 + e * 0.03; }, {"rdfentry_"})
+                  .Hist</*BinContentType=*/RBinWithError, double, double>({axis}, {"x"}, "w");
+   EXPECT_EQ(hist->GetNEntries(), 10);
+   for (auto index : axis.GetNormalRange()) {
+      auto &bin = hist->GetBinContent(index);
+      double weight = 0.1 + index.GetIndex() * 0.03;
+      EXPECT_FLOAT_EQ(bin.fSum, weight);
+      EXPECT_FLOAT_EQ(bin.fSum2, weight * weight);
+   }
+}
+
+TEST_P(RDFHist, WeightJit)
+{
+   RDataFrame df(10);
+   const RRegularAxis axis(10, {5.0, 15.0});
+   auto hist = df.Define("x", "rdfentry_ + 5.5").Define("w", "0.1 + rdfentry_ * 0.03").Hist({axis}, {"x"}, "w");
+   EXPECT_EQ(hist->GetNEntries(), 10);
+   for (auto index : axis.GetNormalRange()) {
+      auto &bin = hist->GetBinContent(index);
+      double weight = 0.1 + index.GetIndex() * 0.03;
+      EXPECT_FLOAT_EQ(bin.fSum, weight);
+      EXPECT_FLOAT_EQ(bin.fSum2, weight * weight);
+   }
+}
+
+TEST_P(RDFHist, PtrWeight)
+{
+   RDataFrame df(10);
+   auto hist = std::make_shared<RHist<double>>(10, std::make_pair(5.0, 15.0));
+   auto resPtr = df.Define("x", [](ULong64_t e) { return e + 5.5; }, {"rdfentry_"})
+                    .Define("w", [](ULong64_t e) { return 0.1 + e * 0.03; }, {"rdfentry_"})
+                    .Hist<double, double>(hist, {"x"}, "w");
+   EXPECT_EQ(hist, resPtr.GetSharedPtr());
+   EXPECT_EQ(hist->GetNEntries(), 10);
+}
+
+TEST_P(RDFHist, PtrWeightJit)
+{
+   RDataFrame df(10);
+   auto hist = std::make_shared<RHist<double>>(10, std::make_pair(5.0, 15.0));
+   auto resPtr = df.Define("x", "rdfentry_ + 5.5").Define("w", "0.1 + rdfentry_ * 0.03").Hist(hist, {"x"}, "w");
+   EXPECT_EQ(hist, resPtr.GetSharedPtr());
+   EXPECT_EQ(hist->GetNEntries(), 10);
+}
+
+TEST_P(RDFHist, WeightInvalidNumberOfArguments)
+{
+   RDataFrame df(10);
+   const RRegularAxis axis(10, {5.0, 15.0});
+   auto dfXW = df.Define("x", [](ULong64_t e) { return e + 5.5; }, {"rdfentry_"})
+                  .Define("w", [](ULong64_t e) { return 0.1 + e * 0.03; }, {"rdfentry_"});
+   try {
+      // Cannot use EXPECT_THROW because of template arguments...
+      dfXW.Hist</*BinContentType=*/double, double, double, double>({axis}, {"x", "x"}, "w");
+      FAIL() << "expected std::runtime_error";
+   } catch (const std::runtime_error &e) {
+      // expected
+   }
+
+   auto hist = std::make_shared<RHist<double>>(10, std::make_pair(5.0, 15.0));
+   try {
+      // Cannot use EXPECT_THROW because of template arguments...
+      dfXW.Hist<double, double, double>(hist, {"x", "x"}, "w");
+      FAIL() << "expected std::runtime_error";
+   } catch (const std::runtime_error &e) {
+      // expected
+   }
+}
+
+TEST_P(RDFHist, WeightInvalidNumberOfArgumentsJit)
+{
+   RDataFrame df(10);
+   const RRegularAxis axis(10, {5.0, 15.0});
+   auto dfXW = df.Define("x", "rdfentry_ + 5.5").Define("w", "0.1 + rdfentry_ * 0.03");
+   EXPECT_THROW(dfXW.Hist({axis}, {"x", "x"}, "w"), std::runtime_error);
+
+   auto hist = std::make_shared<RHist<double>>(10, std::make_pair(5.0, 15.0));
+   EXPECT_THROW(dfXW.Hist(hist, {"x", "x"}, "w"), std::runtime_error);
+}
+
 INSTANTIATE_TEST_SUITE_P(Seq, RDFHist, ::testing::Values(false));
 
 #ifdef R__USE_IMT