Logo ROOT  
Reference Guide
 
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Loading...
Searching...
No Matches
RLoopManager.hxx
Go to the documentation of this file.
1// Author: Enrico Guiraud, Danilo Piparo CERN 03/2017
2
3/*************************************************************************
4 * Copyright (C) 1995-2022, 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_RLOOPMANAGER
12#define ROOT_RLOOPMANAGER
13
14#include "ROOT/InternalTreeUtils.hxx" // RNoCleanupNotifier
15#include "ROOT/RDataSource.hxx"
21#include "ROOT/RDF/Utils.hxx"
22
23#include <functional>
24#include <limits>
25#include <map>
26#include <memory>
27#include <set>
28#include <string>
29#include <string_view>
30#include <unordered_map>
31#include <unordered_set>
32#include <vector>
33#include <any>
34
35// forward declarations
36class TTree;
37class TTreeReader;
38class TDirectory;
39
40namespace ROOT {
41namespace RDF {
42class RCutFlowReport;
43class RDataSource;
44} // ns RDF
45
46namespace Internal {
47namespace RDF {
48std::vector<std::string> GetBranchNames(TTree &t, bool allowDuplicates = true);
49
50class GraphNode;
51class RActionBase;
52class RVariationBase;
53class RDefinesWithReaders;
54class RVariationsWithReaders;
55
56namespace GraphDrawing {
58} // ns GraphDrawing
59
60using Callback_t = std::function<void(unsigned int)>;
61
62class RCallback {
65 std::vector<ULong64_t> fCounters;
66
67public:
69 : fFun(std::move(f)), fEveryN(everyN), fCounters(nSlots, 0ull)
70 {
71 }
72
73 void operator()(unsigned int slot)
74 {
75 auto &c = fCounters[slot];
76 ++c;
77 if (c == fEveryN) {
78 c = 0ull;
79 fFun(slot);
80 }
81 }
82};
83
86 std::vector<int> fHasBeenCalled; // std::vector<bool> is thread-unsafe for our purposes (and generally evil)
87
88public:
90
91 void operator()(unsigned int slot)
92 {
93 if (fHasBeenCalled[slot] == 1)
94 return;
95 fFun(slot);
97 }
98};
99
100} // namespace RDF
101} // namespace Internal
102} // namespace ROOT
103
104namespace ROOT {
105namespace Detail {
106namespace RDF {
108
109class RFilterBase;
110class RRangeBase;
111class RDefineBase;
113
114/// The head node of a RDF computation graph.
115/// This class is responsible of running the event loop.
116class RLoopManager : public RNodeBase {
117 using ColumnNames_t = std::vector<std::string>;
118 enum class ELoopType {
119 kInvalid,
122 kNoFiles,
126 };
127
128 friend struct RCallCleanUpTask;
129
130 std::vector<RDFInternal::RActionBase *> fBookedActions; ///< Non-owning pointers to actions to be run
131 std::vector<RDFInternal::RActionBase *> fRunActions; ///< Non-owning pointers to actions already run
132 std::vector<RFilterBase *> fBookedFilters;
133 std::vector<RFilterBase *> fBookedNamedFilters; ///< Contains a subset of fBookedFilters, i.e. only the named filters
134 std::vector<RRangeBase *> fBookedRanges;
135 std::vector<RDefineBase *> fBookedDefines;
136 std::vector<RDFInternal::RVariationBase *> fBookedVariations;
137
138 /// Shared pointer to the input TTree. It does not delete the pointee if the TTree/TChain was passed directly as an
139 /// argument to RDataFrame's ctor (in which case we let users retain ownership).
140 std::shared_ptr<TTree> fTree{nullptr};
142 Long64_t fEndEntry{std::numeric_limits<Long64_t>::max()};
143
144 /// Keys are `fname + "/" + treename` as RSampleInfo::fID; Values are pointers to the corresponding sample
145 std::unordered_map<std::string, ROOT::RDF::Experimental::RSample *> fSampleMap;
146 /// Samples need to survive throughout the whole event loop, hence stored as an attribute
147 std::vector<ROOT::RDF::Experimental::RSample> fSamples;
148
149 /// Friends of the fTree. Only used if we constructed fTree ourselves.
150 std::vector<std::unique_ptr<TChain>> fFriends;
152 /// Range of entries created when no data source is specified.
153 std::pair<ULong64_t, ULong64_t> fEmptyEntryRange{};
154 unsigned int fNSlots{1};
156 /// The kind of event loop that is going to be run (e.g. on ROOT files, on no files)
158 std::unique_ptr<RDataSource> fDataSource{}; ///< Owning pointer to a data-source object. Null if no data-source
159 /// Registered callbacks to be executed every N events.
160 /// The registration happens via the RegisterCallback method.
161 std::vector<RDFInternal::RCallback> fCallbacksEveryNEvents;
162 /// Registered callbacks to invoke just once before running the loop.
163 /// The registration happens via the RegisterCallback method.
164 std::vector<RDFInternal::ROneTimeCallback> fCallbacksOnce;
165 /// Registered callbacks to call at the beginning of each "data block".
166 /// The key is the pointer of the corresponding node in the computation graph (a RDefinePerSample or a RAction).
167 std::unordered_map<void *, ROOT::RDF::SampleCallback_t> fSampleCallbacks;
169 std::vector<ROOT::RDF::RSampleInfo> fSampleInfos;
170 unsigned int fNRuns{0}; ///< Number of event loops run
171
172 /// Readers for TTree/RDataSource columns (one per slot), shared by all nodes in the computation graph.
173 std::vector<std::unordered_map<std::string, std::unique_ptr<RColumnReaderBase>>> fDatasetColumnReaders;
174
175 /// Cache of the tree/chain branch names. Never access directy, always use GetBranchNames().
177
179
180 void RunEmptySourceMT();
181 void RunEmptySource();
182 void RunTreeProcessorMT();
183 void RunTreeReader();
184 void RunDataSourceMT();
185 void RunDataSource();
186 void RunAndCheckFilters(unsigned int slot, Long64_t entry);
187 void InitNodeSlots(TTreeReader *r, unsigned int slot);
188 void InitNodes();
189 void CleanUpNodes();
190 void CleanUpTask(TTreeReader *r, unsigned int slot);
191 void EvalChildrenCounts();
192 void SetupSampleCallbacks(TTreeReader *r, unsigned int slot);
193 void UpdateSampleInfo(unsigned int slot, const std::pair<ULong64_t, ULong64_t> &range);
194 void UpdateSampleInfo(unsigned int slot, TTreeReader &r);
195
196 // List of branches for which we want to suppress the printed error about
197 // missing branch when switching to a new tree. This is modified by readers,
198 // so must be declared before them in this class.
199 std::vector<std::string> fSuppressErrorsForMissingBranches{};
201 std::set<std::pair<std::string_view, std::unique_ptr<ROOT::Internal::RDF::RDefinesWithReaders>>>
203 std::set<std::pair<std::string_view, std::unique_ptr<ROOT::Internal::RDF::RVariationsWithReaders>>>
205
206 /// A wrapped reference to a TTree dataset that can be shared by many computation graphs. Ensures lifetime
207 /// management.
208 std::any fTTreeLifeline{};
209
210public:
212 RLoopManager(TTree *tree, const ColumnNames_t &defaultBranches);
213 RLoopManager(std::unique_ptr<TTree> tree, const ColumnNames_t &defaultBranches);
215 RLoopManager(std::unique_ptr<RDataSource> ds, const ColumnNames_t &defaultBranches);
217
218 // Rule of five
219
220 RLoopManager(const RLoopManager &) = delete;
224 ~RLoopManager() override;
225
226 void Jit();
228 void Run(bool jit = true);
229 const ColumnNames_t &GetDefaultColumnNames() const;
230 TTree *GetTree() const;
232 RDataSource *GetDataSource() const { return fDataSource.get(); }
243 bool CheckFilters(unsigned int, Long64_t) final;
244 unsigned int GetNSlots() const { return fNSlots; }
245 void Report(ROOT::RDF::RCutFlowReport &rep) const final;
246 /// End of recursive chain of calls, does nothing
248 void SetTree(std::shared_ptr<TTree> tree);
251 void ToJitExec(const std::string &) const;
252 void RegisterCallback(ULong64_t everyNEvents, std::function<void(unsigned int)> &&f);
253 unsigned int GetNRuns() const { return fNRuns; }
254 bool HasDataSourceColumnReaders(const std::string &col, const std::type_info &ti) const;
255 void AddDataSourceColumnReaders(const std::string &col, std::vector<std::unique_ptr<RColumnReaderBase>> &&readers,
256 const std::type_info &ti);
257 RColumnReaderBase *AddTreeColumnReader(unsigned int slot, const std::string &col,
258 std::unique_ptr<RColumnReaderBase> &&reader, const std::type_info &ti);
259 RColumnReaderBase *GetDatasetColumnReader(unsigned int slot, const std::string &col, const std::type_info &ti) const;
260
261 /// End of recursive chain of calls, does nothing
262 void AddFilterName(std::vector<std::string> &) final {}
263 /// For each booked filter, returns either the name or "Unnamed Filter"
264 std::vector<std::string> GetFiltersNames();
265
266 /// Return all graph edges known to RLoopManager
267 /// This includes Filters and Ranges but not Defines.
268 std::vector<RNodeBase *> GetGraphEdges() const;
269
270 /// Return all actions, either booked or already run
271 std::vector<RDFInternal::RActionBase *> GetAllActions() const;
272
273 std::shared_ptr<ROOT::Internal::RDF::GraphDrawing::GraphNode>
274 GetGraph(std::unordered_map<void *, std::shared_ptr<ROOT::Internal::RDF::GraphDrawing::GraphNode>> &visitedMap) final;
275
276 const ColumnNames_t &GetBranchNames();
277
279
280 void SetEmptyEntryRange(std::pair<ULong64_t, ULong64_t> &&newRange);
283
285 std::set<std::pair<std::string_view, std::unique_ptr<ROOT::Internal::RDF::RDefinesWithReaders>>> &
290 std::set<std::pair<std::string_view, std::unique_ptr<ROOT::Internal::RDF::RVariationsWithReaders>>> &
295
297 const std::vector<std::string> &GetSuppressErrorsForMissingBranches() const
298 {
300 }
301
302 void SetTTreeLifeline(std::any lifeline);
303
304 void SetDataSource(std::unique_ptr<ROOT::RDF::RDataSource> dataSource);
305};
306
307/// \brief Create an RLoopManager that reads a TChain.
308/// \param[in] datasetName Name of the TChain
309/// \param[in] fileNameGlob File name (or glob) in which the TChain is stored.
310/// \param[in] defaultColumns List of default columns, see
311/// \ref https://root.cern/doc/master/classROOT_1_1RDataFrame.html#default-branches "Default column lists"
312/// \return the RLoopManager instance.
313std::shared_ptr<ROOT::Detail::RDF::RLoopManager>
314CreateLMFromTTree(std::string_view datasetName, std::string_view fileNameGlob,
315 const std::vector<std::string> &defaultColumns, bool checkFile = true);
316
317/// \brief Create an RLoopManager that reads a TChain.
318/// \param[in] datasetName Name of the TChain
319/// \param[in] fileNameGlobs List of file names (potentially globs).
320/// \param[in] defaultColumns List of default columns, see
321/// \ref https://root.cern/doc/master/classROOT_1_1RDataFrame.html#default-branches "Default column lists"
322/// \return the RLoopManager instance.
323std::shared_ptr<ROOT::Detail::RDF::RLoopManager>
324CreateLMFromTTree(std::string_view datasetName, const std::vector<std::string> &fileNameGlobs,
325 const std::vector<std::string> &defaultColumns, bool checkFile = true);
326
327#ifdef R__HAS_ROOT7
328/// \brief Create an RLoopManager that reads an RNTuple.
329/// \param[in] datasetName Name of the RNTuple
330/// \param[in] fileNameGlob File name (or glob) in which the RNTuple is stored.
331/// \param[in] defaultColumns List of default columns, see
332/// \ref https://root.cern/doc/master/classROOT_1_1RDataFrame.html#default-branches "Default column lists"
333/// \return the RLoopManager instance.
334std::shared_ptr<ROOT::Detail::RDF::RLoopManager> CreateLMFromRNTuple(std::string_view datasetName,
335 std::string_view fileNameGlob,
336 const std::vector<std::string> &defaultColumns);
337
338/// \brief Create an RLoopManager that reads multiple RNTuples chained vertically.
339/// \param[in] datasetName Name of the RNTuple
340/// \param[in] fileNameGlobs List of file names (potentially globs).
341/// \param[in] defaultColumns List of default columns, see
342/// \ref https://root.cern/doc/master/classROOT_1_1RDataFrame.html#default-branches "Default column lists"
343/// \return the RLoopManager instance.
344std::shared_ptr<ROOT::Detail::RDF::RLoopManager> CreateLMFromRNTuple(std::string_view datasetName,
345 const std::vector<std::string> &fileNameGlobs,
346 const std::vector<std::string> &defaultColumns);
347
348/// \brief Create an RLoopManager opening a file and checking the data format of the dataset.
349/// \param[in] datasetName Name of the dataset in the file.
350/// \param[in] fileNameGlob File name (or glob) in which the dataset is stored.
351/// \param[in] defaultColumns List of default columns, see
352/// \ref https://root.cern/doc/master/classROOT_1_1RDataFrame.html#default-branches "Default column lists"
353/// \throws std::invalid_argument if the file could not be opened.
354/// \return an RLoopManager of the appropriate data source.
355std::shared_ptr<ROOT::Detail::RDF::RLoopManager> CreateLMFromFile(std::string_view datasetName,
356 std::string_view fileNameGlob,
357 const std::vector<std::string> &defaultColumns);
358
359/// \brief Create an RLoopManager that reads many files. The first is opened to infer the data source type.
360/// \param[in] datasetName Name of the dataset.
361/// \param[in] fileNameGlobs List of file names (potentially globs).
362/// \param[in] defaultColumns List of default columns, see
363/// \ref https://root.cern/doc/master/classROOT_1_1RDataFrame.html#default-branches "Default column lists"
364/// \throws std::invalid_argument if the file could not be opened.
365/// \return an RLoopManager of the appropriate data source.
366std::shared_ptr<ROOT::Detail::RDF::RLoopManager> CreateLMFromFile(std::string_view datasetName,
367 const std::vector<std::string> &fileNameGlobs,
368 const std::vector<std::string> &defaultColumns);
369#endif
370
371} // namespace RDF
372} // namespace Detail
373} // namespace ROOT
374
375#endif
#define f(i)
Definition RSha256.hxx:104
#define c(i)
Definition RSha256.hxx:101
long long Long64_t
Definition RtypesCore.h:69
unsigned long long ULong64_t
Definition RtypesCore.h:70
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
The head node of a RDF computation graph.
void UpdateSampleInfo(unsigned int slot, const std::pair< ULong64_t, ULong64_t > &range)
unsigned int fNRuns
Number of event loops run.
bool CheckFilters(unsigned int, Long64_t) final
std::any fTTreeLifeline
A wrapped reference to a TTree dataset that can be shared by many computation graphs.
void EvalChildrenCounts()
Trigger counting of number of children nodes for each node of the functional graph.
void CleanUpNodes()
Perform clean-up operations. To be called at the end of each event loop.
void RunEmptySource()
Run event loop with no source files, in sequence.
void SetEmptyEntryRange(std::pair< ULong64_t, ULong64_t > &&newRange)
void Report(ROOT::RDF::RCutFlowReport &rep) const final
Call FillReport on all booked filters.
void AddSampleCallback(void *nodePtr, ROOT::RDF::SampleCallback_t &&callback)
std::vector< RFilterBase * > fBookedNamedFilters
Contains a subset of fBookedFilters, i.e. only the named filters.
void RunEmptySourceMT()
Run event loop with no source files, in parallel.
RLoopManager & operator=(RLoopManager &&)=delete
std::unordered_map< std::string, ROOT::RDF::Experimental::RSample * > fSampleMap
Keys are fname + "/" + treename as RSampleInfo::fID; Values are pointers to the corresponding sample.
std::shared_ptr< ROOT::Internal::RDF::GraphDrawing::GraphNode > GetGraph(std::unordered_map< void *, std::shared_ptr< ROOT::Internal::RDF::GraphDrawing::GraphNode > > &visitedMap) final
RLoopManager & operator=(const RLoopManager &)=delete
const ColumnNames_t & GetBranchNames()
Return all valid TTree::Branch names (caching results for subsequent calls).
void ToJitExec(const std::string &) const
std::vector< RDFInternal::RActionBase * > GetAllActions() const
Return all actions, either booked or already run.
std::vector< ROOT::RDF::RSampleInfo > fSampleInfos
void ChangeSpec(ROOT::RDF::Experimental::RDatasetSpec &&spec)
Changes the internal TTree held by the RLoopManager.
void SetTree(std::shared_ptr< TTree > tree)
std::set< std::pair< std::string_view, std::unique_ptr< ROOT::Internal::RDF::RVariationsWithReaders > > > & GetUniqueVariationsWithReaders()
std::shared_ptr< TTree > fTree
Shared pointer to the input TTree.
std::vector< RDefineBase * > fBookedDefines
void RunTreeReader()
Run event loop over one or multiple ROOT files, in sequence.
ROOT::Internal::TreeUtils::RNoCleanupNotifier fNoCleanupNotifier
std::vector< RDFInternal::RActionBase * > fRunActions
Non-owning pointers to actions already run.
RLoopManager(const ColumnNames_t &defaultColumns={})
RColumnReaderBase * GetDatasetColumnReader(unsigned int slot, const std::string &col, const std::type_info &ti) const
void AddFilterName(std::vector< std::string > &) final
End of recursive chain of calls, does nothing.
std::vector< RRangeBase * > fBookedRanges
std::vector< ROOT::RDF::Experimental::RSample > fSamples
Samples need to survive throughout the whole event loop, hence stored as an attribute.
std::vector< std::string > ColumnNames_t
void RunAndCheckFilters(unsigned int slot, Long64_t entry)
Execute actions and make sure named filters are called for each event.
void ChangeBeginAndEndEntries(Long64_t begin, Long64_t end)
std::vector< RFilterBase * > fBookedFilters
void Run(bool jit=true)
Start the event loop with a different mechanism depending on IMT/no IMT, data source/no data source.
std::set< std::pair< std::string_view, std::unique_ptr< ROOT::Internal::RDF::RVariationsWithReaders > > > fUniqueVariationsWithReaders
std::unordered_map< void *, ROOT::RDF::SampleCallback_t > fSampleCallbacks
Registered callbacks to call at the beginning of each "data block".
std::vector< std::string > fSuppressErrorsForMissingBranches
std::vector< RDFInternal::RActionBase * > fBookedActions
Non-owning pointers to actions to be run.
RLoopManager(RLoopManager &&)=delete
RColumnReaderBase * AddTreeColumnReader(unsigned int slot, const std::string &col, std::unique_ptr< RColumnReaderBase > &&reader, const std::type_info &ti)
Register a new RTreeColumnReader with this RLoopManager.
void AddDataSourceColumnReaders(const std::string &col, std::vector< std::unique_ptr< RColumnReaderBase > > &&readers, const std::type_info &ti)
void SetupSampleCallbacks(TTreeReader *r, unsigned int slot)
ColumnNames_t fValidBranchNames
Cache of the tree/chain branch names. Never access directy, always use GetBranchNames().
void CleanUpTask(TTreeReader *r, unsigned int slot)
Perform clean-up operations. To be called at the end of each task execution.
std::vector< std::string > & GetSuppressErrorsForMissingBranches()
std::vector< RDFInternal::RCallback > fCallbacksEveryNEvents
Registered callbacks to be executed every N events.
std::vector< std::unordered_map< std::string, std::unique_ptr< RColumnReaderBase > > > fDatasetColumnReaders
Readers for TTree/RDataSource columns (one per slot), shared by all nodes in the computation graph.
void Register(RDFInternal::RActionBase *actionPtr)
const ColumnNames_t & GetDefaultColumnNames() const
Return the list of default columns – empty if none was provided when constructing the RDataFrame.
std::vector< RDFInternal::RVariationBase * > fBookedVariations
std::vector< RNodeBase * > GetGraphEdges() const
Return all graph edges known to RLoopManager This includes Filters and Ranges but not Defines.
std::set< std::pair< std::string_view, std::unique_ptr< ROOT::Internal::RDF::RDefinesWithReaders > > > & GetUniqueDefinesWithReaders()
RDataSource * GetDataSource() const
void RunDataSourceMT()
Run event loop over data accessed through a DataSource, in parallel.
void PartialReport(ROOT::RDF::RCutFlowReport &) const final
End of recursive chain of calls, does nothing.
std::vector< std::string > GetFiltersNames()
For each booked filter, returns either the name or "Unnamed Filter".
RLoopManager(const RLoopManager &)=delete
RDFInternal::RNewSampleNotifier fNewSampleNotifier
std::pair< ULong64_t, ULong64_t > fEmptyEntryRange
Range of entries created when no data source is specified.
std::set< std::pair< std::string_view, std::unique_ptr< ROOT::Internal::RDF::RDefinesWithReaders > > > fUniqueDefinesWithReaders
ROOT::Internal::RDF::RStringCache fCachedColNames
ROOT::Internal::RDF::RStringCache & GetColumnNamesCache()
std::unique_ptr< RDataSource > fDataSource
Owning pointer to a data-source object.
const std::vector< std::string > & GetSuppressErrorsForMissingBranches() const
void InitNodeSlots(TTreeReader *r, unsigned int slot)
Build TTreeReaderValues for all nodes This method loops over all filters, actions and other booked ob...
std::vector< RDFInternal::ROneTimeCallback > fCallbacksOnce
Registered callbacks to invoke just once before running the loop.
void SetDataSource(std::unique_ptr< ROOT::RDF::RDataSource > dataSource)
void RegisterCallback(ULong64_t everyNEvents, std::function< void(unsigned int)> &&f)
void SetTTreeLifeline(std::any lifeline)
void RunDataSource()
Run event loop over data accessed through a DataSource, in sequence.
void Jit()
Add RDF nodes that require just-in-time compilation to the computation graph.
void RunTreeProcessorMT()
Run event loop over one or multiple ROOT files, in parallel.
void Deregister(RDFInternal::RActionBase *actionPtr)
ELoopType fLoopType
The kind of event loop that is going to be run (e.g. on ROOT files, on no files)
void InitNodes()
Initialize all nodes of the functional graph before running the event loop.
RLoopManager * GetLoopManagerUnchecked() final
std::vector< std::unique_ptr< TChain > > fFriends
Friends of the fTree. Only used if we constructed fTree ourselves.
bool HasDataSourceColumnReaders(const std::string &col, const std::type_info &ti) const
Return true if AddDataSourceColumnReaders was called for column name col.
Base class for non-leaf nodes of the computational graph.
Definition RNodeBase.hxx:43
unsigned int fNStopsReceived
Number of times that a children node signaled to stop processing entries.
Definition RNodeBase.hxx:47
unsigned int fNChildren
Number of nodes of the functional graph hanging from this object.
Definition RNodeBase.hxx:46
Helper class that provides the operation graph nodes.
RCallback(ULong64_t everyN, Callback_t &&f, unsigned int nSlots)
std::vector< ULong64_t > fCounters
void operator()(unsigned int slot)
ROneTimeCallback(Callback_t &&f, unsigned int nSlots)
A Thread-safe cache for strings.
Definition Utils.hxx:283
This type includes all parts of RVariation that do not depend on the callable signature.
The dataset specification for RDataFrame.
RDataSource defines an API that RDataFrame can use to read arbitrary data formats.
Describe directory structure in memory.
Definition TDirectory.h:45
A simple, robust and fast interface to read values from ROOT columnar datasets such as TTree,...
Definition TTreeReader.h:45
A TTree represents a columnar dataset.
Definition TTree.h:79
std::shared_ptr< ROOT::Detail::RDF::RLoopManager > CreateLMFromTTree(std::string_view datasetName, std::string_view fileNameGlob, const std::vector< std::string > &defaultColumns, bool checkFile=true)
Create an RLoopManager that reads a TChain.
std::vector< std::string > GetBranchNames(TTree &t, bool allowDuplicates=true)
Get all the branches names, including the ones of the friend trees.
std::function< void(unsigned int)> Callback_t
std::function< void(unsigned int, const ROOT::RDF::RSampleInfo &)> SampleCallback_t
The type of a data-block callback, registered with an RDataFrame computation graph via e....
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
A RAII object that calls RLoopManager::CleanUpTask at destruction.