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::Scalar	Beta() const
ROOT::Math::BoostX::XYZVector	BetaVector() const
ROOT::Math::BoostX	BoostX()
ROOT::Math::BoostX	BoostX(ROOT::Math::BoostX::Scalar beta_x)
ROOT::Math::BoostX	BoostX(const ROOT::Math::BoostX&)
ROOT::Math::BoostX::Scalar	Gamma() const
void	GetComponents(ROOT::Math::BoostX::Scalar& beta_x) const
void	GetLorentzRotation(ROOT::Math::BoostX::Scalar* r) const
ROOT::Math::BoostX	Inverse() const
void	Invert()
bool	operator!=(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&)
bool	operator==(const ROOT::Math::BoostX& rhs) const
void	Rectify()
void	SetBeta(ROOT::Math::BoostX::Scalar beta)
void	SetComponents(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::Scalar	fBeta	boost beta X
ROOT::Math::BoostX::Scalar	fGamma	boost gamma

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); }

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