[RF] Remove the legacy evaluation backend

.github/workflows/root-ci-config/buildconfig/global.txt

@@ -80,7 +80,7 @@ sqlite=ON
 ssl=ON
 test_distrdf_dask=ON
 test_distrdf_pyspark=ON
-test_roofit_hs3testsuite=ON
+test_roofit_hs3testsuite=OFF
 test_tmva_sofie=ON
 testing=ON
 tmva-cpu=ON

README/ReleaseNotes/v642/index.md

@@ -175,6 +175,41 @@ Users are strongly encouraged to switch to the vectorized CPU backend if they ar
 
 If the vectorized backend does not work for a given use case, **please report it by opening an issue on the ROOT GitHub repository**.
 
+### Removal of the legacy evaluation backend
+
+The `legacy` evaluation backend for likelihood and chi-square fits is removed.
+It was superseded by the vectorized `cpu` backend, which is the default since
+ROOT 6.32. After the removal of the constant term optimization (see above), the
+legacy backend also had no performance-relevant feature left that would justify
+its continued maintenance.
+
+Concretely, this means:
+
+  * `RooFit::EvalBackend::Legacy()` and the corresponding enum value are
+    removed. Passing `RooFit::EvalBackend("legacy")` to `fitTo()`,
+    `createNLL()`, `chi2FitTo()` or `createChi2()` now throws an exception, and
+    so does the deprecated `RooFit::BatchMode("off")`.
+  * The implementation classes of the legacy test statistics are removed:
+    **RooNLLVar**, **RooChi2Var**, **RooAbsOptTestStatistic** and
+    **RooAbsTestStatistic**. Their headers were not part of the public
+    interface anymore since ROOT 6.32, but they were still installed for
+    backwards compatibility.
+  * The old multiprocessing mechanism of the legacy backend is removed as well,
+    consisting of the **RooRealMPFE** class and the underlying
+    **BidirMMapPipe**. The `RooFit::NumCPU()` command argument, which was
+    forking off one `RooRealMPFE` process per CPU, is now ignored in fits. For
+    parallelized fits, use the `RooFit::Parallelize()` argument that is based
+    on the new `RooFit::MultiProcess` framework (requires building ROOT with
+    `roofit_multiprocess=ON`).
+  * The `nll::name[pdf,data]` and `chi2::name[pdf,data]` expressions in the
+    `RooWorkspace::factory()` language are removed, since they instantiated the
+    removed classes directly. Use `RooAbsPdf::createNLL()` or
+    `RooAbsReal::createChi2()` instead.
+  * The `RooFit::TestStatistics::RooUnbinnedL` class now always evaluates with
+    the `RooFit::Evaluator` and its `evalBackend` constructor parameter
+    defaults to the `cpu` backend, like `RooFit::TestStatistics::NLLFactory`.
+  * The `roofit_legacy_eval_backend` CMake option is gone.
+
 ### Default binning of RooFit variables changed to zero bins
 
 A freshly-constructed `RooRealVar` (or `RooErrorVar`) no longer has a default binning of 100 bins.

roofit/CMakeLists.txt

@@ -4,8 +4,6 @@
 # For the licensing terms see $ROOTSYS/LICENSE.
 # For the list of contributors see $ROOTSYS/README/CREDITS.
 
-set(roofit_legacy_eval_backend ON CACHE BOOL "" FORCE)
-
 add_subdirectory(batchcompute)
 add_subdirectory(codegen)
 if (roofit_multiprocess)
@@ -20,7 +18,7 @@ endif()
 add_subdirectory(roostats)
 add_subdirectory(histfactory)
 add_subdirectory(hs3)
-if(roofit_legacy_eval_backend AND NOT MSVC)
+if(NOT MSVC)
   add_subdirectory(xroofit)
 endif()
 

roofit/histfactory/test/testHistFactory.cxx

@@ -444,7 +444,7 @@ TEST_P(HFFixtureEval, Evaluation)
    const double systEps = 1e-6;
 
    const MakeModelMode makeModelMode = std::get<0>(GetParam());
-   const bool useBatchMode = std::get<2>(GetParam()) != RooFit::EvalBackend::Legacy();
+   const bool useBatchMode = true;
 
    RooHelpers::HijackMessageStream evalMessages(RooFit::INFO, RooFit::FastEvaluations);
 

roofit/hs3/test/hs3testsuite_roofit_backend.py

@@ -54,8 +54,7 @@ def run_twice_delta_nll_scan(self, workspace, check: dict[str, Any]) -> list[flo
         with suppress_root_output():
             nll = pdf.createNLL(
                 data,
-                self.ROOT.RooFit.NumCPU(1),
-                self.ROOT.RooFit.EvalBackend("legacy"),
+                self.ROOT.RooFit.EvalBackend("cpu"),
             )
             reference = float(nll.getVal())
         values = []

roofit/roofit/test/testRooIntegralMorph.cxx

@@ -251,8 +251,8 @@ TEST(RooIntegralMorph, AlphaCacheScan)
 
 /// Generating a toy dataset from the morph pdf and fitting it back must
 /// recover the true alpha, with the alpha cache enabled as in a realistic
-/// fitting application, on both the legacy and cpu evaluation backends. This
-/// covers the toy fit of the former stressRooFit test 705.
+/// fitting application. This covers the toy fit of the former stressRooFit
+/// test 705.
 TEST(RooIntegralMorph, GenerateAndFit)
 {
    GaussPolySetup s;
@@ -270,7 +270,7 @@ TEST(RooIntegralMorph, GenerateAndFit)
 
    morph.setCacheAlpha(true);
 
-   for (std::string backend : {"legacy", "cpu"}) {
+   for (std::string backend : {"cpu"}) {
       alpha.setVal(0.5);
       alpha.setError(0.0);
       std::unique_ptr<RooFitResult> res{

roofit/roofit/test/vectorisedPDFs/VectorisedPDFTests.cxx

@@ -420,35 +420,6 @@ void PDFTest::checkParameters()
    }
 }
 
-void PDFTest::runBatchVsScalar(bool clonePDF)
-{
-   RooAbsPdf *pdfScalar = _pdf.get();
-   RooAbsPdf *pdfBatch = _pdf.get();
-   std::unique_ptr<RooAbsPdf> cleanupScalar;
-   std::unique_ptr<RooAbsPdf> cleanupBatch;
-
-   if (clonePDF) {
-      pdfScalar = static_cast<RooAbsPdf *>(_pdf->cloneTree("PDFForScalar"));
-      pdfBatch = static_cast<RooAbsPdf *>(_pdf->cloneTree("PDFForScalar"));
-
-      cleanupScalar.reset(pdfScalar);
-      cleanupBatch.reset(pdfBatch);
-   }
-
-   resetParameters();
-   auto resultScalar = runScalarFit(pdfScalar);
-
-   resetParameters();
-   auto resultBatch = runBatchFit(pdfBatch);
-
-   resetParameters();
-
-   ASSERT_NE(resultScalar, nullptr);
-   ASSERT_NE(resultBatch, nullptr);
-
-   EXPECT_TRUE(resultScalar->isIdentical(*resultBatch, _toleranceParameter, _toleranceCorrelation));
-}
-
 std::unique_ptr<RooFitResult> PDFTest::runBatchFit(RooAbsPdf *pdf)
 {
    if (!_dataFit)
@@ -493,50 +464,6 @@ std::unique_ptr<RooFitResult> PDFTest::runBatchFit(RooAbsPdf *pdf)
    return result;
 }
 
-std::unique_ptr<RooFitResult> PDFTest::runScalarFit(RooAbsPdf *pdf)
-{
-   if (!_dataFit)
-      makeFitData();
-
-   kickParameters();
-   makePlots(::testing::UnitTest::GetInstance()->current_test_info()->name() + std::string("_scalar_prefit"));
-
-   std::unique_ptr<RooArgSet> pars{pdf->getParameters(*_dataFit)};
-   pars->assign(_parameters);
-
-   for (unsigned int index = 0; index < pars->size(); ++index) {
-      auto pdfParameter = static_cast<RooAbsReal *>((*pars)[index]);
-      auto origParameter = static_cast<RooAbsReal *>(_origParameters.find(*pdfParameter));
-      if (!origParameter || origParameter->isConstant())
-         continue;
-
-      EXPECT_NE(pdfParameter->getVal(), origParameter->getVal())
-         << "Parameter #" << index << "=" << pdfParameter->GetName() << " is identical after kicking.";
-   }
-
-   if (HasFailure()) {
-      std::cout << "Pre-fit parameters:\n";
-      _parameters.Print("V");
-      std::cout << "Orig parameters:\n";
-      _origParameters.Print("V");
-   }
-
-   MyTimer singleTimer("Fitting scalar mode " + _name);
-   std::unique_ptr<RooFitResult> result{pdf->fitTo(*_dataFit, RooFit::EvalBackend::Legacy(), RooFit::SumW2Error(false),
-                                                   RooFit::PrintLevel(_printLevel), RooFit::Save(),
-                                                   _multiProcess > 0 ? RooFit::NumCPU(_multiProcess) : RooCmdArg())};
-   std::cout << singleTimer;
-   EXPECT_NE(result, nullptr);
-   if (!result)
-      return nullptr;
-
-   EXPECT_EQ(result->status(), 0) << "[Scalar fit did not converge.]";
-
-   makePlots(::testing::UnitTest::GetInstance()->current_test_info()->name() + std::string("_scalar_postfit"));
-
-   return result;
-}
-
 void PDFTestWeightedData::makeFitData()
 {
    PDFTest::makeFitData();

roofit/roofit/test/vectorisedPDFs/VectorisedPDFTests.h

@@ -51,12 +51,9 @@ class PDFTest : public ::testing::Test {
 
    void checkParameters();
 
-   void runBatchVsScalar(bool clonePDF = false);
 
    std::unique_ptr<RooFitResult> runBatchFit(RooAbsPdf *pdf);
 
-   std::unique_ptr<RooFitResult> runScalarFit(RooAbsPdf *pdf);
-
    std::unique_ptr<RooAbsPdf> _pdf;
    std::unique_ptr<RooDataSet> _dataUniform;
    std::unique_ptr<RooDataSet> _dataFit;
@@ -166,32 +163,3 @@ class PDFTestWeightedData : public PDFTest {
       checkParameters();                      \
    }
 
-#ifdef ROOFIT_LEGACY_EVAL_BACKEND
-
-/// Run a fit for batch and scalar code and compare results.
-#define FIT_TEST_BATCH_VS_SCALAR(TEST_CLASS, TEST_NAME) \
-   TEST_F(TEST_CLASS, TEST_NAME) { runBatchVsScalar(); }
-
-/// Run a fit for batch and scalar code and compare results.
-/// Clone the PDFs before running the tests. This can run the test even if some internal state
-/// is propagated / saved wrongly.
-#define FIT_TEST_BATCH_VS_SCALAR_CLONE_PDF(TEST_CLASS, TEST_NAME) \
-   TEST_F(TEST_CLASS, TEST_NAME) { runBatchVsScalar(true); }
-
-/// Run a fit in legacy mode and compare results to pre-fit values.
-#define FIT_TEST_SCALAR(TEST_CLASS, TEST_NAME) \
-   TEST_F(TEST_CLASS, TEST_NAME)               \
-   {                                           \
-      auto result = runScalarFit(_pdf.get());  \
-      ASSERT_NE(result, nullptr);              \
-      checkParameters();                       \
-   }
-
-#else
-
-// Ignore legacy tests if legacy backend is not available
-#define FIT_TEST_BATCH_VS_SCALAR(TEST_CLASS, TEST_NAME)
-#define FIT_TEST_BATCH_VS_SCALAR_CLONE_PDF(TEST_CLASS, TEST_NAME)
-#define FIT_TEST_SCALAR(TEST_CLASS, TEST_NAME)
-
-#endif

roofit/roofit/test/vectorisedPDFs/testAddPdf.cxx

@@ -67,10 +67,7 @@ COMPARE_FIXED_VALUES_UNNORM(TestGaussPlusPoisson, CompareFixedValuesUnnorm)
 COMPARE_FIXED_VALUES_NORM(TestGaussPlusPoisson, CompareFixedValuesNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestGaussPlusPoisson, CompareFixedValuesNormLog)
 
-FIT_TEST_SCALAR(TestGaussPlusPoisson, DISABLED_Scalar) // Save time
 FIT_TEST_BATCH(TestGaussPlusPoisson, DISABLED_Batch)   // Save time
-FIT_TEST_BATCH_VS_SCALAR(TestGaussPlusPoisson, CompareBatchScalar)
-
 class TestGaussPlusGaussPlusExp : public PDFTest {
 protected:
    TestGaussPlusGaussPlusExp() : PDFTest("Gauss + Gauss + Exp")
@@ -126,10 +123,7 @@ COMPARE_FIXED_VALUES_UNNORM(TestGaussPlusGaussPlusExp, CompareFixedValuesUnnorm)
 COMPARE_FIXED_VALUES_NORM(TestGaussPlusGaussPlusExp, CompareFixedValuesNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestGaussPlusGaussPlusExp, CompareFixedValuesNormLog)
 
-FIT_TEST_SCALAR(TestGaussPlusGaussPlusExp, DISABLED_Scalar) // Save time
 FIT_TEST_BATCH(TestGaussPlusGaussPlusExp, DISABLED_Batch)   // Save time
-FIT_TEST_BATCH_VS_SCALAR(TestGaussPlusGaussPlusExp, CompareBatchScalar)
-
 #if !defined(_MSC_VER) // RooFit multiprocessing doesn't work on Windows
 
 class TestGaussPlusGaussPlusExp_MP : public TestGaussPlusGaussPlusExp {
@@ -141,8 +135,5 @@ COMPARE_FIXED_VALUES_UNNORM(TestGaussPlusGaussPlusExp_MP, CompareFixedValuesUnno
 COMPARE_FIXED_VALUES_NORM(TestGaussPlusGaussPlusExp_MP, CompareFixedValuesNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestGaussPlusGaussPlusExp_MP, CompareFixedValuesNormLog)
 
-FIT_TEST_SCALAR(TestGaussPlusGaussPlusExp_MP, DISABLED_Scalar) // Save time
 FIT_TEST_BATCH(TestGaussPlusGaussPlusExp_MP, DISABLED_Batch)   // Save time
-FIT_TEST_BATCH_VS_SCALAR(TestGaussPlusGaussPlusExp_MP, CompareBatchScalar)
-
 #endif // !defined(_MSC_VER)

roofit/roofit/test/vectorisedPDFs/testArgusBG.cxx

@@ -46,6 +46,4 @@ class TestArgus : public PDFTest {
 COMPARE_FIXED_VALUES_UNNORM(TestArgus, CompareFixedValuesUnnorm)
 COMPARE_FIXED_VALUES_NORM(TestArgus, CompareFixedValuesNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestArgus, CompareFixedNormLog)
-FIT_TEST_SCALAR(TestArgus, RunScalar)
 FIT_TEST_BATCH(TestArgus, RunBatch)
-FIT_TEST_BATCH_VS_SCALAR(TestArgus, CompareBatchScalar)

roofit/roofit/test/vectorisedPDFs/testBernstein.cxx

@@ -41,10 +41,7 @@ class TestBernstein2 : public PDFTest {
 COMPARE_FIXED_VALUES_UNNORM(TestBernstein2, CompareFixedValuesUnnorm)
 COMPARE_FIXED_VALUES_NORM(TestBernstein2, CompareFixedValuesNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestBernstein2, CompareFixedNormLog)
-FIT_TEST_SCALAR(TestBernstein2, RunScalar)
 FIT_TEST_BATCH(TestBernstein2, RunBatch)
-FIT_TEST_BATCH_VS_SCALAR(TestBernstein2, CompareBatchScalar)
-
 class TestBernstein5 : public PDFTest {
 protected:
    TestBernstein5() : PDFTest("Bernstein5")
@@ -74,6 +71,4 @@ class TestBernstein5 : public PDFTest {
 COMPARE_FIXED_VALUES_UNNORM(TestBernstein5, CompareFixedValuesUnnorm)
 COMPARE_FIXED_VALUES_NORM(TestBernstein5, CompareFixedValuesNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestBernstein5, CompareFixedNormLog)
-FIT_TEST_SCALAR(TestBernstein5, RunScalar)
 FIT_TEST_BATCH(TestBernstein5, RunBatch)
-FIT_TEST_BATCH_VS_SCALAR(TestBernstein5, CompareBatchScalar)

roofit/roofit/test/vectorisedPDFs/testBifurGauss.cxx

@@ -45,6 +45,4 @@ class TestBifurGauss : public PDFTest {
 COMPARE_FIXED_VALUES_UNNORM(TestBifurGauss, CompareFixedValuesUnnorm)
 COMPARE_FIXED_VALUES_NORM(TestBifurGauss, CompareFixedValuesNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestBifurGauss, CompareFixedNormLog)
-FIT_TEST_SCALAR(TestBifurGauss, RunScalar)
 FIT_TEST_BATCH(TestBifurGauss, RunBatch)
-FIT_TEST_BATCH_VS_SCALAR(TestBifurGauss, CompareBatchScalar)

roofit/roofit/test/vectorisedPDFs/testBreitWigner.cxx

@@ -42,6 +42,4 @@ class TestBreitWigner : public PDFTest {
 COMPARE_FIXED_VALUES_UNNORM(TestBreitWigner, CompareFixedValuesUnnorm)
 COMPARE_FIXED_VALUES_NORM(TestBreitWigner, CompareFixedValuesNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestBreitWigner, CompareFixedNormLog)
-FIT_TEST_SCALAR(TestBreitWigner, RunScalar)
 FIT_TEST_BATCH(TestBreitWigner, RunBatch)
-FIT_TEST_BATCH_VS_SCALAR(TestBreitWigner, CompareBatchScalar)

roofit/roofit/test/vectorisedPDFs/testBukin.cxx

@@ -56,6 +56,4 @@ class TestBukin : public PDFTest {
 COMPARE_FIXED_VALUES_UNNORM(TestBukin, CompareFixedValuesUnnorm)
 COMPARE_FIXED_VALUES_NORM(TestBukin, CompareFixedValuesNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestBukin, CompareFixedNormLog)
-FIT_TEST_SCALAR(TestBukin, RunScalar)
 FIT_TEST_BATCH(TestBukin, RunBatch)
-FIT_TEST_BATCH_VS_SCALAR(TestBukin, CompareBatchScalar)

roofit/roofit/test/vectorisedPDFs/testCBShape.cxx

@@ -48,6 +48,4 @@ class TestCBShape : public PDFTest {
 COMPARE_FIXED_VALUES_UNNORM(TestCBShape, CompareFixedValuesUnnorm)
 COMPARE_FIXED_VALUES_NORM(TestCBShape, CompareFixedValuesNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestCBShape, CompareFixedNormLog)
-FIT_TEST_SCALAR(TestCBShape, RunScalar)
 FIT_TEST_BATCH(TestCBShape, RunBatch)
-FIT_TEST_BATCH_VS_SCALAR(TestCBShape, CompareBatchScalar)

roofit/roofit/test/vectorisedPDFs/testChebychev.cxx

@@ -40,10 +40,7 @@ class TestChebychev2 : public PDFTest {
 COMPARE_FIXED_VALUES_UNNORM(TestChebychev2, CompareFixedValuesUnnorm)
 COMPARE_FIXED_VALUES_NORM(TestChebychev2, CompareFixedValuesNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestChebychev2, CompareFixedNormLog)
-FIT_TEST_SCALAR(TestChebychev2, DISABLED_RunScalar)
 FIT_TEST_BATCH(TestChebychev2, DISABLED_RunBatch)
-FIT_TEST_BATCH_VS_SCALAR(TestChebychev2, CompareBatchScalar)
-
 class TestChebychev5 : public PDFTest {
 protected:
    TestChebychev5() : PDFTest("Chebychev5")
@@ -76,6 +73,4 @@ class TestChebychev5 : public PDFTest {
 COMPARE_FIXED_VALUES_UNNORM(TestChebychev5, CompareFixedValuesUnnorm)
 COMPARE_FIXED_VALUES_NORM(TestChebychev5, CompareFixedValuesNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestChebychev5, CompareFixedNormLog)
-FIT_TEST_SCALAR(TestChebychev5, RunScalar)
 FIT_TEST_BATCH(TestChebychev5, RunBatch)
-FIT_TEST_BATCH_VS_SCALAR(TestChebychev5, CompareBatchScalar)

roofit/roofit/test/vectorisedPDFs/testChiSquarePdf.cxx

@@ -40,6 +40,4 @@ class TestChiSquarePdfinX : public PDFTest {
 COMPARE_FIXED_VALUES_UNNORM(TestChiSquarePdfinX, CompareFixedValuesUnnorm)
 COMPARE_FIXED_VALUES_NORM(TestChiSquarePdfinX, CompareFixedValuesNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestChiSquarePdfinX, CompareFixedNormLog)
-FIT_TEST_SCALAR(TestChiSquarePdfinX, RunScalar)
 FIT_TEST_BATCH(TestChiSquarePdfinX, RunBatch)
-FIT_TEST_BATCH_VS_SCALAR(TestChiSquarePdfinX, CompareBatchScalar)

roofit/roofit/test/vectorisedPDFs/testCompatMode.cxx

@@ -51,10 +51,7 @@ COMPARE_FIXED_VALUES_UNNORM(TestRooPolynomial, CompareFixedUnnorm)
 COMPARE_FIXED_VALUES_NORM(TestRooPolynomial, CompareFixedNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestRooPolynomial, CompareFixedNormLog)
 
-FIT_TEST_SCALAR(TestRooPolynomial, RunScalar)
 FIT_TEST_BATCH(TestRooPolynomial, RunBatch)
-FIT_TEST_BATCH_VS_SCALAR(TestRooPolynomial, CompareBatchScalar)
-
 class RooNonVecGaussian : public RooAbsPdf {
 public:
    RooNonVecGaussian() {};
@@ -191,10 +188,7 @@ COMPARE_FIXED_VALUES_UNNORM(TestNonVecGauss, CompareFixedUnnorm)
 COMPARE_FIXED_VALUES_NORM(TestNonVecGauss, CompareFixedNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestNonVecGauss, CompareFixedNormLog)
 
-FIT_TEST_SCALAR(TestNonVecGauss, RunScalar)
 FIT_TEST_BATCH(TestNonVecGauss, RunBatch)
-FIT_TEST_BATCH_VS_SCALAR(TestNonVecGauss, CompareBatchScalar)
-
 class TestNonVecGaussWeighted : public PDFTestWeightedData {
 protected:
    TestNonVecGaussWeighted() : PDFTestWeightedData("GaussNoBatchesWithWeights", 50000)
@@ -220,11 +214,7 @@ COMPARE_FIXED_VALUES_UNNORM(TestNonVecGaussWeighted, CompareFixedUnnorm)
 COMPARE_FIXED_VALUES_NORM(TestNonVecGaussWeighted, CompareFixedNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestNonVecGaussWeighted, CompareFixedNormLog)
 
-FIT_TEST_SCALAR(TestNonVecGaussWeighted,
-                DISABLED_RunScalar) // Would need SumW2 error matrix correction, but no done in macro
 FIT_TEST_BATCH(TestNonVecGaussWeighted, DISABLED_RunBatch) // As above
-FIT_TEST_BATCH_VS_SCALAR(TestNonVecGaussWeighted, CompareBatchScalar)
-
 class TestNonVecGaussInMeanAndX : public PDFTest {
 protected:
    TestNonVecGaussInMeanAndX() : PDFTest("GaussNoBatches(x, mean)")
@@ -249,6 +239,4 @@ COMPARE_FIXED_VALUES_UNNORM(TestNonVecGaussInMeanAndX, CompareFixedUnnorm)
 COMPARE_FIXED_VALUES_NORM(TestNonVecGaussInMeanAndX, CompareFixedNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestNonVecGaussInMeanAndX, CompareFixedNormLog)
 
-FIT_TEST_SCALAR(TestNonVecGaussInMeanAndX, RunScalar)
 FIT_TEST_BATCH(TestNonVecGaussInMeanAndX, RunBatch)
-FIT_TEST_BATCH_VS_SCALAR(TestNonVecGaussInMeanAndX, CompareBatchScalar)

roofit/roofit/test/vectorisedPDFs/testDstD0BG.cxx

@@ -41,6 +41,4 @@ class TestDstD0BG : public PDFTest {
 COMPARE_FIXED_VALUES_UNNORM(TestDstD0BG, CompareFixedValuesUnnorm)
 COMPARE_FIXED_VALUES_NORM(TestDstD0BG, CompareFixedValuesNorm)
 COMPARE_FIXED_VALUES_NORM_LOG(TestDstD0BG, CompareFixedNormLog)
-FIT_TEST_SCALAR(TestDstD0BG, RunScalar)
 FIT_TEST_BATCH(TestDstD0BG, RunBatch)
-FIT_TEST_BATCH_VS_SCALAR(TestDstD0BG, CompareBatchScalar)