SETTINGS SAVED TO FILE

"; } else { echo "NO FILE SELECTED YET.. PLEASE DO SO HERE

"; } } ?>

ROOT usage

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 VINCIA add-on program for parton showers, but this should also work for a PYTHIA standalone run.

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 .dylib.


Standalone usage

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 examples directory, with details provided below. The examples assume that ROOT is installed, that you have run
 
    ./configure --with-root=root-installation-directory 
where you have to specify which is the ROOT installation directory, and subsequently run make. More fine-grained options are available with 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 link as 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 examples/main92 code provides an example of this and is comprised of the following files:
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.

Error notice

It appears that ROOTCINT cannot handle the dlfcn.h header in the current ROOT version. If you run into this problem with your ROOT installation, you could try to insert the following lines in your PythiaStdlib.h file:
 
   // Stdlib header file for dynamic library loading. 
   #ifndef __CINT__ 
   #define dlsym __ 
   #include <dlfcn.h> 
   #undef dlsym 
   #endif 



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.

Installation

To be run as a plugin, PYTHIA must be compiled as a shared library. This is achieved by running the PYTHIA configure script with the --enable-shared option before make is run.

Define an environment variable for the path to your PYTHIA installation directory
 
    export PYTHIA8=path_to_PYTHIA8_installation 
Before compiling ROOT, configure ROOT by running the configure command including the following options
 
    --enable-pythia8 
    --with-pythia8-incdir=$PYTHIA8/include/Pythia8 
    --with-pythia8-libdir=$PYTHIA8/lib 
In case ROOT has already been compiled before, it will only recompile the PYTHIA module and build the library libEGPythia8.

Interfaces

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
 
    path_to_ROOT_source/montecarlo/pythia8 

The two interfaces are

An example

A 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
 
    /path_to_ROOT_source/tutorials/pythia/pythia8.C 
    /path_to_ROOT_installation/share/doc/root/tutorials/pythia/pythia8.C 

Note that before executing this script The script can then be run with ROOT
 
    root pythia8.C 
After execution, ROOT will display some histograms from the event generation.

Advanced usage

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 rootexamples directory. Also note that one dictionary is found in the examples/main92LinkDef.h file. This may then be loaded in ROOT giving full access to the full PYTHIA 8 functionality, e.g. in an interactive session
 
    gSystem->Load("path_to_PYTHIA8_installation/rootexamples/pythiaDict"); 
    Pythia8::Pythia *p = new Pythia8::Pythia(); 
    p->readString("SoftQCD:nonDiffractive = on");