class ROOT::Math::BoostZ


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

      @ingroup GenVector

Function Members (Methods)

public:

	~BoostZ()
ROOT::Math::BoostZ::Scalar	Beta() const
ROOT::Math::BoostZ::XYZVector	BetaVector() const
ROOT::Math::BoostZ	BoostZ()
ROOT::Math::BoostZ	BoostZ(ROOT::Math::BoostZ::Scalar beta_z)
ROOT::Math::BoostZ	BoostZ(const ROOT::Math::BoostZ&)
ROOT::Math::BoostZ	BoostZ(ROOT::Math::BoostZ&&)
ROOT::Math::BoostZ::Scalar	Gamma() const
void	GetComponents(ROOT::Math::BoostZ::Scalar& beta_z) const
void	GetLorentzRotation(Scalar[] r) const
ROOT::Math::BoostZ	Inverse() const
void	Invert()
bool	operator!=(const ROOT::Math::BoostZ& rhs) const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >	operator()(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >& v) const
ROOT::Math::LorentzVector<PxPyPzE4D<double> >	operator()<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > >(const ROOT::Math::LorentzVector<PxPyPzE4D<double> >& v) const
ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >	operator()<ROOT::Math::PxPyPzE4D<double> >(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >& v) const
ROOT::Math::BoostZ&	operator=(const ROOT::Math::BoostZ&)
ROOT::Math::BoostZ&	operator=(ROOT::Math::BoostZ&&)
bool	operator==(const ROOT::Math::BoostZ& rhs) const
void	Rectify()
void	SetBeta(ROOT::Math::BoostZ::Scalar beta)
void	SetComponents(ROOT::Math::BoostZ::Scalar beta_z)

Data Members

public:

static ROOT::Math::BoostZ::ELorentzRotationMatrixIndex	kLTT
static ROOT::Math::BoostZ::ELorentzRotationMatrixIndex	kLTX
static ROOT::Math::BoostZ::ELorentzRotationMatrixIndex	kLTY
static ROOT::Math::BoostZ::ELorentzRotationMatrixIndex	kLTZ
static ROOT::Math::BoostZ::ELorentzRotationMatrixIndex	kLXT
static ROOT::Math::BoostZ::ELorentzRotationMatrixIndex	kLXX
static ROOT::Math::BoostZ::ELorentzRotationMatrixIndex	kLXY
static ROOT::Math::BoostZ::ELorentzRotationMatrixIndex	kLXZ
static ROOT::Math::BoostZ::ELorentzRotationMatrixIndex	kLYT
static ROOT::Math::BoostZ::ELorentzRotationMatrixIndex	kLYX
static ROOT::Math::BoostZ::ELorentzRotationMatrixIndex	kLYY
static ROOT::Math::BoostZ::ELorentzRotationMatrixIndex	kLYZ
static ROOT::Math::BoostZ::ELorentzRotationMatrixIndex	kLZT
static ROOT::Math::BoostZ::ELorentzRotationMatrixIndex	kLZX
static ROOT::Math::BoostZ::ELorentzRotationMatrixIndex	kLZY
static ROOT::Math::BoostZ::ELorentzRotationMatrixIndex	kLZZ
static ROOT::Math::BoostZ::EBoostMatrixIndex	kTT
static ROOT::Math::BoostZ::EBoostMatrixIndex	kXT
static ROOT::Math::BoostZ::EBoostMatrixIndex	kXX
static ROOT::Math::BoostZ::EBoostMatrixIndex	kXY
static ROOT::Math::BoostZ::EBoostMatrixIndex	kXZ
static ROOT::Math::BoostZ::EBoostMatrixIndex	kYT
static ROOT::Math::BoostZ::EBoostMatrixIndex	kYY
static ROOT::Math::BoostZ::EBoostMatrixIndex	kYZ
static ROOT::Math::BoostZ::EBoostMatrixIndex	kZT
static ROOT::Math::BoostZ::EBoostMatrixIndex	kZZ

private:

ROOT::Math::BoostZ::Scalar	fBeta	boost beta z
ROOT::Math::BoostZ::Scalar	fGamma	boost gamma

Class Charts

Inheritance Inherited Members Includes Libraries

Function documentation

BoostZ()

 ========== Constructors and Assignment =====================

      Default constructor (identity transformation)

explicit BoostZ(Scalar beta_z)

      Construct given a Scalar beta_z

{ SetComponents(beta_z); }

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::BoostZ::Scalar beta_z)

 ======== Components ==============

      Set components from a Scalar beta_z

GetComponents(ROOT::Math::BoostZ::Scalar& beta_z) const

      Get components into a Scalar beta_z

Scalar Beta() const

       Retrieve the beta of the Boost

{ return fBeta; }

Scalar Gamma() const

       Retrieve the gamma of the Boost

{ return fGamma; }

void SetBeta(ROOT::Math::BoostZ::Scalar beta)

       Set the given beta of the Boost

{ SetComponents(beta); }

XYZVector BetaVector() const

GetLorentzRotation(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

void Invert()

      Invert a BoostZ in place

BoostZ Inverse() const

      Return inverse of  a BoostZ

return ! operator==(rhs)