55#include <unordered_map>
69std::string &GetCodeToJit()
71 static std::string code;
75bool ContainsLeaf(
const std::set<TLeaf *> &leaves,
TLeaf *leaf)
77 return (leaves.find(leaf) != leaves.end());
83void InsertBranchName(std::set<std::string> &bNamesReg,
ColumnNames_t &bNames,
const std::string &branchName,
84 const std::string &friendName,
bool allowDuplicates)
86 if (!friendName.empty()) {
88 const auto friendBName = friendName +
"." + branchName;
89 if (bNamesReg.insert(friendBName).second)
90 bNames.push_back(friendBName);
93 if (allowDuplicates || friendName.empty()) {
94 if (bNamesReg.insert(branchName).second)
95 bNames.push_back(branchName);
101void InsertBranchName(std::set<std::string> &bNamesReg,
ColumnNames_t &bNames,
const std::string &branchName,
102 const std::string &friendName, std::set<TLeaf *> &foundLeaves,
TLeaf *leaf,
103 bool allowDuplicates)
105 const bool canAdd = allowDuplicates ? true : !ContainsLeaf(foundLeaves, leaf);
110 InsertBranchName(bNamesReg, bNames, branchName, friendName, allowDuplicates);
112 foundLeaves.insert(leaf);
116 std::string prefix, std::string &friendName,
bool allowDuplicates)
118 for (
auto sb : *
b->GetListOfBranches()) {
120 auto subBranchName = std::string(subBranch->
GetName());
121 auto fullName = prefix + subBranchName;
123 std::string newPrefix;
125 newPrefix = fullName +
".";
127 ExploreBranch(t, bNamesReg, bNames, subBranch, newPrefix, friendName, allowDuplicates);
129 auto branchDirectlyFromTree = t.
GetBranch(fullName.c_str());
130 if (!branchDirectlyFromTree)
131 branchDirectlyFromTree = t.
FindBranch(fullName.c_str());
132 if (branchDirectlyFromTree)
133 InsertBranchName(bNamesReg, bNames, std::string(branchDirectlyFromTree->GetFullName()), friendName,
136 if (bNamesReg.find(subBranchName) == bNamesReg.end() && t.
GetBranch(subBranchName.c_str()))
137 InsertBranchName(bNamesReg, bNames, subBranchName, friendName, allowDuplicates);
141void GetBranchNamesImpl(
TTree &t, std::set<std::string> &bNamesReg,
ColumnNames_t &bNames,
142 std::set<TTree *> &analysedTrees, std::string &friendName,
bool allowDuplicates)
144 std::set<TLeaf *> foundLeaves;
145 if (!analysedTrees.insert(&t).second) {
154 std::string err(
"GetBranchNames: error in opening the tree ");
156 throw std::runtime_error(err);
159 for (
auto b : *branches) {
161 const auto branchName = std::string(branch->
GetName());
165 if (listOfLeaves->GetEntriesUnsafe() == 1) {
166 auto leaf =
static_cast<TLeaf *
>(listOfLeaves->UncheckedAt(0));
167 InsertBranchName(bNamesReg, bNames, branchName, friendName, foundLeaves, leaf, allowDuplicates);
170 for (
auto leaf : *listOfLeaves) {
171 auto castLeaf =
static_cast<TLeaf *
>(leaf);
172 const auto leafName = std::string(leaf->
GetName());
173 const auto fullName = branchName +
"." + leafName;
174 InsertBranchName(bNamesReg, bNames, fullName, friendName, foundLeaves, castLeaf, allowDuplicates);
178 ExploreBranch(t, bNamesReg, bNames, branch, branchName +
".", friendName, allowDuplicates);
179 InsertBranchName(bNamesReg, bNames, branchName, friendName, allowDuplicates);
184 bool dotIsImplied =
false;
187 throw std::runtime_error(
"GetBranchNames: unsupported branch type");
189 if (be->GetType() == 3 || be->GetType() == 4)
192 if (dotIsImplied || branchName.back() ==
'.')
193 ExploreBranch(t, bNamesReg, bNames, branch,
"", friendName, allowDuplicates);
195 ExploreBranch(t, bNamesReg, bNames, branch, branchName +
".", friendName, allowDuplicates);
197 InsertBranchName(bNamesReg, bNames, branchName, friendName, allowDuplicates);
210 for (
auto friendTreeObj : *friendTrees) {
215 if (alias !=
nullptr)
216 frName = std::string(alias);
218 frName = std::string(friendTree->GetName());
220 GetBranchNamesImpl(*friendTree, bNamesReg, bNames, analysedTrees, frName, allowDuplicates);
224void ThrowIfNSlotsChanged(
unsigned int nSlots)
227 if (currentSlots != nSlots) {
228 std::string msg =
"RLoopManager::Run: when the RDataFrame was constructed the number of slots required was " +
229 std::to_string(nSlots) +
", but when starting the event loop it was " +
230 std::to_string(currentSlots) +
".";
231 if (currentSlots > nSlots)
232 msg +=
" Maybe EnableImplicitMT() was called after the RDataFrame was constructed?";
234 msg +=
" Maybe DisableImplicitMT() was called after the RDataFrame was constructed?";
235 throw std::runtime_error(msg);
247struct MaxTreeSizeRAII {
250 MaxTreeSizeRAII() : fOldMaxTreeSize(
TTree::GetMaxTreeSize())
258struct DatasetLogInfo {
259 std::string fDataSet;
265std::string LogRangeProcessing(
const DatasetLogInfo &info)
267 std::stringstream msg;
268 msg <<
"Processing " << info.fDataSet <<
": entry range [" << info.fRangeStart <<
"," << info.fRangeEnd - 1
269 <<
"], using slot " << info.fSlot <<
" in thread " << std::this_thread::get_id() <<
'.';
273DatasetLogInfo TreeDatasetLogInfo(
const TTreeReader &
r,
unsigned int slot)
275 const auto tree =
r.GetTree();
276 const auto chain =
dynamic_cast<TChain *
>(
tree);
280 std::vector<std::string> treeNames;
281 std::vector<std::string> fileNames;
283 treeNames.emplace_back(
f->GetName());
284 fileNames.emplace_back(
f->GetTitle());
287 for (
const auto &t : treeNames) {
291 what +=
" in files {";
292 for (
const auto &
f : fileNames) {
297 assert(tree !=
nullptr);
298 const auto treeName =
tree->GetName();
299 what = std::string(
"tree \"") + treeName +
"\"";
300 const auto file =
tree->GetCurrentFile();
302 what += std::string(
" in file \"") + file->GetName() +
"\"";
304 const auto entryRange =
r.GetEntriesRange();
305 const ULong64_t end = entryRange.second == -1ll ?
tree->GetEntries() : entryRange.second;
306 return {std::move(
what),
static_cast<ULong64_t>(entryRange.first), end, slot};
309auto MakeDatasetColReadersKey(
const std::string &colName,
const std::type_info &ti)
315 return colName +
':' + ti.name();
344 std::set<std::string> bNamesSet;
346 std::set<TTree *> analysedTrees;
347 std::string emptyFrName =
"";
348 GetBranchNamesImpl(t, bNamesSet, bNames, analysedTrees, emptyFrName, allowDuplicates);
353 : fTree(std::shared_ptr<
TTree>(tree, [](
TTree *) {})),
354 fDefaultColumns(defaultBranches),
357 fNewSampleNotifier(fNSlots),
358 fSampleInfos(fNSlots),
359 fDatasetColumnReaders(fNSlots)
364 : fTree(std::move(tree)),
365 fDefaultColumns(defaultBranches),
368 fNewSampleNotifier(fNSlots),
369 fSampleInfos(fNSlots),
370 fDatasetColumnReaders(fNSlots)
375 : fEmptyEntryRange(0, nEmptyEntries),
378 fNewSampleNotifier(fNSlots),
379 fSampleInfos(fNSlots),
380 fDatasetColumnReaders(fNSlots)
385 : fDefaultColumns(defaultBranches),
388 fDataSource(std::move(ds)),
389 fNewSampleNotifier(fNSlots),
390 fSampleInfos(fNSlots),
391 fDatasetColumnReaders(fNSlots)
399 fNewSampleNotifier(fNSlots),
400 fSampleInfos(fNSlots),
401 fDatasetColumnReaders(fNSlots)
432 const auto &trees = sample.GetTreeNames();
433 const auto &files = sample.GetFileNameGlobs();
434 for (std::size_t i = 0ul; i < files.size(); ++i) {
437 const auto fullpath = files[i] +
"?#" + trees[i];
438 chain->Add(fullpath.c_str());
442 const auto sampleId = files[i] +
'/' + trees[i];
449 const auto &friendInfo = spec.GetFriendInfo();
451 for (std::size_t i = 0ul; i <
fFriends.size(); i++) {
452 const auto &thisFriendAlias = friendInfo.fFriendNames[i].second;
453 fTree->AddFriend(
fFriends[i].get(), thisFriendAlias.c_str());
465 const auto nEntriesPerSlot = nEmptyEntries / (
fNSlots * 2);
466 auto remainder = nEmptyEntries % (
fNSlots * 2);
467 std::vector<std::pair<ULong64_t, ULong64_t>> entryRanges;
475 entryRanges.emplace_back(begin, end);
480 auto genFunction = [
this, &slotStack](
const std::pair<ULong64_t, ULong64_t> &range) {
482 auto slot = slotRAII.
fSlot;
488 for (
auto currEntry = range.first; currEntry < range.second; ++currEntry) {
493 std::cerr <<
"RDataFrame::Run: event loop was interrupted\n";
499 pool.
Foreach(genFunction, entryRanges);
518 std::cerr <<
"RDataFrame::Run: event loop was interrupted\n";
543 default:
return false;
562 std::atomic<ULong64_t> entryCount(0ull);
564 tp->Process([
this, &slotStack, &entryCount](
TTreeReader &
r) ->
void {
566 auto slot = slotRAII.
fSlot;
570 const auto entryRange =
r.GetEntriesRange();
571 const auto nEntries = entryRange.second - entryRange.first;
572 auto count = entryCount.fetch_add(nEntries);
575 while (validTTreeReaderRead(
r)) {
582 std::cerr <<
"RDataFrame::Run: event loop was interrupted\n";
589 throw std::runtime_error(
"An error was encountered while processing the data. TTreeReader status code is: " +
590 std::to_string(
r.GetEntryStatus()));
608 throw std::logic_error(
"Something went wrong in initializing the TTreeReader.");
624 std::cerr <<
"RDataFrame::Run: event loop was interrupted\n";
629 throw std::runtime_error(
"An error was encountered while processing the data. TTreeReader status code is: " +
630 std::to_string(
r.GetEntryStatus()));
645 for (
const auto &range : ranges) {
646 const auto start = range.first;
647 const auto end = range.second;
656 std::cerr <<
"RDataFrame::Run: event loop was interrupted\n";
674 auto runOnRange = [
this, &slotStack](
const std::pair<ULong64_t, ULong64_t> &range) {
676 const auto slot = slotRAII.
fSlot;
680 const auto start = range.first;
681 const auto end = range.second;
684 for (
auto entry = start; entry < end; ++entry) {
690 std::cerr <<
"RDataFrame::Run: event loop was interrupted\n";
698 while (!ranges.empty()) {
699 pool.
Foreach(runOnRange, ranges);
718 actionPtr->Run(slot, entry);
720 namedFilterPtr->CheckFilters(slot, entry);
732 ptr->InitSlot(
r, slot);
734 ptr->InitSlot(
r, slot);
736 ptr->InitSlot(
r, slot);
738 ptr->InitSlot(
r, slot);
760 "Empty source, range: {" + std::to_string(range.first) +
", " + std::to_string(range.second) +
"}", range);
765 auto *tree =
r.GetTree()->GetTree();
768 auto *file = tree->GetCurrentFile();
769 const std::string fname = file !=
nullptr ? file->GetName() :
"#inmemorytree#";
771 std::pair<Long64_t, Long64_t> range =
r.GetEntriesRange();
773 if (range.second == -1) {
774 range.second = tree->GetEntries();
777 const std::string &
id = fname + (treename.rfind(
'/', 0) == 0 ?
"" :
"/") + treename;
782 throw std::runtime_error(
"Full sample identifier '" +
id +
"' cannot be found in the available samples.");
818 ptr->ResetChildrenCount();
820 ptr->ResetChildrenCount();
832 ptr->FinalizeSlot(slot);
834 ptr->FinalizeSlot(slot);
836 ptr->FinalizeSlot(slot);
852 if (GetCodeToJit().empty()) {
858 const std::string code = []() {
860 return std::move(GetCodeToJit());
869 :
" in less than 1ms.");
881 actionPtr->TriggerChildrenCount();
883 namedFilterPtr->TriggerChildrenCount();
892 MaxTreeSizeRAII ctxtmts;
906 class NodesCleanerRAII {
910 NodesCleanerRAII(
RLoopManager &thisRLM) : fRLM(thisRLM) {}
914 NodesCleanerRAII runKeeper(*
this);
1015 fPtr->FillReport(rep);
1020 fTree = std::move(tree);
1030 GetCodeToJit().append(code);
1035 if (everyNEvents == 0ull)
1043 std::vector<std::string>
filters;
1045 auto name = (filter->HasName() ? filter->GetName() :
"Unnamed Filter");
1068 std::unordered_map<
void *, std::shared_ptr<ROOT::Internal::RDF::GraphDrawing::GraphNode>> &visitedMap)
1071 auto duplicateRLoopManagerIt = visitedMap.find((
void *)
this);
1072 if (duplicateRLoopManagerIt != visitedMap.end())
1073 return duplicateRLoopManagerIt->second;
1085 auto thisNode = std::make_shared<ROOT::Internal::RDF::GraphDrawing::GraphNode>(
1087 visitedMap[(
void *)
this] = thisNode;
1105 const auto key = MakeDatasetColReadersKey(col, ti);
1113 std::vector<std::unique_ptr<RColumnReaderBase>> &&readers,
1114 const std::type_info &ti)
1116 const auto key = MakeDatasetColReadersKey(col, ti);
1118 assert(readers.size() ==
fNSlots);
1120 for (
auto slot = 0u; slot <
fNSlots; ++slot) {
1129 std::unique_ptr<RColumnReaderBase> &&reader,
1130 const std::type_info &ti)
1133 const auto key = MakeDatasetColReadersKey(col, ti);
1135 assert(readers.find(key) == readers.end() || readers[key] ==
nullptr);
1136 auto *rptr = reader.get();
1137 readers[key] = std::move(reader);
1144 const auto key = MakeDatasetColReadersKey(col, ti);
1147 return it->second.get();
1170 bool fileIsGlob = [&fileNameGlob]() {
1171 const std::vector<std::string_view> wildcards = {
"[",
"]",
"*",
"?"};
1172 return std::any_of(wildcards.begin(), wildcards.end(),
1173 [&fileNameGlob](
const auto &wc) { return fileNameGlob.find(wc) != std::string_view::npos; });
1181 std::unique_ptr<TFile> inFile{
TFile::Open(fileToOpen.c_str(),
"READ_WITHOUT_GLOBALREGISTRATION")};
1182 if (!inFile || inFile->IsZombie())
1183 throw std::invalid_argument(
"RDataFrame: could not open file \"" + fileToOpen +
"\".");
1188std::shared_ptr<ROOT::Detail::RDF::RLoopManager>
1198 std::string datasetNameInt{datasetName};
1199 std::string fileNameGlobInt{fileNameGlob};
1201 chain->Add(fileNameGlobInt.c_str());
1202 auto lm = std::make_shared<ROOT::Detail::RDF::RLoopManager>(std::move(chain), defaultColumns);
1206std::shared_ptr<ROOT::Detail::RDF::RLoopManager>
1208 const std::vector<std::string> &defaultColumns,
bool checkFile)
1216 std::string treeNameInt(datasetName);
1218 for (
auto &
f : fileNameGlobs)
1219 chain->Add(
f.c_str());
1220 auto lm = std::make_shared<ROOT::Detail::RDF::RLoopManager>(std::move(chain), defaultColumns);
1225std::shared_ptr<ROOT::Detail::RDF::RLoopManager>
1226ROOT::Detail::RDF::CreateLMFromRNTuple(std::string_view datasetName, std::string_view fileNameGlob,
1229 auto dataSource = std::make_unique<ROOT::Experimental::RNTupleDS>(datasetName, fileNameGlob);
1230 auto lm = std::make_shared<ROOT::Detail::RDF::RLoopManager>(std::move(dataSource), defaultColumns);
1234std::shared_ptr<ROOT::Detail::RDF::RLoopManager>
1235ROOT::Detail::RDF::CreateLMFromRNTuple(std::string_view datasetName,
const std::vector<std::string> &fileNameGlobs,
1238 auto dataSource = std::make_unique<ROOT::Experimental::RNTupleDS>(datasetName, fileNameGlobs);
1239 auto lm = std::make_shared<ROOT::Detail::RDF::RLoopManager>(std::move(dataSource), defaultColumns);
1243std::shared_ptr<ROOT::Detail::RDF::RLoopManager>
1244ROOT::Detail::RDF::CreateLMFromFile(std::string_view datasetName, std::string_view fileNameGlob,
1250 if (inFile->Get<
TTree>(datasetName.data())) {
1253 return CreateLMFromRNTuple(datasetName, fileNameGlob, defaultColumns);
1256 throw std::invalid_argument(
"RDataFrame: unsupported data format for dataset \"" + std::string(datasetName) +
1257 "\" in file \"" + inFile->GetName() +
"\".");
1260std::shared_ptr<ROOT::Detail::RDF::RLoopManager>
1261ROOT::Detail::RDF::CreateLMFromFile(std::string_view datasetName,
const std::vector<std::string> &fileNameGlobs,
1267 if (inFile->Get<
TTree>(datasetName.data())) {
1270 return CreateLMFromRNTuple(datasetName, fileNameGlobs, defaultColumns);
1273 throw std::invalid_argument(
"RDataFrame: unsupported data format for dataset \"" + std::string(datasetName) +
1274 "\" in file \"" + inFile->GetName() +
"\".");
#define R__LOG_DEBUG(DEBUGLEVEL,...)
std::unique_ptr< TFile > OpenFileWithSanityChecks(std::string_view fileNameGlob)
Helper function to open a file (or the first file from a glob).
unsigned long long ULong64_t
#define R__ASSERT(e)
Checks condition e and reports a fatal error if it's false.
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
#define R__WRITE_LOCKGUARD(mutex)
#define R__READ_LOCKGUARD(mutex)
The head node of a RDF computation graph.
void UpdateSampleInfo(unsigned int slot, const std::pair< ULong64_t, ULong64_t > &range)
RLoopManager(TTree *tree, const ColumnNames_t &defaultBranches)
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.
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.
ULong64_t GetNEmptyEntries() const
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
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
bool fMustRunNamedFilters
void ChangeSpec(ROOT::RDF::Experimental::RDatasetSpec &&spec)
Changes the internal TTree held by the RLoopManager.
void SetTree(std::shared_ptr< TTree > tree)
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.
RColumnReaderBase * GetDatasetColumnReader(unsigned int slot, const std::string &col, const std::type_info &ti) const
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.
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::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.
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.
const ELoopType fLoopType
The kind of event loop that is going to be run (e.g. on ROOT files, on no files)
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< 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.
const unsigned int fNSlots
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.
unsigned int GetNSlots() const
void RunDataSourceMT()
Run event loop over data accessed through a DataSource, in parallel.
std::vector< std::string > GetFiltersNames()
For each booked filter, returns either the name or "Unnamed Filter".
const std::unique_ptr< RDataSource > fDataSource
Owning pointer to a data-source object.
RDFInternal::RNewSampleNotifier fNewSampleNotifier
std::pair< ULong64_t, ULong64_t > fEmptyEntryRange
Range of entries created when no data source is specified.
const ColumnNames_t fDefaultColumns
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 RegisterCallback(ULong64_t everyNEvents, std::function< void(unsigned int)> &&f)
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)
void InitNodes()
Initialize all nodes of the functional graph before running the event loop.
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.
unsigned int fNStopsReceived
Number of times that a children node signaled to stop processing entries.
unsigned int fNChildren
Number of nodes of the functional graph hanging from this object.
Representation of an RNTuple data set in a ROOT file.
virtual ROOT::RDF::SampleCallback_t GetSampleCallback()=0
void SetFlag(unsigned int slot)
bool CheckFlag(unsigned int slot) const
void UnsetFlag(unsigned int slot)
TNotifyLink< RNewSampleFlag > & GetChainNotifyLink(unsigned int slot)
This type includes all parts of RVariation that do not depend on the callable signature.
A thread-safe stack of N indexes (0 to size - 1).
void RegisterChain(TChain &c)
The dataset specification for RDataFrame.
This type represents a sample identifier, to be used in conjunction with RDataFrame features such as ...
This class provides a simple interface to execute the same task multiple times in parallel threads,...
void Foreach(F func, unsigned nTimes, unsigned nChunks=0)
Execute a function without arguments several times in parallel, dividing the execution in nChunks.
A Branch for the case of an object.
A TTree is a list of TBranches.
TClass * IsA() const override
TObjArray * GetListOfLeaves()
A chain is a collection of files containing TTree objects.
TObjArray * GetListOfFiles() const
TDirectory::TContext keeps track and restore the current directory.
A List of entry numbers in a TTree or TChain.
static TFile * Open(const char *name, Option_t *option="", const char *ftitle="", Int_t compress=ROOT::RCompressionSetting::EDefaults::kUseCompiledDefault, Int_t netopt=0)
Create / open a file.
A TFriendElement TF describes a TTree object TF in a file.
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
const char * GetName() const override
Returns name of object.
Mother of all ROOT objects.
Double_t RealTime()
Stop the stopwatch (if it is running) and return the realtime (in seconds) passed between the start a...
void Start(Bool_t reset=kTRUE)
Start the stopwatch.
Double_t CpuTime()
Stop the stopwatch (if it is running) and return the cputime (in seconds) passed between the start an...
void Stop()
Stop the stopwatch.
A simple, robust and fast interface to read values from ROOT columnar datasets such as TTree,...
@ kIndexedFriendNoMatch
A friend with TTreeIndex doesn't have an entry for this index.
@ kMissingBranchWhenSwitchingTree
A branch was not found when switching to the next TTree in the chain.
@ kEntryBeyondEnd
last entry loop has reached its end
@ kEntryValid
data read okay
EEntryStatus GetEntryStatus() const
bool Next()
Move to the next entry (or index of the TEntryList if that is set).
A TTree represents a columnar dataset.
virtual TBranch * FindBranch(const char *name)
Return the branch that correspond to the path 'branchname', which can include the name of the tree or...
virtual TBranch * GetBranch(const char *name)
Return pointer to the branch with the given name in this tree or its friends.
static void SetMaxTreeSize(Long64_t maxsize=100000000000LL)
Set the maximum size in bytes of a Tree file (static function).
virtual TObjArray * GetListOfBranches()
virtual TTree * GetTree() const
virtual TList * GetListOfFriends() const
virtual const char * GetFriendAlias(TTree *) const
If the 'tree' is a friend, this method returns its alias name.
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.
ROOT::Experimental::RLogChannel & RDFLogChannel()
std::vector< std::string > GetBranchNames(TTree &t, bool allowDuplicates=true)
Get all the branches names, including the ones of the friend trees.
void Erase(const T &that, std::vector< T > &v)
Erase that element from vector v
Long64_t InterpreterCalc(const std::string &code, const std::string &context="")
Jit code in the interpreter with TInterpreter::Calc, throw in case of errors.
std::vector< std::string > GetTreeFullPaths(const TTree &tree)
std::unique_ptr< TChain > MakeChainForMT(const std::string &name="", const std::string &title="")
Create a TChain object with options that avoid common causes of thread contention.
std::vector< std::unique_ptr< TChain > > MakeFriends(const ROOT::TreeUtils::RFriendInfo &finfo)
Create friends from the main TTree.
std::vector< std::string > ExpandGlob(const std::string &glob)
Expands input glob into a collection of full paths to files.
std::vector< std::string > ColumnNames_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...
Bool_t IsImplicitMTEnabled()
Returns true if the implicit multi-threading in ROOT is enabled.
R__EXTERN TVirtualRWMutex * gCoreMutex
A RAII object that calls RLoopManager::CleanUpTask at destruction.
RCallCleanUpTask(RLoopManager &lm, unsigned int arg=0u, TTreeReader *reader=nullptr)
RLoopManager & fLoopManager
A RAII object to pop and push slot numbers from a RSlotStack object.