A snapshot of Pluto


Pluto is a collection of C++ classes, adding up to the framework of a simulation package for hadronic-physics reactions.  It is launched interactively from within the ROOT environment, and makes use of ROOT only, without requiring additional packages. The focus is on streamlining particle generators by providing the tools to set up and manipulate particles, reaction channels, and complex reactions, as well as apply experimental filters on the reaction products, such as geometrical acceptance and kinematical conditions. Typical simulations may be executed with a few lines of input, with no expertise required on the part of the user. The output  may be analyzed on line, or further processed with GEANT. The package includes models for resonance and Dalitz decays, resonance spectral functions with mass-dependent widths, and anisotropic angular distributions for selected channels. A decay-manager interface enables multi-step ("cocktail") calculations. An extensive particle data base is available, with capabilities to support up to 999 particles, including user-defined ones. Particle properties and decay modes are included in the data base. Thermal distributions are implemented, enabling multi-hadron decays of hot fireballs.

The general philosophy of Pluto is that on one hand the users should be able to drive the package in a very easy way, but on the other hand are allowed to customize it without any restiction. This means that the user can gain control to add new decays/paticles among with new models up to the writing of plugins/mods.  

Figure 1:  PLUTO structure

pluto_at_a_glance.png (88128 bytes)

The structure and design of Pluto is sketched in the figure above: the orange boxes show the user classes to set up and handle reaction (and decay channels), they start and control the event loop. The yellow box is the interface for accessing the particle stream while the event loop is running, providing a lot of useful features. The boxes shaded in blue represent the data base for the particles and dacays among with a user interface for customization. The light blue boxes are the distribution interface and the physics models, the first one allows to add and/or select physics cases, the models can be either build-in models and runtime replacements. This area of Pluto works even outside the event loop for the calculation of parameters (mass distributions, decay widths,...)


Pluto is designed as an experimentalist's tool (not only) for the HADES Collaboration. It standardizes simulations by providing a common platform that is accessible via the analysis environment (ROOT), with a straightforward user interface that does not inhibit non-experts in simulations. It is a modular and reusable package that can support additional features. A common tool for simulations may facilitate acceptance studies for the detectors comprising the HADES spectrometer, and make feasible comparisons of results obtained by different detector groups. At the same time it is a high-level analysis tool, that, after tracking and particle identification, is useful in the recognition of the physical processes in experimental spectra.


To illustate a simulation with Pluto, a proton-proton reaction with a kinetic energy T=3.5 GeV is considered as an example, the decay steps (channels ) are created with the decay parser in background. In the conventions of Pluto a Channel is a step in a reaction, and a Reaction is a complete process. The output will be written to the file "eta_dalitz", which might be further analyzed. To show some the (optional) features, a TNtuple, a filter and a histrogram are created in addition. A Filter applies physical constraints on any Particle of a Reaction, before the event tree is written to disk. In our case, an event is accepted if both the electron and the positron are produced with polar angles in the range of 18 to 85 degree. The used batch language is based on the ROOT TFormula class, combined with some additional features like the creation of (composite) particles, the access to their getter methods and conditional executions.

The sequence shown below, executed from an interactive ROOT session on a typical linux PC, generates 100k events in around 10 seconds (CPU time). Output is stored for the decay products in a ROOT files (ASCII optional for use as input to GEANT). Some comments sketch the actions induced by the command lines. Details may be found in the Pluto tutorials.

//Create a file for the NTuple:
TFile *f = new TFile("ntuple.root", "RECREATE");

//Create an NTuple with several variables:
TNtuple *ntuple = new TNtuple("ntuple", "data from Pluto events", "eta_px:eta_py:eta_pz:opang");

//Create a control histo:
TH1F * histo1 = new TH1F ("histo1","dilepton mass with opening angle < 9deg",100,0.0,0.7);

//Define the reaction: pp -> pp eta at 3.5 kinetic beam energy:
PReaction my_reaction("3.5","p","p", "p p eta [g dilepton [e+ e-]]","eta_dalitz");

//Inline calculating of a variable (here: Theta of e+ in degree):
my_reaction.Do("theta_ep = ([e+]->Theta() * 180.)/TMath::Pi()");
//...same for e-:
my_reaction.Do("theta_em = ([e-]->Theta() * 180.)/TMath::Pi()");

//Example of a reaction filter: Put a # in front of the variable name:
my_reaction.Do("#filter = 1; if theta_ep<18 || theta_ep>85 || theta_em<18 || theta_em>85; #filter = 0");

//Calculate the variables for the NTuple:
my_reaction.Do("eta_px = [eta]->Px() ; eta_py = [eta]->Py() ; eta_pz = [eta]->Pz();");

//Opening angle in lab frame:
my_reaction.Do("opang = [e+]->Angle([e-])");

//The NTuple should be written here:

//The (conditional) histogram. Prepare the axis (_x)
my_reaction.Do(histo1,"if opang > (9./180.)*TMath::Pi(); _x = ([e+] + [e-])->M()");

//Run event loop: