[skip-ci][df] Swap all RDataFrame to ROOT::RDataFrame in docs to avoid confusion.

Author: martamaja10

tree/dataframe/src/RDataFrame.cxx

@@ -290,25 +290,25 @@ operations should work with. Here are the most common methods to construct an RD
 TFile *f = TFile::Open("file.root");
 TTree *t = f.Get<TTree>("treeName");
 
-RDataFrame d1("treeName", "file.root");
-RDataFrame d2("treeName", f); // same as TTreeReader
-RDataFrame d3(*t);
+ROOT::RDataFrame d1("treeName", "file.root");
+ROOT::RDataFrame d2("treeName", f); // same as TTreeReader
+ROOT::RDataFrame d3(*t);
 
 // multiple files -- all constructors are equivalent
 TChain chain("myTree");
 chain.Add("file1.root");
 chain.Add("file2.root");
 
-RDataFrame d4("myTree", {"file1.root", "file2.root"});
+ROOT::RDataFrame d4("myTree", {"file1.root", "file2.root"});
 std::vector<std::string> files = {"file1.root", "file2.root"};
-RDataFrame d5("myTree", files);
-RDataFrame d6("myTree", "file*.root"); // the glob is passed as-is to TChain's constructor
-RDataFrame d7(chain);
+ROOT::RDataFrame d5("myTree", files);
+ROOT::RDataFrame d6("myTree", "file*.root"); // the glob is passed as-is to TChain's constructor
+ROOT::RDataFrame d7(chain);
 ~~~
 Additionally, users can construct an RDataFrame with no data source by passing an integer number. This is the number of rows that
 will be generated by this RDataFrame.
 ~~~{.cpp}
-RDataFrame d(10); // a RDF with 10 entries (and no columns/branches, for now)
+ROOT::RDataFrame d(10); // a RDF with 10 entries (and no columns/branches, for now)
 d.Foreach([] { static int i = 0; std::cout << i++ << std::endl; }); // silly example usage: count to ten
 ~~~
 This is useful to generate simple datasets on the fly: the contents of each event can be specified with Define() (explained below). For example, we have used this method to generate [Pythia](https://pythia.org/) events and write them to disk in parallel (with the Snapshot action).
@@ -324,7 +324,7 @@ auto df = ROOT::RDF::FromCSV("input.csv");
 Let's now tackle a very common task, filling a histogram:
 ~~~{.cpp}
 // Fill a TH1D with the "MET" branch
-RDataFrame d("myTree", "file.root");
+ROOT::RDataFrame d("myTree", "file.root");
 auto h = d.Histo1D("MET");
 h->Draw();
 ~~~
@@ -340,7 +340,7 @@ possible [actions](\ref cheatsheet), and all their results are wrapped in smart
 ### Applying a filter
 Let's say we want to cut over the value of branch "MET" and count how many events pass this cut. This is one way to do it:
 ~~~{.cpp}
-RDataFrame d("myTree", "file.root");
+ROOT::RDataFrame d("myTree", "file.root");
 auto c = d.Filter("MET > 4.").Count(); // computations booked, not run
 std::cout << *c << std::endl; // computations run here, upon first access to the result
 ~~~
@@ -358,7 +358,7 @@ runtime performance is very important, a C++ callable can be specified instead (
 but it can be any kind of function or even a functor class), together with a list of column names.
 This snippet is analogous to the one above:
 ~~~{.cpp}
-RDataFrame d("myTree", "file.root");
+ROOT::RDataFrame d("myTree", "file.root");
 auto metCut = [](double x) { return x > 4.; }; // a C++11 lambda function checking "x > 4"
 auto c = d.Filter(metCut, {"MET"}).Count();
 std::cout << *c << std::endl;
@@ -367,7 +367,7 @@ std::cout << *c << std::endl;
 An example of a more complex filter expressed as a string containing C++ code is shown below
 
 ~~~{.cpp}
-RDataFrame d("myTree", "file.root");
+ROOT::RDataFrame d("myTree", "file.root");
 auto df = d.Define("p", "std::array<double, 4> p{px, py, pz}; return p;")
            .Filter("double p2 = 0.0; for (auto&& x : p) p2 += x*x; return sqrt(p2) < 10.0;");
 ~~~
@@ -386,7 +386,7 @@ Let's now consider the case in which "myTree" contains two quantities "x" and "y
 quantity `z = sqrt(x*x + y*y)`. Using the Define() transformation, we can create a new column in the dataset containing
 the variable "z":
 ~~~{.cpp}
-RDataFrame d("myTree", "file.root");
+ROOT::RDataFrame d("myTree", "file.root");
 auto sqrtSum = [](double x, double y) { return sqrt(x*x + y*y); };
 auto zMean = d.Define("z", sqrtSum, {"x","y"}).Mean("z");
 std::cout << *zMean << std::endl;
@@ -398,7 +398,7 @@ columns. Define() and Filter() transformations can be concatenated and intermixe
 
 As with filters, it is possible to specify new columns as string expressions. This snippet is analogous to the one above:
 ~~~{.cpp}
-RDataFrame d("myTree", "file.root");
+ROOT::RDataFrame d("myTree", "file.root");
 auto zMean = d.Define("z", "sqrt(x*x + y*y)").Mean("z");
 std::cout << *zMean << std::endl;
 ~~~
@@ -412,8 +412,7 @@ transformations to create a dataset on the fly. We then save the generated data
 ~~~{.cpp}
 ROOT::RDataFrame d(100); // an RDF that will generate 100 entries (currently empty)
 int x = -1;
-auto d_with_columns = d.Define("x", []()->int { return ++x; })
-                       .Define("xx", []()->int { return x*x; });
+auto d_with_columns = d.Define("x", []()->int { return ++x; }).Define("xx", []()->int { return x*x; });
 d_with_columns.Snapshot("myNewTree", "newfile.root");
 ~~~
 This example is slightly more advanced than what we have seen so far. First, it makes use of lambda captures (a
@@ -434,7 +433,7 @@ actions can be concatenated to and intermixed with Range()s. If a range is speci
 exclusively on the entries passing the filter -- it will not even count the other entries! The same goes for a Range()
 hanging from another Range(). Here are some commented examples:
 ~~~{.cpp}
-RDataFrame d("myTree", "file.root");
+ROOT::RDataFrame d("myTree", "file.root");
 // Here we store a dataframe that loops over only the first 30 entries in a variable
 auto d30 = d.Range(30);
 // This is how you pick all entries from 15 onwards
@@ -1331,12 +1330,12 @@ whenever a list specific to the transformation/action is not present. RDataFrame
 needed, ignoring trailing extra names if present.
 ~~~{.cpp}
 // use "b1" and "b2" as default columns
-RDataFrame d1("myTree", "file.root", {"b1","b2"});
+ROOT::RDataFrame d1("myTree", "file.root", {"b1","b2"});
 auto h = d1.Filter([](int b1, int b2) { return b1 > b2; }) // will act on "b1" and "b2"
            .Histo1D(); // will act on "b1"
 
 // just one default column this time
-RDataFrame d2("myTree", "file.root", {"b1"});
+ROOT::RDataFrame d2("myTree", "file.root", {"b1"});
 auto d2f = d2.Filter([](double b2) { return b2 > 0; }, {"b2"}) // we can still specify non-default column lists
 auto min = d2f.Min(); // returns the minimum value of "b1" for the filtered entries
 auto vals = d2f.Take<double>(); // return the values for all entries passing the selection as a vector