FitHelpers.cxx

Go to the documentation of this file.

/// \cond ROOFIT_INTERNAL
 
/*
 * Project: RooFit
 * Authors:
 *   Jonas Rembser, CERN 2023
 *
 * Copyright (c) 2023, CERN
 *
 * Redistribution and use in source and binary forms,
 * with or without modification, are permitted according to the terms
 * listed in LICENSE (http://roofit.sourceforge.net/license.txt)
 */
 
#include "FitHelpers.h"
 
#include <RooAbsData.h>
#include <RooAbsPdf.h>
#include <RooAbsReal.h>
#include <RooAddition.h>
#include <RooBatchCompute.h>
#include <RooBinSamplingPdf.h>
#include <RooCategory.h>
#include <RooCmdConfig.h>
#include <RooConstraintSum.h>
#include <RooDataHist.h>
#include <RooDataSet.h>
#include <RooDerivative.h>
#include <RooFit/Evaluator.h>
#include <RooFit/TestStatistics/RooRealL.h>
#include <RooFit/TestStatistics/buildLikelihood.h>
#include <RooFitResult.h>
#include <RooLinkedList.h>
#include <RooMinimizer.h>
#include <RooConstVar.h>
#include <RooRealVar.h>
#include <RooSimultaneous.h>
#include <RooFormulaVar.h>
 
#include <Math/CholeskyDecomp.h>
#include <Math/Util.h>
 
#include "ConstraintHelpers.h"
#include "RooEvaluatorWrapper.h"
#include "RooFitImplHelpers.h"
#include "RooFit/Detail/RooNLLVarNew.h"
 
#ifdef ROOFIT_LEGACY_EVAL_BACKEND
#include "RooChi2Var.h"
#include "RooNLLVar.h"
 
#ifdef ROOFIT_MULTIPROCESS
#include "RooFit/MultiProcess/Config.h"
#endif
#endif
 
using RooFit::Detail::RooNLLVarNew;
 
namespace {
 
constexpr int extendedFitDefault = 2;
 
#ifdef ROOFIT_LEGACY_EVAL_BACKEND
/// Print a deprecation warning when the legacy evaluation backend is selected for a fit.
void printLegacyEvalBackendWarning(RooAbsReal const &topLevelArg)
{
   oocoutW(&topLevelArg, InputArguments)
      << "The legacy evaluation backend is deprecated and will be removed in ROOT 6.44.\n"
         "Please use the default \"cpu\" evaluation backend instead, i.e., don't pass RooFit::EvalBackend(\"legacy\")\n"
         "or RooFit::BatchMode(\"off\") anymore. If the default backend does not work for your use case, please\n"
         "report it by opening an issue on the ROOT GitHub repository."
      << std::endl;
}
#endif
 
////////////////////////////////////////////////////////////////////////////////
/// Use the asymptotically correct approach to estimate errors in the presence of weights.
/// This is slower but more accurate than `SumW2Error`. See also https://arxiv.org/abs/1911.01303).
/// Applies the calculated covaraince matrix to the RooMinimizer and returns
/// the quality of the covariance matrix.
/// See also the documentation of RooAbsPdf::fitTo(), where this function is used.
/// \param[in] minimizer The RooMinimizer to get the fit result from. The state
///            of the minimizer will be altered by this function: the covariance
///            matrix caltulated here will be applied to it via
///            RooMinimizer::applyCovarianceMatrix().
/// \param[in] data The dataset that was used for the fit.
int calcAsymptoticCorrectedCovariance(RooAbsReal &pdf, RooMinimizer &minimizer, RooAbsData const &data)
{
   RooFormulaVar logpdf("logpdf", "log(pdf)", "log(@0)", pdf);
   RooArgSet obs;
   logpdf.getObservables(data.get(), obs);
 
   // Warning if the dataset is binned. TODO: in some cases,
   // people also use RooDataSet to encode binned data,
   // e.g. for simultaneous fits. It would be useful to detect
   // this in this future as well.
   if (dynamic_cast<RooDataHist const *>(&data)) {
      oocoutW(&pdf, InputArguments)
         << "RooAbsPdf::fitTo(" << pdf.GetName()
         << ") WARNING: Asymptotic error correction is requested for a binned data set. "
            "This method is not designed to handle binned data. A standard chi2 fit will likely be more suitable.";
   };
 
   // Calculated corrected errors for weighted likelihood fits
   std::unique_ptr<RooFitResult> rw(minimizer.save());
   // Weighted inverse Hessian matrix
   const TMatrixDSym &matV = rw->covarianceMatrix();
   oocoutI(&pdf, Fitting)
      << "RooAbsPdf::fitTo(" << pdf.GetName()
      << ") Calculating covariance matrix according to the asymptotically correct approach. If you find this "
         "method useful please consider citing https://arxiv.org/abs/1911.01303.\n";
 
   // Initialise matrix containing first derivatives
   int nFloatPars = rw->floatParsFinal().size();
   TMatrixDSym num(nFloatPars);
   for (int k = 0; k < nFloatPars; k++) {
      for (int l = 0; l < nFloatPars; l++) {
         num(k, l) = 0.0;
      }
   }
 
   // Create derivative objects
   std::vector<std::unique_ptr<RooDerivative>> derivatives;
   const RooArgList &floated = rw->floatParsFinal();
   RooArgSet allparams;
   logpdf.getParameters(data.get(), allparams);
   std::unique_ptr<RooArgSet> floatingparams{allparams.selectByAttrib("Constant", false)};
 
   const double eps = 1.0e-4;
 
   // Calculate derivatives of logpdf
   for (const auto paramresult : floated) {
      auto paraminternal = static_cast<RooRealVar *>(floatingparams->find(*paramresult));
      assert(floatingparams->find(*paramresult)->IsA() == RooRealVar::Class());
      double error = static_cast<RooRealVar *>(paramresult)->getError();
      derivatives.emplace_back(logpdf.derivative(*paraminternal, obs, 1, eps * error));
   }
 
   // Calculate derivatives for number of expected events, needed for extended ML fit
   RooAbsPdf *extended_pdf = dynamic_cast<RooAbsPdf *>(&pdf);
   std::vector<double> diffs_expected(floated.size(), 0.0);
   if (extended_pdf && extended_pdf->expectedEvents(obs) != 0.0) {
      for (std::size_t k = 0; k < floated.size(); k++) {
         const auto paramresult = static_cast<RooRealVar *>(floated.at(k));
         auto paraminternal = static_cast<RooRealVar *>(floatingparams->find(*paramresult));
 
         *paraminternal = paramresult->getVal();
         double error = paramresult->getError();
         paraminternal->setVal(paramresult->getVal() + eps * error);
         double expected_plus = log(extended_pdf->expectedEvents(obs));
         paraminternal->setVal(paramresult->getVal() - eps * error);
         double expected_minus = log(extended_pdf->expectedEvents(obs));
         *paraminternal = paramresult->getVal();
         double diff = (expected_plus - expected_minus) / (2.0 * eps * error);
         diffs_expected[k] = diff;
      }
   }
 
   // Loop over data
   for (int j = 0; j < data.numEntries(); j++) {
      // Sets obs to current data point, this is where the pdf will be evaluated
      obs.assign(*data.get(j));
      // Determine first derivatives
      std::vector<double> diffs(floated.size(), 0.0);
      for (std::size_t k = 0; k < floated.size(); k++) {
         const auto paramresult = static_cast<RooRealVar *>(floated.at(k));
         auto paraminternal = static_cast<RooRealVar *>(floatingparams->find(*paramresult));
         // first derivative to parameter k at best estimate point for this measurement
         double diff = derivatives[k]->getVal();
         // need to reset to best fit point after differentiation
         *paraminternal = paramresult->getVal();
         diffs[k] = diff;
      }
 
      // Fill numerator matrix
      for (std::size_t k = 0; k < floated.size(); k++) {
         for (std::size_t l = 0; l < floated.size(); l++) {
            num(k, l) += data.weightSquared() * (diffs[k] + diffs_expected[k]) * (diffs[l] + diffs_expected[l]);
         }
      }
   }
   num.Similarity(matV);
 
   // Propagate corrected errors to parameters objects
   minimizer.applyCovarianceMatrix(num);
 
   // The derivatives are found in RooFit and not with the minimizer (e.g.
   // minuit), so the quality of the corrected covariance matrix corresponds to
   // the quality of the original covariance matrix
   return rw->covQual();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Apply correction to errors and covariance matrix. This uses two covariance
/// matrices, one with the weights, the other with squared weights, to obtain
/// the correct errors for weighted likelihood fits.
/// Applies the calculated covaraince matrix to the RooMinimizer and returns
/// the quality of the covariance matrix.
/// See also the documentation of RooAbsPdf::fitTo(), where this function is used.
/// \param[in] minimizer The RooMinimizer to get the fit result from. The state
///            of the minimizer will be altered by this function: the covariance
///            matrix caltulated here will be applied to it via
///            RooMinimizer::applyCovarianceMatrix().
/// \param[in] nll The NLL object that was used for the fit.
int calcSumW2CorrectedCovariance(RooAbsReal const &pdf, RooMinimizer &minimizer, RooAbsReal &nll)
{
   // Calculated corrected errors for weighted likelihood fits
   std::unique_ptr<RooFitResult> rw{minimizer.save()};
   nll.applyWeightSquared(true);
   oocoutI(&pdf, Fitting) << "RooAbsPdf::fitTo(" << pdf.GetName()
                          << ") Calculating sum-of-weights-squared correction matrix for covariance matrix\n";
   minimizer.hesse();
   std::unique_ptr<RooFitResult> rw2{minimizer.save()};
   nll.applyWeightSquared(false);
 
   // Apply correction matrix
   const TMatrixDSym &matV = rw->covarianceMatrix();
   TMatrixDSym matC = rw2->covarianceMatrix();
   ROOT::Math::CholeskyDecompGenDim<double> decomp(matC.GetNrows(), matC);
   if (!decomp) {
      oocoutE(&pdf, Fitting) << "RooAbsPdf::fitTo(" << pdf.GetName()
                             << ") ERROR: Cannot apply sum-of-weights correction to covariance matrix: correction "
                                "matrix calculated with weight-squared is singular\n";
      return -1;
   }
 
   // replace C by its inverse
   decomp.Invert(matC);
   // the class lies about the matrix being symmetric, so fill in the
   // part above the diagonal
   for (int i = 0; i < matC.GetNrows(); ++i) {
      for (int j = 0; j < i; ++j) {
         matC(j, i) = matC(i, j);
      }
   }
   matC.Similarity(matV);
   // C now contains V C^-1 V
   // Propagate corrected errors to parameters objects
   minimizer.applyCovarianceMatrix(matC);
 
   return std::min(rw->covQual(), rw2->covQual());
}
 
/// Configuration struct for RooAbsPdf::minimizeNLL with all the default values
/// that also should be taken as the default values for RooAbsPdf::fitTo.
struct MinimizerConfig {
   double recoverFromNaN = 10.;
   int verbose = 0;
   int doSave = 0;
   int doTimer = 0;
   int printLevel = 1;
   int strategy = 1;
   int initHesse = 0;
   int hesse = 1;
   int minos = 0;
   int numee = 10;
   int doEEWall = 1;
   int doWarn = 1;
   int doSumW2 = -1;
   int doAsymptotic = -1;
   int maxCalls = -1;
   int doOffset = -1;
   int parallelize = 0;
   bool enableParallelGradient = false;
   bool enableParallelDescent = false;
   int parallelDescentNumSplits = 0;
   int parallelDescentSplitStrategy = 0;
   bool timingAnalysis = false;
   const RooArgSet *minosSet = nullptr;
   std::string minType;
   std::string minAlg = "minuit";
};
 
/// Validates the NumCPU() argument for the non-legacy evaluation backends and
/// returns the effective number of worker threads for the RooFit::Evaluator.
int effectiveNumWorkers(RooAbsArg const &arg, RooFit::EvalBackend::Value evalBackend, int numCpu)
{
   using Value = RooFit::EvalBackend::Value;
 
   if (numCpu <= 1) {
      return 1;
   }
   if (evalBackend == Value::Cuda) {
      oocoutW(&arg, Fitting) << "The NumCPU() option is ignored by the CUDA evaluation backend." << std::endl;
      return 1;
   }
   if (evalBackend == Value::CodegenNoGrad) {
      oocoutW(&arg, Fitting) << "The NumCPU() option has no effect with EvalBackend(\"codegen_no_grad\"), "
                                "because the test statistic is evaluated with single-threaded generated code."
                             << std::endl;
      return 1;
   }
   if (evalBackend == Value::Codegen) {
      oocxcoutI(&arg, Fitting) << "NumCPU(" << numCpu << ") enables multi-threaded evaluation of large batches "
                               << "for test statistic values. The generated gradient code is not affected."
                               << std::endl;
      return numCpu;
   }
   oocxcoutI(&arg, Fitting) << "NumCPU(" << numCpu << ") enables multi-threaded evaluation of large batches in "
                            << "the RooBatchCompute library. The interleaving strategy argument of NumCPU() is "
                            << "ignored." << std::endl;
   return numCpu;
}
 
bool interpretExtendedCmdArg(RooAbsPdf const &pdf, int extendedCmdArg)
{
   // Process automatic extended option
   if (extendedCmdArg == extendedFitDefault) {
      bool ext = pdf.extendMode() == RooAbsPdf::CanBeExtended || pdf.extendMode() == RooAbsPdf::MustBeExtended;
      if (ext) {
         oocoutI(&pdf, Minimization)
            << "p.d.f. provides expected number of events, including extended term in likelihood." << std::endl;
      }
      return ext;
   }
   // If Extended(false) was explicitly set, but the pdf MUST be extended, then
   // it's time to print an error. This happens when you're fitting a RooAddPdf
   // with coefficient that represent yields, and without the additional
   // constraint these coefficients are degenerate because the RooAddPdf
   // normalizes itself. Nothing correct can come out of this.
   if (extendedCmdArg == 0) {
      if (pdf.extendMode() == RooAbsPdf::MustBeExtended) {
         std::string errMsg = "You used the Extended(false) option on a pdf where the fit MUST be extended! "
                              "The parameters are not well defined and you're getting nonsensical results.";
         oocoutE(&pdf, InputArguments) << errMsg << std::endl;
      }
   }
   return extendedCmdArg;
}
 
/// To set the fitrange attribute of the PDF and custom ranges for the
/// observables so that RooPlot can automatically plot the fitting range.
void resetFitrangeAttributes(RooAbsArg &pdf, RooAbsData const &data, std::string const &baseName, const char *rangeName,
                             bool splitRange)
{
   // Clear possible range attributes from previous fits.
   pdf.removeStringAttribute("fitrange");
 
   // No fitrange was specified, so we do nothing. Or "SplitRange" is used, and
   // then there are no uniquely defined ranges for the observables (as they
   // are different in each category).
   if (!rangeName || splitRange)
      return;
 
   RooArgSet observables;
   pdf.getObservables(data.get(), observables);
 
   std::string fitrangeValue;
   auto subranges = ROOT::Split(rangeName, ",");
   for (auto const &subrange : subranges) {
      if (subrange.empty())
         continue;
      std::string fitrangeValueSubrange = std::string("fit_") + baseName;
      if (subranges.size() > 1) {
         fitrangeValueSubrange += "_" + subrange;
      }
      fitrangeValue += fitrangeValueSubrange + ",";
      for (RooAbsArg *arg : observables) {
 
         if (arg->isCategory())
            continue;
         auto &observable = static_cast<RooRealVar &>(*arg);
 
         observable.setRange(fitrangeValueSubrange.c_str(), observable.getMin(subrange.c_str()),
                             observable.getMax(subrange.c_str()));
      }
   }
   pdf.setStringAttribute("fitrange", fitrangeValue.substr(0, fitrangeValue.size() - 1).c_str());
}
 
/// Iterate the simultaneous pdf's categories and build one test-statistic term
/// per channel via `makeTerm`. Channels excluded by the (optional) category
/// range are skipped. The per-channel term's special variables are prefixed
/// with `_<catName>_`. The terms are summed into a RooAddition named
/// `combinedName`.
template <typename TermFactory>
std::unique_ptr<RooAddition> createSimultaneousStat(RooSimultaneous const &simPdf, std::string const &rangeName,
                                                    std::string const &combinedName, TermFactory &&makeTerm)
{
   RooAbsCategoryLValue const &simCat = simPdf.indexCat();
 
   RooArgList terms;
   for (auto const &catState : simCat) {
      std::string const &catName = catState.first;
      RooAbsCategory::value_type catIndex = catState.second;
 
      // Skip channels excluded by a category range (only RooCategory supports
      // ranges on categorical values).
      if (!rangeName.empty()) {
         auto simCatAsRooCategory = dynamic_cast<RooCategory const *>(&simCat);
         if (simCatAsRooCategory && !simCatAsRooCategory->isStateInRange(rangeName.c_str(), catIndex)) {
            continue;
         }
      }
 
      RooAbsPdf *channelPdf = simPdf.getPdf(catName.c_str());
      if (!channelPdf) {
         continue;
      }
      std::unique_ptr<RooArgSet> observables{
         std::unique_ptr<RooArgSet>(channelPdf->getVariables())->selectByAttrib("__obs__", true)};
      std::unique_ptr<RooNLLVarNew> term = makeTerm(*channelPdf, *observables);
      term->setPrefix(std::string("_") + catName + "_");
      terms.addOwned(std::move(term));
   }
 
   auto combined = std::make_unique<RooAddition>(combinedName.c_str(), combinedName.c_str(), terms);
   combined->addOwnedComponents(std::move(terms));
   return combined;
}
 
std::unique_ptr<RooAbsArg> createSimultaneousChi2(RooSimultaneous const &simPdf, std::string const &rangeName,
                                                  bool isSimPdfExtended, RooDataHist::ErrorType etype)
{
   auto chi2 =
      createSimultaneousStat(simPdf, rangeName, "simChi2", [&](RooAbsPdf &channelPdf, RooArgSet const &observables) {
         RooNLLVarNew::Config cfg;
         cfg.statistic = RooNLLVarNew::Statistic::Chi2;
         cfg.extended = isSimPdfExtended && channelPdf.extendMode() != RooAbsPdf::CanNotBeExtended;
         cfg.chi2ErrorType = etype;
         auto name = std::string("chi2_") + channelPdf.GetName();
         return std::make_unique<RooNLLVarNew>(name.c_str(), name.c_str(), channelPdf, observables, cfg);
      });
   // Flag the top node so RooEvaluatorWrapper knows not to skip zero-weight bins
   chi2->setAttribute("Chi2EvaluationActive");
   return chi2;
}
 
std::unique_ptr<RooAbsArg> createSimultaneousNLL(RooSimultaneous const &simPdf, bool isSimPdfExtended,
                                                 std::string const &rangeName, RooFit::OffsetMode offset)
{
   auto nll =
      createSimultaneousStat(simPdf, rangeName, "mynll", [&](RooAbsPdf &channelPdf, RooArgSet const &observables) {
         RooNLLVarNew::Config cfg;
         // Only request extended NLLs for channels that can be extended.
         cfg.extended = isSimPdfExtended && channelPdf.extendMode() != RooAbsPdf::CanNotBeExtended;
         cfg.offsetMode = offset;
         auto name = std::string("nll_") + channelPdf.GetName();
         return std::make_unique<RooNLLVarNew>(name.c_str(), name.c_str(), channelPdf, observables, cfg);
      });
 
   const int simCount = nll->list().size();
   for (auto *child : static_range_cast<RooNLLVarNew *>(nll->list())) {
      child->setSimCount(simCount);
   }
   return nll;
}
 
/// Apply the `IntegrateBins` precision to either a single pdf or in-place to
/// the component pdfs of a RooSimultaneous. Newly-allocated wrapper pdfs are
/// appended to `ownedOut`. The returned reference points either at one of
/// those wrappers or at the input pdf itself.
RooAbsPdf &applyIntegrateBinsWrapping(RooAbsPdf &pdf, RooAbsData const &data, double precision, RooArgList &ownedOut)
{
   if (auto *simPdf = dynamic_cast<RooSimultaneous *>(&pdf)) {
      simPdf->wrapPdfsInBinSamplingPdfs(data, precision);
      return pdf;
   }
   if (std::unique_ptr<RooAbsPdf> wrapped = RooBinSamplingPdf::create(pdf, data, precision)) {
      RooAbsPdf &ref = *wrapped;
      ownedOut.addOwned(std::move(wrapped));
      return ref;
   }
   return pdf;
}
 
/// RAII helper for the `setNormRange` + SplitRange/RangeName attribute setting
/// that must be done around `compileForNormSet` so that the compiled pdf sees
/// the restricted normalization range. All mutations are reverted on
/// destruction.
class NormRangeScope {
public:
   NormRangeScope(RooAbsPdf &pdf, const char *rangeName, bool splitRange) : _pdf{&pdf}
   {
      if (pdf.normRange()) {
         _oldNormRange = pdf.normRange();
      }
      pdf.setNormRange(rangeName);
      pdf.setAttribute("SplitRange", splitRange);
      pdf.setStringAttribute("RangeName", rangeName);
   }
   NormRangeScope(NormRangeScope const &) = delete;
   NormRangeScope &operator=(NormRangeScope const &) = delete;
   ~NormRangeScope()
   {
      _pdf->setAttribute("SplitRange", false);
      _pdf->setStringAttribute("RangeName", nullptr);
      _pdf->setNormRange(_oldNormRange.empty() ? nullptr : _oldNormRange.c_str());
   }
 
private:
   RooAbsPdf *_pdf;
   std::string _oldNormRange;
};
 
/// Shared `compileForNormSet` sequence used by both the NLL and chi2 CPU
/// backends. Sets up the reduced normalization range via `NormRangeScope`,
/// then runs the graph compilation. When `likelihoodMode` is true the
/// CompileContext is flagged accordingly (enabling binned-likelihood
/// optimisations in the compiled pdf). The returned compiled pdf has
/// `fixAddCoefRange` already applied when `addCoefRangeName` is non-empty.
std::unique_ptr<RooAbsPdf> compilePdfForFit(RooAbsPdf &pdf, RooArgSet const &normSet, const char *rangeName,
                                            bool splitRange, const char *addCoefRangeName, bool likelihoodMode)
{
   NormRangeScope scope{pdf, rangeName, splitRange};
 
   RooFit::Detail::CompileContext ctx{normSet};
   ctx.setLikelihoodMode(likelihoodMode);
   std::unique_ptr<RooAbsArg> head = pdf.compileForNormSet(normSet, ctx);
   std::unique_ptr<RooAbsPdf> pdfClone{&dynamic_cast<RooAbsPdf &>(*head.release())};
 
   if (addCoefRangeName && *addCoefRangeName) {
      pdfClone->fixAddCoefRange(addCoefRangeName, false);
   }
   return pdfClone;
}
 
std::unique_ptr<RooAbsReal> createNLLNew(RooAbsPdf &pdf, RooAbsData &data, std::unique_ptr<RooAbsReal> &&constraints,
                                         std::string const &rangeName, RooArgSet const &projDeps, bool isExtended,
                                         double integrateOverBinsPrecision, RooFit::OffsetMode offset)
{
   if (constraints) {
      // The computation graph for the constraints is very small, no need to do
      // the tracking of clean and dirty nodes here.
      constraints->setOperMode(RooAbsArg::ADirty);
   }
 
   RooArgSet observables;
   pdf.getObservables(data.get(), observables);
   observables.remove(projDeps, true, true);
 
   oocxcoutI(&pdf, Fitting) << "RooAbsPdf::fitTo(" << pdf.GetName()
                            << ") fixing normalization set for coefficient determination to observables in data"
                            << "\n";
   pdf.fixAddCoefNormalization(observables, false);
 
   RooArgList binSamplingPdfs;
   RooAbsPdf &finalPdf = applyIntegrateBinsWrapping(pdf, data, integrateOverBinsPrecision, binSamplingPdfs);
 
   RooArgList nllTerms;
   auto *simPdf = dynamic_cast<RooSimultaneous *>(&finalPdf);
   // A RooSimultaneous whose index category is not among the data columns is
   // a "switch" pdf selecting the component given by the current index state
   // (analogous to RooMultiPdf): there are no channels to split the NLL into,
   // so it is treated like an ordinary pdf.
   if (simPdf && simPdf->indexCatIsObservable(*data.get())) {
      nllTerms.addOwned(createSimultaneousNLL(*simPdf, isExtended, rangeName, offset));
   } else {
      RooNLLVarNew::Config cfg;
      cfg.extended = isExtended;
      cfg.offsetMode = offset;
      nllTerms.addOwned(std::make_unique<RooNLLVarNew>("RooNLLVarNew", "RooNLLVarNew", finalPdf, observables, cfg));
   }
   if (constraints) {
      nllTerms.addOwned(std::move(constraints));
   }
 
   std::string nllName = std::string("nll_") + pdf.GetName() + "_" + data.GetName();
   auto nll = std::make_unique<RooAddition>(nllName.c_str(), nllName.c_str(), nllTerms);
   nll->addOwnedComponents(std::move(binSamplingPdfs));
   nll->addOwnedComponents(std::move(nllTerms));
 
   return nll;
}
 
} // namespace
 
namespace RooFit::FitHelpers {
 
void defineMinimizationOptions(RooCmdConfig &pc)
{
   // Default-initialized instance of MinimizerConfig to get the default
   // minimizer parameter values.
   MinimizerConfig minimizerDefaults;
 
   pc.defineDouble("RecoverFromUndefinedRegions", "RecoverFromUndefinedRegions", 0, minimizerDefaults.recoverFromNaN);
   pc.defineInt("verbose", "Verbose", 0, minimizerDefaults.verbose);
   pc.defineInt("doSave", "Save", 0, minimizerDefaults.doSave);
   pc.defineInt("doTimer", "Timer", 0, minimizerDefaults.doTimer);
   pc.defineInt("printLevel", "PrintLevel", 0, minimizerDefaults.printLevel);
   pc.defineInt("strategy", "Strategy", 0, minimizerDefaults.strategy);
   pc.defineInt("initHesse", "InitialHesse", 0, minimizerDefaults.initHesse);
   pc.defineInt("hesse", "Hesse", 0, minimizerDefaults.hesse);
   pc.defineInt("minos", "Minos", 0, minimizerDefaults.minos);
   pc.defineInt("numee", "PrintEvalErrors", 0, minimizerDefaults.numee);
   pc.defineInt("doEEWall", "EvalErrorWall", 0, minimizerDefaults.doEEWall);
   pc.defineInt("doWarn", "Warnings", 0, minimizerDefaults.doWarn);
   pc.defineInt("doSumW2", "SumW2Error", 0, minimizerDefaults.doSumW2);
   pc.defineInt("doAsymptoticError", "AsymptoticError", 0, minimizerDefaults.doAsymptotic);
   pc.defineInt("maxCalls", "MaxCalls", 0, minimizerDefaults.maxCalls);
   pc.defineInt("doOffset", "OffsetLikelihood", 0, minimizerDefaults.doOffset);
   pc.defineInt("parallelize", "Parallelize", 0, minimizerDefaults.parallelize); // Three parallelize arguments
   pc.defineInt("enableParallelGradient", "ParallelGradientOptions", 0, minimizerDefaults.enableParallelGradient);
   pc.defineInt("enableParallelDescent", "ParallelDescentOptions", 0, minimizerDefaults.enableParallelDescent);
   pc.defineInt("parallelDescentNumSplits", "ParallelDescentOptions", 1, minimizerDefaults.parallelDescentNumSplits);
   pc.defineInt("parallelDescentSplitStrategy", "ParallelDescentOptions", 2,
                minimizerDefaults.parallelDescentSplitStrategy);
   pc.defineInt("timingAnalysis", "TimingAnalysis", 0, minimizerDefaults.timingAnalysis);
   pc.defineString("mintype", "Minimizer", 0, minimizerDefaults.minType.c_str());
   pc.defineString("minalg", "Minimizer", 1, minimizerDefaults.minAlg.c_str());
   pc.defineSet("minosSet", "Minos", 0, minimizerDefaults.minosSet);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Minimizes a given NLL variable by finding the optimal parameters with the
/// RooMinimzer. The NLL variable can be created with RooAbsPdf::createNLL.
/// If you are looking for a function that combines likelihood creation with
/// fitting, see RooAbsPdf::fitTo.
/// \param[in] nll The negative log-likelihood variable to minimize.
/// \param[in] data The dataset that was also used for the NLL. It's a necessary
///            parameter because it is used in the asymptotic error correction.
/// \param[in] cfg Configuration struct with all the configuration options for
///            the RooMinimizer. These are a subset of the options that you can
///            also pass to RooAbsPdf::fitTo via the RooFit command arguments.
std::unique_ptr<RooFitResult> minimize(RooAbsReal &pdf, RooAbsReal &nll, RooAbsData const &data, RooCmdConfig const &pc)
{
   MinimizerConfig cfg;
   cfg.recoverFromNaN = pc.getDouble("RecoverFromUndefinedRegions");
   cfg.verbose = pc.getInt("verbose");
   cfg.doSave = pc.getInt("doSave");
   cfg.doTimer = pc.getInt("doTimer");
   cfg.printLevel = pc.getInt("printLevel");
   cfg.strategy = pc.getInt("strategy");
   cfg.initHesse = pc.getInt("initHesse");
   cfg.hesse = pc.getInt("hesse");
   cfg.minos = pc.getInt("minos");
   cfg.numee = pc.getInt("numee");
   cfg.doEEWall = pc.getInt("doEEWall");
   cfg.doWarn = pc.getInt("doWarn");
   cfg.doSumW2 = pc.getInt("doSumW2");
   cfg.doAsymptotic = pc.getInt("doAsymptoticError");
   cfg.maxCalls = pc.getInt("maxCalls");
   cfg.minosSet = pc.getSet("minosSet");
   cfg.minType = pc.getString("mintype", "");
   cfg.minAlg = pc.getString("minalg", "minuit");
   cfg.doOffset = pc.getInt("doOffset");
   cfg.parallelize = pc.getInt("parallelize");
   cfg.enableParallelGradient = pc.getInt("enableParallelGradient");
   cfg.enableParallelDescent = pc.getInt("enableParallelDescent");
   cfg.parallelDescentNumSplits = pc.getInt("parallelDescentNumSplits");
   cfg.parallelDescentSplitStrategy = pc.getInt("parallelDescentSplitStrategy");
   cfg.timingAnalysis = pc.getInt("timingAnalysis");
 
   // Determine if the dataset has weights
   bool weightedData = data.isNonPoissonWeighted();
 
   // The weighted-data uncertainty correction options only apply to likelihood
   // fits. Skip the NLL-only paths when minimizing a chi-squared test statistic.
   const bool isChi2 = nll.getAttribute("Chi2EvaluationActive");
 
   std::string msgPrefix = std::string{"RooAbsPdf::fitTo("} + pdf.GetName() + "): ";
 
   // Warn user that a method to determine parameter uncertainties should be provided if weighted data is offered
   if (!isChi2 && weightedData && cfg.doSumW2 == -1 && cfg.doAsymptotic == -1) {
      oocoutW(&pdf, InputArguments) << msgPrefix <<
         R"(WARNING: a likelihood fit is requested of what appears to be weighted data.
       While the estimated values of the parameters will always be calculated taking the weights into account,
       there are multiple ways to estimate the errors of the parameters. You are advised to make an
       explicit choice for the error calculation:
           - Either provide SumW2Error(true), to calculate a sum-of-weights-corrected HESSE error matrix
             (error will be proportional to the number of events in MC).
           - Or provide SumW2Error(false), to return errors from original HESSE error matrix
             (which will be proportional to the sum of the weights, i.e., a dataset with <sum of weights> events).
           - Or provide AsymptoticError(true), to use the asymptotically correct expression
             (for details see https://arxiv.org/abs/1911.01303)."
)";
   }
 
   if (cfg.minos && (cfg.doSumW2 == 1 || cfg.doAsymptotic == 1)) {
      oocoutE(&pdf, InputArguments)
         << msgPrefix
         << " sum-of-weights and asymptotic error correction do not work with MINOS errors. Not fitting.\n";
      return nullptr;
   }
   if (cfg.doAsymptotic == 1 && cfg.minos) {
      oocoutW(&pdf, InputArguments) << msgPrefix << "WARNING: asymptotic correction does not apply to MINOS errors\n";
   }
 
   // avoid setting both SumW2 and Asymptotic for uncertainty correction
   if (cfg.doSumW2 == 1 && cfg.doAsymptotic == 1) {
      oocoutE(&pdf, InputArguments) << msgPrefix
                                    << "ERROR: Cannot compute both asymptotically correct and SumW2 errors.\n";
      return nullptr;
   }
 
   // Apply the experimental likelihood-splitting settings from
   // ParallelDescentOptions(). A numSplits value of zero keeps the automatic
   // task-splitting defaults of RooFit::MultiProcess.
   if (cfg.parallelDescentNumSplits > 0) {
#ifdef ROOFIT_MULTIPROCESS
      if (cfg.parallelDescentSplitStrategy == 0) {
         RooFit::MultiProcess::Config::LikelihoodJob::defaultNEventTasks = cfg.parallelDescentNumSplits;
      } else {
         RooFit::MultiProcess::Config::LikelihoodJob::defaultNComponentTasks = cfg.parallelDescentNumSplits;
      }
#else
      oocoutW(&pdf, InputArguments) << "Likelihood-splitting settings passed via ParallelDescentOptions() are "
                                       "ignored, because ROOT was built without RooFit::MultiProcess support"
                                    << std::endl;
#endif
   }
 
   // Instantiate RooMinimizer
   RooMinimizer::Config minimizerConfig;
   minimizerConfig.enableParallelGradient = cfg.enableParallelGradient;
   minimizerConfig.enableParallelDescent = cfg.enableParallelDescent;
   minimizerConfig.parallelize = cfg.parallelize;
   minimizerConfig.timingAnalysis = cfg.timingAnalysis;
   minimizerConfig.offsetting = cfg.doOffset;
   RooMinimizer m(nll, minimizerConfig);
 
   m.setMinimizerType(cfg.minType);
   m.setEvalErrorWall(cfg.doEEWall);
   m.setRecoverFromNaNStrength(cfg.recoverFromNaN);
   m.setPrintEvalErrors(cfg.numee);
   if (cfg.maxCalls > 0)
      m.setMaxFunctionCalls(cfg.maxCalls);
   if (cfg.printLevel != 1)
      m.setPrintLevel(cfg.printLevel);
   if (cfg.verbose)
      m.setVerbose(true); // Activate verbose options
   if (cfg.doTimer)
      m.setProfile(true); // Activate timer options
   if (cfg.strategy != 1)
      m.setStrategy(cfg.strategy); // Modify fit strategy
   if (cfg.initHesse)
      m.hesse();                                        // Initialize errors with hesse
   m.minimize(cfg.minType.c_str(), cfg.minAlg.c_str()); // Minimize using chosen algorithm
   if (cfg.hesse)
      m.hesse(); // Evaluate errors with Hesse
 
   int corrCovQual = -1;
 
   if (!isChi2 && m.getNPar() > 0) {
      if (cfg.doAsymptotic == 1)
         corrCovQual = calcAsymptoticCorrectedCovariance(pdf, m, data); // Asymptotically correct
      if (cfg.doSumW2 == 1)
         corrCovQual = calcSumW2CorrectedCovariance(pdf, m, nll);
   }
 
   if (cfg.minos)
      cfg.minosSet ? m.minos(*cfg.minosSet) : m.minos(); // Evaluate errs with Minos
 
   // Optionally return fit result
   std::unique_ptr<RooFitResult> ret;
   if (cfg.doSave) {
      auto name = std::string("fitresult_") + pdf.GetName() + "_" + data.GetName();
      auto title = std::string("Result of fit of p.d.f. ") + pdf.GetName() + " to dataset " + data.GetName();
      ret = std::unique_ptr<RooFitResult>{m.save(name.c_str(), title.c_str())};
      if ((cfg.doSumW2 == 1 || cfg.doAsymptotic == 1) && m.getNPar() > 0)
         ret->setCovQual(corrCovQual);
   }
 
   return ret;
}
 
std::unique_ptr<RooAbsReal> createNLL(RooAbsPdf &pdf, RooAbsData &data, const RooLinkedList &cmdList)
{
   auto timingScope = std::make_unique<ROOT::Math::Util::TimingScope>(
      [&pdf](std::string const &msg) { oocoutI(&pdf, Fitting) << msg << std::endl; }, "Creation of NLL object took");
 
   auto baseName = std::string("nll_") + pdf.GetName() + "_" + data.GetName();
 
   // Select the pdf-specific commands
   RooCmdConfig pc("RooAbsPdf::createNLL(" + std::string(pdf.GetName()) + ")");
 
   pc.defineString("rangeName", "RangeWithName", 0, "", true);
   pc.defineString("addCoefRange", "SumCoefRange", 0, "");
   pc.defineString("globstag", "GlobalObservablesTag", 0, "");
   pc.defineString("globssource", "GlobalObservablesSource", 0, "data");
   pc.defineDouble("rangeLo", "Range", 0, -999.);
   pc.defineDouble("rangeHi", "Range", 1, -999.);
   pc.defineInt("splitRange", "SplitRange", 0, 0);
   pc.defineInt("ext", "Extended", 0, extendedFitDefault);
   pc.defineInt("numcpu", "NumCPU", 0, 1);
   pc.defineInt("interleave", "NumCPU", 1, 0);
   pc.defineInt("verbose", "Verbose", 0, 0);
   pc.defineInt("cloneData", "CloneData", 0, 0);
   pc.defineSet("projDepSet", "ProjectedObservables", 0, nullptr);
   pc.defineSet("cPars", "Constrain", 0, nullptr);
   pc.defineSet("glObs", "GlobalObservables", 0, nullptr);
   pc.defineInt("doOffset", "OffsetLikelihood", 0, 0);
   pc.defineSet("extCons", "ExternalConstraints", 0, nullptr);
   pc.defineInt("EvalBackend", "EvalBackend", 0, static_cast<int>(RooFit::EvalBackend::defaultValue()));
   pc.defineDouble("IntegrateBins", "IntegrateBins", 0, -1.);
   pc.defineMutex("Range", "RangeWithName");
   pc.defineMutex("GlobalObservables", "GlobalObservablesTag");
   pc.defineInt("ModularL", "ModularL", 0, 0);
 
   // New style likelihoods define parallelization through Parallelize(...) on fitTo or attributes on
   // RooMinimizer::Config.
   pc.defineMutex("ModularL", "NumCPU");
 
   // New style likelihoods define offsetting on minimizer, not on likelihood
   pc.defineMutex("ModularL", "OffsetLikelihood");
 
   // Process and check varargs
   pc.process(cmdList);
   if (!pc.ok(true)) {
      return nullptr;
   }
 
   if (pc.getInt("ModularL")) {
      int lut[3] = {2, 1, 0};
      RooFit::TestStatistics::RooAbsL::Extended ext{
         static_cast<RooFit::TestStatistics::RooAbsL::Extended>(lut[pc.getInt("ext")])};
 
      RooArgSet cParsSet;
      RooArgSet extConsSet;
      RooArgSet glObsSet;
 
      if (auto tmp = pc.getSet("cPars"))
         cParsSet.add(*tmp);
 
      if (auto tmp = pc.getSet("extCons"))
         extConsSet.add(*tmp);
 
      if (auto tmp = pc.getSet("glObs"))
         glObsSet.add(*tmp);
 
      const std::string rangeName = pc.getString("globstag", "", false);
 
      RooFit::TestStatistics::NLLFactory builder{pdf, data};
      builder.Extended(ext)
         .ConstrainedParameters(cParsSet)
         .ExternalConstraints(extConsSet)
         .GlobalObservables(glObsSet)
         .GlobalObservablesTag(rangeName.c_str())
         .EvalBackend(RooFit::EvalBackend(static_cast<RooFit::EvalBackend::Value>(pc.getInt("EvalBackend"))));
 
      return std::make_unique<RooFit::TestStatistics::RooRealL>("likelihood", "", builder.build());
   }
 
   // Decode command line arguments
   const char *rangeName = pc.getString("rangeName", nullptr, true);
   const char *addCoefRangeName = pc.getString("addCoefRange", nullptr, true);
   const bool ext = interpretExtendedCmdArg(pdf, pc.getInt("ext"));
 
   int splitRange = pc.getInt("splitRange");
   int cloneData = pc.getInt("cloneData");
   auto offset = static_cast<RooFit::OffsetMode>(pc.getInt("doOffset"));
 
   if (pc.hasProcessed("Range")) {
      double rangeLo = pc.getDouble("rangeLo");
      double rangeHi = pc.getDouble("rangeHi");
 
      // Create range with name 'fit' with above limits on all observables
      RooArgSet obs;
      pdf.getObservables(data.get(), obs);
      for (auto *rrv : dynamic_range_cast<RooRealVar *>(obs)) {
         if (rrv)
            rrv->setRange("fit", rangeLo, rangeHi);
      }
 
      // Set range name to be fitted to "fit"
      rangeName = "fit";
   }
 
   // Set the fitrange attribute of th PDF, add observables ranges for plotting
   resetFitrangeAttributes(pdf, data, baseName, rangeName, splitRange);
 
   RooArgSet projDeps;
   auto tmp = pc.getSet("projDepSet");
   if (tmp) {
      projDeps.add(*tmp);
   }
 
   const std::string globalObservablesSource = pc.getString("globssource", "data", false);
   if (globalObservablesSource != "data" && globalObservablesSource != "model") {
      std::string errMsg = "RooAbsPdf::fitTo: GlobalObservablesSource can only be \"data\" or \"model\"!";
      oocoutE(&pdf, InputArguments) << errMsg << std::endl;
      throw std::invalid_argument(errMsg);
   }
   const bool takeGlobalObservablesFromData = globalObservablesSource == "data";
 
   // Lambda function to create the correct constraint term for a PDF. In old
   // RooFit, we use this PDF itself as the argument, for the new BatchMode
   // we're passing a clone.
   auto createConstr = [&]() -> std::unique_ptr<RooAbsReal> {
      return createConstraintTerm(baseName + "_constr",                    // name
                                  pdf,                                     // pdf
                                  data,                                    // data
                                  pc.getSet("cPars"),                      // Constrain RooCmdArg
                                  pc.getSet("extCons"),                    // ExternalConstraints RooCmdArg
                                  pc.getSet("glObs"),                      // GlobalObservables RooCmdArg
                                  pc.getString("globstag", nullptr, true), // GlobalObservablesTag RooCmdArg
                                  takeGlobalObservablesFromData);          // From GlobalObservablesSource RooCmdArg
   };
 
   auto evalBackend = static_cast<RooFit::EvalBackend::Value>(pc.getInt("EvalBackend"));
 
   // Construct BatchModeNLL if requested
   if (evalBackend != RooFit::EvalBackend::Value::Legacy) {
 
      RooArgSet normSet;
      pdf.getObservables(data.get(), normSet);
 
      auto *simPdfForProjDeps = dynamic_cast<RooSimultaneous const *>(&pdf);
      if (simPdfForProjDeps && simPdfForProjDeps->indexCatIsObservable(normSet)) {
         for (auto i : projDeps) {
            auto res = normSet.find(i->GetName());
            if (res != nullptr) {
               res->setAttribute("__conditional__");
            }
         }
      } else {
         normSet.remove(projDeps);
      }
 
      std::unique_ptr<RooAbsPdf> pdfClone =
         compilePdfForFit(pdf, normSet, rangeName, splitRange, addCoefRangeName, /*likelihoodMode=*/true);
 
      if (addCoefRangeName) {
         oocxcoutI(&pdf, Fitting) << "RooAbsPdf::fitTo(" << pdf.GetName()
                                  << ") fixing interpretation of coefficients of any component to range "
                                  << addCoefRangeName << "\n";
      }
 
      std::unique_ptr<RooAbsReal> compiledConstr;
      if (std::unique_ptr<RooAbsReal> constr = createConstr()) {
         compiledConstr = RooFit::Detail::compileForNormSet(*constr, *data.get());
         compiledConstr->addOwnedComponents(std::move(constr));
      }
 
      auto nll = createNLLNew(*pdfClone, data, std::move(compiledConstr), rangeName ? rangeName : "", projDeps, ext,
                              pc.getDouble("IntegrateBins"), offset);
 
      const double correction = pdfClone->getCorrection();
 
      if (correction > 0) {
         oocoutI(&pdf, Fitting) << "[FitHelpers] Detected correction term from RooAbsPdf::getCorrection(). "
                                << "Adding penalty to NLL." << std::endl;
 
         // Convert the multiplicative correction to an additive term in -log L
         auto penaltyTerm = std::make_unique<RooConstVar>((baseName + "_Penalty").c_str(),
                                                          "Penalty term from getCorrection()", correction);
 
         // add penalty and NLL
         auto correctedNLL = std::make_unique<RooAddition>((baseName + "_corrected").c_str(), "NLL + penalty",
                                                           RooArgSet{*nll, *penaltyTerm});
 
         // transfer ownership of terms
         correctedNLL->addOwnedComponents(std::move(nll), std::move(penaltyTerm));
         nll = std::move(correctedNLL);
      }
 
      const int nWorkers = effectiveNumWorkers(pdf, evalBackend, pc.getInt("numcpu"));
 
      auto nllWrapper = std::make_unique<RooFit::Experimental::RooEvaluatorWrapper>(
         *nll, &data, evalBackend == RooFit::EvalBackend::Value::Cuda, rangeName ? rangeName : "", pdfClone.get(),
         takeGlobalObservablesFromData, nWorkers);
 
      // We destroy the timing scrope for createNLL prematurely, because we
      // separately measure the time for jitting and gradient creation
      // inside the RooFuncWrapper.
      timingScope.reset();
 
      if (evalBackend == RooFit::EvalBackend::Value::Codegen) {
         nllWrapper->generateGradient();
      }
      if (evalBackend == RooFit::EvalBackend::Value::CodegenNoGrad) {
         nllWrapper->setUseGeneratedFunctionCode(true);
      }
 
      nllWrapper->addOwnedComponents(std::move(nll));
      nllWrapper->addOwnedComponents(std::move(pdfClone));
 
      return nllWrapper;
   }
 
   std::unique_ptr<RooAbsReal> nll;
 
#ifdef ROOFIT_LEGACY_EVAL_BACKEND
   printLegacyEvalBackendWarning(pdf);
 
   bool verbose = pc.getInt("verbose");
 
   int numcpu = pc.getInt("numcpu");
   int numcpu_strategy = pc.getInt("interleave");
   // strategy 3 works only for RooSimultaneous.
   if (numcpu_strategy == 3 && !pdf.InheritsFrom("RooSimultaneous")) {
      oocoutW(&pdf, Minimization) << "Cannot use a NumCpu Strategy = 3 when the pdf is not a RooSimultaneous, "
                                     "falling back to default strategy = 0"
                                  << std::endl;
      numcpu_strategy = 0;
   }
   RooFit::MPSplit interl = (RooFit::MPSplit)numcpu_strategy;
 
   auto binnedLInfo = RooHelpers::getBinnedL(pdf);
   RooAbsPdf &actualPdf = binnedLInfo.binnedPdf ? *binnedLInfo.binnedPdf : pdf;
 
   // Construct NLL
   RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::CollectErrors);
   RooAbsTestStatistic::Configuration cfg;
   cfg.addCoefRangeName = addCoefRangeName ? addCoefRangeName : "";
   cfg.nCPU = numcpu;
   cfg.interleave = interl;
   cfg.verbose = verbose;
   cfg.splitCutRange = static_cast<bool>(splitRange);
   cfg.cloneInputData = static_cast<bool>(cloneData);
   cfg.integrateOverBinsPrecision = pc.getDouble("IntegrateBins");
   cfg.binnedL = binnedLInfo.isBinnedL;
   cfg.takeGlobalObservablesFromData = takeGlobalObservablesFromData;
   cfg.rangeName = rangeName ? rangeName : "";
   auto nllVar = std::make_unique<RooNLLVar>(baseName.c_str(), "-log(likelihood)", actualPdf, data, projDeps, ext, cfg);
   nllVar->enableBinOffsetting(offset == RooFit::OffsetMode::Bin);
   nll = std::move(nllVar);
   RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::PrintErrors);
 
   // Include constraints, if any, in likelihood
   if (std::unique_ptr<RooAbsReal> constraintTerm = createConstr()) {
 
      // Even though it is technically only required when the computation graph
      // is changed because global observables are taken from data, it is safer
      // to clone the constraint model in general to reset the normalization
      // integral caches and avoid ASAN build failures (the PDF of the main
      // measurement is cloned too anyway, so not much overhead). This can be
      // reconsidered after the caching of normalization sets by pointer is changed
      // to a more memory-safe solution.
      constraintTerm = RooHelpers::cloneTreeWithSameParameters(*constraintTerm, data.get());
 
      // Redirect the global observables to the ones from the dataset if applicable.
      constraintTerm->setData(data, false);
 
      // The computation graph for the constraints is very small, no need to do
      // the tracking of clean and dirty nodes here.
      constraintTerm->setOperMode(RooAbsArg::ADirty);
 
      auto orignll = std::move(nll);
      nll = std::make_unique<RooAddition>((baseName + "_with_constr").c_str(), "nllWithCons",
                                          RooArgSet(*orignll, *constraintTerm));
      nll->addOwnedComponents(std::move(orignll), std::move(constraintTerm));
   }
 
   if (offset == RooFit::OffsetMode::Initial) {
      nll->enableOffsetting(true);
   }
 
   if (const double correction = pdf.getCorrection(); correction > 0) {
      oocoutI(&pdf, Fitting) << "[FitHelpers] Detected correction term from RooAbsPdf::getCorrection(). "
                             << "Adding penalty to NLL." << std::endl;
 
      // Convert the multiplicative correction to an additive term in -log L
      auto penaltyTerm = std::make_unique<RooConstVar>((baseName + "_Penalty").c_str(),
                                                       "Penalty term from getCorrection()", correction);
 
      auto correctedNLL = std::make_unique<RooAddition>(
         // add penalty and NLL
         (baseName + "_corrected").c_str(), "NLL + penalty", RooArgSet(*nll, *penaltyTerm));
 
      // transfer ownership of terms
      correctedNLL->addOwnedComponents(std::move(nll), std::move(penaltyTerm));
      nll = std::move(correctedNLL);
   }
#else
   throw std::runtime_error("RooFit was not built with the legacy evaluation backend");
#endif
 
   return nll;
}
 
std::unique_ptr<RooAbsReal> createChi2(RooAbsReal &real, RooDataHist &data, const RooLinkedList &cmdList)
{
   RooCmdConfig pc("createChi2(" + std::string(real.GetName()) + ")");
 
   pc.defineInt("EvalBackend", "EvalBackend", 0, static_cast<int>(RooFit::EvalBackend::defaultValue()));
   pc.defineInt("numcpu", "NumCPU", 0, 1);
   pc.defineInt("verbose", "Verbose", 0, 0);
   pc.defineString("rangeName", "RangeWithName", 0, "", true);
   pc.defineDouble("rangeLo", "Range", 0, -999.);
   pc.defineDouble("rangeHi", "Range", 1, -999.);
   pc.defineMutex("Range", "RangeWithName");
   pc.defineInt("etype", "DataError", 0, (Int_t)RooDataHist::Auto);
   pc.defineInt("extended", "Extended", 0, extendedFitDefault);
   pc.defineInt("splitRange", "SplitRange", 0, 0);
   pc.defineDouble("integrate_bins", "IntegrateBins", 0, -1);
   pc.defineString("addCoefRange", "SumCoefRange", 0, "");
   pc.allowUndefined();
 
   pc.process(cmdList);
   if (!pc.ok(true)) {
      return nullptr;
   }
 
   // Clear possible range attributes from previous fits.
   real.removeStringAttribute("fitrange");
 
   std::string baseName = "chi2_" + std::string(real.GetName()) + "_" + data.GetName();
 
   auto evalBackend = static_cast<RooFit::EvalBackend::Value>(pc.getInt("EvalBackend"));
 
   RooDataHist::ErrorType etype = static_cast<RooDataHist::ErrorType>(pc.getInt("etype"));
   // Resolve Auto to a concrete mode so it's consistent across backends.
   if (etype == RooDataHist::Auto) {
      etype = data.isNonPoissonWeighted() ? RooDataHist::SumW2 : RooDataHist::Expected;
   }
 
   auto *pdf = dynamic_cast<RooAbsPdf *>(&real);
   const char *rangeName = pc.getString("rangeName", nullptr, true);
 
   // Translate Range(lo, hi) into a "fit" named range on all observables.
   if (pc.hasProcessed("Range")) {
      const double rangeLo = pc.getDouble("rangeLo");
      const double rangeHi = pc.getDouble("rangeHi");
      RooArgSet obs;
      real.getObservables(data.get(), obs);
      for (auto *rrv : dynamic_range_cast<RooRealVar *>(obs)) {
         if (rrv) {
            rrv->setRange("fit", rangeLo, rangeHi);
         }
      }
      rangeName = "fit";
   }
 
   if (evalBackend != RooFit::EvalBackend::Value::Legacy) {
      RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::CollectErrors);
 
      const int splitRange = pc.getInt("splitRange");
      resetFitrangeAttributes(real, data, baseName, rangeName, splitRange);
 
      std::unique_ptr<RooFit::Experimental::RooEvaluatorWrapper> wrapper;
 
      const int nWorkers = effectiveNumWorkers(real, evalBackend, pc.getInt("numcpu"));
 
      // Function mode: the input is a non-pdf RooAbsReal. We can short-circuit
      // the pdf-compilation pipeline since there's no real pdf to normalize.
      if (!pdf) {
         RooArgSet observables;
         real.getObservables(data.get(), observables);
         RooNLLVarNew::Config cfg;
         cfg.statistic = RooNLLVarNew::Statistic::Chi2;
         cfg.chi2ErrorType = etype;
         auto chi2 = std::make_unique<RooNLLVarNew>(baseName.c_str(), baseName.c_str(), real, observables, cfg);
         wrapper = std::make_unique<RooFit::Experimental::RooEvaluatorWrapper>(
            *chi2, &data, evalBackend == RooFit::EvalBackend::Value::Cuda, rangeName ? rangeName : "",
            /*simPdf=*/nullptr,
            /*takeGlobalObservablesFromData=*/true, nWorkers);
         wrapper->addOwnedComponents(std::move(chi2));
      } else {
         const bool extended = interpretExtendedCmdArg(*pdf, pc.getInt("extended"));
 
         RooArgSet normSet;
         pdf->getObservables(data.get(), normSet);
 
         oocxcoutI(pdf, Fitting) << "createChi2(" << pdf->GetName()
                                 << ") fixing normalization set for coefficient determination to observables in data\n";
         pdf->fixAddCoefNormalization(normSet, false);
 
         std::unique_ptr<RooAbsPdf> pdfClone =
            compilePdfForFit(*pdf, normSet, rangeName, splitRange, pc.getString("addCoefRange", nullptr, true),
                             /*likelihoodMode=*/false);
 
         RooArgList binSamplingPdfs;
         RooAbsPdf &finalPdf =
            applyIntegrateBinsWrapping(*pdfClone, data, pc.getDouble("integrate_bins"), binSamplingPdfs);
 
         std::unique_ptr<RooAbsReal> chi2;
         auto *simPdfClone = dynamic_cast<RooSimultaneous *>(&finalPdf);
         // Like in createNLLNew(): a "switch"-mode RooSimultaneous (index
         // category not among the data columns) is treated as an ordinary pdf.
         if (simPdfClone && simPdfClone->indexCatIsObservable(*data.get())) {
            chi2 = std::unique_ptr<RooAbsReal>{dynamic_cast<RooAbsReal *>(
               createSimultaneousChi2(*simPdfClone, rangeName ? rangeName : "", extended, etype).release())};
         } else {
            RooArgSet observables;
            finalPdf.getObservables(data.get(), observables);
            RooNLLVarNew::Config cfg;
            cfg.statistic = RooNLLVarNew::Statistic::Chi2;
            cfg.extended = extended;
            cfg.chi2ErrorType = etype;
            chi2 = std::make_unique<RooNLLVarNew>(baseName.c_str(), baseName.c_str(), finalPdf, observables, cfg);
         }
 
         wrapper = std::make_unique<RooFit::Experimental::RooEvaluatorWrapper>(
            *chi2, &data, evalBackend == RooFit::EvalBackend::Value::Cuda, rangeName ? rangeName : "", pdfClone.get(),
            /*takeGlobalObservablesFromData=*/true, nWorkers);
         wrapper->addOwnedComponents(std::move(binSamplingPdfs));
         wrapper->addOwnedComponents(std::move(chi2));
         wrapper->addOwnedComponents(std::move(pdfClone));
      }
 
      if (evalBackend == RooFit::EvalBackend::Value::Codegen) {
         wrapper->generateGradient();
      }
      if (evalBackend == RooFit::EvalBackend::Value::CodegenNoGrad) {
         wrapper->setUseGeneratedFunctionCode(true);
      }
 
      RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::PrintErrors);
      return wrapper;
   }
 
#ifdef ROOFIT_LEGACY_EVAL_BACKEND
   printLegacyEvalBackendWarning(real);
 
   RooAbsTestStatistic::Configuration cfg;
 
   RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::CollectErrors);
 
   bool extended = false;
   if (pdf) {
      extended = interpretExtendedCmdArg(*pdf, pc.getInt("extended"));
   }
 
   const char *addCoefRangeName = pc.getString("addCoefRange", nullptr, true);
   int splitRange = pc.getInt("splitRange");
 
   // Set the fitrange attribute of th PDF, add observables ranges for plotting
   resetFitrangeAttributes(real, data, baseName, rangeName, splitRange);
 
   cfg.rangeName = rangeName ? rangeName : "";
   cfg.nCPU = pc.getInt("numcpu");
   cfg.interleave = RooFit::Interleave;
   cfg.verbose = static_cast<bool>(pc.getInt("verbose"));
   cfg.cloneInputData = false;
   cfg.integrateOverBinsPrecision = pc.getDouble("integrate_bins");
   cfg.addCoefRangeName = addCoefRangeName ? addCoefRangeName : "";
   cfg.splitCutRange = static_cast<bool>(splitRange);
   auto chi2 = std::make_unique<RooChi2Var>(baseName.c_str(), baseName.c_str(), real, static_cast<RooDataHist &>(data),
                                            extended, etype, cfg);
 
   RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::PrintErrors);
 
   return chi2;
#else
   throw std::runtime_error("createChi2() is not supported without the legacy evaluation backend");
   return nullptr;
#endif
}
 
std::unique_ptr<RooFitResult> fitTo(RooAbsReal &real, RooAbsData &data, const RooLinkedList &cmdList, bool chi2)
{
   const bool isDataHist = dynamic_cast<RooDataHist const *>(&data);
 
   RooCmdConfig pc("fitTo(" + std::string(real.GetName()) + ")");
 
   RooLinkedList fitCmdList(cmdList);
   std::string nllCmdListString;
 
   // Check on the raw command list whether parallel minimization is requested,
   // because in that case ModularL(true) is implied below. The check needs to
   // happen before filtering the command list: with a modular likelihood,
   // offsetting is configured on the minimizer instead of the likelihood, so
   // the OffsetLikelihood argument must not be forwarded to createNLL(), where
   // it is mutually exclusive with ModularL.
   auto cmdEnabled = [&cmdList](const char *cmdName) {
      auto *arg = static_cast<RooCmdArg *>(cmdList.FindObject(cmdName));
      return arg && arg->getInt(0) != 0;
   };
   const bool parallelRequested =
      cmdEnabled("Parallelize") || cmdEnabled("ParallelGradientOptions") || cmdEnabled("ParallelDescentOptions");
 
   if (!chi2) {
      nllCmdListString = "ProjectedObservables,Extended,Range,"
                         "RangeWithName,SumCoefRange,NumCPU,SplitRange,Constrained,Constrain,ExternalConstraints,"
                         "CloneData,GlobalObservables,GlobalObservablesSource,GlobalObservablesTag,"
                         "EvalBackend,IntegrateBins,ModularL";
 
      if (!parallelRequested && !cmdEnabled("ModularL")) {
         nllCmdListString += ",OffsetLikelihood";
      }
   } else {
      auto createChi2DataHistCmdArgs = "Range,RangeWithName,NumCPU,IntegrateBins,ProjectedObservables,"
                                       "AddCoefRange,SplitRange,DataError,Extended,EvalBackend";
      auto createChi2DataSetCmdArgs = "YVar,Integrate,RangeWithName,NumCPU,Verbose";
      nllCmdListString += isDataHist ? createChi2DataHistCmdArgs : createChi2DataSetCmdArgs;
   }
 
   RooLinkedList nllCmdList = pc.filterCmdList(fitCmdList, nllCmdListString.c_str());
 
   pc.defineDouble("prefit", "Prefit", 0, 0);
   defineMinimizationOptions(pc);
 
   // Process and check varargs
   pc.process(fitCmdList);
   if (!pc.ok(true)) {
      return nullptr;
   }
 
   // TimingAnalysis works only for RooSimultaneous.
   if (pc.getInt("timingAnalysis") && !real.InheritsFrom("RooSimultaneous")) {
      oocoutW(&real, Minimization) << "The timingAnalysis feature was built for minimization with RooSimultaneous "
                                      "and is not implemented for other PDF's. Please create a RooSimultaneous to "
                                      "enable this feature."
                                   << std::endl;
   }
 
   // Decode command line arguments
   double prefit = pc.getDouble("prefit");
 
   if (prefit != 0) {
      size_t nEvents = static_cast<size_t>(prefit * data.numEntries());
      if (prefit > 0.5 || nEvents < 100) {
         oocoutW(&real, InputArguments) << "PrefitDataFraction should be in suitable range."
                                        << "With the current PrefitDataFraction=" << prefit
                                        << ", the number of events would be " << nEvents << " out of "
                                        << data.numEntries() << ". Skipping prefit..." << std::endl;
      } else {
         size_t step = data.numEntries() / nEvents;
 
         RooDataSet tiny("tiny", "tiny", *data.get(), data.isWeighted() ? RooFit::WeightVar() : RooCmdArg());
 
         for (int i = 0; i < data.numEntries(); i += step) {
            const RooArgSet *event = data.get(i);
            tiny.add(*event, data.weight());
         }
         RooLinkedList tinyCmdList(cmdList);
         pc.filterCmdList(tinyCmdList, "Prefit,Hesse,Minos,Verbose,Save,Timer");
         RooCmdArg hesse_option = RooFit::Hesse(false);
         RooCmdArg print_option = RooFit::PrintLevel(-1);
 
         tinyCmdList.Add(&hesse_option);
         tinyCmdList.Add(&print_option);
 
         fitTo(real, tiny, tinyCmdList, chi2);
      }
   }
 
   RooCmdArg modularL_option;
   if (parallelRequested) {
      // Set to new style likelihood if parallelization is requested
      modularL_option = RooFit::ModularL(true);
      nllCmdList.Add(&modularL_option);
   }
 
   std::unique_ptr<RooAbsReal> nll;
   if (chi2) {
      if (isDataHist) {
         nll = std::unique_ptr<RooAbsReal>{real.createChi2(static_cast<RooDataHist &>(data), nllCmdList)};
      }
   } else {
      nll = std::unique_ptr<RooAbsReal>{dynamic_cast<RooAbsPdf &>(real).createNLL(data, nllCmdList)};
   }
 
   if (!nll) {
      oocoutE(&real, InputArguments) << "RooFit::FitHelpers::fitTo(" << real.GetName()
                                     << ") could not create the test statistic, no fit performed" << std::endl;
      return nullptr;
   }
 
   return RooFit::FitHelpers::minimize(real, *nll, data, pc);
}
 
} // namespace RooFit::FitHelpers
 
/// \endcond