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

 ------ assignment ------

Assignment operator from a lorentz vector of arbitrary type

 ------ Set, Get, and access coordinate data ------

Retrieve a const reference to  the coordinates object

Set internal data based on an array of 4 Scalar numbers

get internal data into 4 Scalar numbers

get internal data into an array of 4 Scalar numbers

 ------------------- Equality -----------------

Exact equality

 ------ Individual element access, in various coordinate systems ------
 individual coordinate accessors in various coordinate systems

spatial X component

spatial Y component

spatial Z component

return 4-th component (time, or energy for a 4-momentum vector)

return magnitude (mass) squared  M2 = T**2 - X**2 - Y**2 - Z**2
(we use -,-,-,+ metric)

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 the spatial (3D) magnitude ( sqrt(X**2 + Y**2 + Z**2) )

return the square of the spatial (3D) magnitude ( X**2 + Y**2 + Z**2 )

return the square of the transverse spatial component ( X**2 + Y**2 )

return the  transverse spatial component sqrt ( X**2 + Y**2 )

return the transverse mass squared
\f[ m_t^2 = E^2 - p{_z}^2 \f]

return the transverse mass
\f[ \sqrt{ m_t^2 = E^2 - p{_z}^2} X sign(E^ - p{_z}^2) \f]

return the transverse energy squared
\f[ e_t = \frac{E^2 p_{\perp}^2 }{ |p|^2 } \f]

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

azimuthal  Angle

polar Angle

pseudorapidity
\f[ \eta = - \ln { \tan { \frac { \theta} {2} } } \f]

 ------ Operations combining two Lorentz vectors ------

scalar (Dot) product of two LorentzVector vectors (metric is -,-,-,+)
Enable the product using any other LorentzVector implementing
the x(), y() , y() and t() member functions
\param  q  any LorentzVector implementing the x(), y() , z() and t()
member functions
\return the result of v.q of type according to the base scalar type of v

LorentzVector<CoordinateType> v(*this);
v.Negate();

 ---- Relativistic Properties ----

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

 TODO - It would be good to check that E > Pz and use the Throw()
        mechanism or at least load a NAN if not.
        We should then move the code to a .cpp file.

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

 TODO - It would be good to check that E > Pz and use the Throw()
        mechanism or at least load a NAN if not.

Determine if momentum-energy can represent a physical massive particle

Determine if momentum-energy can represent a massless particle

Determine if momentum-energy is spacelike, and represents a tachyon

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

 TODO - should attempt to Throw with msg about
 boostVector computed for LorentzVector with t=0

beta and gamma

Return beta scalar value

Return Gamma scalar value

 ---- Limited backward name compatibility with CLHEP ----

requested by CMS

Single-component update