Many PYTHIA users wish to use ROOT
to produce histograms, or even to run PYTHIA as a plugin to ROOT.
This is possible. It is not a task supported by the PYTHIA team,
however. All issues involving ROOT usage should be directed to the
ROOT team, or to the local support team of your collaboration.
Below some helpful hints have been collected. The text is based on
contributions by Rene Brun, Andreas Morsch and Axel Naumann.
Another example may be found in the
add-on program for parton showers, but this should also work for
a PYTHIA standalone run.
- Standalone usage
- Storing partial PYTHIA events in ROOT trees
- PYTHIA as a plugin to ROOT
Note that in all that follows, a Linux-type system with a Bash shell
and GNU Make is assumed. In particular, for Mac OS X, the
LD_LIBRARY_PATH should be replaced with
DYLD_LIBRARY_PATH and the extension for shared libraries
.so should be replaced with
One can perform the generation and analysis of events in a completely
standalone fashion, and only use ROOT to process the completed events.
Two example programs are provided in the
directory, with details provided below.
The examples assume that ROOT is installed, that you have run
where you have to specify which is the ROOT installation directory,
and subsequently run
make. More fine-grained options are
configure, if need be.
Histogramming with ROOT
An example of histogramming with ROOT is provided in
examples/main91.cc. It may be compiled and run
just like the other example programs. After PYTHIA has run, a ROOT
histogram of the charged multiplicity in the events will be shown.
This is now stored in the
hist.root file. If you can
make this example work, the road should be open to do the same for
all other histogramming needs. Specifically, you need to edit the
examples/Makefile file to add the other programs to
main91.cc currently does.
Storing PYTHIA events in ROOT trees
Instead of only generating histograms, it is possible to store entire
PYTHIA events in ROOT trees. The
provides an example of this and is comprised of the following files:
main92.cc is the main example program showing how
PYTHIA events can be stored in ROOT trees;
main92LinkDef.h is used by Makefile to generate the
dictionary for all PYTHIA classes involved in the IO, as needed for
the example; and
main92.h is a small include declaring the
Pythia8 namespace as default.
The example may be compiled and run with as usual. Afterwards, the new
pytree.root file will contain the PYTHIA events. Note
that files can become quite large when many events are generated. To
open these files within the ROOT interpreter the PYTHIA class
dictionary must be loaded,
.L main92.so. In compiled
code, the PYTHIA class dictionary
main92.so must be
linked against, to either read or write PYTHIA events to a ROOT file.
It appears that ROOTCINT cannot handle the
in the current ROOT version. If you run into this problem with your
ROOT installation, you could try to insert the following lines in
// Stdlib header file for dynamic library loading.
#define dlsym __
Storing partial PYTHIA events in ROOT trees
Instead of storing full PYTHIA events in ROOT trees, a common user case
is to store only track information relevant to a particular analysis.
The resulting ROOT trees will then be what is often referred to as
The advantage of this over the above method is a significant reduction
of disk space used, as well as the possibility to construct trees
resembling those familiar from the experiments' central MC production.
examples/main93 example provides this - among other -
functionality. As for the above example, it is split up in several
main93.cc is the main example program;
main93.cmnd is a sample input command file;
main93LinkDef.h is used by Makefile to generate the
dictionary for only the used PYTHIA classes involved in the IO, for
the example; and
main93.h defines a "track" and an "event" class where
relevant event -and track information is defined.
Compiling the example
main93 example is compatible with ROOT v.6 and above.
One should have a working installation of ROOT, and then configure PYTHIA
One can then compile
main93 with the usual:
provided that all ROOT paths are set correctly by eg. running:
Running the example
main93 example can be run with several command line options.
will display a help text showing these options.
To produce events, the user needs to supply a command file with option
-c COMMAND-FILE.cmnd. The example command file
main93.cmnd is a good starting point. The crucial command to
output ROOT trees is to set
Main:writeROOT = on.
The ROOT file will be named
pythia.root per default. This can
be changed by appending
-o ONAME on the command line.
Changing the event information
The header file
main93.h defines a simple event class and track
class, which in turn defines the information stored to the tree. If a user
wants to change this, either by adding more track information or imposing
cuts corresponding to detector acceptance (thus reducing the file size),
this can be done directly in this header file. Both the track class and the
event class has
init functions returning a boolean value, and
false, the track/event is rejected.
main93 example must be recompiled after making any changes to
the header file.
PYTHIA as a plugin to ROOT
In more ROOT-centric applications, PYTHIA can be run as a ROOT plug-in.
This requires a version of ROOT that has been
installed from source. The reason is that the interfaces depend on
PYTHIA header files that are not distributed with ROOT. Installing ROOT
is not more difficult than the PYTHIA installation, and some
guidelines are provided below.
To be run as a plugin, PYTHIA must be compiled as a shared library.
This is achieved by running the PYTHIA
--enable-shared option before
Define an environment variable for the path to your
PYTHIA installation directory
Before compiling ROOT,
configure ROOT by running the
including the following options
In case ROOT has already been compiled before, it will only recompile
the PYTHIA module and build the library
When running PYTHIA as a plugin, the exact interface structure becomes
very relevant. ROOT provides two simple interfaces (wrappers) for
PYTHIA 8. The code for these interfaces are located in
The two interfaces are
basic example for generating minimum-bias events with PYTHIA 8 inside
a ROOT macro, and filling some histograms with the kinematics of the
final-state particles is provided in either of the locations below
Note that before executing this script
The script can then be run with ROOT
After execution, ROOT will display some histograms from the event
To access the full PYTHIA functionality from the CINT interpreter,
a ROOT dictionary must be created. Currently that option has not been
implemented as a standard option for PYTHIA 8.2, but it should be in
the same spirit as what can be found in the 8.1
directory. Also note that one dictionary is found in the
This may then be loaded in ROOT giving full access to the full PYTHIA 8
functionality, e.g. in an interactive session
Pythia8::Pythia *p = new Pythia8::Pythia();
p->readString("SoftQCD:nonDiffractive = on");