Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RVariedAction.hxx
Go to the documentation of this file.
1// Author: Enrico Guiraud, CERN 11/2021
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_RVARIEDACTION
12#define ROOT_RVARIEDACTION
13
14#include "ColumnReaderUtils.hxx"
15#include "GraphNode.hxx"
16#include "RActionBase.hxx"
17#include "RColumnReaderBase.hxx"
18#include "RLoopManager.hxx"
19#include "RJittedFilter.hxx"
22
23#include <Rtypes.h> // R__CLING_PTRCHECK
24#include <ROOT/TypeTraits.hxx>
25
26#include <algorithm>
27#include <array>
28#include <memory>
29#include <utility> // make_index_sequence
30#include <vector>
31
32namespace ROOT {
33namespace Internal {
34namespace RDF {
35
37
38/// Just like an RAction, but it has N action helpers and N previous nodes (N is the number of variations).
39template <typename Helper, typename PrevNode, typename ColumnTypes_t>
40class R__CLING_PTRCHECK(off) RVariedAction final : public RActionBase {
41 using TypeInd_t = std::make_index_sequence<ColumnTypes_t::list_size>;
42 // If the PrevNode is a RJittedFilter, our collection of previous nodes will have to use the RNodeBase type:
43 // we'll have a RJittedFilter for the nominal case, but the others will be concrete filters.
44 using PrevNodeType = std::conditional_t<std::is_same<PrevNode, RJittedFilter>::value, RFilterBase, PrevNode>;
45
46 std::vector<Helper> fHelpers; ///< Action helpers per variation.
47 /// Owning pointers to upstream nodes for each systematic variation.
48 std::vector<std::shared_ptr<PrevNodeType>> fPrevNodes;
49
50 /// Column readers per slot (outer dimension), per variation and per input column (inner dimension, std::array).
51 std::vector<std::vector<std::array<RColumnReaderBase *, ColumnTypes_t::list_size>>> fInputValues;
52
53 /// The nth flag signals whether the nth input column is a custom column or not.
54 std::array<bool, ColumnTypes_t::list_size> fIsDefine;
55
56 /// \brief Creates new filter nodes, one per variation, from the upstream nominal one.
57 /// \param nominal The nominal filter
58 /// \return The varied filters
59 ///
60 /// The nominal filter is not included in the return value.
61 std::vector<std::shared_ptr<PrevNodeType>> MakePrevFilters(std::shared_ptr<PrevNode> nominal) const
62 {
63 const auto &variations = GetVariations();
64 std::vector<std::shared_ptr<PrevNodeType>> prevFilters;
65 prevFilters.reserve(variations.size());
66 if (static_cast<RNodeBase *>(nominal.get()) == fLoopManager) {
67 // just fill this with the RLoopManager N times
68 prevFilters.resize(variations.size(), nominal);
69 } else {
70 // create varied versions of the previous filter node
71 const auto &prevVariations = nominal->GetVariations();
72 for (const auto &variation : variations) {
73 if (IsStrInVec(variation, prevVariations)) {
74 prevFilters.emplace_back(std::static_pointer_cast<PrevNodeType>(nominal->GetVariedFilter(variation)));
75 } else {
76 prevFilters.emplace_back(nominal);
77 }
78 }
79 }
80
81 return prevFilters;
82 }
83
85 {
86 // The column register and names are private members of RActionBase
87 const auto &colRegister = GetColRegister();
88 const auto &columnNames = GetColumnNames();
89
90 fLoopManager->Register(this);
91
92 for (auto i = 0u; i < columnNames.size(); ++i) {
93 auto *define = colRegister.GetDefine(columnNames[i]);
94 fIsDefine[i] = define != nullptr;
95 if (fIsDefine[i])
96 define->MakeVariations(GetVariations());
97 }
98 }
99
100 /// This constructor takes in input a vector of previous nodes, motivated by the CloneAction logic.
101 RVariedAction(std::vector<Helper> &&helpers, const ColumnNames_t &columns,
102 const std::vector<std::shared_ptr<PrevNodeType>> &prevNodes, const RColumnRegister &colRegister)
103 : RActionBase(prevNodes[0]->GetLoopManagerUnchecked(), columns, colRegister, prevNodes[0]->GetVariations()),
104 fHelpers(std::move(helpers)),
105 fPrevNodes(prevNodes),
106 fInputValues(GetNSlots())
107 {
108 SetupClass();
109 }
110
111public:
112 RVariedAction(std::vector<Helper> &&helpers, const ColumnNames_t &columns, std::shared_ptr<PrevNode> prevNode,
113 const RColumnRegister &colRegister)
114 : RActionBase(prevNode->GetLoopManagerUnchecked(), columns, colRegister, prevNode->GetVariations()),
115 fHelpers(std::move(helpers)),
116 fPrevNodes(MakePrevFilters(prevNode)),
117 fInputValues(GetNSlots())
118 {
119 SetupClass();
120 }
121
122 RVariedAction(const RVariedAction &) = delete;
124
125 ~RVariedAction() { fLoopManager->Deregister(this); }
126
127 void Initialize() final
128 {
129 std::for_each(fHelpers.begin(), fHelpers.end(), [](Helper &h) { h.Initialize(); });
130 }
131
132 void InitSlot(TTreeReader *r, unsigned int slot) final
133 {
134 RColumnReadersInfo info{GetColumnNames(), GetColRegister(), fIsDefine.data(), *fLoopManager};
135
136 // get readers for each systematic variation
137 for (const auto &variation : GetVariations())
138 fInputValues[slot].emplace_back(GetColumnReaders(slot, r, ColumnTypes_t{}, info, variation));
139
140 std::for_each(fHelpers.begin(), fHelpers.end(), [=](Helper &h) { h.InitTask(r, slot); });
141 }
142
143 template <typename... ColTypes, std::size_t... S>
144 void
145 CallExec(unsigned int slot, unsigned int varIdx, Long64_t entry, TypeList<ColTypes...>, std::index_sequence<S...>)
146 {
147 fHelpers[varIdx].Exec(slot, fInputValues[slot][varIdx][S]->template Get<ColTypes>(entry)...);
148 (void)entry;
149 }
150
151 void Run(unsigned int slot, Long64_t entry) final
152 {
153 for (auto varIdx = 0u; varIdx < GetVariations().size(); ++varIdx) {
154 if (fPrevNodes[varIdx]->CheckFilters(slot, entry))
155 CallExec(slot, varIdx, entry, ColumnTypes_t{}, TypeInd_t{});
156 }
157 }
158
160 {
161 std::for_each(fPrevNodes.begin(), fPrevNodes.end(), [](auto &f) { f->IncrChildrenCount(); });
162 }
163
164 /// Clean-up operations to be performed at the end of a task.
165 void FinalizeSlot(unsigned int slot) final
166 {
167 fInputValues[slot].clear();
168 std::for_each(fHelpers.begin(), fHelpers.end(), [=](Helper &h) { h.CallFinalizeTask(slot); });
169 }
170
171 /// Clean-up and finalize the action result (e.g. merging slot-local results).
172 /// It invokes the helper's Finalize method.
173 void Finalize() final
174 {
175 std::for_each(fHelpers.begin(), fHelpers.end(), [](Helper &h) { h.Finalize(); });
176 SetHasRun();
177 }
178
179 /// Return the partially-updated value connected to the first variation.
180 void *PartialUpdate(unsigned int slot) final { return PartialUpdateImpl(slot); }
181
182 /// Return a callback that in turn runs the callbacks of each variation's helper.
184 {
185 if (fHelpers[0].GetSampleCallback()) {
186 std::vector<ROOT::RDF::SampleCallback_t> callbacks;
187 for (auto &h : fHelpers)
188 callbacks.push_back(h.GetSampleCallback());
189
190 auto callEachCallback = [cs = std::move(callbacks)](unsigned int slot, const RSampleInfo &info) {
191 for (auto &c : cs)
192 c(slot, info);
193 };
194
195 return callEachCallback;
196 }
197
198 return {};
199 }
200
201 std::shared_ptr<RDFGraphDrawing::GraphNode>
202 GetGraph(std::unordered_map<void *, std::shared_ptr<RDFGraphDrawing::GraphNode>> &visitedMap) final
203 {
204 auto prevNode = fPrevNodes[0]->GetGraph(visitedMap);
205 const auto &prevColumns = prevNode->GetDefinedColumns();
206
207 // Action nodes do not need to go through CreateFilterNode: they are never common nodes between multiple branches
208 const auto nodeType = HasRun() ? RDFGraphDrawing::ENodeType::kUsedAction : RDFGraphDrawing::ENodeType::kAction;
209 auto thisNode = std::make_shared<RDFGraphDrawing::GraphNode>("Varied " + fHelpers[0].GetActionName(),
210 visitedMap.size(), nodeType);
211 visitedMap[(void *)this] = thisNode;
212
213 auto upmostNode = AddDefinesToGraph(thisNode, GetColRegister(), prevColumns, visitedMap);
214
215 thisNode->AddDefinedColumns(GetColRegister().GenerateColumnNames());
216 upmostNode->SetPrevNode(prevNode);
217 return thisNode;
218 }
219
220 /**
221 Retrieve a container holding the names and values of the variations. It
222 knows how to merge with others of the same type.
223 */
224 std::unique_ptr<RMergeableValueBase> GetMergeableValue() const final
225 {
226 std::vector<std::string> keys{GetVariations()};
227
228 std::vector<std::unique_ptr<RDFDetail::RMergeableValueBase>> values;
229 values.reserve(fHelpers.size());
230 for (auto &&h : fHelpers)
231 values.emplace_back(h.GetMergeableValue());
232
233 return std::make_unique<RDFDetail::RMergeableVariationsBase>(std::move(keys), std::move(values));
234 }
235
236 [[noreturn]] std::unique_ptr<RActionBase> MakeVariedAction(std::vector<void *> &&) final
237 {
238 throw std::logic_error("Cannot produce a varied action from a varied action.");
239 }
240
241 std::unique_ptr<RActionBase> CloneAction(void *typeErasedResults) final
242 {
243 const auto &vectorOfTypeErasedResults = *reinterpret_cast<const std::vector<void *> *>(typeErasedResults);
244 assert(vectorOfTypeErasedResults.size() == fHelpers.size() &&
245 "The number of results and the number of helpers are not the same!");
246
247 std::vector<Helper> clonedHelpers;
248 clonedHelpers.reserve(fHelpers.size());
249 for (std::size_t i = 0; i < fHelpers.size(); i++) {
250 clonedHelpers.emplace_back(fHelpers[i].CallMakeNew(vectorOfTypeErasedResults[i]));
251 }
252
253 return std::unique_ptr<RVariedAction>(
254 new RVariedAction(std::move(clonedHelpers), GetColumnNames(), fPrevNodes, GetColRegister()));
255 }
256
257private:
258 // this overload is SFINAE'd out if Helper does not implement `PartialUpdate`
259 // the template parameter is required to defer instantiation of the method to SFINAE time
260 template <typename H = Helper>
261 auto PartialUpdateImpl(unsigned int slot) -> decltype(std::declval<H>().PartialUpdate(slot), (void *)(nullptr))
262 {
263 return &fHelpers[0].PartialUpdate(slot);
264 }
265
266 // this one is always available but has lower precedence thanks to `...`
267 void *PartialUpdateImpl(...) { throw std::runtime_error("This action does not support callbacks!"); }
268};
269
270} // namespace RDF
271} // namespace Internal
272} // namespace ROOT
273
274#endif // ROOT_RVARIEDACTION
#define f(i)
Definition RSha256.hxx:104
#define c(i)
Definition RSha256.hxx:101
#define h(i)
Definition RSha256.hxx:106
long long Long64_t
Definition RtypesCore.h:80
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
Base class for non-leaf nodes of the computational graph.
Definition RNodeBase.hxx:43
A binder for user-defined columns, variations and aliases.
Just like an RAction, but it has N action helpers and N previous nodes (N is the number of variations...
void Finalize() final
Clean-up and finalize the action result (e.g.
void Run(unsigned int slot, Long64_t entry) final
std::vector< std::shared_ptr< PrevNodeType > > fPrevNodes
Owning pointers to upstream nodes for each systematic variation.
std::unique_ptr< RMergeableValueBase > GetMergeableValue() const final
Retrieve a container holding the names and values of the variations.
RVariedAction(std::vector< Helper > &&helpers, const ColumnNames_t &columns, std::shared_ptr< PrevNode > prevNode, const RColumnRegister &colRegister)
void CallExec(unsigned int slot, unsigned int varIdx, Long64_t entry, TypeList< ColTypes... >, std::index_sequence< S... >)
auto PartialUpdateImpl(unsigned int slot) -> decltype(std::declval< H >().PartialUpdate(slot),(void *)(nullptr))
std::unique_ptr< RActionBase > CloneAction(void *typeErasedResults) final
ROOT::RDF::SampleCallback_t GetSampleCallback() final
Return a callback that in turn runs the callbacks of each variation's helper.
void FinalizeSlot(unsigned int slot) final
Clean-up operations to be performed at the end of a task.
std::vector< std::shared_ptr< PrevNodeType > > MakePrevFilters(std::shared_ptr< PrevNode > nominal) const
Creates new filter nodes, one per variation, from the upstream nominal one.
std::make_index_sequence< ColumnTypes_t::list_size > TypeInd_t
std::vector< std::vector< std::array< RColumnReaderBase *, ColumnTypes_t::list_size > > > fInputValues
Column readers per slot (outer dimension), per variation and per input column (inner dimension,...
std::vector< Helper > fHelpers
Action helpers per variation.
RVariedAction & operator=(const RVariedAction &)=delete
void InitSlot(TTreeReader *r, unsigned int slot) final
std::conditional_t< std::is_same< PrevNode, RJittedFilter >::value, RFilterBase, PrevNode > PrevNodeType
std::shared_ptr< RDFGraphDrawing::GraphNode > GetGraph(std::unordered_map< void *, std::shared_ptr< RDFGraphDrawing::GraphNode > > &visitedMap) final
std::array< bool, ColumnTypes_t::list_size > fIsDefine
The nth flag signals whether the nth input column is a custom column or not.
void * PartialUpdate(unsigned int slot) final
Return the partially-updated value connected to the first variation.
std::unique_ptr< RActionBase > MakeVariedAction(std::vector< void * > &&) final
RVariedAction(const RVariedAction &)=delete
RVariedAction(std::vector< Helper > &&helpers, const ColumnNames_t &columns, const std::vector< std::shared_ptr< PrevNodeType > > &prevNodes, const RColumnRegister &colRegister)
This constructor takes in input a vector of previous nodes, motivated by the CloneAction logic.
This type represents a sample identifier, to be used in conjunction with RDataFrame features such as ...
A simple, robust and fast interface to read values from ROOT columnar datasets such as TTree,...
Definition TTreeReader.h:44
unsigned int GetNSlots()
Definition RDFUtils.cxx:283
bool IsStrInVec(const std::string &str, const std::vector< std::string > &vec)
Definition RDFUtils.cxx:424
std::array< RDFDetail::RColumnReaderBase *, sizeof...(ColTypes)> GetColumnReaders(unsigned int slot, TTreeReader *r, TypeList< ColTypes... >, const RColumnReadersInfo &colInfo, const std::string &variationName="nominal")
Create a group of column readers, one per type in the parameter pack.
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...
This type aggregates some of the arguments passed to GetColumnReaders.
Lightweight storage for a collection of types.