ROOT Version 6.22 Release Notes

Introduction

ROOT version 6.22/00 was released on June 14, 2020.

For more information, see:

http://root.cern

The following people have contributed to this version:

Guilherme Amadio, CERN/SFT,
Bertrand Bellenot, CERN/SFT,
Jakob Blomer, CERN/SFT,
Rene Brun, CERN/SFT,
Philippe Canal, FNAL,
Olivier Couet, CERN/SFT,
Surya Dwivedi, GSOC/SFT,
Massimiliano Galli, CERN/SFT,
Andrei Gheata, CERN/SFT,
Hadrien Grasland, IJCLab/LAL,
Enrico Guiraud, CERN/SFT,
Claire Guyot, CERN/SFT,
Stephan Hageboeck, CERN/SFT,
Sergey Linev, GSI,
Pere Mato, CERN/SFT,
Lorenzo Moneta, CERN/SFT,
Alja Mrak-Tadel, UCSD/CMS,
Jan Musinsky, SAS Kosice,
Axel Naumann, CERN/SFT,
Vincenzo Eduardo Padulano, Bicocca/SFT,
Danilo Piparo, CERN/SFT,
Timur Pocheptsoff, Qt Company,
Renato Quagliani, LPNHE, CNRS/IN2P3, Sorbonne Université,
Fons Rademakers, CERN/SFT,
Oksana Shadura, UNL/CMS,
Enric Tejedor Saavedra, CERN/SFT,
Matevz Tadel, UCSD/CMS,
Vassil Vassilev, Princeton/CMS,
Wouter Verkerke, NIKHEF/Atlas,
Stefan Wunsch, CERN/SFT

Deprecation and Removal

• ROOT::GetImplicitMTPoolSize has been deprecated in favor of the newly added ROOT::GetThreadPoolSize and will be removed in v6.24.
• Manually setting TThreadedObject::fgMaxSlots is deprecated: TThreadedObject now increases the number of slots on-demand rather than running out and throwing an exception

Core Libraries

• ROOT comes with C++ Modules enabled. More details about the technology found here.
• The ACLiC can be configured to pass options to the rootcling invocation by enabling in the .rootrc the ACLiC.ExtraRootclingFlags [-opts] line.
• A call to ROOT::EnableThreadSafety is not required before using TThreadExecutor or TTreeProcessorMT anymore
• TTreeProcessorMT does not silently activate implicit multi-threading features anymore. An explicit call to ROOT::EnableImplicitMT is required instead
• TTreeProcessorMT now has a constructor argument to set the number of threads for its thread-pool

TTree Libraries

• A new status bit was added to TTree: kEntriesReshuffled, which indicates a TTree that is the output of the processing of another tree during which its entry order has been changed (this can happen, for instance, when processing a tree in a multi-thread application). To avoid silent entry number mismatches, trees with this bit set cannot add friend trees nor can be added as friends, unless the friend TTree has an appropriate TTreeIndex.
• TTree::GetBranch has been updated to execute its search trough the set of branches breadth first instead of depth first. In some cases this changes the branch that is returned. For example with:

    struct FloatInt {
       float f;
       int x;
    };

and

   int x = 1;
   FloatInt s{2.1, 3};
   TTree t("t", "t");
   t.Branch("i", &i); // Create a top level branch named "i" and a sub-branch name "x"
   t.Branch("x", &x);

the old version of t.GetBranch("x") was return the i.x sub-branch while the new version return the x top level branch.

• TTree::GetBranch was also upgraded to properly handle being give a full branch name. In prior version, with the example above, GetBranch("i.x") would return nullptr. With the new version it returns the address of the branch i.x.

• TChain now properly carries from TTree to TTree, each TBranch MakeClass (also known as DecomposedObj[ect] mode, if it was set (implicitly or explicitly).

• TTree::SetBranchAddress and TChain::SetBranchAddress now automatically detect when a branch needs to be switched to MakeClass(also known asDecomposedObj[ect]` mode).

• TChain now always checks the branch address; even in the case the address is set before any TTree is loaded. Specifically in addition to checking the address type in the case:

chain->LoadTree(0);
chain->SetBranchAdress(branch_name, &address);

now TChain will also check the addresses in the case:

chain->SetBranchAdress(branch_name, &address);
chain->LoadTree(0);

• TTree and TChain no longet override user provided sub-branch addresses. Prior to this release doing:

// Not setting the top level branch address.
chain->SetBranchAdress(sub_branch_name, &address);
chain->GetEntry(0);

Resulted in the address set to be forgotten. Note that a work-around was:

// Not setting the top level branch address.
chain->GetEntry(0);
chain->SetBranchAdress(sub_branch_name, &address);

But also the address needed to (in most cases) also be set again after each new tree was loaded.

Note that, the following:

chain->SetBranchAdress(sub_branch_name, &address);
chain->SetBranchAdress(top_level_branch_name, &other_address);
chain->GetEntry(0);

will result (as one would expect) with the first SetBranchAddress being ignored/over-ridden.

RDataFrame

• Starting from this version, when RSnapshotOptions.fMode is "UPDATE" (i.e. the output file is opened in “UPDATE” mode), Snapshot will refuse to write out a TTree if one with the same name is already present in the output file. Users can set the new flag RSnapshotOption::fOverwriteIfExists to true to force the deletion of the TTree that is already present and the writing of a new TTree with the same name. See ROOT-10573 for more details.
• RDataFrame changed its error handling strategy in case of unreadable input files. Instead of simply logging an error and skipping the file, it now throws an exception if any of the input files is unreadable (this could also happen in the middle of an event loop). See ROOT-10549 for more details.
• New analysis examples based on the recent ATLAS Open Data release (Higgs to two photons, W boson analysis, Higgs to four leptons)
• An exception is now thrown in case the size of ROOT’s thread-pool changes between RDataFrame construction time and the time the event loop begins.
• Just-in-time compilation of large portions of the computation graph has been optimized, and it is now much faster. Please report any regressions you might encounter on our issue tracker.
• MakeRootDataFrame is now a safe way to construct RDFs. It used to return RDFs with more limited functionality.

Histogram Libraries

• When fitting an histogram using the fit option W (set all bin errors to be equal to 1), renormalize the obtained fit parameter errors using the obtained chi2 fit value. This is the same procedure performed already when fitting a TGraph.
• Applying some fixes when performing histogram fits using bin integral in multi-thread mode.

Math Libraries

Minuit2

• Fix the case when a new better minimum is found while running MINOS
• add some fixed in handling the message printing
• use std::numeric_limits for the default value of the internal precision

Matrix

• Improve TDecompQRH , QR decomposition in an orthogonal matrix Q. Add a function TDecompQR::GetOrthogonalMatrix() returning the Q matrix found by the decomposition.

RooFit Libraries

RooWorkspace::Import() for Python

RooWorkspace.import() cannot be used in Python, since it is a reserved keyword. Users therefore had to resort to

getattr(workspace, 'import')(...)

Now,

workspace.Import(...)

has been defined for the new PyROOT, which makes calling the function easier.

Modernised category classes

RooFit’s categories were modernised. Previously, the class RooCatType was used to store category states. It stores two members, an integer for the category index, and up to 256 characters for a category name. Now, such states are stored only using an integer, and category names can have arbitrary length. This will use 4 instead of 288 bytes per category entry in a dataset, and paves the way for faster computations that rely on category states.

The interface to define or manipulate category states was also updated. Since categories are mappings from state names to state index, this is now reflected in the interface. Among others, this is now possible:

RooCategory cat("cat", "Lepton flavour");
cat["electron"] = 1;
cat["muon"] = 2;

RooCategory cat("cat", "Lepton flavour");
cat.defineType("electron", 1);
cat.defineType("muon", 2);

See also the Category reference guide or different RooFit tutorials, specifically rf404_categories.

Type-safe proxies for RooFit objects

RooFit’s proxy classes have been modernised. The class RooTemplateProxy allows for access to other RooFit objects similarly to a smart pointer. In older versions of RooFit, proxies would always hold pointers to very abstract classes, e.g. RooAbsReal, although one wanted to work with a PDF. Therefore, casting was frequently necessary. Further, one could provoke runtime errors by storing an incompatible object in a proxy. For example, one could store a variable RooRealVar in a proxy that was meant to store PDFs.

Now, RooFit classes that use proxies can be simplified as follows:

RooTemplateProxy<RooAbsPdf> pdf;

RooRealProxy realProxy;

pdf->fitTo(...);

RooAbsArg* absArg = realProxy.absArg();
RooAbsPdf* pdf = dynamic_cast<RooAbsPdf*>(absArg);
// Should work, but maybe someone stored wrong
// object. Add some checking code.
if (pdf != nullptr) {
...
}
pdf->fitTo(...);

Check the doxygen reference guide for RooTemplateProxy for more information on how to modernise old code.

Documentation updates

• The documentation is now structured better. The functional parts like roofitcore, roofit, roostats, histfactory can now be found in doxygen with a similar structure as the directory structure in git.
• Especially the hard-to-find command arguments that can be passed to various functions in RooFit now have their own doxygen page.
• Clarified and extended documentation for plotting PDFs:
  • Since plotting PDFs can be tricky when special normalisation is required (e.g. because of blinding or fitting in side bands), the documentation of RooAbsPdf::plotOn() and the arguments it accepts was updated and clarified.
  • The new tutorial rf212_plottingInRanges_blinding shows how to normalise a PDF if it has been fit only in a part of the plotting range.
• Started grouping of interfaces that are public but not necessarily useful for “normal” in doxygen. Examples are RooCategory or the very broad public interface of RooAbsArg, where the client-server interface that’s only relevant for RooFit or the legacy interfaces are now split off.
• Completely overhaul the documentation of RooWorkspace’s factory syntax.
• Make SPlot documentation understandable.
• Clarify different constructors of RooRealVars, and how to make them constant or initialise them.
• Add a tutorial about plotting with limited ranges rf212_plottingInRanges_blinding
• Improve the tutorial for weighted fits, rf611_weightedfits.

Miscellaneous

• Warn and fail better. Convert things that silently give the wrong results into things that fail noisily.
  • When RooDataSet is read from a file, and there’s a read error, the function now returns nullptr instead of an incomplete dataset.
  • Better checking of invalid formulae in RooGenericPdf / RooFormulaVar. Using e.g. RooFormulaVar(... "x+y", x); silently assumed that y is zero and constant.
  • Ensure that the right number of coefficients is given for RooAddPdf (depends on recursive/non-recursive fractions), and complain if that’s not the case.
• Add automatic conversions when reading values for variables from Trees. New are e.g. ULong64_t, Long64_t, Short_t, UShort_t.
• RooResolutionModel now also takes RooLinearVar as observables. With this, it is possible to easily scale and shift the observable used in the convolutions.
• Add a helper to locally/temporarily change RooFit’s message level. This also includes an object that can hijack all messages sent by a specific object or with specific topics.

HistFactory

Switch default statistical MC errors to Poisson

When defining HistFactory samples with statistical errors from C++, e.g.

  Sample background1( "background1", "background1", InputFile );
  background1.ActivateStatError();

statistical MC errors now default to Poisson instead of Gaussian constraints. This better reflects the uncertainty of the MC simulations, and now actually implements what is promised in the HistFactory paper. For large number of entries in a bin, this doesn’t make a difference, but for bins with low statistics, it better reflects the “counting” nature of bins. This can be reverted as follows:

  // C++:
  Channel chan("channel1");
  chan.SetStatErrorConfig( 0.05, "Gauss" );

  // Within a <Channel ... > XML:
  <StatErrorConfig RelErrorThreshold="0.05" ConstraintType="Gauss" />

Less verbose HistFactory

HistFactory was very verbose, writing to the terminal with lots of cout. Now, many HistFactory messages are going into RooFit’s message stream number 2. The verbosity can therefore be adjusted using

  RooMsgService::instance().getStream(2).minLevel = RooFit::PROGRESS;

hist2workspace is also much less verbose. The verbosity can be restored with hist2workspace -v for intermediate verbosity or -vv for what it printed previously.

TMVA

Deep Learning module

• Extend Deep Learning module by adding support for LSTM and GRU Recurrent layers.
• Add implementation for all recurrent layers (LSTM, GRU, and simple RNN) for GPU using the CUDA cuDNN library
• Add support for Batch Normalization implemented in both CPU and GPU
• Deprecate MethodDNN , defined by the TMVA::kDNN enumeration for building neural networks with fully connected dense layers. It is replaced by MethodDL (TMVA::kDL)
• Deprecate also the option Architecture=Standard for MethodDL. Have only CPU or GPU architecture options. When a BLAS implementation is not found use the CPU architecture with matrix operations provided by the ROOT TMatrix classes.
• Add new tutorials showing usage new Deep Learning functionalities
• All these new updates are documented in the new version of the TMVA Users Guide, available in github here.

PyMVA

• Add support for Tensorflow version 2 as backend for Keras in MethodPyKeras. Note that it requires still an independent Keras installation with a Keras version >= 2.3
• Add also some fixes needed when using Python version 3.

2D Graphics Libraries

• Universal time (correct time zone and daylight saving time) in PDF file. Implemented by Jan Musinsky.
• The crosshair type cursor type did not work on MacOS Catalina. This has been fixed by Timur Pocheptsoff.
• Take into account the Z errors when defining the frame to paint a TGraph2DErrors.
• Implement the of “F” in TPad::RedrawAxis to allow the plot’s frame redrawing when erased.
• Implement TCanvas::SetRealAspectRatio to resize a canvas so that the plot inside is shown in real aspect.
• New graphics style “BELLE2” from Martin Ritter.

Geometry Libraries

Geometry drawing in web browser

When ROOT compiled with -Droot7=ON flag, one can enable geometry drawing in web browser. Just apply –web option when starting root like: root --web tutorials/geom/rootgeom.C Not all features of TGeoPainter are supported - only plain drawing of selected TGeoVolume

Language Bindings

PyROOT

ROOT 6.22 makes the new (experimental) PyROOT its default. This new PyROOT is designed on top of the new cppyy, which provides more and better support for modern C++. The documentation for cppyy and the new features it provides can be found here.

For what concerns new additions to PyROOT, this is the list:

• The ROOT.Numba.Declare decorator provides a simple way to call Python callables from C++. The Python callables are just-in-time compiled with numba, which ensures a runtime performance similar to a C++ implementation. The feature is targeted to improve the performance of Python based analyses, e.g., allows seamless integration into RDataFrame workflows. See the tutorial pyroot004_NumbaDeclare.py for further information.
• Multi-Python builds are now supported (see more info in the Build, Configuration and Testing Infrastructure section).
• The two PyROOT teardown modes (soft and hard) are now fully functional. In the soft mode, at teardown of the Python interpreter, all the proxied C++ objects will be cleaned; in the hard mode, in addition to the proxy cleaning, gROOT.EndOfProcessCleanups() will be invoked and thus the C++ interpreter will be shut down. The hard mode is the default, but if the application just runs a PyROOT script as part of a longer process and it would like ROOT to still be usable after the script finishes, the soft mode can be activated by adding this to the PyROOT script:

import ROOT
ROOT.PyConfig.ShutDown = False

On the other hand, there are some backwards-incompatible changes of the new PyROOT with respect to the new one, listed next:

• Instantiation of function templates must be done using square brackets instead of parentheses. For example, if we consider the following code snippet:

> import ROOT

> ROOT.gInterpreter.Declare("""
template<typename T> T foo(T arg) { return arg; }
""")

> ROOT.foo['int']  # instantiation
 cppyy template proxy (internal)

> ROOT.foo('int')  # call (auto-instantiation from arg type)
'int'

Note that the above does not affect class templates, which can be instantiated either with parenthesis or square brackets:

> ROOT.std.vector['int'] # instantiation
<class cppyy.gbl.std.vector<int> at 0x5528378>

> ROOT.std.vector('int') # instantiation
<class cppyy.gbl.std.vector<int> at 0x5528378>

• Overload resolution in new cppyy has been significantly rewritten, which sometimes can lead to a different overload choice (but still a compatible one!). For example, for the following overloads of std::string:

string (const char* s, size_t n)                           (1)
string (const string& str, size_t pos, size_t len = npos)  (2)

when invoking ROOT.std.string(s, len(s)), where s is a Python string, the new PyROOT will pick (2) whereas the old would pick (1).

• The conversion between None and C++ pointer types is not allowed anymore. Instead, ROOT.nullptr should be used:

> ROOT.gInterpreter.Declare("""
class A {};
void foo(A* a) {}
""")

> ROOT.foo(ROOT.nullptr)  # ok

> ROOT.foo(None)          # fails
TypeError: void ::foo(A* a) =>
TypeError: could not convert argument 1

• Old PyROOT has ROOT.Long and ROOT.Double to pass integer and floating point numbers by reference. In the new PyROOT, ctypes must be used instead.

> ROOT.gInterpreter.Declare("""
void foo(int& i) { ++i; }
void foo(double& d) { ++d; }
""")

> import ctypes

> i = ctypes.c_int(1)
> d = ctypes.c_double(1.)

> ROOT.foo(i); i
c_int(2)

> ROOT.foo(d); d
c_double(2.0)

• When a character array is converted to a Python string, the new PyROOT only considers the characters before the end-of-string character:

> ROOT.gInterpreter.Declare('char MyWord[] = "Hello";')

> mw = ROOT.MyWord

> type(mw)
<class 'str'>

> mw  # '\x00' is not part of the string
'Hello'

• Any Python class derived from a base C++ class now requires the base class to define a virtual destructor:

> ROOT.gInterpreter.Declare("class CppBase {};")
 True
> class PyDerived(ROOT.CppBase): pass
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: CppBase not an acceptable base: no virtual destructor

• There are several name changes for what concerns cppyy APIs and proxy object attributes, including:

• New PyROOT does not parse command line arguments by default anymore. For example, when running python my_script.py -b, the -b argument will not be parsed by PyROOT, and therefore the batch mode will not be activated. If the user wants to enable the PyROOT argument parsing again, they can do so by starting their Python script with:

import ROOT
ROOT.PyConfig.IgnoreCommandLineOptions = False

• In new PyROOT, addressof should be used to retrieve the address of fields in a struct, for example:

> ROOT.gInterpreter.Declare("""
struct MyStruct {
  int a;
  float b;
};
""")

> s = ROOT.MyStruct()

> ROOT.addressof(s, 'a')
94015521402096L

> ROOT.addressof(s, 'b')
94015521402100L

> ROOT.addressof(s)
94015521402096L

In old PyROOT, AddressOf could be used for that purpose too, but its behaviour was inconsistent. AddressOf(o) returned a buffer whose first position contained the address of object o, but Address(o, 'field') returned a buffer whose address was the address of the field, instead of such address being contained in the first position of the buffer. Note that, in the new PyROOT, AddressOf(o) can still be invoked, and it still returns a buffer whose first position contains the address of object o.

• In old PyROOT, there were two C++ classes called TPyMultiGenFunction and TPyMultiGradFunction which inherited from ROOT::Math::IMultiGenFunction and ROOT::Math::IMultiGradFunction, respectively. The purpose of these classes was to serve as a base class for Python classes that wanted to inherit from the ROOT::Math classes. This allowed to define Python functions that could be used for fitting in Fit::Fitter. In the new PyROOT, TPyMultiGenFunction and TPyMultiGradFunction do not exist anymore, since their functionality is automatically provided by new cppyy: when a Python class inherits from a C++ class, a wrapper C++ class is automatically generated. That wrapper class will redirect any call from C++ to the methods implemented by the Python class. Therefore, the user can make their Python function classes inherit directly from the ROOT::Math C++ classes, for example:

import ROOT

from array import array

class MyMultiGenFCN( ROOT.Math.IMultiGenFunction ):
    def NDim( self ):
        return 1

    def DoEval( self, x ):
        return (x[0] - 42) * (x[0] - 42)

    def Clone( self ):
        x = MyMultiGenFCN()
        ROOT.SetOwnership(x, False)
        return x

def main():
    fitter = ROOT.Fit.Fitter()
    myMultiGenFCN = MyMultiGenFCN()
    params = array('d', [1.])
    fitter.FitFCN(myMultiGenFCN, params)
    fitter.Result().Print(ROOT.std.cout, True)

if __name__ == '__main__':
    main()

• Fixed in 6.22/04, true for 6.22/00 and 6.22/02: Inheritance of Python classes from C++ classes is not working in some cases. This is described in ROOT-10789 and ROOT-10582. This affects the creation of GUIs from Python, e.g. in the Python GUI tutorial, where the inheritance from TGMainFrame is not working at the moment. Future releases of ROOT will fix these issues and provide a way to program GUIs from Python, including a replacement for TPyDispatcher, which is no longer provided.

• When iterating over an std::vector<std::string> from Python, the elements returned by the iterator are no longer of type Python str, but cppyy.gbl.std.string. This is an optimization to make the iteration faster (copies are avoided) and it allows to call modifier methods on the std::string objects.

> import cppyy

> cppyy.cppdef('std::vector<std::string> foo() { return std::vector<std::string>{"foo","bar"};}')

> v = cppyy.gbl.foo()

> type(v)
<class cppyy.gbl.std.vector<string> at 0x4ad8220>

> for s in v:
...   print(type(s))  # s is no longer a Python string, but an std::string
...
<class cppyy.gbl.std.string at 0x4cd41b0>
<class cppyy.gbl.std.string at 0x4cd41b0>

Tutorials

• Add 3 new TMVA tutorials:
  • TMVA_Higgs_Classification.C showing the usage of the TMVA deep neural network in a typical classification problem,
  • TMVA_CNN_Classification.C showing the usage of CNN in TMVA with MethodDL and in PyMVA using MethodPyKeras,
  • TMVA_RNN_Classification.C showing the usage of RNN in both TMVA and Keras.

Class Reference Guide

• A new version switching mechanism has been introduced; see https://github.com/root-project/doxyvers

Build, Configuration and Testing Infrastructure

• By default, ROOT now falls back to the built-in version of xrootd if it can’t find it in the system. This means that passing -Dbuiltin_xrootd=ON is not necessary anymore to build ROOT with xrootd support. Note that built-in xrootd requires a working network connection.
• Glew library was moved from ROOT graf3d sources to the proper ROOT builtins mechanism (GLEW library and headers are still installed together with ROOT for backward compatibility)
• ROOT uses header files from source directories to build own ROOT libraries; header files from $ROOTSYS/include directory only required to compile users code.
• Updated version of Glew used as buitin mechanism in ROOT: 2.1.0 (http://glew.sourceforge.net/)
• Updated version of googletest library: 1.10.0

Experimental address sanitizer build configuration

Added a build flag asan that switches on address sanitizer. It’s experimental, so expect problems. For example, when building with gcc, manipulations in global variables in llvm will abort the build. Such checks can be disabled using environment variables. Check the address sanitizer documentation or the link below for details. In clang, which allows to blacklist functions, the build will continue.

See core/sanitizer for information.

Optimization of ROOT header files

Many (but intentionally not all) unused includes were removed from ROOT header files. For instance, #include "TObjString.h" and #include "ThreadLocalStorage.h" were removed from TClass.h. Or #include "TDatime.h" was removed from TDirectory.h header file . Or #include "TDatime.h" was removed from TFile.h. This change may cause errors during compilation of ROOT-based code. To fix it, provide missing the includes where they are really required. This improves compile times and reduces code inter-dependency; see https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/WhyIWYU.md for a good overview of the motivation.

Even more includes will be “hidden” when ROOT configured with -Ddev=ON build option. In that case ROOT uses #ifdef R__LESS_INCLUDES to replace unused includes by class forward declarations. Such dev builds can be used to verify that ROOT-based code really includes all necessary ROOT headers.

Multi-Python PyROOT

In 6.22, the new (experimental) PyROOT is built by default. In order to build with the old PyROOT instead, the option -Dpyroot_legacy=ON can be used. This is a summary of the PyROOT options:

• pyroot: by default ON, it enables the build of PyROOT.
• pyroot_legacy: by default OFF, it allows the user to select the old PyROOT (legacy) to be built instead of the new one.
• pyroot_experimental: this option is deprecated in 6.22 and should no longer be used. If used, it triggers a warning.

This new PyROOT also introduces the possibility of building its libraries for both Python2 and Python3 in a single ROOT build (CMake >= 3.14 is required). If no option is specified, PyROOT will be built for the most recent Python3 and Python2 versions that CMake can find. If only one version can be found, PyROOT will be built for only that version. Moreover, for a given Python installation to be considered, it must provide both the Python interpreter (binary) and the development package.

The user can also choose to build ROOT only for a given Python version, even if multiple installations exist in the system. For that purpose, the option -DPYTHON_EXECUTABLE=/path/to/python_exec can be used to point to the desired Python installation.

If the user wants to build PyROOT for both Python2 and Python3, but not necessarily with the highest versions that are available on the system, they can provide hints to CMake by using -DPython2_ROOT_DIR=python2_dir and/or -DPython3_ROOT_DIR=python3_dir to point to the root directory of some desired Python installation. Similarly, Python2_EXECUTABLE and/or Python3_EXECUTABLE can be used to point to particular Python executables.

When executing a Python script, the Python version used will determine which version of the PyROOT libraries will be loaded. Therefore, once the ROOT environment has been set (e.g. via source $ROOTSYS/bin/thisroot.sh), the user will be able to use PyROOT from any of the Python versions it has been built for.

Regarding TPython, its library is built only for the highest Python version that PyROOT is built with. Therefore, in a Python3-Python2 ROOT build, the Python code executed with TPython must be Python3-compliant.

Bugs and Issues fixed in this release

• [ROOT-8799] - Automatically convert Python iterables into C++ collections
• [ROOT-10346] - [DF] Warn on mismatch between slot pool size and effective number of slots
• [ROOT-2566] - RooNDKeysPdf has no default constructor which causes a crash when reading it from a workspace
• [ROOT-2936] - Problem plotting slices of RooSimultaneous
• [ROOT-3579] - RooTreeDataStore not Cloning the tree properly (and const correctness)
• [ROOT-4060] - histfactory - print error and exit if channel name begins with numeric char
• [ROOT-4312] - NLL problem using setData
• [ROOT-4580] - RooDataSet reduce(Cut(mycut)) and Draw(myvar,mycut) give different results
• [ROOT-7485] - Incorrect normalization when using named ranges in fitTo() and fitting several times
• [ROOT-7520] - Segmentation fault when loading a RooLinearVar from a RooWorkspace
• [ROOT-7578] - HistFactory: invalid Sample names cause segfault
• [ROOT-7921] - component(s) … already in the workspace when using PROD after EDIT
• [ROOT-7983] - Missing RooDataSet::createHistogram methods
• [ROOT-7986] - Severe memory leak reading RooFitResult and HypoTestInverterResult from disk
• [ROOT-9535] - Unexpected crash when cloning TH2 histogram
• [ROOT-9556] - [DF] Users might silently get wrong results when they process two trees as friends, one of which has been produced by a multi-thread Snapshot of the other
• [ROOT-9768] - Char array branches not correctly retrieved as Python strings
• [ROOT-9966] - Thread-safety problem in TFile from use of TSystem
• [ROOT-10109] - Wrong overload resolution for GetBinErrorUp in TH2D
• [ROOT-10146] - TH2 FitSlicesX() and TH3 FitSlicesZ() don’t use the axis range set by user
• [ROOT-10159] - from ROOT import on python cmd line fails if IPython is already imported
• [ROOT-10175] - Notebook jsmva on package util not found
• [ROOT-10178] - TTreeProcessorMT can’t deal with trees with different names in the same TChain
• [ROOT-10209] - ROOT 6.18/00 does not compile with CUDA available in C++17 mode
• [ROOT-10277] - Crash when generating a large number of datasets
• [ROOT-10397] - [TTreeReaderArray] Segfault when accessing data from leaflist
• [ROOT-10417] - TMVA test bug: rtensor.cxx:303
• [ROOT-10458] - RDataFrame: sub-par diagnostics for interpreted types
• [ROOT-10488] - TClass::GetListOfMethods does not include constructor for std::hash
• [ROOT-10494] - TChain::Add and TChain::AddFile broken with URL that contains double slashes
• [ROOT-10503] - RooAbsPdf::chi2FitTo overloads get lost in PyROOT
• [ROOT-10508] - RDataFrame created from TChain after calling TChain::AddFriend() crashes when trying to plot a variable if MultiThread is enabled
• [ROOT-10517] - RooFit::CutRange is buggy with multiple range
• [ROOT-10518] - chi2FitTo and fitTo are not working properly with multiple ranges
• [ROOT-10524] - Performance anomaly when running TChain::AddFriend()
• [ROOT-10527] - RDataFrame Display() crashes with column of std::string
• [ROOT-10529] - Error in <TClass::ReadRules()>: Cannot find rules etc/class.rules
• [ROOT-10533] - [TTreeProcessorMT] Support friend chains with differently named trees
• [ROOT-10545] - .qqqqqq does not exit root
• [ROOT-10549] - RDataFrame warns but does not throw when skipping files after network glitch
• [ROOT-10550] - plotOn normalization crazy and error message when doing loops of toys
• [ROOT-10561] - [TTreeProcessorMT] Breaks without EnableImplicitMT on
• [ROOT-10563] - RDataFrame::Cache fails when used with RDataFrame::Alias
• [ROOT-10568] - Wrong version in master branch
• [ROOT-10572] - roofit plotOn reproducibly crashes when having done many toys before, in a specific configuration
• [ROOT-10573] - Snapshot fails to update TTree if Multithreading enabled
• [ROOT-10575] - Issues with enabling pyroot_experimental
• [ROOT-10576] - Error getting list of methods of std in cxx17
• [ROOT-10578] - TMVA::Experimental Intel compiler support
• [ROOT-10583] - Incorrect OpenGL rendering
• [ROOT-10587] - [Doc] Python RDF tutorials not shown correctly in doxygen
• [ROOT-10595] - Bias obtained in TH1::KolmogorovTest when using option X
• [ROOT-10596] - [DF] Deprecate/hide ROOT::MakeRootDataFrame
• [ROOT-10597] - ROOT 6.20.0 fails to compile with -Dcuda=yes when cudnn not installed
• [ROOT-10599] - rootls -t doesn’t work with multiple cycles for a tree
• [ROOT-10601] - Problem Drawing Histograms after TH2::FitSlicesX/Y
• [ROOT-10605] - wrong slice in plotting simultaneous pdf built with RooSimWSTool
• [ROOT-10606] - current master fails basic RooFit functionality due to cppyy changes
• [ROOT-10619] - [DF] Crash with unused jitted filters
• [ROOT-10624] - [Graphics][JSROOT] Broken histogram fill color with %jsroot on
• [ROOT-10629] - clang CodeGen assertion “popping exception stack when not empty”
• [ROOT-10630] - Failed to run python code: copy_string=history.history.keys()[0]
• [ROOT-10647] - Missing implementation of “section” in RooArgSet::writeToStream
• [ROOT-10648] - Occasional streamer type mismatch in multi-thread TTree writing
• [ROOT-10654] - rootmv doesn’t work with multiple cycles TTrees in TFiles
• [ROOT-10656] - TTreeProcessorMT leaves implicit multi-threading enabled after a call to Process
• [ROOT-10658] - wrong -I flags provided for dictionary compilation
• [ROOT-10661] - rootcling produces uncompilable dictionary if class depends on boost headers
• [ROOT-10663] - ROOT dictionary for ATLAS persistent class can’t load correctly
• [ROOT-10668] - RooFit with Asymptotically Correct approach will segfault if RooRealVar Name != Title
• [ROOT-10670] - hesse does not know which minimizer to use
• [ROOT-10672] - segfault when retrieving TTreeCache from TChain
• [ROOT-10676] - Constructing a RooDataSet from TTree with cuts causes warnings
• [ROOT-10680] - PyROOT numpy vs RVec<bool> comparison results in infinite loop
• [ROOT-10681] - New cppyy only provides addressof, not AddressOf
• [ROOT-10689] - cling misidentifies called lambda
• [ROOT-10693] - PyROOT Infinite iteration over RVec
• [ROOT-10696] - TDirectory::GetObject() with wrong type leaks memory
• [ROOT-10702] - [TTree] Wrong data could be silently written if data-member of object has same name as another branch
• [ROOT-10706] - Fit to TMultiGraph with single TGraphAsymErrors different from single graph fit
• [ROOT-10709] - RooFit depends from MathMore when ROOT compiled with -Dmathmore=ON
• [ROOT-10711] - X, Y axis scale changes during allinging X,Y axis title as centered in TMultiGraph
• [ROOT-10712] - Failing template instantiation during tear down.
• [ROOT-10713] - Several memory leaks when reading RooStats::HypoTestInverterResult
• [ROOT-10718] - TMath::Poisson(n,mu) for n = 0 and mu < 0 returns wrong value !
• [ROOT-10721] - Python tutorials are not compatible with Python 3
• [ROOT-10723] - [TChain] Potential access to invalid fTree in TChain destructor
• [ROOT-10731] - PyROOT Broken conversion from boolean numpy array to bool*
• [ROOT-10732] - hadd broken
• [ROOT-10733] - gtest-tree-treeplayer-test-treeprocessormt fails without xrootd
• [ROOT-10734] - pymva tutorials not disable when pymva not available
• [ROOT-10736] - roofit tutorials failing without PyRoot-experimental.
• [ROOT-10737] - RooAbsPdf is distorted outside its “Range” used previously with fitTo
• [ROOT-10751] - ROOT Fails to find C++ standard library path on non-standard locale
• [ROOT-10753] - [TTreeReader] Wrong entries are loaded in case of TChain+TEntryList
• [ROOT-10754] - [cling] Miscompilation with make_shared/shared_ptr
• [ROOT-10764] - RooAbsAnaConvPdf crashes when being imported and retrieved from RooWorkspace
• [ROOT-10765] - C++14 now requires root7
• [ROOT-10766] - Missing overload in LHCb’s FuncOps__::__le__
• [ROOT-10768] - Document backwards incompatible changes & new features in the new PyROOT
• [ROOT-10774] - rootbrowse freezes after startup
• [ROOT-10777] - Cannot py-import Gaudi: assert “partial specialization scope specifier in SFINAE context”
• [ROOT-10779] - HistFactory models that are written to a file, then retrieved with updated histograms find only old histograms
• [ROOT-10782] - With gcc10 STL headers don’t include implicitly stdexcept
• [ROOT-10784] - Mistake in what is reported in documentation
• [ROOT-10788] - PyROOT failed to load cmssw libraires
• [ROOT-10790] - [DF] Single-thread Snapshot into a directory also creates a spurious TTree outside of it
• [ROOT-10792] - [DF] Snapshot of TClonesArrays read via TTreeReaderArray is broken
• [ROOT-10798] - ROOT 6.20/02 can’t generate a dictionary for ATLAS’s EventLoop package
• [ROOT-10804] - assertion in clang::Sema::LookupSpecialMember
• [ROOT-10810] - Segmentation fault in pickling of weighted RooFit datasets
• [ROOT-10820] - Circular includes Rtypes.h and TGenericClassInfo.h
• [ROOT-10822] - [DF] RVecs of non-split branches can read from invalid addresses
• [ROOT-10833] - PyROOT FutureWarning in ROOT.py
• [ROOT-10837] - hadd crashes when slow merging file with multiple array with same index
• [ROOT-10839] - Missing lock guard in THashTable
• [ROOT-6882] - RooFit doesn’t support ULong64_t
• [ROOT-10341] - Support I/O for RooNDKeysPDF
• [ROOT-10534] - RDataFrame Provide report about number of event loops run
• [ROOT-2558] - SPlot crashes when yields are not the top level fitparameters
• [ROOT-5311] - HistFactory output is too verbose and cannot be controlled
• [ROOT-8033] - Poisson constraint for statistical error in HistFactory
• [ROOT-9365] - Member functions’ definition locations missing in Class HistoToWorkspaceFactoryFast
• [ROOT-10513] - [PyROOT exp] Use consistent names for interoperability functions
• [ROOT-10521] - RooAbsData::getRange() argument var should be const
• [ROOT-10657] - [DF] Speed up jitting
• [ROOT-10665] - Make TFile::ReadProcessID thread safe

Release 6.22/02

Published on August 17, 2020

RDataFrame

• With ROOT-10023 fixed, RDataFrame can now read and write certain branches containing unsplit objects, i.e. TBranchObjects. More information is available at ROOT-10022.
• Snapshot now respects the basket size and split level of the original branch when copying branches to a new TTree.
• For some TTrees, RDataFrame’s GetColumnNames method returns multiple valid spellings for a given column. For example, leaf "l" under branch "b" might now be mentioned as "l" as well as "b.l", while only one of the two spellings might have been recognized before.

Bugs and Issues fixed in this release

• [ROOT-9240] - Compiled program with libNew.so crash
• [ROOT-9731] [DF] Cannot read columns holding TVector3 pointers
• [ROOT-10023] [TTreeReader] Unable to read TBranchObject
• [ROOT-10796] Bug in MakeProxy std::map<int,std::vector<double,*>>
• [ROOT-10845] RooArgSet IsOnHeap result incorrect
• [ROOT-10846] TPython documentation is gone
• [ROOT-10870] pyROOT issue with std::shared_ptr in 6.22/00
• [ROOT-10882] Drawing crashes when histogram title contain special characters
• [ROOT-10884] Error importing JupyROOT with conda ROOT
• [ROOT-10889] [RDF] Unexpected/broken behaviour of the Display action
• [ROOT-10891] [DF] Display of char* branches is broken
• [ROOT-10913] RooCategory doesn’t update its label when its state is dirty.
• [ROOT-10916] [Graphics][JSROOT] “%jsroot on” broken in Juypter notebooks
• [ROOT-10917] prompt: pressing ctrl-R when no root_hist file is present results in a segfault
• [ROOT-10920] Models with Poisson constraints don’t have noRounding=true
• [ROOT-10925] Can not compile ROOT macro on Windows
• [ROOT-10927] Dramatic increase of memory usage while reading trees containing histograms
• [ROOT-10931] Polygon doesn’t close when drawing PDF as filled curve
• [ROOT-10934] Error when making a nested RooSimultaneous
• [ROOT-10969] Can not compile ROOT macro on Win10: picking up paths to other SW
• [ROOT-10987] RooFit’s caching can lead to wrong results when batch computations used.
• [ROOT-10022] [DF] Add support for TBranchObjects (e.g. branches containing TH2F)
• [ROOT-10967] PyROOT Improve pretty printing to respect existing C++ methods

Release 6.22/04

Published on an unlucky Friday, November 13, 2020, this release had a fatal issue in the I/O subsystem, which is why it was never announced. Please use 6.22/06 instead!

PyROOT

• Several issues related with Python-C++ inheritance have been fixed. One of these issues affected the programming of GUIs from Python because of an error when inheriting from TGMainFrame (see ROOT-10826); such error is no longer there and GUIs can be programmed again from Python, using the TPyDispatcher class as before. Moreover, the inheritance from TSelector has been fixed too, which makes it possible to extend TSelector by directly inheriting from it, instead of using the TPySelector class that was provided in the old PyROOT (see ROOT-11025).

Bugs and Issues fixed in this release

• [ROOT-8173] - RooStreamParser not working for float number with negative exponent
• [ROOT-8331] - Error in the member function Multiply(const Double_t *vin, Double_t* vout, Double_t w) in TEveTrans of Eve package
• [ROOT-9563] - [TreeProcMT] Trees in subdirectories are not supported (and their usage lead to a crash)
• [ROOT-9674] - [DF] Wrong branch type inference in some cases
• [ROOT-10152] - [DF] Cannot analyze friend trees in subdirectories with MT
• [ROOT-10786] - Cling not intepreting using directive
• [ROOT-10826] - Inheritance issue when creating GUI from Python
• [ROOT-10849] - Recursive ASTReader assertion Fedora32 C++17
• [ROOT-10862] - TMVA in ROOT 6.22/00 doesn’t use the built-in GSL library correctly
• [ROOT-10886] - 6.22/00 Build failure with Clang 7.0.0 on SL7 with -Druntime_cxxmodules:BOOL=ON
• [ROOT-10896] - IMT Snapshot segfault when TTree switches over multiple files
• [ROOT-10935] - RooDataSet::read() no longer accepts RooCategory numbers
• [ROOT-10942] - [DF] Regression in recognition of nested branch names
• [ROOT-10993] - ROOT fails in loading nlohmann/json
• [ROOT-11000] - rootcling fails for Gaudi classes
• [ROOT-11001] - unable to create TChain on ROOT file
• [ROOT-11010] - PyROOT cross-inheritance fails to call proper constructor
• [ROOT-11013] - “Impossible code path” in TGenCollectionProxy.cxx when using rootcling
• [ROOT-11015] - OpenGL rendering is incorrect for “pgon - pgon”
• [ROOT-11025] - Issue with automatic C++ wrapper during inheritance (to replace TPySelector)
• [ROOT-11027] - Lxplus ROOT installation not showing graphics from Python
• [ROOT-11030] - pythonization segfault with derived TTree class in namespace
• [ROOT-10844] - Check GUI-related PyROOT tutorials

• [ROOT-10872] - cppyy tries to generate copy constructors for non copyable classes

• #6529 - segfault in RooWorkspace::import
• #6408 - Creating RooDataSet causes SegFault
• #6553 - TMVA Provide support in MethodPyKeras for tensorflow.keras
• #6455 - [DF] RDataSource does not early-quit event loops when all Ranges are exhausted
• #6579 - PyROOT: AttributeError: Failed to get attribute TPyDispatcher from ROOT
• #6435 - [DF] Jitted Min method breaks with RVec columns
• #6467 - TChain issue in PyROOT with conda
• #6376 - vtable corruption in Python specialization of C++ classes
• #6356 - [JupyROOT][roottest] New nbconvert versions break notebook comparisons
• #6482 - TClass::GetListOfFunctions() fails to enumerate using decls.
• #6359 - python: interpreter/llvm/src/include/llvm/Support/Casting.h:106: static bool llvm::isa_impl_cl<To, const From*>::doit(const From*) [with To = clang::UsingDecl; From = clang::Decl]: Assertion ‘Val && “isa<> used on a null pointer”’ failed.
• #6578 - Using declaration of TGMainFrame constructor not taken into account
• #6666 - TClass::GetListOfDataMembers returns an empty list even-though the information is available.
• #6725 - rootpcm does not record TEnum’s underlying type
• #6726 - TStreamerInfo::GenerateInfoForPair generates the wrong offset if an enum type is first.
• #6670 - segfault in TClass::InheritsFrom() depending on linking order
• #6465 - ROOT signed-char convertion issue on AARCH64
• #6443 - Spurrious auto-parsing (as seen with CMS file and libraries)

• #6509 - [ROOT I/O] Warning: writing 1 byte into a region of size 0

Release 6.22/06

Published on Friday, November 27, 2020.

macOS Big Sur support

This version supports macOS 11.0 (aka “Big Sur”), which required several adjustments on ROOT’s side. Starting with this version, ROOT also supports Apple’s ARM-architecture M1 processor (“Apple Silicon”). Note that tbb does not officially support Apple’s M1 chip. ROOT will implement a workaround for this in an upcoming release.

Bugs and Issues fixed in this release

• #6840 - TClass for pair sometimes have the wrong offset/size
• #6540 - Crash message should point to github
• #6838 - build/unix/compiledata.sh assumes macOS will always have major version 10
• #6563 - Test failures on MacOS with Xcode 12
• #6839 - Compilation fails on macosx 11.0 with arm processor
• #6797 - TCling::UpdateListOfLoadedSharedLibraries() Linux thread safety
• #6331 - Fedora 32 test failures
• #6856 - error when creating a python class inheriting from a ROOT class, 6.22/02

Release 6.22/08

Published on March 10, 2021

Windows Binaries

Due to false positive virus scanner reports, all previous Windows binaries of ROOT have been removed. These false positives were addressed by a trivial change to ROOT’s sources which is available since 6.22/08.

Build, Configuration and Testing Infrastructure

The following builtins have been updated:

• VecCore 0.7.0

Bugs and Issues fixed in this release

• #6944 - RDataFrame misidentifies vector type of a friend tree with identical branch name to another friend tree
• #6964 - [TTree] GetLeaf ignores the branchname arg if friend trees are present
• #7016 - Memory leak during schema evolution of some classes
• #7143 - TTreeProcessorMT: Fails when iterating over different treenames within same ROOT file
• #6933 - ROOT 6.22 should reject TBB 2021.1.1 and above during configuration (fails to compile)
• #7115 - regex_error when selecting pdf components to plot
• #7240 - [RF] Batch mode returns broken logarithms when -DVDT=OFF

HEAD of the v6-22-00-patches branch

These changes will be part of a future 6.22/10.