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


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::LorentzVector >::Scalar Beta() const ROOT::Math::LorentzVector >::BetaVector BoostToCM() const ROOT::Math::LorentzVector >::Scalar ColinearRapidity() const const ROOT::Math::PxPyPzM4D& Coordinates() const ROOT::Math::LorentzVector >::Scalar E() const ROOT::Math::LorentzVector >::Scalar e() const ROOT::Math::LorentzVector >::Scalar energy() const ROOT::Math::LorentzVector >::Scalar Et() const ROOT::Math::LorentzVector >::Scalar Et2() const ROOT::Math::LorentzVector >::Scalar Eta() const ROOT::Math::LorentzVector >::Scalar eta() const ROOT::Math::LorentzVector >::Scalar Gamma() const void GetCoordinates(ROOT::Math::LorentzVector >::Scalar* dest) const void GetCoordinates(ROOT::Math::LorentzVector >::Scalar& a, ROOT::Math::LorentzVector >::Scalar& b, ROOT::Math::LorentzVector >::Scalar& c, ROOT::Math::LorentzVector >::Scalar& d) const bool isLightlike(ROOT::Math::LorentzVector >::Scalar tolerance = 100*std::numeric_limits::epsilon()) const bool isSpacelike() const bool isTimelike() const ROOT::Math::LorentzVector > LorentzVector >() ROOT::Math::LorentzVector > LorentzVector >(const ROOT::Math::LorentzVector >&) ROOT::Math::LorentzVector > LorentzVector >(const ROOT::Math::LorentzVector >::Scalar& a, const ROOT::Math::LorentzVector >::Scalar& b, const ROOT::Math::LorentzVector >::Scalar& c, const ROOT::Math::LorentzVector >::Scalar& d) ROOT::Math::LorentzVector >::Scalar M() const ROOT::Math::LorentzVector >::Scalar M2() const ROOT::Math::LorentzVector >::Scalar mag() const ROOT::Math::LorentzVector >::Scalar mag2() const ROOT::Math::LorentzVector >::Scalar mass() const ROOT::Math::LorentzVector >::Scalar mass2() const ROOT::Math::LorentzVector >::Scalar Mt() const ROOT::Math::LorentzVector >::Scalar mt() const ROOT::Math::LorentzVector >::Scalar Mt2() const ROOT::Math::LorentzVector >::Scalar mt2() const bool operator!=(const ROOT::Math::LorentzVector >& rhs) const ROOT::Math::LorentzVector > operator*(const ROOT::Math::LorentzVector >::Scalar& a) const ROOT::Math::LorentzVector >& operator*=(ROOT::Math::LorentzVector >::Scalar a) ROOT::Math::LorentzVector > operator+() const ROOT::Math::LorentzVector > operator-() const ROOT::Math::LorentzVector > operator/(const ROOT::Math::LorentzVector >::Scalar& a) const ROOT::Math::LorentzVector >& operator/=(ROOT::Math::LorentzVector >::Scalar a) ROOT::Math::LorentzVector >& operator=(const ROOT::Math::LorentzVector >&) bool operator==(const ROOT::Math::LorentzVector >& rhs) const ROOT::Math::LorentzVector >::Scalar P() const ROOT::Math::LorentzVector >::Scalar P2() const ROOT::Math::LorentzVector >::Scalar Perp2() const ROOT::Math::LorentzVector >::Scalar perp2() const ROOT::Math::LorentzVector >::Scalar Phi() const ROOT::Math::LorentzVector >::Scalar phi() const ROOT::Math::LorentzVector >::Scalar Pt() const ROOT::Math::LorentzVector >::Scalar pt() const ROOT::Math::LorentzVector >::Scalar Px() const ROOT::Math::LorentzVector >::Scalar px() const ROOT::Math::LorentzVector >::Scalar Py() const ROOT::Math::LorentzVector >::Scalar py() const ROOT::Math::LorentzVector >::Scalar Pz() const ROOT::Math::LorentzVector >::Scalar pz() const ROOT::Math::LorentzVector >::Scalar R() const ROOT::Math::LorentzVector >::Scalar r() const ROOT::Math::LorentzVector >::Scalar Rapidity() const ROOT::Math::LorentzVector >::Scalar Rho() const ROOT::Math::LorentzVector >::Scalar rho() const void SetCoordinates(const ROOT::Math::LorentzVector >::Scalar* src) void SetCoordinates(ROOT::Math::LorentzVector >::Scalar a, ROOT::Math::LorentzVector >::Scalar b, ROOT::Math::LorentzVector >::Scalar c, ROOT::Math::LorentzVector >::Scalar d) void SetE(ROOT::Math::LorentzVector >::Scalar a) void SetEta(ROOT::Math::LorentzVector >::Scalar a) void SetM(ROOT::Math::LorentzVector >::Scalar a) void SetPhi(ROOT::Math::LorentzVector >::Scalar a) void SetPt(ROOT::Math::LorentzVector >::Scalar a) void SetPx(ROOT::Math::LorentzVector >::Scalar a) void SetPxPyPzE(ROOT::Math::LorentzVector >::Scalar x, ROOT::Math::LorentzVector >::Scalar y, ROOT::Math::LorentzVector >::Scalar z, ROOT::Math::LorentzVector >::Scalar t) void SetPy(ROOT::Math::LorentzVector >::Scalar a) void SetPz(ROOT::Math::LorentzVector >::Scalar a) void SetXYZT(ROOT::Math::LorentzVector >::Scalar x, ROOT::Math::LorentzVector >::Scalar y, ROOT::Math::LorentzVector >::Scalar z, ROOT::Math::LorentzVector >::Scalar t) ROOT::Math::LorentzVector >::Scalar T() const ROOT::Math::LorentzVector >::Scalar t() const ROOT::Math::LorentzVector >::Scalar Theta() const ROOT::Math::LorentzVector >::Scalar theta() const ROOT::Math::DisplacementVector3D,ROOT::Math::DefaultCoordinateSystemTag> Vect() const ROOT::Math::LorentzVector >::Scalar X() const ROOT::Math::LorentzVector >::Scalar x() const ROOT::Math::LorentzVector >::Scalar Y() const ROOT::Math::LorentzVector >::Scalar y() const ROOT::Math::LorentzVector >::Scalar Z() const ROOT::Math::LorentzVector >::Scalar z() const

Data Members

private:
 ROOT::Math::PxPyPzM4D fCoordinates internal coordinate system

Function documentation

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

Assignment operator from a lorentz vector of arbitrary type


SetXYZT(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<Double32_t> >::Scalar x, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<Double32_t> >::Scalar y, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<Double32_t> >::Scalar z, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<Double32_t> >::Scalar t)
fCoordinates. SetCoordinates(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<Double32_t> >::Scalar a, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<Double32_t> >::Scalar b, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<Double32_t> >::Scalar c, ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<Double32_t> >::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<Double32_t> >::Scalar* src)
Set internal data based on an array of 4 Scalar numbers


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


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


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

Exact equality


bool operator!=(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<Double32_t> >& 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<Double32_t> >::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<Double32_t> >::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<Double32_t> >::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<Double32_t> >::Scalar a)
{ fCoordinates.SetEta(a); }
void SetM(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<Double32_t> >::Scalar a)
{ fCoordinates.SetM (a); }
void SetPhi(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<Double32_t> >::Scalar a)
{ fCoordinates.SetPhi(a); }
void SetPt(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<Double32_t> >::Scalar a)
{ fCoordinates.SetPt (a); }
void SetPx(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<Double32_t> >::Scalar a)
{ fCoordinates.SetPx (a); }
void SetPy(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<Double32_t> >::Scalar a)
{ fCoordinates.SetPy (a); }
void SetPz(ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<Double32_t> >::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.