/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RDF/RInterface.hxx

Bug Summary

File:	cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RDF/RInterface.hxx
Warning:	line 299, column 7 Potential leak of memory pointed to by 'upcastNodeOnHeap'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -O3 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name SVDdEdxValidationAlgorithm.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/data/b2soft/buildbot/development/build -fcoverage-compilation-dir=/data/b2soft/buildbot/development/build -resource-dir /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21 -isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++ -isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/x86_64-redhat-linux -isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/c++/backward -isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/include -isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/python3.12 -isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP -isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4 -isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include -isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root -isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/belle_legacy -I include/ -D _PACKAGE_="svd" -D G4UI_USE_TCSH -D RaveDllExport= -D HAS_SQLITE -D HAS_CALLGRIND -I include -I /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2 -internal-isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/bin/../lib64/gcc/x86_64-redhat-linux/15.2.0/../../../../include/c++ -internal-isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/bin/../lib64/gcc/x86_64-redhat-linux/15.2.0/../../../../include/c++/x86_64-redhat-linux -internal-isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/bin/../lib64/gcc/x86_64-redhat-linux/15.2.0/../../../../include/c++/backward -internal-isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/bin/../lib64/gcc/x86_64-redhat-linux/15.2.0/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-missing-braces -Wno-unused-command-line-argument -std=c++20 -fdeprecated-macro -ferror-limit 19 -fgnuc-version=4.2.1 -fno-implicit-modules -fskip-odr-check-in-gmf -fcxx-exceptions -fexceptions -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /scan_build/2026-05-31-004316-385593-1 -x c++ svd/calibration/src/SVDdEdxValidationAlgorithm.cc

svd/calibration/src/SVDdEdxValidationAlgorithm.cc

→

1/**************************************************************************
* basf2 (Belle II Analysis Software Framework)                           *
* Author: The Belle II Collaboration                                     *
*                                                                        *
* See git log for contributors and copyright holders.                    *
* This file is licensed under LGPL-3.0, see LICENSE.md.                  *
**************************************************************************/

9#include <svd/calibration/SVDdEdxValidationAlgorithm.h>

11#include <tuple>
12#include <vector>
13#include <string>

15#include <TROOT.h>
16#include <TStyle.h>
17#include <TMath.h>
18#include <TFile.h>
19#include <TColor.h>
20#include <TLegend.h>
21#include <TCanvas.h>
22#include <TH1D.h>
23#include <TH1D.h>
24#include <TH2D.h>
25#include <TAxis.h>
26#include <TGraph.h>
27#include <TMultiGraph.h>
28#include <TCut.h>

30#include <RooDataSet.h>
31#include <RooRealVar.h>
32#include <RooAddPdf.h>
33#include <RooGaussian.h>
34#include <RooChebychev.h>
35#include <RooBifurGauss.h>
36#include <RooDstD0BG.h>
37#include <RooAbsDataStore.h>
38#include <RooTreeDataStore.h>
39#include <RooMsgService.h>
40#include <RooStats/SPlot.h>
41#include <ROOT/RDataFrame.hxx>

43using namespace ROOT;
44using namespace RooFit;
45using namespace Belle2;

47SVDdEdxValidationAlgorithm::SVDdEdxValidationAlgorithm() : CalibrationAlgorithm("SVDdEdxValidationCollector"),
m_fullValidation(true), m_isMakePlots(true)
49{
setDescription("SVD dE/dx validation algorithm");
51}

53/* Main calibration method */
54CalibrationAlgorithm::EResult SVDdEdxValidationAlgorithm::calibrate()
55{
gROOT(ROOT::GetROOT())->SetBatch(true);

// const auto exprun = getRunList()[0];
// B2INFO("ExpRun used for calibration: " << exprun.first << " " << exprun.second);

// Get data objects
auto TTreeLambda = getObjectPtr<TTree>("Lambda");
auto TTreeDstar = getObjectPtr<TTree>("Dstar");
auto TTreeGamma = getObjectPtr<TTree>("Gamma");

if (TTreeLambda->GetEntries() < m_MinEvtsPerTree) {
  B2WARNING("Not enough data for calibration.")do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Warning, 0, "svd")) { { LogVariableStream varStream
; varStream << "Not enough data for calibration."; Belle2
::LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2
::LogConfig::c_Warning, std::move(varStream), "svd", __PRETTY_FUNCTION__
, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc", 67, 0)
); }; } } while(false);
  return c_NotEnoughData;
}

// call the calibration functions
TTree* TTreeLambdaSW = LambdaMassFit(TTreeLambda);
TTree* TTreeDstarSW = DstarMassFit(TTreeDstar);
TTree* TTreeGammaWrap = TTreeGamma.get();

std::vector<TString> PIDDetectors;
PIDDetectors.push_back("SVDonly");
if (m_fullValidation) {
  PIDDetectors.push_back("ALL");
  PIDDetectors.push_back("noSVD");
}

std::map<TTree*, TString> SWeightNameMap = {
  {TTreeGammaWrap, "1"},
  {TTreeDstarSW, "nSignalDstar_sw"},
  {TTreeLambdaSW, "nSignalLambda_sw"}
};

for (const TString& PIDDetectorsName : PIDDetectors) {
  PlotEfficiencyPlots(PIDDetectorsName, TTreeGammaWrap, SWeightNameMap[TTreeGammaWrap], "FirstElectron", "electron", TTreeDstarSW,
                      SWeightNameMap[TTreeDstarSW], "PionD", "pion",
                      "BinaryElectronPionID",
                      "0.5", m_NumEffBins, 0., m_MomHighEff);
  PlotEfficiencyPlots(PIDDetectorsName, TTreeGammaWrap, SWeightNameMap[TTreeGammaWrap], "FirstElectron", "electron", TTreeDstarSW,
                      SWeightNameMap[TTreeDstarSW], "Kaon", "kaon",
                      "BinaryElectronKaonID", "0.5",
                      m_NumEffBins, 0., m_MomHighEff);
  PlotEfficiencyPlots(PIDDetectorsName, TTreeLambdaSW, SWeightNameMap[TTreeLambdaSW], "Proton", "proton", TTreeDstarSW,
                      SWeightNameMap[TTreeDstarSW], "PionD", "pion",
                      "BinaryProtonPionID", "0.5",
                      m_NumEffBins, 0.25, m_MomHighEff);
  PlotEfficiencyPlots(PIDDetectorsName, TTreeLambdaSW, SWeightNameMap[TTreeLambdaSW], "Proton", "proton", TTreeDstarSW,
                      SWeightNameMap[TTreeDstarSW], "Kaon", "kaon",
                      "BinaryProtonKaonID", "0.5",
                      m_NumEffBins, 0.25, m_MomHighEff);
  PlotEfficiencyPlots(PIDDetectorsName, TTreeDstarSW, SWeightNameMap[TTreeDstarSW], "PionD", "pion", TTreeDstarSW,
                      SWeightNameMap[TTreeDstarSW],
                      "Kaon", "kaon",
                      "BinaryPionKaonID", "0.5", m_NumEffBins,
                      0., m_MomHighEff);
  PlotEfficiencyPlots(PIDDetectorsName, TTreeDstarSW, SWeightNameMap[TTreeDstarSW], "Kaon", "kaon", TTreeDstarSW,
                      SWeightNameMap[TTreeDstarSW],
                      "PionD", "pion",
                      "BinaryKaonPionID", "0.5", m_NumEffBins,
                      0., m_MomHighEff);
}

if (m_fullValidation) {
  PlotROCCurve(TTreeGammaWrap, SWeightNameMap[TTreeGammaWrap], "FirstElectron", "electron", TTreeDstarSW,
               SWeightNameMap[TTreeDstarSW], "PionD",
               "pion", "BinaryElectronPionID");
  PlotROCCurve(TTreeGammaWrap, SWeightNameMap[TTreeGammaWrap], "FirstElectron", "electron", TTreeDstarSW,
               SWeightNameMap[TTreeDstarSW], "Kaon",
               "kaon", "BinaryElectronKaonID");
  PlotROCCurve(TTreeLambdaSW, SWeightNameMap[TTreeLambdaSW], "Proton", "proton", TTreeDstarSW, SWeightNameMap[TTreeDstarSW], "PionD",
               "pion",
               "BinaryProtonPionID");
  PlotROCCurve(TTreeLambdaSW, SWeightNameMap[TTreeLambdaSW], "Proton", "proton", TTreeDstarSW, SWeightNameMap[TTreeDstarSW], "Kaon",
               "kaon",
               "BinaryProtonKaonID");
  PlotROCCurve(TTreeDstarSW, SWeightNameMap[TTreeDstarSW], "PionD", "pion", TTreeDstarSW, SWeightNameMap[TTreeDstarSW], "Kaon",
               "kaon",
               "BinaryPionKaonID");
  PlotROCCurve(TTreeDstarSW, SWeightNameMap[TTreeDstarSW], "Kaon", "kaon", TTreeDstarSW, SWeightNameMap[TTreeDstarSW], "PionD",
               "pion",
               "BinaryKaonPionID");
}
B2INFO("SVD dE/dx validation done!")do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Info, 0, "svd")) { { LogVariableStream varStream
; varStream << "SVD dE/dx validation done!"; Belle2::LogSystem
::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig
::c_Info, std::move(varStream), "svd", __PRETTY_FUNCTION__, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc"
, 138, 0)); }; } } while(false);

return c_OK;
141}

143// generic efficiency and fake rate
144void SVDdEdxValidationAlgorithm::PlotEfficiencyPlots(const TString& PIDDetectorsName, TTree* SignalTree, TString SignalWeightName,
                                                   TString SignalVarName, TString SignalVarNameFull, TTree* FakeTree, TString FakeWeightName, TString FakeVarName,
                                                   TString FakeVarNameFull, TString PIDVarName, TString PIDCut, unsigned int nbins, double MomLow, double MomHigh)
147{

if ((SignalTree == nullptr) || (FakeTree == nullptr)) {
  B2FATAL("Invalid dataset, stopping here")do { { LogVariableStream varStream; varStream << "Invalid dataset, stopping here"
; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage
(Belle2::LogConfig::c_Fatal, std::move(varStream), "svd", __PRETTY_FUNCTION__
, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc", 150, 0
)); }; exit(1); } while(false);
}

if ((SignalTree->GetEntries() == 0) || (FakeTree->GetEntries() == 0)) {
  B2FATAL("The dataset is empty, stopping here")do { { LogVariableStream varStream; varStream << "The dataset is empty, stopping here"
; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage
(Belle2::LogConfig::c_Fatal, std::move(varStream), "svd", __PRETTY_FUNCTION__
, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc", 154, 0
)); }; exit(1); } while(false);
}

if ((SignalTree->GetBranch(Form("%sMomentum", SignalVarName.Data())) == nullptr)
    || (FakeTree->GetBranch(Form("%sMomentum", FakeVarName.Data())) == nullptr)) {
  B2FATAL("Check the provided branch name, stopping here")do { { LogVariableStream varStream; varStream << "Check the provided branch name, stopping here"
; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage
(Belle2::LogConfig::c_Fatal, std::move(varStream), "svd", __PRETTY_FUNCTION__
, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc", 159, 0
)); }; exit(1); } while(false);
}

TString SignalFiducialCut = "(1>0)"; // placeholder for a possible sanity cut
TString FakesFiducialCut = "(1>0)";

// Produce the plots of the SVD PID distribution
if (PIDDetectorsName == "SVDonly") {
  SignalTree->Draw(Form("%s%s%s>>hSignalPIDDistribution(100,0.,1.)", SignalVarName.Data(), PIDVarName.Data(),
                        PIDDetectorsName.Data()),
                   SignalWeightName + Form("* (%sMomentum>%f && %sMomentum<%f)", SignalVarName.Data(), MomLow, SignalVarName.Data(), MomHigh), "goff");
  TH1D* hSignalPIDDistribution = static_cast<TH1D*>(gDirectory(::ROOT::Internal::TDirectoryAtomicAdapter{})->Get("hSignalPIDDistribution"));
  hSignalPIDDistribution->Scale(1. / hSignalPIDDistribution->Integral());
  hSignalPIDDistribution->GetXaxis()->SetTitle(PIDVarName + PIDDetectorsName + " for " + SignalVarNameFull);
  hSignalPIDDistribution->GetYaxis()->SetTitle("Candidates, normalised");
  hSignalPIDDistribution->SetMaximum(1.35 * hSignalPIDDistribution->GetMaximum());

  SignalTree->Draw(Form("%sElectronLLSVDonly>>hSignalElectronLLDistribution(100,-17.,3.)", SignalVarName.Data()),
                   SignalWeightName + Form("* (%sMomentum>%f && %sMomentum<%f)", SignalVarName.Data(), MomLow, SignalVarName.Data(), MomHigh), "goff");
  TH1D* hSignalElectronLLDistribution = static_cast<TH1D*>(gDirectory(::ROOT::Internal::TDirectoryAtomicAdapter{})->Get("hSignalElectronLLDistribution"));
  SignalTree->Draw(Form("%sPionLLSVDonly>>hSignalPionLLDistribution(100,-17.,3.)", SignalVarName.Data()),
                   SignalWeightName + Form("* (%sMomentum>%f && %sMomentum<%f)", SignalVarName.Data(), MomLow, SignalVarName.Data(), MomHigh), "goff");
  TH1D* hSignalPionLLDistribution = static_cast<TH1D*>(gDirectory(::ROOT::Internal::TDirectoryAtomicAdapter{})->Get("hSignalPionLLDistribution"));
  SignalTree->Draw(Form("%sKaonLLSVDonly>>hSignalKaonLLDistribution(100,-17.,3.)", SignalVarName.Data()),
                   SignalWeightName + Form("* (%sMomentum>%f && %sMomentum<%f)", SignalVarName.Data(), MomLow, SignalVarName.Data(), MomHigh), "goff");
  TH1D* hSignalKaonLLDistribution = static_cast<TH1D*>(gDirectory(::ROOT::Internal::TDirectoryAtomicAdapter{})->Get("hSignalKaonLLDistribution"));
  SignalTree->Draw(Form("%sProtonLLSVDonly>>hSignalProtonLLDistribution(100,-17.,3.)", SignalVarName.Data()),
                   SignalWeightName + Form("* (%sMomentum>%f && %sMomentum<%f)", SignalVarName.Data(), MomLow, SignalVarName.Data(), MomHigh), "goff");
  TH1D* hSignalProtonLLDistribution = static_cast<TH1D*>(gDirectory(::ROOT::Internal::TDirectoryAtomicAdapter{})->Get("hSignalProtonLLDistribution"));

  // same but only for tracks that are expected to actually have SVD dEdx info
  SignalTree->Draw(Form("%sElectronLLSVDonly>>hSignalElectronLLDistributionGood(100,-17.,3.)", SignalVarName.Data()),
                   SignalWeightName + Form("* (%sSVDdEdx>0) * (%sMomentum>%f && %sMomentum<%f)", SignalVarName.Data(), SignalVarName.Data(), MomLow,
                                           SignalVarName.Data(), MomHigh), "goff");
  TH1D* hSignalElectronLLDistributionGood = static_cast<TH1D*>(gDirectory(::ROOT::Internal::TDirectoryAtomicAdapter{})->Get("hSignalElectronLLDistributionGood"));
  SignalTree->Draw(Form("%sPionLLSVDonly>>hSignalPionLLDistributionGood(100,-17.,3.)", SignalVarName.Data()),
                   SignalWeightName + Form("* (%sSVDdEdx>0) * (%sMomentum>%f && %sMomentum<%f)", SignalVarName.Data(), SignalVarName.Data(), MomLow,
                                           SignalVarName.Data(), MomHigh), "goff");
  TH1D* hSignalPionLLDistributionGood = static_cast<TH1D*>(gDirectory(::ROOT::Internal::TDirectoryAtomicAdapter{})->Get("hSignalPionLLDistributionGood"));
  SignalTree->Draw(Form("%sKaonLLSVDonly>>hSignalKaonLLDistributionGood(100,-17.,3.)", SignalVarName.Data()),
                   SignalWeightName + Form("* (%sSVDdEdx>0) * (%sMomentum>%f && %sMomentum<%f)", SignalVarName.Data(), SignalVarName.Data(), MomLow,
                                           SignalVarName.Data(), MomHigh), "goff");
  TH1D* hSignalKaonLLDistributionGood = static_cast<TH1D*>(gDirectory(::ROOT::Internal::TDirectoryAtomicAdapter{})->Get("hSignalKaonLLDistributionGood"));
  SignalTree->Draw(Form("%sProtonLLSVDonly>>hSignalProtonLLDistributionGood(100,-17.,3.)", SignalVarName.Data()),
                   SignalWeightName + Form("* (%sSVDdEdx>0) * (%sMomentum>%f && %sMomentum<%f)", SignalVarName.Data(), SignalVarName.Data(), MomLow,
                                           SignalVarName.Data(), MomHigh), "goff");
  TH1D* hSignalProtonLLDistributionGood = static_cast<TH1D*>(gDirectory(::ROOT::Internal::TDirectoryAtomicAdapter{})->Get("hSignalProtonLLDistributionGood"));


  hSignalElectronLLDistribution->Scale(1. / hSignalElectronLLDistribution->Integral());
  hSignalPionLLDistribution->Scale(1. / hSignalPionLLDistribution->Integral());
  hSignalKaonLLDistribution->Scale(1. / hSignalKaonLLDistribution->Integral());
  hSignalProtonLLDistribution->Scale(1. / hSignalProtonLLDistribution->Integral());

  hSignalElectronLLDistributionGood->Scale(1. / hSignalElectronLLDistributionGood->Integral());
  hSignalPionLLDistributionGood->Scale(1. / hSignalPionLLDistributionGood->Integral());
  hSignalKaonLLDistributionGood->Scale(1. / hSignalKaonLLDistributionGood->Integral());
  hSignalProtonLLDistributionGood->Scale(1. / hSignalProtonLLDistributionGood->Integral());

  hSignalElectronLLDistribution->GetXaxis()->SetTitle("ElectronLL (SVD only) for " + SignalVarNameFull);
  hSignalElectronLLDistribution->GetYaxis()->SetTitle("Candidates, normalised");
  hSignalElectronLLDistribution->SetMaximum(1.35 * hSignalElectronLLDistribution->GetMaximum());

  hSignalPionLLDistribution->GetXaxis()->SetTitle("PionLL (SVD only) for " + SignalVarNameFull);
  hSignalPionLLDistribution->GetYaxis()->SetTitle("Candidates, normalised");
  hSignalPionLLDistribution->SetMaximum(1.35 * hSignalPionLLDistribution->GetMaximum());

  hSignalKaonLLDistribution->GetXaxis()->SetTitle("KaonLL (SVD only) for " + SignalVarNameFull);
  hSignalKaonLLDistribution->GetYaxis()->SetTitle("Candidates, normalised");
  hSignalKaonLLDistribution->SetMaximum(1.35 * hSignalKaonLLDistribution->GetMaximum());

  hSignalProtonLLDistribution->GetXaxis()->SetTitle("ProtonLL (SVD only) for " + SignalVarNameFull);
  hSignalProtonLLDistribution->GetYaxis()->SetTitle("Candidates, normalised");
  hSignalProtonLLDistribution->SetMaximum(1.35 * hSignalProtonLLDistribution->GetMaximum());

  hSignalElectronLLDistributionGood->GetXaxis()->SetTitle("ElectronLL (SVD only) for " + SignalVarNameFull);
  hSignalElectronLLDistributionGood->GetYaxis()->SetTitle("Candidates, normalised");
  hSignalElectronLLDistributionGood->SetMaximum(1.35 * hSignalElectronLLDistributionGood->GetMaximum());

  hSignalPionLLDistributionGood->GetXaxis()->SetTitle("PionLL (SVD only) for " + SignalVarNameFull);
  hSignalPionLLDistributionGood->GetYaxis()->SetTitle("Candidates, normalised");
  hSignalPionLLDistributionGood->SetMaximum(1.35 * hSignalPionLLDistributionGood->GetMaximum());

  hSignalKaonLLDistributionGood->GetXaxis()->SetTitle("KaonLL (SVD only) for " + SignalVarNameFull);
  hSignalKaonLLDistributionGood->GetYaxis()->SetTitle("Candidates, normalised");
  hSignalKaonLLDistributionGood->SetMaximum(1.35 * hSignalKaonLLDistributionGood->GetMaximum());

  hSignalProtonLLDistributionGood->GetXaxis()->SetTitle("ProtonLL (SVD only) for " + SignalVarNameFull);
  hSignalProtonLLDistributionGood->GetYaxis()->SetTitle("Candidates, normalised");
  hSignalProtonLLDistributionGood->SetMaximum(1.35 * hSignalProtonLLDistributionGood->GetMaximum());

  TCanvas* DistribCanvas = new TCanvas("DistribCanvas", "", 600, 600);
  gPad(TVirtualPad::Pad())->SetTopMargin(0.05);
  gPad(TVirtualPad::Pad())->SetRightMargin(0.05);
  gPad(TVirtualPad::Pad())->SetLeftMargin(0.13);
  gPad(TVirtualPad::Pad())->SetBottomMargin(0.12);

  hSignalPIDDistribution->SetLineWidth(2);
  hSignalPIDDistribution->SetLineColor(TColor::GetColor("#2166ac"));
  hSignalPIDDistribution->Draw("hist");

  DistribCanvas->Print("SVDdEdxValidation_Distribution_" + SignalVarNameFull + PIDVarName + PIDDetectorsName +
                       "_MomRange_" +
                       std::to_string(
                         MomLow)
                       .substr(0, 3) +
                       "_" + std::to_string(MomHigh).substr(0, 3) + ".pdf");

  hSignalElectronLLDistribution->SetLineWidth(2);
  hSignalPionLLDistribution->SetLineWidth(2);
  hSignalKaonLLDistribution->SetLineWidth(2);
  hSignalProtonLLDistribution->SetLineWidth(2);

  hSignalElectronLLDistributionGood->SetLineWidth(2);
  hSignalPionLLDistributionGood->SetLineWidth(2);
  hSignalKaonLLDistributionGood->SetLineWidth(2);
  hSignalProtonLLDistributionGood->SetLineWidth(2);

  hSignalElectronLLDistributionGood->SetLineColor(kBlack);
  hSignalPionLLDistributionGood->SetLineColor(kBlack);
  hSignalKaonLLDistributionGood->SetLineColor(kBlack);
  hSignalProtonLLDistributionGood->SetLineColor(kBlack);

  hSignalElectronLLDistribution->SetTitle("ElectronLL (SVD), all tracks");
  hSignalPionLLDistribution->SetTitle("PionLL (SVD), all tracks");
  hSignalKaonLLDistribution->SetTitle("KaonLL (SVD), all tracks");
  hSignalProtonLLDistribution->SetTitle("ProtonLL (SVD), all tracks");

  hSignalElectronLLDistributionGood->SetTitle("ElectronLL (SVD), tracks with dEdx info");
  hSignalPionLLDistributionGood->SetTitle("PionLL (SVD), tracks with dEdx info");
  hSignalKaonLLDistributionGood->SetTitle("KaonLL (SVD), tracks with dEdx info");
  hSignalProtonLLDistributionGood->SetTitle("ProtonLL (SVD), tracks with dEdx info");

  hSignalElectronLLDistribution->GetXaxis()->SetTitleSize(0.04);
  hSignalElectronLLDistribution->GetYaxis()->SetTitleSize(0.04);
  hSignalElectronLLDistribution->GetXaxis()->SetTitleOffset(1.0);
  hSignalElectronLLDistribution->GetYaxis()->SetTitleOffset(1.3);
  hSignalElectronLLDistribution->GetYaxis()->SetLabelSize(0.04);
  hSignalElectronLLDistribution->GetXaxis()->SetLabelSize(0.04);

  hSignalPionLLDistribution->GetXaxis()->SetTitleSize(0.04);
  hSignalPionLLDistribution->GetYaxis()->SetTitleSize(0.04);
  hSignalPionLLDistribution->GetXaxis()->SetTitleOffset(1.0);
  hSignalPionLLDistribution->GetYaxis()->SetTitleOffset(1.3);
  hSignalPionLLDistribution->GetYaxis()->SetLabelSize(0.04);
  hSignalPionLLDistribution->GetXaxis()->SetLabelSize(0.04);

  hSignalKaonLLDistribution->GetXaxis()->SetTitleSize(0.04);
  hSignalKaonLLDistribution->GetYaxis()->SetTitleSize(0.04);
  hSignalKaonLLDistribution->GetXaxis()->SetTitleOffset(1.0);
  hSignalKaonLLDistribution->GetYaxis()->SetTitleOffset(1.3);
  hSignalKaonLLDistribution->GetYaxis()->SetLabelSize(0.04);
  hSignalKaonLLDistribution->GetXaxis()->SetLabelSize(0.04);

  hSignalProtonLLDistribution->GetXaxis()->SetTitleSize(0.04);
  hSignalProtonLLDistribution->GetYaxis()->SetTitleSize(0.04);
  hSignalProtonLLDistribution->GetXaxis()->SetTitleOffset(1.0);
  hSignalProtonLLDistribution->GetYaxis()->SetTitleOffset(1.3);
  hSignalProtonLLDistribution->GetYaxis()->SetLabelSize(0.04);
  hSignalProtonLLDistribution->GetXaxis()->SetLabelSize(0.04);

  TCanvas* LLCanvas = new TCanvas("LLCanvas", "", 900, 700);

  gPad(TVirtualPad::Pad())->SetTopMargin(0.05);
  gPad(TVirtualPad::Pad())->SetRightMargin(0.05);
  gPad(TVirtualPad::Pad())->SetLeftMargin(0.13);
  gPad(TVirtualPad::Pad())->SetBottomMargin(0.12);

  LLCanvas->Divide(2, 2, 0.01, 0.01);
  LLCanvas->cd(1);
  hSignalElectronLLDistribution->Draw("hist");
  LLCanvas->cd(2);
  hSignalPionLLDistribution->Draw("hist");
  LLCanvas->cd(3);
  hSignalKaonLLDistribution->Draw("hist");
  LLCanvas->cd(4);
  hSignalProtonLLDistribution->Draw("hist");

  TCanvas* LLCanvasGood = new TCanvas("LLCanvasGood", "", 900, 700);

  gPad(TVirtualPad::Pad())->SetTopMargin(0.05);
  gPad(TVirtualPad::Pad())->SetRightMargin(0.05);
  gPad(TVirtualPad::Pad())->SetLeftMargin(0.13);
  gPad(TVirtualPad::Pad())->SetBottomMargin(0.12);

  LLCanvasGood->Divide(2, 2, 0.01, 0.01);
  LLCanvasGood->cd(1);
  hSignalElectronLLDistributionGood->Draw("hist");
  LLCanvasGood->cd(2);
  hSignalPionLLDistributionGood->Draw("hist");
  LLCanvasGood->cd(3);
  hSignalKaonLLDistributionGood->Draw("hist");
  LLCanvasGood->cd(4);
  hSignalProtonLLDistributionGood->Draw("hist");

  LLCanvas->Print("SVDdEdxValidation_LLDistributions_" + SignalVarNameFull +
                  "_SVDonly_MomRange_" +
                  std::to_string(
                    MomLow)
                  .substr(0, 3) +
                  "_" + std::to_string(MomHigh).substr(0, 3) + ".pdf");

  LLCanvasGood->Print("SVDdEdxValidation_LLDistributions_GoodSVDTracks_" + SignalVarNameFull +
                      "_SVDonly_MomRange_" +
                      std::to_string(
                        MomLow)
                      .substr(0, 3) +
                      "_" + std::to_string(MomHigh).substr(0, 3) + ".pdf");

  TFile DistribFile("SVDdEdxValidation_Distribution_" + SignalVarNameFull + PIDVarName + PIDDetectorsName +
                    "_MomRange_" +
                    std::to_string(
                      MomLow)
                    .substr(0, 3) +
                    "_" + std::to_string(MomHigh).substr(0, 3) + ".root",
                    "RECREATE");
  hSignalPIDDistribution->SetLineColor(kBlack);
  hSignalPIDDistribution->Write();
  DistribFile.Close();
  delete DistribCanvas;

  TFile LLDistribFile(TString("SVDdEdxValidation_LLDistributions_" + SignalVarNameFull + "_SVDonly_MomRange_" +
                              std::to_string(
                                MomLow)
                              .substr(0, 3) +
                              "_" + std::to_string(MomHigh).substr(0, 3) + ".root"),
                      "RECREATE");
  hSignalElectronLLDistribution->Write();
  hSignalPionLLDistribution->Write();
  hSignalKaonLLDistribution->Write();
  hSignalProtonLLDistribution->Write();
  LLDistribFile.Close();
  delete LLCanvas;
  delete LLCanvasGood;
}

// ---------- Momentum distributions (for efficiency determination) ----------

SignalTree->Draw(Form("%sMomentum>>hAllSignal(%i,%f,%f)", SignalVarName.Data(), nbins, MomLow, MomHigh),
                 SignalWeightName + " * (" + SignalFiducialCut + ")", "goff");
SignalTree->Draw(Form("%sMomentum>>hSelectedSignal(%i,%f,%f)", SignalVarName.Data(), nbins, MomLow, MomHigh),
                 SignalWeightName + " * (" + SignalVarName + PIDVarName + PIDDetectorsName + ">" + PIDCut + "&&" + SignalFiducialCut +
                 ")",
                 "goff");

FakeTree->Draw(Form("%sMomentum>>hAllFakes(%i,%f,%f)", FakeVarName.Data(), nbins, MomLow, MomHigh),
               FakeWeightName + " * (" + FakesFiducialCut + ")", "goff");
FakeTree->Draw(Form("%sMomentum>>hSelectedFakes(%i,%f,%f)", FakeVarName.Data(), nbins, MomLow, MomHigh),
               FakeWeightName + " * (" + FakeVarName + PIDVarName + PIDDetectorsName + ">" + PIDCut + "&&" + FakesFiducialCut + ")",
               "goff");

TH1D* hAllSignal = static_cast<TH1D*>(gDirectory(::ROOT::Internal::TDirectoryAtomicAdapter{})->Get("hAllSignal"));
TH1D* hSelectedSignal = static_cast<TH1D*>(gDirectory(::ROOT::Internal::TDirectoryAtomicAdapter{})->Get("hSelectedSignal"));
TH1D* hAllFakes = static_cast<TH1D*>(gDirectory(::ROOT::Internal::TDirectoryAtomicAdapter{})->Get("hAllFakes"));
TH1D* hSelectedFakes = static_cast<TH1D*>(gDirectory(::ROOT::Internal::TDirectoryAtomicAdapter{})->Get("hSelectedFakes"));

// ---------- Add slow pions to the pion dataset ----------
if (strncmp(SignalVarName.Data(), "PionD", 5) == 0) {
  SignalTree->Draw(Form("SlowPionMomentum>>hAllSignalSlow(%i,%f,%f)", nbins, MomLow, MomHigh),
                   SignalWeightName + " * (" + SignalFiducialCut + ")", "goff");
  SignalTree->Draw(Form("SlowPionMomentum>>hSelectedSignalSlow(%i,%f,%f)", nbins, MomLow, MomHigh),
                   SignalWeightName + " * (SlowPion" + PIDVarName + PIDDetectorsName + ">" + PIDCut + "&&" + SignalFiducialCut + ")", "goff");
  TH1D* hAllSignalSlow = static_cast<TH1D*>(gDirectory(::ROOT::Internal::TDirectoryAtomicAdapter{})->Get("hAllSignalSlow"));
  TH1D* hSelectedSignalSlow = static_cast<TH1D*>(gDirectory(::ROOT::Internal::TDirectoryAtomicAdapter{})->Get("hSelectedSignalSlow"));
  hAllSignal->Add(hAllSignalSlow);
  hSelectedSignal->Add(hSelectedSignalSlow);
}

if (strncmp(FakeVarName.Data(), "PionD", 5) == 0) {
  FakeTree->Draw(Form("SlowPionMomentum>>hAllFakesSlow(%i,%f,%f)", nbins, MomLow, MomHigh),
                 FakeWeightName + " * (" + FakesFiducialCut + ")",
                 "goff");
  FakeTree->Draw(Form("SlowPionMomentum>>hSelectedFakesSlow(%i,%f,%f)", nbins, MomLow, MomHigh),
                 FakeWeightName + " * (SlowPion" + PIDVarName + PIDDetectorsName + ">" + PIDCut + "&&" + FakesFiducialCut + ")", "goff");
  TH1D* hAllFakesSlow = static_cast<TH1D*>(gDirectory(::ROOT::Internal::TDirectoryAtomicAdapter{})->Get("hAllFakesSlow"));
  TH1D* hSelectedFakesSlow = static_cast<TH1D*>(gDirectory(::ROOT::Internal::TDirectoryAtomicAdapter{})->Get("hSelectedFakesSlow"));
  hAllFakes->Add(hAllFakesSlow);
  hSelectedFakes->Add(hSelectedFakesSlow);
}

TH1D* EffHistoSig = static_cast<TH1D*>(hAllSignal->Clone("EffHistoSig"));   // signal efficiency
TH1D* EffHistoFake = static_cast<TH1D*>(hAllFakes->Clone("EffHistoFake"));  // fakes efficiency

EffHistoSig->Divide(hSelectedSignal, hAllSignal);//, 1, 1, "B");
EffHistoFake->Divide(hSelectedFakes, hAllFakes);//, 1, 1, "B");

// PID plots
TH1D* hBase = new TH1D("hBase", "", 100, 0.0, MomHigh);
hBase->SetTitle(";Momentum [GeV];Efficiency");
hBase->SetMaximum(1.20);
hBase->SetMinimum(0.0);

TLegend* tleg1 = new TLegend(0.63, 0.82, 0.93, 0.94);
tleg1->AddEntry(EffHistoSig, SignalVarNameFull + " efficiency", "pl");
tleg1->AddEntry(EffHistoFake, FakeVarNameFull + " fake rate", "pl");

TCanvas* ResultCanvas = new TCanvas("ResultCanvas", "", 600, 600);
gPad(TVirtualPad::Pad())->SetTopMargin(0.05);
gPad(TVirtualPad::Pad())->SetRightMargin(0.05);
gPad(TVirtualPad::Pad())->SetLeftMargin(0.13);
gPad(TVirtualPad::Pad())->SetBottomMargin(0.12);

ResultCanvas->SetGrid();
hBase->Draw();
EffHistoSig->SetMarkerSize(1.5);
EffHistoSig->SetMarkerStyle(22);
EffHistoSig->SetMarkerColor(TColor::GetColor("#2166ac"));
EffHistoSig->SetLineColor(TColor::GetColor("#2166ac"));
EffHistoSig->Draw("P,same");

EffHistoFake->SetMarkerSize(1.5);
EffHistoFake->SetMarkerStyle(23);
EffHistoFake->SetMarkerColor(TColor::GetColor("#ef8a62"));
EffHistoFake->SetLineColor(TColor::GetColor("#ef8a62"));
EffHistoFake->Draw("P,same");

tleg1->Draw("same");

hBase->SetStats(0);
hBase->GetXaxis()->SetTitleSize(0.04);
hBase->GetYaxis()->SetTitleSize(0.04);
hBase->GetXaxis()->SetTitleOffset(1.0);
hBase->GetYaxis()->SetTitleOffset(1.3);
hBase->GetYaxis()->SetLabelSize(0.04);
hBase->GetXaxis()->SetLabelSize(0.04);

// std::setprecision(2);
ResultCanvas->Print("SVDdEdxValidation_Efficiency_" + SignalVarNameFull + "_vs_" + FakeVarNameFull + PIDVarName + "_" +
                    PIDDetectorsName +
                    "_Cut" +
                    PIDCut + "_MomRange_" + std::to_string(MomLow).substr(0, 3) + "_" + std::to_string(MomHigh).substr(0, 3) + ".pdf");
TFile ResultFile("SVDdEdxValidation_Efficiency_" + SignalVarNameFull + "_vs_" + FakeVarNameFull + PIDVarName + "_" +
                 PIDDetectorsName +
                 "_Cut" +
                 PIDCut + "_MomRange_" + std::to_string(MomLow).substr(0, 3) + "_" + std::to_string(MomHigh).substr(0, 3) + ".root",
                 "RECREATE");
EffHistoSig->SetLineColor(kBlack);
EffHistoSig->SetMarkerColor(kBlack);
EffHistoFake->SetLineColor(kBlack);
EffHistoFake->SetMarkerColor(kBlack);
EffHistoSig->Write();
EffHistoFake->Write();
ResultFile.Close();
delete ResultCanvas;
delete hBase;
504}

506void SVDdEdxValidationAlgorithm::PlotROCCurve(TTree* SignalTree, TString SignalWeightName, TString SignalVarName,
                                            TString SignalVarNameFull, TTree* FakeTree, TString FakeWeightName, TString FakeVarName, TString FakeVarNameFull,
                                            TString PIDVarName)
509{

if ((SignalTree == nullptr) || (FakeTree == nullptr)) {
1
Assuming the condition is false→
2
←
Assuming the condition is false→
  B2FATAL("Invalid dataset, stopping here")do { { LogVariableStream varStream; varStream << "Invalid dataset, stopping here"
; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage
(Belle2::LogConfig::c_Fatal, std::move(varStream), "svd", __PRETTY_FUNCTION__
, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc", 512, 0
)); }; exit(1); } while(false);
}

if ((SignalTree->GetEntries() == 0) || (FakeTree->GetEntries() == 0)) {
3
←
Assuming the condition is false→
4
←
Assuming the condition is false→
  B2FATAL("The dataset is empty, stopping here")do { { LogVariableStream varStream; varStream << "The dataset is empty, stopping here"
; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage
(Belle2::LogConfig::c_Fatal, std::move(varStream), "svd", __PRETTY_FUNCTION__
, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc", 516, 0
)); }; exit(1); } while(false);
}

if ((SignalTree->GetBranch(Form("%sMomentum", SignalVarName.Data())) == nullptr)
5
←
Assuming the condition is false→
7
←
Taking false branch→
    || (FakeTree->GetBranch(Form("%sMomentum", FakeVarName.Data())) == nullptr)) {
6
←
Assuming the condition is false→
  B2FATAL("Check the provided branch name, stopping here")do { { LogVariableStream varStream; varStream << "Check the provided branch name, stopping here"
; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage
(Belle2::LogConfig::c_Fatal, std::move(varStream), "svd", __PRETTY_FUNCTION__
, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc", 521, 0
)); }; exit(1); } while(false);
}

std::vector<TString> PIDDetectors;
PIDDetectors.clear();
PIDDetectors.push_back("ALL");
PIDDetectors.push_back("noSVD");

std::vector<double> SignalEfficiencyALL, FakeEfficiencyALL;
SignalEfficiencyALL.reserve(m_NumROCpoints);
FakeEfficiencyALL.reserve(m_NumROCpoints);
std::vector<double> SignalEfficiencynoSVD, FakeEfficiencynoSVD;
SignalEfficiencynoSVD.reserve(m_NumROCpoints);
FakeEfficiencynoSVD.reserve(m_NumROCpoints);

TString SignalFiducialCut = SignalVarName + PIDVarName + "noSVD>=0"; // sanity cuts to reject events with NaN
TString FakesFiducialCut = FakeVarName + PIDVarName + "noSVD>=0";
TString SignalFiducialCutSlow = "SlowPion" + PIDVarName + "noSVD>=0";
TString FakesFiducialCutSlow = "SlowPion" + PIDVarName + "noSVD>=0";

// calculate efficiencies

TCut AllSignalCut = SignalFiducialCut * Form("%sMomentum>%f && %sMomentum<%f", SignalVarName.Data(), m_MomLowROC,
                                             SignalVarName.Data(), m_MomHighROC);

double AllSignalIntegral, SelectedSignalIntegral;

auto DataFrameSignalAll = RDataFrame(*SignalTree).Filter(AllSignalCut.GetTitle());
8
←
Calling 'RInterface::Filter'→

if (SignalWeightName == "1") {
  AllSignalIntegral = DataFrameSignalAll.Count().GetValue();
} else {
  AllSignalIntegral = DataFrameSignalAll.Sum(SignalWeightName).GetValue();
}

std::unique_ptr<ROOT::RDF::RNode> DataFrameSlowSignalAll;

if (strncmp(SignalVarName.Data(), "PionD", 5) == 0) {
  TString SignalVarNameSlow = "SlowPion";
  TCut AllSignalCutSlow = TCut(SignalFiducialCut) * TCut(SignalFiducialCutSlow) * Form("(%sMomentum>%f && %sMomentum<%f)",
                          SignalVarNameSlow.Data(), m_MomLowROC, SignalVarNameSlow.Data(), m_MomHighROC);
  DataFrameSlowSignalAll = std::make_unique<ROOT::RDF::RNode>(RDataFrame(*SignalTree).Filter(AllSignalCutSlow.GetTitle()));

  if (SignalWeightName == "1") {
    AllSignalIntegral += DataFrameSlowSignalAll->Count().GetValue();
  } else {
    AllSignalIntegral += DataFrameSlowSignalAll->Sum(SignalWeightName).GetValue();
  }
}

for (unsigned int i = 0; i < PIDDetectors.size(); i++) {
  for (unsigned int j = 0; j < m_NumROCpoints; ++j) {
    delete gROOT(ROOT::GetROOT())->FindObject("PIDCut");

    // scan cut values from 0 to 1, with a denser scan closer to 0 or 1, to get a nicer ROC curve
    double x = 1. / m_NumROCpoints * j;
    TString PIDCut = TString::Format("%f", 1. / (1 + TMath::Power(x / (1 - x), -3)));

    TCut SelectedSignalCut = Form("(%s%s%s > %s)", SignalVarName.Data(), PIDVarName.Data(), PIDDetectors[i].Data(), PIDCut.Data());

    if (SignalWeightName == "1") {
      SelectedSignalIntegral = DataFrameSignalAll.Filter(SelectedSignalCut.GetTitle()).Count().GetValue();
    } else {
      SelectedSignalIntegral = DataFrameSignalAll.Filter(SelectedSignalCut.GetTitle()).Sum(SignalWeightName).GetValue();
    }

    // special treatment for pions: add also the slow pions from Dstar to gain low-momentum coverage
    if (strncmp(SignalVarName.Data(), "PionD", 5) == 0) {
      TString SignalVarNameSlow = "SlowPion";
      TCut SelectedSignalCutSlow = Form("(%s%s%s > %s)", SignalVarNameSlow.Data(), PIDVarName.Data(), PIDDetectors[i].Data(),
                                        PIDCut.Data());

      if (SignalWeightName == "1") {
        SelectedSignalIntegral += DataFrameSlowSignalAll->Filter(SelectedSignalCutSlow.GetTitle()).Count().GetValue();
      } else {
        SelectedSignalIntegral += DataFrameSlowSignalAll->Filter(SelectedSignalCutSlow.GetTitle()).Sum(SignalWeightName).GetValue();
      }
    }

    if (PIDDetectors[i] == "ALL") {
      SignalEfficiencyALL.push_back(SelectedSignalIntegral / AllSignalIntegral);
    }

    if (PIDDetectors[i] == "noSVD") {
      SignalEfficiencynoSVD.push_back(SelectedSignalIntegral / AllSignalIntegral);
    }
  }
}

// calculate fake rates

TCut AllFakeCut = FakesFiducialCut * Form("%sMomentum>%f && %sMomentum<%f", FakeVarName.Data(), m_MomLowROC, FakeVarName.Data(),
                                          m_MomHighROC);

double AllFakeIntegral, SelectedFakeIntegral;
auto DataFrameFakeAll = RDataFrame(*FakeTree).Filter(AllFakeCut.GetTitle());

if (FakeWeightName == "1") {
  AllFakeIntegral = DataFrameFakeAll.Count().GetValue();
} else {
  AllFakeIntegral = DataFrameFakeAll.Sum(FakeWeightName).GetValue();
}

std::unique_ptr<ROOT::RDF::RNode> DataFrameSlowFakeAll;

// special treatment for pions: add also the slow pions from Dstar to gain low-momentum coverage
if (strncmp(FakeVarName.Data(), "PionD", 5) == 0) {

  TString FakeVarNameSlow = "SlowPion";
  TCut AllFakeCutSlow = TCut(FakesFiducialCut) * TCut(FakesFiducialCutSlow) * Form("(%sMomentum>%f && %sMomentum<%f)",
                        FakeVarNameSlow.Data(), m_MomLowROC, FakeVarNameSlow.Data(), m_MomHighROC);
  DataFrameSlowFakeAll = std::make_unique<ROOT::RDF::RNode>(RDataFrame(*FakeTree).Filter(AllFakeCutSlow.GetTitle()));

  if (FakeWeightName == "1") {
    AllFakeIntegral += DataFrameSlowFakeAll->Count().GetValue();
  } else {
    AllFakeIntegral += DataFrameSlowFakeAll->Sum(FakeWeightName).GetValue();
  }
}

for (unsigned int i = 0; i < PIDDetectors.size(); i++) {
  for (unsigned int j = 0; j < m_NumROCpoints; ++j) {
    delete gROOT(ROOT::GetROOT())->FindObject("PIDCut");
    delete gROOT(ROOT::GetROOT())->FindObject("hAllFakes");
    delete gROOT(ROOT::GetROOT())->FindObject("hSelectedFakes");

    // scan cut values from 0 to 1, with a denser scan closer to 0 or 1, to get a nicer ROC curve
    double x = 1. / m_NumROCpoints * j;
    TString PIDCut = TString::Format("%f", 1. / (1 + TMath::Power(x / (1 - x), -3)));

    TCut SelectedFakeCut = Form("(%s%s%s > %s)", FakeVarName.Data(), PIDVarName.Data(), PIDDetectors[i].Data(), PIDCut.Data());

    if (FakeWeightName == "1") {
      SelectedFakeIntegral = DataFrameFakeAll.Filter(SelectedFakeCut.GetTitle()).Count().GetValue();
    } else {
      SelectedFakeIntegral = DataFrameFakeAll.Filter(SelectedFakeCut.GetTitle()).Sum(FakeWeightName).GetValue();
    }

    if (strncmp(FakeVarName.Data(), "PionD", 5) == 0) {
      TString FakeVarNameSlow = "SlowPion";

      TCut SelectedFakeCutSlow = Form("(%s%s%s > %s)", FakeVarNameSlow.Data(), PIDVarName.Data(), PIDDetectors[i].Data(), PIDCut.Data());

      if (FakeWeightName == "1") {
        SelectedFakeIntegral += DataFrameSlowFakeAll->Filter(SelectedFakeCutSlow.GetTitle()).Count().GetValue();
      } else {
        SelectedFakeIntegral += DataFrameSlowFakeAll->Filter(SelectedFakeCutSlow.GetTitle()).Sum(FakeWeightName).GetValue();
      }
    }

    if (PIDDetectors[i] == "ALL") {
      FakeEfficiencyALL.push_back(SelectedFakeIntegral / AllFakeIntegral);
    }

    if (PIDDetectors[i] == "noSVD") {
      FakeEfficiencynoSVD.push_back(SelectedFakeIntegral / AllFakeIntegral);
    }
  }
}

auto ResultCanvas = new TCanvas("ResultCanvas", "", 600, 400);
TMultiGraph* hmgraph = new TMultiGraph();

// efficiency vs fake rate graph
TGraph* hgraphALL = new TGraph(m_NumROCpoints, FakeEfficiencyALL.data(), SignalEfficiencyALL.data());
hgraphALL->SetMarkerColor(TColor::GetColor("#2166ac"));
hgraphALL->SetMarkerStyle(20);
hgraphALL->SetLineColor(TColor::GetColor("#2166ac"));
hgraphALL->SetLineWidth(3);
hgraphALL->SetDrawOption("AP*");
hgraphALL->SetTitle("with SVD");

TGraph* hgraphnoSVD = new TGraph(m_NumROCpoints, FakeEfficiencynoSVD.data(), SignalEfficiencynoSVD.data());
hgraphnoSVD->SetMarkerColor(TColor::GetColor("#ef8a62"));
hgraphnoSVD->SetLineColor(TColor::GetColor("#ef8a62"));
hgraphnoSVD->SetLineWidth(3);
hgraphnoSVD->SetMarkerStyle(22);
hgraphnoSVD->SetDrawOption("P*");
hgraphnoSVD->SetTitle("without SVD");

hmgraph->Add(hgraphALL);
hmgraph->Add(hgraphnoSVD);
hmgraph->Draw("A");
hmgraph->GetHistogram()->GetXaxis()->SetTitle(FakeVarNameFull + " fake rate");
hmgraph->GetHistogram()->GetYaxis()->SetTitle(SignalVarNameFull + " signal efficiency");

ResultCanvas->BuildLegend(0.6, 0.25, 0.9, 0.5);
ResultCanvas->SetGrid();

ResultCanvas->Print("SVDdEdxValidation_ROC_curve_" + SignalVarNameFull + "_vs_" + FakeVarNameFull + PIDVarName + "_MomRange" +
                    std::to_string(m_MomLowROC).substr(0, 3) + "_" + std::to_string(m_MomHighROC).substr(0, 3) + ".pdf");

TFile ResultFile("SVDdEdxValidation_ROC_curve_" + SignalVarNameFull + "_vs_" + FakeVarNameFull + PIDVarName + "_MomRange" +
                 std::to_string(m_MomLowROC).substr(0, 3) + "_" + std::to_string(m_MomHighROC).substr(0, 3) + ".root",
                 "RECREATE");
hmgraph->Write();
ResultFile.Close();

delete ResultCanvas;
720}

722TTree* SVDdEdxValidationAlgorithm::LambdaMassFit(std::shared_ptr<TTree> preselTree)
723{
B2INFO("Configuring the Lambda fit...")do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Info, 0, "svd")) { { LogVariableStream varStream
; varStream << "Configuring the Lambda fit..."; Belle2::
LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::
LogConfig::c_Info, std::move(varStream), "svd", __PRETTY_FUNCTION__
, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc", 724, 0
)); }; } } while(false);
gROOT(ROOT::GetROOT())->SetBatch(true);
RooMsgService::instance().setGlobalKillBelow(RooFit::WARNING);

RooRealVar InvM("InvM", "m(p^{+}#pi^{-})", 1.1, 1.13, "GeV/c^{2}");

RooRealVar ProtonMomentum("ProtonMomentum", "momentum for p", -1.e8, 1.e8);
RooRealVar ProtonSVDdEdx("ProtonSVDdEdx", "", -1.e8, 1.e8);

RooRealVar exp("exp", "experiment number", 0, 1.e5);
RooRealVar run("run", "run number", 0, 1.e7);

RooRealVar ProtonProtonIDALL("ProtonProtonIDALL", "", -1.e8, 1.e8);
RooRealVar ProtonProtonIDSVDonly("ProtonProtonIDSVDonly", "", -1.e8, 1.e8);
RooRealVar ProtonProtonIDnoSVD("ProtonProtonIDnoSVD", "", -1.e8, 1.e8);

RooRealVar ProtonElectronLLSVDonly("ProtonElectronLLSVDonly", "", -1.e8, 1.e8);
RooRealVar ProtonPionLLSVDonly("ProtonPionLLSVDonly", "", -1.e8, 1.e8);
RooRealVar ProtonKaonLLSVDonly("ProtonKaonLLSVDonly", "", -1.e8, 1.e8);
RooRealVar ProtonProtonLLSVDonly("ProtonProtonLLSVDonly", "", -1.e8, 1.e8);

RooRealVar ProtonBinaryProtonPionIDALL("ProtonBinaryProtonPionIDALL", "", -1.e8, 1.e8);
RooRealVar ProtonBinaryProtonPionIDSVDonly("ProtonBinaryProtonPionIDSVDonly", "", -1.e8, 1.e8);
RooRealVar ProtonBinaryProtonPionIDnoSVD("ProtonBinaryProtonPionIDnoSVD", "", -1.e8, 1.e8);

RooRealVar ProtonBinaryProtonKaonIDALL("ProtonBinaryProtonKaonIDALL", "", -1.e8, 1.e8);
RooRealVar ProtonBinaryProtonKaonIDSVDonly("ProtonBinaryProtonKaonIDSVDonly", "", -1.e8, 1.e8);
RooRealVar ProtonBinaryProtonKaonIDnoSVD("ProtonBinaryProtonKaonIDnoSVD", "", -1.e8, 1.e8);

RooRealVar ProtonBinaryProtonElectronIDALL("ProtonBinaryProtonElectronIDALL", "", -1.e8, 1.e8);
RooRealVar ProtonBinaryProtonElectronIDSVDonly("ProtonBinaryProtonElectronIDSVDonly", "", -1.e8, 1.e8);
RooRealVar ProtonBinaryProtonElectronIDnoSVD("ProtonBinaryProtonElectronIDnoSVD", "", -1.e8, 1.e8);

RooRealVar ProtonBinaryPionProtonIDALL("ProtonBinaryPionProtonIDALL", "", -1.e8, 1.e8);
RooRealVar ProtonBinaryPionProtonIDSVDonly("ProtonBinaryPionProtonIDSVDonly", "", -1.e8, 1.e8);
RooRealVar ProtonBinaryPionProtonIDnoSVD("ProtonBinaryPionProtonIDnoSVD", "", -1.e8, 1.e8);

RooRealVar ProtonBinaryKaonProtonIDALL("ProtonBinaryKaonProtonIDALL", "", -1.e8, 1.e8);
RooRealVar ProtonBinaryKaonProtonIDSVDonly("ProtonBinaryKaonProtonIDSVDonly", "", -1.e8, 1.e8);
RooRealVar ProtonBinaryKaonProtonIDnoSVD("ProtonBinaryKaonProtonIDnoSVD", "", -1.e8, 1.e8);

RooRealVar ProtonBinaryElectronProtonIDALL("ProtonBinaryElectronProtonIDALL", "", -1.e8, 1.e8);
RooRealVar ProtonBinaryElectronProtonIDSVDonly("ProtonBinaryElectronProtonIDSVDonly", "", -1.e8, 1.e8);
RooRealVar ProtonBinaryElectronProtonIDnoSVD("ProtonBinaryElectronProtonIDnoSVD", "", -1.e8, 1.e8);

auto variables = new RooArgSet();

variables->add(InvM);

variables->add(ProtonMomentum);
variables->add(ProtonSVDdEdx);
variables->add(exp);
variables->add(run);

variables->add(ProtonProtonIDALL);
variables->add(ProtonProtonIDSVDonly);
variables->add(ProtonProtonIDnoSVD);
variables->add(ProtonElectronLLSVDonly);
variables->add(ProtonPionLLSVDonly);
variables->add(ProtonKaonLLSVDonly);
variables->add(ProtonProtonLLSVDonly);
variables->add(ProtonBinaryProtonPionIDALL);
variables->add(ProtonBinaryProtonPionIDSVDonly);
variables->add(ProtonBinaryProtonPionIDnoSVD);
variables->add(ProtonBinaryProtonKaonIDALL);
variables->add(ProtonBinaryProtonKaonIDSVDonly);
variables->add(ProtonBinaryProtonKaonIDnoSVD);
variables->add(ProtonBinaryProtonElectronIDALL);
variables->add(ProtonBinaryProtonElectronIDSVDonly);
variables->add(ProtonBinaryProtonElectronIDnoSVD);
variables->add(ProtonBinaryPionProtonIDALL);
variables->add(ProtonBinaryPionProtonIDSVDonly);
variables->add(ProtonBinaryPionProtonIDnoSVD);
variables->add(ProtonBinaryKaonProtonIDALL);
variables->add(ProtonBinaryKaonProtonIDSVDonly);
variables->add(ProtonBinaryKaonProtonIDnoSVD);
variables->add(ProtonBinaryElectronProtonIDALL);
variables->add(ProtonBinaryElectronProtonIDSVDonly);
variables->add(ProtonBinaryElectronProtonIDnoSVD);

RooDataSet* LambdaDataset = new RooDataSet("LambdaDataset", "LambdaDataset", *variables, Import(*preselTree));

if (LambdaDataset->sumEntries() == 0) {
  B2FATAL("The Lambda dataset is empty, stopping here")do { { LogVariableStream varStream; varStream << "The Lambda dataset is empty, stopping here"
; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage
(Belle2::LogConfig::c_Fatal, std::move(varStream), "svd", __PRETTY_FUNCTION__
, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc", 807, 0
)); }; exit(1); } while(false);
}

// the signal PDF; might be revisited at a later point

RooRealVar GaussMean("GaussMean", " GaussMean", 1.116, 1.111, 1.12);
RooRealVar GaussSigma("GaussSigma", "#sigma_{1}", 3.e-3, 3.e-5, 10.e-3);
RooGaussian LambdaGauss("LambdaGauss", "LambdaGauss", InvM, GaussMean, GaussSigma);

/* temporary RooRealVar sigmaBifurGaussL1 and sigmaBifurGaussR1 to replace
 * RooRealVar resolutionParamL("resolutionParamL", "resolutionParamL", 0.4, 5.e-4, 1.0);
 * RooRealVar resolutionParamR("resolutionParamR", "resolutionParamR", 0.4, 5.e-4, 1.0);
 * RooFormulaVar sigmaBifurGaussL1("sigmaBifurGaussL1", "resolutionParamL*GaussSigma", RooArgSet(resolutionParamL, GaussSigma));
 * RooFormulaVar sigmaBifurGaussR1("sigmaBifurGaussR1", "resolutionParamR*GaussSigma", RooArgSet(resolutionParamR, GaussSigma));
 */
RooRealVar sigmaBifurGaussL1("sigmaBifurGaussL1", "sigma left", 0.4 * 3.e-3, 3.e-5, 10.e-3);
RooRealVar sigmaBifurGaussR1("sigmaBifurGaussR1", "sigma right", 0.4 * 3.e-3, 3.e-5, 10.e-3);
RooBifurGauss LambdaBifurGauss("LambdaBifurGauss", "LambdaBifurGauss", InvM, GaussMean, sigmaBifurGaussL1, sigmaBifurGaussR1);

/* temporary RooRealVar sigmaBifurGaussL2 to replace
 * RooRealVar resolutionParam2("resolutionParam2", "resolutionParam2", 0.2, 5.e-4, 1.0);
 * sigmaBifurGaussL2("sigmaBifurGaussL2", "resolutionParam2*GaussSigma", RooArgSet(resolutionParam2, GaussSigma));
 */
RooRealVar sigmaBifurGaussL2("sigmaBifurGaussL2", "sigmaBifurGaussL2", 0.2 * 3.e-3, 3.e-5, 10.e-3);
RooGaussian LambdaBifurGauss2("LambdaBifurGauss2", "LambdaBifurGauss2", InvM, GaussMean, sigmaBifurGaussL2);

RooRealVar fracBifurGaussYield("fracBifurGaussYield", "fracBifurGaussYield", 0.3, 5.e-4, 1.0);
RooRealVar fracGaussYield("fracGaussYield", "fracGaussYield", 0.8, 5.e-4, 1.0);

RooAddPdf LambdaCombinedBifurGauss("LambdaCombinedBifurGauss", "LambdaBifurGauss + LambdaBifurGauss2 ", RooArgList(LambdaBifurGauss,
                                   LambdaBifurGauss2), RooArgList(fracBifurGaussYield));

RooAddPdf LambdaSignalPDF("LambdaSignalPDF", "LambdaCombinedBifurGauss + LambdaGauss", RooArgList(LambdaCombinedBifurGauss,
                          LambdaGauss), RooArgList(fracGaussYield));

// Background PDF
RooRealVar BkgPolyCoef0("BkgPolyCoef0", "BkgPolyCoef0", 0.1, 0., 1.5);
RooRealVar BkgPolyCoef1("BkgPolyCoef1", "BkgPolyCoef1", -0.5, -1.5, -1.e-3);
RooChebychev BkgPolyPDF("BkgPolyPDF", "BkgPolyPDF", InvM, RooArgList(BkgPolyCoef0, BkgPolyCoef1));

RooRealVar nSignalLambda("nSignalLambda", "nSignalLambda", 0.6 * preselTree->GetEntries(), 0., 0.99 * preselTree->GetEntries());
RooRealVar nBkgLambda("nBkgLambda", "nBkgLambda", 0.4 * preselTree->GetEntries(), 0., 0.99 * preselTree->GetEntries());
RooAddPdf totalPDFLambda("totalPDFLambda", "totalPDFLambda pdf", RooArgList(LambdaSignalPDF, BkgPolyPDF),
                         RooArgList(nSignalLambda, nBkgLambda));

B2INFO("Lambda: Start fitting...")do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Info, 0, "svd")) { { LogVariableStream varStream
; varStream << "Lambda: Start fitting..."; Belle2::LogSystem
::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig
::c_Info, std::move(varStream), "svd", __PRETTY_FUNCTION__, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc"
, 852, 0)); }; } } while(false);
RooFitResult* LambdaFitResult = totalPDFLambda.fitTo(*LambdaDataset, Save(kTRUE), PrintLevel(-1));

int status = LambdaFitResult->status();
int covqual = LambdaFitResult->covQual();
double diff = nSignalLambda.getValV() + nBkgLambda.getValV() - LambdaDataset->sumEntries();

B2INFO("Lambda: Fit status: " << status << "; covariance quality: " << covqual)do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Info, 0, "svd")) { { LogVariableStream varStream
; varStream << "Lambda: Fit status: " << status <<
 "; covariance quality: " << covqual; Belle2::LogSystem
::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig
::c_Info, std::move(varStream), "svd", __PRETTY_FUNCTION__, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc"
, 859, 0)); }; } } while(false);
// if the fit is not healthy, try again once before giving up, with a slightly different setup:
if ((status > 0) || (TMath::Abs(diff) > 1.) || (nSignalLambda.getError() < sqrt(nSignalLambda.getValV()))
    || (nSignalLambda.getError() > (nSignalLambda.getValV()))) {

  LambdaFitResult = totalPDFLambda.fitTo(*LambdaDataset, Save(), Strategy(2), Offset(1));
  status = LambdaFitResult->status();
  covqual = LambdaFitResult->covQual();
  diff = nSignalLambda.getValV() + nBkgLambda.getValV() - LambdaDataset->sumEntries();
}

if ((status > 0) || (TMath::Abs(diff) > 1.) || (nSignalLambda.getError() < sqrt(nSignalLambda.getValV()))
    || (nSignalLambda.getError() > (nSignalLambda.getValV()))) {
  B2WARNING("Lambda: Fit problem: fit status " << status << "; sum of component yields minus the dataset yield is " << diff <<do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Warning, 0, "svd")) { { LogVariableStream varStream
; varStream << "Lambda: Fit problem: fit status " <<
 status << "; sum of component yields minus the dataset yield is "
 << diff << "; signal yield is " << nSignalLambda
.getValV() << ", while its uncertainty is " << nSignalLambda
.getError(); Belle2::LogSystem::Instance().sendMessage(Belle2
::LogMessage(Belle2::LogConfig::c_Warning, std::move(varStream
), "svd", __PRETTY_FUNCTION__, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc"
, 873, 0)); }; } } while(false)
            "; signal yield is " << nSignalLambda.getValV() << ", while its uncertainty is " << nSignalLambda.getError())do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Warning, 0, "svd")) { { LogVariableStream varStream
; varStream << "Lambda: Fit problem: fit status " <<
 status << "; sum of component yields minus the dataset yield is "
 << diff << "; signal yield is " << nSignalLambda
.getValV() << ", while its uncertainty is " << nSignalLambda
.getError(); Belle2::LogSystem::Instance().sendMessage(Belle2
::LogMessage(Belle2::LogConfig::c_Warning, std::move(varStream
), "svd", __PRETTY_FUNCTION__, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc"
, 873, 0)); }; } } while(false);
}
if (covqual < 2) {
  B2INFO("Lambda: Fit warning: covariance quality " << covqual)do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Info, 0, "svd")) { { LogVariableStream varStream
; varStream << "Lambda: Fit warning: covariance quality "
 << covqual; Belle2::LogSystem::Instance().sendMessage(
Belle2::LogMessage(Belle2::LogConfig::c_Info, std::move(varStream
), "svd", __PRETTY_FUNCTION__, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc"
, 876, 0)); }; } } while(false);
}

TCanvas* canvLambda = new TCanvas("canvLambda", "canvLambda");
RooPlot* LambdaFitFrame = LambdaDataset->plotOn(InvM.frame(130));
totalPDFLambda.plotOn(LambdaFitFrame, LineColor(TColor::GetColor("#4575b4")));

double chisquare = LambdaFitFrame->chiSquare();
B2INFO("Lambda: Fit chi2 = " << chisquare)do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Info, 0, "svd")) { { LogVariableStream varStream
; varStream << "Lambda: Fit chi2 = " << chisquare
; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage
(Belle2::LogConfig::c_Info, std::move(varStream), "svd", __PRETTY_FUNCTION__
, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc", 884, 0
)); }; } } while(false);
totalPDFLambda.paramOn(LambdaFitFrame, Layout(0.6, 0.96, 0.93), Format("NEU", AutoPrecision(2)));
LambdaFitFrame->getAttText()->SetTextSize(0.03);

totalPDFLambda.plotOn(LambdaFitFrame, Components("LambdaSignalPDF"), LineColor(TColor::GetColor("#d73027")));
totalPDFLambda.plotOn(LambdaFitFrame, Components("BkgPolyPDF"), LineColor(TColor::GetColor("#fc8d59")));
totalPDFLambda.plotOn(LambdaFitFrame, LineColor(TColor::GetColor("#4575b4")));

LambdaFitFrame->GetXaxis()->SetTitle("m(p#pi^{-}) (GeV/c^{2})");

LambdaFitFrame->Draw();

if (m_isMakePlots) {
  canvLambda->Print("SVDdEdxValidationFitLambda.pdf");
  TFile LambdaFitPlotFile("SVDdEdxValidationLambdaFitPlotFile.root", "RECREATE");
  canvLambda->Write();
  LambdaFitPlotFile.Close();
}
RooStats::SPlot* sPlotDatasetLambda = new RooStats::SPlot("sData", "An SPlot", *LambdaDataset, &totalPDFLambda,
                                                          RooArgList(nSignalLambda, nBkgLambda));

for (int iEvt = 0; iEvt < 5; iEvt++) {
  if (TMath::Abs(sPlotDatasetLambda->GetSWeight(iEvt, "nSignalLambda") + sPlotDatasetLambda->GetSWeight(iEvt,
                 "nBkgLambda") - 1) > 5.e-3)
    B2FATAL("Lambda: sPlot error: sum of weights not equal to 1")do { { LogVariableStream varStream; varStream << "Lambda: sPlot error: sum of weights not equal to 1"
; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage
(Belle2::LogConfig::c_Fatal, std::move(varStream), "svd", __PRETTY_FUNCTION__
, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc", 908, 0
)); }; exit(1); } while(false);
}

TTree* treeLambda_sw = LambdaDataset->GetClonedTree();
treeLambda_sw->SetName("treeLambda_sw");

B2INFO("Lambda: sPlot done. ")do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Info, 0, "svd")) { { LogVariableStream varStream
; varStream << "Lambda: sPlot done. "; Belle2::LogSystem
::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig
::c_Info, std::move(varStream), "svd", __PRETTY_FUNCTION__, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc"
, 914, 0)); }; } } while(false);

return treeLambda_sw;
917}

919TTree* SVDdEdxValidationAlgorithm::DstarMassFit(std::shared_ptr<TTree> preselTree)
920{
B2INFO("Configuring the Dstar fit...")do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Info, 0, "svd")) { { LogVariableStream varStream
; varStream << "Configuring the Dstar fit..."; Belle2::
LogSystem::Instance().sendMessage(Belle2::LogMessage(Belle2::
LogConfig::c_Info, std::move(varStream), "svd", __PRETTY_FUNCTION__
, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc", 921, 0
)); }; } } while(false);
gROOT(ROOT::GetROOT())->SetBatch(true);
RooMsgService::instance().setGlobalKillBelow(RooFit::WARNING);

RooRealVar deltaM("deltaM", "m(D*)-m(D^{0})", 0.139545, 0.151, "GeV/c^{2}");

RooRealVar KaonMomentum("KaonMomentum", "momentum for Kaon(GeV)", -1.e8, 1.e8);
RooRealVar KaonSVDdEdx("KaonSVDdEdx", "", -1.e8, 1.e8);
RooRealVar PionDMomentum("PionDMomentum", "momentum for pion(GeV)", -1.e8, 1.e8);
RooRealVar PionDSVDdEdx("PionDSVDdEdx", "", -1.e8, 1.e8);
RooRealVar SlowPionMomentum("SlowPionMomentum", "momentum for slow pion(GeV)", -1.e8, 1.e8);
RooRealVar SlowPionSVDdEdx("SlowPionSVDdEdx", "", -1.e8, 1.e8);

RooRealVar exp("exp", "experiment number", 0, 1.e5);
RooRealVar run("run", "run number", 0, 1.e8);

RooRealVar KaonKaonIDALL("KaonKaonIDALL", "", -1.e8, 1.e8);
RooRealVar KaonKaonIDSVDonly("KaonKaonIDSVDonly", "", -1.e8, 1.e8);
RooRealVar KaonKaonIDnoSVD("KaonKaonIDnoSVD", "", -1.e8, 1.e8);

RooRealVar KaonPionIDALL("KaonPionIDALL", "", -1.e8, 1.e8);
RooRealVar KaonPionIDSVDonly("KaonPionIDSVDonly", "", -1.e8, 1.e8);
RooRealVar KaonPionIDnoSVD("KaonPionIDnoSVD", "", -1.e8, 1.e8);

RooRealVar KaonProtonIDALL("KaonProtonIDALL", "", -1.e8, 1.e8);
RooRealVar KaonProtonIDSVDonly("KaonProtonIDSVDonly", "", -1.e8, 1.e8);
RooRealVar KaonProtonIDnoSVD("KaonProtonIDnoSVD", "", -1.e8, 1.e8);

RooRealVar KaonElectronIDALL("KaonElectronIDALL", "", -1.e8, 1.e8);
RooRealVar KaonElectronIDSVDonly("KaonElectronIDSVDonly", "", -1.e8, 1.e8);
RooRealVar KaonElectronIDnoSVD("KaonElectronIDnoSVD", "", -1.e8, 1.e8);

RooRealVar KaonElectronLLSVDonly("KaonElectronLLSVDonly", "", -1.e8, 1.e8);
RooRealVar KaonPionLLSVDonly("KaonPionLLSVDonly", "", -1.e8, 1.e8);
RooRealVar KaonKaonLLSVDonly("KaonKaonLLSVDonly", "", -1.e8, 1.e8);
RooRealVar KaonProtonLLSVDonly("KaonProtonLLSVDonly", "", -1.e8, 1.e8);

RooRealVar KaonBinaryKaonPionIDALL("KaonBinaryKaonPionIDALL", "", -1.e8, 1.e8);
RooRealVar KaonBinaryKaonPionIDSVDonly("KaonBinaryKaonPionIDSVDonly", "", -1.e8, 1.e8);
RooRealVar KaonBinaryKaonPionIDnoSVD("KaonBinaryKaonPionIDnoSVD", "", -1.e8, 1.e8);

RooRealVar KaonBinaryPionKaonIDALL("KaonBinaryPionKaonIDALL", "", -1.e8, 1.e8);
RooRealVar KaonBinaryPionKaonIDSVDonly("KaonBinaryPionKaonIDSVDonly", "", -1.e8, 1.e8);
RooRealVar KaonBinaryPionKaonIDnoSVD("KaonBinaryPionKaonIDnoSVD", "", -1.e8, 1.e8);

RooRealVar KaonBinaryProtonKaonIDALL("KaonBinaryProtonKaonIDALL", "", -1.e8, 1.e8);
RooRealVar KaonBinaryProtonKaonIDSVDonly("KaonBinaryProtonKaonIDSVDonly", "", -1.e8, 1.e8);
RooRealVar KaonBinaryProtonKaonIDnoSVD("KaonBinaryProtonKaonIDnoSVD", "", -1.e8, 1.e8);

RooRealVar KaonBinaryElectronKaonIDALL("KaonBinaryElectronKaonIDALL", "", -1.e8, 1.e8);
RooRealVar KaonBinaryElectronKaonIDSVDonly("KaonBinaryElectronKaonIDSVDonly", "", -1.e8, 1.e8);
RooRealVar KaonBinaryElectronKaonIDnoSVD("KaonBinaryElectronKaonIDnoSVD", "", -1.e8, 1.e8);

RooRealVar PionDKaonIDALL("PionDKaonIDALL", "", -1.e8, 1.e8);
RooRealVar PionDKaonIDSVDonly("PionDKaonIDSVDonly", "", -1.e8, 1.e8);
RooRealVar PionDKaonIDnoSVD("PionDKaonIDnoSVD", "", -1.e8, 1.e8);

RooRealVar PionDPionIDALL("PionDPionIDALL", "", -1.e8, 1.e8);
RooRealVar PionDPionIDSVDonly("PionDPionIDSVDonly", "", -1.e8, 1.e8);
RooRealVar PionDPionIDnoSVD("PionDPionIDnoSVD", "", -1.e8, 1.e8);

RooRealVar PionDElectronIDALL("PionDElectronIDALL", "", -1.e8, 1.e8);
RooRealVar PionDElectronIDSVDonly("PionDElectronIDSVDonly", "", -1.e8, 1.e8);
RooRealVar PionDElectronIDnoSVD("PionDElectronIDnoSVD", "", -1.e8, 1.e8);

RooRealVar PionDProtonIDALL("PionDProtonIDALL", "", -1.e8, 1.e8);
RooRealVar PionDProtonIDSVDonly("PionDProtonIDSVDonly", "", -1.e8, 1.e8);
RooRealVar PionDProtonIDnoSVD("PionDProtonIDnoSVD", "", -1.e8, 1.e8);

RooRealVar PionDElectronLLSVDonly("PionDElectronLLSVDonly", "", -1.e8, 1.e8);
RooRealVar PionDPionLLSVDonly("PionDPionLLSVDonly", "", -1.e8, 1.e8);
RooRealVar PionDKaonLLSVDonly("PionDKaonLLSVDonly", "", -1.e8, 1.e8);
RooRealVar PionDProtonLLSVDonly("PionDProtonLLSVDonly", "", -1.e8, 1.e8);

RooRealVar PionDBinaryPionKaonIDALL("PionDBinaryPionKaonIDALL", "", -1.e8, 1.e8);
RooRealVar PionDBinaryPionKaonIDSVDonly("PionDBinaryPionKaonIDSVDonly", "", -1.e8, 1.e8);
RooRealVar PionDBinaryPionKaonIDnoSVD("PionDBinaryPionKaonIDnoSVD", "", -1.e8, 1.e8);

RooRealVar PionDBinaryKaonPionIDALL("PionDBinaryKaonPionIDALL", "", -1.e8, 1.e8);
RooRealVar PionDBinaryKaonPionIDSVDonly("PionDBinaryKaonPionIDSVDonly", "", -1.e8, 1.e8);
RooRealVar PionDBinaryKaonPionIDnoSVD("PionDBinaryKaonPionIDnoSVD", "", -1.e8, 1.e8);

RooRealVar PionDBinaryProtonPionIDALL("PionDBinaryProtonPionIDALL", "", -1.e8, 1.e8);
RooRealVar PionDBinaryProtonPionIDSVDonly("PionDBinaryProtonPionIDSVDonly", "", -1.e8, 1.e8);
RooRealVar PionDBinaryProtonPionIDnoSVD("PionDBinaryProtonPionIDnoSVD", "", -1.e8, 1.e8);

RooRealVar PionDBinaryElectronPionIDALL("PionDBinaryElectronPionIDALL", "", -1.e8, 1.e8);
RooRealVar PionDBinaryElectronPionIDSVDonly("PionDBinaryElectronPionIDSVDonly", "", -1.e8, 1.e8);
RooRealVar PionDBinaryElectronPionIDnoSVD("PionDBinaryElectronPionIDnoSVD", "", -1.e8, 1.e8);

RooRealVar SlowPionKaonIDALL("SlowPionKaonIDALL", "", -1.e8, 1.e8);
RooRealVar SlowPionKaonIDSVDonly("SlowPionKaonIDSVDonly", "", -1.e8, 1.e8);
RooRealVar SlowPionKaonIDnoSVD("SlowPionKaonIDnoSVD", "", -1.e8, 1.e8);

RooRealVar SlowPionPionIDALL("SlowPionPionIDALL", "", -1.e8, 1.e8);
RooRealVar SlowPionPionIDSVDonly("SlowPionPionIDSVDonly", "", -1.e8, 1.e8);
RooRealVar SlowPionPionIDnoSVD("SlowPionPionIDnoSVD", "", -1.e8, 1.e8);

RooRealVar SlowPionElectronIDALL("SlowPionElectronIDALL", "", -1.e8, 1.e8);
RooRealVar SlowPionElectronIDSVDonly("SlowPionElectronIDSVDonly", "", -1.e8, 1.e8);
RooRealVar SlowPionElectronIDnoSVD("SlowPionElectronIDnoSVD", "", -1.e8, 1.e8);

RooRealVar SlowPionProtonIDALL("SlowPionProtonIDALL", "", -1.e8, 1.e8);
RooRealVar SlowPionProtonIDSVDonly("SlowPionProtonIDSVDonly", "", -1.e8, 1.e8);
RooRealVar SlowPionProtonIDnoSVD("SlowPionProtonIDnoSVD", "", -1.e8, 1.e8);

RooRealVar SlowPionElectronLLSVDonly("SlowPionElectronLLSVDonly", "", -1.e8, 1.e8);
RooRealVar SlowPionPionLLSVDonly("SlowPionPionLLSVDonly", "", -1.e8, 1.e8);
RooRealVar SlowPionKaonLLSVDonly("SlowPionKaonLLSVDonly", "", -1.e8, 1.e8);
RooRealVar SlowPionProtonLLSVDonly("SlowPionProtonLLSVDonly", "", -1.e8, 1.e8);

RooRealVar SlowPionBinaryPionKaonIDALL("SlowPionBinaryPionKaonIDALL", "", -1.e8, 1.e8);
RooRealVar SlowPionBinaryPionKaonIDSVDonly("SlowPionBinaryPionKaonIDSVDonly", "", -1.e8, 1.e8);
RooRealVar SlowPionBinaryPionKaonIDnoSVD("SlowPionBinaryPionKaonIDnoSVD", "", -1.e8, 1.e8);

RooRealVar SlowPionBinaryKaonPionIDALL("SlowPionBinaryKaonPionIDALL", "", -1.e8, 1.e8);
RooRealVar SlowPionBinaryKaonPionIDSVDonly("SlowPionBinaryKaonPionIDSVDonly", "", -1.e8, 1.e8);
RooRealVar SlowPionBinaryKaonPionIDnoSVD("SlowPionBinaryKaonPionIDnoSVD", "", -1.e8, 1.e8);

RooRealVar SlowPionBinaryProtonPionIDALL("SlowPionBinaryProtonPionIDALL", "", -1.e8, 1.e8);
RooRealVar SlowPionBinaryProtonPionIDSVDonly("SlowPionBinaryProtonPionIDSVDonly", "", -1.e8, 1.e8);
RooRealVar SlowPionBinaryProtonPionIDnoSVD("SlowPionBinaryProtonPionIDnoSVD", "", -1.e8, 1.e8);

RooRealVar SlowPionBinaryElectronPionIDALL("SlowPionBinaryElectronPionIDALL", "", -1.e8, 1.e8);
RooRealVar SlowPionBinaryElectronPionIDSVDonly("SlowPionBinaryElectronPionIDSVDonly", "", -1.e8, 1.e8);
RooRealVar SlowPionBinaryElectronPionIDnoSVD("SlowPionBinaryElectronPionIDnoSVD", "", -1.e8, 1.e8);

auto variables = new RooArgSet();
variables->add(deltaM);
variables->add(KaonMomentum);
variables->add(KaonSVDdEdx);
variables->add(PionDMomentum);
variables->add(PionDSVDdEdx);
variables->add(SlowPionMomentum);
variables->add(SlowPionSVDdEdx);
variables->add(exp);
variables->add(run);

variables->add(KaonKaonIDALL);
variables->add(KaonKaonIDSVDonly);
variables->add(KaonKaonIDnoSVD);
variables->add(KaonPionIDALL);
variables->add(KaonPionIDSVDonly);
variables->add(KaonPionIDnoSVD);
variables->add(KaonProtonIDALL);
variables->add(KaonProtonIDSVDonly);
variables->add(KaonProtonIDnoSVD);
variables->add(KaonElectronIDALL);
variables->add(KaonElectronIDSVDonly);
variables->add(KaonElectronIDnoSVD);

variables->add(KaonElectronLLSVDonly);
variables->add(KaonPionLLSVDonly);
variables->add(KaonKaonLLSVDonly);
variables->add(KaonProtonLLSVDonly);

variables->add(KaonBinaryKaonPionIDALL);
variables->add(KaonBinaryKaonPionIDSVDonly);
variables->add(KaonBinaryKaonPionIDnoSVD);
variables->add(KaonBinaryPionKaonIDALL);
variables->add(KaonBinaryPionKaonIDSVDonly);
variables->add(KaonBinaryPionKaonIDnoSVD);
variables->add(KaonBinaryProtonKaonIDALL);
variables->add(KaonBinaryProtonKaonIDSVDonly);
variables->add(KaonBinaryProtonKaonIDnoSVD);
variables->add(KaonBinaryElectronKaonIDALL);
variables->add(KaonBinaryElectronKaonIDSVDonly);
variables->add(KaonBinaryElectronKaonIDnoSVD);

variables->add(PionDPionIDALL);
variables->add(PionDPionIDSVDonly);
variables->add(PionDPionIDnoSVD);
variables->add(PionDKaonIDALL);
variables->add(PionDKaonIDSVDonly);
variables->add(PionDKaonIDnoSVD);
variables->add(PionDElectronIDALL);
variables->add(PionDElectronIDSVDonly);
variables->add(PionDElectronIDnoSVD);
variables->add(PionDProtonIDALL);
variables->add(PionDProtonIDSVDonly);
variables->add(PionDProtonIDnoSVD);

variables->add(PionDElectronLLSVDonly);
variables->add(PionDPionLLSVDonly);
variables->add(PionDKaonLLSVDonly);
variables->add(PionDProtonLLSVDonly);

variables->add(PionDBinaryPionKaonIDALL);
variables->add(PionDBinaryPionKaonIDSVDonly);
variables->add(PionDBinaryPionKaonIDnoSVD);
variables->add(PionDBinaryKaonPionIDALL);
variables->add(PionDBinaryKaonPionIDSVDonly);
variables->add(PionDBinaryKaonPionIDnoSVD);
variables->add(PionDBinaryProtonPionIDALL);
variables->add(PionDBinaryProtonPionIDSVDonly);
variables->add(PionDBinaryProtonPionIDnoSVD);
variables->add(PionDBinaryElectronPionIDALL);
variables->add(PionDBinaryElectronPionIDSVDonly);
variables->add(PionDBinaryElectronPionIDnoSVD);

variables->add(SlowPionPionIDALL);
variables->add(SlowPionPionIDSVDonly);
variables->add(SlowPionPionIDnoSVD);
variables->add(SlowPionKaonIDALL);
variables->add(SlowPionKaonIDSVDonly);
variables->add(SlowPionKaonIDnoSVD);
variables->add(SlowPionElectronIDALL);
variables->add(SlowPionElectronIDSVDonly);
variables->add(SlowPionElectronIDnoSVD);
variables->add(SlowPionProtonIDALL);
variables->add(SlowPionProtonIDSVDonly);
variables->add(SlowPionProtonIDnoSVD);

variables->add(SlowPionElectronLLSVDonly);
variables->add(SlowPionPionLLSVDonly);
variables->add(SlowPionKaonLLSVDonly);
variables->add(SlowPionProtonLLSVDonly);

variables->add(SlowPionBinaryPionKaonIDALL);
variables->add(SlowPionBinaryPionKaonIDSVDonly);
variables->add(SlowPionBinaryPionKaonIDnoSVD);
variables->add(SlowPionBinaryKaonPionIDALL);
variables->add(SlowPionBinaryKaonPionIDSVDonly);
variables->add(SlowPionBinaryKaonPionIDnoSVD);
variables->add(SlowPionBinaryProtonPionIDALL);
variables->add(SlowPionBinaryProtonPionIDSVDonly);
variables->add(SlowPionBinaryProtonPionIDnoSVD);
variables->add(SlowPionBinaryElectronPionIDALL);
variables->add(SlowPionBinaryElectronPionIDSVDonly);
variables->add(SlowPionBinaryElectronPionIDnoSVD);

RooDataSet* DstarDataset = new RooDataSet("DstarDataset", "DstarDataset", *variables, Import(*preselTree));

if (DstarDataset->sumEntries() == 0) {
  B2FATAL("The Dstar dataset is empty, stopping here")do { { LogVariableStream varStream; varStream << "The Dstar dataset is empty, stopping here"
; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage
(Belle2::LogConfig::c_Fatal, std::move(varStream), "svd", __PRETTY_FUNCTION__
, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc", 1155, 0
)); }; exit(1); } while(false);
}

RooPlot* DstarFitFrame = DstarDataset->plotOn(deltaM.frame());

RooRealVar GaussMean("GaussMean", "GaussMean", 0.145, 0.140, 0.150);
RooRealVar GaussSigma1("GaussSigma1", "GaussSigma1", 0.01, 1.e-4, 1.0);
RooGaussian DstarGauss1("DstarGauss1", "DstarGauss1", deltaM, GaussMean, GaussSigma1);
RooRealVar GaussSigma2("GaussSigma2", "GaussSigma2", 0.001, 1.e-4, 1.0);
RooGaussian DstarGauss2("DstarGauss2", "DstarGauss2", deltaM, GaussMean, GaussSigma2);
RooRealVar fracGaussYield("fracGaussYield", "Fraction of two Gaussians", 0.75, 0.0, 1.0);
RooAddPdf DstarSignalPDF("DstarSignalPDF", "DstarGauss1+DstarGauss2", RooArgList(DstarGauss1, DstarGauss2), fracGaussYield);

RooRealVar dm0Bkg("dm0Bkg", "dm0", 0.13957018, 0.130, 0.140);
RooRealVar aBkg("aBkg", "a", -0.0784, -0.08, 3.0);
RooRealVar bBkg("bBkg", "b", -0.444713, -0.5, 0.4);
RooRealVar cBkg("cBkg", "c", 0.3);
RooDstD0BG DstarBkgPDF("DstarBkgPDF", "DstarBkgPDF", deltaM, dm0Bkg, cBkg, aBkg, bBkg);
RooRealVar nSignalDstar("nSignalDstar", "signal yield", 0.5 * preselTree->GetEntries(), 0, preselTree->GetEntries());
RooRealVar nBkgDstar("nBkgDstar", "background yield", 0.5 * preselTree->GetEntries(), 0, preselTree->GetEntries());
RooAddPdf totalPDFDstar("totalPDFDstar", "totalPDFDstar pdf", RooArgList(DstarSignalPDF, DstarBkgPDF),
                        RooArgList(nSignalDstar, nBkgDstar));

B2INFO("Dstar: Start fitting...")do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Info, 0, "svd")) { { LogVariableStream varStream
; varStream << "Dstar: Start fitting..."; Belle2::LogSystem
::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig
::c_Info, std::move(varStream), "svd", __PRETTY_FUNCTION__, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc"
, 1178, 0)); }; } } while(false);
RooFitResult* DstarFitResult = totalPDFDstar.fitTo(*DstarDataset, Save(kTRUE), PrintLevel(-1));

int status = DstarFitResult->status();
int covqual = DstarFitResult->covQual();
double diff = nSignalDstar.getValV() + nBkgDstar.getValV() - DstarDataset->sumEntries();

B2INFO("Dstar: Fit status: " << status << "; covariance quality: " << covqual)do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Info, 0, "svd")) { { LogVariableStream varStream
; varStream << "Dstar: Fit status: " << status <<
 "; covariance quality: " << covqual; Belle2::LogSystem
::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig
::c_Info, std::move(varStream), "svd", __PRETTY_FUNCTION__, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc"
, 1185, 0)); }; } } while(false);
// if the fit is not healthy, try again once before giving up, with a slightly different setup:
if ((status > 0) || (TMath::Abs(diff) > 1.) || (nSignalDstar.getError() < sqrt(nSignalDstar.getValV()))
    || (nSignalDstar.getError() > (nSignalDstar.getValV()))) {

  DstarFitResult = totalPDFDstar.fitTo(*DstarDataset, Save(), Strategy(2), Offset(1));
  status = DstarFitResult->status();
  covqual = DstarFitResult->covQual();
  diff = nSignalDstar.getValV() + nBkgDstar.getValV() - DstarDataset->sumEntries();
}

if ((status > 0) || (TMath::Abs(diff) > 1.) || (nSignalDstar.getError() < sqrt(nSignalDstar.getValV()))
    || (nSignalDstar.getError() > (nSignalDstar.getValV()))) {
  B2WARNING("Dstar: Fit problem: fit status " << status << "; sum of component yields minus the dataset yield is " << diff <<do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Warning, 0, "svd")) { { LogVariableStream varStream
; varStream << "Dstar: Fit problem: fit status " <<
 status << "; sum of component yields minus the dataset yield is "
 << diff << "; signal yield is " << nSignalDstar
.getValV() << ", while its uncertainty is " << nSignalDstar
.getError(); Belle2::LogSystem::Instance().sendMessage(Belle2
::LogMessage(Belle2::LogConfig::c_Warning, std::move(varStream
), "svd", __PRETTY_FUNCTION__, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc"
, 1199, 0)); }; } } while(false)
            "; signal yield is " << nSignalDstar.getValV() << ", while its uncertainty is " << nSignalDstar.getError())do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Warning, 0, "svd")) { { LogVariableStream varStream
; varStream << "Dstar: Fit problem: fit status " <<
 status << "; sum of component yields minus the dataset yield is "
 << diff << "; signal yield is " << nSignalDstar
.getValV() << ", while its uncertainty is " << nSignalDstar
.getError(); Belle2::LogSystem::Instance().sendMessage(Belle2
::LogMessage(Belle2::LogConfig::c_Warning, std::move(varStream
), "svd", __PRETTY_FUNCTION__, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc"
, 1199, 0)); }; } } while(false);
}
if (covqual < 2) {
  B2INFO("Dstar: Fit warning: covariance quality " << covqual)do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Info, 0, "svd")) { { LogVariableStream varStream
; varStream << "Dstar: Fit warning: covariance quality "
 << covqual; Belle2::LogSystem::Instance().sendMessage(
Belle2::LogMessage(Belle2::LogConfig::c_Info, std::move(varStream
), "svd", __PRETTY_FUNCTION__, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc"
, 1202, 0)); }; } } while(false);
}

totalPDFDstar.plotOn(DstarFitFrame, LineColor(TColor::GetColor("#4575b4")));

double chisquare = DstarFitFrame->chiSquare();
B2INFO("Dstar: Fit chi2 = " << chisquare)do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Info, 0, "svd")) { { LogVariableStream varStream
; varStream << "Dstar: Fit chi2 = " << chisquare;
 Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage
(Belle2::LogConfig::c_Info, std::move(varStream), "svd", __PRETTY_FUNCTION__
, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc", 1208, 0
)); }; } } while(false);
totalPDFDstar.paramOn(DstarFitFrame, Layout(0.63, 0.96, 0.93), Format("NEU", AutoPrecision(2)));
DstarFitFrame->getAttText()->SetTextSize(0.03);

totalPDFDstar.plotOn(DstarFitFrame, Components("DstarSignalPDF"), LineColor(TColor::GetColor("#d73027")));
totalPDFDstar.plotOn(DstarFitFrame, Components("DstarBkgPDF"), LineColor(TColor::GetColor("#fc8d59")));
totalPDFDstar.plotOn(DstarFitFrame, LineColor(TColor::GetColor("#4575b4")));

DstarFitFrame->GetXaxis()->SetTitle("#Deltam [GeV/c^{2}]");
TCanvas* canvDstar = new TCanvas("canvDstar", "canvDstar");
canvDstar->cd();

DstarFitFrame->Draw();

if (m_isMakePlots) {
  canvDstar->Print("SVDdEdxValidationFitDstar.pdf");
  TFile DstarFitPlotFile("SVDdEdxValidationDstarFitPlotFile.root", "RECREATE");
  canvDstar->Write();
  DstarFitPlotFile.Close();
}

/////////////////// SPlot ///////////////////////////////////////////////////////////

RooStats::SPlot* sPlotDatasetDstar = new RooStats::SPlot("sData", "An SPlot", *DstarDataset, &totalPDFDstar,
                                                         RooArgList(nSignalDstar, nBkgDstar));

for (int iEvt = 0; iEvt < 5; iEvt++) {
  if (TMath::Abs(sPlotDatasetDstar->GetSWeight(iEvt, "nSignalDstar") + sPlotDatasetDstar->GetSWeight(iEvt, "nBkgDstar") - 1) > 5.e-3)
    B2FATAL("Dstar: sPlot error: sum of weights not equal to 1")do { { LogVariableStream varStream; varStream << "Dstar: sPlot error: sum of weights not equal to 1"
; Belle2::LogSystem::Instance().sendMessage(Belle2::LogMessage
(Belle2::LogConfig::c_Fatal, std::move(varStream), "svd", __PRETTY_FUNCTION__
, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc", 1236, 0
)); }; exit(1); } while(false);
}

TTree* treeDstar_sw = DstarDataset->GetClonedTree();
treeDstar_sw->SetName("treeDstar_sw");

B2INFO("Dstar: sPlot done. ")do { if (Belle2::LogSystem::Instance().isLevelEnabled(Belle2::
LogConfig::c_Info, 0, "svd")) { { LogVariableStream varStream
; varStream << "Dstar: sPlot done. "; Belle2::LogSystem
::Instance().sendMessage(Belle2::LogMessage(Belle2::LogConfig
::c_Info, std::move(varStream), "svd", __PRETTY_FUNCTION__, "svd/calibration/src/SVDdEdxValidationAlgorithm.cc"
, 1242, 0)); }; } } while(false);

return treeDstar_sw;
1245}

←

/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RDF/RInterface.hxx

→

1// Author: Enrico Guiraud, Danilo Piparo CERN  03/2017

3/*************************************************************************
* Copyright (C) 1995-2021, Rene Brun and Fons Rademakers.               *
* All rights reserved.                                                  *
*                                                                       *
* For the licensing terms see $ROOTSYS/LICENSE.                         *
* For the list of contributors see $ROOTSYS/README/CREDITS.             *
*************************************************************************/

11#ifndef ROOT_RDF_TINTERFACE
12#define ROOT_RDF_TINTERFACE

14#include "ROOT/RDataSource.hxx"
15#include "ROOT/RDF/ActionHelpers.hxx"
16#include "ROOT/RDF/HistoModels.hxx"
17#include "ROOT/RDF/InterfaceUtils.hxx"
18#include "ROOT/RDF/RColumnRegister.hxx"
19#include "ROOT/RDF/RDefaultValueFor.hxx"
20#include "ROOT/RDF/RDefine.hxx"
21#include "ROOT/RDF/RDefinePerSample.hxx"
22#include "ROOT/RDF/RFilter.hxx"
23#include "ROOT/RDF/RInterfaceBase.hxx"
24#include "ROOT/RDF/RVariation.hxx"
25#include "ROOT/RDF/RLazyDSImpl.hxx"
26#include "ROOT/RDF/RLoopManager.hxx"
27#include "ROOT/RDF/RRange.hxx"
28#include "ROOT/RDF/RFilterWithMissingValues.hxx"
29#include "ROOT/RDF/Utils.hxx"
30#include "ROOT/RDF/RDFDescription.hxx"
31#include "ROOT/RDF/RVariationsDescription.hxx"
32#include "ROOT/RResultPtr.hxx"
33#include "ROOT/RSnapshotOptions.hxx"
34#include <string_view>
35#include "ROOT/RVec.hxx"
36#include "ROOT/TypeTraits.hxx"
37#include "RtypesCore.h" // for ULong64_t
38#include "TDirectory.h"
39#include "TH1.h" // For Histo actions
40#include "TH2.h" // For Histo actions
41#include "TH3.h" // For Histo actions
42#include "THn.h"
43#include "TProfile.h"
44#include "TProfile2D.h"
45#include "TStatistic.h"

47#include <algorithm>
48#include <cstddef>
49#include <initializer_list>
50#include <iterator> // std::back_insterter
51#include <limits>
52#include <memory>
53#include <set>
54#include <sstream>
55#include <stdexcept>
56#include <string>
57#include <type_traits> // is_same, enable_if
58#include <typeinfo>
59#include <unordered_set>
60#include <utility> // std::index_sequence
61#include <vector>
62#include <any>

64class TGraph;

66// Windows requires a forward decl of printValue to accept it as a valid friend function in RInterface
67namespace ROOT {
68void DisableImplicitMT();
69bool IsImplicitMTEnabled();
70void EnableImplicitMT(UInt_t numthreads);
71class RDataFrame;
72} // namespace ROOT
73namespace cling {
74std::string printValue(ROOT::RDataFrame *tdf);
75}

77namespace ROOT {
78namespace RDF {
79namespace RDFDetail = ROOT::Detail::RDF;
80namespace RDFInternal = ROOT::Internal::RDF;
81namespace TTraits = ROOT::TypeTraits;

83template <typename Proxied, typename DataSource>
84class RInterface;

86using RNode = RInterface<::ROOT::Detail::RDF::RNodeBase, void>;
87} // namespace RDF

89namespace Internal {
90namespace RDF {
91class GraphCreatorHelper;
92void ChangeEmptyEntryRange(const ROOT::RDF::RNode &node, std::pair<ULong64_t, ULong64_t> &&newRange);
93void ChangeBeginAndEndEntries(const RNode &node, Long64_t begin, Long64_t end);
94void ChangeSpec(const ROOT::RDF::RNode &node, ROOT::RDF::Experimental::RDatasetSpec &&spec);
95void TriggerRun(ROOT::RDF::RNode node);
96std::string GetDataSourceLabel(const ROOT::RDF::RNode &node);
97void SetTTreeLifeline(ROOT::RDF::RNode &node, std::any lifeline);
98} // namespace RDF
99} // namespace Internal

101namespace RDF {

103// clang-format off
104/**
* \class ROOT::RDF::RInterface
* \ingroup dataframe
* \brief The public interface to the RDataFrame federation of classes.
* \tparam Proxied One of the "node" base types (e.g. RLoopManager, RFilterBase). The user never specifies this type manually.
* \tparam DataSource The type of the RDataSource which is providing the data to the data frame. There is no source by default.
*
* The documentation of each method features a one liner illustrating how to use the method, for example showing how
* the majority of the template parameters are automatically deduced requiring no or very little effort by the user.
*/
114// clang-format on
115template <typename Proxied, typename DataSource = void>
116class RInterface : public RInterfaceBase {
 using DS_t = DataSource;
 using RFilterBase = RDFDetail::RFilterBase;
 using RRangeBase = RDFDetail::RRangeBase;
 using RLoopManager = RDFDetail::RLoopManager;
 friend std::string cling::printValue(::ROOT::RDataFrame *tdf); // For a nice printing at the prompt
 friend class RDFInternal::GraphDrawing::GraphCreatorHelper;

 template <typename T, typename W>
 friend class RInterface;

 friend void RDFInternal::TriggerRun(RNode node);
 friend void RDFInternal::ChangeEmptyEntryRange(const RNode &node, std::pair<ULong64_t, ULong64_t> &&newRange);
 friend void RDFInternal::ChangeBeginAndEndEntries(const RNode &node, Long64_t start, Long64_t end);
 friend void RDFInternal::ChangeSpec(const RNode &node, ROOT::RDF::Experimental::RDatasetSpec &&spec);
 friend std::string ROOT::Internal::RDF::GetDataSourceLabel(const RNode &node);
 friend void ROOT::Internal::RDF::SetTTreeLifeline(ROOT::RDF::RNode &node, std::any lifeline);
 std::shared_ptr<Proxied> fProxiedPtr; ///< Smart pointer to the graph node encapsulated by this RInterface.

135public:
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Copy-assignment operator for RInterface.
 RInterface &operator=(const RInterface &) = default;

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Copy-ctor for RInterface.
 RInterface(const RInterface &) = default;

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Move-ctor for RInterface.
 RInterface(RInterface &&) = default;

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Move-assignment operator for RInterface.
 RInterface &operator=(RInterface &&) = default;

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Build a RInterface from a RLoopManager.
 /// This constructor is only available for RInterface<RLoopManager>.
 template <typename T = Proxied, typename = std::enable_if_t<std::is_same<T, RLoopManager>::value, int>>
 RInterface(const std::shared_ptr<RLoopManager> &proxied) : RInterfaceBase(proxied), fProxiedPtr(proxied)
 {
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Cast any RDataFrame node to a common type ROOT::RDF::RNode.
 /// Different RDataFrame methods return different C++ types. All nodes, however,
 /// can be cast to this common type at the cost of a small performance penalty.
 /// This allows, for example, storing RDataFrame nodes in a vector, or passing them
 /// around via (non-template, C++11) helper functions.
 /// Example usage:
 /// ~~~{.cpp}
 /// // a function that conditionally adds a Range to a RDataFrame node.
 /// RNode MaybeAddRange(RNode df, bool mustAddRange)
 /// {
 ///    return mustAddRange ? df.Range(1) : df;
 /// }
 /// // use as :
 /// ROOT::RDataFrame df(10);
 /// auto maybeRanged = MaybeAddRange(df, true);
 /// ~~~
 /// Note that it is not a problem to pass RNode's by value.
 operator RNode() const
 {
    return RNode(std::static_pointer_cast<::ROOT::Detail::RDF::RNodeBase>(fProxiedPtr), *fLoopManager, fColRegister);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Append a filter to the call graph.
 /// \param[in] f Function, lambda expression, functor class or any other callable object. It must return a `bool`
 /// signalling whether the event has passed the selection (true) or not (false).
 /// \param[in] columns Names of the columns/branches in input to the filter function.
 /// \param[in] name Optional name of this filter. See `Report`.
 /// \return the filter node of the computation graph.
 ///
 /// Append a filter node at the point of the call graph corresponding to the
 /// object this method is called on.
 /// The callable `f` should not have side-effects (e.g. modification of an
 /// external or static variable) to ensure correct results when implicit
 /// multi-threading is active.
 ///
 /// RDataFrame only evaluates filters when necessary: if multiple filters
 /// are chained one after another, they are executed in order and the first
 /// one returning false causes the event to be discarded.
 /// Even if multiple actions or transformations depend on the same filter,
 /// it is executed once per entry. If its result is requested more than
 /// once, the cached result is served.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // C++ callable (function, functor class, lambda...) that takes two parameters of the types of "x" and "y"
 /// auto filtered = df.Filter(myCut, {"x", "y"});
 ///
 /// // String: it must contain valid C++ except that column names can be used instead of variable names
 /// auto filtered = df.Filter("x*y > 0");
 /// ~~~
 ///
 /// \note If the body of the string expression contains an explicit `return` statement (even if it is in a nested
 /// scope), RDataFrame _will not_ add another one in front of the expression. So this will not work:
 /// ~~~{.cpp}
 /// df.Filter("Sum(Map(vec, [](float e) { return e*e > 0.5; }))")
 /// ~~~
 /// but instead this will:
 /// ~~~{.cpp}
 /// df.Filter("return Sum(Map(vec, [](float e) { return e*e > 0.5; }))")
 /// ~~~
 template <typename F, std::enable_if_t<!std::is_convertible<F, std::string>::value, int> = 0>
 RInterface<RDFDetail::RFilter<F, Proxied>, DS_t>
 Filter(F f, const ColumnNames_t &columns = {}, std::string_view name = "")
 {
    RDFInternal::CheckFilter(f);
    using ColTypes_t = typename TTraits::CallableTraits<F>::arg_types;
    constexpr auto nColumns = ColTypes_t::list_size;
    const auto validColumnNames = GetValidatedColumnNames(nColumns, columns);
    CheckAndFillDSColumns(validColumnNames, ColTypes_t());

    using F_t = RDFDetail::RFilter<F, Proxied>;

    auto filterPtr = std::make_shared<F_t>(std::move(f), validColumnNames, fProxiedPtr, fColRegister, name);
    return RInterface<F_t, DS_t>(std::move(filterPtr), *fLoopManager, fColRegister);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Append a filter to the call graph.
 /// \param[in] f Function, lambda expression, functor class or any other callable object. It must return a `bool`
 /// signalling whether the event has passed the selection (true) or not (false).
 /// \param[in] name Optional name of this filter. See `Report`.
 /// \return the filter node of the computation graph.
 ///
 /// Refer to the first overload of this method for the full documentation.
 template <typename F, std::enable_if_t<!std::is_convertible<F, std::string>::value, int> = 0>
 RInterface<RDFDetail::RFilter<F, Proxied>, DS_t> Filter(F f, std::string_view name)
 {
    // The sfinae is there in order to pick up the overloaded method which accepts two strings
    // rather than this template method.
    return Filter(f, {}, name);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Append a filter to the call graph.
 /// \param[in] f Function, lambda expression, functor class or any other callable object. It must return a `bool`
 /// signalling whether the event has passed the selection (true) or not (false).
 /// \param[in] columns Names of the columns/branches in input to the filter function.
 /// \return the filter node of the computation graph.
 ///
 /// Refer to the first overload of this method for the full documentation.
 template <typename F>
 RInterface<RDFDetail::RFilter<F, Proxied>, DS_t> Filter(F f, const std::initializer_list<std::string> &columns)
 {
    return Filter(f, ColumnNames_t{columns});
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Append a filter to the call graph.
 /// \param[in] expression The filter expression in C++
 /// \param[in] name Optional name of this filter. See `Report`.
 /// \return the filter node of the computation graph.
 ///
 /// The expression is just-in-time compiled and used to filter entries. It must
 /// be valid C++ syntax in which variable names are substituted with the names
 /// of branches/columns.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// auto filtered_df = df.Filter("myCollection.size() > 3");
 /// auto filtered_name_df = df.Filter("myCollection.size() > 3", "Minumum collection size");
 /// ~~~
 ///
 /// \note If the body of the string expression contains an explicit `return` statement (even if it is in a nested
 /// scope), RDataFrame _will not_ add another one in front of the expression. So this will not work:
 /// ~~~{.cpp}
 /// df.Filter("Sum(Map(vec, [](float e) { return e*e > 0.5; }))")
 /// ~~~
 /// but instead this will:
 /// ~~~{.cpp}
 /// df.Filter("return Sum(Map(vec, [](float e) { return e*e > 0.5; }))")
 /// ~~~
 RInterface<RDFDetail::RJittedFilter, DS_t> Filter(std::string_view expression, std::string_view name = "")
 {
    // deleted by the jitted call to JitFilterHelper
    auto upcastNodeOnHeap = RDFInternal::MakeSharedOnHeap(RDFInternal::UpcastNode(fProxiedPtr));
9
←
Calling 'MakeSharedOnHeap<ROOT::Detail::RDF::RNodeBase>'→
11
←
Returned allocated memory→
    using BaseNodeType_t = typename std::remove_pointer_t<decltype(upcastNodeOnHeap)>::element_type;
    RInterface<BaseNodeType_t> upcastInterface(*upcastNodeOnHeap, *fLoopManager, fColRegister);
    const auto jittedFilter =
12
←
Potential leak of memory pointed to by 'upcastNodeOnHeap'
       RDFInternal::BookFilterJit(upcastNodeOnHeap, name, expression, fLoopManager->GetBranchNames(), fColRegister,
                                  fLoopManager->GetTree(), GetDataSource());

    return RInterface<RDFDetail::RJittedFilter, DS_t>(std::move(jittedFilter), *fLoopManager, fColRegister);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Discard entries with missing values
 /// \param[in] column Column name whose entries with missing values should be discarded
 /// \return The filter node of the computation graph
 ///
 /// This operation is useful in case an entry of the dataset is incomplete,
 /// i.e. if one or more of the columns do not have valid values. If the value
 /// of the input column is missing for an entry, the entire entry will be
 /// discarded from the rest of this branch of the computation graph.
 ///
 /// Use cases include:
 /// * When processing multiple files, one or more of them is missing a column
 /// * In horizontal joining with entry matching, a certain dataset has no
 ///   match for the current entry.
 ///
 /// ### Example usage:
 ///
 /// \code{.py}
 /// # Assume a dataset with columns [idx, x] matching another dataset with
 /// # columns [idx, y]. For idx == 42, the right-hand dataset has no match
 /// df = ROOT.RDataFrame(dataset)
 /// df_nomissing = df.FilterAvailable("idx").Define("z", "x + y")
 /// colz = df_nomissing.Take[int]("z")
 /// \endcode
 ///
 /// \code{.cpp}
 /// // Assume a dataset with columns [idx, x] matching another dataset with
 /// // columns [idx, y]. For idx == 42, the right-hand dataset has no match
 /// ROOT::RDataFrame df{dataset};
 /// auto df_nomissing = df.FilterAvailable("idx")
 ///                       .Define("z", [](int x, int y) { return x + y; }, {"x", "y"});
 /// auto colz = df_nomissing.Take<int>("z");
 /// \endcode
 ///
 /// \note See FilterMissing() if you want to keep only the entries with
 ///       missing values instead.
 RInterface<RDFDetail::RFilterWithMissingValues<Proxied>, DS_t> FilterAvailable(std::string_view column)
 {
    const auto columns = ColumnNames_t{column.data()};
    // For now disable this functionality in case of an empty data source and
    // the column name was not defined previously.
    if (ROOT::Internal::RDF::GetDataSourceLabel(*this) == "EmptyDS")
       throw std::runtime_error("Unknown column: \"" + std::string(column) + "\"");
    using F_t = RDFDetail::RFilterWithMissingValues<Proxied>;
    auto filterPtr = std::make_shared<F_t>(/*discardEntry*/ true, fProxiedPtr, fColRegister, columns);
    CheckAndFillDSColumns(columns, TTraits::TypeList<void>{});
    return RInterface<F_t, DS_t>(std::move(filterPtr), *fLoopManager, fColRegister);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Keep only the entries that have missing values.
 /// \param[in] column Column name whose entries with missing values should be kept
 /// \return The filter node of the computation graph
 ///
 /// This operation is useful in case an entry of the dataset is incomplete,
 /// i.e. if one or more of the columns do not have valid values. It only
 /// keeps the entries for which the value of the input column is missing.
 ///
 /// Use cases include:
 /// * When processing multiple files, one or more of them is missing a column
 /// * In horizontal joining with entry matching, a certain dataset has no
 ///   match for the current entry.
 ///
 /// ### Example usage:
 ///
 /// \code{.py}
 /// # Assume a dataset made of two files vertically chained together, one has
 /// # column "x" and the other has column "y"
 /// df = ROOT.RDataFrame(dataset)
 /// df_valid_col_x = df.FilterMissing("y")
 /// df_valid_col_y = df.FilterMissing("x")
 /// display_x = df_valid_col_x.Display(("x",))
 /// display_y = df_valid_col_y.Display(("y",))
 /// \endcode
 ///
 /// \code{.cpp}
 /// // Assume a dataset made of two files vertically chained together, one has
 /// // column "x" and the other has column "y"
 /// ROOT.RDataFrame df{dataset};
 /// auto df_valid_col_x = df.FilterMissing("y");
 /// auto df_valid_col_y = df.FilterMissing("x");
 /// auto display_x = df_valid_col_x.Display<int>({"x"});
 /// auto display_y = df_valid_col_y.Display<int>({"y"});
 /// \endcode
 ///
 /// \note See FilterAvailable() if you want to discard the entries in case
 ///       there is a missing value instead.
 RInterface<RDFDetail::RFilterWithMissingValues<Proxied>, DS_t> FilterMissing(std::string_view column)
 {
    const auto columns = ColumnNames_t{column.data()};
    // For now disable this functionality in case of an empty data source and
    // the column name was not defined previously.
    if (ROOT::Internal::RDF::GetDataSourceLabel(*this) == "EmptyDS")
       throw std::runtime_error("Unknown column: \"" + std::string(column) + "\"");
    using F_t = RDFDetail::RFilterWithMissingValues<Proxied>;
    auto filterPtr = std::make_shared<F_t>(/*discardEntry*/ false, fProxiedPtr, fColRegister, columns);
    CheckAndFillDSColumns(columns, TTraits::TypeList<void>{});
    return RInterface<F_t, DS_t>(std::move(filterPtr), *fLoopManager, fColRegister);
 }

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Define a new column.
 /// \param[in] name The name of the defined column.
 /// \param[in] expression Function, lambda expression, functor class or any other callable object producing the defined value. Returns the value that will be assigned to the defined column.
 /// \param[in] columns Names of the columns/branches in input to the producer function.
 /// \return the first node of the computation graph for which the new quantity is defined.
 ///
 /// Define a column that will be visible from all subsequent nodes
 /// of the functional chain. The `expression` is only evaluated for entries that pass
 /// all the preceding filters.
 /// A new variable is created called `name`, accessible as if it was contained
 /// in the dataset from subsequent transformations/actions.
 ///
 /// Use cases include:
 /// * caching the results of complex calculations for easy and efficient multiple access
 /// * extraction of quantities of interest from complex objects
 ///
 /// An exception is thrown if the name of the new column is already in use in this branch of the computation graph.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // assuming a function with signature:
 /// double myComplexCalculation(const RVec<float> &muon_pts);
 /// // we can pass it directly to Define
 /// auto df_with_define = df.Define("newColumn", myComplexCalculation, {"muon_pts"});
 /// // alternatively, we can pass the body of the function as a string, as in Filter:
 /// auto df_with_define = df.Define("newColumn", "x*x + y*y");
 /// ~~~
 ///
 /// \note If the body of the string expression contains an explicit `return` statement (even if it is in a nested
 /// scope), RDataFrame _will not_ add another one in front of the expression. So this will not work:
 /// ~~~{.cpp}
 /// df.Define("x2", "Map(v, [](float e) { return e*e; })")
 /// ~~~
 /// but instead this will:
 /// ~~~{.cpp}
 /// df.Define("x2", "return Map(v, [](float e) { return e*e; })")
 /// ~~~
 template <typename F, typename std::enable_if_t<!std::is_convertible<F, std::string>::value, int> = 0>
 RInterface<Proxied, DS_t> Define(std::string_view name, F expression, const ColumnNames_t &columns = {})
 {
    return DefineImpl<F, RDFDetail::ExtraArgsForDefine::None>(name, std::move(expression), columns, "Define");
 }
 // clang-format on

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Define a new column with a value dependent on the processing slot.
 /// \param[in] name The name of the defined column.
 /// \param[in] expression Function, lambda expression, functor class or any other callable object producing the defined value. Returns the value that will be assigned to the defined column.
 /// \param[in] columns Names of the columns/branches in input to the producer function (excluding the slot number).
 /// \return the first node of the computation graph for which the new quantity is defined.
 ///
 /// This alternative implementation of `Define` is meant as a helper to evaluate new column values in a thread-safe manner.
 /// The expression must be a callable of signature R(unsigned int, T1, T2, ...) where `T1, T2...` are the types
 /// of the columns that the expression takes as input. The first parameter is reserved for an unsigned integer
 /// representing a "slot number". RDataFrame guarantees that different threads will invoke the expression with
 /// different slot numbers - slot numbers will range from zero to ROOT::GetThreadPoolSize()-1.
 /// Note that there is no guarantee as to how often each slot will be reached during the event loop.
 ///
 /// The following two calls are equivalent, although `DefineSlot` is slightly more performant:
 /// ~~~{.cpp}
 /// int function(unsigned int, double, double);
 /// df.Define("x", function, {"rdfslot_", "column1", "column2"})
 /// df.DefineSlot("x", function, {"column1", "column2"})
 /// ~~~
 ///
 /// See Define() for more information.
 template <typename F>
 RInterface<Proxied, DS_t> DefineSlot(std::string_view name, F expression, const ColumnNames_t &columns = {})
 {
    return DefineImpl<F, RDFDetail::ExtraArgsForDefine::Slot>(name, std::move(expression), columns, "DefineSlot");
 }
 // clang-format on

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Define a new column with a value dependent on the processing slot and the current entry.
 /// \param[in] name The name of the defined column.
 /// \param[in] expression Function, lambda expression, functor class or any other callable object producing the defined value. Returns the value that will be assigned to the defined column.
 /// \param[in] columns Names of the columns/branches in input to the producer function (excluding slot and entry).
 /// \return the first node of the computation graph for which the new quantity is defined.
 ///
 /// This alternative implementation of `Define` is meant as a helper in writing entry-specific, thread-safe custom
 /// columns. The expression must be a callable of signature R(unsigned int, ULong64_t, T1, T2, ...) where `T1, T2...`
 /// are the types of the columns that the expression takes as input. The first parameter is reserved for an unsigned
 /// integer representing a "slot number". RDataFrame guarantees that different threads will invoke the expression with
 /// different slot numbers - slot numbers will range from zero to ROOT::GetThreadPoolSize()-1.
 /// Note that there is no guarantee as to how often each slot will be reached during the event loop.
 /// The second parameter is reserved for a `ULong64_t` representing the current entry being processed by the current thread.
 ///
 /// The following two `Define`s are equivalent, although `DefineSlotEntry` is slightly more performant:
 /// ~~~{.cpp}
 /// int function(unsigned int, ULong64_t, double, double);
 /// Define("x", function, {"rdfslot_", "rdfentry_", "column1", "column2"})
 /// DefineSlotEntry("x", function, {"column1", "column2"})
 /// ~~~
 ///
 /// See Define() for more information.
 template <typename F>
 RInterface<Proxied, DS_t> DefineSlotEntry(std::string_view name, F expression, const ColumnNames_t &columns = {})
 {
    return DefineImpl<F, RDFDetail::ExtraArgsForDefine::SlotAndEntry>(name, std::move(expression), columns,
                                                                      "DefineSlotEntry");
 }
 // clang-format on

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Define a new column.
 /// \param[in] name The name of the defined column.
 /// \param[in] expression An expression in C++ which represents the defined value
 /// \return the first node of the computation graph for which the new quantity is defined.
 ///
 /// The expression is just-in-time compiled and used to produce the column entries.
 /// It must be valid C++ syntax in which variable names are substituted with the names
 /// of branches/columns.
 ///
 /// \note If the body of the string expression contains an explicit `return` statement (even if it is in a nested
 /// scope), RDataFrame _will not_ add another one in front of the expression. So this will not work:
 /// ~~~{.cpp}
 /// df.Define("x2", "Map(v, [](float e) { return e*e; })")
 /// ~~~
 /// but instead this will:
 /// ~~~{.cpp}
 /// df.Define("x2", "return Map(v, [](float e) { return e*e; })")
 /// ~~~
 ///
 /// Refer to the first overload of this method for the full documentation.
 RInterface<Proxied, DS_t> Define(std::string_view name, std::string_view expression)
 {
    constexpr auto where = "Define";
    RDFInternal::CheckValidCppVarName(name, where);
    // these checks must be done before jitting lest we throw exceptions in jitted code
    RDFInternal::CheckForRedefinition(where, name, fColRegister, fLoopManager->GetBranchNames(),
                                      GetDataSource() ? GetDataSource()->GetColumnNames() : ColumnNames_t{});

    auto upcastNodeOnHeap = RDFInternal::MakeSharedOnHeap(RDFInternal::UpcastNode(fProxiedPtr));
    auto jittedDefine = RDFInternal::BookDefineJit(name, expression, *fLoopManager, GetDataSource(), fColRegister,
                                                   fLoopManager->GetBranchNames(), upcastNodeOnHeap);

    RDFInternal::RColumnRegister newCols(fColRegister);
    newCols.AddDefine(std::move(jittedDefine));

    RInterface<Proxied, DS_t> newInterface(fProxiedPtr, *fLoopManager, std::move(newCols));

    return newInterface;
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Overwrite the value and/or type of an existing column.
 /// \param[in] name The name of the column to redefine.
 /// \param[in] expression Function, lambda expression, functor class or any other callable object producing the defined value. Returns the value that will be assigned to the defined column.
 /// \param[in] columns Names of the columns/branches in input to the expression.
 /// \return the first node of the computation graph for which the quantity is redefined.
 ///
 /// The old value of the column can be used as an input for the expression.
 ///
 /// An exception is thrown in case the column to redefine does not already exist.
 /// See Define() for more information.
 template <typename F, std::enable_if_t<!std::is_convertible<F, std::string>::value, int> = 0>
 RInterface<Proxied, DS_t> Redefine(std::string_view name, F expression, const ColumnNames_t &columns = {})
 {
    return DefineImpl<F, RDFDetail::ExtraArgsForDefine::None>(name, std::move(expression), columns, "Redefine");
 }

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Overwrite the value and/or type of an existing column.
 /// \param[in] name The name of the column to redefine.
 /// \param[in] expression Function, lambda expression, functor class or any other callable object producing the defined value. Returns the value that will be assigned to the defined column.
 /// \param[in] columns Names of the columns/branches in input to the producer function (excluding slot).
 /// \return the first node of the computation graph for which the new quantity is defined.
 ///
 /// The old value of the column can be used as an input for the expression.
 /// An exception is thrown in case the column to redefine does not already exist.
 ///
 /// See DefineSlot() for more information.
 // clang-format on
 template <typename F>
 RInterface<Proxied, DS_t> RedefineSlot(std::string_view name, F expression, const ColumnNames_t &columns = {})
 {
    return DefineImpl<F, RDFDetail::ExtraArgsForDefine::Slot>(name, std::move(expression), columns, "RedefineSlot");
 }

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Overwrite the value and/or type of an existing column.
 /// \param[in] name The name of the column to redefine.
 /// \param[in] expression Function, lambda expression, functor class or any other callable object producing the defined value. Returns the value that will be assigned to the defined column.
 /// \param[in] columns Names of the columns/branches in input to the producer function (excluding slot and entry).
 /// \return the first node of the computation graph for which the new quantity is defined.
 ///
 /// The old value of the column can be used as an input for the expression.
 /// An exception is thrown in case the column to re-define does not already exist.
 ///
 /// See DefineSlotEntry() for more information.
 // clang-format on
 template <typename F>
 RInterface<Proxied, DS_t> RedefineSlotEntry(std::string_view name, F expression, const ColumnNames_t &columns = {})
 {
    return DefineImpl<F, RDFDetail::ExtraArgsForDefine::SlotAndEntry>(name, std::move(expression), columns,
                                                                      "RedefineSlotEntry");
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Overwrite the value and/or type of an existing column.
 /// \param[in] name The name of the column to redefine.
 /// \param[in] expression An expression in C++ which represents the defined value
 /// \return the first node of the computation graph for which the new quantity is defined.
 ///
 /// The expression is just-in-time compiled and used to produce the column entries.
 /// It must be valid C++ syntax in which variable names are substituted with the names
 /// of branches/columns.
 ///
 /// The old value of the column can be used as an input for the expression.
 /// An exception is thrown in case the column to re-define does not already exist.
 ///
 /// Aliases cannot be overridden. See the corresponding Define() overload for more information.
 RInterface<Proxied, DS_t> Redefine(std::string_view name, std::string_view expression)
 {
    constexpr auto where = "Redefine";
    RDFInternal::CheckValidCppVarName(name, where);
    RDFInternal::CheckForDefinition(where, name, fColRegister, fLoopManager->GetBranchNames(),
                                    GetDataSource() ? GetDataSource()->GetColumnNames() : ColumnNames_t{});
    RDFInternal::CheckForNoVariations(where, name, fColRegister);

    auto upcastNodeOnHeap = RDFInternal::MakeSharedOnHeap(RDFInternal::UpcastNode(fProxiedPtr));
    auto jittedDefine = RDFInternal::BookDefineJit(name, expression, *fLoopManager, GetDataSource(), fColRegister,
                                                   fLoopManager->GetBranchNames(), upcastNodeOnHeap);

    RDFInternal::RColumnRegister newCols(fColRegister);
    newCols.AddDefine(std::move(jittedDefine));

    RInterface<Proxied, DS_t> newInterface(fProxiedPtr, *fLoopManager, std::move(newCols));

    return newInterface;
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief In case the value in the given column is missing, provide a default value
 /// \tparam T The type of the column
 /// \param[in] column Column name where missing values should be replaced by the given default value
 /// \param[in] defaultValue Value to provide instead of a missing value
 /// \return The node of the graph that will provide a default value
 ///
 /// This operation is useful in case an entry of the dataset is incomplete,
 /// i.e. if one or more of the columns do not have valid values. It does not
 /// modify the values of the column, but in case any entry is missing, it
 /// will provide the default value to downstream nodes instead.
 ///
 /// Use cases include:
 /// * When processing multiple files, one or more of them is missing a column
 /// * In horizontal joining with entry matching, a certain dataset has no
 ///   match for the current entry.
 ///
 /// ### Example usage:
 ///
 /// \code{.cpp}
 /// // Assume a dataset with columns [idx, x] matching another dataset with
 /// // columns [idx, y]. For idx == 42, the right-hand dataset has no match
 /// ROOT::RDataFrame df{dataset};
 /// auto df_default = df.DefaultValueFor("y", 33)
 ///                     .Define("z", [](int x, int y) { return x + y; }, {"x", "y"});
 /// auto colz = df_default.Take<int>("z");
 /// \endcode
 ///
 /// \code{.py}
 /// df = ROOT.RDataFrame(dataset)
 /// df_default = df.DefaultValueFor("y", 33).Define("z", "x + y")
 /// colz = df_default.Take[int]("z")
 /// \endcode
 template <typename T>
 RInterface<Proxied, DS_t> DefaultValueFor(std::string_view column, const T &defaultValue)
 {
    constexpr auto where{"DefaultValueFor"};
    RDFInternal::CheckForNoVariations(where, column, fColRegister);
    // For now disable this functionality in case of an empty data source and
    // the column name was not defined previously.
    if (ROOT::Internal::RDF::GetDataSourceLabel(*this) == "EmptyDS")
       RDFInternal::CheckForDefinition(where, column, fColRegister, fLoopManager->GetBranchNames(),
                                       GetDataSource() ? GetDataSource()->GetColumnNames() : ColumnNames_t{});

    // Declare return type to the interpreter, for future use by jitted actions
    auto retTypeName = RDFInternal::TypeID2TypeName(typeid(T));
    if (retTypeName.empty()) {
       // The type is not known to the interpreter.
       // We must not error out here, but if/when this column is used in jitted code
       const auto demangledType = RDFInternal::DemangleTypeIdName(typeid(T));
       retTypeName = "CLING_UNKNOWN_TYPE_" + demangledType;
    }

    const auto validColumnNames = ColumnNames_t{column.data()};
    auto newColumn = std::make_shared<ROOT::Internal::RDF::RDefaultValueFor<T>>(
       column, retTypeName, defaultValue, validColumnNames, fColRegister, *fLoopManager);
    CheckAndFillDSColumns(validColumnNames, TTraits::TypeList<T>{});

    RDFInternal::RColumnRegister newCols(fColRegister);
    newCols.AddDefine(std::move(newColumn));

    RInterface<Proxied> newInterface(fProxiedPtr, *fLoopManager, std::move(newCols));

    return newInterface;
 }

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Define a new column that is updated when the input sample changes.
 /// \param[in] name The name of the defined column.
 /// \param[in] expression A C++ callable that computes the new value of the defined column.
 /// \return the first node of the computation graph for which the new quantity is defined.
 ///
 /// The signature of the callable passed as second argument should be `T(unsigned int slot, const ROOT::RDF::RSampleInfo &id)`
 /// where:
 /// - `T` is the type of the defined column
 /// - `slot` is a number in the range [0, nThreads) that is different for each processing thread. This can simplify
 ///   the definition of thread-safe callables if you are interested in using parallel capabilities of RDataFrame.
 /// - `id` is an instance of a ROOT::RDF::RSampleInfo object which contains information about the sample which is
 ///   being processed (see the class docs for more information).
 ///
 /// DefinePerSample() is useful to e.g. define a quantity that depends on which TTree in which TFile is being
 /// processed or to inject a callback into the event loop that is only called when the processing of a new sample
 /// starts rather than at every entry.
 ///
 /// The callable will be invoked once per input TTree or once per multi-thread task, whichever is more often.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// ROOT::RDataFrame df{"mytree", {"sample1.root","sample2.root"}};
 /// df.DefinePerSample("weightbysample",
 ///                    [](unsigned int slot, const ROOT::RDF::RSampleInfo &id)
 ///                    { return id.Contains("sample1") ? 1.0f : 2.0f; });
 /// ~~~
 // clang-format on
 // TODO we could SFINAE on F's signature to provide friendlier compilation errors in case of signature mismatch
 template <typename F, typename RetType_t = typename TTraits::CallableTraits<F>::ret_type>
 RInterface<Proxied, DS_t> DefinePerSample(std::string_view name, F expression)
 {
    RDFInternal::CheckValidCppVarName(name, "DefinePerSample");
    RDFInternal::CheckForRedefinition("DefinePerSample", name, fColRegister, fLoopManager->GetBranchNames(),
                                      GetDataSource() ? GetDataSource()->GetColumnNames() : ColumnNames_t{});

    auto retTypeName = RDFInternal::TypeID2TypeName(typeid(RetType_t));
    if (retTypeName.empty()) {
       // The type is not known to the interpreter.
       // We must not error out here, but if/when this column is used in jitted code
       const auto demangledType = RDFInternal::DemangleTypeIdName(typeid(RetType_t));
       retTypeName = "CLING_UNKNOWN_TYPE_" + demangledType;
    }

    auto newColumn =
       std::make_shared<RDFDetail::RDefinePerSample<F>>(name, retTypeName, std::move(expression), *fLoopManager);

    RDFInternal::RColumnRegister newCols(fColRegister);
    newCols.AddDefine(std::move(newColumn));
    RInterface<Proxied> newInterface(fProxiedPtr, *fLoopManager, std::move(newCols));
    return newInterface;
 }

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Define a new column that is updated when the input sample changes.
 /// \param[in] name The name of the defined column.
 /// \param[in] expression A valid C++ expression as a string, which will be used to compute the defined value.
 /// \return the first node of the computation graph for which the new quantity is defined.
 ///
 /// The expression is just-in-time compiled and used to produce the column entries.
 /// It must be valid C++ syntax and the usage of the special variable names `rdfslot_` and `rdfsampleinfo_` is
 /// permitted, where these variables will take the same values as the `slot` and `id` parameters described at the
 /// DefinePerSample(std::string_view name, F expression) overload. See the documentation of that overload for more information.
 ///
 /// ### Example usage:
 /// ~~~{.py}
 /// df = ROOT.RDataFrame('mytree', ['sample1.root','sample2.root'])
 /// df.DefinePerSample('weightbysample', 'rdfsampleinfo_.Contains("sample1") ? 1.0f : 2.0f')
 /// ~~~
 ///
 /// \note
 /// If you have declared some C++ function to the interpreter, the correct syntax to call that function with this
 /// overload of DefinePerSample is by calling it explicitly with the special names `rdfslot_` and `rdfsampleinfo_` as
 /// input parameters. This is for example the correct way to call this overload when working in PyROOT:
 /// ~~~{.py}
 /// ROOT.gInterpreter.Declare(
 /// """
 /// float weights(unsigned int slot, const ROOT::RDF::RSampleInfo &id){
 ///    return id.Contains("sample1") ? 1.0f : 2.0f;
 /// }
 /// """)
 /// df = ROOT.RDataFrame("mytree", ["sample1.root","sample2.root"])
 /// df.DefinePerSample("weightsbysample", "weights(rdfslot_, rdfsampleinfo_)")
 /// ~~~
 ///
 /// \note
 /// Differently from what happens in Define(), the string expression passed to DefinePerSample cannot contain
 /// column names other than those mentioned above: the expression is evaluated once before the processing of the
 /// sample even starts, so column values are not accessible.
 // clang-format on
 RInterface<Proxied, DS_t> DefinePerSample(std::string_view name, std::string_view expression)
 {
    RDFInternal::CheckValidCppVarName(name, "DefinePerSample");
    // these checks must be done before jitting lest we throw exceptions in jitted code
    RDFInternal::CheckForRedefinition("DefinePerSample", name, fColRegister, fLoopManager->GetBranchNames(),
                                      GetDataSource() ? GetDataSource()->GetColumnNames() : ColumnNames_t{});

    auto upcastNodeOnHeap = RDFInternal::MakeSharedOnHeap(RDFInternal::UpcastNode(fProxiedPtr));
    auto jittedDefine =
       RDFInternal::BookDefinePerSampleJit(name, expression, *fLoopManager, fColRegister, upcastNodeOnHeap);

    RDFInternal::RColumnRegister newCols(fColRegister);
    newCols.AddDefine(std::move(jittedDefine));

    RInterface<Proxied, DS_t> newInterface(fProxiedPtr, *fLoopManager, std::move(newCols));

    return newInterface;
 }

 /// \brief Register systematic variations for a single existing column using custom variation tags.
 /// \param[in] colName name of the column for which varied values are provided.
 /// \param[in] expression a callable that evaluates the varied values for the specified columns. The callable can
 ///            take any column values as input, similarly to what happens during Filter and Define calls. It must
 ///            return an RVec of varied values, one for each variation tag, in the same order as the tags.
 /// \param[in] inputColumns the names of the columns to be passed to the callable.
 /// \param[in] variationTags names for each of the varied values, e.g. `"up"` and `"down"`.
 /// \param[in] variationName a generic name for this set of varied values, e.g. `"ptvariation"`.
 ///
 /// Vary provides a natural and flexible syntax to define systematic variations that automatically propagate to
 /// Filters, Defines and results. RDataFrame usage of columns with attached variations does not change, but for
 /// results that depend on any varied quantity, a map/dictionary of varied results can be produced with
 /// ROOT::RDF::Experimental::VariationsFor (see the example below).
 ///
 /// The dictionary will contain a "nominal" value (accessed with the "nominal" key) for the unchanged result, and
 /// values for each of the systematic variations that affected the result (via upstream Filters or via direct or
 /// indirect dependencies of the column values on some registered variations). The keys will be a composition of
 /// variation names and tags, e.g. "pt:up" and "pt:down" for the example below.
 ///
 /// In the following example we add up/down variations of pt and fill a histogram with a quantity that depends on pt.
 /// We automatically obtain three histograms in output ("nominal", "pt:up" and "pt:down"):
 /// ~~~{.cpp}
 /// auto nominal_hx =
 ///     df.Vary("pt", [] (double pt) { return RVecD{pt*0.9, pt*1.1}; }, {"down", "up"})
 ///       .Filter("pt > k")
 ///       .Define("x", someFunc, {"pt"})
 ///       .Histo1D("x");
 ///
 /// auto hx = ROOT::RDF::Experimental::VariationsFor(nominal_hx);
 /// hx["nominal"].Draw();
 /// hx["pt:down"].Draw("SAME");
 /// hx["pt:up"].Draw("SAME");
 /// ~~~
 /// RDataFrame computes all variations as part of a single loop over the data.
 /// In particular, this means that I/O and computation of values shared
 /// among variations only happen once for all variations. Thus, the event loop
 /// run-time typically scales much better than linearly with the number of
 /// variations.
 ///
 /// RDataFrame lazily computes the varied values required to produce the
 /// outputs of \ref ROOT::RDF::Experimental::VariationsFor "VariationsFor()". If \ref
 /// ROOT::RDF::Experimental::VariationsFor "VariationsFor()" was not called for a result, the computations are only
 /// run for the nominal case.
 ///
 /// See other overloads for examples when variations are added for multiple existing columns,
 /// or when the tags are auto-generated instead of being directly defined.
 template <typename F>
 RInterface<Proxied, DS_t> Vary(std::string_view colName, F &&expression, const ColumnNames_t &inputColumns,
                                const std::vector<std::string> &variationTags, std::string_view variationName = "")
 {
    std::vector<std::string> colNames{{std::string(colName)}};
    const std::string theVariationName{variationName.empty() ? colName : variationName};

    return VaryImpl<true>(std::move(colNames), std::forward<F>(expression), inputColumns, variationTags,
                          theVariationName);
 }

 /// \brief Register systematic variations for a single existing column using auto-generated variation tags.
 /// \param[in] colName name of the column for which varied values are provided.
 /// \param[in] expression a callable that evaluates the varied values for the specified columns. The callable can
 ///            take any column values as input, similarly to what happens during Filter and Define calls. It must
 ///            return an RVec of varied values, one for each variation tag, in the same order as the tags.
 /// \param[in] inputColumns the names of the columns to be passed to the callable.
 /// \param[in] nVariations number of variations returned by the expression. The corresponding tags will be `"0"`,
 /// `"1"`, etc. 
 /// \param[in] variationName a generic name for this set of varied values, e.g. `"ptvariation"`.
 ///            colName is used if none is provided.
 ///
 /// This overload of Vary takes an nVariations parameter instead of a list of tag names.
 /// The varied results will be accessible via the keys of the dictionary with the form `variationName:N` where `N`
 /// is the corresponding sequential tag starting at 0 and going up to `nVariations - 1`.
 ///
 /// Example usage:
 /// ~~~{.cpp}
 /// auto nominal_hx =
 ///   df.Vary("pt", [] (double pt) { return RVecD{pt*0.9, pt*1.1}; }, 2)
 ///     .Histo1D("x");
 ///
 /// auto hx = ROOT::RDF::Experimental::VariationsFor(nominal_hx);
 /// hx["nominal"].Draw();
 /// hx["x:0"].Draw("SAME");
 /// hx["x:1"].Draw("SAME");
 /// ~~~
 ///
 /// \note See also This Vary() overload for more information.
 template <typename F>
 RInterface<Proxied, DS_t> Vary(std::string_view colName, F &&expression, const ColumnNames_t &inputColumns,
                                std::size_t nVariations, std::string_view variationName = "")
 {
    R__ASSERT(nVariations > 0 && "Must have at least one variation.")do { if (__builtin_expect(!!(!(nVariations > 0 && "Must have at least one variation."
)), 0)) ::Fatal("", kAssertMsg, "nVariations > 0 && \"Must have at least one variation.\""
, 911, "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RDF/RInterface.hxx"
); } while (false);

    std::vector<std::string> variationTags;
    variationTags.reserve(nVariations);
    for (std::size_t i = 0u; i < nVariations; ++i)
       variationTags.emplace_back(std::to_string(i));

    const std::string theVariationName{variationName.empty() ? colName : variationName};

    return Vary(colName, std::forward<F>(expression), inputColumns, std::move(variationTags), theVariationName);
 }

 /// \brief Register systematic variations for multiple existing columns using custom variation tags.
 /// \param[in] colNames set of names of the columns for which varied values are provided.
 /// \param[in] expression a callable that evaluates the varied values for the specified columns. The callable can
 ///            take any column values as input, similarly to what happens during Filter and Define calls. It must
 ///            return an RVec of varied values, one for each variation tag, in the same order as the tags.
 /// \param[in] inputColumns the names of the columns to be passed to the callable.
 /// \param[in] variationTags names for each of the varied values, e.g. `"up"` and `"down"`.
 /// \param[in] variationName a generic name for this set of varied values, e.g. `"ptvariation"`
 ///
 /// This overload of Vary takes a list of column names as first argument and
 /// requires that the expression returns an RVec of RVecs of values: one inner RVec for the variations of each
 /// affected column. The `variationTags` are defined as `{"down", "up"}`.
 ///
 /// Example usage:
 /// ~~~{.cpp}
 /// // produce variations "ptAndEta:down" and "ptAndEta:up"
 /// auto nominal_hx =
 ///   df.Vary({"pt", "eta"}, // the columns that will vary simultaneously
 ///         [](double pt, double eta) { return RVec<RVecF>{{pt*0.9, pt*1.1}, {eta*0.9, eta*1.1}}; },
 ///         {"pt", "eta"},  // inputs to the Vary expression, independent of what columns are varied
 ///         {"down", "up"}, // variation tags
 ///         "ptAndEta")    // variation name
 ///     .Histo1D("pt", "eta");
 ///
 /// auto hx = ROOT::RDF::Experimental::VariationsFor(nominal_hx);
 /// hx["nominal"].Draw();
 /// hx["ptAndEta:down"].Draw("SAME");
 /// hx["ptAndEta:up"].Draw("SAME");
 /// ~~~
 ///
 /// \note See also This Vary() overload for more information.

 template <typename F>
 RInterface<Proxied, DS_t>
 Vary(const std::vector<std::string> &colNames, F &&expression, const ColumnNames_t &inputColumns,
      const std::vector<std::string> &variationTags, std::string_view variationName)
 {
    return VaryImpl<false>(colNames, std::forward<F>(expression), inputColumns, variationTags, variationName);
 }

 /// \brief Register systematic variations for multiple existing columns using custom variation tags.
 /// \param[in] colNames set of names of the columns for which varied values are provided.
 /// \param[in] expression a callable that evaluates the varied values for the specified columns. The callable can
 ///            take any column values as input, similarly to what happens during Filter and Define calls. It must
 ///            return an RVec of varied values, one for each variation tag, in the same order as the tags.
 /// \param[in] inputColumns the names of the columns to be passed to the callable.
 /// \param[in] variationTags names for each of the varied values, e.g. `"up"` and `"down"`.
 /// \param[in] variationName a generic name for this set of varied values, e.g. `"ptvariation"`.
 ///            colName is used if none is provided.
 ///
 /// \note This overload ensures that the ambiguity between C++20 string, vector<string> construction from init list
 /// is avoided.
 ///
 /// \note See also This Vary() overload for more information.
 template <typename F>
 RInterface<Proxied, DS_t>
 Vary(std::initializer_list<std::string> colNames, F &&expression, const ColumnNames_t &inputColumns,
      const std::vector<std::string> &variationTags, std::string_view variationName)
 {
    return Vary(std::vector<std::string>(colNames), std::forward<F>(expression), inputColumns, variationTags, variationName);
 }

 /// \brief Register systematic variations for multiple existing columns using auto-generated tags.
 /// \param[in] colNames set of names of the columns for which varied values are provided.
 /// \param[in] expression a callable that evaluates the varied values for the specified columns. The callable can
 ///            take any column values as input, similarly to what happens during Filter and Define calls. It must
 ///            return an RVec of varied values, one for each variation tag, in the same order as the tags.
 /// \param[in] inputColumns the names of the columns to be passed to the callable.
 /// \param[in] nVariations number of variations returned by the expression. The corresponding tags will be `"0"`,
 /// `"1"`, etc. 
 /// \param[in] variationName a generic name for this set of varied values, e.g. `"ptvariation"`.
 ///            colName is used if none is provided.
 ///
 /// This overload of Vary takes a list of column names as first argument.
 /// It takes an `nVariations` parameter instead of a list of tag names (`variationTags`). Tag names
 /// will be auto-generated as the sequence 0...``nVariations-1``.
 ///
 /// Example usage:
 /// ~~~{.cpp}
 /// auto nominal_hx =
 ///   df.Vary({"pt", "eta"}, // the columns that will vary simultaneously
 ///         [](double pt, double eta) { return RVec<RVecF>{{pt*0.9, pt*1.1}, {eta*0.9, eta*1.1}}; },
 ///         {"pt", "eta"},  // inputs to the Vary expression, independent of what columns are varied
 ///         2, // auto-generated variation tags
 ///         "ptAndEta")    // variation name
 ///     .Histo1D("pt", "eta");
 ///
 /// auto hx = ROOT::RDF::Experimental::VariationsFor(nominal_hx);
 /// hx["nominal"].Draw();
 /// hx["ptAndEta:0"].Draw("SAME");
 /// hx["ptAndEta:1"].Draw("SAME");
 /// ~~~
 ///
 /// \note See also This Vary() overload for more information.
 template <typename F>
 RInterface<Proxied, DS_t>
 Vary(const std::vector<std::string> &colNames, F &&expression, const ColumnNames_t &inputColumns,
      std::size_t nVariations, std::string_view variationName)
 {
    R__ASSERT(nVariations > 0 && "Must have at least one variation.")do { if (__builtin_expect(!!(!(nVariations > 0 && "Must have at least one variation."
)), 0)) ::Fatal("", kAssertMsg, "nVariations > 0 && \"Must have at least one variation.\""
, 1022, "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RDF/RInterface.hxx"
); } while (false);

    std::vector<std::string> variationTags;
    variationTags.reserve(nVariations);
    for (std::size_t i = 0u; i < nVariations; ++i)
       variationTags.emplace_back(std::to_string(i));

    return Vary(colNames, std::forward<F>(expression), inputColumns, std::move(variationTags), variationName);
 }

 /// \brief Register systematic variations for for multiple existing columns using custom variation tags.
 /// \param[in] colNames set of names of the columns for which varied values are provided.
 /// \param[in] expression a callable that evaluates the varied values for the specified columns. The callable can
 ///            take any column values as input, similarly to what happens during Filter and Define calls. It must
 ///            return an RVec of varied values, one for each variation tag, in the same order as the tags.
 /// \param[in] inputColumns the names of the columns to be passed to the callable.
 /// \param[in] inputColumns the names of the columns to be passed to the callable.
 /// \param[in] nVariations number of variations returned by the expression. The corresponding tags will be `"0"`,
 /// `"1"`, etc. 
 /// \param[in] variationName a generic name for this set of varied values, e.g. `"ptvariation"`.
 ///            colName is used if none is provided.
 ///
 /// \note This overload ensures that the ambiguity between C++20 string, vector<string> construction from init list
 /// is avoided.
 ///
 /// \note See also This Vary() overload for more information.
 template <typename F>
 RInterface<Proxied, DS_t>
 Vary(std::initializer_list<std::string> colNames, F &&expression, const ColumnNames_t &inputColumns,
      std::size_t nVariations, std::string_view variationName)
 {
    return Vary(std::vector<std::string>(colNames), std::forward<F>(expression), inputColumns, nVariations, variationName);
 }

 /// \brief Register systematic variations for a single existing column using custom variation tags.
 /// \param[in] colName name of the column for which varied values are provided.
 /// \param[in] expression a string containing valid C++ code that evaluates to an RVec containing the varied
 ///            values for the specified column.
 /// \param[in] variationTags names for each of the varied values, e.g. `"up"` and `"down"`.
 /// \param[in] variationName a generic name for this set of varied values, e.g. `"ptvariation"`.
 ///            colName is used if none is provided.
 ///
 /// This overload adds the possibility for the expression used to evaluate the varied values to be just-in-time
 /// compiled. The example below shows how Vary() is used while dealing with a single column. The variation tags are
 /// defined as `{"down", "up"}`.
 /// ~~~{.cpp}
 /// auto nominal_hx =
 ///     df.Vary("pt", "ROOT::RVecD{pt*0.9, pt*1.1}", {"down", "up"})
 ///       .Filter("pt > k")
 ///       .Define("x", someFunc, {"pt"})
 ///       .Histo1D("x");
 ///
 /// auto hx = ROOT::RDF::Experimental::VariationsFor(nominal_hx);
 /// hx["nominal"].Draw();
 /// hx["pt:down"].Draw("SAME");
 /// hx["pt:up"].Draw("SAME");
 /// ~~~
 ///
 /// \note See also This Vary() overload for more information.
 RInterface<Proxied, DS_t> Vary(std::string_view colName, std::string_view expression,
                                const std::vector<std::string> &variationTags, std::string_view variationName = "")
 {
    std::vector<std::string> colNames{{std::string(colName)}};
    const std::string theVariationName{variationName.empty() ? colName : variationName};

    return JittedVaryImpl(colNames, expression, variationTags, theVariationName, /*isSingleColumn=*/true);
 }

 /// \brief Register systematic variations for a single existing column using auto-generated variation tags.
 /// \param[in] colName name of the column for which varied values are provided.
 /// \param[in] expression a string containing valid C++ code that evaluates to an RVec containing the varied
 ///            values for the specified column.
 /// \param[in] nVariations number of variations returned by the expression. The corresponding tags will be `"0"`,
 /// `"1"`, etc. 
 /// \param[in] variationName a generic name for this set of varied values, e.g. `"ptvariation"`.
 ///            colName is used if none is provided.
 ///
 /// This overload adds the possibility for the expression used to evaluate the varied values to be a just-in-time
 /// compiled. The example below shows how Vary() is used while dealing with a single column. The variation tags are
 /// auto-generated.
 /// ~~~{.cpp}
 /// auto nominal_hx =
 ///     df.Vary("pt", "ROOT::RVecD{pt*0.9, pt*1.1}", 2)
 ///       .Histo1D("pt");
 ///
 /// auto hx = ROOT::RDF::Experimental::VariationsFor(nominal_hx);
 /// hx["nominal"].Draw();
 /// hx["pt:0"].Draw("SAME");
 /// hx["pt:1"].Draw("SAME");
 /// ~~~
 ///
 /// \note See also This Vary() overload for more information.
 RInterface<Proxied, DS_t> Vary(std::string_view colName, std::string_view expression, std::size_t nVariations,
                                std::string_view variationName = "")
 {
    std::vector<std::string> variationTags;
    variationTags.reserve(nVariations);
    for (std::size_t i = 0u; i < nVariations; ++i)
       variationTags.emplace_back(std::to_string(i));

    return Vary(colName, expression, std::move(variationTags), variationName);
 }

 /// \brief Register systematic variations for multiple existing columns using auto-generated variation tags.
 /// \param[in] colNames set of names of the columns for which varied values are provided.
 /// \param[in] expression a string containing valid C++ code that evaluates to an RVec or RVecs containing the varied
 ///            values for the specified columns.
 /// \param[in] nVariations number of variations returned by the expression. The corresponding tags will be `"0"`,
 /// `"1"`, etc. 
 /// \param[in] variationName a generic name for this set of varied values, e.g. `"ptvariation"`.
 ///
 /// This overload adds the possibility for the expression used to evaluate the varied values to be just-in-time
 /// compiled. It takes an nVariations parameter instead of a list of tag names.
 /// The varied results will be accessible via the keys of the dictionary with the form `variationName:N` where `N`
 /// is the corresponding sequential tag starting at 0 and going up to `nVariations - 1`.
 /// The example below shows how Vary() is used while dealing with multiple columns.
 ///
 /// ~~~{.cpp}
 /// auto nominal_hx =
 ///     df.Vary({"x", "y"}, "ROOT::RVec<ROOT::RVecD>{{x*0.9, x*1.1}, {y*0.9, y*1.1}}", 2, "xy")
 ///       .Histo1D("x", "y");
 ///
 /// auto hx = ROOT::RDF::Experimental::VariationsFor(nominal_hx);
 /// hx["nominal"].Draw();
 /// hx["xy:0"].Draw("SAME");
 /// hx["xy:1"].Draw("SAME");
 /// ~~~
 ///
 /// \note See also This Vary() overload for more information.
 RInterface<Proxied, DS_t> Vary(const std::vector<std::string> &colNames, std::string_view expression,
                                std::size_t nVariations, std::string_view variationName)
 {
    std::vector<std::string> variationTags;
    variationTags.reserve(nVariations);
    for (std::size_t i = 0u; i < nVariations; ++i)
       variationTags.emplace_back(std::to_string(i));

    return Vary(colNames, expression, std::move(variationTags), variationName);
 }

 /// \brief Register systematic variations for multiple existing columns using auto-generated variation tags.
 /// \param[in] colNames set of names of the columns for which varied values are provided.
 /// \param[in] expression a string containing valid C++ code that evaluates to an RVec containing the varied
 ///            values for the specified column.
 /// \param[in] nVariations number of variations returned by the expression. The corresponding tags will be `"0"`,
 /// `"1"`, etc. 
 /// \param[in] variationName a generic name for this set of varied values, e.g. `"ptvariation"`.
 ///            colName is used if none is provided.
 ///
 /// \note This overload ensures that the ambiguity between C++20 string, vector<string> construction from init list
 /// is avoided.
 ///
 /// \note See also This Vary() overload for more information.
 RInterface<Proxied, DS_t> Vary(std::initializer_list<std::string> colNames, std::string_view expression,
                                std::size_t nVariations, std::string_view variationName)
 {
    return Vary(std::vector<std::string>(colNames), expression, nVariations, variationName);
 }

 /// \brief Register systematic variations for multiple existing columns using custom variation tags.
 /// \param[in] colNames set of names of the columns for which varied values are provided.
 /// \param[in] expression a string containing valid C++ code that evaluates to an RVec or RVecs containing the varied
 ///            values for the specified columns.
 /// \param[in] variationTags names for each of the varied values, e.g. `"up"` and `"down"`.
 /// \param[in] variationName a generic name for this set of varied values, e.g. `"ptvariation"`.
 ///
 /// This overload adds the possibility for the expression used to evaluate the varied values to be just-in-time
 /// compiled. The example below shows how Vary() is used while dealing with multiple columns. The tags are defined as
 /// `{"down", "up"}`.
 /// ~~~{.cpp}
 /// auto nominal_hx =
 ///     df.Vary({"x", "y"}, "ROOT::RVec<ROOT::RVecD>{{x*0.9, x*1.1}, {y*0.9, y*1.1}}", {"down", "up"}, "xy")
 ///       .Histo1D("x", "y");
 ///
 /// auto hx = ROOT::RDF::Experimental::VariationsFor(nominal_hx);
 /// hx["nominal"].Draw();
 /// hx["xy:down"].Draw("SAME");
 /// hx["xy:up"].Draw("SAME");
 /// ~~~
 ///
 /// \note See also This Vary() overload for more information.
 RInterface<Proxied, DS_t> Vary(const std::vector<std::string> &colNames, std::string_view expression,
                                const std::vector<std::string> &variationTags, std::string_view variationName)
 {
    return JittedVaryImpl(colNames, expression, variationTags, variationName, /*isSingleColumn=*/false);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Allow to refer to a column with a different name.
 /// \param[in] alias name of the column alias
 /// \param[in] columnName of the column to be aliased
 /// \return the first node of the computation graph for which the alias is available.
 ///
 /// Aliasing an alias is supported.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// auto df_with_alias = df.Alias("simple_name", "very_long&complex_name!!!");
 /// ~~~
 RInterface<Proxied, DS_t> Alias(std::string_view alias, std::string_view columnName)
 {
    // The symmetry with Define is clear. We want to:
    // - Create globally the alias and return this very node, unchanged
    // - Make aliases accessible based on chains and not globally

    // Helper to find out if a name is a column
    auto &dsColumnNames = GetDataSource() ? GetDataSource()->GetColumnNames() : ColumnNames_t{};

    constexpr auto where = "Alias";
    RDFInternal::CheckValidCppVarName(alias, where);
    // If the alias name is a column name, there is a problem
    RDFInternal::CheckForRedefinition(where, alias, fColRegister, fLoopManager->GetBranchNames(), dsColumnNames);

    const auto validColumnName = GetValidatedColumnNames(1, {std::string(columnName)})[0];

    RDFInternal::RColumnRegister newCols(fColRegister);
    newCols.AddAlias(alias, validColumnName);

    RInterface<Proxied, DS_t> newInterface(fProxiedPtr, *fLoopManager, std::move(newCols));

    return newInterface;
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Save selected columns to disk, in a new TTree `treename` in file `filename`.
 /// \tparam ColumnTypes variadic list of branch/column types.
 /// \param[in] treename The name of the output TTree.
 /// \param[in] filename The name of the output TFile.
 /// \param[in] columnList The list of names of the columns/branches to be written.
 /// \param[in] options RSnapshotOptions struct with extra options to pass to TFile and TTree.
 /// \return a `RDataFrame` that wraps the snapshotted dataset.
 ///
 /// Support for writing of nested branches is limited (although RDataFrame is able to read them) and dot ('.')
 /// characters in input column names will be replaced by underscores ('_') in the branches produced by Snapshot.
 /// When writing a variable size array through Snapshot, it is required that the column indicating its size is also
 /// written out and it appears before the array in the columnList.
 ///
 /// By default, in case of TTree or TChain inputs, Snapshot will try to write out all top-level branches. For other
 /// types of inputs, all columns returned by GetColumnNames() will be written out. If friend trees or chains are
 /// present, by default all friend top-level branches that have names that do not collide with
 /// names of branches in the main TTree/TChain will be written out. Since v6.24, Snapshot will also write out
 /// friend branches with the same names of branches in the main TTree/TChain with names of the form
 /// `<friendname>_<branchname>` in order to differentiate them from the branches in the main tree/chain.
 ///
 /// ### Writing to a sub-directory
 ///
 /// Snapshot supports writing the TTree in a sub-directory inside the TFile. It is sufficient to specify the path to
 /// the TTree as part of the TTree name, e.g. `df.Snapshot("subdir/t", "f.root")` write TTree `t` in the
 /// sub-directory `subdir` of file `f.root` (creating file and sub-directory as needed).
 ///
 /// \attention In multi-thread runs (i.e. when EnableImplicitMT() has been called) threads will loop over clusters of
 /// entries in an undefined order, so Snapshot will produce outputs in which (clusters of) entries will be shuffled
 /// with respect to the input TTree. Using such "shuffled" TTrees as friends of the original trees would result in
 /// wrong associations between entries in the main TTree and entries in the "shuffled" friend. Since v6.22, ROOT will
 /// error out if such a "shuffled" TTree is used in a friendship.
 ///
 /// \note In case no events are written out (e.g. because no event passes all filters), Snapshot will still write the
 /// requested output TTree to the file, with all the branches requested to preserve the dataset schema.
 ///
 /// \note Snapshot will refuse to process columns with names of the form `#columnname`. These are special columns
 /// made available by some data sources (e.g. RNTupleDS) that represent the size of column `columnname`, and are
 /// not meant to be written out with that name (which is not a valid C++ variable name). Instead, go through an
 /// Alias(): `df.Alias("nbar", "#bar").Snapshot(..., {"nbar"})`.
 ///
 /// ### Example invocations:
 ///
 /// ~~~{.cpp}
 /// // without specifying template parameters (column types automatically deduced)
 /// df.Snapshot("outputTree", "outputFile.root", {"x", "y"});
 ///
 /// // specifying template parameters ("x" is `int`, "y" is `float`)
 /// df.Snapshot<int, float>("outputTree", "outputFile.root", {"x", "y"});
 /// ~~~
 ///
 /// To book a Snapshot without triggering the event loop, one needs to set the appropriate flag in
 /// `RSnapshotOptions`:
 /// ~~~{.cpp}
 /// RSnapshotOptions opts;
 /// opts.fLazy = true;
 /// df.Snapshot("outputTree", "outputFile.root", {"x"}, opts);
 /// ~~~
 template <typename... ColumnTypes>
 RResultPtr<RInterface<RLoopManager>>
 Snapshot(std::string_view treename, std::string_view filename, const ColumnNames_t &columnList,
          const RSnapshotOptions &options = RSnapshotOptions())
 {
    return SnapshotImpl<ColumnTypes...>(treename, filename, columnList, options);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Save selected columns to disk, in a new TTree `treename` in file `filename`.
 /// \param[in] treename The name of the output TTree.
 /// \param[in] filename The name of the output TFile.
 /// \param[in] columnList The list of names of the columns/branches to be written.
 /// \param[in] options RSnapshotOptions struct with extra options to pass to TFile and TTree.
 /// \return a `RDataFrame` that wraps the snapshotted dataset.
 ///
 /// This function returns a `RDataFrame` built with the output tree as a source.
 /// The types of the columns are automatically inferred and do not need to be specified.
 ///
 /// See above for a more complete description and example usages.
 RResultPtr<RInterface<RLoopManager>> Snapshot(std::string_view treename, std::string_view filename,
                                               const ColumnNames_t &columnList,
                                               const RSnapshotOptions &options = RSnapshotOptions())
 {
    // like columnList but with `#var` columns removed
    auto colListNoPoundSizes = RDFInternal::FilterArraySizeColNames(columnList, "Snapshot");
    // like columnListWithoutSizeColumns but with aliases resolved
    auto colListNoAliases = GetValidatedColumnNames(colListNoPoundSizes.size(), colListNoPoundSizes);
    RDFInternal::CheckForDuplicateSnapshotColumns(colListNoAliases);
    // like validCols but with missing size branches required by array branches added in the right positions
    const auto pairOfColumnLists = RDFInternal::AddSizeBranches(
       fLoopManager->GetBranchNames(), GetDataSource(), std::move(colListNoAliases), std::move(colListNoPoundSizes));
    const auto &colListNoAliasesWithSizeBranches = pairOfColumnLists.first;
    const auto &colListWithAliasesAndSizeBranches = pairOfColumnLists.second;

    const auto fullTreeName = treename;
    const auto parsedTreePath = RDFInternal::ParseTreePath(fullTreeName);
    treename = parsedTreePath.fTreeName;
    const auto &dirname = parsedTreePath.fDirName;

    ::TDirectory::TContext ctxt;

    RResultPtr<RInterface<RLoopManager>> resPtr;

    if (options.fOutputFormat == ESnapshotOutputFormat::kRNTuple) {
       if (RDFInternal::GetDataSourceLabel(*this) == "TTreeDS") {
          throw std::runtime_error("Snapshotting from TTree to RNTuple is not yet supported. The current recommended "
                                   "way to convert TTrees to RNTuple is through the RNTupleImporter.");
       }

       // The data source of the RNTuple resulting from the Snapshot action does not exist yet here, so we create one
       // without a data source for now, and set it once the actual data source can be created (i.e., after
       // writing the RNTuple).
       auto newRDF = std::make_shared<RInterface<RLoopManager>>(std::make_shared<RLoopManager>(colListNoPoundSizes));

       auto snapHelperArgs = std::make_shared<RDFInternal::SnapshotHelperArgs>(RDFInternal::SnapshotHelperArgs{
          std::string(filename), std::string(dirname), std::string(treename), colListWithAliasesAndSizeBranches,
          options, newRDF->GetLoopManager(), GetLoopManager(), true /* fToNTuple */});

       // The Snapshot helper will use colListNoAliasesWithSizeBranches (with aliases resolved) as input columns, and
       // colListWithAliasesAndSizeBranches (still with aliases in it, passed through snapHelperArgs) as output column
       // names.
       resPtr = CreateAction<RDFInternal::ActionTags::Snapshot, RDFDetail::RInferredType>(
          colListNoAliasesWithSizeBranches, newRDF, snapHelperArgs, fProxiedPtr,
          colListNoAliasesWithSizeBranches.size());
    } else {
       if (RDFInternal::GetDataSourceLabel(*this) == "RNTupleDS" &&
           options.fOutputFormat == ESnapshotOutputFormat::kDefault) {
          Warning("Snapshot",
                  "The default Snapshot output data format is TTree, but the input data format is RNTuple. If you "
                  "want to Snapshot to RNTuple or suppress this warning, set the appropriate fOutputFormat option in "
                  "RSnapshotOptions. Note that this current default behaviour might change in the future.");
       }

       // We create an RLoopManager without a data source. This needs to be initialised when the output TTree dataset
       // has actually been created and written to TFile, i.e. at the end of the Snapshot execution.
       auto newRDF = std::make_shared<RInterface<RLoopManager>>(
          std::make_shared<RLoopManager>(colListNoAliasesWithSizeBranches));

       auto snapHelperArgs = std::make_shared<RDFInternal::SnapshotHelperArgs>(RDFInternal::SnapshotHelperArgs{
          std::string(filename), std::string(dirname), std::string(treename), colListWithAliasesAndSizeBranches,
          options, newRDF->GetLoopManager(), GetLoopManager(), false /* fToRNTuple */});

       resPtr = CreateAction<RDFInternal::ActionTags::Snapshot, RDFDetail::RInferredType>(
          colListNoAliasesWithSizeBranches, newRDF, snapHelperArgs, fProxiedPtr,
          colListNoAliasesWithSizeBranches.size(), options.fVector2RVec);
    }

    if (!options.fLazy)
       *resPtr;
    return resPtr;
 }

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Save selected columns to disk, in a new TTree `treename` in file `filename`.
 /// \param[in] treename The name of the output TTree.
 /// \param[in] filename The name of the output TFile.
 /// \param[in] columnNameRegexp The regular expression to match the column names to be selected. The presence of a '^' and a '$' at the end of the string is implicitly assumed if they are not specified. The dialect supported is PCRE via the TPRegexp class. An empty string signals the selection of all columns.
 /// \param[in] options RSnapshotOptions struct with extra options to pass to TFile and TTree
 /// \return a `RDataFrame` that wraps the snapshotted dataset.
 ///
 /// This function returns a `RDataFrame` built with the output tree as a source.
 /// The types of the columns are automatically inferred and do not need to be specified.
 ///
 /// See above for a more complete description and example usages.
 RResultPtr<RInterface<RLoopManager>> Snapshot(std::string_view treename, std::string_view filename,
                                               std::string_view columnNameRegexp = "",
                                               const RSnapshotOptions &options = RSnapshotOptions())
 {
    const auto definedColumns = fColRegister.GenerateColumnNames();
    auto *tree = fLoopManager->GetTree();

    const auto treeBranchNames = tree != nullptr ? ROOT::Internal::TreeUtils::GetTopLevelBranchNames(*tree) : ColumnNames_t{};
    const auto dsColumns = GetDataSource() ? ROOT::Internal::RDF::GetTopLevelFieldNames(*GetDataSource()) : ColumnNames_t{};
    // Ignore R_rdf_sizeof_* columns coming from datasources: we don't want to Snapshot those
    ColumnNames_t dsColumnsWithoutSizeColumns;
    std::copy_if(dsColumns.begin(), dsColumns.end(), std::back_inserter(dsColumnsWithoutSizeColumns),
                 [](const std::string &name) { return name.size() < 13 || name.substr(0, 13) != "R_rdf_sizeof_"; });
    ColumnNames_t columnNames;
    columnNames.reserve(definedColumns.size() + treeBranchNames.size() + dsColumnsWithoutSizeColumns.size());
    columnNames.insert(columnNames.end(), definedColumns.begin(), definedColumns.end());
    columnNames.insert(columnNames.end(), treeBranchNames.begin(), treeBranchNames.end());
    columnNames.insert(columnNames.end(), dsColumnsWithoutSizeColumns.begin(), dsColumnsWithoutSizeColumns.end());

    // The only way we can get duplicate entries is if a column coming from a tree or data-source is Redefine'd.
    // RemoveDuplicates should preserve ordering of the columns: it might be meaningful.
    RDFInternal::RemoveDuplicates(columnNames);

    auto selectedColumns = RDFInternal::ConvertRegexToColumns(columnNames, columnNameRegexp, "Snapshot");

    if (RDFInternal::GetDataSourceLabel(*this) == "RNTupleDS") {
       RDFInternal::RemoveRNTupleSubFields(selectedColumns);
    }

    return Snapshot(treename, filename, selectedColumns, options);
 }
 // clang-format on

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Save selected columns to disk, in a new TTree `treename` in file `filename`.
 /// \param[in] treename The name of the output TTree.
 /// \param[in] filename The name of the output TFile.
 /// \param[in] columnList The list of names of the columns/branches to be written.
 /// \param[in] options RSnapshotOptions struct with extra options to pass to TFile and TTree.
 /// \return a `RDataFrame` that wraps the snapshotted dataset.
 ///
 /// This function returns a `RDataFrame` built with the output tree as a source.
 /// The types of the columns are automatically inferred and do not need to be specified.
 ///
 /// See above for a more complete description and example usages.
 RResultPtr<RInterface<RLoopManager>> Snapshot(std::string_view treename, std::string_view filename,
                                               std::initializer_list<std::string> columnList,
                                               const RSnapshotOptions &options = RSnapshotOptions())
 {
    ColumnNames_t selectedColumns(columnList);
    return Snapshot(treename, filename, selectedColumns, options);
 }
 // clang-format on

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Save selected columns in memory.
 /// \tparam ColumnTypes variadic list of branch/column types.
 /// \param[in] columnList columns to be cached in memory.
 /// \return a `RDataFrame` that wraps the cached dataset.
 ///
 /// This action returns a new `RDataFrame` object, completely detached from
 /// the originating `RDataFrame`. The new dataframe only contains the cached
 /// columns and stores their content in memory for fast, zero-copy subsequent access.
 ///
 /// Use `Cache` if you know you will only need a subset of the (`Filter`ed) data that
 /// fits in memory and that will be accessed many times.
 ///
 /// \note Cache will refuse to process columns with names of the form `#columnname`. These are special columns
 /// made available by some data sources (e.g. RNTupleDS) that represent the size of column `columnname`, and are
 /// not meant to be written out with that name (which is not a valid C++ variable name). Instead, go through an
 /// Alias(): `df.Alias("nbar", "#bar").Cache<std::size_t>(..., {"nbar"})`.
 ///
 /// ### Example usage:
 ///
 /// **Types and columns specified:**
 /// ~~~{.cpp}
 /// auto cache_some_cols_df = df.Cache<double, MyClass, int>({"col0", "col1", "col2"});
 /// ~~~
 ///
 /// **Types inferred and columns specified (this invocation relies on jitting):**
 /// ~~~{.cpp}
 /// auto cache_some_cols_df = df.Cache({"col0", "col1", "col2"});
 /// ~~~
 ///
 /// **Types inferred and columns selected with a regexp (this invocation relies on jitting):**
 /// ~~~{.cpp}
 /// auto cache_all_cols_df = df.Cache(myRegexp);
 /// ~~~
 template <typename... ColumnTypes>
 RInterface<RLoopManager> Cache(const ColumnNames_t &columnList)
 {
    auto staticSeq = std::make_index_sequence<sizeof...(ColumnTypes)>();
    return CacheImpl<ColumnTypes...>(columnList, staticSeq);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Save selected columns in memory.
 /// \param[in] columnList columns to be cached in memory
 /// \return a `RDataFrame` that wraps the cached dataset.
 ///
 /// See the previous overloads for more information.
 RInterface<RLoopManager> Cache(const ColumnNames_t &columnList)
 {
    // Early return: if the list of columns is empty, just return an empty RDF
    // If we proceed, the jitted call will not compile!
    if (columnList.empty()) {
       auto nEntries = *this->Count();
       RInterface<RLoopManager> emptyRDF(std::make_shared<RLoopManager>(nEntries));
       return emptyRDF;
    }

    std::stringstream cacheCall;
    auto upcastNode = RDFInternal::UpcastNode(fProxiedPtr);
    RInterface<TTraits::TakeFirstParameter_t<decltype(upcastNode)>> upcastInterface(fProxiedPtr, *fLoopManager,
                                                                                    fColRegister);
    // build a string equivalent to
    // "(RInterface<nodetype*>*)(this)->Cache<Ts...>(*(ColumnNames_t*)(&columnList))"
    RInterface<RLoopManager> resRDF(std::make_shared<ROOT::Detail::RDF::RLoopManager>(0));
    cacheCall << "*reinterpret_cast<ROOT::RDF::RInterface<ROOT::Detail::RDF::RLoopManager>*>("
              << RDFInternal::PrettyPrintAddr(&resRDF)
              << ") = reinterpret_cast<ROOT::RDF::RInterface<ROOT::Detail::RDF::RNodeBase>*>("
              << RDFInternal::PrettyPrintAddr(&upcastInterface) << ")->Cache<";

    const auto columnListWithoutSizeColumns = RDFInternal::FilterArraySizeColNames(columnList, "Cache");

    const auto validColumnNames =
       GetValidatedColumnNames(columnListWithoutSizeColumns.size(), columnListWithoutSizeColumns);
    const auto colTypes = GetValidatedArgTypes(validColumnNames, fColRegister, fLoopManager->GetTree(),
                                               GetDataSource(), "Cache", /*vector2RVec=*/false);
    for (const auto &colType : colTypes)
       cacheCall << colType << ", ";
    if (!columnListWithoutSizeColumns.empty())
       cacheCall.seekp(-2, cacheCall.cur);                         // remove the last ",
    cacheCall << ">(*reinterpret_cast<std::vector<std::string>*>(" // vector<string> should be ColumnNames_t
              << RDFInternal::PrettyPrintAddr(&columnListWithoutSizeColumns) << "));";

    // book the code to jit with the RLoopManager and trigger the event loop
    fLoopManager->ToJitExec(cacheCall.str());
    fLoopManager->Jit();

    return resRDF;
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Save selected columns in memory.
 /// \param[in] columnNameRegexp The regular expression to match the column names to be selected. The presence of a '^' and a '$' at the end of the string is implicitly assumed if they are not specified. The dialect supported is PCRE via the TPRegexp class. An empty string signals the selection of all columns.
 /// \return a `RDataFrame` that wraps the cached dataset.
 ///
 /// The existing columns are matched against the regular expression. If the string provided
 /// is empty, all columns are selected. See the previous overloads for more information.
 RInterface<RLoopManager> Cache(std::string_view columnNameRegexp = "")
 {
    const auto definedColumns = fColRegister.GenerateColumnNames();
    auto *tree = fLoopManager->GetTree();
    const auto treeBranchNames =
       tree != nullptr ? ROOT::Internal::TreeUtils::GetTopLevelBranchNames(*tree) : ColumnNames_t{};
    const auto dsColumns = GetDataSource() ? GetDataSource()->GetColumnNames() : ColumnNames_t{};
    // Ignore R_rdf_sizeof_* columns coming from datasources: we don't want to Snapshot those
    ColumnNames_t dsColumnsWithoutSizeColumns;
    std::copy_if(dsColumns.begin(), dsColumns.end(), std::back_inserter(dsColumnsWithoutSizeColumns),
                 [](const std::string &name) { return name.size() < 13 || name.substr(0, 13) != "R_rdf_sizeof_"; });
    ColumnNames_t columnNames;
    columnNames.reserve(definedColumns.size() + treeBranchNames.size() + dsColumns.size());
    columnNames.insert(columnNames.end(), definedColumns.begin(), definedColumns.end());
    columnNames.insert(columnNames.end(), treeBranchNames.begin(), treeBranchNames.end());
    columnNames.insert(columnNames.end(), dsColumns.begin(), dsColumns.end());
    const auto selectedColumns = RDFInternal::ConvertRegexToColumns(columnNames, columnNameRegexp, "Cache");
    return Cache(selectedColumns);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Save selected columns in memory.
 /// \param[in] columnList columns to be cached in memory.
 /// \return a `RDataFrame` that wraps the cached dataset.
 ///
 /// See the previous overloads for more information.
 RInterface<RLoopManager> Cache(std::initializer_list<std::string> columnList)
 {
    ColumnNames_t selectedColumns(columnList);
    return Cache(selectedColumns);
 }

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Creates a node that filters entries based on range: [begin, end).
 /// \param[in] begin Initial entry number considered for this range.
 /// \param[in] end Final entry number (excluded) considered for this range. 0 means that the range goes until the end of the dataset.
 /// \param[in] stride Process one entry of the [begin, end) range every `stride` entries. Must be strictly greater than 0.
 /// \return the first node of the computation graph for which the event loop is limited to a certain range of entries.
 ///
 /// Note that in case of previous Ranges and Filters the selected range refers to the transformed dataset.
 /// Ranges are only available if EnableImplicitMT has _not_ been called. Multi-thread ranges are not supported.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// auto d_0_30 = d.Range(0, 30); // Pick the first 30 entries
 /// auto d_15_end = d.Range(15, 0); // Pick all entries from 15 onwards
 /// auto d_15_end_3 = d.Range(15, 0, 3); // Stride: from event 15, pick an event every 3
 /// ~~~
 // clang-format on
 RInterface<RDFDetail::RRange<Proxied>, DS_t> Range(unsigned int begin, unsigned int end, unsigned int stride = 1)
 {
    // check invariants
    if (stride == 0 || (end != 0 && end < begin))
       throw std::runtime_error("Range: stride must be strictly greater than 0 and end must be greater than begin.");
    CheckIMTDisabled("Range");

    using Range_t = RDFDetail::RRange<Proxied>;
    auto rangePtr = std::make_shared<Range_t>(begin, end, stride, fProxiedPtr);
    RInterface<RDFDetail::RRange<Proxied>, DS_t> newInterface(std::move(rangePtr), *fLoopManager, fColRegister);
    return newInterface;
 }

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Creates a node that filters entries based on range.
 /// \param[in] end Final entry number (excluded) considered for this range. 0 means that the range goes until the end of the dataset.
 /// \return a node of the computation graph for which the range is defined.
 ///
 /// See the other Range overload for a detailed description.
 // clang-format on
 RInterface<RDFDetail::RRange<Proxied>, DS_t> Range(unsigned int end) { return Range(0, end, 1); }

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Execute a user-defined function on each entry (*instant action*).
 /// \param[in] f Function, lambda expression, functor class or any other callable object performing user defined calculations.
 /// \param[in] columns Names of the columns/branches in input to the user function.
 ///
 /// The callable `f` is invoked once per entry. This is an *instant action*:
 /// upon invocation, an event loop as well as execution of all scheduled actions
 /// is triggered.
 /// Users are responsible for the thread-safety of this callable when executing
 /// with implicit multi-threading enabled (i.e. ROOT::EnableImplicitMT).
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// myDf.Foreach([](int i){ std::cout << i << std::endl;}, {"myIntColumn"});
 /// ~~~
 // clang-format on
 template <typename F>
 void Foreach(F f, const ColumnNames_t &columns = {})
 {
    using arg_types = typename TTraits::CallableTraits<decltype(f)>::arg_types_nodecay;
    using ret_type = typename TTraits::CallableTraits<decltype(f)>::ret_type;
    ForeachSlot(RDFInternal::AddSlotParameter<ret_type>(f, arg_types()), columns);
 }

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Execute a user-defined function requiring a processing slot index on each entry (*instant action*).
 /// \param[in] f Function, lambda expression, functor class or any other callable object performing user defined calculations.
 /// \param[in] columns Names of the columns/branches in input to the user function.
 ///
 /// Same as `Foreach`, but the user-defined function takes an extra
 /// `unsigned int` as its first parameter, the *processing slot index*.
 /// This *slot index* will be assigned a different value, `0` to `poolSize - 1`,
 /// for each thread of execution.
 /// This is meant as a helper in writing thread-safe `Foreach`
 /// actions when using `RDataFrame` after `ROOT::EnableImplicitMT()`.
 /// The user-defined processing callable is able to follow different
 /// *streams of processing* indexed by the first parameter.
 /// `ForeachSlot` works just as well with single-thread execution: in that
 /// case `slot` will always be `0`.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// myDf.ForeachSlot([](unsigned int s, int i){ std::cout << "Slot " << s << ": "<< i << std::endl;}, {"myIntColumn"});
 /// ~~~
 // clang-format on
 template <typename F>
 void ForeachSlot(F f, const ColumnNames_t &columns = {})
 {
    using ColTypes_t = TypeTraits::RemoveFirstParameter_t<typename TTraits::CallableTraits<F>::arg_types>;
    constexpr auto nColumns = ColTypes_t::list_size;

    const auto validColumnNames = GetValidatedColumnNames(nColumns, columns);
    CheckAndFillDSColumns(validColumnNames, ColTypes_t());

    using Helper_t = RDFInternal::ForeachSlotHelper<F>;
    using Action_t = RDFInternal::RAction<Helper_t, Proxied>;

    auto action = std::make_unique<Action_t>(Helper_t(std::move(f)), validColumnNames, fProxiedPtr, fColRegister);

    fLoopManager->Run();
 }

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Execute a user-defined reduce operation on the values of a column.
 /// \tparam F The type of the reduce callable. Automatically deduced.
 /// \tparam T The type of the column to apply the reduction to. Automatically deduced.
 /// \param[in] f A callable with signature `T(T,T)`
 /// \param[in] columnName The column to be reduced. If omitted, the first default column is used instead.
 /// \return the reduced quantity wrapped in a ROOT::RDF:RResultPtr.
 ///
 /// A reduction takes two values of a column and merges them into one (e.g.
 /// by summing them, taking the maximum, etc). This action performs the
 /// specified reduction operation on all processed column values, returning
 /// a single value of the same type. The callable f must satisfy the general
 /// requirements of a *processing function* besides having signature `T(T,T)`
 /// where `T` is the type of column columnName.
 ///
 /// The returned reduced value of each thread (e.g. the initial value of a sum) is initialized to a
 /// default-constructed T object. This is commonly expected to be the neutral/identity element for the specific
 /// reduction operation `f` (e.g. 0 for a sum, 1 for a product). If a default-constructed T does not satisfy this
 /// requirement, users should explicitly specify an initialization value for T by calling the appropriate `Reduce`
 /// overload.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// auto sumOfIntCol = d.Reduce([](int x, int y) { return x + y; }, "intCol");
 /// ~~~
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 // clang-format on
 template <typename F, typename T = typename TTraits::CallableTraits<F>::ret_type>
 RResultPtr<T> Reduce(F f, std::string_view columnName = "")
 {
    static_assert(
       std::is_default_constructible<T>::value,
       "reduce object cannot be default-constructed. Please provide an initialisation value (redIdentity)");
    return Reduce(std::move(f), columnName, T());
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Execute a user-defined reduce operation on the values of a column.
 /// \tparam F The type of the reduce callable. Automatically deduced.
 /// \tparam T The type of the column to apply the reduction to. Automatically deduced.
 /// \param[in] f A callable with signature `T(T,T)`
 /// \param[in] columnName The column to be reduced. If omitted, the first default column is used instead.
 /// \param[in] redIdentity The reduced object of each thread is initialized to this value.
 /// \return the reduced quantity wrapped in a RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// auto sumOfIntColWithOffset = d.Reduce([](int x, int y) { return x + y; }, "intCol", 42);
 /// ~~~
 /// See the description of the first Reduce overload for more information.
 template <typename F, typename T = typename TTraits::CallableTraits<F>::ret_type>
 RResultPtr<T> Reduce(F f, std::string_view columnName, const T &redIdentity)
 {
    return Aggregate(f, f, columnName, redIdentity);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Return the number of entries processed (*lazy action*).
 /// \return the number of entries wrapped in a RResultPtr.
 ///
 /// Useful e.g. for counting the number of entries passing a certain filter (see also `Report`).
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// auto nEntriesAfterCuts = myFilteredDf.Count();
 /// ~~~
 ///
 RResultPtr<ULong64_t> Count()
 {
    const auto nSlots = fLoopManager->GetNSlots();
    auto cSPtr = std::make_shared<ULong64_t>(0);
    using Helper_t = RDFInternal::CountHelper;
    using Action_t = RDFInternal::RAction<Helper_t, Proxied>;
    auto action = std::make_unique<Action_t>(Helper_t(cSPtr, nSlots), ColumnNames_t({}), fProxiedPtr,
                                             RDFInternal::RColumnRegister(fColRegister));
    return MakeResultPtr(cSPtr, *fLoopManager, std::move(action));
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Return a collection of values of a column (*lazy action*, returns a std::vector by default).
 /// \tparam T The type of the column.
 /// \tparam COLL The type of collection used to store the values.
 /// \param[in] column The name of the column to collect the values of.
 /// \return the content of the selected column wrapped in a RResultPtr.
 ///
 /// The collection type to be specified for C-style array columns is `RVec<T>`:
 /// in this case the returned collection is a `std::vector<RVec<T>>`.
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // In this case intCol is a std::vector<int>
 /// auto intCol = rdf.Take<int>("integerColumn");
 /// // Same content as above but in this case taken as a RVec<int>
 /// auto intColAsRVec = rdf.Take<int, RVec<int>>("integerColumn");
 /// // In this case intCol is a std::vector<RVec<int>>, a collection of collections
 /// auto cArrayIntCol = rdf.Take<RVec<int>>("cArrayInt");
 /// ~~~
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 template <typename T, typename COLL = std::vector<T>>
 RResultPtr<COLL> Take(std::string_view column = "")
 {
    const auto columns = column.empty() ? ColumnNames_t() : ColumnNames_t({std::string(column)});

    const auto validColumnNames = GetValidatedColumnNames(1, columns);
    CheckAndFillDSColumns(validColumnNames, TTraits::TypeList<T>());

    using Helper_t = RDFInternal::TakeHelper<T, T, COLL>;
    using Action_t = RDFInternal::RAction<Helper_t, Proxied>;
    auto valuesPtr = std::make_shared<COLL>();
    const auto nSlots = fLoopManager->GetNSlots();

    auto action =
       std::make_unique<Action_t>(Helper_t(valuesPtr, nSlots), validColumnNames, fProxiedPtr, fColRegister);
    return MakeResultPtr(valuesPtr, *fLoopManager, std::move(action));
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Fill and return a one-dimensional histogram with the values of a column (*lazy action*).
 /// \tparam V The type of the column used to fill the histogram.
 /// \param[in] model The returned histogram will be constructed using this as a model.
 /// \param[in] vName The name of the column that will fill the histogram.
 /// \return the monodimensional histogram wrapped in a RResultPtr.
 ///
 /// Columns can be of a container type (e.g. `std::vector<double>`), in which case the histogram
 /// is filled with each one of the elements of the container. In case multiple columns of container type
 /// are provided (e.g. values and weights) they must have the same length for each one of the events (but
 /// possibly different lengths between events).
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column type (this invocation needs jitting internally)
 /// auto myHist1 = myDf.Histo1D({"histName", "histTitle", 64u, 0., 128.}, "myColumn");
 /// // Explicit column type
 /// auto myHist2 = myDf.Histo1D<float>({"histName", "histTitle", 64u, 0., 128.}, "myColumn");
 /// ~~~
 ///
 /// \note Differently from other ROOT interfaces, the returned histogram is not associated to gDirectory
 /// and the caller is responsible for its lifetime (in particular, a typical source of confusion is that
 /// if result histograms go out of scope before the end of the program, ROOT might display a blank canvas).
 template <typename V = RDFDetail::RInferredType>
 RResultPtr<::TH1D> Histo1D(const TH1DModel &model = {"", "", 128u, 0., 0.}, std::string_view vName = "")
 {
    const auto userColumns = vName.empty() ? ColumnNames_t() : ColumnNames_t({std::string(vName)});

    const auto validatedColumns = GetValidatedColumnNames(1, userColumns);

    std::shared_ptr<::TH1D> h(nullptr);
    {
       ROOT::Internal::RDF::RIgnoreErrorLevelRAII iel(kError);
       h = model.GetHistogram();
       h->SetDirectory(nullptr);
    }

    if (h->GetXaxis()->GetXmax() == h->GetXaxis()->GetXmin())
       RDFInternal::HistoUtils<::TH1D>::SetCanExtendAllAxes(*h);
    return CreateAction<RDFInternal::ActionTags::Histo1D, V>(validatedColumns, h, h, fProxiedPtr);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Fill and return a one-dimensional histogram with the values of a column (*lazy action*).
 /// \tparam V The type of the column used to fill the histogram.
 /// \param[in] vName The name of the column that will fill the histogram.
 /// \return the monodimensional histogram wrapped in a RResultPtr.
 ///
 /// This overload uses a default model histogram TH1D(name, title, 128u, 0., 0.).
 /// The "name" and "title" strings are built starting from the input column name.
 /// See the description of the first Histo1D() overload for more details.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column type (this invocation needs jitting internally)
 /// auto myHist1 = myDf.Histo1D("myColumn");
 /// // Explicit column type
 /// auto myHist2 = myDf.Histo1D<float>("myColumn");
 /// ~~~
 template <typename V = RDFDetail::RInferredType>
 RResultPtr<::TH1D> Histo1D(std::string_view vName)
 {
    const auto h_name = std::string(vName);
    const auto h_title = h_name + ";" + h_name + ";count";
    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 weighted values of a column (*lazy action*).
 /// \tparam V The type of the column used to fill the histogram.
 /// \tparam W The type of the column used as weights.
 /// \param[in] model The returned histogram will be constructed using this as a model.
 /// \param[in] vName The name of the column that will fill the histogram.
 /// \param[in] wName The name of the column that will provide the weights.
 /// \return the monodimensional histogram wrapped in a RResultPtr.
 ///
 /// See the description of the first Histo1D() overload for more details.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column type (this invocation needs jitting internally)
 /// auto myHist1 = myDf.Histo1D({"histName", "histTitle", 64u, 0., 128.}, "myValue", "myweight");
 /// // Explicit column type
 /// auto myHist2 = myDf.Histo1D<float, int>({"histName", "histTitle", 64u, 0., 128.}, "myValue", "myweight");
 /// ~~~
 template <typename V = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>
 RResultPtr<::TH1D> Histo1D(const TH1DModel &model, std::string_view vName, std::string_view wName)
 {
    const std::vector<std::string_view> columnViews = {vName, wName};
    const auto userColumns = RDFInternal::AtLeastOneEmptyString(columnViews)
                                ? ColumnNames_t()
                                : ColumnNames_t(columnViews.begin(), columnViews.end());
    std::shared_ptr<::TH1D> h(nullptr);
    {
       ROOT::Internal::RDF::RIgnoreErrorLevelRAII iel(kError);
       h = model.GetHistogram();
    }
    return CreateAction<RDFInternal::ActionTags::Histo1D, V, W>(userColumns, 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.
 /// \tparam W The type of the column used as weights.
 /// \param[in] vName The name of the column that will fill the histogram.
 /// \param[in] wName The name of the column that will provide the weights.
 /// \return the monodimensional histogram wrapped in a RResultPtr.
 ///
 /// This overload uses a default model histogram TH1D(name, title, 128u, 0., 0.).
 /// The "name" and "title" strings are built starting from the input column names.
 /// See the description of the first Histo1D() overload for more details.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column types (this invocation needs jitting internally)
 /// auto myHist1 = myDf.Histo1D("myValue", "myweight");
 /// // Explicit column types
 /// auto myHist2 = myDf.Histo1D<float, int>("myValue", "myweight");
 /// ~~~
 template <typename V = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>
 RResultPtr<::TH1D> Histo1D(std::string_view vName, std::string_view wName)
 {
    // We build name and title based on the value and weight column names
    std::string str_vName{vName};
    std::string str_wName{wName};
    const auto h_name = str_vName + "_weighted_" + str_wName;
    const auto h_title = str_vName + ", weights: " + str_wName + ";" + str_vName + ";count * " + str_wName;
    return Histo1D<V, W>({h_name.c_str(), h_title.c_str(), 128u, 0., 0.}, vName, wName);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \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.
 /// \tparam W The type of the column used as weights.
 /// \param[in] model The returned histogram will be constructed using this as a model.
 /// \return the monodimensional histogram wrapped in a RResultPtr.
 ///
 /// This overload will use the first two default columns as column names.
 /// See the description of the first Histo1D() overload for more details.
 template <typename V, typename W>
 RResultPtr<::TH1D> Histo1D(const TH1DModel &model = {"", "", 128u, 0., 0.})
 {
    return Histo1D<V, W>(model, "", "");
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Fill and return a two-dimensional histogram (*lazy action*).
 /// \tparam V1 The type of the column used to fill the x axis of the histogram.
 /// \tparam V2 The type of the column used to fill the y axis of the histogram.
 /// \param[in] model The returned histogram will be constructed using this as a model.
 /// \param[in] v1Name The name of the column that will fill the x axis.
 /// \param[in] v2Name The name of the column that will fill the y axis.
 /// \return the bidimensional histogram wrapped in a RResultPtr.
 ///
 /// Columns can be of a container type (e.g. std::vector<double>), in which case the histogram
 /// is filled with each one of the elements of the container. In case multiple columns of container type
 /// are provided (e.g. values and weights) they must have the same length for each one of the events (but
 /// possibly different lengths between events).
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column types (this invocation needs jitting internally)
 /// auto myHist1 = myDf.Histo2D({"histName", "histTitle", 64u, 0., 128., 32u, -4., 4.}, "myValueX", "myValueY");
 /// // Explicit column types
 /// auto myHist2 = myDf.Histo2D<float, float>({"histName", "histTitle", 64u, 0., 128., 32u, -4., 4.}, "myValueX", "myValueY");
 /// ~~~
 ///
 ///
 /// \note Differently from other ROOT interfaces, the returned histogram is not associated to gDirectory
 /// and the caller is responsible for its lifetime (in particular, a typical source of confusion is that
 /// if result histograms go out of scope before the end of the program, ROOT might display a blank canvas).
 template <typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType>
 RResultPtr<::TH2D> Histo2D(const TH2DModel &model, std::string_view v1Name = "", std::string_view v2Name = "")
 {
    std::shared_ptr<::TH2D> h(nullptr);
    {
       ROOT::Internal::RDF::RIgnoreErrorLevelRAII iel(kError);
       h = model.GetHistogram();
    }
    if (!RDFInternal::HistoUtils<::TH2D>::HasAxisLimits(*h)) {
       throw std::runtime_error("2D histograms with no axes limits are not supported yet.");
    }
    const std::vector<std::string_view> columnViews = {v1Name, v2Name};
    const auto userColumns = RDFInternal::AtLeastOneEmptyString(columnViews)
                                ? ColumnNames_t()
                                : ColumnNames_t(columnViews.begin(), columnViews.end());
    return CreateAction<RDFInternal::ActionTags::Histo2D, V1, V2>(userColumns, h, h, fProxiedPtr);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Fill and return a weighted two-dimensional histogram (*lazy action*).
 /// \tparam V1 The type of the column used to fill the x axis of the histogram.
 /// \tparam V2 The type of the column used to fill the y axis of the histogram.
 /// \tparam W The type of the column used for the weights of the histogram.
 /// \param[in] model The returned histogram will be constructed using this as a model.
 /// \param[in] v1Name The name of the column that will fill the x axis.
 /// \param[in] v2Name The name of the column that will fill the y axis.
 /// \param[in] wName The name of the column that will provide the weights.
 /// \return the bidimensional histogram wrapped in a RResultPtr.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column types (this invocation needs jitting internally)
 /// auto myHist1 = myDf.Histo2D({"histName", "histTitle", 64u, 0., 128., 32u, -4., 4.}, "myValueX", "myValueY", "myWeight");
 /// // Explicit column types
 /// auto myHist2 = myDf.Histo2D<float, float, double>({"histName", "histTitle", 64u, 0., 128., 32u, -4., 4.}, "myValueX", "myValueY", "myWeight");
 /// ~~~
 ///
 /// See the documentation of the first Histo2D() overload for more details.
 template <typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType,
           typename W = RDFDetail::RInferredType>
 RResultPtr<::TH2D>
 Histo2D(const TH2DModel &model, std::string_view v1Name, std::string_view v2Name, std::string_view wName)
 {
    std::shared_ptr<::TH2D> h(nullptr);
    {
       ROOT::Internal::RDF::RIgnoreErrorLevelRAII iel(kError);
       h = model.GetHistogram();
    }
    if (!RDFInternal::HistoUtils<::TH2D>::HasAxisLimits(*h)) {
       throw std::runtime_error("2D histograms with no axes limits are not supported yet.");
    }
    const std::vector<std::string_view> columnViews = {v1Name, v2Name, wName};
    const auto userColumns = RDFInternal::AtLeastOneEmptyString(columnViews)
                                ? ColumnNames_t()
                                : ColumnNames_t(columnViews.begin(), columnViews.end());
    return CreateAction<RDFInternal::ActionTags::Histo2D, V1, V2, W>(userColumns, h, h, fProxiedPtr);
 }

 template <typename V1, typename V2, typename W>
 RResultPtr<::TH2D> Histo2D(const TH2DModel &model)
 {
    return Histo2D<V1, V2, W>(model, "", "", "");
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Fill and return a three-dimensional histogram (*lazy action*).
 /// \tparam V1 The type of the column used to fill the x axis of the histogram. Inferred if not present.
 /// \tparam V2 The type of the column used to fill the y axis of the histogram. Inferred if not present.
 /// \tparam V3 The type of the column used to fill the z axis of the histogram. Inferred if not present.
 /// \param[in] model The returned histogram will be constructed using this as a model.
 /// \param[in] v1Name The name of the column that will fill the x axis.
 /// \param[in] v2Name The name of the column that will fill the y axis.
 /// \param[in] v3Name The name of the column that will fill the z axis.
 /// \return the tridimensional histogram wrapped in a RResultPtr.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column types (this invocation needs jitting internally)
 /// auto myHist1 = myDf.Histo3D({"name", "title", 64u, 0., 128., 32u, -4., 4., 8u, -2., 2.},
 ///                             "myValueX", "myValueY", "myValueZ");
 /// // Explicit column types
 /// auto myHist2 = myDf.Histo3D<double, double, float>({"name", "title", 64u, 0., 128., 32u, -4., 4., 8u, -2., 2.},
 ///                                                    "myValueX", "myValueY", "myValueZ");
 /// ~~~
 ///
 /// \note Differently from other ROOT interfaces, the returned histogram is not associated to gDirectory
 /// and the caller is responsible for its lifetime (in particular, a typical source of confusion is that
 /// if result histograms go out of scope before the end of the program, ROOT might display a blank canvas).
 template <typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType,
           typename V3 = RDFDetail::RInferredType>
 RResultPtr<::TH3D> Histo3D(const TH3DModel &model, std::string_view v1Name = "", std::string_view v2Name = "",
                            std::string_view v3Name = "")
 {
    std::shared_ptr<::TH3D> h(nullptr);
    {
       ROOT::Internal::RDF::RIgnoreErrorLevelRAII iel(kError);
       h = model.GetHistogram();
    }
    if (!RDFInternal::HistoUtils<::TH3D>::HasAxisLimits(*h)) {
       throw std::runtime_error("3D histograms with no axes limits are not supported yet.");
    }
    const std::vector<std::string_view> columnViews = {v1Name, v2Name, v3Name};
    const auto userColumns = RDFInternal::AtLeastOneEmptyString(columnViews)
                                ? ColumnNames_t()
                                : ColumnNames_t(columnViews.begin(), columnViews.end());
    return CreateAction<RDFInternal::ActionTags::Histo3D, V1, V2, V3>(userColumns, h, h, fProxiedPtr);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Fill and return a three-dimensional histogram (*lazy action*).
 /// \tparam V1 The type of the column used to fill the x axis of the histogram. Inferred if not present.
 /// \tparam V2 The type of the column used to fill the y axis of the histogram. Inferred if not present.
 /// \tparam V3 The type of the column used to fill the z axis of the histogram. Inferred if not present.
 /// \tparam W The type of the column used for the weights of the histogram. Inferred if not present.
 /// \param[in] model The returned histogram will be constructed using this as a model.
 /// \param[in] v1Name The name of the column that will fill the x axis.
 /// \param[in] v2Name The name of the column that will fill the y axis.
 /// \param[in] v3Name The name of the column that will fill the z axis.
 /// \param[in] wName The name of the column that will provide the weights.
 /// \return the tridimensional histogram wrapped in a RResultPtr.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column types (this invocation needs jitting internally)
 /// auto myHist1 = myDf.Histo3D({"name", "title", 64u, 0., 128., 32u, -4., 4., 8u, -2., 2.},
 ///                             "myValueX", "myValueY", "myValueZ", "myWeight");
 /// // Explicit column types
 /// using d_t = double;
 /// auto myHist2 = myDf.Histo3D<d_t, d_t, float, d_t>({"name", "title", 64u, 0., 128., 32u, -4., 4., 8u, -2., 2.},
 ///                                                    "myValueX", "myValueY", "myValueZ", "myWeight");
 /// ~~~
 ///
 ///
 /// See the documentation of the first Histo2D() overload for more details.
 template <typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType,
           typename V3 = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>
 RResultPtr<::TH3D> Histo3D(const TH3DModel &model, std::string_view v1Name, std::string_view v2Name,
                            std::string_view v3Name, std::string_view wName)
 {
    std::shared_ptr<::TH3D> h(nullptr);
    {
       ROOT::Internal::RDF::RIgnoreErrorLevelRAII iel(kError);
       h = model.GetHistogram();
    }
    if (!RDFInternal::HistoUtils<::TH3D>::HasAxisLimits(*h)) {
       throw std::runtime_error("3D histograms with no axes limits are not supported yet.");
    }
    const std::vector<std::string_view> columnViews = {v1Name, v2Name, v3Name, wName};
    const auto userColumns = RDFInternal::AtLeastOneEmptyString(columnViews)
                                ? ColumnNames_t()
                                : ColumnNames_t(columnViews.begin(), columnViews.end());
    return CreateAction<RDFInternal::ActionTags::Histo3D, V1, V2, V3, W>(userColumns, h, h, fProxiedPtr);
 }

 template <typename V1, typename V2, typename V3, typename W>
 RResultPtr<::TH3D> Histo3D(const TH3DModel &model)
 {
    return Histo3D<V1, V2, V3, W>(model, "", "", "", "");
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Fill and return an N-dimensional histogram (*lazy action*).
 /// \tparam FirstColumn The first type of the column the values of which are used to fill the object. Inferred if not
 /// present.
 /// \tparam OtherColumns A list of the other types of the columns the values of which are used to fill the
 /// object.
 /// \param[in] model The returned histogram will be constructed using this as a model.
 /// \param[in] columnList
 /// A list containing the names of the columns that will be passed when calling `Fill`.
 ///  (N columns for unweighted filling, or N+1 columns for weighted filling)
 /// \return the N-dimensional histogram wrapped in a RResultPtr.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. See RResultPtr documentation.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// auto myFilledObj = myDf.HistoND<float, float, float, float>({"name","title", 4,
 ///                                                {40,40,40,40}, {20.,20.,20.,20.}, {60.,60.,60.,60.}},
 ///                                               {"col0", "col1", "col2", "col3"});
 /// ~~~
 ///
 template <typename FirstColumn, typename... OtherColumns> // need FirstColumn to disambiguate overloads
 RResultPtr<::THnD> HistoND(const THnDModel &model, const ColumnNames_t &columnList)
 {
    std::shared_ptr<::THnD> h(nullptr);
    {
       ROOT::Internal::RDF::RIgnoreErrorLevelRAII iel(kError);
       h = model.GetHistogram();

       if (int(columnList.size()) == (h->GetNdimensions() + 1)) {
          h->Sumw2();
       } else if (int(columnList.size()) != h->GetNdimensions()) {
          throw std::runtime_error("Wrong number of columns for the specified number of histogram axes.");
       }
    }
    return CreateAction<RDFInternal::ActionTags::HistoND, FirstColumn, OtherColumns...>(columnList, h, h,
                                                                                        fProxiedPtr);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Fill and return an N-dimensional histogram (*lazy action*).
 /// \param[in] model The returned histogram will be constructed using this as a model.
 /// \param[in] columnList A list containing the names of the columns that will be passed when calling `Fill`
 ///  (N columns for unweighted filling, or N+1 columns for weighted filling)
 /// \return the N-dimensional histogram wrapped in a RResultPtr.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// auto myFilledObj = myDf.HistoND({"name","title", 4,
 ///                                                {40,40,40,40}, {20.,20.,20.,20.}, {60.,60.,60.,60.}},
 ///                                               {"col0", "col1", "col2", "col3"});
 /// ~~~
 ///
 RResultPtr<::THnD> HistoND(const THnDModel &model, const ColumnNames_t &columnList)
 {
    std::shared_ptr<::THnD> h(nullptr);
    {
       ROOT::Internal::RDF::RIgnoreErrorLevelRAII iel(kError);
       h = model.GetHistogram();

       if (int(columnList.size()) == (h->GetNdimensions() + 1)) {
          h->Sumw2();
       } else if (int(columnList.size()) != h->GetNdimensions()) {
          throw std::runtime_error("Wrong number of columns for the specified number of histogram axes.");
       }
    }
    return CreateAction<RDFInternal::ActionTags::HistoND, RDFDetail::RInferredType>(columnList, h, h, fProxiedPtr,
                                                                                    columnList.size());
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Fill and return a TGraph object (*lazy action*).
 /// \tparam X The type of the column used to fill the x axis.
 /// \tparam Y The type of the column used to fill the y axis.
 /// \param[in] x The name of the column that will fill the x axis.
 /// \param[in] y The name of the column that will fill the y axis.
 /// \return the TGraph wrapped in a RResultPtr.
 ///
 /// Columns can be of a container type (e.g. std::vector<double>), in which case the TGraph
 /// is filled with each one of the elements of the container.
 /// If Multithreading is enabled, the order in which points are inserted is undefined.
 /// If the Graph has to be drawn, it is suggested to the user to sort it on the x before printing.
 /// A name and a title to the TGraph is given based on the input column names.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column types (this invocation needs jitting internally)
 /// auto myGraph1 = myDf.Graph("xValues", "yValues");
 /// // Explicit column types
 /// auto myGraph2 = myDf.Graph<int, float>("xValues", "yValues");
 /// ~~~
 ///
 /// \note Differently from other ROOT interfaces, the returned TGraph is not associated to gDirectory
 /// and the caller is responsible for its lifetime (in particular, a typical source of confusion is that
 /// if result histograms go out of scope before the end of the program, ROOT might display a blank canvas).
 template <typename X = RDFDetail::RInferredType, typename Y = RDFDetail::RInferredType>
 RResultPtr<::TGraph> Graph(std::string_view x = "", std::string_view y = "")
 {
    auto graph = std::make_shared<::TGraph>();
    const std::vector<std::string_view> columnViews = {x, y};
    const auto userColumns = RDFInternal::AtLeastOneEmptyString(columnViews)
                                ? ColumnNames_t()
                                : ColumnNames_t(columnViews.begin(), columnViews.end());

    const auto validatedColumns = GetValidatedColumnNames(2, userColumns);

    // We build a default name and title based on the input columns
    const auto g_name = validatedColumns[1] + "_vs_" + validatedColumns[0];
    const auto g_title = validatedColumns[1] + " vs " + validatedColumns[0];
    graph->SetNameTitle(g_name.c_str(), g_title.c_str());
    graph->GetXaxis()->SetTitle(validatedColumns[0].c_str());
    graph->GetYaxis()->SetTitle(validatedColumns[1].c_str());

    return CreateAction<RDFInternal::ActionTags::Graph, X, Y>(validatedColumns, graph, graph, fProxiedPtr);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Fill and return a TGraphAsymmErrors object (*lazy action*).
 /// \param[in] x The name of the column that will fill the x axis.
 /// \param[in] y The name of the column that will fill the y axis.
 /// \param[in] exl The name of the column of X low errors
 /// \param[in] exh The name of the column of X high errors
 /// \param[in] eyl The name of the column of Y low errors
 /// \param[in] eyh The name of the column of Y high errors
 /// \return the TGraphAsymmErrors wrapped in a RResultPtr.
 ///
 /// Columns can be of a container type (e.g. std::vector<double>), in which case the graph
 /// is filled with each one of the elements of the container.
 /// If Multithreading is enabled, the order in which points are inserted is undefined.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column types (this invocation needs jitting internally)
 /// auto myGAE1 = myDf.GraphAsymmErrors("xValues", "yValues", "exl", "exh", "eyl", "eyh");
 /// // Explicit column types
 /// using f = float
 /// auto myGAE2 = myDf.GraphAsymmErrors<f, f, f, f, f, f>("xValues", "yValues", "exl", "exh", "eyl", "eyh");
 /// ~~~
 ///
 /// `GraphAssymErrors` should also be used for the cases in which values associated only with 
 /// one of the axes have associated errors. For example, only `ey` exist and `ex` are equal to zero. 
 /// In such cases, user should do the following: 
 /// ~~~{.cpp}
 /// // Create a column of zeros in RDataFrame
 /// auto rdf_withzeros = rdf.Define("zero", "0"); 
 /// // or alternatively: 
 /// auto rdf_withzeros = rdf.Define("zero", []() -> double { return 0.;});
 /// // Create the graph with y errors only
 /// auto rdf_errorsOnYOnly = rdf_withzeros.GraphAsymmErrors("xValues", "yValues", "zero", "zero", "eyl", "eyh");
 /// ~~~
 ///
 /// \note Differently from other ROOT interfaces, the returned TGraphAsymmErrors is not associated to gDirectory
 /// and the caller is responsible for its lifetime (in particular, a typical source of confusion is that
 /// if result histograms go out of scope before the end of the program, ROOT might display a blank canvas).
 template <typename X = RDFDetail::RInferredType, typename Y = RDFDetail::RInferredType,
           typename EXL = RDFDetail::RInferredType, typename EXH = RDFDetail::RInferredType,
           typename EYL = RDFDetail::RInferredType, typename EYH = RDFDetail::RInferredType>
 RResultPtr<::TGraphAsymmErrors>
 GraphAsymmErrors(std::string_view x = "", std::string_view y = "", std::string_view exl = "",
                  std::string_view exh = "", std::string_view eyl = "", std::string_view eyh = "")
 {
    auto graph = std::make_shared<::TGraphAsymmErrors>();
    const std::vector<std::string_view> columnViews = {x, y, exl, exh, eyl, eyh};
    const auto userColumns = RDFInternal::AtLeastOneEmptyString(columnViews)
                                ? ColumnNames_t()
                                : ColumnNames_t(columnViews.begin(), columnViews.end());

    const auto validatedColumns = GetValidatedColumnNames(6, userColumns);

    // We build a default name and title based on the input columns
    const auto g_name = validatedColumns[1] + "_vs_" + validatedColumns[0];
    const auto g_title = validatedColumns[1] + " vs " + validatedColumns[0];
    graph->SetNameTitle(g_name.c_str(), g_title.c_str());
    graph->GetXaxis()->SetTitle(validatedColumns[0].c_str());
    graph->GetYaxis()->SetTitle(validatedColumns[1].c_str());

    return CreateAction<RDFInternal::ActionTags::GraphAsymmErrors, X, Y, EXL, EXH, EYL, EYH>(validatedColumns, graph,
                                                                                             graph, fProxiedPtr);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Fill and return a one-dimensional profile (*lazy action*).
 /// \tparam V1 The type of the column the values of which are used to fill the profile. Inferred if not present.
 /// \tparam V2 The type of the column the values of which are used to fill the profile. Inferred if not present.
 /// \param[in] model The model to be considered to build the new return value.
 /// \param[in] v1Name The name of the column that will fill the x axis.
 /// \param[in] v2Name The name of the column that will fill the y axis.
 /// \return the monodimensional profile wrapped in a RResultPtr.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column types (this invocation needs jitting internally)
 /// auto myProf1 = myDf.Profile1D({"profName", "profTitle", 64u, -4., 4.}, "xValues", "yValues");
 /// // Explicit column types
 /// auto myProf2 = myDf.Graph<int, float>({"profName", "profTitle", 64u, -4., 4.}, "xValues", "yValues");
 /// ~~~
 ///
 /// \note Differently from other ROOT interfaces, the returned profile is not associated to gDirectory
 /// and the caller is responsible for its lifetime (in particular, a typical source of confusion is that
 /// if result histograms go out of scope before the end of the program, ROOT might display a blank canvas).
 template <typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType>
 RResultPtr<::TProfile>
 Profile1D(const TProfile1DModel &model, std::string_view v1Name = "", std::string_view v2Name = "")
 {
    std::shared_ptr<::TProfile> h(nullptr);
    {
       ROOT::Internal::RDF::RIgnoreErrorLevelRAII iel(kError);
       h = model.GetProfile();
    }

    if (!RDFInternal::HistoUtils<::TProfile>::HasAxisLimits(*h)) {
       throw std::runtime_error("Profiles with no axes limits are not supported yet.");
    }
    const std::vector<std::string_view> columnViews = {v1Name, v2Name};
    const auto userColumns = RDFInternal::AtLeastOneEmptyString(columnViews)
                                ? ColumnNames_t()
                                : ColumnNames_t(columnViews.begin(), columnViews.end());
    return CreateAction<RDFInternal::ActionTags::Profile1D, V1, V2>(userColumns, h, h, fProxiedPtr);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Fill and return a one-dimensional profile (*lazy action*).
 /// \tparam V1 The type of the column the values of which are used to fill the profile. Inferred if not present.
 /// \tparam V2 The type of the column the values of which are used to fill the profile. Inferred if not present.
 /// \tparam W The type of the column the weights of which are used to fill the profile. Inferred if not present.
 /// \param[in] model The model to be considered to build the new return value.
 /// \param[in] v1Name The name of the column that will fill the x axis.
 /// \param[in] v2Name The name of the column that will fill the y axis.
 /// \param[in] wName The name of the column that will provide the weights.
 /// \return the monodimensional profile wrapped in a RResultPtr.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column types (this invocation needs jitting internally)
 /// auto myProf1 = myDf.Profile1D({"profName", "profTitle", 64u, -4., 4.}, "xValues", "yValues", "weight");
 /// // Explicit column types
 /// auto myProf2 = myDf.Profile1D<int, float, double>({"profName", "profTitle", 64u, -4., 4.},
 ///                                                   "xValues", "yValues", "weight");
 /// ~~~
 ///
 /// See the first Profile1D() overload for more details.
 template <typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType,
           typename W = RDFDetail::RInferredType>
 RResultPtr<::TProfile>
 Profile1D(const TProfile1DModel &model, std::string_view v1Name, std::string_view v2Name, std::string_view wName)
 {
    std::shared_ptr<::TProfile> h(nullptr);
    {
       ROOT::Internal::RDF::RIgnoreErrorLevelRAII iel(kError);
       h = model.GetProfile();
    }

    if (!RDFInternal::HistoUtils<::TProfile>::HasAxisLimits(*h)) {
       throw std::runtime_error("Profile histograms with no axes limits are not supported yet.");
    }
    const std::vector<std::string_view> columnViews = {v1Name, v2Name, wName};
    const auto userColumns = RDFInternal::AtLeastOneEmptyString(columnViews)
                                ? ColumnNames_t()
                                : ColumnNames_t(columnViews.begin(), columnViews.end());
    return CreateAction<RDFInternal::ActionTags::Profile1D, V1, V2, W>(userColumns, h, h, fProxiedPtr);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Fill and return a one-dimensional profile (*lazy action*).
 /// See the first Profile1D() overload for more details.
 template <typename V1, typename V2, typename W>
 RResultPtr<::TProfile> Profile1D(const TProfile1DModel &model)
 {
    return Profile1D<V1, V2, W>(model, "", "", "");
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Fill and return a two-dimensional profile (*lazy action*).
 /// \tparam V1 The type of the column used to fill the x axis of the histogram. Inferred if not present.
 /// \tparam V2 The type of the column used to fill the y axis of the histogram. Inferred if not present.
 /// \tparam V3 The type of the column used to fill the z axis of the histogram. Inferred if not present.
 /// \param[in] model The returned profile will be constructed using this as a model.
 /// \param[in] v1Name The name of the column that will fill the x axis.
 /// \param[in] v2Name The name of the column that will fill the y axis.
 /// \param[in] v3Name The name of the column that will fill the z axis.
 /// \return the bidimensional profile wrapped in a RResultPtr.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column types (this invocation needs jitting internally)
 /// auto myProf1 = myDf.Profile2D({"profName", "profTitle", 40, -4, 4, 40, -4, 4, 0, 20},
 ///                               "xValues", "yValues", "zValues");
 /// // Explicit column types
 /// auto myProf2 = myDf.Profile2D<int, float, double>({"profName", "profTitle", 40, -4, 4, 40, -4, 4, 0, 20},
 ///                                                   "xValues", "yValues", "zValues");
 /// ~~~
 ///
 /// \note Differently from other ROOT interfaces, the returned profile is not associated to gDirectory
 /// and the caller is responsible for its lifetime (in particular, a typical source of confusion is that
 /// if result histograms go out of scope before the end of the program, ROOT might display a blank canvas).
 template <typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType,
           typename V3 = RDFDetail::RInferredType>
 RResultPtr<::TProfile2D> Profile2D(const TProfile2DModel &model, std::string_view v1Name = "",
                                    std::string_view v2Name = "", std::string_view v3Name = "")
 {
    std::shared_ptr<::TProfile2D> h(nullptr);
    {
       ROOT::Internal::RDF::RIgnoreErrorLevelRAII iel(kError);
       h = model.GetProfile();
    }

    if (!RDFInternal::HistoUtils<::TProfile2D>::HasAxisLimits(*h)) {
       throw std::runtime_error("2D profiles with no axes limits are not supported yet.");
    }
    const std::vector<std::string_view> columnViews = {v1Name, v2Name, v3Name};
    const auto userColumns = RDFInternal::AtLeastOneEmptyString(columnViews)
                                ? ColumnNames_t()
                                : ColumnNames_t(columnViews.begin(), columnViews.end());
    return CreateAction<RDFInternal::ActionTags::Profile2D, V1, V2, V3>(userColumns, h, h, fProxiedPtr);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Fill and return a two-dimensional profile (*lazy action*).
 /// \tparam V1 The type of the column used to fill the x axis of the histogram. Inferred if not present.
 /// \tparam V2 The type of the column used to fill the y axis of the histogram. Inferred if not present.
 /// \tparam V3 The type of the column used to fill the z axis of the histogram. Inferred if not present.
 /// \tparam W The type of the column used for the weights of the histogram. Inferred if not present.
 /// \param[in] model The returned histogram will be constructed using this as a model.
 /// \param[in] v1Name The name of the column that will fill the x axis.
 /// \param[in] v2Name The name of the column that will fill the y axis.
 /// \param[in] v3Name The name of the column that will fill the z axis.
 /// \param[in] wName The name of the column that will provide the weights.
 /// \return the bidimensional profile wrapped in a RResultPtr.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column types (this invocation needs jitting internally)
 /// auto myProf1 = myDf.Profile2D({"profName", "profTitle", 40, -4, 4, 40, -4, 4, 0, 20},
 ///                               "xValues", "yValues", "zValues", "weight");
 /// // Explicit column types
 /// auto myProf2 = myDf.Profile2D<int, float, double, int>({"profName", "profTitle", 40, -4, 4, 40, -4, 4, 0, 20},
 ///                                                        "xValues", "yValues", "zValues", "weight");
 /// ~~~
 ///
 /// See the first Profile2D() overload for more details.
 template <typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType,
           typename V3 = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>
 RResultPtr<::TProfile2D> Profile2D(const TProfile2DModel &model, std::string_view v1Name, std::string_view v2Name,
                                    std::string_view v3Name, std::string_view wName)
 {
    std::shared_ptr<::TProfile2D> h(nullptr);
    {
       ROOT::Internal::RDF::RIgnoreErrorLevelRAII iel(kError);
       h = model.GetProfile();
    }

    if (!RDFInternal::HistoUtils<::TProfile2D>::HasAxisLimits(*h)) {
       throw std::runtime_error("2D profiles with no axes limits are not supported yet.");
    }
    const std::vector<std::string_view> columnViews = {v1Name, v2Name, v3Name, wName};
    const auto userColumns = RDFInternal::AtLeastOneEmptyString(columnViews)
                                ? ColumnNames_t()
                                : ColumnNames_t(columnViews.begin(), columnViews.end());
    return CreateAction<RDFInternal::ActionTags::Profile2D, V1, V2, V3, W>(userColumns, h, h, fProxiedPtr);
 }

 /// \brief Fill and return a two-dimensional profile (*lazy action*).
 /// See the first Profile2D() overload for more details.
 template <typename V1, typename V2, typename V3, typename W>
 RResultPtr<::TProfile2D> Profile2D(const TProfile2DModel &model)
 {
    return Profile2D<V1, V2, V3, W>(model, "", "", "", "");
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Return an object of type T on which `T::Fill` will be called once per event (*lazy action*).
 ///
 /// Type T must provide at least:
 /// - a copy-constructor
 /// - a `Fill` method that accepts as many arguments and with same types as the column names passed as columnList
 ///   (these types can also be passed as template parameters to this method)
 /// - a `Merge` method with signature `Merge(TCollection *)` or `Merge(const std::vector<T *>&)` that merges the
 ///   objects passed as argument into the object on which `Merge` was called (an analogous of TH1::Merge). Note that
 ///   if the signature that takes a `TCollection*` is used, then T must inherit from TObject (to allow insertion in
 ///   the TCollection*).
 ///
 /// \tparam FirstColumn The first type of the column the values of which are used to fill the object. Inferred together with OtherColumns if not present.
 /// \tparam OtherColumns A list of the other types of the columns the values of which are used to fill the object.
 /// \tparam T The type of the object to fill. Automatically deduced.
 /// \param[in] model The model to be considered to build the new return value.
 /// \param[in] columnList A list containing the names of the columns that will be passed when calling `Fill`
 /// \return the filled object wrapped in a RResultPtr.
 ///
 /// The user gives up ownership of the model object.
 /// The list of column names to be used for filling must always be specified.
 /// This action is *lazy*: upon invocation of this method the calculation is booked but not executed.
 /// Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// MyClass obj;
 /// // Deduce column types (this invocation needs jitting internally, and in this case
 /// // MyClass needs to be known to the interpreter)
 /// auto myFilledObj = myDf.Fill(obj, {"col0", "col1"});
 /// // explicit column types
 /// auto myFilledObj = myDf.Fill<float, float>(obj, {"col0", "col1"});
 /// ~~~
 ///
 template <typename FirstColumn = RDFDetail::RInferredType, typename... OtherColumns, typename T>
 RResultPtr<std::decay_t<T>> Fill(T &&model, const ColumnNames_t &columnList)
 {
    auto h = std::make_shared<std::decay_t<T>>(std::forward<T>(model));
    if (!RDFInternal::HistoUtils<T>::HasAxisLimits(*h)) {
       throw std::runtime_error("The absence of axes limits is not supported yet.");
    }
    return CreateAction<RDFInternal::ActionTags::Fill, FirstColumn, OtherColumns...>(columnList, h, h, fProxiedPtr,
                                                                                     columnList.size());
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Return a TStatistic object, filled once per event (*lazy action*).
 ///
 /// \tparam V The type of the value column
 /// \param[in] value The name of the column with the values to fill the statistics with.
 /// \return the filled TStatistic object wrapped in a RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column type (this invocation needs jitting internally)
 /// auto stats0 = myDf.Stats("values");
 /// // Explicit column type
 /// auto stats1 = myDf.Stats<float>("values");
 /// ~~~
 ///
 template <typename V = RDFDetail::RInferredType>
 RResultPtr<TStatistic> Stats(std::string_view value = "")
 {
    ColumnNames_t columns;
    if (!value.empty()) {
       columns.emplace_back(std::string(value));
    }
    const auto validColumnNames = GetValidatedColumnNames(1, columns);
    if (std::is_same<V, RDFDetail::RInferredType>::value) {
       return Fill(TStatistic(), validColumnNames);
    } else {
       return Fill<V>(TStatistic(), validColumnNames);
    }
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Return a TStatistic object, filled once per event (*lazy action*).
 ///
 /// \tparam V The type of the value column
 /// \tparam W The type of the weight column
 /// \param[in] value The name of the column with the values to fill the statistics with.
 /// \param[in] weight The name of the column with the weights to fill the statistics with.
 /// \return the filled TStatistic object wrapped in a RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column types (this invocation needs jitting internally)
 /// auto stats0 = myDf.Stats("values", "weights");
 /// // Explicit column types
 /// auto stats1 = myDf.Stats<int, float>("values", "weights");
 /// ~~~
 ///
 template <typename V = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>
 RResultPtr<TStatistic> Stats(std::string_view value, std::string_view weight)
 {
    ColumnNames_t columns{std::string(value), std::string(weight)};
    constexpr auto vIsInferred = std::is_same<V, RDFDetail::RInferredType>::value;
    constexpr auto wIsInferred = std::is_same<W, RDFDetail::RInferredType>::value;
    const auto validColumnNames = GetValidatedColumnNames(2, columns);
    // We have 3 cases:
    // 1. Both types are inferred: we use Fill and let the jit kick in.
    // 2. One of the two types is explicit and the other one is inferred: the case is not supported.
    // 3. Both types are explicit: we invoke the fully compiled Fill method.
    if (vIsInferred && wIsInferred) {
       return Fill(TStatistic(), validColumnNames);
    } else if (vIsInferred != wIsInferred) {
       std::string error("The ");
       error += vIsInferred ? "value " : "weight ";
       error += "column type is explicit, while the ";
       error += vIsInferred ? "weight " : "value ";
       error += " is specified to be inferred. This case is not supported: please specify both types or none.";
       throw std::runtime_error(error);
    } else {
       return Fill<V, W>(TStatistic(), validColumnNames);
    }
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Return the minimum of processed column values (*lazy action*).
 /// \tparam T The type of the branch/column.
 /// \param[in] columnName The name of the branch/column to be treated.
 /// \return the minimum value of the selected column wrapped in a RResultPtr.
 ///
 /// If T is not specified, RDataFrame will infer it from the data and just-in-time compile the correct
 /// template specialization of this method.
 /// If the type of the column is inferred, the return type is `double`, the type of the column otherwise.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column type (this invocation needs jitting internally)
 /// auto minVal0 = myDf.Min("values");
 /// // Explicit column type
 /// auto minVal1 = myDf.Min<double>("values");
 /// ~~~
 ///
 template <typename T = RDFDetail::RInferredType>
 RResultPtr<RDFDetail::MinReturnType_t<T>> Min(std::string_view columnName = "")
 {
    const auto userColumns = columnName.empty() ? ColumnNames_t() : ColumnNames_t({std::string(columnName)});
    using RetType_t = RDFDetail::MinReturnType_t<T>;
    auto minV = std::make_shared<RetType_t>(std::numeric_limits<RetType_t>::max());
    return CreateAction<RDFInternal::ActionTags::Min, T>(userColumns, minV, minV, fProxiedPtr);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Return the maximum of processed column values (*lazy action*).
 /// \tparam T The type of the branch/column.
 /// \param[in] columnName The name of the branch/column to be treated.
 /// \return the maximum value of the selected column wrapped in a RResultPtr.
 ///
 /// If T is not specified, RDataFrame will infer it from the data and just-in-time compile the correct
 /// template specialization of this method.
 /// If the type of the column is inferred, the return type is `double`, the type of the column otherwise.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column type (this invocation needs jitting internally)
 /// auto maxVal0 = myDf.Max("values");
 /// // Explicit column type
 /// auto maxVal1 = myDf.Max<double>("values");
 /// ~~~
 ///
 template <typename T = RDFDetail::RInferredType>
 RResultPtr<RDFDetail::MaxReturnType_t<T>> Max(std::string_view columnName = "")
 {
    const auto userColumns = columnName.empty() ? ColumnNames_t() : ColumnNames_t({std::string(columnName)});
    using RetType_t = RDFDetail::MaxReturnType_t<T>;
    auto maxV = std::make_shared<RetType_t>(std::numeric_limits<RetType_t>::lowest());
    return CreateAction<RDFInternal::ActionTags::Max, T>(userColumns, maxV, maxV, fProxiedPtr);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Return the mean of processed column values (*lazy action*).
 /// \tparam T The type of the branch/column.
 /// \param[in] columnName The name of the branch/column to be treated.
 /// \return the mean value of the selected column wrapped in a RResultPtr.
 ///
 /// If T is not specified, RDataFrame will infer it from the data and just-in-time compile the correct
 /// template specialization of this method.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column type (this invocation needs jitting internally)
 /// auto meanVal0 = myDf.Mean("values");
 /// // Explicit column type
 /// auto meanVal1 = myDf.Mean<double>("values");
 /// ~~~
 ///
 template <typename T = RDFDetail::RInferredType>
 RResultPtr<double> Mean(std::string_view columnName = "")
 {
    const auto userColumns = columnName.empty() ? ColumnNames_t() : ColumnNames_t({std::string(columnName)});
    auto meanV = std::make_shared<double>(0);
    return CreateAction<RDFInternal::ActionTags::Mean, T>(userColumns, meanV, meanV, fProxiedPtr);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Return the unbiased standard deviation of processed column values (*lazy action*).
 /// \tparam T The type of the branch/column.
 /// \param[in] columnName The name of the branch/column to be treated.
 /// \return the standard deviation value of the selected column wrapped in a RResultPtr.
 ///
 /// If T is not specified, RDataFrame will infer it from the data and just-in-time compile the correct
 /// template specialization of this method.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column type (this invocation needs jitting internally)
 /// auto stdDev0 = myDf.StdDev("values");
 /// // Explicit column type
 /// auto stdDev1 = myDf.StdDev<double>("values");
 /// ~~~
 ///
 template <typename T = RDFDetail::RInferredType>
 RResultPtr<double> StdDev(std::string_view columnName = "")
 {
    const auto userColumns = columnName.empty() ? ColumnNames_t() : ColumnNames_t({std::string(columnName)});
    auto stdDeviationV = std::make_shared<double>(0);
    return CreateAction<RDFInternal::ActionTags::StdDev, T>(userColumns, stdDeviationV, stdDeviationV, fProxiedPtr);
 }

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Return the sum of processed column values (*lazy action*).
 /// \tparam T The type of the branch/column.
 /// \param[in] columnName The name of the branch/column.
 /// \param[in] initValue Optional initial value for the sum. If not present, the column values must be default-constructible.
 /// \return the sum of the selected column wrapped in a RResultPtr.
 ///
 /// If T is not specified, RDataFrame will infer it from the data and just-in-time compile the correct
 /// template specialization of this method.
 /// If the type of the column is inferred, the return type is `double`, the type of the column otherwise.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is
 /// booked but not executed. Also see RResultPtr.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// // Deduce column type (this invocation needs jitting internally)
 /// auto sum0 = myDf.Sum("values");
 /// // Explicit column type
 /// auto sum1 = myDf.Sum<double>("values");
 /// ~~~
 ///
 template <typename T = RDFDetail::RInferredType>
 RResultPtr<RDFDetail::SumReturnType_t<T>>
 Sum(std::string_view columnName = "",
     const RDFDetail::SumReturnType_t<T> &initValue = RDFDetail::SumReturnType_t<T>{})
 {
    const auto userColumns = columnName.empty() ? ColumnNames_t() : ColumnNames_t({std::string(columnName)});
    auto sumV = std::make_shared<RDFDetail::SumReturnType_t<T>>(initValue);
    return CreateAction<RDFInternal::ActionTags::Sum, T>(userColumns, sumV, sumV, fProxiedPtr);
 }
 // clang-format on

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Gather filtering statistics.
 /// \return the resulting `RCutFlowReport` instance wrapped in a RResultPtr.
 ///
 /// Calling `Report` on the main `RDataFrame` object gathers stats for
 /// all named filters in the call graph. Calling this method on a
 /// stored chain state (i.e. a graph node different from the first) gathers
 /// the stats for all named filters in the chain section between the original
 /// `RDataFrame` and that node (included). Stats are gathered in the same
 /// order as the named filters have been added to the graph.
 /// A RResultPtr<RCutFlowReport> is returned to allow inspection of the
 /// effects cuts had.
 ///
 /// This action is *lazy*: upon invocation of
 /// this method the calculation is booked but not executed. See RResultPtr
 /// documentation.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// auto filtered = d.Filter(cut1, {"b1"}, "Cut1").Filter(cut2, {"b2"}, "Cut2");
 /// auto cutReport = filtered3.Report();
 /// cutReport->Print();
 /// ~~~
 ///
 RResultPtr<RCutFlowReport> Report()
 {
    bool returnEmptyReport = false;
    // if this is a RInterface<RLoopManager> on which `Define` has been called, users
    // are calling `Report` on a chain of the form LoopManager->Define->Define->..., which
    // certainly does not contain named filters.
    // The number 4 takes into account the implicit columns for entry and slot number
    // and their aliases (2 + 2, i.e. {r,t}dfentry_ and {r,t}dfslot_)
    if (std::is_same<Proxied, RLoopManager>::value && fColRegister.GenerateColumnNames().size() > 4)
       returnEmptyReport = true;

    auto rep = std::make_shared<RCutFlowReport>();
    using Helper_t = RDFInternal::ReportHelper<Proxied>;
    using Action_t = RDFInternal::RAction<Helper_t, Proxied>;

    auto action = std::make_unique<Action_t>(Helper_t(rep, fProxiedPtr.get(), returnEmptyReport), ColumnNames_t({}),
                                             fProxiedPtr, RDFInternal::RColumnRegister(fColRegister));

    return MakeResultPtr(rep, *fLoopManager, std::move(action));
 }

 /// \brief Returns the names of the filters created.
 /// \return the container of filters names.
 ///
 /// If called on a root node, all the filters in the computation graph will
 /// be printed. For any other node, only the filters upstream of that node.
 /// Filters without a name are printed as "Unnamed Filter"
 /// This is not an action nor a transformation, just a query to the RDataFrame object.
 ///
 /// ### Example usage:
 /// ~~~{.cpp}
 /// auto filtNames = d.GetFilterNames();
 /// for (auto &&filtName : filtNames) std::cout << filtName << std::endl;
 /// ~~~
 ///
 std::vector<std::string> GetFilterNames() { return RDFInternal::GetFilterNames(fProxiedPtr); }

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Execute a user-defined accumulation operation on the processed column values in each processing slot.
 /// \tparam F The type of the aggregator callable. Automatically deduced.
 /// \tparam U The type of the aggregator variable. Must be default-constructible, copy-constructible and copy-assignable. Automatically deduced.
 /// \tparam T The type of the column to apply the reduction to. Automatically deduced.
 /// \param[in] aggregator A callable with signature `U(U,T)` or `void(U&,T)`, where T is the type of the column, U is the type of the aggregator variable
 /// \param[in] merger A callable with signature `U(U,U)` or `void(std::vector<U>&)` used to merge the results of the accumulations of each thread
 /// \param[in] columnName The column to be aggregated. If omitted, the first default column is used instead.
 /// \param[in] aggIdentity The aggregator variable of each thread is initialized to this value (or is default-constructed if the parameter is omitted)
 /// \return the result of the aggregation wrapped in a RResultPtr.
 ///
 /// An aggregator callable takes two values, an aggregator variable and a column value. The aggregator variable is
 /// initialized to aggIdentity or default-constructed if aggIdentity is omitted.
 /// This action calls the aggregator callable for each processed entry, passing in the aggregator variable and
 /// the value of the column columnName.
 /// If the signature is `U(U,T)` the aggregator variable is then copy-assigned the result of the execution of the callable.
 /// Otherwise the signature of aggregator must be `void(U&,T)`.
 ///
 /// The merger callable is used to merge the partial accumulation results of each processing thread. It is only called in multi-thread executions.
 /// If its signature is `U(U,U)` the aggregator variables of each thread are merged two by two.
 /// If its signature is `void(std::vector<U>& a)` it is assumed that it merges all aggregators in a[0].
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is booked but not executed. Also see RResultPtr.
 ///
 /// Example usage:
 /// ~~~{.cpp}
 /// auto aggregator = [](double acc, double x) { return acc * x; };
 /// ROOT::EnableImplicitMT();
 /// // If multithread is enabled, the aggregator function will be called by more threads
 /// // and will produce a vector of partial accumulators.
 /// // The merger function performs the final aggregation of these partial results.
 /// auto merger = [](std::vector<double> &accumulators) {
 ///    for (auto i : ROOT::TSeqU(1u, accumulators.size())) {
 ///       accumulators[0] *= accumulators[i];
 ///    }
 /// };
 ///
 /// // The accumulator is initialized at this value by every thread.
 /// double initValue = 1.;
 ///
 /// // Multiplies all elements of the column "x"
 /// auto result = d.Aggregate(aggregator, merger, "x", initValue);
 /// ~~~
 // clang-format on
 template <typename AccFun, typename MergeFun, typename R = typename TTraits::CallableTraits<AccFun>::ret_type,
           typename ArgTypes = typename TTraits::CallableTraits<AccFun>::arg_types,
           typename ArgTypesNoDecay = typename TTraits::CallableTraits<AccFun>::arg_types_nodecay,
           typename U = TTraits::TakeFirstParameter_t<ArgTypes>,
           typename T = TTraits::TakeFirstParameter_t<TTraits::RemoveFirstParameter_t<ArgTypes>>>
 RResultPtr<U> Aggregate(AccFun aggregator, MergeFun merger, std::string_view columnName, const U &aggIdentity)
 {
    RDFInternal::CheckAggregate<R, MergeFun>(ArgTypesNoDecay());
    const auto columns = columnName.empty() ? ColumnNames_t() : ColumnNames_t({std::string(columnName)});

    const auto validColumnNames = GetValidatedColumnNames(1, columns);
    CheckAndFillDSColumns(validColumnNames, TTraits::TypeList<T>());

    auto accObjPtr = std::make_shared<U>(aggIdentity);
    using Helper_t = RDFInternal::AggregateHelper<AccFun, MergeFun, R, T, U>;
    using Action_t = RDFInternal::RAction<Helper_t, Proxied>;
    auto action = std::make_unique<Action_t>(
       Helper_t(std::move(aggregator), std::move(merger), accObjPtr, fLoopManager->GetNSlots()), validColumnNames,
       fProxiedPtr, fColRegister);
    return MakeResultPtr(accObjPtr, *fLoopManager, std::move(action));
 }

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Execute a user-defined accumulation operation on the processed column values in each processing slot.
 /// \tparam F The type of the aggregator callable. Automatically deduced.
 /// \tparam U The type of the aggregator variable. Must be default-constructible, copy-constructible and copy-assignable. Automatically deduced.
 /// \tparam T The type of the column to apply the reduction to. Automatically deduced.
 /// \param[in] aggregator A callable with signature `U(U,T)` or `void(U,T)`, where T is the type of the column, U is the type of the aggregator variable
 /// \param[in] merger A callable with signature `U(U,U)` or `void(std::vector<U>&)` used to merge the results of the accumulations of each thread
 /// \param[in] columnName The column to be aggregated. If omitted, the first default column is used instead.
 /// \return the result of the aggregation wrapped in a RResultPtr.
 ///
 /// See previous Aggregate overload for more information.
 // clang-format on
 template <typename AccFun, typename MergeFun, typename R = typename TTraits::CallableTraits<AccFun>::ret_type,
           typename ArgTypes = typename TTraits::CallableTraits<AccFun>::arg_types,
           typename U = TTraits::TakeFirstParameter_t<ArgTypes>,
           typename T = TTraits::TakeFirstParameter_t<TTraits::RemoveFirstParameter_t<ArgTypes>>>
 RResultPtr<U> Aggregate(AccFun aggregator, MergeFun merger, std::string_view columnName = "")
 {
    static_assert(
       std::is_default_constructible<U>::value,
       "aggregated object cannot be default-constructed. Please provide an initialisation value (aggIdentity)");
    return Aggregate(std::move(aggregator), std::move(merger), columnName, U());
 }

 // clang-format off
 ////////////////////////////////////////////////////////////////////////////
 /// \brief Book execution of a custom action using a user-defined helper object.
 /// \tparam FirstColumn The type of the first column used by this action.  Inferred together with OtherColumns if not present.
 /// \tparam OtherColumns A list of the types of the other columns used by this action
 /// \tparam Helper The type of the user-defined helper. See below for the required interface it should expose.
 /// \param[in] helper The Action Helper to be scheduled.
 /// \param[in] columns The names of the columns on which the helper acts.
 /// \return the result of the helper wrapped in a RResultPtr.
 ///
 /// This method books a custom action for execution. The behavior of the action is completely dependent on the
 /// Helper object provided by the caller. The required interface for the helper is described below (more
 /// methods that the ones required can be present, e.g. a constructor that takes the number of worker threads is usually useful):
 ///
 /// ### Mandatory interface
 ///
 /// * `Helper` must publicly inherit from `ROOT::Detail::RDF::RActionImpl<Helper>`
 /// * `Helper::Result_t`: public alias for the type of the result of this action helper. `Result_t` must be default-constructible.
 /// * `Helper(Helper &&)`: a move-constructor is required. Copy-constructors are discouraged.
 /// * `std::shared_ptr<Result_t> GetResultPtr() const`: return a shared_ptr to the result of this action (of type
 ///   Result_t). The RResultPtr returned by Book will point to this object. Note that this method can be called
 ///   _before_ Initialize(), because the RResultPtr is constructed before the event loop is started.
 /// * `void Initialize()`: this method is called once before starting the event-loop. Useful for setup operations.
 ///   It must reset the state of the helper to the expected state at the beginning of the event loop: the same helper,
 ///   or copies of it, might be used for multiple event loops (e.g. in the presence of systematic variations).
 /// * `void InitTask(TTreeReader *, unsigned int slot)`: each working thread shall call this method during the event
 ///   loop, before processing a batch of entries. The pointer passed as argument, if not null, will point to the TTreeReader
 ///   that RDataFrame has set up to read the task's batch of entries. It is passed to the helper to allow certain advanced optimizations
 ///   it should not usually serve any purpose for the Helper. This method is often no-op for simple helpers.
 /// * `void Exec(unsigned int slot, ColumnTypes...columnValues)`: each working thread shall call this method
 ///   during the event-loop, possibly concurrently. No two threads will ever call Exec with the same 'slot' value:
 ///   this parameter is there to facilitate writing thread-safe helpers. The other arguments will be the values of
 ///   the requested columns for the particular entry being processed.
 /// * `void Finalize()`: this method is called at the end of the event loop. Commonly used to finalize the contents of the result.
 /// * `std::string GetActionName()`: it returns a string identifier for this type of action that RDataFrame will use in
 ///    diagnostics, SaveGraph(), etc.
 ///
 /// ### Optional methods
 ///
 /// If these methods are implemented they enable extra functionality as per the description below.
 ///
 /// * `Result_t &PartialUpdate(unsigned int slot)`: if present, it must return the value of the partial result of this action for the given 'slot'.
 ///   Different threads might call this method concurrently, but will do so with different 'slot' numbers.
 ///   RDataFrame leverages this method to implement RResultPtr::OnPartialResult().
 /// * `ROOT::RDF::SampleCallback_t GetSampleCallback()`: if present, it must return a callable with the
 ///   appropriate signature (see ROOT::RDF::SampleCallback_t) that will be invoked at the beginning of the processing
 ///   of every sample, as in DefinePerSample().
 /// * `Helper MakeNew(void *newResult, std::string_view variation = "nominal")`: if implemented, it enables varying
 ///   the action's result with VariationsFor(). It takes a type-erased new result that can be safely cast to a
 ///   `std::shared_ptr<Result_t> *` (a pointer to shared pointer) and should be used as the action's output result.
 ///   The function optionally takes the name of the current variation which could be useful in customizing its behaviour.
 ///
 /// In case Book is called without specifying column types as template arguments, corresponding typed code will be just-in-time compiled
 /// by RDataFrame. In that case the Helper class needs to be known to the ROOT interpreter.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is booked but not executed. Also see RResultPtr.
 ///
 /// ### Examples
 /// See [this tutorial](https://root.cern/doc/master/df018__customActions_8C.html) for an example implementation of an action helper.
 ///
 /// It is also possible to inspect the code used by built-in RDataFrame actions at ActionHelpers.hxx.
 ///
 // clang-format on
 template <typename FirstColumn = RDFDetail::RInferredType, typename... OtherColumns, typename Helper>
 RResultPtr<typename std::decay_t<Helper>::Result_t> Book(Helper &&helper, const ColumnNames_t &columns = {})
 {
    using HelperT = std::decay_t<Helper>;
    // TODO add more static sanity checks on Helper
    using AH = RDFDetail::RActionImpl<HelperT>;
    static_assert(std::is_base_of<AH, HelperT>::value && std::is_convertible<HelperT *, AH *>::value,
                  "Action helper of type T must publicly inherit from ROOT::Detail::RDF::RActionImpl<T>");

    auto hPtr = std::make_shared<HelperT>(std::forward<Helper>(helper));
    auto resPtr = hPtr->GetResultPtr();

    if (std::is_same<FirstColumn, RDFDetail::RInferredType>::value && columns.empty()) {
       return CallCreateActionWithoutColsIfPossible<HelperT>(resPtr, hPtr, TTraits::TypeList<FirstColumn>{});
    } else {
       return CreateAction<RDFInternal::ActionTags::Book, FirstColumn, OtherColumns...>(columns, resPtr, hPtr,
                                                                                        fProxiedPtr, columns.size());
    }
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Provides a representation of the columns in the dataset.
 /// \tparam ColumnTypes variadic list of branch/column types.
 /// \param[in] columnList Names of the columns to be displayed.
 /// \param[in] nRows Number of events for each column to be displayed.
 /// \param[in] nMaxCollectionElements Maximum number of collection elements to display per row.
 /// \return the `RDisplay` instance wrapped in a RResultPtr.
 ///
 /// This function returns a `RResultPtr<RDisplay>` containing all the entries to be displayed, organized in a tabular
 /// form. RDisplay will either print on the standard output a summarized version through `RDisplay::Print()` or will
 /// return a complete version through `RDisplay::AsString()`.
 ///
 /// This action is *lazy*: upon invocation of this method the calculation is booked but not executed. Also see
 /// RResultPtr.
 ///
 /// Example usage:
 /// ~~~{.cpp}
 /// // Preparing the RResultPtr<RDisplay> object with all columns and default number of entries
 /// auto d1 = rdf.Display("");
 /// // Preparing the RResultPtr<RDisplay> object with two columns and 128 entries
 /// auto d2 = d.Display({"x", "y"}, 128);
 /// // Printing the short representations, the event loop will run
 /// d1->Print();
 /// d2->Print();
 /// ~~~
 template <typename... ColumnTypes>
 RResultPtr<RDisplay> Display(const ColumnNames_t &columnList, size_t nRows = 5, size_t nMaxCollectionElements = 10)
 {
    CheckIMTDisabled("Display");
    auto newCols = columnList;
    newCols.insert(newCols.begin(), "rdfentry_"); // Artificially insert first column
    auto displayer = std::make_shared<RDisplay>(newCols, GetColumnTypeNamesList(newCols), nMaxCollectionElements);
    using displayHelperArgs_t = std::pair<size_t, std::shared_ptr<RDisplay>>;
    // Need to add ULong64_t type corresponding to the first column rdfentry_
    return CreateAction<RDFInternal::ActionTags::Display, ULong64_t, ColumnTypes...>(
       std::move(newCols), displayer, std::make_shared<displayHelperArgs_t>(nRows, displayer), fProxiedPtr);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Provides a representation of the columns in the dataset.
 /// \param[in] columnList Names of the columns to be displayed.
 /// \param[in] nRows Number of events for each column to be displayed.
 /// \param[in] nMaxCollectionElements  Maximum number of collection elements to display per row.
 /// \return the `RDisplay` instance wrapped in a RResultPtr.
 ///
 /// This overload automatically infers the column types.
 /// See the previous overloads for further details.
 ///
 /// Invoked when no types are specified to Display
 RResultPtr<RDisplay> Display(const ColumnNames_t &columnList, size_t nRows = 5, size_t nMaxCollectionElements = 10)
 {
    CheckIMTDisabled("Display");
    auto newCols = columnList;
    newCols.insert(newCols.begin(), "rdfentry_"); // Artificially insert first column
    auto displayer = std::make_shared<RDisplay>(newCols, GetColumnTypeNamesList(newCols), nMaxCollectionElements);
    using displayHelperArgs_t = std::pair<size_t, std::shared_ptr<RDisplay>>;
    return CreateAction<RDFInternal::ActionTags::Display, RDFDetail::RInferredType>(
       std::move(newCols), displayer, std::make_shared<displayHelperArgs_t>(nRows, displayer), fProxiedPtr,
       columnList.size() + 1);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Provides a representation of the columns in the dataset.
 /// \param[in] columnNameRegexp A regular expression to select the columns.
 /// \param[in] nRows Number of events for each column to be displayed.
 /// \param[in] nMaxCollectionElements Maximum number of collection elements to display per row.
 /// \return the `RDisplay` instance wrapped in a RResultPtr.
 ///
 /// The existing columns are matched against the regular expression. If the string provided
 /// is empty, all columns are selected.
 /// See the previous overloads for further details.
 RResultPtr<RDisplay>
 Display(std::string_view columnNameRegexp = "", size_t nRows = 5, size_t nMaxCollectionElements = 10)
 {
    const auto columnNames = GetColumnNames();
    const auto selectedColumns = RDFInternal::ConvertRegexToColumns(columnNames, columnNameRegexp, "Display");
    return Display(selectedColumns, nRows, nMaxCollectionElements);
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Provides a representation of the columns in the dataset.
 /// \param[in] columnList Names of the columns to be displayed.
 /// \param[in] nRows Number of events for each column to be displayed.
 /// \param[in] nMaxCollectionElements Number of maximum elements in collection.
 /// \return the `RDisplay` instance wrapped in a RResultPtr.
 ///
 /// See the previous overloads for further details.
 RResultPtr<RDisplay>
 Display(std::initializer_list<std::string> columnList, size_t nRows = 5, size_t nMaxCollectionElements = 10)
 {
    ColumnNames_t selectedColumns(columnList);
    return Display(selectedColumns, nRows, nMaxCollectionElements);
 }

3150private:
 template <typename F, typename DefineType, typename RetType = typename TTraits::CallableTraits<F>::ret_type>
 std::enable_if_t<std::is_default_constructible<RetType>::value, RInterface<Proxied, DS_t>>
 DefineImpl(std::string_view name, F &&expression, const ColumnNames_t &columns, const std::string &where)
 {
    if (where.compare(0, 8, "Redefine") != 0) { // not a Redefine
       RDFInternal::CheckValidCppVarName(name, where);
       RDFInternal::CheckForRedefinition(where, name, fColRegister, fLoopManager->GetBranchNames(),
                                         GetDataSource() ? GetDataSource()->GetColumnNames() : ColumnNames_t{});
    } else {
       RDFInternal::CheckForDefinition(where, name, fColRegister, fLoopManager->GetBranchNames(),
                                       GetDataSource() ? GetDataSource()->GetColumnNames() : ColumnNames_t{});
       RDFInternal::CheckForNoVariations(where, name, fColRegister);
    }

    using ArgTypes_t = typename TTraits::CallableTraits<F>::arg_types;
    using ColTypesTmp_t = typename RDFInternal::RemoveFirstParameterIf<
       std::is_same<DefineType, RDFDetail::ExtraArgsForDefine::Slot>::value, ArgTypes_t>::type;
    using ColTypes_t = typename RDFInternal::RemoveFirstTwoParametersIf<
       std::is_same<DefineType, RDFDetail::ExtraArgsForDefine::SlotAndEntry>::value, ColTypesTmp_t>::type;

    constexpr auto nColumns = ColTypes_t::list_size;

    const auto validColumnNames = GetValidatedColumnNames(nColumns, columns);
    CheckAndFillDSColumns(validColumnNames, ColTypes_t());

    // Declare return type to the interpreter, for future use by jitted actions
    auto retTypeName = RDFInternal::TypeID2TypeName(typeid(RetType));
    if (retTypeName.empty()) {
       // The type is not known to the interpreter.
       // We must not error out here, but if/when this column is used in jitted code
       const auto demangledType = RDFInternal::DemangleTypeIdName(typeid(RetType));
       retTypeName = "CLING_UNKNOWN_TYPE_" + demangledType;
    }

    using NewCol_t = RDFDetail::RDefine<F, DefineType>;
    auto newColumn = std::make_shared<NewCol_t>(name, retTypeName, std::forward<F>(expression), validColumnNames,
                                                fColRegister, *fLoopManager);

    RDFInternal::RColumnRegister newCols(fColRegister);
    newCols.AddDefine(std::move(newColumn));

    RInterface<Proxied> newInterface(fProxiedPtr, *fLoopManager, std::move(newCols));

    return newInterface;
 }

 // This overload is chosen when the callable passed to Define or DefineSlot returns void.
 // It simply fires a compile-time error. This is preferable to a static_assert in the main `Define` overload because
 // this way compilation of `Define` has no way to continue after throwing the error.
 template <typename F, typename DefineType, typename RetType = typename TTraits::CallableTraits<F>::ret_type,
           bool IsFStringConv = std::is_convertible<F, std::string>::value,
           bool IsRetTypeDefConstr = std::is_default_constructible<RetType>::value>
 std::enable_if_t<!IsFStringConv && !IsRetTypeDefConstr, RInterface<Proxied, DS_t>>
 DefineImpl(std::string_view, F, const ColumnNames_t &, const std::string &)
 {
    static_assert(std::is_default_constructible<typename TTraits::CallableTraits<F>::ret_type>::value,
                  "Error in `Define`: type returned by expression is not default-constructible");
    return *this; // never reached
 }

 template <typename... ColumnTypes>
 RResultPtr<RInterface<RLoopManager>> SnapshotImpl(std::string_view fullTreeName, std::string_view filename,
                                                   const ColumnNames_t &columnList, const RSnapshotOptions &options)
 {
    const auto columnListWithoutSizeColumns = RDFInternal::FilterArraySizeColNames(columnList, "Snapshot");

    RDFInternal::CheckTypesAndPars(sizeof...(ColumnTypes), columnListWithoutSizeColumns.size());
    // validCols has aliases resolved, while columnListWithoutSizeColumns still has aliases in it.
    const auto validCols = GetValidatedColumnNames(columnListWithoutSizeColumns.size(), columnListWithoutSizeColumns);
    RDFInternal::CheckForDuplicateSnapshotColumns(validCols);
    CheckAndFillDSColumns(validCols, TTraits::TypeList<ColumnTypes...>());

    const auto parsedTreePath = RDFInternal::ParseTreePath(fullTreeName);
    const auto &treename = parsedTreePath.fTreeName;
    const auto &dirname = parsedTreePath.fDirName;

    ::TDirectory::TContext ctxt;

    RResultPtr<RInterface<RLoopManager>> resPtr;

    if (options.fOutputFormat == ESnapshotOutputFormat::kRNTuple) {
       if (RDFInternal::GetDataSourceLabel(*this) == "TTreeDS") {
          throw std::runtime_error("Snapshotting from TTree to RNTuple is not yet supported. The current recommended "
                                   "way to convert TTrees to RNTuple is through the RNTupleImporter.");
       }

       auto newRDF =
          std::make_shared<RInterface<RLoopManager>>(std::make_shared<RLoopManager>(columnListWithoutSizeColumns));

       auto snapHelperArgs = std::make_shared<RDFInternal::SnapshotHelperArgs>(RDFInternal::SnapshotHelperArgs{
          std::string(filename), std::string(dirname), std::string(treename), columnListWithoutSizeColumns, options,
          newRDF->GetLoopManager(), GetLoopManager(), true /* fToRNTuple */});

       // The Snapshot helper will use validCols (with aliases resolved) as input columns, and
       // columnListWithoutSizeColumns (still with aliases in it, passed through snapHelperArgs) as output column
       // names.
       resPtr = CreateAction<RDFInternal::ActionTags::Snapshot, ColumnTypes...>(validCols, newRDF, snapHelperArgs,
                                                                                fProxiedPtr);
    } else {
       if (RDFInternal::GetDataSourceLabel(*this) == "RNTupleDS" &&
           options.fOutputFormat == ESnapshotOutputFormat::kDefault) {
          Warning("Snapshot",
                  "The default Snapshot output data format is TTree, but the input data format is RNTuple. If you "
                  "want to Snapshot to RNTuple or suppress this warning, set the appropriate fOutputFormat option in "
                  "RSnapshotOptions. Note that this current default behaviour might change in the future.");
       }

       // We create an RLoopManager without a data source. This needs to be initialised when the output TTree dataset
       // has actually been created and written to TFile, i.e. at the end of the Snapshot execution.
       auto newRDF =
          std::make_shared<RInterface<RLoopManager>>(std::make_shared<RLoopManager>(columnListWithoutSizeColumns));

       auto snapHelperArgs = std::make_shared<RDFInternal::SnapshotHelperArgs>(RDFInternal::SnapshotHelperArgs{
          std::string(filename), std::string(dirname), std::string(treename), columnListWithoutSizeColumns, options,
          newRDF->GetLoopManager(), GetLoopManager(), false /* fToRNTuple */});

       // The Snapshot helper will use validCols (with aliases resolved) as input columns, and
       // columnListWithoutSizeColumns (still with aliases in it, passed through snapHelperArgs) as output column
       // names.
       resPtr = CreateAction<RDFInternal::ActionTags::Snapshot, ColumnTypes...>(validCols, newRDF, snapHelperArgs,
                                                                                fProxiedPtr);
    }

    if (!options.fLazy)
       *resPtr;
    return resPtr;
 }

 ////////////////////////////////////////////////////////////////////////////
 /// \brief Implementation of cache.
 template <typename... ColTypes, std::size_t... S>
 RInterface<RLoopManager> CacheImpl(const ColumnNames_t &columnList, std::index_sequence<S...>)
 {
    const auto columnListWithoutSizeColumns = RDFInternal::FilterArraySizeColNames(columnList, "Snapshot");

    // Check at compile time that the columns types are copy constructible
    constexpr bool areCopyConstructible =
       RDFInternal::TEvalAnd<std::is_copy_constructible<ColTypes>::value...>::value;
    static_assert(areCopyConstructible, "Columns of a type which is not copy constructible cannot be cached yet.");

    RDFInternal::CheckTypesAndPars(sizeof...(ColTypes), columnListWithoutSizeColumns.size());

    auto colHolders = std::make_tuple(Take<ColTypes>(columnListWithoutSizeColumns[S])...);
    auto ds = std::make_unique<RLazyDS<ColTypes...>>(
       std::make_pair(columnListWithoutSizeColumns[S], std::get<S>(colHolders))...);

    RInterface<RLoopManager> cachedRDF(std::make_shared<RLoopManager>(std::move(ds), columnListWithoutSizeColumns));

    return cachedRDF;
 }

 template <bool IsSingleColumn, typename F>
 RInterface<Proxied, DS_t>
 VaryImpl(const std::vector<std::string> &colNames, F &&expression, const ColumnNames_t &inputColumns,
          const std::vector<std::string> &variationTags, std::string_view variationName)
 {
    using F_t = std::decay_t<F>;
    using ColTypes_t = typename TTraits::CallableTraits<F_t>::arg_types;
    using RetType = typename TTraits::CallableTraits<F_t>::ret_type;
    constexpr auto nColumns = ColTypes_t::list_size;

    SanityChecksForVary<RetType>(colNames, variationTags, variationName);

    const auto validColumnNames = GetValidatedColumnNames(nColumns, inputColumns);
    CheckAndFillDSColumns(validColumnNames, ColTypes_t{});

    auto retTypeName = RDFInternal::TypeID2TypeName(typeid(RetType));
    if (retTypeName.empty()) {
       // The type is not known to the interpreter, but we don't want to error out
       // here, rather if/when this column is used in jitted code, so we inject a broken but telling type name.
       const auto demangledType = RDFInternal::DemangleTypeIdName(typeid(RetType));
       retTypeName = "CLING_UNKNOWN_TYPE_" + demangledType;
    }

    auto variation = std::make_shared<RDFInternal::RVariation<F_t, IsSingleColumn>>(
       colNames, variationName, std::forward<F>(expression), variationTags, retTypeName, fColRegister, *fLoopManager,
       validColumnNames);

    RDFInternal::RColumnRegister newCols(fColRegister);
    newCols.AddVariation(std::move(variation));

    RInterface<Proxied> newInterface(fProxiedPtr, *fLoopManager, std::move(newCols));

    return newInterface;
 }

 RInterface<Proxied, DS_t> JittedVaryImpl(const std::vector<std::string> &colNames, std::string_view expression,
                                          const std::vector<std::string> &variationTags,
                                          std::string_view variationName, bool isSingleColumn)
 {
    R__ASSERT(!variationTags.empty() && "Must have at least one variation.")do { if (__builtin_expect(!!(!(!variationTags.empty() &&
 "Must have at least one variation.")), 0)) ::Fatal("", kAssertMsg
, "!variationTags.empty() && \"Must have at least one variation.\""
, 3341, "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RDF/RInterface.hxx"
); } while (false);
    R__ASSERT(!colNames.empty() && "Must have at least one varied column.")do { if (__builtin_expect(!!(!(!colNames.empty() && "Must have at least one varied column."
)), 0)) ::Fatal("", kAssertMsg, "!colNames.empty() && \"Must have at least one varied column.\""
, 3342, "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RDF/RInterface.hxx"
); } while (false);
    R__ASSERT(!variationName.empty() && "Must provide a variation name.")do { if (__builtin_expect(!!(!(!variationName.empty() &&
 "Must provide a variation name.")), 0)) ::Fatal("", kAssertMsg
, "!variationName.empty() && \"Must provide a variation name.\""
, 3343, "/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RDF/RInterface.hxx"
); } while (false);

    for (auto &colName : colNames) {
       RDFInternal::CheckValidCppVarName(colName, "Vary");
       RDFInternal::CheckForDefinition("Vary", colName, fColRegister, fLoopManager->GetBranchNames(),
                                       GetDataSource() ? GetDataSource()->GetColumnNames() : ColumnNames_t{});
    }
    RDFInternal::CheckValidCppVarName(variationName, "Vary");

    // when varying multiple columns, they must be different columns
    if (colNames.size() > 1) {
       std::set<std::string> uniqueCols(colNames.begin(), colNames.end());
       if (uniqueCols.size() != colNames.size())
          throw std::logic_error("A column name was passed to the same Vary invocation multiple times.");
    }

    auto upcastNodeOnHeap = RDFInternal::MakeSharedOnHeap(RDFInternal::UpcastNode(fProxiedPtr));
    auto jittedVariation = RDFInternal::BookVariationJit(
       colNames, variationName, variationTags, expression, *fLoopManager, GetDataSource(), fColRegister,
       fLoopManager->GetBranchNames(), upcastNodeOnHeap, isSingleColumn);

    RDFInternal::RColumnRegister newColRegister(fColRegister);
    newColRegister.AddVariation(std::move(jittedVariation));

    RInterface<Proxied, DS_t> newInterface(fProxiedPtr, *fLoopManager, std::move(newColRegister));

    return newInterface;
 }

 template <typename Helper, typename ActionResultType>
 auto CallCreateActionWithoutColsIfPossible(const std::shared_ptr<ActionResultType> &resPtr,
                                            const std::shared_ptr<Helper> &hPtr,
                                            TTraits::TypeList<RDFDetail::RInferredType>)
    -> decltype(hPtr->Exec(0u), RResultPtr<ActionResultType>{})
 {
    return CreateAction<RDFInternal::ActionTags::Book>(/*columns=*/{}, resPtr, hPtr, fProxiedPtr, 0u);
 }

 template <typename Helper, typename ActionResultType, typename... Others>
 RResultPtr<ActionResultType>
 CallCreateActionWithoutColsIfPossible(const std::shared_ptr<ActionResultType> &,
                                       const std::shared_ptr<Helper>& /*hPtr*/,
                                       Others...)
 {
    throw std::logic_error(std::string("An action was booked with no input columns, but the action requires "
                                       "columns! The action helper type was ") +
                           typeid(Helper).name());
    return {};
 }

3393protected:
 RInterface(const std::shared_ptr<Proxied> &proxied, RLoopManager &lm,
            const RDFInternal::RColumnRegister &colRegister)
    : RInterfaceBase(lm, colRegister), fProxiedPtr(proxied)
 {
 }

 const std::shared_ptr<Proxied> &GetProxiedPtr() const { return fProxiedPtr; }
3401};

3403} // namespace RDF

3405} // namespace ROOT

3407#endif // ROOT_RDF_INTERFACE

←

/cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root/ROOT/RDF/InterfaceUtils.hxx

1// Author: Enrico Guiraud, Danilo Piparo CERN  02/2018
2 
3/*************************************************************************
4 * Copyright (C) 1995-2018, Rene Brun and Fons Rademakers.               *
5 * All rights reserved.                                                  *
6 *                                                                       *
7 * For the licensing terms see $ROOTSYS/LICENSE.                         *
8 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
9 *************************************************************************/
10 
11#ifndef ROOT_RDF_TINTERFACE_UTILS
12#define ROOT_RDF_TINTERFACE_UTILS
13 
14#include "RColumnRegister.hxx"
15#include <ROOT/RDF/RAction.hxx>
16#include <ROOT/RDF/ActionHelpers.hxx> // for BuildAction
17#include <ROOT/RDF/RColumnRegister.hxx>
18#include <ROOT/RDF/RDefine.hxx>
19#include <ROOT/RDF/RDefinePerSample.hxx>
20#include <ROOT/RDF/RFilter.hxx>
21#include <ROOT/RDF/Utils.hxx>
22#include <ROOT/RDF/RJittedAction.hxx>
23#include <ROOT/RDF/RJittedDefine.hxx>
24#include <ROOT/RDF/RJittedFilter.hxx>
25#include <ROOT/RDF/RJittedVariation.hxx>
26#include <ROOT/RDF/RLoopManager.hxx>
27#include <string_view>
28#include <ROOT/RDF/RVariation.hxx>
29#include <ROOT/TypeTraits.hxx>
30#include <TError.h> // gErrorIgnoreLevel
31#include <TH1.h>
32#include <TROOT.h> // IsImplicitMTEnabled
33 
34#include <deque>
35#include <functional>
36#include <map>
37#include <memory>
38#include <string>
39#include <type_traits>
40#include <typeinfo>
41#include <vector>
42#include <unordered_map>
43 
44class TObjArray;
45class TTree;
46namespace ROOT {
47namespace Detail {
48namespace RDF {
49class RNodeBase;
50}
51}
52namespace RDF {
53template <typename T>
54class RResultPtr;
55template<typename T, typename V>
56class RInterface;
57using RNode = RInterface<::ROOT::Detail::RDF::RNodeBase, void>;
58class RDataSource;
59} // namespace RDF
60 
61} // namespace ROOT
62 
63/// \cond HIDDEN_SYMBOLS
64 
65namespace ROOT {
66namespace Internal {
67namespace RDF {
68using namespace ROOT::Detail::RDF;
69using namespace ROOT::RDF;
70namespace TTraits = ROOT::TypeTraits;
71 
72std::string DemangleTypeIdName(const std::type_info &typeInfo);
73 
74ColumnNames_t
75ConvertRegexToColumns(const ColumnNames_t &colNames, std::string_view columnNameRegexp, std::string_view callerName);
76 
77/// An helper object that sets and resets gErrorIgnoreLevel via RAII.
78class RIgnoreErrorLevelRAII {
79private:
80   int fCurIgnoreErrorLevel = gErrorIgnoreLevel;
81 
82public:
83   RIgnoreErrorLevelRAII(int errorIgnoreLevel) { gErrorIgnoreLevel = errorIgnoreLevel; }
84   ~RIgnoreErrorLevelRAII() { gErrorIgnoreLevel = fCurIgnoreErrorLevel; }
85};
86 
87/****** BuildAction overloads *******/
88 
89// clang-format off
90/// This namespace defines types to be used for tag dispatching in RInterface.
91namespace ActionTags {
92struct Histo1D{};
93struct Histo2D{};
94struct Histo3D{};
95struct HistoND{};
96struct Graph{};
97struct GraphAsymmErrors{};
98struct Profile1D{};
99struct Profile2D{};
100struct Min{};
101struct Max{};
102struct Sum{};
103struct Mean{};
104struct Fill{};
105struct StdDev{};
106struct Display{};
107struct Snapshot{};
108struct Book{};
109}
110// clang-format on
111 
112template <typename T, bool ISV6HISTO = std::is_base_of<TH1, std::decay_t<T>>::value>
113struct HistoUtils {
114   static void SetCanExtendAllAxes(T &h) { h.SetCanExtend(::TH1::kAllAxes); }
115   static bool HasAxisLimits(T &h)
116   {
117      auto xaxis = h.GetXaxis();
118      return !(xaxis->GetXmin() == 0. && xaxis->GetXmax() == 0.);
119   }
120};
121 
122template <typename T>
123struct HistoUtils<T, false> {
124   static void SetCanExtendAllAxes(T &) {}
125   static bool HasAxisLimits(T &) { return true; }
126};
127 
128// Generic filling (covers Histo2D, Histo3D, HistoND, Profile1D and Profile2D actions, with and without weights)
129template <typename... ColTypes, typename ActionTag, typename ActionResultType, typename PrevNodeType>
130std::unique_ptr<RActionBase>
131BuildAction(const ColumnNames_t &bl, const std::shared_ptr<ActionResultType> &h, const unsigned int nSlots,
132            std::shared_ptr<PrevNodeType> prevNode, ActionTag, const RColumnRegister &colRegister)
133{
134   using Helper_t = FillHelper<ActionResultType>;
135   using Action_t = RAction<Helper_t, PrevNodeType, TTraits::TypeList<ColTypes...>>;
136   return std::make_unique<Action_t>(Helper_t(h, nSlots), bl, std::move(prevNode), colRegister);
137}
138 
139// Histo1D filling (must handle the special case of distinguishing FillHelper and BufferedFillHelper
140template <typename... ColTypes, typename PrevNodeType>
141std::unique_ptr<RActionBase>
142BuildAction(const ColumnNames_t &bl, const std::shared_ptr<::TH1D> &h, const unsigned int nSlots,
143            std::shared_ptr<PrevNodeType> prevNode, ActionTags::Histo1D, const RColumnRegister &colRegister)
144{
145   auto hasAxisLimits = HistoUtils<::TH1D>::HasAxisLimits(*h);
146 
147   if (hasAxisLimits || !IsImplicitMTEnabled()) {
148      using Helper_t = FillHelper<::TH1D>;
149      using Action_t = RAction<Helper_t, PrevNodeType, TTraits::TypeList<ColTypes...>>;
150      return std::make_unique<Action_t>(Helper_t(h, nSlots), bl, std::move(prevNode), colRegister);
151   } else {
152      using Helper_t = BufferedFillHelper;
153      using Action_t = RAction<Helper_t, PrevNodeType, TTraits::TypeList<ColTypes...>>;
154      return std::make_unique<Action_t>(Helper_t(h, nSlots), bl, std::move(prevNode), colRegister);
155   }
156}
157 
158template <typename... ColTypes, typename PrevNodeType>
159std::unique_ptr<RActionBase>
160BuildAction(const ColumnNames_t &bl, const std::shared_ptr<TGraph> &g, const unsigned int nSlots,
161            std::shared_ptr<PrevNodeType> prevNode, ActionTags::Graph, const RColumnRegister &colRegister)
162{
163   using Helper_t = FillTGraphHelper;
164   using Action_t = RAction<Helper_t, PrevNodeType, TTraits::TypeList<ColTypes...>>;
165   return std::make_unique<Action_t>(Helper_t(g, nSlots), bl, std::move(prevNode), colRegister);
166}
167 
168template <typename... ColTypes, typename PrevNodeType>
169std::unique_ptr<RActionBase>
170BuildAction(const ColumnNames_t &bl, const std::shared_ptr<TGraphAsymmErrors> &g, const unsigned int nSlots,
171            std::shared_ptr<PrevNodeType> prevNode, ActionTags::GraphAsymmErrors, const RColumnRegister &colRegister)
172{
173   using Helper_t = FillTGraphAsymmErrorsHelper;
174   using Action_t = RAction<Helper_t, PrevNodeType, TTraits::TypeList<ColTypes...>>;
175   return std::make_unique<Action_t>(Helper_t(g, nSlots), bl, std::move(prevNode), colRegister);
176}
177 
178// Min action
179template <typename ColType, typename PrevNodeType, typename ActionResultType>
180std::unique_ptr<RActionBase>
181BuildAction(const ColumnNames_t &bl, const std::shared_ptr<ActionResultType> &minV, const unsigned int nSlots,
182            std::shared_ptr<PrevNodeType> prevNode, ActionTags::Min, const RColumnRegister &colRegister)
183{
184   using Helper_t = MinHelper<ActionResultType>;
185   using Action_t = RAction<Helper_t, PrevNodeType, TTraits::TypeList<ColType>>;
186   return std::make_unique<Action_t>(Helper_t(minV, nSlots), bl, std::move(prevNode), colRegister);
187}
188 
189// Max action
190template <typename ColType, typename PrevNodeType, typename ActionResultType>
191std::unique_ptr<RActionBase>
192BuildAction(const ColumnNames_t &bl, const std::shared_ptr<ActionResultType> &maxV, const unsigned int nSlots,
193            std::shared_ptr<PrevNodeType> prevNode, ActionTags::Max, const RColumnRegister &colRegister)
194{
195   using Helper_t = MaxHelper<ActionResultType>;
196   using Action_t = RAction<Helper_t, PrevNodeType, TTraits::TypeList<ColType>>;
197   return std::make_unique<Action_t>(Helper_t(maxV, nSlots), bl, std::move(prevNode), colRegister);
198}
199 
200// Sum action
201template <typename ColType, typename PrevNodeType, typename ActionResultType>
202std::unique_ptr<RActionBase>
203BuildAction(const ColumnNames_t &bl, const std::shared_ptr<ActionResultType> &sumV, const unsigned int nSlots,
204            std::shared_ptr<PrevNodeType> prevNode, ActionTags::Sum, const RColumnRegister &colRegister)
205{
206   using Helper_t = SumHelper<ActionResultType>;
207   using Action_t = RAction<Helper_t, PrevNodeType, TTraits::TypeList<ColType>>;
208   return std::make_unique<Action_t>(Helper_t(sumV, nSlots), bl, std::move(prevNode), colRegister);
209}
210 
211// Mean action
212template <typename ColType, typename PrevNodeType>
213std::unique_ptr<RActionBase>
214BuildAction(const ColumnNames_t &bl, const std::shared_ptr<double> &meanV, const unsigned int nSlots,
215            std::shared_ptr<PrevNodeType> prevNode, ActionTags::Mean, const RColumnRegister &colRegister)
216{
217   using Helper_t = MeanHelper;
218   using Action_t = RAction<Helper_t, PrevNodeType, TTraits::TypeList<ColType>>;
219   return std::make_unique<Action_t>(Helper_t(meanV, nSlots), bl, std::move(prevNode), colRegister);
220}
221 
222// Standard Deviation action
223template <typename ColType, typename PrevNodeType>
224std::unique_ptr<RActionBase>
225BuildAction(const ColumnNames_t &bl, const std::shared_ptr<double> &stdDeviationV, const unsigned int nSlots,
226            std::shared_ptr<PrevNodeType> prevNode, ActionTags::StdDev, const RColumnRegister &colRegister)
227{
228   using Helper_t = StdDevHelper;
229   using Action_t = RAction<Helper_t, PrevNodeType, TTraits::TypeList<ColType>>;
230   return std::make_unique<Action_t>(Helper_t(stdDeviationV, nSlots), bl, prevNode, colRegister);
231}
232 
233using displayHelperArgs_t = std::pair<size_t, std::shared_ptr<ROOT::RDF::RDisplay>>;
234 
235// Display action
236template <typename... ColTypes, typename PrevNodeType>
237std::unique_ptr<RActionBase>
238BuildAction(const ColumnNames_t &bl, const std::shared_ptr<displayHelperArgs_t> &helperArgs, const unsigned int,
239            std::shared_ptr<PrevNodeType> prevNode, ActionTags::Display, const RColumnRegister &colRegister)
240{
241   using Helper_t = DisplayHelper<PrevNodeType>;
242   using Action_t = RAction<Helper_t, PrevNodeType, TTraits::TypeList<ColTypes...>>;
243   return std::make_unique<Action_t>(Helper_t(helperArgs->first, helperArgs->second, prevNode), bl, prevNode,
244                                     colRegister);
245}
246 
247struct SnapshotHelperArgs {
248   std::string fFileName;
249   std::string fDirName;
250   std::string fTreeName;
251   std::vector<std::string> fOutputColNames;
252   ROOT::RDF::RSnapshotOptions fOptions;
253   ROOT::Detail::RDF::RLoopManager *fOutputLoopManager;
254   ROOT::Detail::RDF::RLoopManager *fInputLoopManager;
255   bool fToNTuple;
256};
257 
258// SnapshotTTree action
259template <typename... ColTypes, typename PrevNodeType>
260std::unique_ptr<RActionBase>
261BuildAction(const ColumnNames_t &colNames, const std::shared_ptr<SnapshotHelperArgs> &snapHelperArgs,
262            const unsigned int nSlots, std::shared_ptr<PrevNodeType> prevNode, ActionTags::Snapshot,
263            const RColumnRegister &colRegister)
264{
265   const auto &filename = snapHelperArgs->fFileName;
266   const auto &dirname = snapHelperArgs->fDirName;
267   const auto &treename = snapHelperArgs->fTreeName;
268   const auto &outputColNames = snapHelperArgs->fOutputColNames;
269   const auto &options = snapHelperArgs->fOptions;
270   const auto &lmPtr = snapHelperArgs->fOutputLoopManager;
271   const auto &inputLM = snapHelperArgs->fInputLoopManager;
272 
273   auto sz = sizeof...(ColTypes);
274   std::vector<bool> isDefine(sz);
275   for (auto i = 0u; i < sz; ++i)
276      isDefine[i] = colRegister.IsDefineOrAlias(colNames[i]);
277 
278   std::unique_ptr<RActionBase> actionPtr;
279   if (snapHelperArgs->fToNTuple) {
280      if (!ROOT::IsImplicitMTEnabled()) {
281         // single-thread snapshot
282         using Helper_t = SnapshotRNTupleHelper<ColTypes...>;
283         using Action_t = RAction<Helper_t, PrevNodeType>;
284 
285         actionPtr.reset(new Action_t(
286            Helper_t(filename, dirname, treename, colNames, outputColNames, options, lmPtr, std::move(isDefine)),
287            colNames, prevNode, colRegister));
288      } else {
289         // multi-thread snapshot to RNTuple is not yet supported
290         // TODO(fdegeus) Add MT snapshotting
291         throw std::runtime_error("Snapshot: Snapshotting to RNTuple with IMT enabled is not supported yet.");
292      }
293 
294      return actionPtr;
295   } else {
296      if (!ROOT::IsImplicitMTEnabled()) {
297         // single-thread snapshot
298         using Helper_t = SnapshotTTreeHelper<ColTypes...>;
299         using Action_t = RAction<Helper_t, PrevNodeType>;
300         actionPtr.reset(new Action_t(Helper_t(filename, dirname, treename, colNames, outputColNames, options,
301                                               std::move(isDefine), lmPtr, inputLM),
302                                      colNames, prevNode, colRegister));
303      } else {
304         // multi-thread snapshot
305         using Helper_t = SnapshotTTreeHelperMT<ColTypes...>;
306         using Action_t = RAction<Helper_t, PrevNodeType>;
307         actionPtr.reset(new Action_t(Helper_t(nSlots, filename, dirname, treename, colNames, outputColNames, options,
308                                               std::move(isDefine), lmPtr, inputLM),
309                                      colNames, prevNode, colRegister));
310      }
311   }
312   return actionPtr;
313}
314 
315// Book with custom helper type
316template <typename... ColTypes, typename PrevNodeType, typename Helper_t>
317std::unique_ptr<RActionBase>
318BuildAction(const ColumnNames_t &bl, const std::shared_ptr<Helper_t> &h, const unsigned int /*nSlots*/,
319            std::shared_ptr<PrevNodeType> prevNode, ActionTags::Book, const RColumnRegister &colRegister)
320{
321   using Action_t = RAction<Helper_t, PrevNodeType, TTraits::TypeList<ColTypes...>>;
322   return std::make_unique<Action_t>(Helper_t(std::move(*h)), bl, std::move(prevNode), colRegister);
323}
324 
325/****** end BuildAndBook ******/
326 
327template <typename Filter>
328void CheckFilter(Filter &)
329{
330   using FilterRet_t = typename RDF::CallableTraits<Filter>::ret_type;
331   static_assert(std::is_convertible<FilterRet_t, bool>::value,
332                 "filter expression returns a type that is not convertible to bool");
333}
334 
335ColumnNames_t FilterArraySizeColNames(const ColumnNames_t &columnNames, const std::string &action);
336 
337void CheckValidCppVarName(std::string_view var, const std::string &where);
338 
339void CheckForRedefinition(const std::string &where, std::string_view definedCol, const RColumnRegister &colRegister,
340                          const ColumnNames_t &treeColumns, const ColumnNames_t &dataSourceColumns);
341 
342void CheckForDefinition(const std::string &where, std::string_view definedColView, const RColumnRegister &colRegister,
343                        const ColumnNames_t &treeColumns, const ColumnNames_t &dataSourceColumns);
344 
345void CheckForNoVariations(const std::string &where, std::string_view definedColView,
346                          const RColumnRegister &colRegister);
347 
348std::string PrettyPrintAddr(const void *const addr);
349 
350std::shared_ptr<RJittedFilter> BookFilterJit(std::shared_ptr<RNodeBase> *prevNodeOnHeap, std::string_view name,
351                                             std::string_view expression, const ColumnNames_t &branches,
352                                             const RColumnRegister &colRegister, TTree *tree, RDataSource *ds);
353 
354std::shared_ptr<RJittedDefine> BookDefineJit(std::string_view name, std::string_view expression, RLoopManager &lm,
355                                             RDataSource *ds, const RColumnRegister &colRegister,
356                                             const ColumnNames_t &branches, std::shared_ptr<RNodeBase> *prevNodeOnHeap);
357 
358std::shared_ptr<RJittedDefine> BookDefinePerSampleJit(std::string_view name, std::string_view expression,
359                                                      RLoopManager &lm, const RColumnRegister &colRegister,
360                                                      std::shared_ptr<RNodeBase> *upcastNodeOnHeap);
361 
362std::shared_ptr<RJittedVariation>
363BookVariationJit(const std::vector<std::string> &colNames, std::string_view variationName,
364                 const std::vector<std::string> &variationTags, std::string_view expression, RLoopManager &lm,
365                 RDataSource *ds, const RColumnRegister &colRegister, const ColumnNames_t &branches,
366                 std::shared_ptr<RNodeBase> *upcastNodeOnHeap, bool isSingleColumn);
367 
368std::string JitBuildAction(const ColumnNames_t &bl, std::shared_ptr<RDFDetail::RNodeBase> *prevNode,
369                           const std::type_info &art, const std::type_info &at, void *rOnHeap, TTree *tree,
370                           const unsigned int nSlots, const RColumnRegister &colRegister, RDataSource *ds,
371                           std::weak_ptr<RJittedAction> *jittedActionOnHeap, const bool vector2RVec = true);
372 
373// Allocate a weak_ptr on the heap, return a pointer to it. The user is responsible for deleting this weak_ptr.
374// This function is meant to be used by RInterface's methods that book code for jitting.
375// The problem it solves is that we generate code to be lazily jitted with the addresses of certain objects in them,
376// and we need to check those objects are still alive when the generated code is finally jitted and executed.
377// So we pass addresses to weak_ptrs allocated on the heap to the jitted code, which is then responsible for
378// the deletion of the weak_ptr object.
379template <typename T>
380std::weak_ptr<T> *MakeWeakOnHeap(const std::shared_ptr<T> &shPtr)
381{
382   return new std::weak_ptr<T>(shPtr);
383}
384 
385// Same as MakeWeakOnHeap, but create a shared_ptr that makes sure the object is definitely kept alive.
386template <typename T>
387std::shared_ptr<T> *MakeSharedOnHeap(const std::shared_ptr<T> &shPtr)
388{
389   return new std::shared_ptr<T>(shPtr);
10
←
Memory is allocated→
390}
391 
392bool AtLeastOneEmptyString(const std::vector<std::string_view> strings);
393 
394/// Take a shared_ptr<AnyNodeType> and return a shared_ptr<RNodeBase>.
395/// This works for RLoopManager nodes as well as filters and ranges.
396std::shared_ptr<RNodeBase> UpcastNode(std::shared_ptr<RNodeBase> ptr);
397 
398ColumnNames_t GetValidatedColumnNames(RLoopManager &lm, const unsigned int nColumns, const ColumnNames_t &columns,
399                                      const RColumnRegister &validDefines, RDataSource *ds);
400 
401std::vector<std::string> GetValidatedArgTypes(const ColumnNames_t &colNames, const RColumnRegister &colRegister,
402                                              TTree *tree, RDataSource *ds, const std::string &context,
403                                              bool vector2RVec);
404 
405std::vector<bool> FindUndefinedDSColumns(const ColumnNames_t &requestedCols, const ColumnNames_t &definedDSCols);
406 
407template <typename T>
408void AddDSColumnsHelper(const std::string &colName, RLoopManager &lm, RDataSource &ds, RColumnRegister &colRegister)
409{
410 
411   if (colRegister.IsDefineOrAlias(colName))
412      return;
413 
414   if (lm.HasDataSourceColumnReaders(colName, typeid(T)))
415      return;
416 
417   if (!ds.HasColumn(colName) &&
418       lm.GetSuppressErrorsForMissingBranches().find(colName) == lm.GetSuppressErrorsForMissingBranches().end())
419      return;
420 
421   const auto nSlots = lm.GetNSlots();
422   std::vector<std::unique_ptr<RColumnReaderBase>> colReaders;
423   colReaders.reserve(nSlots);
424 
425   const auto valuePtrs = ds.GetColumnReaders<T>(colName);
426   if (!valuePtrs.empty()) { // we are using the old GetColumnReaders mechanism in this RDataSource
427      for (auto *ptr : valuePtrs)
428         colReaders.emplace_back(new RDSColumnReader<T>(ptr));
429 
430   } else { // using the new GetColumnReaders mechanism
431      // TODO consider changing the interface so we return all of these for all slots in one go
432      for (auto slot = 0u; slot < lm.GetNSlots(); ++slot)
433         colReaders.emplace_back(
434            ROOT::Internal::RDF::CreateColumnReader(ds, slot, colName, typeid(T), /*treeReader*/ nullptr));
435   }
436 
437   lm.AddDataSourceColumnReaders(colName, std::move(colReaders), typeid(T));
438}
439 
440/// Take list of column names that must be defined, current map of custom columns, current list of defined column names,
441/// and return a new map of custom columns (with the new datasource columns added to it)
442template <typename... ColumnTypes>
443void AddDSColumns(const std::vector<std::string> &requiredCols, RLoopManager &lm, RDataSource &ds,
444                  TTraits::TypeList<ColumnTypes...>, RColumnRegister &colRegister)
445{
446   // hack to expand a template parameter pack without c++17 fold expressions.
447   using expander = int[];
448   int i = 0;
449   (void)expander{(AddDSColumnsHelper<ColumnTypes>(requiredCols[i], lm, ds, colRegister), ++i)..., 0};
450}
451 
452// this function is meant to be called by the jitted code generated by BookFilterJit
453template <typename F, typename PrevNode>
454void JitFilterHelper(F &&f, const char **colsPtr, std::size_t colsSize, std::string_view name,
455                     std::weak_ptr<RJittedFilter> *wkJittedFilter, std::shared_ptr<PrevNode> *prevNodeOnHeap,
456                     RColumnRegister *colRegister) noexcept
457{
458   if (wkJittedFilter->expired()) {
459      // The branch of the computation graph that needed this jitted code went out of scope between the type
460      // jitting was booked and the time jitting actually happened. Nothing to do other than cleaning up.
461      delete wkJittedFilter;
462      delete colRegister;
463      delete prevNodeOnHeap;
464      return;
465   }
466 
467   const ColumnNames_t cols(colsPtr, colsPtr + colsSize);
468   delete[] colsPtr;
469 
470   const auto jittedFilter = wkJittedFilter->lock();
471 
472   // mock Filter logic -- validity checks and Define-ition of RDataSource columns
473   using Callable_t = std::decay_t<F>;
474   using F_t = RFilter<Callable_t, PrevNode>;
475   using ColTypes_t = typename TTraits::CallableTraits<Callable_t>::arg_types;
476   constexpr auto nColumns = ColTypes_t::list_size;
477   CheckFilter(f);
478 
479   auto &lm = *jittedFilter->GetLoopManagerUnchecked(); // RLoopManager must exist at this time
480   auto ds = lm.GetDataSource();
481 
482   if (ds != nullptr)
483      AddDSColumns(cols, lm, *ds, ColTypes_t(), *colRegister);
484 
485   jittedFilter->SetFilter(
486      std::unique_ptr<RFilterBase>(new F_t(std::forward<F>(f), cols, *prevNodeOnHeap, *colRegister, name)));
487   // colRegister points to the columns structure in the heap, created before the jitted call so that the jitter can
488   // share data after it has lazily compiled the code. Here the data has been used and the memory can be freed.
489   delete colRegister;
490   delete prevNodeOnHeap;
491   delete wkJittedFilter;
492}
493 
494namespace DefineTypes {
495struct RDefineTag {};
496struct RDefinePerSampleTag {};
497}
498 
499template <typename F>
500auto MakeDefineNode(DefineTypes::RDefineTag, std::string_view name, std::string_view dummyType, F &&f,
501                    const ColumnNames_t &cols, RColumnRegister &colRegister, RLoopManager &lm)
502{
503   return std::unique_ptr<RDefineBase>(new RDefine<std::decay_t<F>, ExtraArgsForDefine::None>(
504      name, dummyType, std::forward<F>(f), cols, colRegister, lm));
505}
506 
507template <typename F>
508auto MakeDefineNode(DefineTypes::RDefinePerSampleTag, std::string_view name, std::string_view dummyType, F &&f,
509                    const ColumnNames_t &, RColumnRegister &, RLoopManager &lm)
510{
511   return std::unique_ptr<RDefineBase>(
512      new RDefinePerSample<std::decay_t<F>>(name, dummyType, std::forward<F>(f), lm));
513}
514 
515// Build a RDefine or a RDefinePerSample object and attach it to an existing RJittedDefine
516// This function is meant to be called by jitted code right before starting the event loop.
517// If colsPtr is null, build a RDefinePerSample (it has no input columns), otherwise a RDefine.
518template <typename RDefineTypeTag, typename F>
519void JitDefineHelper(F &&f, const char **colsPtr, std::size_t colsSize, std::string_view name, RLoopManager *lm,
520                     std::weak_ptr<RJittedDefine> *wkJittedDefine, RColumnRegister *colRegister,
521                     std::shared_ptr<RNodeBase> *prevNodeOnHeap) noexcept
522{
523   // a helper to delete objects allocated before jitting, so that the jitter can share data with lazily jitted code
524   auto doDeletes = [&] {
525      delete wkJittedDefine;
526      delete colRegister;
527      delete prevNodeOnHeap;
528      delete[] colsPtr;
529   };
530 
531   if (wkJittedDefine->expired()) {
532      // The branch of the computation graph that needed this jitted code went out of scope between the type
533      // jitting was booked and the time jitting actually happened. Nothing to do other than cleaning up.
534      doDeletes();
535      return;
536   }
537 
538   const ColumnNames_t cols(colsPtr, colsPtr + colsSize);
539 
540   auto jittedDefine = wkJittedDefine->lock();
541 
542   using Callable_t = std::decay_t<F>;
543   using ColTypes_t = typename TTraits::CallableTraits<Callable_t>::arg_types;
544 
545   auto ds = lm->GetDataSource();
546   if (ds != nullptr && colsPtr)
547      AddDSColumns(cols, *lm, *ds, ColTypes_t(), *colRegister);
548 
549   // will never actually be used (trumped by jittedDefine->GetTypeName()), but we set it to something meaningful
550   // to help devs debugging
551   const auto dummyType = "jittedCol_t";
552   // use unique_ptr<RDefineBase> instead of make_unique<NewCol_t> to reduce jit/compile-times
553   std::unique_ptr<RDefineBase> newCol{
554      MakeDefineNode(RDefineTypeTag{}, name, dummyType, std::forward<F>(f), cols, *colRegister, *lm)};
555   jittedDefine->SetDefine(std::move(newCol));
556 
557   doDeletes();
558}
559 
560template <bool IsSingleColumn, typename F>
561void JitVariationHelper(F &&f, const char **colsPtr, std::size_t colsSize, const char **variedCols,
562                        std::size_t variedColsSize, const char **variationTags, std::size_t variationTagsSize,
563                        std::string_view variationName, RLoopManager *lm,
564                        std::weak_ptr<RJittedVariation> *wkJittedVariation, RColumnRegister *colRegister,
565                        std::shared_ptr<RNodeBase> *prevNodeOnHeap) noexcept
566{
567   // a helper to delete objects allocated before jitting, so that the jitter can share data with lazily jitted code
568   auto doDeletes = [&] {
569      delete[] colsPtr;
570      delete[] variedCols;
571      delete[] variationTags;
572 
573      delete wkJittedVariation;
574      delete colRegister;
575      delete prevNodeOnHeap;
576   };
577 
578   if (wkJittedVariation->expired()) {
579      // The branch of the computation graph that needed this jitted variation went out of scope between the type
580      // jitting was booked and the time jitting actually happened. Nothing to do other than cleaning up.
581      doDeletes();
582      return;
583   }
584 
585   const ColumnNames_t inputColNames(colsPtr, colsPtr + colsSize);
586   std::vector<std::string> variedColNames(variedCols, variedCols + variedColsSize);
587   std::vector<std::string> tags(variationTags, variationTags + variationTagsSize);
588 
589   auto jittedVariation = wkJittedVariation->lock();
590 
591   using Callable_t = std::decay_t<F>;
592   using ColTypes_t = typename TTraits::CallableTraits<Callable_t>::arg_types;
593 
594   auto ds = lm->GetDataSource();
595   if (ds != nullptr)
596      AddDSColumns(inputColNames, *lm, *ds, ColTypes_t(), *colRegister);
597 
598   // use unique_ptr<RDefineBase> instead of make_unique<NewCol_t> to reduce jit/compile-times
599   std::unique_ptr<RVariationBase> newVariation{new RVariation<std::decay_t<F>, IsSingleColumn>(
600      std::move(variedColNames), variationName, std::forward<F>(f), std::move(tags), jittedVariation->GetTypeName(),
601      *colRegister, *lm, inputColNames)};
602   jittedVariation->SetVariation(std::move(newVariation));
603 
604   doDeletes();
605}
606 
607/// Convenience function invoked by jitted code to build action nodes at runtime
608template <typename ActionTag, typename... ColTypes, typename PrevNodeType, typename HelperArgType>
609void CallBuildAction(std::shared_ptr<PrevNodeType> *prevNodeOnHeap, const char **colsPtr, std::size_t colsSize,
610                     const unsigned int nSlots, std::shared_ptr<HelperArgType> *helperArgOnHeap,
611                     std::weak_ptr<RJittedAction> *wkJittedActionOnHeap, RColumnRegister *colRegister) noexcept
612{
613   // a helper to delete objects allocated before jitting, so that the jitter can share data with lazily jitted code
614   auto doDeletes = [&] {
615      delete[] colsPtr;
616      delete helperArgOnHeap;
617      delete wkJittedActionOnHeap;
618      // colRegister must be deleted before prevNodeOnHeap because their dtor needs the RLoopManager to be alive
619      // and prevNodeOnHeap is what keeps it alive if the rest of the computation graph is already out of scope
620      delete colRegister;
621      delete prevNodeOnHeap;
622   };
623 
624   if (wkJittedActionOnHeap->expired()) {
625      // The branch of the computation graph that needed this jitted variation went out of scope between the type
626      // jitting was booked and the time jitting actually happened. Nothing to do other than cleaning up.
627      doDeletes();
628      return;
629   }
630 
631   const ColumnNames_t cols(colsPtr, colsPtr + colsSize);
632 
633   auto jittedActionOnHeap = wkJittedActionOnHeap->lock();
634 
635   // if we are here it means we are jitting, if we are jitting the loop manager must be alive
636   auto &prevNodePtr = *prevNodeOnHeap;
637   auto &loopManager = *prevNodePtr->GetLoopManagerUnchecked();
638   using ColTypes_t = TypeList<ColTypes...>;
639   constexpr auto nColumns = ColTypes_t::list_size;
640   auto ds = loopManager.GetDataSource();
641   if (ds != nullptr)
642      AddDSColumns(cols, loopManager, *ds, ColTypes_t(), *colRegister);
643 
644   auto actionPtr = BuildAction<ColTypes...>(cols, std::move(*helperArgOnHeap), nSlots, std::move(prevNodePtr),
645                                             ActionTag{}, *colRegister);
646   jittedActionOnHeap->SetAction(std::move(actionPtr));
647 
648   doDeletes();
649}
650 
651/// The contained `type` alias is `double` if `T == RInferredType`, `U` if `T == std::container<U>`, `T` otherwise.
652template <typename T, bool Container = IsDataContainer<T>::value && !std::is_same<T, std::string>::value>
653struct RMinReturnType {
654   using type = T;
655};
656 
657template <>
658struct RMinReturnType<RInferredType, false> {
659   using type = double;
660};
661 
662template <typename T>
663struct RMinReturnType<T, true> {
664   using type = TTraits::TakeFirstParameter_t<T>;
665};
666 
667// return wrapper around f that prepends an `unsigned int slot` parameter
668template <typename R, typename F, typename... Args>
669std::function<R(unsigned int, Args...)> AddSlotParameter(F &f, TypeList<Args...>)
670{
671   return [f](unsigned int, Args... a) mutable -> R { return f(a...); };
672}
673 
674template <typename ColType, typename... Rest>
675struct RNeedJittingHelper {
676   static constexpr bool value = RNeedJittingHelper<Rest...>::value;
677};
678 
679template <typename... Rest>
680struct RNeedJittingHelper<RInferredType, Rest...> {
681   static constexpr bool value = true;
682};
683 
684template <typename T>
685struct RNeedJittingHelper<T> {
686   static constexpr bool value = false;
687};
688 
689template <>
690struct RNeedJittingHelper<RInferredType> {
691   static constexpr bool value = true;
692};
693 
694template <typename ...ColTypes>
695struct RNeedJitting {
696   static constexpr bool value = RNeedJittingHelper<ColTypes...>::value;
697};
698 
699template <>
700struct RNeedJitting<> {
701   static constexpr bool value = false;
702};
703 
704///////////////////////////////////////////////////////////////////////////////
705/// Check preconditions for RInterface::Aggregate:
706/// - the aggregator callable must have signature `U(U,T)` or `void(U&,T)`.
707/// - the merge callable must have signature `U(U,U)` or `void(std::vector<U>&)`
708template <typename R, typename Merge, typename U, typename T, typename decayedU = std::decay_t<U>,
709          typename mergeArgsNoDecay_t = typename CallableTraits<Merge>::arg_types_nodecay,
710          typename mergeArgs_t = typename CallableTraits<Merge>::arg_types,
711          typename mergeRet_t = typename CallableTraits<Merge>::ret_type>
712void CheckAggregate(TypeList<U, T>)
713{
714   constexpr bool isAggregatorOk =
715      (std::is_same<R, decayedU>::value) || (std::is_same<R, void>::value && std::is_lvalue_reference<U>::value);
716   static_assert(isAggregatorOk, "aggregator function must have signature `U(U,T)` or `void(U&,T)`");
717   constexpr bool isMergeOk =
718      (std::is_same<TypeList<decayedU, decayedU>, mergeArgs_t>::value && std::is_same<decayedU, mergeRet_t>::value) ||
719      (std::is_same<TypeList<std::vector<decayedU> &>, mergeArgsNoDecay_t>::value &&
720       std::is_same<void, mergeRet_t>::value);
721   static_assert(isMergeOk, "merge function must have signature `U(U,U)` or `void(std::vector<U>&)`");
722}
723 
724///////////////////////////////////////////////////////////////////////////////
725/// This overload of CheckAggregate is called when the aggregator takes more than two arguments
726template <typename R, typename T>
727void CheckAggregate(T)
728{
729   static_assert(sizeof(T) == 0, "aggregator function must take exactly two arguments");
730}
731 
732///////////////////////////////////////////////////////////////////////////////
733/// Check as many template parameters were passed as the number of column names, throw if this is not the case.
734void CheckTypesAndPars(unsigned int nTemplateParams, unsigned int nColumnNames);
735 
736/// Return local BranchNames or default BranchNames according to which one should be used
737const ColumnNames_t SelectColumns(unsigned int nArgs, const ColumnNames_t &bl, const ColumnNames_t &defBl);
738 
739/// Check whether column names refer to a valid branch of a TTree or have been `Define`d. Return invalid column names.
740ColumnNames_t FindUnknownColumns(const ColumnNames_t &requiredCols, const ColumnNames_t &datasetColumns,
741                                 const RColumnRegister &definedCols, const ColumnNames_t &dataSourceColumns);
742 
743/// Returns the list of Filters defined in the whole graph
744std::vector<std::string> GetFilterNames(const std::shared_ptr<RLoopManager> &loopManager);
745 
746/// Returns the list of Filters defined in the branch
747template <typename NodeType>
748std::vector<std::string> GetFilterNames(const std::shared_ptr<NodeType> &node)
749{
750   std::vector<std::string> filterNames;
751   node->AddFilterName(filterNames);
752   return filterNames;
753}
754 
755struct ParsedTreePath {
756   std::string fTreeName;
757   std::string fDirName;
758};
759 
760ParsedTreePath ParseTreePath(std::string_view fullTreeName);
761 
762// Check if a condition is true for all types
763template <bool...>
764struct TBoolPack;
765 
766template <bool... bs>
767using IsTrueForAllImpl_t = typename std::is_same<TBoolPack<bs..., true>, TBoolPack<true, bs...>>;
768 
769template <bool... Conditions>
770struct TEvalAnd {
771   static constexpr bool value = IsTrueForAllImpl_t<Conditions...>::value;
772};
773 
774// Check if a class is a specialisation of stl containers templates
775// clang-format off
776 
777template <typename>
778struct IsList_t : std::false_type {};
779 
780template <typename T>
781struct IsList_t<std::list<T>> : std::true_type {};
782 
783template <typename>
784struct IsDeque_t : std::false_type {};
785 
786template <typename T>
787struct IsDeque_t<std::deque<T>> : std::true_type {};
788// clang-format on
789 
790void CheckForDuplicateSnapshotColumns(const ColumnNames_t &cols);
791 
792template <typename T>
793struct InnerValueType {
794   using type = T; // fallback for when T is not a nested RVec
795};
796 
797template <typename Elem>
798struct InnerValueType<ROOT::VecOps::RVec<ROOT::VecOps::RVec<Elem>>> {
799   using type = Elem;
800};
801 
802template <typename T>
803using InnerValueType_t = typename InnerValueType<T>::type;
804 
805std::pair<std::vector<std::string>, std::vector<std::string>>
806AddSizeBranches(const std::vector<std::string> &branches, ROOT::RDF::RDataSource *ds,
807                std::vector<std::string> &&colsWithoutAliases, std::vector<std::string> &&colsWithAliases);
808 
809void RemoveDuplicates(ColumnNames_t &columnNames);
810void RemoveRNTupleSubFields(ColumnNames_t &columnNames);
811 
812} // namespace RDF
813} // namespace Internal
814 
815namespace Detail {
816namespace RDF {
817 
818/// The aliased type is `double` if `T == RInferredType`, `U` if `T == container<U>`, `T` otherwise.
819template <typename T>
820using MinReturnType_t = typename RDFInternal::RMinReturnType<T>::type;
821 
822template <typename T>
823using MaxReturnType_t = MinReturnType_t<T>;
824 
825template <typename T>
826using SumReturnType_t = MinReturnType_t<T>;
827 
828} // namespace RDF
829} // namespace Detail
830} // namespace ROOT
831 
832/// \endcond
833 
834#endif