Logo ROOT  
Reference Guide
No Matches
LorentzVector Classes

To avoid exposing templated parameter to the users, typedefs are defined for all types of vectors based an double's and float's. To use them, one must include the header file Math/Vector4D.h. The following typedef's, defined in the header file Math/Vector4Dfwd.h, are available for the different instantiations of the template class ROOT::Math::LorentzVector:

The metric used for all the LorentzVector's is (-,-,-,+)

Constructors and Assignment

The following declarations are available:

XYZTVector v1; // create an empty vector (x = 0, y = 0, z = 0, t = 0)
XYZTVector v2(1,2,3,4); // create a vector with x=1, y = 2, z = 3, t = 4
PtEtaPhiEVector v3(1,2,PI,5); // create a vector with pt = 1, eta = 2, phi = PI, E = 5

Note that each type of vector is constructed by passing its coordinates representations, so a XYZTVector(1,2,3,4) is different from a PtEtaPhiEVector(1,2,3,4).

In addition the Vector classes can be constructed by any vector, which implements the accessors x(), y() and z() and t(). This cann be another ROOT::Math::LorentzVector based on a different coordinate system or even any vector of a different package, like the CLHEP HepLorentzVector that implements the required signature.

XYZTVector v1(1,2,3,4);
PtEtaPhiEVector v2(v1);
CLHEP::HepLorentzVector q(1,2,3,4);
XYZTVector v3(q)

Coordinate Accessors

All the same coordinate accessors are available through the interface of the class ROOT::Math::LorentzVector. For example:

v1.X(); v1.X(); v1.Z(); v1.T() // returns cartesian components for the cartesian vector v1
v2.Px(); v2.Py(); v2.Pz(); v2.E() // returns cartesian components for the cylindrical vector v2
v1.Pt(); v1.Eta(); v1.Phi(); v1.M() // returns other components for the cartesian vector v1

In addition, all the 4 coordinates of the vector can be retrieved with the GetCoordinates method:

double d[4];
v1.GetCoordinates(d); // fill d array with (x,y,z,t) components of v1
v2.GetCoordinates(d); // fill d array with (pt,eta,phi,e) components of v2
std::vector w(4);
v1.GetCoordinates(w.begin(),w.end()); // fill std::vector with (x,y,z,t) components of v1

To get information on all the coordinate accessors see the reference documentation of ROOT::Math::LorentzVector

Setter Methods

One can set only all the three coordinates via:

v1.SetCoordinates(c1,c2,c3,c4); // sets the (x,y,z,t) for a XYZTVector
v2.SetCoordinates(c1,c2,c3,c4); // sets pt,eta,phi,e for a PtEtaPhiEVector
v2.SetXYZ(x,y,z,t); // sets the 4 cartesian components for the PtEtaPhiEVector

Single coordinate setter methods are available for the basic vector coordinates, like SetX() for a XYZTVector or SetPt() for a PtEtaPhiEVector. Attempting to do a SetX() on a non cartesian vector will not compile.

XYZTVector v1; v1.SetX(1) // OK setting x for a cartesian vector
PtEtaPhiEVector v2; v2.SetX(1) // ERROR: cannot set X for a non-cartesian vector. Method will not compile
v2.SetR(1) // OK setting Pt for a PtEtaPhiEVector vector

In addition there are setter methods from C arrays or iterators.

double d[4] = {1.,2.,3.,4.};
XYZTVector v;
v.SetCoordinates(d); // set (x,y,z,t) components of v using values from d

or for example from an std::vector using the iterators

std::vector w(4);
v.SetCoordinates(w.begin(),w.end()); // set (x,y,z,t) components of v using values from w

Arithmetic Operations

The following operations are possible between LorentzVectors classes, even of different coordinate system types: ( v and w are two LorentzVector of the same type, q is a generic LorentzVector implementing x(), y(), z() and t() and a is a generic scalar type: double, flot, int, etc.... )

v += q;
v -= q;
v = -q;
v *= a;
v /= a;
w = v + q;
w = v - q;
w = v * a;
w = a * v;
w = v / a;


v == w;
v != w;

Other Methods

a = v.Dot(q); // dot product in metric (+,+,+,-) of two LorentzVector's
XYZVector s = v.Vect() // return the spatial components (x,y,z)
v.Beta(); // return beta and gamma value
v.Gamma() // (vector must be time-like otherwise result is meaningless)
XYZVector b = v.BoostToCM() // return boost vector which will bring the Vector in its mas frame (P=0)