ROOT status and short review
CERN/IT, 1211 Geneva 23
GSI/Darmstadt and Hewlett-Packard
The ROOT system initially developed in the context of NA49 at CERN
is now being used by tens of experiments in HEP, Nuclear Physics,
Astrophysics, data mining, etc. This paper summarizes the functionality
of the current version 1.03 and its performance.
1. Project history
- Project started in January 1995.
- Version 0.5 (demonstration prototype) in November 1995.
- Version 1.0 in March 1997.
- Current version 1.03 released in December 1997.
- Plan to release version 2.0 in March 1998.
- Small development team.
- Not officially supported.
2. ROOT Users
Several hundred people using ROOT for data analysis and
presentation (PAW replacement) (DESY in particular).
Tools like h2root facilitate the transition.
360 people registered, 300 people in roottalk mailing list.
80000 hits/month on our Web site.
8000 FTP distributions of binaries in 1997.
- Started in NA49, a CERN heavy ion experiment.
- Adopted by at least the following experiments:
Alice, Phobos, Finuda, E907, Taps, Hades, Integral, Pierre Auger
- Adopted by a few data mining projects:
eg Medical Fraud Detection at Los Alamos
- Several experiments evaluating ROOT as the base framework:
(CDF, D0, Minos, Star, Phenix, Brahms, HeraB)
- Several interesting projects in new experiments:
- Atlfast (fast simulation for Atlas).
- test beams in Atlas and CMS.
- MonteCarlo(s) in Alice.
- AMS visualisation and data analysis.
3. Functionality: a quick summary
- The C++ interpreter (from Masa Goto/HP-Japan). A very large subset
of the language in interactive commands and macros. Interpreted code
call call compiled code and vice-versa.
- Support for RTTI(Run Time Type Identification) from class definition file.
- Automatic GUI and I/O code generation.
- User classes and macros documentation tools. The complete ROOT system
is documented via the tool class THtml.
- Inspectors and Browsers. This tools are very useful to navigate
in data structures in memory or on a data base. The object dump
uses the RTTI information.
- 2-D graphics (low-level and high level classes). All low-level
graphics primitives (lines, circles, boxes, text, markers, axis, etc.).
High level functions to draw a set of non-equidistant points with
error bars or to draw parametric functions. Support for high precision
vector + raster Postcript is available, including in batch sessions.
A simple graphics editor can be used to add/modify annotations
on a picture. The canvas can be saved in many formats (ps, eps, gif)
but also as a ROOT file for processing in a new session. ROOT can
also save the picture as a C++ macro. This feature has been found
particularly interesting and powerful by the traditional PAW users
familiar with commands and macros, but also by users of commercial
WYSIWIG systems. The ROOT graphics system is fully object-oriented.
The event loop can report the object currently pointed by the mouse
via the TObject::DistancetoPrimitive and TObject::ExecuteAction
functions. Clicking with the right mouse on any object shows a pop-up menu
with a list of items (member functions with parameters).
- 3-D graphics (X3D and OpenGL). The X3D viewer runs only on Unix
systems. The system is extremely fast for complex pictures and runs
very efficiently in a network. X3D supports: wireframe, hidden line and
hidden surface algorithms + stereo views for these 3 modes.
The OpenGL class runs on Unix and WindowsNT/95 systems. The Unix
implementation is in general based on the public domain version of GL,
- A rich set of container classes. This includes support for simple lists,
doubly linked lists, hash lists and tables, balanced trees, object
arrays. The development of a special container TClonesArray
provides support for arrays of objects typically found in the case
of simulation and reconstruction programs. This class improves
considerably the performance of the system by minimizing
the memory allocation problem.
- Data Base with Objects compression + remote access. The data base
system is designed to support very large files or collection
of files. The ROOT data bases are machine independent. The I/O system
supports schema evolution and object versionning. The compression
algorithm is seen by our users as a fundamental feature.
The system includes both sequential and direct access to events.
One can selectively read only subsets of events. The automatic split
of objects into branches and leaves provides the conventional support
of object-oriented data bases and in addition the attribute-oriented
access necessary in the physics analysis phases. A ROOT data base can be
transparently accessed in the network using the semantics of the WEB URLs.
A ROOT daemon can be automatically started on the remote site. This daemon
supports concurrent read and write operations.
- 1-D, 2-D, 3-D histogramming. For all dimensions, several bin data types
are available. Bin or cell errors can be specified. Profile histograms
are implemented, as well as projections. Fitting is supported
for all dimensions. Operations between histograms via functions or
normal operators are included with correct errors calculation.
User defined objects can be added to a list in a given histogram.
These objects are drawn when the histogram is drawn.
- Minimisation: based on the popular Minuit system
- Trees (more than Ntuples: analysis a la PAW or user driven).
Trees are an extension of the Ntuples to the general case of objects.
They provide the flexibility of Ntuples in the data analysis phase
without breaking the object model. The generation of a Tree is
automatic from the class definition and based on the RTTI.
ROOT supports also the analysis of a file with a Tree when
the access to the class that generated this Tree is not available.
- Client/Server, Shared memory and Threads support. These services
are essential in applications using ROOT online.
- Interface to Operating System.
- Dynamic Linking plays a key role in the system. This extends
the power of the basic system by giving the possibility to call
classes from external shared libraries or DLLs. User classes
dynamically linked can be invoked from the interpreter.
- PROOF (Parallel ROOT facility). This facility is currently
being developped within NA49. PROOF makes use of a network of PCs
to process a data base query in parallel.
- Interface to Event generators: Pythia, Venus.
- General Utilities (linear algebra, transforms, Random numbers).
- Conversion tools (h2root, g2root, gh2root).
ROOT histogram package compared to Hbook and LHC++:
- ROOT I/O performance compared to Zebra I/O:
20% to 100% faster (see table on our Web site)
- ROOT data base size compared to Zebra and Objectivity.
- typically two times smaller than Zebra.
- more than a factor 3 smaller than Objectivity (in test).
Other reports soon available:
eg, Phobos comparing ROOT and Objectivity
- 80% faster than Hbook.
- XXX% faster than LHC++.
- Automatized from our Web site: http://root.cern.ch
- Support for all Unix platforms (native compilers + gcc on most).
- Support for WindowsNT/95.
- 1/3 Linux, 1/3 on Windows, 1/3 on other Unix boxes.
- On AFS for hpux9,10, aix, solaris, linux.
- Documentation set available.
- ROOT course available.
6. Areas for improvement
We list below some of the many improvements we intend to implement
in the coming months:
GUI. The coming version 2 includes the following
- C++ Interpreter:
- Robustness must be improved.
- Better error recovery in case of user mistakes.
- Some C++ functions still not implemented.
- Pointers to functions not well supported.
- Minimal support for templates.
- Many loop types not yet optimized.
- Automatic compilation/linking still pending.
- Interpreted class cannot inherit from a compiled class.
- A state of the art GUI with the Windows95 look and feel.
- A common base class for X11, Win32, Java, Client-Server.
- A Tree browser and cut manager.
Documentation must be improved.
Makefiles distributed with source.
- Graph quality (PAW level) could be improved.
- Better control for styles.
- Support for Math notation(screen,ps) (LateX, XML).
- Image processing classes.
Masahuru Goto is playing a fundamental role in the development
of the C++ interpreter. Despite the distance, the communication channels
are pretty effective. We would like to thank our colleagues Nenad Buncic and Valery Fine
for their involment in the project. The NA49 collaboration has provided
an excellent environment to prototype the system. Many thanks to
Andres Sandoval and Gunther Roland in particular.