Phi.h

Go to the documentation of this file.

//===============================================
//                Phi class
//===============================================
//
//  A utility class to implement the cyclic nature
//  of the phi variable in the range  -Pi <-> Pi
// 
//  The constructor uses a double number, which is reduced to
//  the required range by repeated addition or subtraction of 2*Pi
// 
//  The operation in any arithmetic expression involving Phi and
//  double numbers is understood in this way:
//
//  - wherever any double number is used then it is implicitly converted
//    to a Phi as per the constructor. The operation then proceeds exactly
//    as if the expression contained only 
//
// -  The user can add and subtract Phi objects and the result is automatically
//  kept within a cyclic range.
//
//  -The difference between two PHI objects always represents the smallest 
//   angle between them, signed according to whether this is clockwise
//   or anticlockwise.
//
// - Most operations are convertable to use a double arguments where sensible. 
//


#ifndef PHI_H
#define PHI_H
class Phi;
class MsgStream;
//output operators for the Athena MessageStream 
MsgStream& operator << ( MsgStream&, const Phi& ) ;      
MsgStream& operator << ( MsgStream&, const Phi* const) ; 

class Phi {
  
 private:
  
  double m_val ;
  
  void reduce() {
    while( m_val >  s_upperLimit )  { m_val -= s_range ; }
    while( m_val <= s_lowerLimit  ) { m_val += s_range ; }
  }
  static const double s_upperLimit;
  static const double s_lowerLimit;
  static const double s_range;
  
  
  
 public:
  
  // Constructors:
  Phi() { this->m_val = 0. ;  }
  Phi( double init )     { this->m_val = init ; this->reduce() ; }
  Phi( const Phi& src )        { this->m_val = src.m_val ; } 
  
  // Arithmetic:
  
  Phi& operator= ( const Phi& rhs ) { 
    this->m_val = rhs.m_val; 
    return *this; 
  }
  
  Phi& operator+= ( Phi& rhs )  { 
    this->m_val += rhs.m_val ; 
    reduce() ;
    return *this; 
  }
  
  Phi& operator-= ( Phi& in )  { 
    this->m_val -= in.m_val;
    reduce() ;
    return *this; 
  }
  
  Phi operator+ ( Phi& in )  const { 
    Phi result( this->m_val + in.m_val ) ;
    return result ;
  }
  
  Phi operator- ( Phi& in )  const { 
    Phi result(this->m_val - in.m_val ) ;
    return result ;
  }
  
  // boolean 
  bool operator< ( Phi& in ) const { return this->m_val < in.m_val ; }
  bool operator> ( Phi& in ) const { return this->m_val > in.m_val ; }
  
  // Conversions
  operator double() const { return this->m_val ; }
  // debug
  double lowerLimit() const {return s_lowerLimit;}
  double upperLimit() const {return s_upperLimit;}
  double range     () const {return s_range;}
  double val()        const {return m_val;}
};
#endif

---