Lorentz boost class with the (4D) transformation represented internally by a 4x4 orthosymplectic matrix.
A variable names bgamma appears in several places in this file.
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.
- See also
- Overview of the physics vector library
A few words of elaboration are needed to make its meaning clear. On page 69 of Misner, Thorne and Wheeler, (Exercise 2.7) the elements of the matrix for a general Lorentz boost are given as
\[ \Lambda^{j'}_k = \Lambda^{k'}_j
= (\gamma - 1) n^j n^k + \delta^{jk} \]
where the n^i are unit vectors in the direction of the three spatial axes. Using the definitions, \( n^i = \beta_i/\beta \) , then, for example,
\[ \Lambda_{xy} = (\gamma - 1) n_x n_y
= (\gamma - 1) \beta_x \beta_y/\beta^2 \]
By definition,
\[ \gamma^2 = 1/(1 - \beta^2) \]
so that
\[ \gamma^2 \beta^2 = \gamma^2 - 1 \]
or
\[ \beta^2 = (\gamma^2 - 1)/\gamma^2 \]
If we insert this into the expression for \( \Lambda_{xy} \), we get
\[ \Lambda_{xy} = (\gamma - 1) \gamma^2/(\gamma^2 - 1) \beta_x \beta_y \]
or, finally
\[ \Lambda_{xy} = \gamma^2/(\gamma+1) \beta_x \beta_y \]
The expression \( \gamma^2/(\gamma+1) \) is what we call bgamma in the code below.
Definition at line 47 of file Boost.h.
|
| | Boost () |
| | Default constructor (identity transformation)
|
| |
| | Boost (Boost const &b) |
| | copy constructor
|
| |
| | Boost (BoostX const &bx) |
| | Construct from an axial boost.
|
| |
| | Boost (BoostY const &by) |
| |
| | Boost (BoostZ const &bz) |
| |
| template<class Avector > |
| | Boost (const Avector &beta) |
| | Construct given a beta vector (which must have methods x(), y(), z())
|
| |
| template<class IT > |
| | Boost (IT begin, IT 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.
|
| |
| | Boost (Scalar beta_x, Scalar beta_y, Scalar beta_z) |
| | Construct given a three Scalars beta_x, beta_y, and beta_z.
|
| |
| XYZVector | BetaVector () const |
| |
| template<class IT > |
| void | GetComponents (IT begin) const |
| | Get given a pointer or an iterator defining the beginning of an array into which to place beta_x, beta_y, and beta_z.
|
| |
| template<class IT > |
| void | GetComponents (IT begin, IT end) const |
| | 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.
|
| |
| void | GetComponents (Scalar &beta_x, Scalar &beta_y, Scalar &beta_z) const |
| | Get components into beta_x, beta_y, and beta_z.
|
| |
| void | 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.
|
| |
| Boost | Inverse () const |
| | Return inverse of a boost.
|
| |
| void | Invert () |
| | Invert a Boost in place.
|
| |
| bool | operator!= (const Boost &rhs) const |
| |
| template<class Foreign4Vector > |
| Foreign4Vector | operator() (const Foreign4Vector &v) const |
| | Lorentz transformation operation on an arbitrary 4-vector v.
|
| |
| template<class CoordSystem > |
| LorentzVector< CoordSystem > | operator() (const LorentzVector< CoordSystem > &v) const |
| | Lorentz transformation operation on a LorentzVector in any coordinate system.
|
| |
| LorentzVector< ROOT::Math::PxPyPzE4D< double > > | operator() (const LorentzVector< ROOT::Math::PxPyPzE4D< double > > &v) const |
| | Lorentz transformation operation on a Minkowski ('Cartesian') LorentzVector.
|
| |
| template<class A4Vector > |
| A4Vector | operator* (const A4Vector &v) const |
| | Overload operator * for boost on a vector.
|
| |
| Boost & | operator= (Boost const &rhs) |
| | Assignment operator.
|
| |
| Boost & | operator= (BoostX const &bx) |
| | Assign from an axial pure boost.
|
| |
| Boost & | operator= (BoostY const &by) |
| |
| Boost & | operator= (BoostZ const &bz) |
| |
| bool | operator== (const Boost &rhs) const |
| | Equality/inequality operators.
|
| |
| void | Rectify () |
| | Re-adjust components to eliminate small deviations from a perfect orthosyplectic matrix.
|
| |
| template<class Avector > |
| void | SetComponents (const Avector &beta) |
| | Set components from a beta vector.
|
| |
| template<class IT > |
| void | SetComponents (IT begin, IT end) |
| | 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.
|
| |
| void | SetComponents (Scalar beta_x, Scalar beta_y, Scalar beta_z) |
| | Set components from beta_x, beta_y, and beta_z.
|
| |
