ROOT version 6.18/00 was released on June 25, 2019.
For more information, see http://root.cern
The following people have contributed to this new version:
Kim Albertsson, CERN/ATLAS,
Guilherme Amadio, CERN/SFT,
Bertrand Bellenot, CERN/SFT,
Iliana Betsou, CERN/SFT,
Jakob Blomer, CERN/SFT,
Brian Bockelman, Nebraska,
Rene Brun, CERN/SFT,
Philippe Canal, FNAL,
Javier Cervantes Villanueva, CERN/SFT,
Olivier Couet, CERN/SFT,
Alexandra Dobrescu, CERN/SFT,
Giulio Eulisse, CERN/ALICE,
Gerri Ganis, CERN/SFT,
Andrei Gheata, CERN/SFT,
Enrico Guiraud, CERN/SFT,
Stephan Hageboeck, CERN/SFT,
Jan Knedlik, GSI,
Sergey Linev, GSI,
Pere Mato, CERN/SFT,
Lorenzo Moneta, CERN/SFT,
Alja Mrak-Tadel, UCSD/CMS,
Axel Naumann, CERN/SFT,
Vincenzo Eduardo Padulano, Bicocca/SFT,
Danilo Piparo, CERN/SFT,
Fons Rademakers, CERN/SFT,
Henry Schreiner, Princeton,
Oksana Shadura, Nebraska,
Simon Spies, GSI,
Yuka Takahashi, Princeton and CERN/SFT,
Enric Tejedor Saavedra, CERN/SFT,
Matevz Tadel, UCSD/CMS,
Vassil Vassilev, Princeton/CMS,
Wouter Verkerke, NIKHEF/Atlas,
Zhe Zhang, Nebraska,
Stefan Wunsch, CERN/SFT
The Virtual Monte Carlo (VMC) interfaces have been deprecated for this release and will be removed in a future release. It is no longer built by default, but can still be enabled with the option -Dvmc=ON in the CMake configuration phase. A standalone version of VMC is being developed at https://github.com/vmc-project/vmc to replace the deprecated version in ROOT.
Support for the following optional components of ROOT has been removed:
In addition, the following deprecated parts of ROOT components have been removed:
THttpServer::ExecuteHttp() and THttpServer::SubmitHttp from THttpServerThe deprecation of the GraphViz integration has been reverted since the code is still in use.
The ODBC interface, deprecated in ROOT 6.16, is no longer deprecated in ROOT 6.18. It is the main option to support databases on Windows, so the decision to deprecate it was reverted.
The xft option has been merged into x11 and is no longer used (its value is now ignored by ROOT).
R__SUGGEST_ALTERNATIVE("Suggestion text") macro allows to suggest alternatives to classes. It must be used after the class definition and before the final semicolon:class DoNotUseClass {
} R__SUGGEST_ALTERNATIVE("Use ... instead.");It is activated by the preprocessor defines R__SUGGEST_NEW_INTERFACE. The former is useful when deprecation warnings should be activated/deactivated at global level, for example for an entire project. This could be done by defining R__SUGGEST_NEW_INTERFACE in the build system. If the warning needs to be confined within single translation units, irrespective of the definition of R__SUGGEST_NEW_INTERFACE, the R__ALWAYS_SUGGEST_ALTERNATIVE macro can be used:
#ifndef DONOTUSECLASS_H
#define DONOTUSECLASS_H
class DoNotUseClass {
} R__ALWAYS_SUGGEST_ALTERNATIVE("Use ... instead.");
#endifThe same macro as for classes can be used for functions:
TIterator* createIterator() const
R__SUGGEST_ALTERNATIVE("begin(), end() and range-based for loops.") {
return makeLegacyIterator();
}The deprecrated I/O plugins for HDFS, Castor and RFIO have been removed.
A new version of zlib (ZLIB-CF), based on ZLIB Cloudlare fork and CMSSW zlib Cloudlare fork, was added in ROOT. It is a high performance modification of zlib 1.2.8 compression algorithm, which offers up to 70% faster compression speed for Intel/ARMv8 processors for tested use cases (30% - for fast compression (CompressionSettings(101)) and 70% for the slow compression (CompressionSettings(109))), using SIMD/NEON acceleration for CRC32 and Adler computations. ZLIB-CF was adopted in ROOT using a zlib builtin mechanism. To enable ZLIB-CF, please use -Dbuiltin_zlib=ON flag.
The following methods were deprecated and removed:
Bool_t THttpServer::SubmitHttp(THttpCallArg *arg, Bool_t can_run_immediately = kFALSE, Bool_t ownership = kFALSE)Bool_t THttpServer::ExecuteHttp(THttpCallArg *arg)Bool_t TRootSniffer::Produce(const char *path, const char *file, const char *options, void *&ptr, Long_t &length, TString &str)TString THttpCallArg::GetPostDataAsString()void THttpCallArg::FillHttpHeader(TString &buf, const char *header = nullptr)void THttpCallArg::SetBinData(void *data, Long_t length)The methods could be replaced by equivalent methods with other signature:
Bool_t THttpServer::SubmitHttp(std::shared_ptr<THttpCallArg> arg, Bool_t can_run_immediately = kFALSE)Bool_t THttpServer::ExecuteHttp(std::shared_ptr<THttpCallArg> arg)Bool_t TRootSniffer::Produce(const std::string &path, const std::string &file, const std::string &options, std::string &res)const void *THttpCallArg::GetPostData() constLong_t THttpCallArg::GetPostDataLength() conststd::string THttpCallArg::FillHttpHeader(const char *header = nullptr)void THttpCallArg::SetContent(std::string &&cont)TStringLong class is deprecated. Please use std::string (or, if needeed, TString) instead.ClassDef(Inline) macros with an error prompted at dictionary generation or compile time.TDirectory and TFile:TMemFiles.Added necessary changes to allow XRootD local redirection - Uses standard VectorReadLimits and does not query a XRootD data server (which is unknown in local redirection), when it is redirected to a local file - Adds a new constructor with a const char *lurl to TNetXNGFile and passes it to TFile, if set. This allows redirection to files that have a different name in the local file system and is important to allow derivation (for example to TAlien and TJAlienFile) while still keeping functionality via TArchiveFile when the file name in the local file system does not match *.zip
Add possibility to convert STL std::map, std::multimap, std::unordered_map, std::unordered_multimap classes into JSON object. This only possible when key typename is std::string (or compatible) and contains only valid JSON identifiers. By default these classes converted into JSON array of std::pair objects. To enable new feature, compact parameter should be 5:
std::map<std::string,int> obj;
obj["name1"] = 11;
obj["name1"] = 22;
auto json = TBufferJSON::ToJSON(&obj, 5);
// {"_typename": "map<string,int>", "name1": 11, "name2": 22}
auto dflt_json = TBufferJSON::ToJSON(&obj);
// [{"$pair" : "pair<string,int>", "first" : "name1", "second" : 11}, {"$pair" : "pair<string,int>", "first" : "name2", "second" : 22}]Also one could put “JSON_object” string in class-member comments to enable this feature:
class Container {
int field{5};
std::unordered_map<std::string,double> data; ///< JSON_object indicates conversion
};Now one could disable storage of type information - _typename field. For that compact parameter has to include value 100. Be aware that such JSON representation may not be recognized by JSROOT. Maximal compression of JSON can be achieved now with compact parameter 128 = 100 + 20 + 5 + 3: 3 - remove all spaces and new lines 5 - convert map->object (when applicable) 20 - special compression of large arrays (auto-detected in JSROOT) 100 - suppressing _typename for all classes
Cache and Snapshot. This allows usage of a larger set of regular expressions to specify which columns should be written out.GetNSlots method to easily retrieve the number of slots that will be used by DefineSlot, ForeachSlot, OnPartialResultSlot, …HasColumn method to check whether a column is available to a given RDF nodeAsRNode helper function to convert RDF nodes to the common RNode typeAsNumpy method to export contents of a RDataFrame as a dictionary of numpy arrays
MakeNumpyDataFrame factory to process data owned by numpy arrays with RDataFrameStats method has been added, allowing to retrieve a TStatistic object filled with the values of a column and, optionally, the values of a second column to be used as weights.Float16_t and Double32_t values using the truncation methods from TBuffer (See for example TBuffer::WriteDouble32)'f' (Float16_t) and 'd' (Double32_t)TStreamerElement::GetRange. Therefore the range and bits specifier has to be attached to the type character.TTree and TBuffer has been updated accordingly.Float16_t floatVal;
Float16_t floatArray[7];
Double32_t doubleVal;
Double32_t doubleArray[5];
TTree *tree = new TTree("tree", "An example tree using the new data types");
tree->Branch("floatVal", &floatVal, "floatVal/f"); // Float16_t value with default settings
tree->Branch("floatArray", floatArray, "floatArray[7]/f[0,100]"); // Float16_t array with range from 0 to 100
tree->Branch("doubleVal", &doubleVal, "doubleVal/d[0,1000,20]"); // Double32_t value with range from 0 to 1000 and 20 bits
tree->Branch("doubleArray", doubleArray, "doubleArray[5]/d[0,0,18]"); // Double32_t array without range and 18 bitsTBulkBranchRead class (inside the ROOT::Experimental::Internal namespace) provides a mechanism for reading, in a single library call, many events’ worth of simple data (primitive types, arrays of primitives, split structures) stored in a TTree. This allows for extremely fast delivery of event data to the process. This is meant as an internal interface that allows the ROOT team to implement faster high-level interface.TTreeReaderFast class (inside the ROOT::Experimental::Internal namespace) provides a simple mechanism for reading ntuples with the bulk IO interface.TH1::FindFirstBinAbove(..) and TH1::FindLastBinAvove(..) functionsSetBinError and fix a bug in GetBinError in case of weighted events.TF1::GetX has been improved. In case of the presence of multiple roots, the function will return the root with the lower x value. In case of no-roots a NaN will be returned instead of returning a random incorrect value.TComplex value printer for printing the value of object at the root prompt and in pythonTLorentzVector a link to ROOT::Math::LorentzVector, which is a superior tool.TStatistic::Merge able to deal silently with empty TStatistic objects. This implementation is useful when filling TStatistics with one of ROOT’s implicitly parallelised utilities such as RDataFrame or TThreadExecutor.T RVec<T>::at>(size_t, T) method to allow users to specify a default value to be returned in case the vector is shorter than the position specified. No exception is thrown.Concatenate helper to merge the content of two RVec<T> instances.VecOps::Map utility allowing to apply a callable on a set of RVecs and not only to one.DeltaR2, DeltaR and DeltaPhi helpers for RVec.InvariantMass(es) helpers computing the invariant mass from particle kinematics stored in RVecs.Max, Min, ArgMax, and ArgMin helpers for RVec.Construct helper to build an RVec<T> starting from N RVec<P_i>, where a constructor T::T(P_0, P_1, ..., P_Nm1) exists.AsRVec helper to adopt memory owned by numpy arrays with RVecsdouble f(double x, double y, double z) {...}, clad::differentiate(f, "z") is equivalent to clad::differentiate(f, 2). clad::gradient(f, "x, y") differentiates with respect to x and y but not z. The gradient results are stored in a _result parameter in the same order as x and y were specified. Namely, the result of x is stored in _result[0] and the result of y in _result[1]. If we invert the arguments specified in the string to clad::gradient(f, "y, x") the results will be stored inversely.double A[] = {1, 2, 3};, double A[3]; or double A[1][2][3][4];The Johnson SU PDF has been added to RooFit. It comes with an analytical integral and a generator function, which make it superior (faster and more accurate) than implementing it manually with an interpreted/compiled formula.
hist2workspace performance optimisations. For a large, ATLAS-style Higgs–>bb workspace with > 100 systematic uncertainties and more than 10 channels, the run time for converting histograms to a fit model decreases by a factor 11 to 12.
RooFit’s collections RooArgSet and RooArgList have been made more STL-like. The underlying implementation used to be the RooLinkedList, but now both collections work with std::vector. The collections have an STL-like interface concerning iterators such that iterations over the two collections that looked like
TIterator* depIter = intDepList.createIterator() ;
RooAbsArg* arg;
while((arg=(RooAbsArg*)depIter->Next())) {
...
}
delete depIter;now look like:
for (auto arg : intDepList) {
...
}Depending on how many elements are iterated, RooFit will be between 10 and 20% faster if the new iterators are used. Heavily using old iterators might slow it down by 5 to 10%. Iterators in key classes have been updated, such that many workflows in RooFit are 10 - 20% faster.
The (three kinds) of legacy iterators in RooFit are still supported, such that old code will not break, but they are slower than begin(), end() and range-based for loops.
Important caveat: The old RooFit collections could be modified while iterating. The STL-like iterators do not support this (as for a e.g. std::vector)! Using the legacy iterators with the new collections (i.e. in existing code), mutating the collection is still possible in the following cases: - Inserting/deleting elements after the current iterator. - Changing an element at a position other than the current iterator - But not inserting/deleting before/at the current iterator position. With a debug build (with assertions), the legacy iterators will check that the collection is not mutated. In a release build, elements might be skipped or be iterated twice.
The legacy iterators have been flagged with a special deprecation macro that can be used help the user use the recommended ROOT interface. Defining one of the deprecation macros (either in a single translation unit or in the build system), and creating a legacy iterator will trigger a compiler warning such as:
<path>/RooChebychev.cxx:66:34: warning: 'createIterator' is deprecated: There is a superior alternative: begin(), end() and range-based for loops. [-Wdeprecated-declarations]
TIterator* coefIter = coefList.createIterator() ;
^
1 warning generated.This release provides a consolidation and several fixes of the new machine learning tools provided in TMVA such as the Deep Learning module. The method TMVA::Types::kDL should be used now for building Deep Learning architecture in TMVA, while TMVA::Types::kDNN is now deprecated. TMVA::Types::kDL provides all the functionality of TMVA::Types::kDNN, i.e building fully connected dense layer, but in addition supports building convolutional and recurrent neural network architectures. These release contains improvements in the MethodDL such as: - fix droput support for dense layer - add protection to avoid returning NaN in the cross-entropy loss function
In addition we have :
TMVA::Executor class to control the multi-thread running of TMVA. By default now MT running will be enabled only when ROOT::EnabledImplicitMT() is called. But we can take the control of the threads by using TMVA::gConfig().EnableMT(...) and TMVA::gConfig().DisableMT()TBox::DistancetoPrimitive and TBox::ExecuteEvent now work in log scales (by Jérémie Dudouet). auto h = new TH1F("h","h",5,0.5,5.5);
h->SetBinContent(1,100000);
h->SetBinContent(2,10000);
h->SetBinContent(3,1000);
h->SetBinContent(4,100);
h->SetBinContent(5,10);
h->SetMinimum(50.);
h->SetMaximum(40000);
h->Draw("L*");
gPad->SetLogy();ChangeLabel is now available for alphanumeric axis.The CMake module FindOracle.cmake was updated to support version 18.x of the Oracle client libraries.
TProfile2Poly classTGeoOverlap classTGeoHalfSpace for compositesTF2 drawings, see tutorials/graphics/anim.CrequestAnimationFrame when do monitoring, improves performanceTH2Poly drawingsgStyle attributes to draw histogram titleTH2 lego plotsTWebCanvas - interactivity, attributes/position updates, context menusSoftwareRenderer instead of CanvasRendererJSROOT sources were moved from etc/http/ into js/ subfolder in ROOT sources tree. OpenUI5 files were moved to ui5/ subfolder. After ROOT compilation they can be found in $ROOTSYS/js/ and $ROOTSYS/ui5/ subfolders respectively.
RSqliteDS examples.TFile::Cp rather than relying on CMake.The minimum required version of CMake has been updated to 3.9 or newer to be able to take advantage of new features such as native support for the CUDA language, among other things. Please refer to CMake’s release notes for further information.
The method to select the C++ standard has changed. Now the recommended way to select the C++ standard is via the option -DCMAKE_CXX_STANDARD=XX, which is the idiomatic way to do it in CMake. The old options still work, but have been deprecated and will be removed in a future release.
Build option descriptions have been updated to indicate which builtins require an active network connection during the build. You can inspect the list of options and their descriptions by running cmake -LH $PWD in the build directory.
The build system has been updated to remove most file globbing to improve the reliability of incremental builds when source files are added or removed.
A new check has been added to make ROOT fail during the configuration step if incompatible versions of the Python interpreter and its libraries are selected.
The all=ON option now tries to enable more options. Some options had their default value toggled to disabled, which affected all=ON. Now all options are listed explicitly so that they are enabled regardless of their default value.
The following builtins had their versions updated for this release:
ROOT_GENERATE_DICTIONARY / ROOT_STANDARD_LIBRARY_PACKAGEA change in the argument handling of ROOT_GENERATE_DICTIONARY and ROOT_STANDARD_LIBRARY_PACKAGE might need your attention: these macros now respect whether a header file was passed with its full relative path (the common case), or with a full path. The latter allows to find headers at runtime - at the cost of a loss of relocatability: you cannot move the library containing that dictionary to a different directory, because the header location is stored in the dictionary. This case is used by roottest but should likely not be used by anything but test suites.
Instead pass relative paths, together with a -I option to find the headers, plus setting ROOT_INCLUDE_PATH for finding the headers back at runtime. The ROOT stress suite is now updated to follow this behavior; see for instance the injection of $ROOTSYS/test in test/stressMathCore.cxx, allowing ROOT to find the header at runtime, whether interpreted (R__ADD_INCLUDE_PATH) or compiled (TROOT::AddExtraInterpreterArgs({"-I..."}) before interpreter construction).
If you called ROOT_GENERATE_DICTIONARY(Dict ${CMAKE_CURRENT_SOURCE_DIR}/subdir/Header1.h LINKDEF LinkDef.h) then update that call to ROOT_GENERATE_DICTIONARY(Dict Header1.h OPTIONS -I subdir LINKDEF LinkDef.h) if the header is usually included as #include "Header1.h", or to ROOT_GENERATE_DICTIONARY(Dict subdir/Header1.h LINKDEF LinkDef.h) if the header is usually included as #include "subdir/Header1.h". I.e. the general rule is: pass to ROOT_GENERATE_DICTIONARY (or ROOT_STANDARD_LIBRARY_PACKAGE) the spelling as #includeed.
As an important side-effect, ROOT_GENERATE_DICTIONARY and thus ROOT_STANDARD_LIBRARY_PACKAGE now require the header to be found at configuration time. We have seen too many cases where the header location was mis-stated, and as a consequence, CMake did not generate the proper dependencies. If the header should not be taken into account for dependencies and / or if the header will not be found (e.g. the standard library’s vector) please pass the header through the NODEPHEADERS option to ROOT_GENERATE_DICTIONARY or ROOT_STANDARD_LIBRARY_PACKAGE.
We believe that this simplification / regularization of behavior, and the additional checks are worth the possible changes on the user side.
If the fix or new feature is a pythonization related to a C++ class, the change is added to the respective section above.
TTree and subclasses, TDirectory and subclasses, TCollection and subclasses, TObject, TClass, TString, TObjString, TIter, TStyle, TH1, TFX, TMinuit, TVector3, TVectorT, TArray, TCollection, TSeqCollection, TClonesArray, TComplex, TGraph, RooDataHist) - ROOT-9510DeclareCppCallable decorator, which allows to call Python callables from C++, e.g., in an RDataFrame workflow:@ROOT.DeclareCppCallable(["float"], "float")
def f(x):
return 2.0 * x
ROOT.CppCallable.f(21.0)
# Returns 42.0
df = ROOT.ROOT.RDataFrame(4).Define("x", "CppCallable::f(rdfentry_)")
df.AsNumpy()
# Returns {'x': numpy.array([0., 2., 4., 6.], dtype=float32)}gInterpreter->Declare from a computation graph with no jitted nodes--web should be unavailable if not available!TBrowser with root --webroot-config --tutdir to return the correct tutorial directory$ sign, ROOT segfaults.basic_string(const TString&) is ambiguous”gStyle->SetHistMinimumZero(1) is not persistentauto_ptr<T> into unique_ptr<T>Released on August 23, 2019
enum’s underlying type availableenum-Droottest=ON when using a release tarballRooDataSets with large weight array cannot be serialisedTTree is dropped under specific circumstancesRooMCStudy crashes when requesting pulls for parameters that don’t have pullsRooDataSet::add has side effects on event weight errorRSlotStack sometimes runs out of slots (preliminary fix)enum class crashes PyROOTstdout message in RooMCStudyReleased on September 11, 2019
genvector and smatrix to instance for one floating point type (float, double, Double32_t, Float16_t) to instances for any other floating point type.I/O customization rules when the target classes contained typedefs (in particular Double32_t)Streamer Function was explicitly attached to their TClass.I/O rule on ‘current’ StreamerInfo.TTreeReader’s use of Set[Local]EntryMakeProject and in handling of I/O customization rules.TFileRooDataHist::sumstd::unique_ptr in STL containerThese changes will be part of a future 6.18/06.