ROOT
v6-22
Reference Guide
df020_helpers.C
Go to the documentation of this file.
1
/// \file
2
/// \ingroup tutorial_dataframe
3
/// \notebook
4
/// This tutorial shows usage of the RDF helper tools, contained in ROOT/RDFHelpers.hxx
5
///
6
/// \macro_code
7
///
8
/// \date July 2018
9
/// \author Enrico Guiraud
10
11
void
df020_helpers()
12
{
13
// First of all, we create a dataframe with 3 entries and define two simple columns
14
const
auto
nEntries = 3;
15
ROOT::RDataFrame
_df(nEntries);
16
auto
df = _df.Define(
"one"
, [] {
return
1; }).Define(
"two"
, [] {
return
2; });
17
18
// *** Not ***
19
// This helper takes a callable `f` (which must return a `bool`) and produces a new callable which takes the same
20
// arguments as `f` but returns its negated result. `Not` is useful to invert the check performed by a given Filter.
21
// Here we define a simple lambda that checks whether a value is equal to 1, and invert it with Not:
22
auto
isOne = [] (
int
a
) {
return
a
== 1; };
23
auto
isNotOne =
ROOT::RDF::Not
(isOne);
24
25
// Both `isOne` and `isNotOne` are callables that we can use in `Filters`:
26
auto
c1
= df.Filter(isOne, {
"one"
}).Count();
27
auto
c2
= df.Filter(isNotOne, {
"two"
}).Count();
28
// Both counts are equal to the total number of entries, as both Filters always pass.
29
R__ASSERT
(*
c1
== nEntries);
30
R__ASSERT
(*
c2
== nEntries);
31
32
// *** PassAsVec ***
33
// Consider the following function, which checks if a vector consists of two elements equal to 1 and 2:
34
auto
checkOneTwo = [] (
const
std::vector<int> &
v
) {
return
v
.size() == 2 &&
v
[0] == 1 &&
v
[1] == 2; };
35
// The following line, although it looks reasonable, would _not_ run correctly:
36
// df.Filter(checkOneTwo, {"one", "two"});
37
// The reason is that `Filter(..., {"one", "two"})` expects a callable that takes exactly two integers, while
38
// `checkOneTwo` actually takes a vector of integers (i.e. it does not have the right signature).
39
// PassAsVec helps passing down the single values "one", "two" to `checkOneTwo` as a collection: it takes a callable
40
// `f` that expects a collection as argument and returns a new callable that takes single arguments instead, passes
41
// them down to `f` and returns what `f` returns.
42
// PassAsVec requires that number of arguments and their type is specified as template argument.
43
// Here's an example usage (remember, PassAsVec(f) returns a new callable!):
44
auto
c3
= df.Filter(ROOT::RDF::PassAsVec<2, int>(checkOneTwo), {
"one"
,
"two"
}).Count();
45
R__ASSERT
(*
c3
== nEntries);
46
}
R__ASSERT
#define R__ASSERT(e)
Definition:
TError.h:96
ROOT::RDataFrame
ROOT's RDataFrame offers a high level interface for analyses of data stored in TTrees,...
Definition:
RDataFrame.hxx:42
c1
return c1
Definition:
legend1.C:41
c2
return c2
Definition:
legend2.C:14
c3
return c3
Definition:
legend3.C:15
ROOT::RDF::Not
auto Not(F &&f) -> decltype(RDFInternal::NotHelper(Args(), std::forward< F >(f)))
Given a callable with signature bool(T1, T2, ...) return a callable with same signature that returns ...
Definition:
RDFHelpers.hxx:80
v
@ v
Definition:
rootcling_impl.cxx:3624
a
auto * a
Definition:
textangle.C:12
tutorials
dataframe
df020_helpers.C
ROOT v6-22 - Reference Guide Generated on Fri Apr 1 2022 11:53:17 (GVA Time) using Doxygen 1.9.4