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::Scalar	Gamma() const
void	GetComponents(ROOT::Math::BoostZ::Scalar& beta_z) const
void	GetLorentzRotation(ROOT::Math::BoostZ::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<ROOT::Math::PxPyPzE4D<double> >	operator*(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >& v) const
ROOT::Math::BoostZ&	operator=(const 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

private:

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::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(ROOT::Math::BoostZ::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 boost on a vector

void Invert()

      Invert a BoostZ in place

BoostZ Inverse() const

      Return inverse of  a BoostZ

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