By Ivar Mathias Grøvik
The purposes of this project is to develop a alpha prototype of a visualization class within root. The main goals are developing different ways of visualization for a decay process, however due to time constraints, the focus has been reduced to drawing decay schemes for different particles, and drawing a 3d representation of a decay process involving two end particles for each decay in the chain.
The idea for this project started with me making an object class hierarchy of particles, for my own interest. I felt root could use a sort of visualization package for different particles, mainly for use in teaching or getting different particle properties if needed in calculations.
Decay processes for this project are retrieved from the Particle Physics Booklet, distributed by CERN. Due to time constraints, I've limited the 3d-modelling part of the program to decay processes involving only two daughter particles in each part of the chain, the modeling also uses several approximations, which I would have liked to remove given more time. For example, the function that calculates momentum of the two daughter particles in the source particle rest frame assumes all momentum goes in the y-direction, which gives the 3d model a "flat" look. I would have liked to include random distributions of momentum vectors, possibly with random numbers, to give each simulation its own model. A couple of formulas are used in the program.
[Definition of Four-momentum]
[Relation of total energy, rest mass and momentum]
[Lorentz transformation between two reference frames]
These are the formulas used. They are used for calculations of momentum, often in the reference frame of a source particle moving relatively to the origin, or the lab frame of reference as some like to call it.
The program combines in total 3 files, which can be found here: http://folk.uib.no/igr024/Prosjekt.tar.gz
Momentum.cpp is a class based around manipulation of momentum. Its core variables are scalars representing a momentum vector in a Cartesian coordinate system, it also contains the angles phi and theta used in the spherical coordinate system, however these are not used in the currently implemented functions. It also contains a integer called GUIColor, the reason for this is graphing. Every object with momentum has a corresponding color, implemented higher up in the class hierarchy.
Particles.cpp contains a main class Particle, which is used for all the subclasses. The particle class contains multiple functions for calculating energy-mass, getting information on momentum, energy and mass, lists with some examples of decay modes, along with methods to graph these in a decay scheme, or vectors for lab and its own rest frame, and a Lorentz matrix to transform the reference frame.
decays.cpp contains functions for manipulation of multiple objects of particles, for example listing decay schemes and drawing models.
The program in its entirety is loaded by just running root decays.cpp.
Since I’ve made a class, with functionality I thought could be useful, instead of starting a project with a clear goal, for example analyzing a dataset, I’ll list some examples of how to use my program, and I will end with some discussion and some thoughts in retrospective. I will use the Kaon class for the examples, since it is the most developed.
Listing multiple decay processes in the terminal is simple. You can either make a particle object, for example with a kaon:
Kaon *par = new Kaon();
These lines will produce the following result in the terminal:
Displaying the same results more neatly using root and latex can be done by using the drawDecayL function, which creates a GUI session interface in root.
Using the command drawDecayScheme on a KaonN object gives the following.
Please note that there are two drawTwoBodyDecay function, one called drawTwoBodyDecay2, do not use this one, as it is part of the main drawTwoBodyDecay function.
Calling the drawTwoBodyDecay with same parameters as the previous functions, either a particle object or just a string representing a particle. See either the definition of each particle class in Particles.cpp or use the function getSymbol() to see the strings.
Using the function on a KaonN particle, with specification for the negative pion to split into a negative muon and a anti muon neutrino neutrino, and the neutral pion to split into an electron and a positron yields this graph.
To make this graph, you first make a KaonN object, call the drawTwoBodyDecay(particle) function, the program then asks you to select which decays you want to model, which you select with the corresponding numbers. If a daughter particle further decays, you are asked to select which sequence you want for that particle as well.
Another example using the Tau lepton:
My initial plans for this project proved very ambitions, and in retrospective were very unrealistic for the scope of the project. Working with root was both simple and hard; at times root allowed me to easily do things which would have been difficult in just C++. For example working with matrices and vectors for the lorentz transformation. On the other hand I found at least initially that working with the 3d view was difficult. I found it difficult to draw vectors in the 3d view, resorting in the end to just draw lines between points, and having each particle have a color. If I were to start the project over again, I would have started with modeling in 2d, which would have been easier to work with, and my models essentially became anyway, due to the assumptions I had to make to make it work. The documentation provided on CERN’s website was very helpful, but was difficult to understand when I started the project, at least in my experience, but when I got more accustomed to both C and root, it quickly became my most used tool. Trying to develop a class like this has both fun and a great learning experience, and I can easily see my self using root further in my studies.
Huge thanks to both Boris Wagner and Ladislav Kocbach for both great help and tips, and also for allowing me to pursue this as a project.