Phi.h

Go to the documentation of this file.

#ifndef GeometryVector_Geom_Phi_h
#define GeometryVector_Geom_Phi_h

#include "DataFormats/GeometryVector/interface/Pi.h"
#include <cmath>

namespace Geom {

  template <class T>
  class Phi {
  public:

    Phi() {}

    explicit Phi( const T& val) : theValue(val) { normalize();}

    operator T() const { return theValue;}

    template <class T1> operator Phi<T1>() { return Phi<T1>(theValue);}

    T value() const { return theValue;}

    // so that template classes expecting phi() works! (deltaPhi)
    T phi() const { return theValue;}

    Phi& operator+=(const T& a) {theValue+=a; normalize(); return *this;}
    Phi& operator+=(const Phi& a) {return operator+=(a.value());}

    Phi& operator-=(const T& a) {theValue-=a; normalize(); return *this;}
    Phi& operator-=(const Phi& a) {return operator-=(a.value());}

    Phi& operator*=(const T& a) {theValue*=a; normalize(); return *this;}

    Phi& operator/=(const T& a) {theValue/=a; normalize(); return *this;}

    T degrees() const { return theValue*T(180.)/pi();}

  private:

    T theValue;

    void normalize() { 
      if( theValue > twoPi() || theValue < -twoPi()) {
    theValue = std::fmod( theValue, (T) twoPi());
      }
      if (theValue <= -pi()) theValue += twoPi();
      if (theValue >  pi()) theValue -= twoPi();
    }

  };

  template <class T>
  inline Phi<T> operator-(const Phi<T>& a) {return Phi<T>(-a.value());}


  template <class T>
  inline Phi<T> operator+(const Phi<T>& a, const Phi<T>& b) {
    return Phi<T>(a) += b;
  }
  template <class T, class Scalar>
  inline Phi<T> operator+(const Phi<T>& a, const Scalar& b) {
    return Phi<T>(a) += b;
  }
  template <class T, class Scalar>
  inline Phi<T> operator+(const Scalar& a, const Phi<T>& b) {
    return Phi<T>(b) += a;
  }


  template <class T>
  inline Phi<T> operator-(const Phi<T>& a, const Phi<T>& b) { 
    return Phi<T>(a) -= b;
  }
  template <class T, class Scalar>
  inline Phi<T> operator-(const Phi<T>& a, const Scalar& b) { 
    return Phi<T>(a) -= b;
  }
  template <class T, class Scalar>
  inline Phi<T> operator-(const Scalar& a, const Phi<T>& b) { 
    return Phi<T>(a - b.value());  // use of unary operators would normalize twice
  }


  template <class T, class Scalar>
  inline Phi<T> operator*(const Phi<T>& a, const Scalar& b) {
    return Phi<T>(a) *= b;
  }
  template <class T>
  inline Phi<T> operator*(double a, const Phi<T>& b) {
    return Phi<T>(b) *= a;
  }


  template <class T>
  inline T operator/(const Phi<T>& a, const Phi<T>& b) { 
    return a.value() / b.value();
  }
  template <class T>
  inline Phi<T> operator/(const Phi<T>& a, double b) {
    return Phi<T>(a) /= b;
  }


}

/*
// this a full mess wiht the above that is a mess in itself
#include "DataFormats/Math/interface/deltaPhi.h"
namespace reco {
  template <class T1,class T2>
  inline double deltaPhi(const Geom::Phi<T1> phi1, const Geom::Phi<T2> phi2) {
    return deltaPhi(static_cast<double>(phi1.value()), static_cast<double>(phi2.value()));
  }
 
  template <class T>
  inline double deltaPhi(const Geom::Phi<T> phi1, double phi2) {
    return deltaPhi(static_cast<double>(phi1.value()), phi2);
  }
  template <class T>
  inline double deltaPhi(const Geom::Phi<T> phi1, float phi2) {
    return deltaPhi(static_cast<double>(phi1.value()), static_cast<double>(phi2));
  }
  template <class T>
  inline double deltaPhi(double phi1, const Geom::Phi<T>  phi2) {
    return deltaPhi(phi1, static_cast<double>(phi2.value()) );
  }
  template <class T>
  inline double deltaPhi(float phi1, const Geom::Phi<T>  phi2) {
    return deltaPhi(static_cast<double>(phi1),static_cast<double>(phi2.value()) );
  }
}
*/

#endif