class ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >


Class describing a generic LorentzVector in the 4D space-time,
using the specified coordinate system for the spatial vector part.
The metric used for the LorentzVector is (-,-,-,+).
In the case of LorentzVector we don't distinguish the concepts
of points and displacement vectors as in the 3D case,
since the main use case for 4D Vectors is to describe the kinematics of
relativistic particles. A LorentzVector behaves like a
DisplacementVector in 4D.  The Minkowski components could be viewed as
v and t, or for kinematic 4-vectors, as p and E.

@ingroup GenVector

Function Members (Methods)

public:
~LorentzVector<ROOT::Math::PxPyPzM4D<double> >()
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarBeta() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::BetaVectorBoostToCM() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarColinearRapidity() const
const ROOT::Math::PxPyPzM4D<double>&Coordinates() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarE() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalare() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalarenergy() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarEt() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarEt2() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarEta() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalareta() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarGamma() const
voidGetCoordinates(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar* dest) const
voidGetCoordinates(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar& a, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar& b, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar& c, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar& d) const
boolisLightlike(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar tolerance = 100*std::numeric_limits<Scalar>::epsilon()) const
boolisSpacelike() const
boolisTimelike() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >LorentzVector<ROOT::Math::PxPyPzM4D<double> >()
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >LorentzVector<ROOT::Math::PxPyPzM4D<double> >(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >&)
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >LorentzVector<ROOT::Math::PxPyPzM4D<double> >(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar& a, const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar& b, const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar& c, const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar& d)
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarM() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarM2() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalarmag() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalarmag2() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalarmass() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalarmass2() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarMt() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalarmt() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarMt2() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalarmt2() const
booloperator!=(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >& rhs) const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >operator*(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar& a) const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >&operator*=(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >operator+() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >operator-() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >operator/(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar& a) const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >&operator/=(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >&operator=(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >&)
booloperator==(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >& rhs) const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarP() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarP2() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarPerp2() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalarperp2() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarPhi() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalarphi() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarPt() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalarpt() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarPx() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalarpx() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarPy() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalarpy() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarPz() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalarpz() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarR() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalarr() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarRapidity() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarRho() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalarrho() const
voidSetCoordinates(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar* src)
voidSetCoordinates(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar b, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar c, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar d)
voidSetE(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
voidSetEta(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
voidSetM(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
voidSetPhi(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
voidSetPt(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
voidSetPx(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
voidSetPxPyPzE(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar x, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar y, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar z, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar t)
voidSetPy(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
voidSetPz(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
voidSetXYZT(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar x, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar y, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar z, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar t)
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarT() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalart() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarTheta() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalartheta() const
ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>Vect() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarX() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalarx() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarY() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalary() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::ScalarZ() const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalarz() const

Data Members

private:
ROOT::Math::PxPyPzM4D<double>fCoordinatesinternal coordinate system

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

LorentzVector & operator=(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >& )
 ------ assignment ------

Assignment operator from a lorentz vector of arbitrary type

SetXYZT(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar x, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar y, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar z, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar t)
fCoordinates. SetCoordinates(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar b, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar c, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar d)
const CoordSystem & Coordinates()
 ------ Set, Get, and access coordinate data ------

Retrieve a const reference to  the coordinates object

void SetCoordinates(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar* src)
Set internal data based on an array of 4 Scalar numbers

{ fCoordinates.SetCoordinates(src); }
void GetCoordinates(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar& a, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar& b, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar& c, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar& d) const
get internal data into 4 Scalar numbers

{ fCoordinates.GetCoordinates(a, b, c, d); }
void GetCoordinates(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar* dest) const
get internal data into an array of 4 Scalar numbers

{ fCoordinates.GetCoordinates(dest); }
fCoordinates. SetPxPyPzE(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar x, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar y, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar z, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar t)
bool operator==(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >& rhs) const
 ------------------- Equality -----------------

Exact equality

bool operator!=(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >& rhs) const
Scalar Px()
 ------ Individual element access, in various coordinate systems ------
 individual coordinate accessors in various coordinate systems

spatial X component

{ return fCoordinates.Px(); }
Scalar X()
spatial Y component

{ return fCoordinates.Px(); }
Scalar Py()
{ return fCoordinates.Py(); }
Scalar Y()
spatial Z component

{ return fCoordinates.Py(); }
Scalar Pz()
{ return fCoordinates.Pz(); }
Scalar Z()
return 4-th component (time, or energy for a 4-momentum vector)

{ return fCoordinates.Pz(); }
Scalar E()
{ return fCoordinates.E(); }
Scalar T()
return magnitude (mass) squared  M2 = T**2 - X**2 - Y**2 - Z**2
(we use -,-,-,+ metric)

{ return fCoordinates.E(); }
Scalar M2()
return magnitude (mass) using the  (-,-,-,+)  metric.
If M2 is negative (space-like vector) a GenVector_exception
is suggested and if continuing, - sqrt( -M2) is returned

{ return fCoordinates.M2(); }
Scalar M()
return the spatial (3D) magnitude ( sqrt(X**2 + Y**2 + Z**2) )

{ return fCoordinates.M();}
Scalar R()
{ return fCoordinates.R(); }
Scalar P()
return the square of the spatial (3D) magnitude ( X**2 + Y**2 + Z**2 )

{ return fCoordinates.R(); }
Scalar P2()
return the square of the transverse spatial component ( X**2 + Y**2 )

{ return P() * P(); }
Scalar Perp2( )
{ return fCoordinates.Perp2();}
Scalar Pt()
return the  transverse spatial component sqrt ( X**2 + Y**2 )

{ return fCoordinates.Pt(); }
Scalar Rho()
{ return fCoordinates.Pt(); }
Scalar Mt2()
return the transverse mass squared
\f[ m_t^2 = E^2 - p{_z}^2 \f]

{ return fCoordinates.Mt2(); }
Scalar Mt()
return the transverse mass
\f[ \sqrt{ m_t^2 = E^2 - p{_z}^2} X sign(E^ - p{_z}^2) \f]

{ return fCoordinates.Mt(); }
Scalar Et2()
return the transverse energy squared
\f[ e_t = \frac{E^2 p_{\perp}^2 }{ |p|^2 } \f]

{ return fCoordinates.Et2(); }
Scalar Et()
return the transverse energy
\f[ e_t = \sqrt{ \frac{E^2 p_{\perp}^2 }{ |p|^2 } } X sign(E) \f]

{ return fCoordinates.Et(); }
Scalar Phi()
azimuthal  Angle

{ return fCoordinates.Phi();}
Scalar Theta()
polar Angle

{ return fCoordinates.Theta(); }
Scalar Eta()
pseudorapidity
\f[ \eta = - \ln { \tan { \frac { \theta} {2} } } \f]

{ return fCoordinates.Eta(); }
return operator*(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar& a) const
LorentzVector<CoordinateType> v(*this);
v.Negate();
Scalar Rapidity()
 ---- Relativistic Properties ----

Rapidity relative to the Z axis:  .5 log [(E+Pz)/(E-Pz)]

Scalar ColinearRapidity()
Rapidity in the direction of travel: atanh (|P|/E)=.5 log[(E+P)/(E-P)]

bool isTimelike( )
Determine if momentum-energy can represent a physical massive particle

bool isLightlike(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar tolerance = 100*std::numeric_limits<Scalar>::epsilon()) const
Determine if momentum-energy can represent a massless particle

bool isSpacelike( )
Determine if momentum-energy is spacelike, and represents a tachyon

BetaVector BoostToCM( )
The beta vector for the boost that would bring this vector into
its center of mass frame (zero momentum)

return - Vect()
 TODO - should attempt to Throw with msg about
 boostVector computed for LorentzVector with t=0
Scalar Beta()
beta and gamma

Return beta scalar value

Scalar Gamma()
Return Gamma scalar value

Scalar x()
 Method providing limited backward name compatibility with CLHEP ----
{ return fCoordinates.Px(); }
Scalar y()
{ return fCoordinates.Py(); }
Scalar z()
{ return fCoordinates.Pz(); }
Scalar t()
{ return fCoordinates.E(); }
Scalar px()
{ return fCoordinates.Px(); }
Scalar py()
{ return fCoordinates.Py(); }
Scalar pz()
{ return fCoordinates.Pz(); }
Scalar e()
{ return fCoordinates.E(); }
Scalar theta()
{ return fCoordinates.Theta(); }
Scalar phi()
{ return fCoordinates.Phi(); }
Scalar rho()
{ return fCoordinates.Rho(); }
Scalar eta()
{ return fCoordinates.Eta(); }
Scalar pt()
{ return fCoordinates.Pt(); }
Scalar perp2()
{ return fCoordinates.Perp2(); }
Scalar mag2()
{ return fCoordinates.M2(); }
Scalar mag()
{ return fCoordinates.M(); }
Scalar mt()
{ return fCoordinates.Mt(); }
Scalar mt2()
{ return fCoordinates.Mt2(); }
Scalar energy()
 Methods  requested by CMS ---
{ return fCoordinates.E(); }
Scalar mass()
{ return fCoordinates.M(); }
Scalar mass2()
{ return fCoordinates.M2(); }
void SetE(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
Methods setting a Single-component
Work only if the component is one of which the vector is represented.
For example SetE will work for a PxPyPzE Vector but not for a PxPyPzM Vector.

{ fCoordinates.SetE (a); }
void SetEta(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
{ fCoordinates.SetEta(a); }
void SetM(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
{ fCoordinates.SetM (a); }
void SetPhi(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
{ fCoordinates.SetPhi(a); }
void SetPt(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
{ fCoordinates.SetPt (a); }
void SetPx(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
{ fCoordinates.SetPx (a); }
void SetPy(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
{ fCoordinates.SetPy (a); }
void SetPz(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> >::Scalar a)
{ fCoordinates.SetPz (a); }

Last update: root/mathcore:$Id: LorentzVector.h 21503 2007-12-19 17:34:54Z moneta $
Copyright (c) 2005 , LCG ROOT MathLib Team *

This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.