[RDF] Add BarChart() action for categorical/string columns

Histo1D only supports numeric columns; there was no way to fill a
histogram from a string/categorical column (e.g. particle type,
detector region labels) without manual workarounds. This adds a
BarChart() lazy action that fills a label-binned, auto-extending
TH1D from either std::string columns or classic C-style char[]
tree branches (inferred as RVec<char> by RDataFrame).

- ActionTags::BarChart + a dedicated BuildAction overload
- BarChartHelper, since FillHelper<TH1D> cannot compile against
  either std::string or RVec<char> (no implicit conversion to
  the const char* Fill overload)
- RInterface::BarChart(vName, name, title)
- Test coverage in dataframe_histomodels.cxx (bin ordering/counts)
  and dataframe_simple.cxx (auto name/title derivation)

Closes #17057

Author: MehkaanKhan

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

@@ -483,6 +483,66 @@ public:
    }
 };
 
+// BarChartHelper: fills a TH1D from string/categorical columns via TH1D::Fill(const char*).
+// FillHelper<TH1D>::Exec cannot do this: std::string has no implicit conversion to const char*,
+// so its non-container Exec overload's decltype(Fill(x...)) SFINAEs out, and std::string is
+// explicitly excluded from IsDataContainer (see Utils.hxx), so the container-fill overload
+// SFINAEs out too -- FillHelper<TH1D> simply won't compile for a std::string column.
+class R__CLING_PTRCHECK(off) BarChartHelper : public RActionImpl<BarChartHelper> {
+   std::vector<::TH1D *> fObjects;
+
+public:
+   BarChartHelper(BarChartHelper &&) = default;
+   BarChartHelper(const BarChartHelper &) = delete;
+
+   BarChartHelper(const std::shared_ptr<::TH1D> &h, const unsigned int nSlots) : fObjects(nSlots, nullptr)
+   {
+      fObjects[0] = h.get();
+      for (unsigned int i = 1; i < nSlots; ++i) {
+         fObjects[i] = new ::TH1D(*fObjects[0]);
+         UnsetDirectoryIfPossible(fObjects[i]);
+      }
+   }
+
+   void InitTask(TTreeReader *, unsigned int) {}
+
+   void Exec(unsigned int slot, const std::string &label) { fObjects[slot]->Fill(label.c_str(), 1.0); }
+
+   void Exec(unsigned int slot, const ROOT::VecOps::RVec<char> &label)
+   {
+      fObjects[slot]->Fill(std::string(label.begin(), label.end()).c_str(), 1.0);
+   }
+
+   void Initialize() { /* noop */ }
+
+   void Finalize()
+   {
+      if (fObjects.size() > 1) {
+         TList l;
+         for (auto it = ++fObjects.begin(); it != fObjects.end(); ++it)
+            l.Add(*it);
+         fObjects[0]->Merge(&l);
+
+         for (auto it = ++fObjects.begin(); it != fObjects.end(); ++it)
+            delete *it;
+      }
+      fObjects[0]->LabelsDeflate("X");
+   }
+
+   ::TH1D &PartialUpdate(unsigned int slot) { return *fObjects[slot]; }
+
+   std::string GetActionName() { return std::string("BarChart\n") + fObjects[0]->GetName(); }
+
+   BarChartHelper MakeNew(void *newResult, std::string_view /*variation*/ = "nominal")
+   {
+      auto &result = *static_cast<std::shared_ptr<::TH1D> *>(newResult);
+      ResetIfPossible(result.get());
+      UnsetDirectoryIfPossible(result.get());
+      return BarChartHelper(result, fObjects.size());
+   }
+};
+
+
 #ifdef R__HAS_ROOT7
 template <typename BinContentType, bool WithWeight = false>
 class R__CLING_PTRCHECK(off) RHistFillHelper

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

@@ -87,6 +87,7 @@ public:
 /// This namespace defines types to be used for tag dispatching in RInterface.
 namespace ActionTags {
 struct Histo1D{};
+struct BarChart{};
 struct Histo2D{};
 struct Histo3D{};
 struct HistoND{};
@@ -153,6 +154,18 @@ BuildAction(const ColumnNames_t &bl, const std::shared_ptr<::TH1D> &h, const uns
    }
 }
 
+// BarChart filling: always uses BarChartHelper (labels have no numeric axis limits to check)
+template <typename... ColTypes, typename PrevNodeType>
+std::unique_ptr<RActionBase>
+BuildAction(const ColumnNames_t &bl, const std::shared_ptr<::TH1D> &h, const unsigned int nSlots,
+            std::shared_ptr<PrevNodeType> prevNode, ActionTags::BarChart, const RColumnRegister &colRegister)
+{
+   using Helper_t = BarChartHelper;
+   using Action_t = RAction<Helper_t, PrevNodeType, TTraits::TypeList<ColTypes...>>;
+   return std::make_unique<Action_t>(Helper_t(h, nSlots), bl, std::move(prevNode), colRegister);
+}
+
+
 // Action for Histo3D, where thread safe filling might be supported to save memory
 template <typename... ColTypes, typename ActionResultType, typename PrevNodeType>
 std::unique_ptr<RActionBase>

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

@@ -1499,6 +1499,35 @@ public:
       return Histo1D<V>({h_name.c_str(), h_title.c_str(), 128u, 0., 0.}, vName);
    }
 
+   ////////////////////////////////////////////////////////////////////////////
+  /// \brief Fill and return a one-dimensional histogram with the values of a categorical/string column (*lazy action*).
+  /// \tparam V The type of the column used to fill the histogram (must be std::string).
+  /// \param[in] vName The name of the column that will fill the histogram.
+  /// \param[in] name The name of the returned histogram. Defaults to the column name.
+  /// \param[in] title The title of the returned histogram. Defaults to "<name>;<name>;count".
+  /// \return the bar chart histogram wrapped in a RResultPtr, one bin per distinct label encountered.
+  ///
+  /// The returned TH1D has an extendable axis (TH1::kAllAxes) that grows a new bin for each
+  /// previously-unseen label; bins are ordered by first-encounter order, not sorted.
+  ///
+  /// ### Example usage:
+  /// ~~~{.cpp}
+  /// auto h = myDf.BarChart("Nation");
+  /// ~~~
+  template <typename V = RDFDetail::RInferredType>
+  RResultPtr<::TH1D> BarChart(std::string_view vName, std::string_view name = "", std::string_view title = "")
+  {
+     const auto h_name = name.empty() ? std::string(vName) : std::string(name);
+     const auto h_title = title.empty() ? (h_name + ";" + h_name + ";count") : std::string(title);
+     const auto userColumns = ColumnNames_t({std::string(vName)});
+     const auto validatedColumns = GetValidatedColumnNames(1, userColumns);
+
+     std::shared_ptr<::TH1D> h(new ::TH1D(h_name.c_str(), h_title.c_str(), 1, 0., 1.));
+     h->SetCanExtend(::TH1::kAllAxes);
+     return CreateAction<RDFInternal::ActionTags::BarChart, V>(validatedColumns, h, h, fProxiedPtr);
+  }
+
+
    ////////////////////////////////////////////////////////////////////////////
    /// \brief Fill and return a one-dimensional histogram with the weighted values of a column (*lazy action*).
    /// \tparam V The type of the column used to fill the histogram.

tree/dataframe/test/dataframe_histomodels.cxx

@@ -62,6 +62,24 @@ TEST(RDataFrameHistoModels, Histo1D)
    CheckBins(h2edgesd->GetXaxis(), edgesd);
 }
 
+TEST(RDataFrameHistoModels, BarChart)
+{
+   ROOT::RDataFrame tdf(6);
+   std::vector<std::string> labels{"a", "b", "a", "c", "b", "a"};
+   auto i = 0u;
+   auto d = tdf.Define("x", [&i, &labels]() { return labels[i++]; });
+   auto h = d.BarChart("x");
+
+   ASSERT_EQ(h->GetNbinsX(), 3);
+   EXPECT_STREQ(h->GetXaxis()->GetBinLabel(1), "a");
+   EXPECT_STREQ(h->GetXaxis()->GetBinLabel(2), "b");
+   EXPECT_STREQ(h->GetXaxis()->GetBinLabel(3), "c");
+   EXPECT_DOUBLE_EQ(h->GetBinContent(1), 3);
+   EXPECT_DOUBLE_EQ(h->GetBinContent(2), 2);
+   EXPECT_DOUBLE_EQ(h->GetBinContent(3), 1);
+}
+
+
 TEST(RDataFrameHistoModels, Prof1D)
 {
    ROOT::RDataFrame tdf(10);

tree/dataframe/test/dataframe_simple.cxx

@@ -824,6 +824,18 @@ TEST(RDFSimpleTests, AutomaticNamesOfHisto1DAndGraph)
    EXPECT_STREQ(gxy->GetYaxis()->GetTitle(), "y");
 }
 
+TEST(RDFSimpleTests, AutomaticNamesOfBarChart)
+{
+   auto df = RDataFrame(1).Define("x", []() { return std::string("a"); });
+   auto hx = df.BarChart("x");
+
+   EXPECT_STREQ(hx->GetName(), "x");
+   EXPECT_STREQ(hx->GetTitle(), "x");
+   EXPECT_STREQ(hx->GetXaxis()->GetTitle(), "x");
+   EXPECT_STREQ(hx->GetYaxis()->GetTitle(), "count");
+}
+
+
 TEST_P(RDFSimpleTests, DifferentTreesInDifferentThreads)
 {
    const auto filename = "DifferentTreesInDifferentThreads.root";