ROOT logo
ROOT » MATH » GENVECTOR » ROOT::Math::LorentzRotation

class ROOT::Math::LorentzRotation


     Lorentz transformation class with the (4D) transformation represented by
     a 4x4 orthosymplectic matrix.
     See also Boost, BoostX, BoostY and BoostZ for classes representing
     specialized Lorentz transformations.
     Also, the 3-D rotation classes can be considered to be special Lorentz
     transformations which do not mix space and time components.

     @ingroup GenVector


Function Members (Methods)

public:
~LorentzRotation()
voidGetComponents(double* begin) const
voidGetComponents(ROOT::Math::LorentzRotation::Scalar& xx, ROOT::Math::LorentzRotation::Scalar& xy, ROOT::Math::LorentzRotation::Scalar& xz, ROOT::Math::LorentzRotation::Scalar& xt, ROOT::Math::LorentzRotation::Scalar& yx, ROOT::Math::LorentzRotation::Scalar& yy, ROOT::Math::LorentzRotation::Scalar& yz, ROOT::Math::LorentzRotation::Scalar& yt, ROOT::Math::LorentzRotation::Scalar& zx, ROOT::Math::LorentzRotation::Scalar& zy, ROOT::Math::LorentzRotation::Scalar& zz, ROOT::Math::LorentzRotation::Scalar& zt, ROOT::Math::LorentzRotation::Scalar& tx, ROOT::Math::LorentzRotation::Scalar& ty, ROOT::Math::LorentzRotation::Scalar& tz, ROOT::Math::LorentzRotation::Scalar& tt) const
ROOT::Math::LorentzRotationInverse() const
voidInvert()
ROOT::Math::LorentzRotationLorentzRotation()
ROOT::Math::LorentzRotationLorentzRotation(ROOT::Math::LorentzRotation const& r)
ROOT::Math::LorentzRotationLorentzRotation(ROOT::Math::Boost const& b)
ROOT::Math::LorentzRotationLorentzRotation(ROOT::Math::BoostX const& bx)
ROOT::Math::LorentzRotationLorentzRotation(ROOT::Math::BoostY const& by)
ROOT::Math::LorentzRotationLorentzRotation(ROOT::Math::BoostZ const& bz)
ROOT::Math::LorentzRotationLorentzRotation(ROOT::Math::Rotation3D const& r)
ROOT::Math::LorentzRotationLorentzRotation(ROOT::Math::AxisAngle const& a)
ROOT::Math::LorentzRotationLorentzRotation(ROOT::Math::EulerAngles const& e)
ROOT::Math::LorentzRotationLorentzRotation(ROOT::Math::Quaternion const& q)
ROOT::Math::LorentzRotationLorentzRotation(ROOT::Math::RotationX const& r)
ROOT::Math::LorentzRotationLorentzRotation(ROOT::Math::RotationY const& r)
ROOT::Math::LorentzRotationLorentzRotation(ROOT::Math::RotationZ const& r)
ROOT::Math::LorentzRotationLorentzRotation(double* begin, double* end)
ROOT::Math::LorentzRotationLorentzRotation(ROOT::Math::LorentzRotation::Scalar xx, ROOT::Math::LorentzRotation::Scalar xy, ROOT::Math::LorentzRotation::Scalar xz, ROOT::Math::LorentzRotation::Scalar xt, ROOT::Math::LorentzRotation::Scalar yx, ROOT::Math::LorentzRotation::Scalar yy, ROOT::Math::LorentzRotation::Scalar yz, ROOT::Math::LorentzRotation::Scalar yt, ROOT::Math::LorentzRotation::Scalar zx, ROOT::Math::LorentzRotation::Scalar zy, ROOT::Math::LorentzRotation::Scalar zz, ROOT::Math::LorentzRotation::Scalar zt, ROOT::Math::LorentzRotation::Scalar tx, ROOT::Math::LorentzRotation::Scalar ty, ROOT::Math::LorentzRotation::Scalar tz, ROOT::Math::LorentzRotation::Scalar tt)
booloperator!=(const ROOT::Math::LorentzRotation& rhs) const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >operator()(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >& v) const
ROOT::Math::LorentzRotationoperator*(const ROOT::Math::LorentzRotation& r) const
ROOT::Math::LorentzRotationoperator*(const ROOT::Math::Boost& b) const
ROOT::Math::LorentzRotationoperator*(const ROOT::Math::BoostX& b) const
ROOT::Math::LorentzRotationoperator*(const ROOT::Math::BoostY& b) const
ROOT::Math::LorentzRotationoperator*(const ROOT::Math::BoostZ& b) const
ROOT::Math::LorentzRotationoperator*(const ROOT::Math::Rotation3D& r) const
ROOT::Math::LorentzRotationoperator*(const ROOT::Math::AxisAngle& a) const
ROOT::Math::LorentzRotationoperator*(const ROOT::Math::EulerAngles& e) const
ROOT::Math::LorentzRotationoperator*(const ROOT::Math::Quaternion& q) const
ROOT::Math::LorentzRotationoperator*(const ROOT::Math::RotationX& rx) const
ROOT::Math::LorentzRotationoperator*(const ROOT::Math::RotationY& ry) const
ROOT::Math::LorentzRotationoperator*(const ROOT::Math::RotationZ& rz) const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >operator*(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >& v) const
ROOT::Math::LorentzRotation&operator=(ROOT::Math::LorentzRotation const& rhs)
ROOT::Math::LorentzRotation&operator=(ROOT::Math::Boost const& b)
ROOT::Math::LorentzRotation&operator=(ROOT::Math::BoostX const& b)
ROOT::Math::LorentzRotation&operator=(ROOT::Math::BoostY const& b)
ROOT::Math::LorentzRotation&operator=(ROOT::Math::BoostZ const& b)
ROOT::Math::LorentzRotation&operator=(ROOT::Math::Rotation3D const& r)
ROOT::Math::LorentzRotation&operator=(ROOT::Math::AxisAngle const& a)
ROOT::Math::LorentzRotation&operator=(ROOT::Math::EulerAngles const& e)
ROOT::Math::LorentzRotation&operator=(ROOT::Math::Quaternion const& q)
ROOT::Math::LorentzRotation&operator=(ROOT::Math::RotationZ const& r)
ROOT::Math::LorentzRotation&operator=(ROOT::Math::RotationY const& r)
ROOT::Math::LorentzRotation&operator=(ROOT::Math::RotationX const& r)
booloperator==(const ROOT::Math::LorentzRotation& rhs) const
voidRectify()
voidSetComponents(double* begin, double* end)
voidSetComponents(ROOT::Math::LorentzRotation::Scalar xx, ROOT::Math::LorentzRotation::Scalar xy, ROOT::Math::LorentzRotation::Scalar xz, ROOT::Math::LorentzRotation::Scalar xt, ROOT::Math::LorentzRotation::Scalar yx, ROOT::Math::LorentzRotation::Scalar yy, ROOT::Math::LorentzRotation::Scalar yz, ROOT::Math::LorentzRotation::Scalar yt, ROOT::Math::LorentzRotation::Scalar zx, ROOT::Math::LorentzRotation::Scalar zy, ROOT::Math::LorentzRotation::Scalar zz, ROOT::Math::LorentzRotation::Scalar zt, ROOT::Math::LorentzRotation::Scalar tx, ROOT::Math::LorentzRotation::Scalar ty, ROOT::Math::LorentzRotation::Scalar tz, ROOT::Math::LorentzRotation::Scalar tt)

Data Members

public:
enum ELorentzRotationMatrixIndex { kXX
kXY
kXZ
kXT
kYX
kYY
kYZ
kYT
kZX
kZY
kZZ
kZT
kTX
kTY
kTZ
kTT
};
private:
ROOT::Math::LorentzRotation::ScalarfM[16]

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

LorentzRotation()
 ========== Constructors and Assignment =====================

      Default constructor (identity transformation)

LorentzRotation(double* begin, double* end)
     Construct given a pair of pointers or iterators defining the
     beginning and end of an array of sixteen Scalars

{ SetComponents(begin,end); }
LorentzRotation( LorentzRotation const & r )
 The compiler-generated and dtor are OK but we have implementwd the copy-ctor and
 assignment operators since we have a template assignment

     Copy constructor

explicit LorentzRotation( Boost const & b )
     Construct from a pure boost

{ b.GetLorentzRotation( fM+0 ); }
explicit LorentzRotation( BoostX const & bx )
{ bx.GetLorentzRotation( fM+0 ); }
explicit LorentzRotation( BoostY const & by )
{ by.GetLorentzRotation( fM+0 ); }
explicit LorentzRotation( BoostZ const & bz )
{ bz.GetLorentzRotation( fM+0 ); }
explicit LorentzRotation( Rotation3D const & r )
     Construct from a 3-D rotation (no space-time mixing)

explicit LorentzRotation( AxisAngle const & a )
explicit LorentzRotation( EulerAngles const & e )
explicit LorentzRotation( Quaternion const & q )
explicit LorentzRotation( RotationX const & r )
explicit LorentzRotation( RotationY const & r )
explicit LorentzRotation( RotationZ const & r )
explicit LorentzRotation(const ForeignMatrix & m)
     Construct from a linear algebra matrix of size at least 4x4,
     which must support operator()(i,j) to obtain elements (0,3) thru (3,3).
     Precondition:  The matrix is assumed to be orthosymplectic.  NO checking
     or re-adjusting is performed.
     Note:  (0,0) refers to the XX component; (3,3) refers to the TT component.

SetComponents(ROOT::Math::LorentzRotation::Scalar xx, ROOT::Math::LorentzRotation::Scalar xy, ROOT::Math::LorentzRotation::Scalar xz, ROOT::Math::LorentzRotation::Scalar xt, ROOT::Math::LorentzRotation::Scalar yx, ROOT::Math::LorentzRotation::Scalar yy, ROOT::Math::LorentzRotation::Scalar yz, ROOT::Math::LorentzRotation::Scalar yt, ROOT::Math::LorentzRotation::Scalar zx, ROOT::Math::LorentzRotation::Scalar zy, ROOT::Math::LorentzRotation::Scalar zz, ROOT::Math::LorentzRotation::Scalar zt, ROOT::Math::LorentzRotation::Scalar tx, ROOT::Math::LorentzRotation::Scalar ty, ROOT::Math::LorentzRotation::Scalar tz, ROOT::Math::LorentzRotation::Scalar tt)
      Assign from another LorentzRotation

SetComponents(ROOT::Math::LorentzRotation::Scalar xx, ROOT::Math::LorentzRotation::Scalar xy, ROOT::Math::LorentzRotation::Scalar xz, ROOT::Math::LorentzRotation::Scalar xt, ROOT::Math::LorentzRotation::Scalar yx, ROOT::Math::LorentzRotation::Scalar yy, ROOT::Math::LorentzRotation::Scalar yz, ROOT::Math::LorentzRotation::Scalar yt, ROOT::Math::LorentzRotation::Scalar zx, ROOT::Math::LorentzRotation::Scalar zy, ROOT::Math::LorentzRotation::Scalar zz, ROOT::Math::LorentzRotation::Scalar zt, ROOT::Math::LorentzRotation::Scalar tx, ROOT::Math::LorentzRotation::Scalar ty, ROOT::Math::LorentzRotation::Scalar tz, ROOT::Math::LorentzRotation::Scalar tt)
operator=( Boost const & b )
     Assign from a pure boost

{ return operator=(LorentzRotation(b)); }
operator=( BoostX const & b )
{ return operator=(LorentzRotation(b)); }
operator=( BoostY const & b )
{ return operator=(LorentzRotation(b)); }
operator=( BoostZ const & b )
{ return operator=(LorentzRotation(b)); }
operator=( Rotation3D const & r )
     Assign from a 3-D rotation

{ return operator=(LorentzRotation(r)); }
operator=( AxisAngle const & a )
{ return operator=(LorentzRotation(a)); }
operator=( EulerAngles const & e )
{ return operator=(LorentzRotation(e)); }
operator=( Quaternion const & q )
{ return operator=(LorentzRotation(q)); }
operator=( RotationZ const & r )
{ return operator=(LorentzRotation(r)); }
operator=( RotationY const & r )
{ return operator=(LorentzRotation(r)); }
operator=( RotationX const & r )
{ return operator=(LorentzRotation(r)); }
operator=(const ForeignMatrix & m)
     Assign from a linear algebra matrix of size at least 4x4,
     which must support operator()(i,j) to obtain elements (0,3) thru (3,3).
     Precondition:  The matrix is assumed to be orthosymplectic.  NO checking
     or re-adjusting is performed.

void Rectify()
     Re-adjust components to eliminate small deviations from a perfect
     orthosyplectic matrix.

GetComponents( Foreign4Vector& v1, Foreign4Vector& v2, Foreign4Vector& v3, Foreign4Vector& v4 )
     Get components into four 4-vectors which will be the (orthosymplectic)
     columns of the rotation matrix.  (The 4-vector class must have a
     constructor from 4 Scalars used as x, y, z, t)

void GetComponents(IT begin, IT end)
     Get the 16 matrix components into data specified by an iterator begin
     and another to the end of the desired data (16 past start).

operator()(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >& v) const
 =========== operations ==============

     Lorentz transformation operation on a Minkowski ('Cartesian')
     LorentzVector

A4Vector operator*(const A4Vector & v)
     Overload operator * for rotation on a vector

void Invert()
      Invert a Lorentz rotation in place

LorentzRotation Inverse() const
      Return inverse of  a rotation

return ! operator==(rhs)