class TLorentzRotation: public TObject

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