ROOT::Math::Boost

ROOT::Math::Boost::Scalar	fM[10]

void SetIdentity()

 set identity boost

void SetComponents(ROOT::Math::Boost::Scalar beta_x, ROOT::Math::Boost::Scalar beta_y, ROOT::Math::Boost::Scalar beta_z)

 set the boost beta as 3 components

void GetComponents(ROOT::Math::Boost::Scalar& beta_x, ROOT::Math::Boost::Scalar& beta_y, ROOT::Math::Boost::Scalar& beta_z) const

 get beta of the boots as 3 components

BetaVector()

 get boost beta vector

void GetLorentzRotation(ROOT::Math::Boost::Scalar* r) const

 get Lorentz rotation corresponding to this boost as an array of 16 values

void Rectify()

 Assuming the representation of this is close to a true Lorentz Rotation,
 but may have drifted due to round-off error from many operations,
 this forms an "exact" orthosymplectic matrix for the Lorentz Rotation
 again.

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

 apply bosost to a PxPyPzE LorentzVector

void Invert()

 invert in place boost (modifying the object)

Boost Inverse()

 return inverse of boost

Boost()

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

Default constructor (identity transformation)

{ SetIdentity(); }

Boost(ROOT::Math::Boost::Scalar beta_x, ROOT::Math::Boost::Scalar beta_y, ROOT::Math::Boost::Scalar beta_z)

Construct given a three Scalars beta_x, beta_y, and beta_z

{ SetComponents(beta_x, beta_y, beta_z); }

Boost(const Avector & beta)

Construct given a beta vector (which must have methods x(), y(), z())

{ SetComponents(beta); }

Boost(double* begin, double* end)

Construct given a pair of pointers or iterators defining the
beginning and end of an array of three Scalars to use as beta_x, _y, and _z

{ SetComponents(begin,end); }

explicit Boost( BoostX const & bx )

Construct from an axial boost

{SetComponents(bx.BetaVector());}

explicit Boost( BoostY const & by )

{SetComponents(by.BetaVector());}

explicit Boost( BoostZ const & bz )

{SetComponents(bz.BetaVector());}

operator=( BoostX const & bx )

 The compiler-generated copy ctor, copy assignment, and dtor are OK.

Assign from an axial pure boost

{ return operator=(Boost(bx)); }

operator=( BoostY const & by )

{ return operator=(Boost(by)); }

operator=( BoostZ const & bz )

{ return operator=(Boost(bz)); }

SetComponents(ROOT::Math::Boost::Scalar beta_x, ROOT::Math::Boost::Scalar beta_y, ROOT::Math::Boost::Scalar beta_z)

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

Set components from beta_x, beta_y, and beta_z

GetComponents(ROOT::Math::Boost::Scalar& beta_x, ROOT::Math::Boost::Scalar& beta_y, ROOT::Math::Boost::Scalar& beta_z) const

Get components into beta_x, beta_y, and beta_z

SetComponents(const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& beta)

Set components from a beta vector

{ SetComponents(beta.x(), beta.y(), beta.z()); }

A4Vector operator*(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >& v) const

Overload operator * for boost on a vector

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

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

class ROOT::Math::Boost

Function Members (Methods)

Data Members

Class Charts

Function documentation

	~Boost()
ROOT::Math::Boost::XYZVector	BetaVector() const
ROOT::Math::Boost	Boost()
ROOT::Math::Boost	Boost(ROOT::Math::BoostX const& bx)
ROOT::Math::Boost	Boost(ROOT::Math::BoostY const& by)
ROOT::Math::Boost	Boost(ROOT::Math::BoostZ const& bz)
ROOT::Math::Boost	Boost(const ROOT::Math::Boost&)
ROOT::Math::Boost	Boost(double* begin, double* end)
ROOT::Math::Boost	Boost(ROOT::Math::Boost::Scalar beta_x, ROOT::Math::Boost::Scalar beta_y, ROOT::Math::Boost::Scalar beta_z)
void	GetComponents(double* begin) const
void	GetComponents(ROOT::Math::Boost::Scalar& beta_x, ROOT::Math::Boost::Scalar& beta_y, ROOT::Math::Boost::Scalar& beta_z) const
void	GetLorentzRotation(ROOT::Math::Boost::Scalar* r) const
ROOT::Math::Boost	Inverse() const
void	Invert()
bool	operator!=(const ROOT::Math::Boost& 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::Boost&	operator=(ROOT::Math::BoostX const& bx)
ROOT::Math::Boost&	operator=(ROOT::Math::BoostY const& by)
ROOT::Math::Boost&	operator=(ROOT::Math::BoostZ const& bz)
ROOT::Math::Boost&	operator=(const ROOT::Math::Boost&)
bool	operator==(const ROOT::Math::Boost& rhs) const
void	Rectify()
void	SetComponents(const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& beta)
void	SetComponents(double* begin, double* end)
void	SetComponents(ROOT::Math::Boost::Scalar beta_x, ROOT::Math::Boost::Scalar beta_y, ROOT::Math::Boost::Scalar beta_z)