TMBLorentzVector.hpp

Go to the documentation of this file.

#ifndef INCLUDE_TMBLORENTZVECTOR
#define INCLUDE_TMBLORENTZVECTOR


// See copyright statements at end of file.

#ifndef INCLUDE_TMBVECTOR3
#include "tmb_tree/TMBVector3.hpp"
#endif
#ifndef ROOT_TRotation
#include "TRotation.h"
#endif

#ifndef ROOT_TLorentzVector
#include "TLorentzVector.h"
#endif

class TLorentzRotation;

class TMBLorentzVector: public TMBVector3 {

public:

   enum ECoordinates { 
       kX = 0, 
       kY = 1, 
       kZ = 2, 
       kE = 3, 
       kNUM_COORDINATES = 4, 
       kSIZE = kNUM_COORDINATES 
   };

   enum EInitializer { 
       kXYZE, 
       kXYZM, 
       kPEtaPhiE, 
       kPEtaPhiM, 
       kPtEtaPhiE, 
       kPtEtaPhiM 
   };

   TMBLorentzVector(Double_t a = 0.0, Double_t b = 0.0,
                    Double_t c = 0.0, Double_t d = 0.0, 
                    EInitializer init = kXYZE) 
       : TMBVector3 ()
   {
       Set(a,b,c,d,init);
   }

   TMBLorentzVector(const TVector3& vect, Double_t v4, EInitializer init=kXYZE):
      TMBVector3(vect) {
      switch (init) {
         case kXYZM: case kPEtaPhiM: case kPtEtaPhiM: fM=v4;
         default: SetE(v4);
      }
   }
   TMBLorentzVector(const Double_t * a, EInitializer init=kXYZE) 
    : TMBVector3()
   {
       Set(a[0],a[1],a[2],a[3],init);
   }
   TMBLorentzVector(const Float_t * a, EInitializer init=kXYZE) {
       Set(a[0],a[1],a[2],a[3],init);
   }

   TMBLorentzVector(const TMBLorentzVector& lv): 
     TMBVector3(lv.Vect()), fM(lv.fM) {
     }

   TMBLorentzVector(const TLorentzVector& lv): TMBVector3(lv.Vect()) {
      SetE(lv.E()); }

   virtual ~TMBLorentzVector() {}




   Double_t M() const { 
      return fM; }

   virtual Double_t E()  const { 
      return TMath::Sqrt(fM*fM+Mag32()); }
   Double_t Energy() const { 
      return E(); }
   Double_t T() const { 
      return E(); }

   virtual const TMBVector3& Vect() const { 
      return *this; }
   virtual TMBVector3& Vect() { 
      return *this; }

   void GetXYZT(Double_t *carray) const { 
      GetXYZ(carray); carray[3]=E(); }
   void GetXYZT(Float_t *carray) const {
      GetXYZ(carray); carray[3]=E(); }

   Double_t operator () (int i) const;
   Double_t operator [] (int i) const { 
      return operator ()(i); } 




   void Set(Double_t a = 0.0, Double_t b = 0.0,
       Double_t c = 0.0, Double_t d = 0.0, 
       EInitializer init = kXYZE) {
       switch (init) {
       case kXYZM: SetXYZM(a,b,c,d); break;
       case kPEtaPhiE: SetPEtaPhiE(a,b,c,d); break;
       case kPEtaPhiM: SetPEtaPhiM(a,b,c,d); break;
       case kPtEtaPhiE: SetPtEtaPhiE(a,b,c,d); break;
       case kPtEtaPhiM: SetPtEtaPhiM(a,b,c,d); break;
       default: SetXYZT(a,b,c,d);
       }
   }

   void SetM(Double_t a) { 
      fM=a; }

   void SetT(Double_t a) { 
      Double_t m2=a*a-Mag32(); 
      fM=m2>0?TMath::Sqrt(m2) : -TMath::Sqrt(-m2); 
   }
   void SetE(Double_t a) { 
      SetT(a); }

   void SetVect(const TVector3 & vect3) { 
      Vect()=vect3; }

   void SetPxPyPzE(Double_t px, Double_t py, Double_t pz, Double_t e) {
      SetXYZT(px,py,pz,e); }
   void SetXYZT(Double_t  x, Double_t  y, Double_t  z, Double_t t) {
      SetXYZ(x,y,z); SetE(t); }
   void SetXYZM(Double_t  x, Double_t  y, Double_t  z, Double_t m) {
      SetXYZ(x,y,z); SetM(m); }
   void SetPtEtaPhiE(Double_t pt, Double_t eta, Double_t phi, Double_t e) {
      SetPtEtaPhi(pt,eta,phi); SetE(e); }
   void SetPtEtaPhiM(Double_t pt, Double_t eta, Double_t phi, Double_t m) {
      SetPtEtaPhi(pt,eta,phi); fM=m; }
   void SetPEtaPhiE(Double_t p, Double_t eta, Double_t phi, Double_t e) {
      SetPtEtaPhi(p*TMath::Sin(2.*TMath::ATan(TMath::Exp(-eta))),eta,phi); SetE(e); }
   void SetPEtaPhiM(Double_t p, Double_t eta, Double_t phi, Double_t m) {
      SetPtEtaPhi(p*TMath::Sin(2.*TMath::ATan(TMath::Exp(-eta))),eta,phi); fM=m; }


   TMBLorentzVector & operator = (const TMBLorentzVector & lv) {
      Vect()=lv.Vect(); fM = lv.fM; return *this; }
   

   TMBLorentzVector   operator +  (const TMBLorentzVector &lv) const {
      return TMBLorentzVector(Vect()+lv.Vect(), E()+lv.E()); }
   TMBLorentzVector & operator += (const TMBLorentzVector &lv) {
      Double_t e=E(); Vect()+=lv.Vect(); SetE(e+lv.E()); return *this; }

   TMBLorentzVector   operator -  (const TMBLorentzVector &lv) const {
      return TMBLorentzVector(Vect()-lv.Vect(), E()-lv.E()); }
   TMBLorentzVector & operator -= (const TMBLorentzVector &lv) {
      Double_t e=E(); Vect()-=lv.Vect(); SetE(e-lv.E()); return *this; }

   TMBLorentzVector operator - () const {
      return TMBLorentzVector(-Vect(),-E()); }

   TMBLorentzVector operator * (Double_t a) const {
      return TMBLorentzVector(Vect()*a, E()*a); }
   TMBLorentzVector & operator *= (Double_t a) {
      Vect()*=a; fM*=a; return *this; }

   Bool_t operator == (const TMBLorentzVector &lv) const {
      return (fM==lv.fM && Vect()==lv.Vect()); }
   Bool_t operator != (const TMBLorentzVector &lv) const {
      return !(operator == (lv)); }

   Bool_t is_equal (const TMBLorentzVector &lv) const;

   Double_t Mag2() const { 
      return fM*fM; }
   Double_t M2() const { 
      return Mag2(); }

   Double_t Mag() const { 
      return fM;
   }

   Double_t Mt2() const { 
      return E()*E() - Z()*Z(); }
   

   Double_t Mt() const { 
      Double_t mm=Mt2(); 
      return mm < 0.0 ? -TMath::Sqrt(-mm) : TMath::Sqrt(mm); }

   Double_t Beta() const { 
      if (E()!=0) return Mag3() / E(); 
      else Warning("Beta()", "E()==0.!"); return 0.; }
   Double_t Gamma() const {
      Double_t b = Beta();
      if (b!=1.) return 1.0/TMath::Sqrt(1- b*b);
      else Warning("Gamma()", "Beta()==1.!"); return 0.; }

   Double_t Dot(const TMBLorentzVector &lv) const {
      return E()*lv.E() - Vect().Dot(lv.Vect()); }
   Double_t operator * (const TMBLorentzVector &lv) const {
      return Dot(lv);}

   void SetVectMag(const TVector3 & spatial, Double_t magnitude) {
      Vect()=spatial; SetE(TMath::Sqrt(magnitude * magnitude + spatial * spatial)); }
   void SetVectM(const TVector3 & spatial, Double_t mass) {
      SetVectMag(spatial, mass); }
   void SetVectE(const TVector3 & spatial, Double_t e) {
      Vect()=spatial; SetE(e); }

   Double_t Plus() const { 
      return E() + Vect().Z(); }
   Double_t Minus() const { 
      return E() - Vect().Z(); }

   TVector3 BoostVector() const {
      if (E()!=0.) return 1./E()*Vect();
      else Warning("BoostVector()","E()==0.!"); return TVector3(); }

   void Boost(Double_t x, Double_t y, Double_t z) { 
      Boost(TVector3(x,y,z)); }
   void Boost(const TVector3 & b);

   Double_t Rapidity() const { 
      if (E()!=Pz()) return .5*log( (E()+Pz()) / (E()-Pz()) );
      else Warning("Rapidity", "E()==Pz()!"); return 0.; }


   TMBLorentzVector & operator *= (const TRotation &m) {
      Vect() *= m; return *this; }
   TMBLorentzVector & Transform(const TRotation &m) {
      Vect().Transform(m); return *this; }
   TMBLorentzVector & operator *= (const TLorentzRotation &);
   TMBLorentzVector & Transform(const TLorentzRotation &);

   operator TLorentzVector() const { 
      return TLorentzVector(X(),Y(),Z(),E()); }

private:
   Double32_t fM; 
   ClassDef(TMBLorentzVector,1) // A four vector with (-,-,-,+) metric
};

inline
TMBLorentzVector operator * (Double_t a, const TMBLorentzVector & p) {
   return TMBLorentzVector(a*p.Vect(), a*p.E());
}

/*************************************************************************
* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
* All rights reserved.                                                  *
*                                                                       *
* For the licensing terms see $ROOTSYS/LICENSE.                         *
* For the list of contributors see $ROOTSYS/README/CREDITS.             *
*************************************************************************/

//------------------------------------------------------------------------------
// Copyright(c) 1995-1997, P.Murat (CDF collaboration, FNAL)
//
// Permission to use, copy, modify and distribute this software and its
// documentation for non-commercial purposes is hereby granted without fee,
// provided that the above copyright notice appears in all copies and
// that both the copyright notice and this permission notice appear in
// the supporting documentation. The authors make no claims about the
// suitability of this software for any purpose.
// It is provided "as is" without express or implied warranty.
// *0001 Mar 29 1999 P.Murat: add forgotten scalar product (dot operator)
//------------------------------------------------------------------------------

#endif // INCLUDE_TMBLORENTZVECTOR

---