ROOT
v6-30
Reference Guide
Loading...
Searching...
No Matches
df020_helpers.C
Go to the documentation of this file.
1
/// \file
2
/// \ingroup tutorial_dataframe
3
/// \notebook
4
/// Show usage of RDataFrame's helper tools, contained in ROOT/RDFHelpers.hxx.
5
///
6
/// \macro_code
7
///
8
/// \date July 2018
9
/// \author Enrico Guiraud (CERN)
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
}
a
#define a(i)
Definition
RSha256.hxx:99
R__ASSERT
#define R__ASSERT(e)
Definition
TError.h:118
ROOT::RDataFrame
ROOT's RDataFrame offers a modern, high-level interface for analysis of data stored in TTree ,...
Definition
RDataFrame.hxx:41
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:83
v
@ v
Definition
rootcling_impl.cxx:3687
tutorials
dataframe
df020_helpers.C
ROOT v6-30 - Reference Guide Generated on Thu Dec 12 2024 06:12:37 (GVA Time) using Doxygen 1.9.8