Q Provide summary information for each product stating the basic philosophy or approach
to solving the analysis/reconstruction problem
Leverage the power of Java as much as possible because:
A With the ROOT system, written in C++, we provide, among others, an
efficient hierarchical object store, a C++ interpreter, advanced
statistical analysis (multi dimensional histogramming, fitting and
minimization algorithms) and visualization tools. The user interacts with
ROOT via a graphical user interface, the command line or batch scripts.
The command and scripting language is C++ (using the interpreter)
and large scripts can be compiled and dynamically linked in.
ROOT also contains a C++ to HTML documentation generation system
using the interpreter's dictionaries (the reference manual on
the web is generated that way) and a rich set of interprocess
communication classes (supporting TCP/IP and shared memory).
For the analysis of very large dataset can (> TB's) we provide the
Parallel ROOT Facility (PROOF).
The system is packaged in a set of modules (shared libraries) which
are dynamically loaded only when needed.
--------------------------------------------------------------------
Q Age of product (how long has it been in development)
A Development started in January 1995.
First prerelease in November 1995 (version 0.5)
First public release fall 1996
--------------------------------------------------------------------
Q Justify existence/parallel development of multiple packages (or
modules) for similar topics
display requirements, particular architecture, modules,..
models for scalability estimations (networking, LARGE databases/files)?
planned interoperability of the packages? Modularity?
(e.g. ROOT fitters and LHC++ display?)
decision guidelines? (which package to use?)
A The ROOT project was started in January 1995 to provide a PAW replacement
in the C++/OO world.
It is with a big disappointment that we saw an alternative project setup
in 1996 by a committee (LCB) with no experience in the field.
--------------------------------------------------------------------
Q Could the developers of the various approaches comment on where they
DONT think it is appropriate to use their approach? E.g. what have they
been forced to optimize away from, etc?
A We did not want to provide a complete OODB.
Our previous experience with PAW/Zebra/RZ indicated that support for locking,
journaling/concurency was far more work than initially anticipated.
At the same time progress with RDBMS and their general availability
was pushing for an hybrid solution with
- Root I/O being used for the event store
- An RDBMS used for run/file catalogs
We also did not put much effort in fancy 3-D interfaces, hoping that
somebody else could join this effort.
--------------------------------------------------------------------
Q Could you compare the availability of ROOT and LHC++ (supported
machines, compilers etc)
A ROOT is currently available on the following machines/compilers:
-Intel 386 Linux RedHat5.1, 6.1, 6.2, SuSe, Mandrake, Debian
with egcs1.2, gcc2.95, KAI
-Intel Itanium Linux gcc2.95 (64 bits)
-Solaris 5 , 6, 7 with
Sun CC4.2, CC5, egcs1.2, gcc2.95, KAI
-Alpha/Unix (64 bit) with
Cxx 6.1,6.2, egcs1.2, gcc2.95
-HP-UX 10.20 with:
CC, aCC, egcs1.2
-AIX4.3 with xlC, egcs 1.2
-SGI/IRIX 6.2, 6.4, 6.5 (-32, -n32 options) with:
CC, egcs1.2, gcc2.95, KAI
-LinuxPPC with gcc2.95
-FreeBSD with gcc2.95
-Windows95/98/NT/2000 with VisualC++ 6
--------------------------------------------------------------------
Q Number of components and total number of lines of code produced.
A ROOT is not only a replacement for PAW. It was designed to be used as a
base framework and I/O solution in online and offline.
Currently 650,000 lines of code (>200000 lines generated by the system
automatically), 50,000 lines of test programs and examples.
see library structure in libs.ps
(pcnotebrun) #[1017] ls -l lib
1144798 Sep 21 13:07 libCint.so
3698279 Sep 25 14:38 libCore.so
429046 Sep 21 13:16 libEG.so
159115 Sep 21 14:25 libEGPythia.so
165362 Sep 21 13:17 libEGPythia6.so
171114 Sep 21 13:17 libEGVenus.so
272379 Sep 21 13:16 libGX11.so
188306 Sep 21 13:16 libGX11TTF.so
888816 Sep 23 19:05 libGpad.so
1290790 Sep 21 13:12 libGraf.so
932054 Sep 21 14:24 libGraf3d.so
2322851 Sep 21 14:24 libGui.so
1311866 Sep 21 13:10 libHist.so
261139 Sep 21 13:15 libHistPainter.so
114653 Sep 21 13:16 libHtml.so
396483 Sep 21 13:15 libMatrix.so
317552 Sep 21 13:15 libMinuit.so
150578 Sep 21 13:17 libMySQL.so
25231 Sep 21 13:09 libNew.so
303397 Sep 21 13:16 libPhysics.so
146699 Sep 21 13:16 libPostscript.so
172324 Sep 21 13:15 libProof.so
145446 Sep 21 13:17 libRFIO.so
1990713 Sep 21 13:17 libRGL.so
172117 Sep 21 14:25 libRint.so
48290 Sep 21 13:18 libSRPAuth.so
945954 Sep 23 08:48 libStar.so
283729 Sep 21 14:25 libThread.so
742309 Sep 21 13:11 libTree.so
232545 Sep 21 13:15 libTreePlayer.so
156463 Sep 21 14:25 libTreeViewer.so
102991 Sep 21 13:16 libX3d.so
--------------------------------------------------------------------
Q Are LHC++ & ROOT free? Licenses? Fees? Special requirements?
A All Root components are free. The full system is available as:
- precompiled binaries for all platforms above
- source.tar.gz (one file of 3.5 MB) including the complete system
- CVS repository. Anybody can check out at any time the latest greatest
version or any released/tagged version.
The installation procedure is based on gmake. No other tools required.
--------------------------------------------------------------------
Q I would like to know about the licenses needed for ROOT and LHC++, who is
the owner? How does it affects the development of them?
is it an important point to be considered for "long-period" experiments like
LHC experiments?
A For ROOT the copyright owners are CERN and Fons Rademakers. This
does not effect the development and distribution. ROOT is available free of
license fees in source and binary form. The basic system does not contain
any 3rd party commercial components that would require a license fee.
--------------------------------------------------------------------
Q How many resources are used in LHC++ to ROOT?
A Which resources?
Two people develop Root (only one supported by CERN)
Masa Goto develops CINT
Philippe Canal has joined recently for Root support at FNAL
Suzanne Panacek is taking care of the new Users Guide.
--------------------------------------------------------------------
Q Could you show a list of experiments where ROOT & LHC++ are used:
as a framework
as an analysis tool
in the DAQ
A Many experiments use Root as a base framework:
Alice at LHC
Star, Phobos, Brahms at RHIC
Minos at FNAL
Hades at GSI
Most experiments at Jefferson Lab
Finuda at Daphne
Many experiments use Root I/O in addition to the above exper.
LHCb at LHC (Atlas planning tests and comparison with Objy)
Phenix at RHIC
CDF at FNAL
H1 at DESY (recent decision). Also Hera-B
BaBar for micro-DSTs (together with Objy)
More than 65 experiments use Root as a data analysis framework.
see table. 76000 binary distributions.
--------------------------------------------------------------------
In all of the following Xxx should be understood as a substitute for
JAS/ROOT/LHC++Anaphe. The idea here is to clump similar specific
questions of the students into one that covers the same area. No
particular order!
Q If I want to make an improvement in Xxx, how do I go about it?
A Proceed like several thousand people who already doing this.
Subscribe to the roottalk mailing list, see what happens and feel free
to submit your complaints, additions, etc. The Root web site has a long list
of links to users contributions. The CREDITS file in the Root source
distribution has a long list of people who have contributed in many
different ways to the Root system.
--------------------------------------------------------------------
Q To what extent does Xxx allow a user or experiment to choose their
scripting language (e.g. Java, Python, CINT, etc)? Can an experiment
choose more than one?
A The default command/script interface in Root is based on CINT.
If a user does not like CINT, he can make a Python interface or yyy.
The Root classes may be invoked directly.
It is worth mentioning that the number of requests for this solution is
close to 0.
Tony Johnson has successfully started an interface to the Root files.
Subir Sarkar (L3 Bombay and CDF) has developped an interface to
the histogramming package (native Root classes written in Java) and also
a native Java interface to the Root files.
--------------------------------------------------------------------
Q How does Xxx work with non-native data storage? If an experiment
defines its own storage system, can Xxx use it? Also, can ROOT/JAS
work with HepODBMS/Objectivity? Can JAS/LHC++ work with ROOT files?
("Work" may not be the right word here - perhaps something like "What
capabilities are lost when using .... data" is a better phrasing?)
A Root can read any type of data not in Root format. The typical situation
is to read ascii files or any type of binary data via normal C++.
The h2root program is an example of a C++/Root based program converting
PAW files to Root format.
NASA have implemented an interface between Root and the HDF files
that are the standard for AstroPhysics.
Root has interfaces to RDBMS systems such as MySQL and Oracle.
An ODBC/JDBC interface has been developped by Valery Onuchyin (see
link on Root web site). We have tens of examples of collaborations using
their legacy data and processing them with Root.
--------------------------------------------------------------------
Q What will need to be developed in Xxx to handle the expected size
of LHC data analysis? What are the current strengths and weaknesses
of Xxx for storing very large amounts of data?
A Root is assumed to work in conjunction with an RDBMS. The RDBMS handles
the run/file catalog and other data that require locking, journaling, etc.
Root files have a current practical limitation to 2 GBytes.
All the hooks are alreay in Root to support larger file sizes.
Root has no implicit limitations that would preclude scaling (unlike
Objy which has maximum limits for container/page/db sizes).
The ALice data Challenge has demonstrated the storage of 25 TeraBytes
of data with the run catalog (25000 files) stored in a simple MySQL
data base. A run catalog of 1000000 files has been successfully tested
with MySQL. Many experiments are currently experimenting with the
combination Root + RDBMS and expect to store several hundred TeraBytes
in 2001.
--------------------------------------------------------------------
Q How does Xxx work with external software such as GEANT4? GEANT3?
What can you do and not do via Xxx?
A The Alice collaboration has developped an abstract MC interface
in the AliRoot framework. This abstract interface has currently
an implementation (TGeant3) for Geant3 and a set of classes. TGeant3
is independent of Alice
- AliGeant4 with Alice specific classes for Geant4
- TGeant4: an experiment independent interface to G4 called by AliGeant4
The geometry input and the hits output is MC independent (same classes
for Geant3 and Geant4).
--------------------------------------------------------------------
Q Is it planned to implement:
a ROOT GUI for G4
persistency for G4 objects in ROOT
interaction interface to G4 classes for ROOT
A A Root GUI has recently be developped in Alice by Isidro Gonzalez.
This work will be presented at the coming Geant4 workshop in October.
The Root GUI has been found more functional and one order of magnitude
faster than the G4/Java interface.
Also in Alice, Ivana Hrivnakova who developped the AliGeant4 and TGeant4
classes is currently working in processing all the G4 classes via rootcint.
This work is now close to completion. Once it is done, the following
facilities will be available:
- Automatic I/O of G4 objects
- Automatic inspection and browsing of G4 data structures
- CINt interactive interface to the G4 classes.
--------------------------------------------------------------------
Q If an experiment has an existing software package, how do you
interface it, and how much its capability will be available via Xxx?
A There are two ways to use ROOT. As framework or as toolkit. When using it as
framework ROOT will control the eventloop and call your software. This will
allow you to use all ROOT's capabilities. Or you can use ROOT as toolkit
you keep your eventloop and you use ROOT features like a 'sub-routine
library' calling e.g. ROOT's histogramming, I/O, etc. Both approaches are
used by several experiments. ALICE, STAR, etc. use the first, while ATLAS,
LHCb are using the latter.
--------------------------------------------------------------------
Q How does Xxx utilize large parallel farms for computation?
A Following our long experience with parallel architectures in the early 1990s
and in particular the development of the PIAF system for PAW, we developped
a first prototype of PROOF in 1997 with the goal of using a parallel
cluster in an heterogeneous environment.
We are investing a lot of effort with PROOF to support large parallel
farms. This work will be gradually integrated with the current
GRID projects (eg Alice has submitted a GRID proposal based on PROOF)
--------------------------------------------------------------------
Q If I want to make an improvement in Xxx, how do I go about it?
A Proceed like several thousand people who already doing this.
Subscribe to the roottalk mailing list, see what happens and feel free
to submit your complaints, additions, etc. The Root web site has a long list
of links to users contributions. The CREDITS file in the Root source
distribution has a long list of people who have contributed in many
different ways to the Root system.
--------------------------------------------------------------------
Q Future & future plans (long & short-term) for ROOT and LHC++
A The main points in the coming months will be:
- implementation of an automatic schema evolution algorithm
using the recently introduced StreamerInfo facility (used by T.Johnson)
- Port of the Unix GUI on NT (this work is currently being done
in collaboration with Bertrand Bellenot from AluSuisse
- Rewrite of the old style panels (AttFill, Line, text, DrawPanel
and Fitpanel) using the new GUI).
- Major extension of PROOF and integration with the GRID projects
--------------------------------------------------------------------
Q Can ROOT work on top of ObjyDB and how
A This has been demonstrated in several configurations.
See Babar, Phenix.
Alice have also compared Root with Objy and used both together
to conclude that Root was superior to Objy in all aspects of the tests.
--------------------------------------------------------------------
Q Real life scenario
I have a grid of physical parameters and i have to simulate
thousands of experiments. At each point in this which has about 2000
points. Each simulated experiment produces a histogram I
have to fit maximizing x2. In summary it is a job of heavily
manipulating 2d and 1d histograms including extending the concept of
histograms to include several in one. Usual adding/subtracting/scaling
comparison of 2 of them and saving them for later use.
How do ROOT and LHC++ compare for this task? What are the
advantages of one or the other? How could they be applied?
A Root is optimized for this process (faster than PAW). All the benchmarks
run since the beginning of LHC++ have always shown a tremendous
advantage for ROOT for:
- execution time
- resources used (memory, disk)
We have hundreds of users doing the kind of tasks above routinely.
Always requests to get more performant algorithms.
--------------------------------------------------------------------
Q Does ROOT or LHC++ predict use of a scripting language that is not OO,
fortran like, with usual call to functions like plot?
A We know several Fortran wrappers calling C++. Vice-versa, Fortran
can be called from C++, including from CINT. Examples are
the Pythia6 and Geant3 interfaces.
--------------------------------------------------------------------
Q What is the role of standards? Wht not use use a scroller that looks
like a scroller? std:: ?
A I suppose slider (and not scroller).
Some Root widgets were developped before the current GUI existed.
The upgrade of these widgets iswaiting for the NT implementation
of the GUI
--------------------------------------------------------------------
Q Is it possible to implement an interface to the ROOT system in LHC++?
e.g. for the graphics/histogramming? or for some parts of the system?
How exchangeable is the data? May there be an adapter Objectivity <->
ROOT tree?
A Already implemented at Babar
--------------------------------------------------------------------
Q I just want to take a part of ROOT that I particularly like (eg GUI) and
use it as a front-end to LHC++ or just in my programs (for example
widgets or threads). How can I do it without getting the whole ROOT system
altogether with parts that I need?
A see libs.ps
--------------------------------------------------------------------
Individual Questions
A Could you show the min. COMPILED program to:
-Create 100 1D histograms with range [0,1] histograms should have a title like
"histo number:xxx
-make a loop 100000 times with:
-random selection of one of the 100 histogram
-fill the selected histogram with a flat generator
-save the histograms to a file
-what is the file size in bytes?
-what is the total RealTime and CpuTime to execute this program?
A For example the following program
#include "TROOT.h"
#include "TFile.h"
#include "TH1.h"
#include "TRandom3.h"
void fill()
{
TFile f("CSCtest.root","recreate");
int i, id;
const int nhist = 100;
TH1F *h[nhist];
char name[8], title[40];
for (id=0;idFill(rand.Rndm());
}
f.Write();
}
We extend the maximum loop index to 1000,000 and to 10,000,000
to get something that can be measured. Otherwise 100000 executes in
less than 0.1 s. With 10,000,000 the result is the following on one of the
CSC Pentium III machines:
root [1] .x fill.C+
100,000 iters Real time 0:0:0, CP time 0.100 (0.390s via CINT)
==> 0.100 microsecond per iteration
1,000,000 iters Real time 0:0:0, CP time 0.540 (3.3s via CINT)
==> 0.540 microsecond per iteration
10,000,000 iters Real time 0:0:4, CP time 4.920 (32s via CINT)
==> 0.492 microsecond per iteration
100,000,000 iters Real time 0:0:47, CP time 47.350
==> 0.473 microsecond per iteration
file size = 43838 bytes
--------------------------------------------------------------------
Q Could you show the minimum INETRACTIVE program to:
connect the file of histograms generated above
create a window with 2 zones (top and bottom)
fit histogram 10 with a straight line and draw it in top zone
fit histogram 20 with a straight line and draw it in bottom zone
generate a ps file corresponding to the window.
A Example of an interactive Root session
TFile f("CSCtest.root")
TCanvas canvas
canvas.Divide(1,2)
canvas.cd(1);
h10.Fit("pol1")
canvas.cd(2)
h20.Fit("pol1");
canvas.Print("CSCtest.ps")
--------------------------------------------------------------------
Q Show a good example for object persistency
A The question is ambiguous.
Here is a trivial example showing how to create/fill and make an histogram
persistent:
TFile f("test.root","new");
TH1F hist("hist","example of histogram made persistent",100,-3,3);
hist.Fill(-1,5);
hist.Write();
f.Close();
The ATLFast example shown in Root exercise C is a very good example
of persistency where both algorithm objects and data objects are saved
in a Root data base. The Event Display example shows how to read subsets
of an event.