ROOT - An Object Orientated Data Analysis Framework

[riaan]

CERN (the Physics project that brought you the WWW), having had many years of experience in developing the interactive data analysis systems like PAW, PIAF and the simulation package GEANT, realized that the growth and maintainability of these products, written in FORTRAN and using some 20 year old libraries, had reached its limits. It was time to re-think their approach to large scale data analysis and simulation. Thus was born ROOT.

ROOT

ROOT is an object-oriented software package that was originally designed for particle physics data analysis and contains several features specific to this field, but it is also commonly used in other applications such as astronomy and data mining.

Development was initiated by René Brun and Fons Rademakers in 1994. ROOT is written in C++, and published under the LGPL. It provides platform independent access to a computer's graphics subsystem and Operating System using abstract layers. Parts of the abstract platform are: a graphical user interface and a gui builder, container classes, reflection, a C++ script and command line interpreter (CINT), object serialization and persistence.
The packages provided by ROOT include those for
* histogramming and graphing to visualize and analyze distributions and functions,
* curve fitting (regression analysis) and minimization of functionals,
* statistics tools used for data analysis,
* matrix algebra,
* four-vector (space-time) computations, as used in high energy physics,
* standard mathematical functions,
* multivariate data analysis, e.g. using Neural Networks,
* image manipulation, used e.g. to analyze astronomical pictures,
* access to distributed data (in the context of the Grid),
* distributed computing, to parallelize data analyses,
* persistence and serialization of objects,
* access to databases,
* 3D visualizations (geometry)
* creating files in various graphics formats, like PostScript, JPEG, SVG,
* interfacing Python and Ruby code in both directions, and last, but not least,
* interfacing Monte Carlo event generators.

IMPLEMENTATIONS

Here's a (not complete) list of some major Physics projects using ROOT extensively:
* CERN's new set of experiments (ALICE, ATLAS, CMS, TOTEM, and LHCb)
* H.E.S.S. - "High Energy Stereoscopic System" here in Namibia
* CDF - "Collider Detector at Fermilab"
* COMPASS - "Common Muon and Proton Apparatus for Structure and Spectroscopy"
* MINOS - "Main Injector Neutrino Oscillation Search"
* The STAR Experiment at the Relativistic Heavy Ion Collider
* GLAST - "Gamma-ray Large Area Space Telescope"
* The IceCube Neutrino Detector

Although not perfect and often criticized by computing professionals, ROOT is a workhorse of the High Energy Physics (Particle and Astroparticle) community. It may just be what you are looking for.

Visit http://root.cern.ch/ to download a version for your favourite open source platform (if you are using Gentoo Linux, then a simple "emerge root" will download and install it for you).

Regards
Riaan

(Material adapted from http://root.cern.ch and http://en.wikipedia.org/wiki/ROOT)

[uwe]

Very interesting.

What I have problems with is that it comes with its own GUI builder which usually means the result doesn't fit into *any* environment. Do you have experience in integrating it into existing DEs like KDE or GNOME (though using C++ libraries from C is far more difficult than the other way round)?

[riaan]

You're quite correct that lots of computing professionals hate some aspects of ROOT, like its monolithic structure, its reliance on CINT and last, but not least, ROOT's idiosyncratic GUI. In the case of the GUI builder, one should have sympathy for a Physicist caught in the publish-or-perish paradigm, because learning how to use any set of tools takes a considerable investment in time, time which is not recognized as productive by your peers nor by the powers-that-be that funds your activities. Thus, a GUI builder that is completely platform independent (yes, I know the same goes for Qt, etc.) and as such, constitutes a more or less once-off investment is a plus point for a busy-busy scientist chasing his/her next publication.

Another point is that ROOT predates KDE by some 3-years (I think). I don't know if even Qt existed when the ROOT project was launched in 1994.

On the other hand, it is possible these days to add ROOT application layer code to a Qt GUI via Python and PyQt. It should be simple for you KDE wizards to extend this to mixing KDE and ROOT. Here's an example from http://wlav.web.cern.ch/wlav/pyroot/overview.html:

-----------------(snip)---------------------
The following example shows how a python class can be used to have ROOT code respond to a click on a Qt widget.

Example 1. Glue-ing Qt and ROOT through python

import sys, ROOT
from qt import *

theApp = QApplication( sys.argv )
box = QVBox()
box.resize( QSize( 40, 10 ).expandedTo( box.minimumSizeHint() ) )

class myButton( QPushButton ):
   def __init__( self, label, master ):
      QPushButton.__init__( self, label, master )
      self.setFont( QFont( 'Times', 18, QFont.Bold ) )

   def browse( self ):
      self.b = ROOT.TBrowser()

bb = myButton( 'browser', box )
QObject.connect( bb, SIGNAL( 'clicked()' ), bb.browse )

theApp.setMainWidget( box )
box.show()
theApp.exec_loop()

When the example is run, a Qt button is displayed, and when the button is clicked, a TBrowser instance is created and will appear on the screen. PyROOT takes care of feeding system events to ROOT widgets, so the TBrowser instance and the button behave properly when you interact with them.

Note
GUI frameworks are a special case, as ROOT has its own GUI classes. For a full seamless integration, one would want to be able to frame ROOT windows in Qt and vice versa. This can be done by retrieving the window handles and a bit of lower level code (which tends to be non-portable), but is not so straightforward, unless you know how windowing systems work.
-----------------(snip)---------------------

Enjoy!
Riaan