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::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(const ROOT::Math::LorentzRotation&)
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::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)
ROOT::Math::LorentzRotation&operator=(const ROOT::Math::LorentzRotation&)
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); }
explicit LorentzRotation( Boost const & b )
Construct from a pure boost

explicit LorentzRotation( Boost  const &  ) {} // TODO
explicit LorentzRotation( BoostX const &  ) {} // TODO
explicit LorentzRotation( BoostY const &  ) {} // TODO
explicit LorentzRotation( BoostZ const &  ) {} // TODO
{ 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(m); }
LorentzRotation(const Foreign4Vector& v1, const Foreign4Vector& v2, const Foreign4Vector& v3, const Foreign4Vector& v4 )
Construct from four orthosymplectic vectors (which must have methods
x(), y(), z() and t()) which will be used as the columns of the Lorentz
rotation matrix.  The orthosymplectic conditions will be checked, and
values adjusted so that the result will always be a good Lorentz rotation
matrix.
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 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.
{ SetComponents(m); return *this; }
void Rectify()
Re-adjust components to eliminate small deviations from a perfect
orthosyplectic matrix.
SetComponents(const Foreign4Vector& v1, const Foreign4Vector& v2, const Foreign4Vector& v3, const Foreign4Vector& v4 )
 ======== Components ==============

Set components from four orthosymplectic vectors (which must have methods
x(), y(), z(), and t()) which will be used as the columns of the
Lorentz rotation matrix.  The values will be adjusted
so that the result will always be a good Lorentz rotation 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()
Return inverse of  a rotation
return ! operator==(const ROOT::Math::LorentzRotation& rhs) const

Last update: root/mathcore:$Id: LorentzRotation.h 21468 2007-12-18 17:51:12Z moneta $
Copyright (c) 2005 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.