Reconstruction/MdcPatRec/MdcGeom/include/MdcGeom/BesAngle.h

Go to the documentation of this file.

#ifndef __BBRANGLE_H__
#define __BBRANGLE_H__
////////////////////////////////
////////////////////////////////
//
// BaBar angles are in radians, and degress should inly be used
// when absolutely necessary. Automatic conversions to and from
// the radians form are provided, but you have to manually
// go to and from degrees
//
// By convention, angles are represented as (-pi, pi]
//
#include "MdcGeom/Constants.h"
#include <math.h>
 
class BesAngle {
public:
  inline BesAngle();
  inline BesAngle( const double );
  inline ~BesAngle();
 
  inline operator double() const { return _phi; }; // automatic conversion to double
 
  inline double rad() const;
  inline double deg() const;
  // convention : returns value in [-180, 180]
 
  inline double posRad() const;
  inline double posDeg() const;
  // returns 0 to 360.  This is not the BaBar convention, and should not
  // be used for handing off values to anyone else's code
 
  inline void setRad( const double );
  inline void setDeg( const double );
 
  inline double arc( double radius ) const;
 
  inline void setSector( int n, int max );
  inline void setSector( int n, int max, BesAngle phi_0 );
 
  inline BesAngle        operator+( const BesAngle& ) const;
  inline BesAngle        operator+( const double ) const; // assumes double in radians
  inline BesAngle        operator-( const BesAngle& ) const;
  inline BesAngle        operator-( const double ) const; // assumes double in radians
  inline BesAngle        operator*( const double ) const;
  inline BesAngle        operator/( const double ) const;
  inline friend BesAngle operator*( const double, const BesAngle& );
 
  inline void operator=( const BesAngle );
  inline void operator+=( BesAngle );
  inline void operator-=( BesAngle );
  inline void operator+=( double ); // assumes double in radians
  inline void operator-=( double ); // assumes double in radians
  inline void operator*=( double );
  inline void operator/=( double );
 
  // note : > and < should have no well defined meaning ?
 
  inline int sector( int max );
  inline int sector( int max, BesAngle phi_0 );
  // convention : returns values [1..max]
  // hxt   HepString degString() const;
  inline friend double sin( const BesAngle );
  inline friend double cos( const BesAngle );
  inline friend double tan( const BesAngle );
 
  // class static constants defined in .cc file
  // these are generally available as Constants::pi, Constants::twoPi, etc,
  // and once the BaBar/Constants class is in a release they should be
  /// used instead.
 
  static const double pi;
  static const double twoPi;
 
  // old names, forwarded for migration BobJ May 21 97
  inline double Rad() const { return rad(); }
  inline double Deg() const { return deg(); }
  // hxt   inline HepString DegString() const { return degString(); }
  inline int Sector( int max ) { return sector( max ); }
  inline int Sector( int max, BesAngle phi_0 ) { return sector( max, phi_0 ); }
 
protected:
  double _phi;
 
  inline static double normalize( double );
 
  static const double toDegrees;
  // hxt   static  const HepString degChar, deg1Char, deg2Char;
};
 
//
// Methods for BesAngle
//
 
inline double BesAngle::normalize( double angle ) {
  if ( angle < -Constants::pi )
  {
    angle += Constants::twoPi;
    if ( angle < -Constants::pi )
      angle = fmod( angle + Constants::pi, Constants::twoPi ) + Constants::pi;
  }
  else if ( angle > Constants::pi )
  {
    angle -= Constants::twoPi;
    if ( angle > Constants::pi )
      angle = fmod( angle + Constants::pi, Constants::twoPi ) - Constants::pi;
  }
  return angle;
}
 
inline BesAngle::BesAngle() : _phi( 0 ) {}
 
inline BesAngle::BesAngle( const double phi ) : _phi( normalize( phi ) ) {}
 
inline BesAngle::~BesAngle() {}
 
inline double BesAngle::rad() const { return _phi; }
 
inline double BesAngle::deg() const { return _phi * Constants::radToDegrees; }
 
inline double BesAngle::posRad() const {
  if ( _phi >= 0.0 ) return _phi;
  else return _phi + Constants::twoPi;
}
 
inline double BesAngle::posDeg() const { return posRad() * Constants::radToDegrees; }
 
inline void BesAngle::setRad( const double phi ) { _phi = normalize( phi ); }
 
inline void BesAngle::setDeg( const double phi ) { setRad( phi / Constants::radToDegrees ); }
 
inline double BesAngle::arc( double radius ) const { return radius * rad(); }
 
inline void BesAngle::setSector( int n, int max ) {
  setRad( ( n + 0.5 ) * Constants::twoPi / max );
}
 
inline void BesAngle::setSector( int n, int max, BesAngle phi_0 ) {
  setRad( ( n + 0.5 ) * Constants::twoPi / max + phi_0._phi );
}
 
inline BesAngle BesAngle::operator+( const BesAngle& a ) const {
  return BesAngle( _phi + a._phi );
}
 
inline BesAngle BesAngle::operator+( const double a ) const { return BesAngle( _phi + a ); }
 
inline BesAngle BesAngle::operator-( const BesAngle& a ) const {
  return BesAngle( _phi - a._phi );
}
 
inline BesAngle BesAngle::operator-( const double a ) const { return BesAngle( _phi - a ); }
 
inline BesAngle BesAngle::operator*( const double x ) const { return BesAngle( _phi * x ); }
 
inline BesAngle BesAngle::operator/( const double x ) const { return BesAngle( _phi / x ); }
 
inline BesAngle operator*( const double x, const BesAngle& a ) { return BesAngle( a * x ); }
 
inline void BesAngle::operator=( const BesAngle a ) { _phi = normalize( a._phi ); }
 
inline void BesAngle::operator+=( BesAngle a ) { _phi = normalize( _phi + a._phi ); }
 
inline void BesAngle::operator+=( double a ) { _phi = normalize( _phi + a ); }
 
inline void BesAngle::operator-=( BesAngle a ) { _phi = normalize( _phi - a._phi ); }
 
inline void BesAngle::operator-=( double a ) { _phi = normalize( _phi - a ); }
 
inline void BesAngle::operator*=( double x ) { _phi = normalize( _phi * x ); }
 
inline void BesAngle::operator/=( double x ) { _phi = normalize( _phi / x ); }
 
inline int BesAngle::sector( int max ) {
  double phi = _phi;
  if ( phi < 0 ) phi += Constants::twoPi;
  return ( int( phi / ( Constants::twoPi / max ) ) + 1 );
}
 
inline int BesAngle::sector( int max, BesAngle phi_0 ) {
  BesAngle t( _phi - phi_0._phi );
  return t.sector( max );
}
 
inline double sin( const BesAngle a ) { return sin( a._phi ); }
 
inline double cos( const BesAngle a ) { return cos( a._phi ); }
 
inline double tan( const BesAngle a ) { return tan( a._phi ); }
 
#endif