Logo ROOT  
Reference Guide
 
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/RDataSource.hxx"
20#include "ROOT/RDF/Utils.hxx"
21
22#include <functional>
23#include <limits>
24#include <map>
25#include <memory>
26#include <set>
27#include <string>
28#include <string_view>
29#include <unordered_map>
30#include <unordered_set>
31#include <vector>
32#include <any>
33
34// forward declarations
35class TTree;
36class TTreeReader;
37class TDirectory;
38
39namespace ROOT {
40namespace RDF {
41class RCutFlowReport;
42class RDataSource;
43} // ns RDF
44
45namespace Internal {
46class RSlotStack;
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
100struct RDSRangeRAII;
101
102} // namespace RDF
103} // namespace Internal
104} // namespace ROOT
105
106namespace ROOT {
107namespace Detail {
108namespace RDF {
110
111class RFilterBase;
112class RRangeBase;
113class RDefineBase;
115
116/// The head node of a RDF computation graph.
117/// This class is responsible of running the event loop.
118class RLoopManager : public RNodeBase {
119 using ColumnNames_t = std::vector<std::string>;
120 enum class ELoopType {
121 kInvalid,
122 kNoFiles,
126 };
127
128 friend struct RCallCleanUpTask;
130
131 /*
132 A wrapped reference to a TTree dataset that can be shared by many computation graphs. Ensures lifetime management.
133 It needs to be destroyed *after* the fDataSource data member, in case it is holding the only Python reference to the
134 input dataset and the data source needs to access it before it is destroyed.
135 */
136 std::any fTTreeLifeline{};
137
138 std::vector<RDFInternal::RActionBase *> fBookedActions; ///< Non-owning pointers to actions to be run
139 std::vector<RDFInternal::RActionBase *> fRunActions; ///< Non-owning pointers to actions already run
140 std::vector<RFilterBase *> fBookedFilters;
141 std::vector<RFilterBase *> fBookedNamedFilters; ///< Contains a subset of fBookedFilters, i.e. only the named filters
142 std::vector<RRangeBase *> fBookedRanges;
143 std::vector<RDefineBase *> fBookedDefines;
144 std::vector<RDFInternal::RVariationBase *> fBookedVariations;
145
147 Long64_t fEndEntry{std::numeric_limits<Long64_t>::max()};
148
149 /// Keys are `fname + "/" + treename` as RSampleInfo::fID; Values are pointers to the corresponding sample
150 std::unordered_map<std::string, ROOT::RDF::Experimental::RSample *> fSampleMap;
151 /// Samples need to survive throughout the whole event loop, hence stored as an attribute
152 std::vector<ROOT::RDF::Experimental::RSample> fSamples;
153
155 /// Range of entries created when no data source is specified.
156 std::pair<ULong64_t, ULong64_t> fEmptyEntryRange{};
157 unsigned int fNSlots{1};
159 /// The kind of event loop that is going to be run (e.g. on ROOT files, on no files)
161 std::unique_ptr<RDataSource> fDataSource{}; ///< Owning pointer to a data-source object. Null if no data-source
162 /// Registered callbacks to be executed every N events.
163 /// The registration happens via the RegisterCallback method.
164 std::vector<RDFInternal::RCallback> fCallbacksEveryNEvents;
165 /// Registered callbacks to invoke just once before running the loop.
166 /// The registration happens via the RegisterCallback method.
167 std::vector<RDFInternal::ROneTimeCallback> fCallbacksOnce;
168 /// Registered callbacks to call at the beginning of each "data block".
169 /// The key is the pointer of the corresponding node in the computation graph (a RDefinePerSample or a RAction).
170 std::unordered_map<void *, ROOT::RDF::SampleCallback_t> fSampleCallbacks;
172 std::vector<ROOT::RDF::RSampleInfo> fSampleInfos;
173 unsigned int fNRuns{0}; ///< Number of event loops run
174
175 /// Readers for TTree/RDataSource columns (one per slot), shared by all nodes in the computation graph.
176 std::vector<std::unordered_map<std::string, std::unique_ptr<RColumnReaderBase>>> fDatasetColumnReaders;
177
178 /// Cache of the tree/chain branch names. Never access directy, always use GetBranchNames().
180
181 /// Pointer to a shared slot stack in case this instance runs concurrently with others:
182 std::weak_ptr<ROOT::Internal::RSlotStack> fSlotStack;
183
184 void RunEmptySourceMT();
185 void RunEmptySource();
186 void RunDataSourceMT();
187 void RunDataSource();
188 void RunAndCheckFilters(unsigned int slot, Long64_t entry);
189 void InitNodeSlots(TTreeReader *r, unsigned int slot);
190 void InitNodes();
191 void CleanUpNodes();
192 void CleanUpTask(TTreeReader *r, unsigned int slot);
193 void EvalChildrenCounts();
194 void SetupSampleCallbacks(TTreeReader *r, unsigned int slot);
195 void UpdateSampleInfo(unsigned int slot, const std::pair<ULong64_t, ULong64_t> &range);
196 void UpdateSampleInfo(unsigned int slot, TTreeReader &r);
197 std::shared_ptr<ROOT::Internal::RSlotStack> SlotStack() const;
198
199 // List of branches for which we want to suppress the printed error about
200 // missing branch when switching to a new tree. This is modified by readers,
201 // so must be declared before them in this class.
202 std::set<std::string> fSuppressErrorsForMissingBranches{};
204 std::set<std::pair<std::string_view, std::unique_ptr<ROOT::Internal::RDF::RDefinesWithReaders>>>
206 std::set<std::pair<std::string_view, std::unique_ptr<ROOT::Internal::RDF::RVariationsWithReaders>>>
208
209public:
211 RLoopManager(TTree *tree, const ColumnNames_t &defaultBranches);
213 RLoopManager(std::unique_ptr<RDataSource> ds, const ColumnNames_t &defaultBranches);
215
216 // Rule of five
217
218 RLoopManager(const RLoopManager &) = delete;
222 ~RLoopManager() override;
223
224 void Jit();
226 void Run(bool jit = true);
227 const ColumnNames_t &GetDefaultColumnNames() const;
228 TTree *GetTree() const;
230 RDataSource *GetDataSource() const { return fDataSource.get(); }
241 bool CheckFilters(unsigned int, Long64_t) final;
242 unsigned int GetNSlots() const { return fNSlots; }
243 void Report(ROOT::RDF::RCutFlowReport &rep) const final;
244 /// End of recursive chain of calls, does nothing
248 void ToJitExec(const std::string &) const;
249 void RegisterCallback(ULong64_t everyNEvents, std::function<void(unsigned int)> &&f);
250 unsigned int GetNRuns() const { return fNRuns; }
251 bool HasDataSourceColumnReaders(std::string_view col, const std::type_info &ti) const;
252 void AddDataSourceColumnReaders(std::string_view col, std::vector<std::unique_ptr<RColumnReaderBase>> &&readers,
253 const std::type_info &ti);
254 RColumnReaderBase *AddTreeColumnReader(unsigned int slot, std::string_view col,
255 std::unique_ptr<RColumnReaderBase> &&reader, const std::type_info &ti);
256 RColumnReaderBase *GetDatasetColumnReader(unsigned int slot, std::string_view col, const std::type_info &ti) const;
257 RColumnReaderBase *AddDataSourceColumnReader(unsigned int slot, std::string_view col, const std::type_info &ti,
259
260 /// End of recursive chain of calls, does nothing
261 void AddFilterName(std::vector<std::string> &) final {}
262 /// For each booked filter, returns either the name or "Unnamed Filter"
263 std::vector<std::string> GetFiltersNames();
264
265 /// Return all graph edges known to RLoopManager
266 /// This includes Filters and Ranges but not Defines.
267 std::vector<RNodeBase *> GetGraphEdges() const;
268
269 /// Return all actions, either booked or already run
270 std::vector<RDFInternal::RActionBase *> GetAllActions() const;
271
272 std::shared_ptr<ROOT::Internal::RDF::GraphDrawing::GraphNode>
273 GetGraph(std::unordered_map<void *, std::shared_ptr<ROOT::Internal::RDF::GraphDrawing::GraphNode>> &visitedMap) final;
274
275 const ColumnNames_t &GetBranchNames();
276
278
279 void SetEmptyEntryRange(std::pair<ULong64_t, ULong64_t> &&newRange);
282
284 std::set<std::pair<std::string_view, std::unique_ptr<ROOT::Internal::RDF::RDefinesWithReaders>>> &
289 std::set<std::pair<std::string_view, std::unique_ptr<ROOT::Internal::RDF::RVariationsWithReaders>>> &
294
295 void SetTTreeLifeline(std::any lifeline);
296 /// Register a slot stack to be used by this RLoopManager. This allows for sharing RDataFrame helpers safely in the
297 /// context of RunGraphs(). Note that the loop manager only stores a weak_ptr, in between runs.
298 void SetSlotStack(const std::shared_ptr<ROOT::Internal::RSlotStack> &slotStack) { fSlotStack = slotStack; }
299
300 void SetDataSource(std::unique_ptr<ROOT::RDF::RDataSource> dataSource);
301
310 const std::set<std::string> &GetSuppressErrorsForMissingBranches() const
311 {
313 }
314
315 /// The task run by every thread on the input entry range, for the generic RDataSource.
316 void DataSourceThreadTask(const std::pair<ULong64_t, ULong64_t> &entryRange, ROOT::Internal::RSlotStack &slotStack,
317 std::atomic<ULong64_t> &entryCount);
318 /// The task run by every thread on an entry range (known by the input TTreeReader), for the TTree data source.
319 void
321};
322
323/// \brief Create an RLoopManager that reads a TChain.
324/// \param[in] datasetName Name of the TChain
325/// \param[in] fileNameGlob File name (or glob) in which the TChain is stored.
326/// \param[in] defaultColumns List of default columns, see
327/// \param[in] checkFile file validator boolean
328/// \ref https://root.cern/doc/master/classROOT_1_1RDataFrame.html#default-branches "Default column lists"
329/// \return the RLoopManager instance.
330std::shared_ptr<ROOT::Detail::RDF::RLoopManager>
331CreateLMFromTTree(std::string_view datasetName, std::string_view fileNameGlob,
332 const std::vector<std::string> &defaultColumns, bool checkFile = true);
333
334/// \brief Create an RLoopManager that reads a TChain.
335/// \param[in] datasetName Name of the TChain
336/// \param[in] fileNameGlobs List of file names (potentially globs).
337/// \param[in] defaultColumns List of default columns, see
338/// \param[in] checkFile file validator boolean
339/// \ref https://root.cern/doc/master/classROOT_1_1RDataFrame.html#default-branches "Default column lists"
340/// \return the RLoopManager instance.
341std::shared_ptr<ROOT::Detail::RDF::RLoopManager>
342CreateLMFromTTree(std::string_view datasetName, const std::vector<std::string> &fileNameGlobs,
343 const std::vector<std::string> &defaultColumns, bool checkFile = true);
344
345/// \brief Create an RLoopManager that reads an RNTuple.
346/// \param[in] datasetName Name of the RNTuple
347/// \param[in] fileNameGlob File name (or glob) in which the RNTuple is stored.
348/// \param[in] defaultColumns List of default columns, see
349/// \ref https://root.cern/doc/master/classROOT_1_1RDataFrame.html#default-branches "Default column lists"
350/// \return the RLoopManager instance.
351std::shared_ptr<ROOT::Detail::RDF::RLoopManager> CreateLMFromRNTuple(std::string_view datasetName,
352 std::string_view fileNameGlob,
353 const std::vector<std::string> &defaultColumns);
354
355/// \brief Create an RLoopManager that reads multiple RNTuples chained vertically.
356/// \param[in] datasetName Name of the RNTuple
357/// \param[in] fileNameGlobs List of file names (potentially globs).
358/// \param[in] defaultColumns List of default columns, see
359/// \ref https://root.cern/doc/master/classROOT_1_1RDataFrame.html#default-branches "Default column lists"
360/// \return the RLoopManager instance.
361std::shared_ptr<ROOT::Detail::RDF::RLoopManager> CreateLMFromRNTuple(std::string_view datasetName,
362 const std::vector<std::string> &fileNameGlobs,
363 const std::vector<std::string> &defaultColumns);
364
365/// \brief Create an RLoopManager opening a file and checking the data format of the dataset.
366/// \param[in] datasetName Name of the dataset in the file.
367/// \param[in] fileNameGlob File name (or glob) in which the dataset is stored.
368/// \param[in] defaultColumns List of default columns, see
369/// \ref https://root.cern/doc/master/classROOT_1_1RDataFrame.html#default-branches "Default column lists"
370/// \throws std::invalid_argument if the file could not be opened.
371/// \return an RLoopManager of the appropriate data source.
372std::shared_ptr<ROOT::Detail::RDF::RLoopManager> CreateLMFromFile(std::string_view datasetName,
373 std::string_view fileNameGlob,
374 const std::vector<std::string> &defaultColumns);
375
376/// \brief Create an RLoopManager that reads many files. The first is opened to infer the data source type.
377/// \param[in] datasetName Name of the dataset.
378/// \param[in] fileNameGlobs List of file names (potentially globs).
379/// \param[in] defaultColumns List of default columns, see
380/// \ref https://root.cern/doc/master/classROOT_1_1RDataFrame.html#default-branches "Default column lists"
381/// \throws std::invalid_argument if the file could not be opened.
382/// \return an RLoopManager of the appropriate data source.
383std::shared_ptr<ROOT::Detail::RDF::RLoopManager> CreateLMFromFile(std::string_view datasetName,
384 const std::vector<std::string> &fileNameGlobs,
385 const std::vector<std::string> &defaultColumns);
386
387} // namespace RDF
388} // namespace Detail
389} // namespace ROOT
390
391#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.
RColumnReaderBase * AddDataSourceColumnReader(unsigned int slot, std::string_view col, const std::type_info &ti, TTreeReader *treeReader)
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
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.
const std::set< std::string > & GetSuppressErrorsForMissingBranches() const
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.
void AddDataSourceColumnReaders(std::string_view col, std::vector< std::unique_ptr< RColumnReaderBase > > &&readers, const std::type_info &ti)
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
std::set< std::string > fSuppressErrorsForMissingBranches
void ChangeSpec(ROOT::RDF::Experimental::RDatasetSpec &&spec)
Changes the internal TTree held by the RLoopManager.
std::weak_ptr< ROOT::Internal::RSlotStack > fSlotStack
Pointer to a shared slot stack in case this instance runs concurrently with others:
std::set< std::pair< std::string_view, std::unique_ptr< ROOT::Internal::RDF::RVariationsWithReaders > > > & GetUniqueVariationsWithReaders()
std::vector< RDefineBase * > fBookedDefines
void TTreeThreadTask(TTreeReader &treeReader, ROOT::Internal::RSlotStack &slotStack, std::atomic< ULong64_t > &entryCount)
The task run by every thread on an entry range (known by the input TTreeReader), for the TTree data s...
void InsertSuppressErrorsForMissingBranch(const std::string &branchName)
RColumnReaderBase * AddTreeColumnReader(unsigned int slot, std::string_view col, std::unique_ptr< RColumnReaderBase > &&reader, const std::type_info &ti)
Register a new RTreeColumnReader with this RLoopManager.
std::vector< RDFInternal::RActionBase * > fRunActions
Non-owning pointers to actions already run.
RLoopManager(const ColumnNames_t &defaultColumns={})
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< RDFInternal::RActionBase * > fBookedActions
Non-owning pointers to actions to be run.
RLoopManager(RLoopManager &&)=delete
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< 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()
void EraseSuppressErrorsForMissingBranch(const std::string &branchName)
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.
void SetSlotStack(const std::shared_ptr< ROOT::Internal::RSlotStack > &slotStack)
Register a slot stack to be used by this RLoopManager.
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.
void DataSourceThreadTask(const std::pair< ULong64_t, ULong64_t > &entryRange, ROOT::Internal::RSlotStack &slotStack, std::atomic< ULong64_t > &entryCount)
The task run by every thread on the input entry range, for the generic RDataSource.
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.
RColumnReaderBase * GetDatasetColumnReader(unsigned int slot, std::string_view col, const std::type_info &ti) const
std::shared_ptr< ROOT::Internal::RSlotStack > SlotStack() const
Create a slot stack with the desired number of slots or reuse a shared instance.
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.
bool HasDataSourceColumnReaders(std::string_view col, const std::type_info &ti) const
Return true if AddDataSourceColumnReaders was called for column name col.
RLoopManager * GetLoopManagerUnchecked() final
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:296
This type includes all parts of RVariation that do not depend on the callable signature.
A thread-safe list of N indexes (0 to size - 1).
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:46
A TTree represents a columnar dataset.
Definition TTree.h:84
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::shared_ptr< ROOT::Detail::RDF::RLoopManager > CreateLMFromFile(std::string_view datasetName, std::string_view fileNameGlob, const std::vector< std::string > &defaultColumns)
Create an RLoopManager opening a file and checking the data format of the dataset.
std::shared_ptr< ROOT::Detail::RDF::RLoopManager > CreateLMFromRNTuple(std::string_view datasetName, std::string_view fileNameGlob, const std::vector< std::string > &defaultColumns)
Create an RLoopManager that reads an RNTuple.
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.