library: libPhysics #include "TLorentzRotation.h"

# TLorentzRotation

class description - source file - inheritance tree (.ps)

## class TLorentzRotation : public TObject

| Inheritance Chart:

`TObject`

<-

`TLorentzRotation`

        protected:

                           TLorentzRotation(Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t)
                      void SetBoost(Double_t, Double_t, Double_t)

        public:

                                                TLorentzRotation()
                                                TLorentzRotation(const TRotation&)
                                                TLorentzRotation(const TLorentzRotation&)
                                                TLorentzRotation(Double_t, Double_t, Double_t)
                                                TLorentzRotation(const TVector3&)
                               TLorentzRotation MatrixMultiplication(const TLorentzRotation&) const
                               TLorentzRotation operator*(const TLorentzRotation& m) const
                               TLorentzRotation Inverse() const
                                                ~TLorentzRotation()
                              TLorentzRotation& Boost(Double_t bx, Double_t by, Double_t bz)
                              TLorentzRotation& Boost(const TVector3& b)
                                 static TClass* Class()
                              TLorentzRotation& Invert()
                                virtual TClass* IsA() const
                                         Bool_t IsIdentity() const
                                         Bool_t operator!=(const TLorentzRotation& r) const
                                       Double_t operator()(int, int) const
                                 TLorentzVector operator*(const TLorentzVector& p) const
                              TLorentzRotation& operator*=(const TLorentzRotation& m)
                              TLorentzRotation& operator=(const TLorentzRotation& r)
                              TLorentzRotation& operator=(const TRotation& r)
                                         Bool_t operator==(const TLorentzRotation& r) const
          TLorentzRotation::TLorentzRotationRow operator[](int i) const
                              TLorentzRotation& Rotate(Double_t angle, const TVector3& axis)
                              TLorentzRotation& Rotate(Double_t angle, const TVector3* axis)
                              TLorentzRotation& RotateX(Double_t angle)
                              TLorentzRotation& RotateY(Double_t angle)
                              TLorentzRotation& RotateZ(Double_t angle)
                                   virtual void ShowMembers(TMemberInspector& insp, char* parent)
                                   virtual void Streamer(TBuffer& b)
                                           void StreamerNVirtual(TBuffer& b)
                              TLorentzRotation& Transform(const TLorentzRotation& m)
                              TLorentzRotation& Transform(const TRotation& m)
                                       Double_t TT() const
                                       Double_t TX() const
                                       Double_t TY() const
                                       Double_t TZ() const
                                 TLorentzVector VectorMultiplication(const TLorentzVector& p) const
                                       Double_t XT() const
                                       Double_t XX() const
                                       Double_t XY() const
                                       Double_t XZ() const
                                       Double_t YT() const
                                       Double_t YX() const
                                       Double_t YY() const
                                       Double_t YZ() const
                                       Double_t ZT() const
                                       Double_t ZX() const
                                       Double_t ZY() const
                                       Double_t ZZ() const

### Data Members

        protected:

          Double_t fxx
          Double_t fxy
          Double_t fxz
          Double_t fxt
          Double_t fyx
          Double_t fyy
          Double_t fyz
          Double_t fyt
          Double_t fzx
          Double_t fzy
          Double_t fzz
          Double_t fzt
          Double_t ftx
          Double_t fty
          Double_t ftz
          Double_t ftt

## Class Description

    *-*-*-*-*-*-*-*-*-*-*-*The Physics Vector package *-*-*-*-*-*-*-*-*-*-*-*
    *-*                    ==========================                       *
    *-* The Physics Vector package consists of five classes:                *
    *-*   - TVector2                                                        *
    *-*   - TVector3                                                        *
    *-*   - TRotation                                                       *
    *-*   - TLorentzVector                                                  *
    *-*   - TLorentzRotation                                                *
    *-* It is a combination of CLHEPs Vector package written by             *
    *-* Leif Lonnblad, Andreas Nilsson and Evgueni Tcherniaev               *
    *-* and a ROOT package written by Pasha Murat.                          *
    *-* for CLHEP see:  http://wwwinfo.cern.ch/asd/lhc++/clhep/             *
    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

## TLorentzRotation

The TLorentzRotation class describes Lorentz transformations including Lorentz boosts and rotations (see TRotation)

`| xx xy xz xt |`
`| |`
`| yx yy yz yt |`
`lambda = | |`
`| zx zy zz zt |`
`| |`
`| tx ty tz tt |`

### Declaration

By default it is initialized to the identity matrix, but it may also be intialized by an other `TLorentzRotation`,
by a pure TRotation or by a boost:

`TLorentzRotation l; // l is initialized as identity`
`TLorentzRotation m(l); // m = l`
`TRotation r;`
`TLorentzRotation lr(r);`
`TLorentzRotation lb1(bx,by,bz);`
`TVector3 b;`
`TLorentzRotation lb2(b);`

The Matrix for a Lorentz boosts is:

`| 1+gamma'*bx*bx gamma'*bx*by gamma'*bx*bz gamma*bx |`
`| gamma'*bx*bz 1+gamma'*by*by gamma'*by*by gamma*by |`
`| gamma'*bz*bx gamma'*bz*by 1+gamma'*bz*bz gamma*bz |`
`| gamma*bx gamma*by gamma*bz gamma |`

with the boost vector `b=(bx,by,bz)` and`gamma=1/Sqrt(1-beta*beta)` and`gamma'=(gamma-1)/beta*beta.`

### Access to the matrix components/Comparisons

Access to the matrix components is possible through the member functions XX(), XY() .. TT(),
through the operator (int,int):

`Double_t xx;`
`TLorentzRotation l;`
`xx = l.XX(); // gets the xx component`
`xx = l(0,0); // gets the xx component`

`if (l==m) {...} // test for equality`
`if (l !=m) {...} // test for inequality`
`if (l.IsIdentity()) {...} // test for identity`

### Transformations of a LorentzRotation

##### Compound transformations

There are four possibilities to find the product of two `TLorentzRotation` transformations:

`TLorentzRotation a,b,c;`
`c = b*a; // product`
`c = a.MatrixMultiplication(b); // a is unchanged`
`a *= b; // Attention: a=a*b`
`c = a.Transform(b) // a=b*a then c=a`

##### Lorentz boosts

`Double_t bx, by, bz;`
`TVector3 v(bx,by,bz);`
`TLorentzRotation l;`
`l.Boost(v);`
`l.Boost(bx,by,bz);`

##### Rotations

`TVector3 axis;`
`l.RotateX(TMath::Pi()); // rotation around x-axis`
`l.Rotate(.5,axis); // rotation around specified vector`

##### Inverse transformation

The matrix for the inverse transformation of a TLorentzRotation is as follows:
`| xx yx zx -tx |`
`| |`
`| xy yy zy -ty |`
`| |`
`| xz yz zz -tz |`
`| |`
`|-xt -yt -zt tt |`
To return the inverse transformation keeping the current unchanged use the memberfunction `Inverse()`.
`Invert()` inverts the current `TLorentzRotation`:

`l1 = l2.Inverse(); // l1 is inverse of l2, l2 unchanged`
`l1 = l2.Invert(); // invert l2, then l1=l2`

### Transformation of a TLorentzVector

To apply `TLorentzRotation` to `TLorentzVector` you can use either the `VectorMultiplication()` member function or the `*` operator. You can also use the `Transform()` function and the `*=` operator of the `TLorentzVector` class.:

`TLorentzVector v;`
`...`
`v=l.VectorMultiplication(v);`
`v = l * v;`

`v.Transform(l);`
`v *= l; // Attention v = l*v`

TLorentzRotation() : fxx(1.0), fxy(0.0), fxz(0.0), fxt(0.0), fyx(0.0), fyy(1.0), fyz(0.0), fyt(0.0), fzx(0.0), fzy(0.0), fzz(1.0), fzt(0.0), ftx(0.0), fty(0.0), ftz(0.0), ftt(1.0)

TLorentzRotation(const TRotation & r) : fxx(r.XX()), fxy(r.XY()), fxz(r.XZ()), fxt(0.0), fyx(r.YX()), fyy(r.YY()), fyz(r.YZ()), fyt(0.0), fzx(r.ZX()), fzy(r.ZY()), fzz(r.ZZ()), fzt(0.0), ftx(0.0), fty(0.0), ftz(0.0), ftt(1.0)

TLorentzRotation(const TLorentzRotation & r) : TObject(r), fxx(r.fxx), fxy(r.fxy), fxz(r.fxz), fxt(r.fxt), fyx(r.fyx), fyy(r.fyy), fyz(r.fyz), fyt(r.fyt), fzx(r.fzx), fzy(r.fzy), fzz(r.fzz), fzt(r.fzt), ftx(r.ftx), fty(r.fty), ftz(r.ftz), ftt(r.ftt)

TLorentzRotation( Double_t rxx, Double_t rxy, Double_t rxz, Double_t rxt, Double_t ryx, Double_t ryy, Double_t ryz, Double_t ryt, Double_t rzx, Double_t rzy, Double_t rzz, Double_t rzt, Double_t rtx, Double_t rty, Double_t rtz, Double_t rtt) : fxx(rxx), fxy(rxy), fxz(rxz), fxt(rxt), fyx(ryx), fyy(ryy), fyz(ryz), fyt(ryt), fzx(rzx), fzy(rzy), fzz(rzz), fzt(rzt), ftx(rtx), fty(rty), ftz(rtz), ftt(rtt)

TLorentzRotation(Double_t bx, Double_t by, Double_t bz)

TLorentzRotation(const TVector3 & p)

void SetBoost(Double_t bx, Double_t by, Double_t bz)

MatrixMultiplication(const TLorentzRotation & b) const

### Inline Functions

                                             void ~TLorentzRotation()
                                         Double_t XX() const
                                         Double_t XY() const
                                         Double_t XZ() const
                                         Double_t XT() const
                                         Double_t YX() const
                                         Double_t YY() const
                                         Double_t YZ() const
                                         Double_t YT() const
                                         Double_t ZX() const
                                         Double_t ZY() const
                                         Double_t ZZ() const
                                         Double_t ZT() const
                                         Double_t TX() const
                                         Double_t TY() const
                                         Double_t TZ() const
                                         Double_t TT() const
            TLorentzRotation::TLorentzRotationRow operator[](int i) const
                                         Double_t operator()(int, int) const
                                TLorentzRotation& operator=(const TLorentzRotation& r)
                                TLorentzRotation& operator=(const TRotation& r)
                                           Bool_t operator==(const TLorentzRotation& r) const
                                           Bool_t operator!=(const TLorentzRotation& r) const
                                           Bool_t IsIdentity() const
                                   TLorentzVector VectorMultiplication(const TLorentzVector& p) const
                                   TLorentzVector operator*(const TLorentzVector& p) const
                                 TLorentzRotation operator*(const TLorentzRotation& m) const
                                TLorentzRotation& operator*=(const TLorentzRotation& m)
                                TLorentzRotation& Transform(const TLorentzRotation& m)
                                TLorentzRotation& Transform(const TRotation& m)
                                 TLorentzRotation Inverse() const
                                TLorentzRotation& Invert()
                                TLorentzRotation& Boost(Double_t bx, Double_t by, Double_t bz)
                                TLorentzRotation& Boost(const TVector3& b)
                                TLorentzRotation& RotateX(Double_t angle)
                                TLorentzRotation& RotateY(Double_t angle)
                                TLorentzRotation& RotateZ(Double_t angle)
                                TLorentzRotation& Rotate(Double_t angle, const TVector3& axis)
                                TLorentzRotation& Rotate(Double_t angle, const TVector3* axis)
                                          TClass* Class()
                                          TClass* IsA() const
                                             void ShowMembers(TMemberInspector& insp, char* parent)
                                             void Streamer(TBuffer& b)
                                             void StreamerNVirtual(TBuffer& b)

Author: Peter Malzacher 19/06/99
Last update: root/physics:$Name: $:$Id: TLorentzRotation.cxx,v 1.3 2003/09/03 06:08:34 brun Exp $