two gamma event




This page contains a few packages in C++ (tested with gcc) useful for determining the mass of the dark matter particle at the LHC. It is assumed that each event has two identical decay chains, i.e., the masses of the invisible particles and all intermediate particles are the same for the two decay chains. The strategy is to use mass shell constraints and the measured missing transverse momenta to constrain the mass space. The detailed method depends on the number of visible particles per decay chain.

(a) Three visible particles per decay chain

When each decay chain contains three visible particles, the 4-momenta of the missing particles, and therefore the masses of all particles can be directly solved for by combining two events. The references are



The code for solving the system is here. Use “tar -xvzf <filename>” to unzip. ROOT is needed for compiling. See the “README” file for instructions on how to run the code. A description of how to run a few examples is given below. A Mathematica notebook used to symbolically reduce the equation system described in the above references to a univariate polynomial equation is kept here (To use this file only–remove the “.gz” extension before using it. It is not zipped. The extension is only used to avoid conflict with the Wiki); this mathematica notebook is not needed to run the main code — it was simply used in constructing the final code.

(b) Two visible particles per decay chain

When each decay chain contains two visible particles, the missing particles' momenta can be obtained event by event if the masses are known. The solution is physical only for a restricted region in the mass space. One can utilize this fact to estimate the unknown masses. See the following references:



We also provide code that solves for the missing particles' momenta for given choices of the masses of the particles in the decay chain; this code is kept in the same place as (a), but the two can be compiled independently, and ROOT is not needed in this case. See the “README” file for instructions on how to run the code. A description on how to run a few examples is given below.

(c) One visible particle per decay chain

In this case, there are two unknown masses: the mass of the dark matter particle and that of its mother particle. The kinematic constraints divide the 2-dimensional mass space into an allowed region and a forbidden region, which are separated by the variable "MT2". See the following for a reference, which also describes a fast algorithm for calculating MT2.


The code for calculating MT2 using the algorithm is currently separate from those for the cases (a) and (b); it is available here. Please read the README file for usage.

How to run the examples

The essential code for (a) and (b) is located in the directory “WIMPMASS/src” after you download and unzip the source files. The files “topology22.cpp” and “topology33.cpp” correspond to the two topologies, which are given as subroutines without a “main” program. Examples of such main programs can be found in the “example” directory. To test these programs, you need to do the following (in a LINUX type environment with gcc installed):

1. Download the source file wimpmass-1.00.tar.gz. Do “tar -xvzf wimpmass-1.00.tar.gz”. A directory called “WIMPMASS” will be created.

2. Assuming ROOT is installed, go to the directory “WIMPMASS/src” and modify the Makefile in that directory to point to your ROOT directory. Then, go to the directory “WIMPMASS/examples” and modify the Makefile in this latter directory to point to your ROOT directory.

3. Go to the directory “WIMPMASS/”, do “make”.

4. Go to the directory “WIMPMASS/examples”. There should be two executable files generated: “example22” and “example33”, corresponding to the two topologies. Both of them read the first two events from an example LHE data file, call the corresponding routines and print out the solutions.

“example22” assumes the presence of two identical chain decays of type Y → b X → b a N in each event, and solves for the invisible particles' (the two N's) momenta assuming three trial masses (m_Y,m_X,m_N), which can be changed in example22.cpp (look for comment “trial masses”). Depending on the input m_Y, m_X and m_N, there may be no solutions, one solution, or more than one solution. In this case, the two events are analyzed one at a time and solutions are returned provided the input visible momenta for the a,b of the two chains (contained in the example LHE data file) for a given event are consistent with there being choices for the invisible momenta consistent with the input assumed masses. The number of events being analyzed can be changed by altering the loop command below comment “loop over events”. As the number of events is increased, the allowed region in m_Y,m_X,m_N space decreases and its structure can be analyzed following the procedures of the corresponding referenced papers to determine the actual masses.

“example33” assumes the presence of two identical chain decays of type Z → c Y → c b X → c b a N in each of a pair of events, and solves for the invisible particles' momenta (and common mass) for this event pair given the input visible momenta for the a,b,c particles in both events (six+six input visible momenta per pair). In this procedure, each pair of events yields as output the possible masses for the BSM particles (m_Z, m_Y, m_X and m_N) in the decay chain consistent with the input visible momenta and the presumed chain topology. Usually there is more than one possible solution. The number of events (n) employed can be increased by altering the command below comment “test the first pair of events”. The number of event pairs that will be analyzed as n is increased is n(n-1)/2. For large n, the distributions of the number of solutions as a function of each of the masses develop peaks. After employing the techniques of the corresponding referenced papers, these peaks will be close to the actual masses of Z, Y, X and N.

There is also an example in the MT2 package, which is straightforward to compile and run. To compile, do

g++ -o example mt2_bisect.cpp example.cpp

or “make” using the provided Makefile (which simply contains the above command). The executable “example” calculates MT2 for an example event, which is given in the file “example.cpp”.

If you have any questions regarding the code or find any bug, please contact Zhenyu Han at

Last Updated: May 8, 2009

wimpmass.txt · Last modified: 2009/06/18 11:43 by gunion
Recent changes RSS feed Creative Commons License Powered by PHP