FourVector.h

Go to the documentation of this file.

#ifndef __FOURVECTOR_H
#define __FOURVECTOR_H

#include "jbltools/kinfit/ThreeVector.h"

#include <iostream>
#include <cmath>
#include <cassert>

//  Class FourVector:

class FourVector {
  public:
    inline FourVector();
    inline FourVector(double E_, double px_, double py_, double pz_);
    inline FourVector(double E_, const ThreeVector& p_);
    inline FourVector(const ThreeVector& p_, double m_);
    // automatically generated copy constructor and assignment is fine
    
    inline double getE()     const;
    inline double getPx()    const;
    inline double getPy()    const;
    inline double getPz()    const;
    inline double getM2()    const;
    inline double getM()     const;
    inline double getMass()     const;
    
    inline double getP2()    const;
    inline double getP()     const;
    inline double getPt2()   const;
    inline double getPt()    const;
    
    inline double getPhi()   const;
    inline double getTheta() const;
    inline double getEta() const;
    
    inline double getComponent (int i) const;
    
    inline ThreeVector getBeta() const { assert (E>0); return (1./E)*p;};
    inline double getGamma() const { assert (getM()>0); return getE()/getM();};
    inline ThreeVector getBetaGamma() const { assert (getM()>0); return (1./getM()>0)*p;};

    inline const ThreeVector& getThreeVector() const { return p;}
    
    FourVector& boost (const FourVector& P);
    void decayto (FourVector& d1, FourVector& d2) const;
    
    inline void setValues (double E_, double px_, double py_, double pz_);
    
    inline FourVector& operator+= (const FourVector& rhs);
    inline FourVector& operator-= (const FourVector& rhs);
    
    inline FourVector& operator*= (double rhs);
  
  private:
    double E;         
    ThreeVector p;    
};

FourVector::FourVector()
: E(0), p()
{}

FourVector::FourVector(double E_, double px_, double py_, double pz_)
: E(E_), p(px_, py_, pz_)
{}

FourVector::FourVector(double E_, const ThreeVector& p_)
: E(E_), p(p_)
{}
    
FourVector::FourVector(const ThreeVector& p_, double m)
: E(std::sqrt(p_.getP2() + m*m)), p(p_)
{}
    
double FourVector::getE()  const { return E; }
double FourVector::getPx() const { return p.getPx(); }
double FourVector::getPy() const { return p.getPy(); }
double FourVector::getPz() const { return p.getPz(); }

double FourVector::getPt2() const { return p.getPt2(); }
double FourVector::getPt()  const { return p.getPt(); }

double FourVector::getP2() const { return p.getP2(); }
double FourVector::getP()  const { return p.getP(); }

double FourVector::getM2()   const { return std::abs(getE()*getE()-getP2()); }
double FourVector::getM()    const { return std::sqrt(getM2()); }
double FourVector::getMass() const { return std::sqrt(getM2()); }

double FourVector::getPhi()   const { return p.getPhi(); }
double FourVector::getTheta() const { return p.getTheta(); }

double FourVector::getEta() const { return p.getEta(); }

double FourVector::getComponent(int i) const { 
  switch (i) {
    case 1: return getPx();
    case 2: return getPy();
    case 3: return getPz();
  }
  return getE();
}

void FourVector::setValues(double E_, double px_, double py_, double pz_) {
  E = E_;
  p.setValues (px_, py_, pz_);
}

FourVector& FourVector::operator+= (const FourVector& rhs) {
  p += rhs.p;
  E += rhs.E;
  return *this;
}

FourVector& FourVector::operator-= (const FourVector& rhs) {
  p -= rhs.p;
  E -= rhs.E;
  return *this;
}

FourVector& FourVector::operator*= (double rhs) {
  p *= rhs;
  E *= rhs;
  return *this;
}

inline FourVector operator+ (const FourVector& lhs, const FourVector& rhs) {
  return FourVector (lhs.getE()+rhs.getE(), lhs.getPx()+rhs.getPx(), lhs.getPy()+rhs.getPy(), lhs.getPz()+rhs.getPz());
}

inline FourVector operator- (const FourVector& lhs, const FourVector& rhs) {
  return FourVector (lhs.getE()-rhs.getE(), lhs.getPx()-rhs.getPx(), lhs.getPy()-rhs.getPy(), lhs.getPz()-rhs.getPz());
}

inline FourVector operator- (const FourVector& rhs) {
  return FourVector (-rhs.getE(), -rhs.getPx(), -rhs.getPy(), -rhs.getPz());
}

inline FourVector operator* (double lhs, const FourVector& rhs) {
  return FourVector (lhs*rhs.getE(), lhs*rhs.getPx(), lhs*rhs.getPy(), lhs*rhs.getPz());
}

inline double operator* (const FourVector& lhs, const FourVector& rhs) {
  return lhs.getE()*rhs.getE() - lhs.getPx()*rhs.getPx() - lhs.getPy()*rhs.getPy() - lhs.getPz()*rhs.getPz();
}


inline std::ostream& operator<< (std::ostream& os, 
                                 const FourVector& rhs 
                                ) {
  os << "(" << rhs.getE() << ", " << rhs.getPx() << ", " << rhs.getPy() << ", " << rhs.getPz() << ")";
  return os;
}


#endif // __FOURVECTOR_H

---