Logo ROOT  
Reference Guide
df002_dataModel.C
Go to the documentation of this file.
1/// \file
2/// \ingroup tutorial_dataframe
3/// \notebook -draw
4/// This tutorial shows the possibility to use data models which are more
5/// complex than flat ntuples with RDataFrame
6///
7/// \macro_code
8/// \macro_image
9///
10/// \date December 2016
11/// \author Danilo Piparo
12using FourVector = ROOT::Math::XYZTVector;
13using FourVectorVec = std::vector<FourVector>;
14using FourVectorRVec = ROOT::VecOps::RVec<FourVector>;
15using CylFourVector = ROOT::Math::RhoEtaPhiVector;
16
17// A simple helper function to fill a test tree: this makes the example
18// stand-alone.
19void fill_tree(const char *filename, const char *treeName)
20{
21 const double M = 0.13957; // set pi+ mass
22 TRandom3 R(1);
23
24 auto genTracks = [&](){
25 FourVectorVec tracks;
26 const auto nPart = R.Poisson(15);
27 tracks.reserve(nPart);
28 for (int j = 0; j < nPart; ++j) {
29 const auto px = R.Gaus(0, 10);
30 const auto py = R.Gaus(0, 10);
31 const auto pt = sqrt(px * px + py * py);
32 const auto eta = R.Uniform(-3, 3);
33 const auto phi = R.Uniform(0.0, 2 * TMath::Pi());
34 CylFourVector vcyl(pt, eta, phi);
35 // set energy
36 auto E = sqrt(vcyl.R() * vcyl.R() + M * M);
37 // fill track vector
38 tracks.emplace_back(vcyl.X(), vcyl.Y(), vcyl.Z(), E);
39 }
40 return tracks;
41 };
42
44 d.Define("tracks", genTracks).Snapshot<FourVectorVec>(treeName, filename, {"tracks"});
45}
46
48{
49
50 // We prepare an input tree to run on
51 auto fileName = "df002_dataModel.root";
52 auto treeName = "myTree";
53 fill_tree(fileName, treeName);
54
55 // We read the tree from the file and create a RDataFrame, a class that
56 // allows us to interact with the data contained in the tree.
57 ROOT::RDataFrame d(treeName, fileName, {"tracks"});
58
59 // ## Operating on branches which are collection of objects
60 // Here we deal with the simplest of the cuts: we decide to accept the event
61 // only if the number of tracks is greater than 5.
62 auto n_cut = [](const FourVectorRVec &tracks) { return tracks.size() > 8; };
63 auto nentries = d.Filter(n_cut, {"tracks"}).Count();
64
65 std::cout << *nentries << " passed all filters" << std::endl;
66
67 // Another possibility consists in creating a new column containing the
68 // quantity we are interested in.
69 // In this example, we will cut on the number of tracks and plot their
70 // transverse momentum.
71 auto getPt = [](const FourVectorRVec &tracks) {
72 return ROOT::VecOps::Map(tracks, [](const FourVector& v){return v.Pt();});
73 };
74
75 // We do the same for the weights.
76 auto getPtWeights = [](const FourVectorRVec &tracks) {
77 return ROOT::VecOps::Map(tracks, [](const FourVector& v){ return 1. / v.Pt();});
78 };
79
80 auto augmented_d = d.Define("tracks_n", [](const FourVectorRVec &tracks) { return (int)tracks.size(); })
81 .Filter([](int tracks_n) { return tracks_n > 2; }, {"tracks_n"})
82 .Define("tracks_pts", getPt)
83 .Define("tracks_pts_weights", getPtWeights);
84
85 auto trN = augmented_d.Histo1D({"", "", 40, -.5, 39.5}, "tracks_n");
86 auto trPts = augmented_d.Histo1D("tracks_pts");
87 auto trWPts = augmented_d.Histo1D("tracks_pts", "tracks_pts_weights");
88
89 auto c1 = new TCanvas();
90 trN->DrawCopy();
91
92 auto c2 = new TCanvas();
93 trPts->DrawCopy();
94
95 auto c3 = new TCanvas();
96 trWPts->DrawCopy();
97
98 return 0;
99}
#define d(i)
Definition: RSha256.hxx:102
#define R(a, b, c, d, e, f, g, h, i)
Definition: RSha256.hxx:110
int nentries
Definition: THbookFile.cxx:89
double sqrt(double)
ROOT's RDataFrame offers a high level interface for analyses of data stored in TTrees,...
Definition: RDataFrame.hxx:42
A "std::vector"-like collection of values implementing handy operation to analyse them.
Definition: RVec.hxx:275
The Canvas class.
Definition: TCanvas.h:27
Random number generator class based on M.
Definition: TRandom3.h:27
TPaveText * pt
return c1
Definition: legend1.C:41
return c2
Definition: legend2.C:14
return c3
Definition: legend3.C:15
DisplacementVector3D< CylindricalEta3D< double >, DefaultCoordinateSystemTag > RhoEtaPhiVector
3D Vector based on the eta based cylindrical coordinates rho, eta, phi in double precision.
Definition: Vector3Dfwd.h:50
LorentzVector< PxPyPzE4D< double > > XYZTVector
LorentzVector based on x,y,x,t (or px,py,pz,E) coordinates in double precision with metric (-,...
Definition: Vector4Dfwd.h:33
auto Map(Args &&... args) -> decltype(ROOT::Detail::VecOps::MapFromTuple(std::forward_as_tuple(args...), std::make_index_sequence< sizeof...(args) - 1 >()))
Create new collection applying a callable to the elements of the input collection.
Definition: RVec.hxx:910
RVec< T > Filter(const RVec< T > &v, F &&f)
Create a new collection with the elements passing the filter expressed by the predicate.
Definition: RVec.hxx:939
constexpr Double_t E()
Base of natural log:
Definition: TMath.h:97
constexpr Double_t Pi()
Definition: TMath.h:38
void tracks()
Definition: tracks.C:49