TLorentzVectorC.h

Go to the documentation of this file.

#ifndef RAD_TLorentzVectorC
#define RAD_TLorentzVectorC
 
#include <complex>
#include "TLorentzVector.h"
 
class TLorentzVectorC {
protected:
  std::complex<double> fx,fy,fz,fe;
public:
  TLorentzVectorC(){}
  TLorentzVectorC(std::complex<double> x,
          std::complex<double> y,
          std::complex<double> z,
          std::complex<double> e){
    fx = x; fy = y; fz = z; fe = e;
  };
  ~TLorentzVectorC(){}
  
  void SetPxPyPzE(std::complex<double> x,
         std::complex<double> y,
         std::complex<double> z,
         std::complex<double> e){
    fx = x; fy = y; fz = z; fe = e;
  }
 
  inline std::complex<double> Px() const {return fx;}
  inline std::complex<double> Py() const {return fy;}
  inline std::complex<double> Pz() const {return fz;}
  inline std::complex<double> E()  const {return fe;}
  inline std::complex<double> X() const {return fx;}
  inline std::complex<double> Y() const {return fy;}
  inline std::complex<double> Z() const {return fz;}
  inline std::complex<double> T() const {return fe;}
  
  inline TLorentzVectorC &operator = (const TLorentzVectorC & q){
    fx = q.Px();
    fy = q.Py();
    fz = q.Pz();
    fe = q.E();
    return *this;
  }
 
  
  inline TLorentzVectorC operator + (const TLorentzVectorC & q) const {
    return TLorentzVectorC(fx+q.Px(), fy+q.Py(), fz+q.Pz(), fe+q.E());
  }
 
  inline TLorentzVectorC &operator += (const TLorentzVectorC & q) {
    fx += q.Px();
    fy += q.Py();
    fz += q.Pz();
    fe += q.T();
    return *this;
  }
  
  inline TLorentzVectorC operator - (const TLorentzVectorC & q) const {
    return TLorentzVectorC(fx-q.Px(), fy-q.Py(), fz-q.Pz(), fe-q.E());
  }
  
  inline TLorentzVectorC &operator -= (const TLorentzVectorC & q) {
    fx -= q.Px();
    fy -= q.Py();
    fz -= q.Pz();
    fe -= q.T();
    return *this;
  }
  
  inline TLorentzVectorC operator - () const {
    return TLorentzVectorC(-X(), -Y(), -Z(), -T());
  }
  
  inline TLorentzVectorC& operator *= (double a) {
    fx *= a;
    fy *= a;
    fz *= a;
    fe *= a;
    return *this;
  }
  
  inline TLorentzVectorC operator * (double a) const {
    return TLorentzVectorC(a*X(), a*Y(), a*Z(), a*T());
  }
 
  inline TLorentzVectorC& operator *= (std::complex<double> a) {
    fx *= a;
    fy *= a;
    fz *= a;
    fe *= a;
    return *this;
  }
  
  inline TLorentzVectorC operator * (std::complex<double> a) const {
    return TLorentzVectorC(a*X(), a*Y(), a*Z(), a*T());
  }
  
  inline std::complex<double> Dot(const TLorentzVectorC & q) const {
    return T()*std::conj(q.T())
      - (Z()*std::conj(q.Z()) + Y()*std::conj(q.Y()) + X()*std::conj(q.X()));
  }
 
  inline std::complex<double> Dot(const TLorentzVector & q) const {
    return T()*q.T() - Z()*q.Z() - Y()*q.Y() - X()*q.X();
  }
 
  inline std::complex<double> operator * (const TLorentzVectorC & q) const {
    return Dot(q);
  }
 
  inline std::complex<double> operator * (const TLorentzVector & q) const {
    return Dot(q);
  }
};
 
#endif // RAD_TLorentzVectorC