OnePiRange.h

Go to the documentation of this file.

#ifndef GeometryVector_Geom_OnePiRange_h
#define GeometryVector_Geom_OnePiRange_h

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

namespace Geom {

  template <class T>
  class OnePiRange {
  public:

    OnePiRange() {}

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

    operator T() const { return theValue;}

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

    T value() const { return theValue;}

    // Standard arithmetics 
    OnePiRange& operator+=(const T& a) {theValue+=a; normalize(); return *this;}
    OnePiRange& operator+=(const OnePiRange& a) {return operator+=(a.value());}

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

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

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

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

    // No need to handle 0 or pi; in this case "inf" is returned.
    T eta() const { return -log(tan(theValue/2.)); } 
    

  private:

    T theValue;

    void normalize() {
      if( theValue > (T) pi() || theValue < 0) {
    theValue = fmod( theValue, (T) pi());   
      }
      if (theValue <  0.)   theValue += pi();
    }

  };

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


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

  template <class T>
  inline OnePiRange<T> operator-(const OnePiRange<T>& a, const OnePiRange<T>& b) { 
    return OnePiRange<T>(a) -= b;
  }

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

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

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

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

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

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

}
#endif