ROOT logo
ROOT » Download » Release Notes

ROOT Version 5.26/00 Release Notes

ROOT version 5.26/00 will be released on December 15 2009. In case you are upgrading from an old version, please read the releases notes of version 5.16, 5.18, 5.20, 5.22 and version 5.24 in addition to these notes.

Binaries for all supported platforms are available at: 

For more information, see:

The following people have contributed to this new version:
Bertrand Bellenot, CERN/SFT,
Brian Bockelman, UNL,
Rene Brun, CERN/SFT,
Philippe Canal, FNAL,
Olivier Couet, CERN/SFT,
Kyle Cranmer, NYU/Atlas, RooStats
Valeri Fine, BNL/STAR,
Lucie Flekova, CERN/SFT summer student,
Fabrizio Furano, CERN/IT,
Gerri Ganis, CERN/SFT,
Andrei Gheata, CERN/Alice,
Mary-Louise Gill, CERN/SFT summer student,
David Gonzalez Maline, CERN/SFT,
Andreas Hoecker, CERN/Atlas, TMVA
Louis Höfler,
Jan Iwaszkiewicz, CERN,
Daniele Kruse, CERN, GDML
Wim Lavrijsen, LBNL, PyRoot
Alfio Lazzaro, Milano/AtlasMinuit
Sergei Linev, GSI,
Anar Manafov, GSI,
Lorenzo Moneta, CERN/SFT,
Axel Naumann, CERN/SFT,
Eddy Offermann, Renaissance,
Katerina Opocenska, Charles Univ. Prague,
Danilo Piparo, Karlsruhe/CMS, RooStats,
Timur Pocheptsov, JINR/Dubna,
Fons Rademakers, CERN/SFT,
Philip Rodrigues, Oxford, Doc,
Paul Russo, FNAL,
Gregory Schott, Karlsruhe/CMS, RooStats,
Tomasz Sosnicki, CERN/SFT summer student,
Joerg Stelzer, DESY/Atlas, TMVA
Matthew Strait, DOC
Alja Tadel, CERN/CMS, Eve
Matevz Tadel, CERN/Alice, Eve
Wouter Verkerke, NIKHEF/Atlas, RooFit,
Matthias Wolf, Karlsruhe/CMS, RooStats


New module editline

The new module editline enhances the prompt, giving type and syntax feedback using e.g. colors. Class names are highlighted blue when typed, indicating that it is known to ROOT. Matching parenthesis pairs are highlighted green when typed, or when the cursor is moved to a bracket. This works for () {} and [] brackets. Any mismatched brackets (those without a matching partner) will be highlighted red when typed or when the cursor is moved to the bracket. Tab completion output is colored magenta to differentiate between tab completion output and user input.

All of the colors are configurable in the .rootrc file. They can be specified as #rgb or #rrggbb or color names: black, red, green, yellow, blue, magenta, cyan or white. They can be followed by an optional bold (alias light) or underlined. Rint.ReverseColor allows to quickly toggle between the default "light on dark" (yes) instead of "dark on light" (no), depending on the terminal background.

An example configuration would be:

Rint.TypeColor:           blue
Rint.BracketColor:        bold green
Rint.BadBracketColor:     underlined red
Rint.TabColor:            magenta
Rint.PromptColor:         black
Rint.ReverseColor:        no

The enhanced prompt is available on all platforms with [n]curses, including Linux, Solaris and MacOS; the bold and underline options are available also for black and white terminals. You can export (or setenv) TERM=xterm-256color for nicer colors.

With editline comes also an improved terminal input handler. It supports e.g. ^O (Ctrl-o) to replay the history: suppose you have entered

root [3] i = func()
root [4] i += 12
root [5] printf("i is %d\n", i)

You now want to re-run these three lines. As always, you press the up cursor three times to see

root [6] i = func()

and now press ^O (Ctrl-o) to run the line, and prepare the next line:

root [6] i = func()^O
root [7] i += 12^O
root [8] printf("i is %d\n", i)^O
root [9] 

allowing you to re-run that part of the history without having to press the up-arrow again and again.

Currently, editline is disabled on Windows.


Schema Evolution.





IMPORTANT enhancement in TTree::Fill:

Slides from a recent seminar describing the main features of ROOT IO and Trees and the recent improvements described below are available at or .

The baskets are flushed and the Tree header saved at regular intervals (See AutoFlush and OptimizeBaskets)

When the amount of data written so far (fTotBytes) is greater than fAutoFlush (see SetAutoFlush) all the baskets are flushed to disk. This makes future reading faster as it guarantees that baskets belonging to nearby entries will be on the same disk region.

When the first call to flush the baskets happens, we also take this opportunity to optimize the baskets buffers. We also check if the number of bytes written is greater than fAutoSave (see SetAutoSave). In this case we also write the Tree header. This makes the Tree recoverable up to this point in case the program writing the Tree crashes.

Note that the user can also decide to call FlushBaskets and AutoSave in her event loop on the base of the number of events written instead of the number of bytes written.

New function TTree::OptimizeBaskets

void TTree::OptimizeBaskets(Int_t maxMemory, Float_t minComp, Option_t *option) 

This function may be called after having filled some entries in a Tree using the information in the existing branch buffers, it will reassign new branch buffer sizes to optimize time and memory.

The function computes the best values for branch buffer sizes such that the total buffer sizes is less than maxMemory and nearby entries written at the same time. In case the branch compression factor for the data written so far is less than compMin, the compression is disabled. if option ="d" an analysis report is printed.

This function may also be called on an existing Tree to figure out the best values given the information in the Tree header

   TFile f("myfile.root");
   TTree *T = (TTree*)f.Get("mytreename");
   T->Print();  //show the branch buffer sizes before optimization
   T->Print();  //show the branch buffer sizes after optimization

New interface functions to customize the TreeCache

   virtual void  AddBranchToCache(const char *bname, Bool_t subbranches = kFALSE);
   virtual void  AddBranchToCache(TBranch *branch,   Bool_t subbranches = kFALSE);
   virtual void  PrintCacheStats(Option_t* option = "") const;
   virtual void  SetParallelUnzip(Bool_t opt=kTRUE);
   virtual void  SetCacheEntryRange(Long64_t first, Long64_t last);
   virtual void  SetCacheLearnEntries(Int_t n=10);
   virtual void  StopCacheLearningPhase();

New functionality AutoFlush (and changes to AutoSave)

Implement a new member fAutoFlush in TTree with its getter and setter:
void TTree::SetAutoFlush(Long64_t autof)
The logic of the AutoFlush mechanism is optimized such that the TreeCache will read always up to the point where FlushBaskets has been called. This minimizes the number of cases where one has to seek backward when reading.
This function may be called at the start of a program to change the default value for fAutoFlush. Flushing the buffers at regular intervals optimize the location of consecutive entries on the disk.
Changed the default value of AutoSave from 10 to 30 MBytes.

New class TTreePerfStats

This new class is an important tool to measure the I/O performance of a Tree. It shows the locations in the file when reading a Tree. In particular it is easy to see the performance of the Tree Cache. The results can be:
       Example of use                                                 
   TFile *f = TFile::Open("RelValMinBias-GEN-SIM-RECO.root");
   T = (TTree*)f->Get("Events");
   Long64_t nentries = T->GetEntries();

   TTreePerfStats *ps= new TTreePerfStats("ioperf",T);

   for (Int_t i=0;i<nentries;i++) {

then, in a root interactive session, one can do:

    root > TFile f("atlas_perf.root");
    root > ioperf->Draw();
    root > ioperf->Print();

The Draw or Print functions print the following information:

   TreeCache = TTree cache size in MBytes
   N leaves  = Number of leaves in the TTree
   ReadTotal = Total number of zipped bytes read
   ReadUnZip = Total number of unzipped bytes read
   ReadCalls = Total number of disk reads
   ReadSize  = Average read size in KBytes
   Readahead = Readahead size in KBytes
   Readextra = Readahead overhead in percent
   Real Time = Real Time in seconds
   CPU  Time = CPU Time in seconds
   Disk Time = Real Time spent in pure raw disk IO
   Disk IO   = Raw disk IO speed in MBytes/second
   ReadUZRT  = Unzipped MBytes per RT second
   ReadUZCP  = Unipped MBytes per CP second
   ReadRT    = Zipped MBytes per RT second
   ReadCP    = Zipped MBytes per CP second

The Figure below shows the result for an original non optimized file when the Tree Cache is not used.

no optimization, no tree cache

The Figure below shows the result for the above data file written with the new version of ROOT and when the Tree cache is activated.

optimization, tree cache


Histogram package

new class TGraphTime

The tutorial gtime.C shows the evolution of a set of points with time and it produces the following picture.

gtime.C output

The tutorial gtime2.C is an example of TGraphTime showing how the class could be used to visualize a set of particles with their time stamp in a MonteCarlo program. It produces the following picture.

gtime2.C output










new classes TFitResult, TFitResultPtr


new tutorial rebin.C

This tutorial illustrates how to:



After analyzing the results of our integration tests, we came to the conclusion that Cint 7 would not provide any immediate and visible gain in performance or memory use while also not helping us achieve any of the benefits we were aiming for to improve Cint for the LHC experiments; Cint 7 was also not yet to the point of being able to improve on any of the Cint 5 deficiencies or on the lack of support for the upcoming C++ standard. Hence we decided to no longer pursue this direction.

As an alternative we started investigating LLVM, a cutting edge popular open source compiler project that is already used in commercial environments. Apple is currently supporting the main developers and relying on LLVM for Mac OS 10.6 and above. Its strengths include binary platform compatibility, a C++ API, large number of optimizer, and a just-in-time compiler, amongst others; these strengths makes it an ideal candidate for building upon to develop a new interpreter. The LLVM team is currently implementing a promising C/C++ and Objective C/C++ front end (Clang) which can already parse more than 95% of the ROOT header files.

After working with the LLVM and Clang team for a while, we are confident that they will deliver a very good C++ compiler. We believe that we can re-use large parts of it to produce a production-grade interpreter with C++ API, leveraging the large LLVM developer community. Thanks to LLVM, this future interpreter would offer better and faster parsing and execution (for both the dictionary generation and the interpretation). We are currently exploring the implementation of the interpreter and reflection database based on LLVM with an early prototype, code named Cling. Amongst other things, it demonstrate the usability of LLVM's just-in-time compiler.

You can see more details on the Cint7 conclusion as well as LLVM and Cling in Axel's presentation.


All other packages have seen bug fixes and performance improvements. They are all backward compatible with the v5.24/00 release.


Fixes were made to "member-style" access on TTrees, to handle several more common cases, such as where names do not match, and sub-branching. Likewise, TPySelector was improved to handle new use cases where it needed a function default constructor, and where the user wants to change the associated TTree.

It is now possible to use buffers, rather than strings, for char* function arguments.

Math Libraries



Various changes to the Sparse Matrix classes:




Mathcore Fitting classes



New infrastructure for toy MC studies

A new class RooStudyManager has been added that is intended to replace the present RooMCStudy framework for toy MC studies on the time scale of ROOT release 5.26.

The present RooMCStudy is a small monolithic driver to execute 'generate-and-fit' style MC studies for a given pdf. It provides some room for customization, through modules inheriting from RooAbsMCStudyModule that can modify the standard behavior, but its design limits the amount of flexibility.

In the new RooStudyManager design, the functionality of RooMCStudy has been split into two classes: class RooStudyManager which manages the logistics of running repetitive studies and class RooGenFitStudy which implements the functionality of the 'generate-and-fit'-style study of RooMCStudy. The new design has two big advantages:

  1. Complete freedom in the design of studies, either by tailoring the behavior of RooGenFitStudy or by using another study module that inherits from RooAbsStudy, and the data that they return.
  2. More flexibility in the mode of execution. The new study manager can execute all study modules inlines, as was done in RooMCStudy), but also parallelized through PROOF (at present only PROOF-lite is support, as well as in batch
The code fragment below illustrates the use of the new study manager
  // Create workspace with p.d.f
  RooWorkspace* ww = new RooWorkspace("ww") ;
  ww->factory("Gaussian::g(x[-10,10],mean[-10,10],sigma[3,0.1,10])") ;

  RooGenFitStudy gfs ;
  gfs.setGenConfig("g","x",NumEvents(1000)) ;
  gfs.setFitConfig("g","x",PrintLevel(-1)) ;

  RooStudyManager mgr(*ww,gfs) ; ; // execute 1000 toys inline
  mgr.runProof(10000,"") ; // execute 10000 toys through PROOF-lite

  gfs.summaryData()->Print() ;

Workspace and factory improvements

The workspace class RooWorkspace has been augmented with several new features

Improvements to functions and pdfs

Miscellaneous improvements data classes

Miscellaneous improvements other


This release contains significant bug fixes and it is strongly reccomended to update to this version if using older ones.

Major Changes in LimitCalculator and HypoTestCalculator classes: usage of ModelConfig class

ProfileLikelihoodCalculator, LikelihoodInterval


new class HypoTestInverter

New class BayesianCalculator


Improvements and Bug fixes


TMVA version 4.0.4 is included in this root release.



On Input Data:
New TMVA event vector building. The code for splitting the input data into training and test samples for all classes and the mixing of those samples to one training and one test sample has been rewritten completely. The new code is more performant and has a clearer structure. This fixes several bugs which have been reported by the TMVA users.

On Minimization:
Variables, targets and spectators are now checked if they are constant. (The execution of TMVA is stopped for variables and targets, a warning is given for spectators.)

On Regression:
The analysis type is no longer defined by calling a dedicated TestAllMethods-member-function of the Factory, but with the option "AnalysisType" in the Factory. The default value is "Auto" where TMVA tries to determine the most suitable analysis type from the targets and classes the user has defined. Other values are "regression", "classification" and "multiclass" for the forthcoming multiclass classification.

Missing regression evaluation plots for training sample were added.

On Cut method:
Removed obsolete option "FVerySmart" from Cuts method.

On MLP method:
Display of convergence information in the progress bar for MLP during training.
Creation of animated gifs for MLP convergence monitoring (please contact authors if you want to do this).

On Datasets:
Checks are performed if events are unvoluntarily cut by using a non-filled array entry (e.g. "arr[4]" is used, when the array has not always at least 5 entries). A warning is given in that case.

Bug fixes











GUI Builder

New features, new user interface

Several important features have been added to the builder, and its user interface has been redesigned. Editing modes are now clearly distinguished with enabled and disabled layout mode. Possibility to enable automatic layout fasten the interface development, as the positioning doesn't have to be done manually anymore
Major changes in the user interface:

Graphical Output

PostScript and PDF


Interface to graphviz

Thanks to three new classes (TGraphStruct, TGraphNode and TGraphEdge) ROOT provides an interface to the graphs visualization package graphviz. Graph visualization is a way of representing structural information as diagrams of abstract graphs and networks.
Example of TGraphStruct
The previous image is produced by the following ROOT macro:
   // Draw a simple graph structure.
   // The graph layout is made using graphviz. This macro creates some
   // nodes and edges and change a few graphical attributes on some of them.
   // Author: Olivier Couet
      TGraphStruct *gs = new TGraphStruct();
      // create some nodes and put them in the graph in one go ...
      TGraphNode *n0 = gs->AddNode("n0","Node 0");
      TGraphNode *n1 = gs->AddNode("n1","First node");
      TGraphNode *n2 = gs->AddNode("n2","Second node");
      TGraphNode *n3 = gs->AddNode("n3","Third node");
      TGraphNode *n4 = gs->AddNode("n4","Fourth node");
      TGraphNode *n5 = gs->AddNode("n5","5th node");
      TGraphNode *n6 = gs->AddNode("n6","Node number six");
      TGraphNode *n7 = gs->AddNode("n7","Node 7");
      TGraphNode *n8 = gs->AddNode("n8","Node 8");
      TGraphNode *n9 = gs->AddNode("n9","Node 9");





      // some edges ...
      TGraphEdge *e06 = gs->AddEdge(n0,n6);

      TCanvas *c = new TCanvas("c","c",800,600);
      return c;
This new funtionnality relies on the graphivz package. This package can be downloaded from

At installation time, to find graphviz, the ROOT's configure file looks in standard locations. It is possible to define a specific location using the configure flags:

--with-gviz-incdir="the directory where gvc.h is"
--with-gviz-libdir="the directory where the libgvc library is"

To install graphviz (if needed) it is recommended to use the following configure flags:

--enable-static=yes --enable-shared=no --with-pic --prefix="graphviz installed here" 

On 64 bits machines, the ROOT sources are compiled with the option -m64. In that case graphviz should be also compiled in 64 bits mode. It might be the default option, but on some machine it is not. In that case the environment variable CC should be defined as:

CC="gcc -m64"

before doing configure.

On Windows machines it recommended to not install graphviz but to download the pre-installed version from The ROOT configure command remains the same.

Graphics Primitives

New class TGraphTime

TGraphTime is used to draw a set of objects evolving with nsteps in time between tmin and tmax. each time step has a new list of objects. This list can be identical to the list of objects in the previous steps, but with different attributes. see example of use in $ROOTSYS/tutorials/graphs/gtime.C








Major changes

Eve window showing CMS calorimeters with 3D / RPhi /
 and Lego views. Selectrion across several views isdemonstrated.
Screenshot of calorimeters.C tutorial. Note the individual tower selection propagated accross all the views.

Eve window showing ALICE VSD example with 3D / RPhi and
	     RhoZ views of clusters and reconstructed tracks.
Screenshot of alice_vsd.C tutorial also showing the functionality of the MultiView class. New title is also visible in the GUI editor.

Minor changes


Major changes

Minor changes


ROOT page - Class index - Top of the page - Valid XHTML 1.0 Transitional