[RF][HS3] RooSpline exporter importer

Adds Functionality to export and import RooSpline objects to HS3 as well as corresponding const-getters to the class itself.

Author: cburgard

roofit/hs3/src/JSONFactories_RooFitCore.cxx

@@ -47,6 +47,8 @@
 #include <RooGaussModel.h>
 #include <RooWorkspace.h>
 #include <RooRealIntegral.h>
+#include <RooSpline.h>
+#include <TSpline.h>
 
 #include <TF1.h>
 #include <TH1.h>
@@ -599,6 +601,63 @@ class ParamHistFuncFactory : public RooFit::JSONIO::Importer {
    }
 };
 
+class RooSplineFactory : public RooFit::JSONIO::Importer {
+public:
+   bool importArg(RooJSONFactoryWSTool *tool, const JSONNode &p) const override
+   {
+      const std::string name(RooJSONFactoryWSTool::name(p));
+
+      // Mandatory fields
+      if (!p.has_child("x")) {
+         RooJSONFactoryWSTool::error("no x given in '" + name + "'");
+      }
+      if (!p.has_child("x0") || !p.has_child("y0")) {
+         RooJSONFactoryWSTool::error("no x0/y0 given in '" + name + "'");
+      }
+
+      RooAbsReal *x = tool->requestArg<RooAbsReal>(p, "x");
+
+      // Optional fields (defaults follow RooSpline ctor defaults)
+      std::string algo = p.has_child("interpolation") ? p["interpolation"].val() : "poly3";
+      int order = 0;
+      if (algo == "poly3")
+         order = 3;
+      else if (algo == "poly5")
+         order = 5;
+      else {
+         RooJSONFactoryWSTool::error("unsupported algo '" + algo + "' for RooSpline in '" + name +
+                                     "': allowed are 'poly3' and 'poly5'");
+      }
+      const bool logx = p.has_child("logx") ? p["logx"].val_bool() : false;
+      const bool logy = p.has_child("logy") ? p["logy"].val_bool() : false;
+
+      // Read knots
+      std::vector<double> x0;
+      std::vector<double> y0;
+      x0.reserve(p["x0"].num_children());
+      y0.reserve(p["y0"].num_children());
+
+      for (const auto &v : p["x0"].children())
+         x0.push_back(v.val_double());
+      for (const auto &v : p["y0"].children())
+         y0.push_back(v.val_double());
+
+      if (x0.size() != y0.size()) {
+         RooJSONFactoryWSTool::error("x0/y0 size mismatch in '" + name + "': x0 has " + std::to_string(x0.size()) +
+                                     ", y0 has " + std::to_string(y0.size()));
+      }
+      if (x0.size() < 2) {
+         RooJSONFactoryWSTool::error("need at least 2 knots in '" + name + "'");
+      }
+
+      // Construct RooSpline(name,title, x, x0, y0, order, logx, logy)
+      tool->wsEmplace<::RooSpline>(name.c_str(), *x, std::span<const double>(x0.data(), x0.size()),
+                                   std::span<const double>(y0.data(), y0.size()), order, logx, logy);
+
+      return true;
+   }
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 // specialized exporter implementations
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1061,6 +1120,42 @@ class ParamHistFuncStreamer : public RooFit::JSONIO::Exporter {
    }
 };
 
+class RooSplineStreamer : public RooFit::JSONIO::Exporter {
+public:
+   std::string const &key() const override;
+
+   bool exportObject(RooJSONFactoryWSTool *, const RooAbsArg *func, RooFit::Detail::JSONNode &elem) const override
+   {
+      auto const *rs = static_cast<RooSpline const *>(func);
+
+      elem["type"] << key();
+
+      // Independent variable
+      elem["x"] << rs->x().GetName();
+
+      // Spline configuration
+      // Canonical algo for RooSpline
+      elem["interpolation"] << (rs->order() == 5 ? "poly5" : "poly3");
+      elem["logx"] << rs->logx();
+      elem["logy"] << rs->logy();
+
+      // Serialize knots as primitive arrays
+      TSpline const &sp = rs->spline();
+      auto &x0 = elem["x0"].set_seq();
+      auto &y0 = elem["y0"].set_seq();
+
+      const int np = sp.GetNp();
+      for (int i = 0; i < np; ++i) {
+         double xk = 0.0, yk = 0.0;
+         sp.GetKnot(i, xk, yk);
+         x0.append_child() << xk;
+         y0.append_child() << yk;
+      }
+
+      return true;
+   }
+};
+
 #define DEFINE_EXPORTER_KEY(class_name, name)    \
    std::string const &class_name::key() const    \
    {                                             \
@@ -1099,6 +1194,7 @@ DEFINE_EXPORTER_KEY(RooDerivativeStreamer, "derivative");
 DEFINE_EXPORTER_KEY(RooFFTConvPdfStreamer, "fft_conv_pdf");
 DEFINE_EXPORTER_KEY(RooExtendPdfStreamer, "extend_pdf");
 DEFINE_EXPORTER_KEY(ParamHistFuncStreamer, "step");
+DEFINE_EXPORTER_KEY(RooSplineStreamer, "spline");
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 // instantiate all importers and exporters
@@ -1132,6 +1228,7 @@ STATIC_EXECUTE([]() {
    registerImporter<RooFFTConvPdfFactory>("fft_conv_pdf", false);
    registerImporter<RooExtendPdfFactory>("extend_pdf", false);
    registerImporter<ParamHistFuncFactory>("step", false);
+   registerImporter<RooSplineFactory>("spline", false);
 
    registerExporter<RooAddPdfStreamer<RooAddPdf>>(RooAddPdf::Class(), false);
    registerExporter<RooAddPdfStreamer<RooAddModel>>(RooAddModel::Class(), false);
@@ -1159,6 +1256,7 @@ STATIC_EXECUTE([]() {
    registerExporter<RooFFTConvPdfStreamer>(RooFFTConvPdf::Class(), false);
    registerExporter<RooExtendPdfStreamer>(RooExtendPdf::Class(), false);
    registerExporter<ParamHistFuncStreamer>(ParamHistFunc::Class(), false);
+   registerExporter<RooSplineStreamer>(RooSpline::Class(), false);   
 });
 
 } // namespace

roofit/hs3/test/testRooFitHS3.cxx

@@ -15,6 +15,7 @@
 #include <RooHelpers.h>
 #include <RooHistFunc.h>
 #include <RooHistPdf.h>
+#include <RooSpline.h>
 #include <RooLognormal.h>
 #include <RooMultiVarGaussian.h>
 #include <RooPoisson.h>
@@ -533,3 +534,26 @@ TEST(RooFitHS3, ModelConfigWithMultiVarGaussian)
    int status = validate(ws1, "mc");
    EXPECT_EQ(status, 0);
 }
+
+TEST(RooFitHS3, RooSpline)
+{
+   // Observable must be called "x" because validate() assumes that convention.
+   RooWorkspace ws;
+
+   // Use an observable with bins to enable the per-bin closure check.
+   auto *x = ws.factory("x[0,10]");
+   ASSERT_NE(x, nullptr);
+   ws.var("x")->setBins(50);
+
+   // Define knots. Keep it simple but nontrivial (nonlinear).
+   const std::vector<double> x0{0.0, 1.5, 3.0, 6.0, 10.0};
+   const std::vector<double> y0{1.0, 2.0, 1.0, 4.0, 3.0};
+
+   RooSpline spline{"spline", "spline", *ws.var("x"), x0, y0, /*order=*/3, /*logx=*/false, /*logy=*/false};
+
+   // Import the object into the workspace and validate JSON IO.
+   ws.import(spline, RooFit::Silence());
+
+   const int status = validate(ws, "spline", /*exact=*/true);
+   EXPECT_EQ(status, 0);
+}

roofit/roofit/inc/RooSpline.h

@@ -37,6 +37,12 @@ class RooSpline : public RooAbsReal {
    /// \param[in] newname The name of the cloned object (optional).
    TObject *clone(const char *newname) const override { return new RooSpline(*this, newname); }
 
+   RooAbsReal const &x() const { return static_cast<RooAbsReal const &>(*_x.absArg()); }
+   int order() const;
+   TSpline const &spline() const { return *_spline; }
+   bool logx() const { return _logx; }
+   bool logy() const { return _logy; }
+
 protected:
    double evaluate() const override;
 

roofit/roofit/src/RooSpline.cxx

@@ -129,3 +129,15 @@ double RooSpline::evaluate() const
    const double x_val = (!_logx) ? _x : std::exp(_x);
    return (!_logy) ? _spline->Eval(x_val) : std::exp(_spline->Eval(x_val));
 }
+
+/// Return the order of the spline
+int RooSpline::order() const
+{
+   // RooSpline currently doesn’t store the order explicitly, so infer from TSpline dynamic type.
+   // (Constructor uses TSpline3 for order=3 and TSpline5 for order=5.)
+   if (dynamic_cast<TSpline5 const *>(_spline.get()))
+      return 5;
+   if (dynamic_cast<TSpline3 const *>(_spline.get()))
+      return 3;
+   return 3; // reasonable default / forward compatibility
+}