Merge branch 'master' of github.com:root-mirror/root into GenVector-AddTemplates

Author: cjones051073

bindings/pyroot/CMakeLists.txt

@@ -36,8 +36,13 @@ endif()
 file(GLOB pyfiles RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.py)
 foreach(pyfile ${pyfiles})
   install(FILES ${pyfile} DESTINATION ${runtimedir})
-  install(CODE "execute_process(COMMAND python -m py_compile \$ENV{DESTDIR}${runtimedir}/${pyfile})")
-  install(CODE "execute_process(COMMAND python -O -m py_compile \$ENV{DESTDIR}${runtimedir}/${pyfile})")
+  if(IS_ABSOLUTE ${runtimedir})
+    set(absruntimedir ${runtimedir})
+  else()
+    set(absruntimedir ${CMAKE_INSTALL_PREFIX}/${runtimedir})
+  endif()
+  install(CODE "execute_process(COMMAND ${PYTHON_EXECUTABLE} -m py_compile \$ENV{DESTDIR}${absruntimedir}/${pyfile})")
+  install(CODE "execute_process(COMMAND ${PYTHON_EXECUTABLE} -O -m py_compile \$ENV{DESTDIR}${absruntimedir}/${pyfile})")
   file(COPY ${pyfile} DESTINATION ${localruntimedir})
 endforeach()
 

main/CMakeLists.txt

@@ -43,8 +43,13 @@ if(python)
   endforeach()
 
   install(FILES python/cmdLineUtils.py DESTINATION ${runtimedir})
-  install(CODE "execute_process(COMMAND ${PYTHON_EXECUTABLE} -m py_compile \$ENV{DESTDIR}${runtimedir}/cmdLineUtils.py)")
-  install(CODE "execute_process(COMMAND ${PYTHON_EXECUTABLE} -O -m py_compile \$ENV{DESTDIR}${runtimedir}/cmdLineUtils.py)")
+  if(IS_ABSOLUTE ${runtimedir})
+    set(absruntimedir ${runtimedir})
+  else()
+    set(absruntimedir ${CMAKE_INSTALL_PREFIX}/${runtimedir})
+  endif()
+  install(CODE "execute_process(COMMAND ${PYTHON_EXECUTABLE} -m py_compile \$ENV{DESTDIR}${absruntimedir}/cmdLineUtils.py)")
+  install(CODE "execute_process(COMMAND ${PYTHON_EXECUTABLE} -O -m py_compile \$ENV{DESTDIR}${absruntimedir}/cmdLineUtils.py)")
   configure_file(python/cmdLineUtils.py ${localruntimedir}/cmdLineUtils.py @ONLY)
 endif()
 

math/mathcore/test/CTestCustom.cmake

@@ -1,6 +1,6 @@
 #---Custom CTest settings---------------------------------------------------
 
-if (CTEST_BUILD_NAME MATCHES arm64 AND CTEST_BUILD_NAME MATCHES dbg)
+if (CTEST_BUILD_NAME MATCHES aarch64 AND CTEST_BUILD_NAME MATCHES dbg)
   # these tests are disabled as they timeout
   list(APPEND CTEST_CUSTOM_TESTS_IGNORE mathcore-testMathRandom)
 endif()

test/CTestCustom.cmake

@@ -15,7 +15,7 @@ if(CTEST_BUILD_NAME MATCHES icc)  #  sse tests of vc fail for icc compiler
 elseif(CTEST_BUILD_NAME MATCHES clang7)
   set(CTEST_CUSTOM_TESTS_IGNORE ${CTEST_CUSTOM_TESTS_IGNORE}
       vc-swizzles_avx)
-elseif (CTEST_BUILD_NAME MATCHES arm64 AND CTEST_BUILD_NAME MATCHES dbg)
+elseif (CTEST_BUILD_NAME MATCHES aarch64 AND CTEST_BUILD_NAME MATCHES dbg)
   # these tests are disabled as they timeout
   list(APPEND CTEST_CUSTOM_TESTS_IGNORE test-stressroostats test-stresstmva test-stressroostats-interpreted test-stresshistogram-interpreted test-stresshistogram test-stressgeometry test-tcollbm test-bench test-stressgeometry-interpreted)
 endif()

tree/treeplayer/inc/ROOT/TDataFrame.hxx

@@ -187,7 +187,7 @@ TVBVec_t BuildReaderValues(TTreeReader &r, const BranchNames &bl, const BranchNa
                            TDFTraitsUtils::TStaticSeq<S...>)
 {
    // isTmpBranch has length bl.size(). Elements are true if the corresponding
-   // branch is a temporary branch created with AddCol, false if they are
+   // branch is a temporary branch created with AddColumn, false if they are
    // actual branches present in the TTree.
    std::array<bool, sizeof...(S)> isTmpBranch;
    for (unsigned int i = 0; i < isTmpBranch.size(); ++i)
@@ -196,7 +196,7 @@ TVBVec_t BuildReaderValues(TTreeReader &r, const BranchNames &bl, const BranchNa
    // Build vector of pointers to TTreeReaderValueBase.
    // tvb[i] points to a TTreeReader{Value,Array} specialized for the i-th BranchType,
    // corresponding to the i-th branch in bl
-   // For temporary branches (declared with AddCol) a nullptr is created instead
+   // For temporary branches (declared with AddColumn) a nullptr is created instead
    // S is expected to be a sequence of sizeof...(BranchTypes) integers
    // Note that here TTypeList only contains one single type
    TVBVec_t tvb{isTmpBranch[S] ? nullptr : ReaderValueOrArray(r, bl.at(S), TDFTraitsUtils::TTypeList<BranchTypes>())
@@ -445,7 +445,7 @@ public:
    /// for another branch in the TTree.
    template <typename F>
    TDataFrameInterface<ROOT::Detail::TDataFrameBranchBase>
-   AddCol(const std::string &name, F expression, const BranchNames &bl = {})
+   AddColumn(const std::string &name, F expression, const BranchNames &bl = {})
    {
       auto df = GetDataFrameChecked();
       ROOT::Internal::CheckTmpBranch(name, df->GetTree());

tree/treeplayer/src/TDataFrame.cxx

@@ -154,18 +154,18 @@ std::cout << *c << std::endl;
 
 ### Creating a temporary branch
 Let's now consider the case in which "myTree" contains two quantities "x" and "y", but our analysis relies on a derived quantity `z = sqrt(x*x + y*y)`.
-Using the `AddCol` transformation, we can create a new column in the data-set containing the variable "z":
+Using the `AddColumn` transformation, we can create a new column in the data-set containing the variable "z":
 ~~~{.cpp}
 auto sqrtSum = [](double x, double y) { return sqrt(x*x + y*y); };
 auto zCut = [](double z) { return z > 0.; }
 
 ROOT::Experimental::TDataFrame d(treeName, filePtr);
-auto zMean = d.AddCol("z", sqrtSum, {"x","y"})
+auto zMean = d.AddColumn("z", sqrtSum, {"x","y"})
               .Filter(zCut, {"z"})
               .Mean("z");
 std::cout << *zMean << std::endl;
 ~~~
-`AddCol` creates the variable "z" by applying `sqrtSum` to "x" and "y". Later in the chain of calls we refer to variables created with `AddCol` as if they were actual tree branches, but they are evaluated on the fly, once per event. As with filters, `AddCol` calls can be chained with other transformations to create multiple temporary branches.
+`AddColumn` creates the variable "z" by applying `sqrtSum` to "x" and "y". Later in the chain of calls we refer to variables created with `AddColumn` as if they were actual tree branches, but they are evaluated on the fly, once per event. As with filters, `AddColumn` calls can be chained with other transformations to create multiple temporary branches.
 
 ### Executing multiple actions
 As a final example let us apply two different cuts on branch "MET" and fill two different histograms with the "pt\_v" of the filtered events.
@@ -197,7 +197,7 @@ You don't need to read all these to start using `TDataFrame`, but they are usefu
 ### Default branch lists
 When constructing a `TDataFrame` object, it is possible to specify a **default branch list** for your analysis, in the usual form of a list of strings representing branch names. The default branch list will be used as fallback whenever one specific to the transformation/action is not present.
 ~~~{.cpp}
-// use "b1" and "b2" as default branches for `Filter`, `AddCol` and actions
+// use "b1" and "b2" as default branches for `Filter`, `AddColumn` and actions
 ROOT::Experimental::TDataFrame d1(treeName, &file, {"b1","b2"});
 // filter acts on default branch list, no need to specify it
 auto h = d1.Filter([](int b1, int b2) { return b1 > b2; }).Histo1D("otherVar");
@@ -275,7 +275,7 @@ auto h1 = filtered.Histo1D("var1");
 
 // create a new branch "vec" with a vector extracted from a complex object (only for filtered entries)
 // and save the state of the chain
-auto newBranchFiltered = filtered.AddCol("vec", [](const Obj& o) { return o.getVector(); }, {"obj"});
+auto newBranchFiltered = filtered.AddColumn("vec", [](const Obj& o) { return o.getVector(); }, {"obj"});
 
 // apply a cut and fill a histogram with "vec"
 auto h2 = newBranchFiltered.Filter(cut1).Histo1D("vec");
@@ -308,7 +308,7 @@ Statistics are retrieved through a call to the `Report` method:
 Stats are printed in the same order as named filters have been added to the graph, and *refer to the latest event-loop* that has been run using the relevant `TDataFrame`. If `Report` is called before the event-loop has been run at least once, a run is triggered.
 
 ### Temporary branches
-Temporary branches are created by invoking `AddCol(name, f, branchList)`. As usual, `f` can be any callable object (function, lambda expression, functor class...); it takes the values of the branches listed in `branchList` (a list of strings) as parameters, in the same order as they are listed in `branchList`. `f` must return the value that will be assigned to the temporary branch.
+Temporary branches are created by invoking `AddColumn(name, f, branchList)`. As usual, `f` can be any callable object (function, lambda expression, functor class...); it takes the values of the branches listed in `branchList` (a list of strings) as parameters, in the same order as they are listed in `branchList`. `f` must return the value that will be assigned to the temporary branch.
 
 A new variable is created called `name`, accessible as if it was contained in the dataset from subsequent transformations/actions.
 
@@ -351,8 +351,8 @@ In the following, whenever we say an action "returns" something, we always mean
 As pointed out before in this document, `TDataFrame` can transparently perform multi-threaded event loops to speed up the execution of its actions. Users only have to call `ROOT::EnableImplicitMT()` *before* constructing the `TDataFrame` object to indicate that it should take advantage of a pool of worker threads. **Each worker thread processes a distinct subset of entries**, and their partial results are merged before returning the final values to the user.
 
 ### Thread safety
-`Filter` and `AddCol` transformations should be inherently thread-safe: they have no side-effects and are not dependent on global state.
-Most `Filter`/`AddCol` functions will in fact be pure in the functional programming sense.
+`Filter` and `AddColumn` transformations should be inherently thread-safe: they have no side-effects and are not dependent on global state.
+Most `Filter`/`AddColumn` functions will in fact be pure in the functional programming sense.
 All actions are built to be thread-safe with the exception of `Foreach`, in which case users are responsible of thread-safety, see [here](#generic-actions).
 
 */

tutorials/CTestCustom.cmake

@@ -6,7 +6,7 @@ if("$ENV{COMPILER}" STREQUAL "classic") #  TTreeProcessorM{T,P} are not availabl
   list(APPEND CTEST_CUSTOM_TESTS_IGNORE tutorial-multicore-mp102_readNtuplesFillHistosAndFit)
 endif()
 
-if (CTEST_BUILD_NAME MATCHES arm64 AND CTEST_BUILD_NAME MATCHES dbg)
+if (CTEST_BUILD_NAME MATCHES aarch64 AND CTEST_BUILD_NAME MATCHES dbg)
   # these tutorials are disabled as they timeout
   list(APPEND CTEST_CUSTOM_TESTS_IGNORE tutorial-roostats-StandardBayesianNumericalDemo tutorial-roostats-OneSidedFrequentistUpperLimitWithBands tutorial-tmva-TMVAClassification tutorial-tmva-TMVARegression tutorial-tmva-TMVAMulticlass  tutorial-roostats-TwoSidedFrequentistUpperLimitWithBands)
 endif()

tutorials/dataframe/tdf001_introduction.C

@@ -150,7 +150,7 @@ int tdf001_introduction() {
    // this is like having a general container at disposal able to accommodate
    // any value of any type.
    // Let's dive in an example:
-   auto entries_sum = d.AddCol("sum", [](double b1, int b2) { return b2 + b1; }, {"b1", "b2"})
+   auto entries_sum = d.AddColumn("sum", [](double b1, int b2) { return b2 + b1; }, {"b1", "b2"})
                        .Filter([](double sum) { return sum > 4.2; }, {"sum"})
                        .Count();
    std::cout << *entries_sum << std::endl;

tutorials/dataframe/tdf002_dataModel.C

@@ -106,10 +106,10 @@ int tdf002_dataModel() {
       return ptsw;
       };
 
-   auto augmented_d = d.AddCol("tracks_n", [](const FourVectors& tracks){return (int)tracks.size();})
+   auto augmented_d = d.AddColumn("tracks_n", [](const FourVectors& tracks){return (int)tracks.size();})
                        .Filter([](int tracks_n){return tracks_n > 2;}, {"tracks_n"})
-                       .AddCol("tracks_pts", getPt)
-                       .AddCol("tracks_pts_weights", getPtWeights);
+                       .AddColumn("tracks_pts", getPt)
+                       .AddColumn("tracks_pts_weights", getPtWeights);
 
    auto trN = augmented_d.Histo1D("tracks_n",40,-.5,39.5);
    auto trPts = augmented_d.Histo1D("tracks_pts");

tutorials/dataframe/tdf004_cutFlowReport.C

@@ -63,7 +63,7 @@ void tdf004_cutFlowReport() {
    auto filtered1 = d.Filter(cut1, {"b1"}, "Cut1");
    auto filtered2 = d.Filter(cut2, {"b2"}, "Cut2");
 
-   auto augmented1 = filtered2.AddCol("b3", [](double b1, int b2){ return b1/b2;});
+   auto augmented1 = filtered2.AddColumn("b3", [](double b1, int b2){ return b1/b2;});
    auto cut3 = [](double x) { return x < .5; };
    auto filtered3 = augmented1.Filter(cut3, {"b3"}, "Cut3");