TLorentzVectorC.h

Go to the documentation of this file.

#ifndef RAD_TLorentzVectorC
#define RAD_TLorentzVectorC
 
#include "TLorentzVector.h"
#include <complex>
 
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