ROOT Version 5.11/06 Release Notes

ROOT version 5.11/06 has been released June 01, 2006.

Binaries for all supported platforms are available at:
Versions for AFS have also been updated. See the list of supported platforms:

For more information, see:

The following people have contributed to this new version:
Mohammad Al-Turany,
Ilka Antcheva,
Bertrand Bellenot,
Denis Bertini,
Rene Brun,
Philippe Canal,
Olivier Couet,
Christophe Delaere,
Valeri Fine,
Markus Frank,
Gerri Ganis,
Andrei Gheata,
Mihaela Gheata,
Masaharu Goto,
Andy Hanushevsky,
Andreas Hoecker,
Christian Holm Christensen,
Jan Iwaszkiewicz,
Anna Kreshuk,
Wim Lavrijsen,
Sergei Linev,
Pere Mato,
Lorenzo Moneta,
Axel Naumann,
Eddy Offermann,
Valeriy Onuchin,
Timur Pocheptsov,
Fons Rademakers,
Stefan Roiser,
Paul Russo,
Joerg Stelzer,
Matevz Tadel,
Tim Tran,
Helge Voss,
Kai Voss.

Improvements in the build system

Precompiled Headers

Precompiled headers are used on Windows with MS Visual C++ (any version), and GCC4, to decrease the compilation time. Currently, everything #included by TH1.h (and TH1.h itself) is precompiled.

Tools Changes

Many scripts (, window's, etc) are replaced by direct invocations, speeding up the build. bindexplib now supports symbol names of arbitrary length.

Windows Debug

By default, ROOT now uses the debug runtime libraries when building a debug version on Windows. This can be changed with the "--disable-winrtdebug" configure switch.

New Supported Compilers


Macros Assert, Check and ForEach

To avoid possible clashes with user defined header files, we have replaced the internal use of macros Assert, Check and ForEach by R__ASSERT, R__CHECK and R__FOR_EACH respectively. The old definitions are still kept until the production release later this year.

WARNING!!. We urge users of these macros to replace them by the new version asap.


One can now silence ROOT by setting "Root.System.BeepDuration: 0" in .rootrc, making it fully usable within meetings; see TSystem::Beep() for details. Windows now uses the sound card, not the system speaker.

Stack Trace

Implemented stack trace for Windows, covering all threads, which is triggered by unhandled exceptions or "fatal" signals.

MSI installer added for Windows (make distmsi); needs WiX binaries, version 3.0.1719.0 from 2006-01-19.

CINT Improvements

CINT parser

Cint / TCint Performance

Improve performance of TCint::UpdateListOfGlobalFunctions, which is called e.g. by TROOT::GetListOfGlobalFunctions(). Improve speed of Cint's G__defined_tagname a bit.

Other improvements

Several parsing improvements, in particular this includes support for distinguish (from the string based interface) a template of Double32_t from a template of double.

Note that the compiler still can not distinguish the 2 forms and thus only 'string' based interface will be able to handle this distinction.

The Qtcint interface

CINT has a new build option to generate the dictionary for the Qt classes. This dictionary is not built by default in the binary distribution files because the resulting library is quite large (>2 Mbytes). You can build it from source via
make qtcint

TTree and I/O

Asynchronous open functionality in TFile

A framework to support asynchronous file open functionality has been implemented. An async open request is submitted using the new static methods TFile::AsyncOpen. This method takes the same arguments as the known TFile::Open, but it never blocks returning an opaque handle, an instance of the new class TFileOpenHandle. The handle contains all the relevant information about the request and can be used to check the status of the request and to retrieve the pointer to the file instance once the file is ready to be used. To make handling of the 'opaque file handles' more user-friendly, a static list of pending open requests is kept internally and methods to identify them by filename are provided.
Example of usage:
       TString fname = "root://dserv.dom.ain//data001/myfile.root";
TFile *f = 0;
// Submit the request (does not block)
// Do something else while waiting for open readiness
EAsyncOpenStatus aos = 0;
while ((aos = TFile::GetAsyncOpenStatus(fname)) == TFile::kAOSInProgress) {
// Do something else
// Attach to the file if ready ... or open it if the asynchronous
// open functionality is not supported
if (aos == TFile::kAOSSuccess || aos == TFile::kAOSNotAsync) {
// Attach to the file
f = TFile::Open(fname);
// Analyse it ...
} else {
// Failure
Currently only TXNetFile (remote file access via XROOTD) is supporting asynchronous file opening. A call to TFile::AsyncOpen for TFile implementations not supporting asynchronous open functionality fills the handle with the parameters needed by a normal TFile::Open, so that the above example works in all cases. The real URL of the file - e.g. the URL where the XROOTD redirector redirects the client - is available after TFile::AsyncOpen via the new method
          const TUrl *TFile::GetEndpointUrl(const char *filepath)

I/O for template instance using Double32_t

The ROOT I/O nows supports the ability to store as float the data member of a template class instance which depends on the template parameter and this parameter is 'Double32_t' (previously they were stored as double). Note that currently (and until the C++ compiler implement the notion of 'opaque typedef') the compiler can not distinguish between a mytemp and a mytemp and thus only the string based interface will properly store the datamember as float.
A consequence of this limitation is that the dictionary for mytemp< double>and mytemp<Double32_t> must be generated in two different dictionary files.

Fast cloning and merging of TTrees

Resolved an issue that prevented the cloning/merging of TTrees using the fast method when the basket were not all ordered (This can happens for a file with many AutoSave).

Schema Evolution

TStreamerInfo::BuildCheck error messages

The checksum calculation used to check the integrety of a class definition was not using a consistent class name for the STL containers. This lead to the appeareance of error messages like:
   Warning in :
                The StreamerInfo of class FitResult read from file t1.root
                has the same version (=1) as the active class but a
                different checksum.
                You should update the version to ClassDef(FitResult,2).
                Do not try to write objects with the current class definition,
                the files will not be readable.
When the 'only' difference was wether or not the dictionary for the stl container was loaded.
The fix for this problem might lead to similar messages in other cases (where the full typename was used for object already on file). The solution in thoses cases is to increase the version number of the class (This solution is __not__ an option for the above mentioned cases (where the difference is the presence or not of a dictionary for the stl container)

Changes in $ROOTSYS/bin/hadd

.New options have been added to this program. hadd adds histograms and trees from a list of root files and write them to a target root file. The target file is newly created and must not be identical to one of the source files.

       hadd targetfile source1 source2 ...
       hadd -f targetfile source1 source2 ...
         (targetfile is overwritten if it exists)
When -the -f option is specified, one can also specify the compression level of the target file. By default the compression level is 1, but For example assume 3 files f1, f2, f3 containing histograms hn and Trees Tn the result of
     hadd -f x.root f1.root f2.root f3.root
will be a file x.root with with h1 h2 h3 h4 h5 T1 T2, where h1 will be the sum of the 2 histograms in f1 and f2, T1 will be the merge of the Trees in f1 and f2 The files may contain sub-directories. If the source files contains histograms and Trees, one can skip the Trees with
       hadd -T targetfile source1 source2 ...
If the sources and and target compression levels are identical (default), the program uses the TChain::Merge function with option "fast", ie the merge will be done without unzipping or unstreaming the baskets (i.e. direct copy of the raw byte on disk). The "fast" mode is typically 5 times faster than the mode unzipping and unstreaming the baskets.
Note that in versions 5.08 and 5.10, the merged files with hadd could show some problem in case of large files when the tree header had been saved multiple times. This was due to a bug in TChain::Merge now fixed in this release.

New version of XROOTD

The new version of XROOTD includes the first port of the client on Windows VC++, completing the set of platforms where TXNetFile is available. In addition, on the client side, there have been several improvements and bug fixes, in particular in the asynchronous functionalities. On the server side, the most relevant additions are: These improvements allow to use a standard startup script for xrootd, to use the same daemon to run concurrently data servers and PROOF servers on the standard ROOT ports (1094 and 1093), and to run the servers under 'root' privileges, required in certain cases.


The major additions are: the Windows porting of the XProof client; the file upload facility and the a bulk of new admin functionality for the XrdProofd server plugin. More details about the usage of the new functionality are given below. In addition there have been several bug fixes - in particular, one potentially causing a huge memory leak on worker nodes - and improvements in the treatment of interrupt and error conditions.

File upload facility

A facility to upload files on a PROOF cluster is now available. Two main methods are provided: A set of methods is also provided to manage the datasets:

Improvements in the XrdProofdProtocol plugin

Several additions have been made to the XrdProofdProtocol plugin mainly to facilitate the administration of a cluster. The cluster administration may have now full control on the PROOF session composition, the number and priority of sessions, as described below. The be active, the following directives must be present in the configuration file used at xrootd startup. Except when explicitly indicated, all the following directives support an optional 'if pattern' condition at the end of the line, e.g.
       xpd.rootsys /opt/root   if lxb*
xpd.rootsys /usr/local if lxp*
Patterns may contain any number of wild cards; the best match is retained (max number of matching chars; if two are equal, the last specified wins).

SQL interface(s): Many improvements by Sergei Linev

Improvements of TSQLServer class

New abstract class TSQLStatement

SQL statements are a feature which allows queries to be submitted in bulk to the DB server and thereby gaining up to several orders of magnitude in performance. The TSQLStatement is currenctly implemented for Oracle and MySQL (version >= 4.1.x). SQL statements are an alternative to TSQLServer::Query() method, which allows only pure text queries and pure text result in TSQLResult classes. TSQLStatement is designed to support following features:

Much more detail can be found in the description of the TSQLStatement class.

ODBC interface: New package

New ODBC driver that allows generic access to many DB's. This version should also compile on Windows for access to MS DB's (Access, SQLServer). For this driver to compile one needs either to install unixODBC ( or iODBC ( On Mac OS X it also works with the system installed iODBC libraries.

To open a connection to a ODBC server. The db arguments can be:

Much more detail in the setup and usage of ODBC can be found in the description of the TODBCServer class.

Fitting enhancements and bug fixes

FFTW: Fast Fourier Tranform: New package

This package contains an interface to the FFTW library of Fast Fourier Transforms ( It consists of the following classes: Only basic interface of FFTW is implemented (no "advanced" or "guru" features). How to install this package:

New class TVirtualFFT

This class provides an abstract interface to FFT transforms. The default library is FFTW3. See class description and tutorial FFT.C for details on how to use it.

Changes in TH1 related to FFTW

Two functions added to class TH1:
 *  virtual TH1 *FFT(TH1* h_output, Option_t *option);
 *  static TH1 *TransformHisto(TVirtualFFT *fft, TH1* h_output, Option_t
The first function allows to do a discrete Fourier transform of a histogram, the second function returns a histogram of the output (different options available) for an existing transform.


The Toolkit for Multivariate Analysis (TMVA) provides an environment for the parallel processing and evaluation of MVA techniques to discriminate signal from background samples. It presently includes (ranked by complexity):

The TMVA package includes an implementation for each of these discrimination techniques, their training and testing (performance evaluation). In addition all these methods can be tested in parallel, and hence their performance on a particular data set may easily be compared. For the comparison of the efficiency and background rejection of all the different methods, the analysis job gives some tabulated efficiency / background values in the log file, as well as the efficiency vs. background rejection curves along with detailed other evaluation information (like ranking, correlation matrixes and alike) in a ROOT file. These results can then be easily displayed using the ROOT macros provided with TMVA.

Performance comparison between the different multivariate analyser methods that are implemented in TMVA. The MVAs were trained on an academic toy-data sample consisting of four linearly correlated Gaussian-distributed variables.


Each method that is trained writes the training results to individual "weight" files, which can be in either text or ROOT format. A class TMVA::Reader serves to use the MVAs in a specific analysis context. Within an event loop, a vector is filled that corresponds to the variables that were used to train the MVA(s) during the training stage. This vector is transfered to the Reader, who takes care of interpreting the weight file of the MVA of choice, and to return the MVA's output. This is then used by the user for further analysis.


Special emphasis has been put on the comparative performance assessment of the various MVA methods. The training, testing and evaluation phases are performed in parallel for the various methods (through a factory). The evaluation accomodates several numerical performance estimators as well as various ROOT plots. ROOT scripts to conveniently access these plots are provided.

A more detailed description of the methods can be found at this location.

Improvements in the Random Numbers

Several improvements have been done in this release for the ROOT random numbers, in particular the generators in TRandom and TRandom2 have been replaced and a new class TRandom1, based on the Ranlux random generator has been introduced. The changes in detail are:


A new linear congruential random generator has been introduced to implement this random number. This generator is based on the BSD random number and is known to have BAD random quality, in particular its period is too short (10**9) and can be exhausted in just few seconds. It is introduced only for backward compatibility since it's having a state of only one 32 bit integer. It must NOT be used for any statistical study.


New random number generator based on the Ranlux engine, and is based on the Fortran implementation of F. James. This engine has mathematically proven random proprieties and a long period of about 10**171. Various luxury level are provided (1,2,3,4). The level 3 is the default where any theoretical possible correlation has very small chance of being detected. The generator uses a state of 24 words. Its main disadvantage is that is much slower than the others (see timing table)


This generator is base now on the maximally equidistributed combined Tausworthe generator by L'Ecuyer. It uses only 3 words for the state and it has a period of about 10**26. It is fast and given its small states, it is recommended in application which require a very small random number size.


This is the default ROOT generator and the recommended one (it is the one used in gRandom). It is based on the Mersenne and Twister engine, it is very fast and has a very long period of 10**6000. The disadvantage is that it uses a rather large state of 624 words.

The following figure shows an estimate of PI obtained generating a pair of random numbers. One sees that when generating an order of 10**10 random numbers, the period for TRandom is exhausted. The figures also show the time (in ns) for generating a random number


Improvements Random Distributions

TRandom::Poisson has been corrected to provide correct Poisson random numbers also for large mu. A rejection algorithm, using a Lorentzian distribution is used. The new algorithm is faster than the previous one for mu between 25 and 88 and it is correct also for mu larger than 88, while before the Gaussian approximation was used.

TRandom::Landau and TRandom::Sphere: some improvement in the performances. have been applied.

The following values are obtained now for the various distributions and engines, running the tutorial testrandom.C on a 2.Ghx Intel Core Duo running MacOSX and compiled with gcc 4.0:

Distribution            microseconds/call
                    TRandom  TRandom1 TRandom2 TRandom3
Rndm..............    0.030    0.130    0.030    0.040
RndmArray.........    0.010    0.130    0.020    0.020
Gaus..............    0.250    0.460    0.250    0.270
Landau............    0.070    0.170    0.070    0.080
Binomial(5,0.5)...    0.160    0.700    0.180    0.200
Binomial(15,0.5)..    0.430    2.060    0.490    0.590
Poisson(3)........    0.220    0.650    0.240    0.260
Poisson(10).......    0.460    1.610    0.490    0.570
Poisson(70).......    1.260    1.670    1.290    1.310
Poisson(100)......    1.280    1.680    1.300    1.320
GausTF1...........    0.210    0.330    0.210    0.220
LandauTF1.........    0.210    0.330    0.210    0.220



The major changes are the addition of an extra template parameters for the DisplacementVector3D and PositionVector3D classes. The new parameter is the Coordinate System Tag and can be used to specify different vector types according to the type of coordinate systems. For example one type of vectors for a global coordinate system and a different type for a local coordinate system. The classes have a default tag, which gives backward compatibility, and is used when one does not need the functionality to specify a coordinate system tag.

The rotation and transformation classes have been modified accordingly to provide, and in the case of the Transform3D class, the possibility to transform from one vector in one coordinate tag to a new coordinate tag.

In addition, this release contains a bug fix in the inversion of EulerAngles class

Some additional methods like energy() and mass() have been added to the LorentzVector class to satisfy a request from CMS. Typedef's to cartesian Vector and Point have been added in the Plane3D and the Transform3D classes on requests from LHCb. This allow a beneric use of the use of the Plane3D and Transform3D classes.

More detailed description of the current release can be found at this location.


Addition of a C++ wrapper to the GSL random number engines and to the distributions. A template class, ROOT::Math::Random has been added with an API similar to the ROOT class TRandom. The class is template on the Random Engine type. Here is an example on how to use this new Random class:

using namespace ROOT::Math;

Random<GSLRngMT>         r1;      // random based on GSL Mersenne and Twister engine (mt19937)
Random<GSLRngCMRG>       r2;      // random based on GSL CMRG engine (gsl_rng_cmrg)
double x =     r1.Uniform();      // generate uniform random numbers
int n    =     r1.Poisson(mu);    //  generate Poisson random numbers with average mu  
The main GSL random number generators are available as C++ type to use for the Random template parameters. In addition the most commonly used random distributions are implemented as methods in the Random classes. Detailed information is available in the reference documentation. A further addition in mathmore is the quartic analytic solver. The routine which is part of the GSL CVS, but not yet released is included now in mathmore. It can be use it from the C++ Polynomial class, as shown in the following example:
// create the polynomial x**4 -50 x**3 + 35 x **2 - 10 *x + 1
ROOT::Math::Polynomial  p(1,-10,35,-50,24)         
// find the Real Roots of p 
std::vector r = p.FindRealRoots(); 
// p will have contains all the 4 real roots (1,2,3,4) 

Reference documentation of mathmore for the current release can be found at this location.


Removed some warning messages and improved the error reporting in the TFitterMinuit class. Fixed a bug in the fitter when fitting in an defined range specified by the function. A small change in Fumili to break the iterations when they do not improve sufficiently the convergence towards the minimum point

More information on Minuit2, the new C++ version of MINUIT, can be found on the MINUIT Web Site and reference documentation at this location.



The main changes with respect to the previous versions (5.10) are the followings:

Reference documentation of the SMatrix package can be found at this location.

TMatrix improvements

In this release additional functionality has been added : Some new operations have been added to improve speed by not creating temporary objects :

TMatrix or Smatrix: Which one to use?

The Smatrix package is designed for small matrices (less than 7x7) and when the sizes of the matrices are known at compile time. It avoids creation of temporary objects in arithmetic operations and it is faster than TMatrix in this case. For large matrices TMatrix is recommended since it is faster and the compilation time Smatrix increases rapidly. We provide a small test program comparing the respective performance of the two packages (see stressOperations and stressKalman in the source directory $ROOTSYS/smatrix/test). If you compile and run these tests programs, you will experience a very long compilation time due to the fact that the Smatrix package is fully contained in header files. The size of the compiled code may become extremely large if this class is used in many user classes. We would appreciate comments from users of this new class concerning their experience with the functionality, speed improvements or degradation, compilation time and code size. Note that if you want to do I/O or use the interpreter (CINT or Python) with this templated class, you must generate the dictionary yourself for the concrete instances that you use. The TMatrix package is a complete Linear Algebra package that includes much more functionality than Smatrix. It can be used automatically with the interpreters and for I/O.



New set of classes dedicated to event visualisation


Small fix for selection/manipulators for multiple viewers case.





Basic graphics


A new way to handle the text fonts allowing to include directly the ROOT PDF files into LaTeX documents (compiled with pdflatex). Here is an example showing how to use ROOT PDF file in LaTeX document.

New class TGraphPolar

New class TGraphPolar (from Sebastian Boser), to draw graphs in polar coordinates. This is a first version. It needs many improvements which will appear in the coming releases. An example illustrating TGraphPolar usage can be found in %ROOTSYS/tutorials/graphpolar.C.

TGraph "exclusion zone"

The exclusion zone is "closed" when the first and last points of the graph are the same. Later we can add an option to force the graph closing.


Two new methods SetVertical() and SetHorizontal() to force the line to be drawn vertically or horizontally. It makes fX[Y]2 equal to fX[Y]1. The line length is kept. TArrow and TGaxis also get these functions by inheritance.

Escape mechanism

When ESC is pressed in a canvas, the current graphics editing is canceled. That's a convenient way to avoid unwanted changes or moves.




Protection added to make sure that the line width is positive and smaller than 100.


The special case introduced in revision 1.9 to change the line color in case of hatch styles (3100->3999), is now removed. This case is now handled in TPad::PaintFillAreaHatches, with the other line attributes.


Fix a bug in TGraphQQ::Quartiles when nx=ny


In TLegend::SavePrimitive save also the border size


In PaintFillAreaHatches the line attributes are now propelly saved before the hatches painting, and restored after.


Correction for settting a canvas internal parameters when TCanvas::SetCanvasSize method is called. That allows to fix a problem of generating images with wrong sizes in batch mode.


Change in Analyse(). GetTextExtent() was called each time Analyse() was called (twice for each LaTex string). It appeared that the call to GetTextExtent() can be ommitted when Analyse() is called to draw the string. This save 5% of the time spent in TLatex drawing.


Remove repeated checks on which fontset should be used (either MS ttf or the free alternatives). These unwanted checks deteriorate the performances.

Canvas in grayscale mode

void TCanvas::SetGrayscale(Bool_t set /*= kTRUE*/) set whether a canvas should be painted in grayscale, and re-paint it if necessary.

One can toggle between a grayscale preview and the regular colored mode using TColor::SetGrayscale(). Note that in grayscale mode, access via RGB will return grayscale values according to ITU standards (and close to b&w printer grayscales), while access via HLS returns de-saturated grayscales.

TCanvas::SetGrayScale is available via the TCanvas context menu.


Implement TPave::DistancetoPrimitive, overloading TBox::DistancetoPrimitive such that picking in a TPave with no fill style is now possible.



- The fit panel opened on the TGraph produced by the following lines, had buttons with no text inside.
          TGraph *g = new TGraph;


A bug introduced after "coding conventions mods" has been fixed.


TShape::Paint was dummy. This method is not needed for TShapes sitting in a TNode. But having it dummy prevent the TShapes outside a TNode to be painted. The following example shows the problem:
            c1 = new TCanvas("c1","Geometry Shapes",200,10,700,500);
            view = new TView(1);
            brik = new TBRIK("BRIK","BRIK","void",200,150,150);




GUI Builder

Object Editors Improvements

Qt BNL Interface

GSI QtRoot

The Qt Interface developed at the GSI is a light weight  interface that enables the user to write a Qt 3 application which can use ROOT. The Native Qt 4 support is planned and will be available very soon.  Furthermore, existing Qt 3 Application can use this interface to have almost full access to the Root functionality (see "Create the Main file for the project" below). Using this interface a full access to both ROOT and Qt widgets is possible in one application.

An Embedded Root canvas can be set inside any Qt widget either by C++ calls or using the Qt designer. To use the Qt 3.x designer to make ROOT applications with Qt GUI's see below:  

I. Add the TQRootCanvas to the Qt Designer:

1. Start the designer
2. In the designer menu choose tools->custom->Edit Custom Widget
3. In the Edit Custom Widget window choose "Load Description"
4. From GSI Qt-Root interface directory load the file ""



    Now you will see the TQRootCanvas in the Class field, you will also
    see all other parameters, signals, slots and properties of the TQRootCanvas.

    Now we are ready use the TQRootCanvas within the Qt 3.x designer.

    II. Create a new Project in the designer

    1. Choose "File->New"
    2. Select C++ Project 
    3. create the Project in a directory of your choice 

        The project setting:

    1. Select Project->Setting from the designer main windows 

    2. in The Project setting window select the C++ tab 

    3. to the Libs line you have to add the Root libraries and the GSI Qt-Root interface  for example:

        -L(ROOTSYS)/lib -lCore -lCint -lHist -lGraf -lGraf3d -lGpad -lTree -lRint -lPostscript -lMatrix -lPhysics -lnsl -lm -ldl -rdynamic  -lqtgsi

    4. to the Includepath line add:    $(ROOTSYS)/include 

    these setting will be saved in file and the qmake will generate the Makefile
    according to these settings.

    III. Now you can create your own widgets in the designer and add them to the project


    IV. Create the Main file for the project

    The main file should look like:

    #include "TQtApplication.h"
    #include "TQtRootApplication.h"

    #include "MyWidget1.h"

    int main( int argc, char ** argv ){

        TQRootApplication a( argc, argv, 0);
        TQApplication app("uno",&argc,argv);

        MyWidget1 *w = new Mywidget1;
        a.connect( &a, SIGNAL( lastWindowClosed() ), &a, SLOT( quit() ) );
        return a.exec();

    in blue are the differences to a standard Qt main file.

  •       Examples:

    1.  The first example shows how to use Qt3 and root without the Qt designer. This program has three different "modes" .ie.
                  * mode 0 : type `./qtroot 0' (Qtroot alone)
                  * mode 1 : type `./qtroot 1' (QtROOT + TBrowser)
                  * mode 2 : type `./qtroot 2' (QtROOT + TBrowser + Guitest (ROOT GUI"S examples))

    2. The second example shows how to use the Qt designer as described above to create Qt - Root applications.

    New features in the Geometry classes


    The visualization manager for TGeo objects (TGeoPainter) fully using geometry iterators (TGeoIterator). The main advantages are that: the painter does not need to change the top volume for TGeoManager and the loops are not longer recursive. This makes painting a process that does not affect any more the manager class. It makes possible having parallel views of different parts of a geometry (or different geometries). New features:




    New Features




    There are several improvements for specific python coding idioms, to the pythonization of ROOT classes, a few optimizations, and some re-wiring for the benefit of PyCintex.

    Interpreter environment

    Global functions can now be used anywhere as drop-in replacements for python functions, the __repr__ printout of proxy objects has been prettified, variables of builtin types can be assigned directly in the ROOT module and be available to CINT, diagnostics for unset errors have been improved, const globals and enums are made read-only, pointer/class based object comparison has been added. The module shutdown sequence has been made explicitly to prevent cycles that can not be handled by the garbage collector during shutdown.

    C++ language and pythonization

    Overloading of functions has been improved with a priority scheme that favors classes with known dictionaries and penalizes void* arguments, and some more boundary checks for builtin types have been added. Unloaded, but known, namespaces are now normally accessible, (builtin) types can be used for template type parameters, and use of return-by-ref assignments from operator() is supported through operator[] with equivalent arguments. New pythonizations are: support for smart pointer dereferencing, a TClass.StaticCast with expected semantics, return type casting on TClass.DynamicCast, direct lookup in TFile objects, and looping over TTree and TTree derived classes.


    Although still not recommended for use, "from ROOT import *" now scales as expected, and its overhead compared to "import ROOT" has been minimized. Class lookup has been improved by using a cache, primarily for the benefit of object returns.


    Ensure consistency of class index and documented classes. Fixed Cint's C++ interface so THtml can distinguish const func from func returning const. Improve performance of THtml.

    Changes in the test directory and new tests

    New tutorials

    ROOT page - Class index - Top of the page