class ROOT::Math::BoostX


Class representing a Lorentz Boost along the X axis, by beta.
For efficiency, gamma is held as well.

@ingroup GenVector

Function Members (Methods)

public:
~BoostX()
ROOT::Math::BoostX::ScalarBeta() const
ROOT::Math::BoostX::XYZVectorBetaVector() const
ROOT::Math::BoostXBoostX()
ROOT::Math::BoostXBoostX(ROOT::Math::BoostX::Scalar beta_x)
ROOT::Math::BoostXBoostX(const ROOT::Math::BoostX&)
ROOT::Math::BoostX::ScalarGamma() const
voidGetComponents(ROOT::Math::BoostX::Scalar& beta_x) const
voidGetLorentzRotation(ROOT::Math::BoostX::Scalar* r) const
ROOT::Math::BoostXInverse() const
voidInvert()
booloperator!=(const ROOT::Math::BoostX& rhs) const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >operator()(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >& v) const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >operator*(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >& v) const
ROOT::Math::BoostX&operator=(const ROOT::Math::BoostX&)
booloperator==(const ROOT::Math::BoostX& rhs) const
voidRectify()
voidSetBeta(ROOT::Math::BoostX::Scalar beta)
voidSetComponents(ROOT::Math::BoostX::Scalar beta_x)

Data Members

public:
enum ELorentzRotationMatrixIndex { kLXX
kLXY
kLXZ
kLXT
kLYX
kLYY
kLYZ
kLYT
kLZX
kLZY
kLZZ
kLZT
kLTX
kLTY
kLTZ
kLTT
};
enum EBoostMatrixIndex { kXX
kXY
kXZ
kXT
kYY
kYZ
kYT
kZZ
kZT
kTT
};
private:
ROOT::Math::BoostX::ScalarfBetaboost beta X
ROOT::Math::BoostX::ScalarfGammaboost gamma

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

BoostX()
 ========== Constructors and Assignment =====================

Default constructor (identity transformation)

explicit BoostX(Scalar beta_x)
Construct given a Scalar beta_x

{ SetComponents(beta_x); }
void Rectify()
 The compiler-generated copy ctor, copy assignment, and dtor are OK.

Re-adjust components to eliminate small deviations from a perfect
orthosyplectic matrix.

SetComponents(ROOT::Math::BoostX::Scalar beta_x)
 ======== Components ==============

Set components from a Scalar beta_x

GetComponents(ROOT::Math::BoostX::Scalar& beta_x) const
Get components into a Scalar beta_x

Scalar Beta()
Retrieve the beta of the Boost

{ return fBeta; }
Scalar Gamma()
Retrieve the gamma of the Boost

{ return fGamma; }
void SetBeta(ROOT::Math::BoostX::Scalar beta)
Set the given beta of the Boost

{ SetComponents(beta); }
XYZVector BetaVector()
GetLorentzRotation(ROOT::Math::BoostX::Scalar* r) const
Get elements of internal 4x4 symmetric representation, into a data
array suitable for direct use as the components of a LorentzRotation
Note -- 16 Scalars will be written into the array; if the array is not
that large, then this will lead to undefined behavior.

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

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

A4Vector operator*(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >& v) const
Overload operator * for operation on a vector

void Invert()
Invert a BoostX in place

BoostX Inverse()
Return inverse of  a boost

return ! operator==(const ROOT::Math::BoostX& rhs) const

Last update: root/mathcore:$Id: BoostX.h 21503 2007-12-19 17:34:54Z moneta $
Copyright (c) 2005 ROOT FNAL 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.