11#ifndef ROOT_RDF_TINTERFACE_UTILS
12#define ROOT_RDF_TINTERFACE_UTILS
42#include <unordered_map>
55template<
typename T,
typename V>
78class RIgnoreErrorLevelRAII {
83 RIgnoreErrorLevelRAII(
int errorIgnoreLevel) {
gErrorIgnoreLevel = errorIgnoreLevel; }
97struct GraphAsymmErrors{};
112template <
typename T,
bool ISV6HISTO = std::is_base_of<TH1, std::decay_t<T>>::value>
115 static bool HasAxisLimits(T &
h)
117 auto xaxis =
h.GetXaxis();
118 return !(xaxis->GetXmin() == 0. && xaxis->GetXmax() == 0.);
123struct HistoUtils<
T, false> {
124 static void SetCanExtendAllAxes(T &) {}
125 static bool HasAxisLimits(T &) {
return true; }
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)
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);
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)
145 auto hasAxisLimits = HistoUtils<::TH1D>::HasAxisLimits(*
h);
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);
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);
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)
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);
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)
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);
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)
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);
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)
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);
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)
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);
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)
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);
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)
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);
233using displayHelperArgs_t = std::pair<size_t, std::shared_ptr<ROOT::RDF::RDisplay>>;
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)
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,
247struct SnapshotHelperArgs {
248 std::string fFileName;
249 std::string fDirName;
250 std::string fTreeName;
251 std::vector<std::string> fOutputColNames;
256template <
typename... ColTypes,
typename PrevNodeType>
257std::unique_ptr<RActionBase>
258BuildAction(
const ColumnNames_t &colNames,
const std::shared_ptr<SnapshotHelperArgs> &snapHelperArgs,
259 const unsigned int nSlots, std::shared_ptr<PrevNodeType> prevNode, ActionTags::Snapshot,
260 const RColumnRegister &colRegister)
262 const auto &
filename = snapHelperArgs->fFileName;
263 const auto &dirname = snapHelperArgs->fDirName;
264 const auto &treename = snapHelperArgs->fTreeName;
265 const auto &outputColNames = snapHelperArgs->fOutputColNames;
266 const auto &options = snapHelperArgs->fOptions;
268 auto sz =
sizeof...(ColTypes);
269 std::vector<bool> isDefine(sz);
270 for (
auto i = 0u; i < sz; ++i)
271 isDefine[i] = colRegister.IsDefineOrAlias(colNames[i]);
273 std::unique_ptr<RActionBase> actionPtr;
276 using Helper_t = SnapshotHelper<ColTypes...>;
277 using Action_t = RAction<Helper_t, PrevNodeType>;
279 new Action_t(Helper_t(
filename, dirname, treename, colNames, outputColNames, options, std::move(isDefine)),
280 colNames, prevNode, colRegister));
283 using Helper_t = SnapshotHelperMT<ColTypes...>;
284 using Action_t = RAction<Helper_t, PrevNodeType>;
285 actionPtr.reset(
new Action_t(
286 Helper_t(nSlots,
filename, dirname, treename, colNames, outputColNames, options, std::move(isDefine)),
287 colNames, prevNode, colRegister));
293template <
typename... ColTypes,
typename PrevNodeType,
typename Helper_t>
294std::unique_ptr<RActionBase>
295BuildAction(
const ColumnNames_t &bl,
const std::shared_ptr<Helper_t> &
h,
const unsigned int ,
296 std::shared_ptr<PrevNodeType> prevNode, ActionTags::Book,
const RColumnRegister &colRegister)
298 using Action_t = RAction<Helper_t, PrevNodeType,
TTraits::TypeList<ColTypes...>>;
299 return std::make_unique<Action_t>(Helper_t(std::move(*
h)), bl, std::move(prevNode), colRegister);
304template <
typename Filter>
305void CheckFilter(Filter &)
307 using FilterRet_t =
typename RDF::CallableTraits<Filter>::ret_type;
308 static_assert(std::is_convertible<FilterRet_t, bool>::value,
309 "filter expression returns a type that is not convertible to bool");
316void CheckForRedefinition(
const std::string &where, std::string_view definedCol,
const RColumnRegister &colRegister,
319void CheckForDefinition(
const std::string &where, std::string_view definedColView,
const RColumnRegister &colRegister,
323 const RColumnRegister &colRegister);
327std::shared_ptr<RJittedFilter>
BookFilterJit(std::shared_ptr<RNodeBase> *prevNodeOnHeap, std::string_view
name,
332 RDataSource *ds,
const RColumnRegister &colRegister,
333 const ColumnNames_t &branches, std::shared_ptr<RNodeBase> *prevNodeOnHeap);
337 std::shared_ptr<RNodeBase> *upcastNodeOnHeap);
339std::shared_ptr<RJittedVariation>
340BookVariationJit(
const std::vector<std::string> &colNames, std::string_view variationName,
341 const std::vector<std::string> &variationTags, std::string_view expression,
RLoopManager &lm,
343 std::shared_ptr<RNodeBase> *upcastNodeOnHeap,
bool isSingleColumn);
346 const std::type_info &art,
const std::type_info &at,
void *rOnHeap,
TTree *tree,
347 const unsigned int nSlots,
const RColumnRegister &colRegister,
RDataSource *ds,
348 std::weak_ptr<RJittedAction> *jittedActionOnHeap);
357std::weak_ptr<T> *MakeWeakOnHeap(
const std::shared_ptr<T> &shPtr)
359 return new std::weak_ptr<T>(shPtr);
364std::shared_ptr<T> *MakeSharedOnHeap(
const std::shared_ptr<T> &shPtr)
366 return new std::shared_ptr<T>(shPtr);
373std::shared_ptr<RNodeBase>
UpcastNode(std::shared_ptr<RNodeBase> ptr);
376 const RColumnRegister &validDefines,
RDataSource *ds);
385void AddDSColumnsHelper(
const std::string &colName,
RLoopManager &lm,
RDataSource &ds, RColumnRegister &colRegister)
387 if (colRegister.IsDefineOrAlias(colName) || !ds.
HasColumn(colName) ||
392 std::vector<std::unique_ptr<RColumnReaderBase>> colReaders;
393 colReaders.reserve(nSlots);
396 if (!valuePtrs.empty()) {
397 for (
auto *ptr : valuePtrs)
398 colReaders.emplace_back(new RDSColumnReader<
T>(ptr));
402 for (
auto slot = 0u; slot < lm.
GetNSlots(); ++slot)
411template <
typename... ColumnTypes>
416 using expander =
int[];
418 (
void)expander{(AddDSColumnsHelper<ColumnTypes>(requiredCols[i], lm, ds, colRegister), ++i)..., 0};
422template <
typename F,
typename PrevNode>
423void JitFilterHelper(
F &&
f,
const char **colsPtr, std::size_t colsSize, std::string_view
name,
424 std::weak_ptr<RJittedFilter> *wkJittedFilter, std::shared_ptr<PrevNode> *prevNodeOnHeap,
425 RColumnRegister *colRegister)
noexcept
427 if (wkJittedFilter->expired()) {
430 delete wkJittedFilter;
432 delete prevNodeOnHeap;
439 const auto jittedFilter = wkJittedFilter->lock();
442 using Callable_t = std::decay_t<F>;
444 using ColTypes_t =
typename TTraits::CallableTraits<Callable_t>::arg_types;
445 constexpr auto nColumns = ColTypes_t::list_size;
452 AddDSColumns(cols, lm, *ds, ColTypes_t(), *colRegister);
454 jittedFilter->SetFilter(
455 std::unique_ptr<RFilterBase>(
new F_t(std::forward<F>(
f), cols, *prevNodeOnHeap, *colRegister,
name)));
459 delete prevNodeOnHeap;
460 delete wkJittedFilter;
463namespace DefineTypes {
465struct RDefinePerSampleTag {};
469auto MakeDefineNode(DefineTypes::RDefineTag, std::string_view
name, std::string_view dummyType,
F &&
f,
473 name, dummyType, std::forward<F>(
f), cols, colRegister, lm));
477auto MakeDefineNode(DefineTypes::RDefinePerSampleTag, std::string_view
name, std::string_view dummyType,
F &&
f,
480 return std::unique_ptr<RDefineBase>(
487template <
typename RDefineTypeTag,
typename F>
488void JitDefineHelper(
F &&
f,
const char **colsPtr, std::size_t colsSize, std::string_view
name,
RLoopManager *lm,
489 std::weak_ptr<RJittedDefine> *wkJittedDefine, RColumnRegister *colRegister,
490 std::shared_ptr<RNodeBase> *prevNodeOnHeap)
noexcept
493 auto doDeletes = [&] {
494 delete wkJittedDefine;
496 delete prevNodeOnHeap;
500 if (wkJittedDefine->expired()) {
509 auto jittedDefine = wkJittedDefine->lock();
511 using Callable_t = std::decay_t<F>;
512 using ColTypes_t =
typename TTraits::CallableTraits<Callable_t>::arg_types;
516 AddDSColumns(cols, *lm, *ds, ColTypes_t(), *colRegister);
520 const auto dummyType =
"jittedCol_t";
522 std::unique_ptr<RDefineBase> newCol{
523 MakeDefineNode(RDefineTypeTag{},
name, dummyType, std::forward<F>(
f), cols, *colRegister, *lm)};
524 jittedDefine->SetDefine(std::move(newCol));
529template <
bool IsSingleColumn,
typename F>
530void JitVariationHelper(
F &&
f,
const char **colsPtr, std::size_t colsSize,
const char **variedCols,
531 std::size_t variedColsSize,
const char **variationTags, std::size_t variationTagsSize,
533 std::weak_ptr<RJittedVariation> *wkJittedVariation, RColumnRegister *colRegister,
534 std::shared_ptr<RNodeBase> *prevNodeOnHeap)
noexcept
537 auto doDeletes = [&] {
540 delete[] variationTags;
542 delete wkJittedVariation;
544 delete prevNodeOnHeap;
547 if (wkJittedVariation->expired()) {
554 const ColumnNames_t inputColNames(colsPtr, colsPtr + colsSize);
555 std::vector<std::string> variedColNames(variedCols, variedCols + variedColsSize);
556 std::vector<std::string> tags(variationTags, variationTags + variationTagsSize);
558 auto jittedVariation = wkJittedVariation->lock();
560 using Callable_t = std::decay_t<F>;
561 using ColTypes_t =
typename TTraits::CallableTraits<Callable_t>::arg_types;
565 AddDSColumns(inputColNames, *lm, *ds, ColTypes_t(), *colRegister);
568 std::unique_ptr<RVariationBase> newVariation{
new RVariation<std::decay_t<F>, IsSingleColumn>(
569 std::move(variedColNames), variationName, std::forward<F>(
f), std::move(tags), jittedVariation->GetTypeName(),
570 *colRegister, *lm, inputColNames)};
571 jittedVariation->SetVariation(std::move(newVariation));
577template <
typename ActionTag,
typename... ColTypes,
typename PrevNodeType,
typename HelperArgType>
578void CallBuildAction(std::shared_ptr<PrevNodeType> *prevNodeOnHeap,
const char **colsPtr, std::size_t colsSize,
579 const unsigned int nSlots, std::shared_ptr<HelperArgType> *helperArgOnHeap,
580 std::weak_ptr<RJittedAction> *wkJittedActionOnHeap, RColumnRegister *colRegister)
noexcept
583 auto doDeletes = [&] {
585 delete helperArgOnHeap;
586 delete wkJittedActionOnHeap;
590 delete prevNodeOnHeap;
593 if (wkJittedActionOnHeap->expired()) {
602 auto jittedActionOnHeap = wkJittedActionOnHeap->lock();
605 auto &prevNodePtr = *prevNodeOnHeap;
606 auto &loopManager = *prevNodePtr->GetLoopManagerUnchecked();
607 using ColTypes_t =
TypeList<ColTypes...>;
608 constexpr auto nColumns = ColTypes_t::list_size;
609 auto ds = loopManager.GetDataSource();
611 AddDSColumns(cols, loopManager, *ds, ColTypes_t(), *colRegister);
613 auto actionPtr = BuildAction<ColTypes...>(cols, std::move(*helperArgOnHeap), nSlots, std::move(prevNodePtr),
614 ActionTag{}, *colRegister);
615 jittedActionOnHeap->SetAction(std::move(actionPtr));
621template <typename T, bool Container = IsDataContainer<T>::value && !std::is_same<T, std::string>::value>
622struct RMinReturnType {
632struct RMinReturnType<
T, true> {
633 using type = TTraits::TakeFirstParameter_t<T>;
637template <
typename R,
typename F,
typename... Args>
640 return [
f](
unsigned int, Args...
a)
mutable ->
R {
return f(
a...); };
643template <
typename ColType,
typename... Rest>
644struct RNeedJittingHelper {
645 static constexpr bool value = RNeedJittingHelper<Rest...>
::value;
648template <
typename... Rest>
650 static constexpr bool value =
true;
654struct RNeedJittingHelper<
T> {
655 static constexpr bool value =
false;
660 static constexpr bool value =
true;
663template <
typename ...ColTypes>
665 static constexpr bool value = RNeedJittingHelper<ColTypes...>
::value;
669struct RNeedJitting<> {
670 static constexpr bool value =
false;
677template <
typename R,
typename Merge,
typename U,
typename T,
typename decayedU = std::decay_t<U>,
678 typename mergeArgsNoDecay_t =
typename CallableTraits<Merge>::arg_types_nodecay,
679 typename mergeArgs_t =
typename CallableTraits<Merge>::arg_types,
680 typename mergeRet_t =
typename CallableTraits<Merge>::ret_type>
683 constexpr bool isAggregatorOk =
684 (std::is_same<R, decayedU>::value) || (std::is_same<R, void>::value && std::is_lvalue_reference<U>::value);
685 static_assert(isAggregatorOk,
"aggregator function must have signature `U(U,T)` or `void(U&,T)`");
686 constexpr bool isMergeOk =
687 (std::is_same<TypeList<decayedU, decayedU>, mergeArgs_t>
::value && std::is_same<decayedU, mergeRet_t>::value) ||
688 (std::is_same<
TypeList<std::vector<decayedU> &>, mergeArgsNoDecay_t>
::value &&
689 std::is_same<void, mergeRet_t>::value);
690 static_assert(isMergeOk,
"merge function must have signature `U(U,U)` or `void(std::vector<U>&)`");
695template <
typename R,
typename T>
696void CheckAggregate(T)
698 static_assert(
sizeof(
T) == 0,
"aggregator function must take exactly two arguments");
710 const RColumnRegister &definedCols,
const ColumnNames_t &dataSourceColumns);
713std::vector<std::string>
GetFilterNames(
const std::shared_ptr<RLoopManager> &loopManager);
716template <
typename NodeType>
717std::vector<std::string>
GetFilterNames(
const std::shared_ptr<NodeType> &node)
719 std::vector<std::string> filterNames;
720 node->AddFilterName(filterNames);
724struct ParsedTreePath {
725 std::string fTreeName;
726 std::string fDirName;
736using IsTrueForAllImpl_t =
typename std::is_same<TBoolPack<bs...,
true>, TBoolPack<
true, bs...>>;
738template <
bool... Conditions>
740 static constexpr bool value = IsTrueForAllImpl_t<Conditions...>
::value;
747struct IsList_t : std::false_type {};
750struct IsList_t<std::list<T>> : std::true_type {};
753struct IsDeque_t : std::false_type {};
756struct IsDeque_t<std::deque<T>> : std::true_type {};
762struct InnerValueType {
766template <
typename Elem>
772using InnerValueType_t =
typename InnerValueType<T>::type;
774std::pair<std::vector<std::string>, std::vector<std::string>>
775AddSizeBranches(
const std::vector<std::string> &branches,
TTree *tree, std::vector<std::string> &&colsWithoutAliases,
776 std::vector<std::string> &&colsWithAliases);
788using MinReturnType_t =
typename RDFInternal::RMinReturnType<T>::type;
791using MaxReturnType_t = MinReturnType_t<T>;
794using SumReturnType_t = MinReturnType_t<T>;
Int_t gErrorIgnoreLevel
Error handling routines.
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 Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char filename
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
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 Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
The head node of a RDF computation graph.
void AddDataSourceColumnReaders(const std::string &col, std::vector< std::unique_ptr< RColumnReaderBase > > &&readers, const std::type_info &ti)
RDataSource * GetDataSource() const
unsigned int GetNSlots() const
RLoopManager * GetLoopManagerUnchecked() final
bool HasDataSourceColumnReaders(const std::string &col, const std::type_info &ti) const
Return true if AddDataSourceColumnReaders was called for column name col.
RDataSource defines an API that RDataFrame can use to read arbitrary data formats.
virtual bool HasColumn(std::string_view colName) const =0
Checks if the dataset has a certain column.
std::vector< T ** > GetColumnReaders(std::string_view columnName)
Called at most once per column by RDF.
The public interface to the RDataFrame federation of classes.
A "std::vector"-like collection of values implementing handy operation to analyse them.
A TTree represents a columnar dataset.
T Sum(const RVec< T > &v, const T zero=T(0))
Sum elements of an RVec.
const ColumnNames_t SelectColumns(unsigned int nRequiredNames, const ColumnNames_t &names, const ColumnNames_t &defaultNames)
Choose between local column names or default column names, throw in case of errors.
void CheckForNoVariations(const std::string &where, std::string_view definedColView, const RColumnRegister &colRegister)
Throw if the column has systematic variations attached.
ParsedTreePath ParseTreePath(std::string_view fullTreeName)
void CheckForRedefinition(const std::string &where, std::string_view definedColView, const RColumnRegister &colRegister, const ColumnNames_t &treeColumns, const ColumnNames_t &dataSourceColumns)
Throw if column definedColView is already there.
void CheckForDefinition(const std::string &where, std::string_view definedColView, const RColumnRegister &colRegister, const ColumnNames_t &treeColumns, const ColumnNames_t &dataSourceColumns)
Throw if column definedColView is not already there.
std::shared_ptr< RJittedDefine > BookDefineJit(std::string_view name, std::string_view expression, RLoopManager &lm, RDataSource *ds, const RColumnRegister &colRegister, const ColumnNames_t &branches, std::shared_ptr< RNodeBase > *upcastNodeOnHeap)
Book the jitting of a Define call.
void CheckValidCppVarName(std::string_view var, const std::string &where)
void RemoveDuplicates(ColumnNames_t &columnNames)
ColumnNames_t GetValidatedColumnNames(RLoopManager &lm, const unsigned int nColumns, const ColumnNames_t &columns, const RColumnRegister &colRegister, RDataSource *ds)
Given the desired number of columns and the user-provided list of columns:
std::shared_ptr< RNodeBase > UpcastNode(std::shared_ptr< RNodeBase > ptr)
std::vector< std::string > GetFilterNames(const std::shared_ptr< RLoopManager > &loopManager)
std::string PrettyPrintAddr(const void *const addr)
void CheckTypesAndPars(unsigned int nTemplateParams, unsigned int nColumnNames)
std::string DemangleTypeIdName(const std::type_info &typeInfo)
bool AtLeastOneEmptyString(const std::vector< std::string_view > strings)
std::shared_ptr< RDFDetail::RJittedFilter > BookFilterJit(std::shared_ptr< RDFDetail::RNodeBase > *prevNodeOnHeap, std::string_view name, std::string_view expression, const ColumnNames_t &branches, const RColumnRegister &colRegister, TTree *tree, RDataSource *ds)
Book the jitting of a Filter call.
std::string JitBuildAction(const ColumnNames_t &cols, std::shared_ptr< RDFDetail::RNodeBase > *prevNode, const std::type_info &helperArgType, const std::type_info &at, void *helperArgOnHeap, TTree *tree, const unsigned int nSlots, const RColumnRegister &colRegister, RDataSource *ds, std::weak_ptr< RJittedAction > *jittedActionOnHeap)
ColumnNames_t FilterArraySizeColNames(const ColumnNames_t &columnNames, const std::string &action)
Take a list of column names, return that list with entries starting by '#' filtered out.
std::shared_ptr< RJittedVariation > BookVariationJit(const std::vector< std::string > &colNames, std::string_view variationName, const std::vector< std::string > &variationTags, std::string_view expression, RLoopManager &lm, RDataSource *ds, const RColumnRegister &colRegister, const ColumnNames_t &branches, std::shared_ptr< RNodeBase > *upcastNodeOnHeap, bool isSingleColumn)
Book the jitting of a Vary call.
void CheckForDuplicateSnapshotColumns(const ColumnNames_t &cols)
ColumnNames_t ConvertRegexToColumns(const ColumnNames_t &colNames, std::string_view columnNameRegexp, std::string_view callerName)
std::pair< std::vector< std::string >, std::vector< std::string > > AddSizeBranches(const std::vector< std::string > &branches, TTree *tree, std::vector< std::string > &&colsWithoutAliases, std::vector< std::string > &&colsWithAliases)
Return copies of colsWithoutAliases and colsWithAliases with size branches for variable-sized array b...
std::vector< bool > FindUndefinedDSColumns(const ColumnNames_t &requestedCols, const ColumnNames_t &definedCols)
Return a bitset each element of which indicates whether the corresponding element in selectedColumns ...
std::shared_ptr< RJittedDefine > BookDefinePerSampleJit(std::string_view name, std::string_view expression, RLoopManager &lm, const RColumnRegister &colRegister, std::shared_ptr< RNodeBase > *upcastNodeOnHeap)
Book the jitting of a DefinePerSample call.
std::vector< std::string > GetValidatedArgTypes(const ColumnNames_t &colNames, const RColumnRegister &colRegister, TTree *tree, RDataSource *ds, const std::string &context, bool vector2rvec)
ColumnNames_t FindUnknownColumns(const ColumnNames_t &requiredCols, const ColumnNames_t &datasetColumns, const RColumnRegister &definedCols, const ColumnNames_t &dataSourceColumns)
void(off) SmallVectorTemplateBase< T
std::vector< std::string > ColumnNames_t
ROOT type_traits extensions.
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.
Short_t Max(Short_t a, Short_t b)
Returns the largest of a and b.
Short_t Min(Short_t a, Short_t b)
Returns the smallest of a and b.
Double_t Mean(Long64_t n, const T *a, const Double_t *w=nullptr)
Returns the weighted mean of an array a with length n.
Double_t StdDev(Long64_t n, const T *a, const Double_t *w=nullptr)
A collection of options to steer the creation of the dataset on file.
Lightweight storage for a collection of types.