Lorentz boost class with the (4D) transformation represented internally by a 4x4 orthosymplectic matrix. See also BoostX, BoostY and BoostZ for classes representing specialized Lorentz boosts. Also, the 3-D rotation classes can be considered to be special Lorentz transformations which do not mix space and time components. @ingroup GenVector
| ~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) |
| void | SetIdentity() |
========== Constructors and Assignment ===================== Default constructor (identity transformation)
{ SetIdentity(); }Construct given a three Scalars beta_x, beta_y, and beta_z
{ SetComponents(beta_x, beta_y, beta_z); }Construct given a beta vector (which must have methods x(), y(), z())
{ SetComponents(beta); }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); }The compiler-generated copy ctor, copy assignment, and dtor are OK. Assign from an axial pure boost
{ return operator=(Boost(bx)); }Re-adjust components to eliminate small deviations from a perfect orthosyplectic matrix.
======== Components ============== Set components from beta_x, beta_y, and beta_z
Get components into beta_x, beta_y, and beta_z
Set components from a beta vector
{ SetComponents(beta.x(), beta.y(), beta.z()); }Set given a pair of pointers or iterators defining the beginning and end of an array of three Scalars to use as beta_x,beta _y, and beta_z
Get given a pair of pointers or iterators defining the beginning and end of an array of three Scalars into which to place beta_x, beta_y, and beta_z
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.
=========== operations ==============
Lorentz transformation operation on a Minkowski ('Cartesian')
LorentzVector
Overload operator * for boost on a vector