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;}

    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*180./pi();}

  private:

    T theValue;

    void normalize() { 
      if( theValue > twoPi() || theValue < -twoPi()) {
    theValue = 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;
  }


}
#endif