Transverse mass calculaton with TLorentzVector gives wrong results

Hi all,
I have the following question: Why does the .Mt() value from TLorentzVector give me a different result for the mass distribution of the W boson than the known short formula for 2 leptons? The formula gives me a peak at around 80 GeV which is correct, but the value from the TLorentzVector gives me a peak at around 130 GeV. This is the code I have:

   int n_el = el_pt.GetSize();
   for (int i=0; i < n_el; i++){
		if(el_pt[i]/1000 > 27 && *met_met/1000 > 30){	     
   		TLorentzVector P_elec;
		 TLorentzVector P_neut;
                 P_elec.SetPtEtaPhiM(el_pt[i]/1000, el_eta[i], el_phi[i], 0);         //pt in GeV
      	         P_neut.SetPtEtaPhiM(*met_met/1000, 0, *met_phi, 0);  

                //Calculation of W_mT
                Double_t deltaPhi = TMath::Abs(el_phi[i] - *met_phi); 
                Double_t CosdeltaPhi = TMath::Cos(deltaPhi);

                 Double_t W_mT _1= TMath::Sqrt(2.0 * el_pt[i]/1000 * (*met_met)/1000 * (1.0 - CosdeltaPhi));  
		 Double_t W_mT_2 = (P_elec + P_neut).Mt();
      }
   }

Thanks!

Hi @helton ,

Maybe @moneta has a clue about this.

Cheers,
Vincenzo

Hi,
You are referring to 2 different definitions, see for example: Transverse mass - Wikipedia

TLorentzVector and the recomended to use ROOT::Math::LorentzVector returns as Mt the transverse mass of a particle defined as sqrt(M2 + Pt2), and it is always greater than M, while the other formula computes the transverse mass of a 2 -particle system, which is a different definition as shown in the linked Wikipedia article.

Best regards,

Lorenzo

Hi Lorenzo,

I see, thanks for the clarification. Since only the second formula gives me the “right” result (aka the right mass) I wonder; If I wanted to calculate the transverse mass where say a lepton, neutrino and a jet or so are involved, so in total 3 “particles”, I cant really analytically calculate a formula like in the 2 particle case. What do I do then?

Greetings

The second formula is used when you have invisible decays (e.g. W decays) and you have then a quantity that is sensible to the mass of the original particle (W). I guess you can probably build a similar formula in case of a 3 body decays, but I don’t know the analytical form/

Best,

Lorenzo

When I try to use LorentzVector instead of TLorentzVector I get a weird error in the header files that it cant find for example #include <Math/Vector4D.h> or Math/GenVector/PxPyPzE4D.h’. Are these outdated headers?

I am using ROOT 6.24/08 on a analysis facility for ATLAS so it should be setup correctly

Greetings

HI,
This is strange, the headers should be installed as the other ROOT headers. How are you building the code ?

Lorenzo

Not sure if I understand the question. But I made a file with MakeSelector(). But doesnt matter if I add it in the .h or the .C file it doesnt seem to find it.

Greetings

Nut how are you compiling the code made from MakeSelector() ? Or are you using the code directly from the ROOT prompt ? In this last case you don’t need to add any include files

Lorenzo

I just save the .C file and run it with ->Process(… .C) from the prompt

Greetings

Hi,
Ah I see, this is an old way to process a TTree. But what is happening if you are just doing at the ROOT prompt:

root [1]  #include "Math/Vector4D.h"

?

Hi,

even when I do that it gives me: ROOT_prompt_3:1:10: fatal error: ‘Math/Vector4D.h’ file not found
#include “Math/Vector4D.h”

Strange, which ROOT version are you using ?

I am using ROOT 6.24/08

Hi,

I worked through the neutrino longitudinal-momentum reconstruction discussed in this thread and implemented a complete reproducible treatment of the problem.

For the decay

W \rightarrow \mu\nu,

the measured transverse missing momentum determines the transverse neutrino components,

p_x^\nu=p_T^\nu\cos\phi_\nu, \qquad p_y^\nu=p_T^\nu\sin\phi_\nu,

while the longitudinal component p_z^\nu remains unknown.

Imposing the fixed-W-mass constraint

(p_\mu+p_\nu)^2=M_W^2

reduces the problem to a quadratic equation for p_z^\nu.

Define

A= \frac{M_W^2-m_\mu^2}{2} + \vec p_T^{\,\mu}\cdot\vec p_T^{\,\nu},

and

E_{T\mu}^2=m_\mu^2+(p_T^\mu)^2.

Then the two longitudinal solutions are

p_{z\nu}^{\pm} = \frac{ A\,p_{z\mu} \pm E_\mu \sqrt{ A^2-E_{T\mu}^2(p_T^\nu)^2 } }{ E_{T\mu}^2 }.

The corresponding reduced discriminant is

D= A^2-E_{T\mu}^2(p_T^\nu)^2.

The useful part is that this discriminant can be factorized directly through the transverse mass:

D= \frac14 \left(M_W^2-m_T^2\right) \left[ M_W^2-m_T^2+ 4E_{T\mu}p_T^\nu \right].

For the physical domain of the reconstruction, the second factor is positive, so the complete real-solution structure follows directly from m_T:

m_T<M_W \quad\Longrightarrow\quad D>0 \quad\Longrightarrow\quad 2\ \text{real }p_z^\nu\text{ solutions},
m_T=M_W \quad\Longrightarrow\quad D=0 \quad\Longrightarrow\quad 1\ \text{tangent/repeated solution},
m_T>M_W \quad\Longrightarrow\quad D<0 \quad\Longrightarrow\quad 0\ \text{real solutions under the exact fixed-mass constraint}.

An important implementation detail is that I retain both real longitudinal branches rather than silently selecting one of them.

Each returned solution is also checked against the original unsquared equation,

E_\mu \sqrt{(p_T^\nu)^2+(p_z^\nu)^2} - p_{z\mu}p_z^\nu = A,

rather than validating the roots only against the squared quadratic equation.

This also gives a precise interpretation of the negative-discriminant case: D<0 does not by itself mean that the recorded event is unphysical. It means that the measured transverse state is incompatible with the selected exact fixed-W-mass constraint for every real value of p_z^\nu.

I tested the implementation over the complete 100,000-event CMS Open Data W\rightarrow\mu\nu sample.

Using M_W=80.3625 GeV, the reconstruction classified:

  • 88,243 events with two real longitudinal neutrino solutions;
  • 0 events inside the numerical tangent band;
  • 11,757 events with no real longitudinal solution under the exact fixed-mass constraint.

The implementation also includes regression tests, direct mass-shell checks, numerical treatment near the discriminant boundary, stable evaluation of the quadratic roots, and a separate high-precision verification.

The complete implementation and reproduction material are publicly available in my GitHub repository named:

Neutrino-Longitudinal-Momentum-Reconstruction

Independent technical review, reproduction, or criticism of the derivation and numerical treatment is welcome.