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