TLorentzRotation

class description - source file - inheritance tree

class TLorentzRotation : public TObject


    protected:

      TLorentzRotation 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()
                           TLorentzRotation TLorentzRotation(TRotation&)
                           TLorentzRotation TLorentzRotation(TLorentzRotation&)
                           TLorentzRotation TLorentzRotation(Double_t, Double_t, Double_t)
                           TLorentzRotation TLorentzRotation(TVector3&)
                           TLorentzRotation MatrixMultiplication(TLorentzRotation&)
                           TLorentzRotation operator*(TLorentzRotation& m)
                           TLorentzRotation Inverse()
                                       void ~TLorentzRotation()
                          TLorentzRotation& Boost(Double_t bx, Double_t by, Double_t bz)
                          TLorentzRotation& Boost(TVector3& b)
                                    TClass* Class()
                          TLorentzRotation& Invert()
                            virtual TClass* IsA()
                                     Bool_t IsIdentity()
                                     Bool_t operator!=(TLorentzRotation& r)
                                   Double_t operator()(int, int)
                             TLorentzVector operator*(TLorentzVector& p)
                          TLorentzRotation& operator*=(TLorentzRotation& m)
                          TLorentzRotation& operator=(TLorentzRotation& r)
                          TLorentzRotation& operator=(TRotation& r)
                                     Bool_t operator==(TLorentzRotation& r)
      TLorentzRotation::TLorentzRotationRow operator[](int i)
                          TLorentzRotation& Rotate(Double_t angle, TVector3& axis)
                          TLorentzRotation& Rotate(Double_t angle, 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)
                          TLorentzRotation& Transform(TLorentzRotation& m)
                          TLorentzRotation& Transform(TRotation& m)
                                   Double_t TT()
                                   Double_t TX()
                                   Double_t TY()
                                   Double_t TZ()
                             TLorentzVector VectorMultiplication(TLorentzVector& p)
                                   Double_t XT()
                                   Double_t XX()
                                   Double_t XY()
                                   Double_t XZ()
                                   Double_t YT()
                                   Double_t YX()
                                   Double_t YY()
                                   Double_t YZ()
                                   Double_t ZT()
                                   Double_t ZX()
                                   Double_t ZY()
                                   Double_t ZZ()

  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) andgamma=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) : 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

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

Author: Peter Malzacher 19/06/99
Last update: 2.22/06 19/06/99 09.07.01 by Peter Malzacher

ROOT page - Class index - Top of the page

This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.