---

GPS.h

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/flux/flux/GPS.h,v 1.7 2001/10/31 23:20:04 srobinsn Exp $
// GPS.h: interface for the GPS class.
//
//      Models the Global Positoning System for a spacecraft. Handles time
//      position, and orientation for the instrument as a whole.

#if !defined(_H_GPS_CLASS)
#define _H_GPS_CLASS

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "facilities/Scheduler.h"
#include "facilities/Observer.h"
#include "geometry/Point.h"

#include <iostream>

class Orbit;
// 
//  class GPS
//
/*!  object is used to compute the spacecraft's position and pointing characteristics.
  Time is tracked through this object, and synchronized with the Scheduler for 
  discrete event simulation. An expansion factor is provided to allow for acceleration
  or randomization of the orbit. If the expansion factor is negative, then the position
  of the spacecraft is chosen as a random distribution over an orbit. Otherwise, the expansion
  factor represents an acceleration of the spacecraft's orbit. Ie. an expansion factor
  of 2 would reduce the orbit period of the spacecraft by 1/2.
*/
class GPS  
{
public:
    class Coords {
    public:
        Coords( double alat, double alon, double apitch
            , double ayaw, double aroll, GPStime atime, double phase ); 
        Coords();
        
        GPStime time () const { return m_time; }
        double  lat () const { return m_lat; }
        double  lon () const { return m_lon; }
        double  pitch () const { return m_pitch; }
        double  yaw () const { return m_yaw; }
        double  roll () const { return m_roll; }
        double  phase () const { return m_phase; }
        
    private:
        GPStime m_time;
        double m_lat, m_lon, m_pitch, m_yaw, m_roll, m_phase;
    };
    
    // const access
    
    GPStime     time () const; 
    double      lat () const; 
    double      lon () const; 
    double      pitch () const; 
    double      yaw () const; 
    double      roll () const; 
    double      phase () const;
    const Orbit* orbit () const;
    Coords      state () const;  
    double      expansion () const; 
    GPStime     sampleintvl () const; 
    double     ascendingLon()const; 
    std::pair<double,double> rotateAngles(); 
    // set data
    
    void    orbit ( Orbit* );
    void    pass ( double );
    void    phase ( double );
    void    expansion ( double );
    void    synch ();    
    void    sampleintvl ( GPStime );
    void    ascendingLon(double);   
    void        rotateAngles(std::pair<double,double> coords); 
    
    void    printOn(std::ostream& out) const; 
    
    // notification
    void notifyObservers() { m_notification.notify();}
    Subject&    notification() { return m_notification; }
    
    // static access/destruction
    static GPS* instance();
    static void     kill ();
    
    /*Vector*/std::pair<double,double> galToGlast(std::pair<double,double> galcoords);
    
    
    
    protected:
        // singleton - protect ctor/dtor
        GPS();
        virtual ~GPS();
        
        // only class/subclasses have access
        void    pitch ( double );       // set pitch
        void    yaw ( double );         // set yaw
        void    roll ( double );        // set roll
        void    lat ( double );         // set latitude
        void    lon ( double );         // set longitude
        void    time ( GPStime );       // set time
        Orbit*  orbit ();               // access the orbit (for manipulation)
        GPStime orbittime () const;     // access to orbit time
        void    orbittime ( GPStime );  // set orbit time
        void    setState ( const GPS::Coords& ); // set the orbital parameters
        std::pair<double,double> m_rotangles;  //angles for coordinate rotation
        
        
        
        
        // friends
        friend class FluxGenerator;
        
    private:
        static GPS* s_instance;
        
        Orbit*  m_orbit;        // orbital position object 
        double  m_expansion;    // orbit expansion factor
        GPStime m_time;     // global time
        GPStime m_orbittime;    // time in orbit (depends on expansion)
        double  m_sampleintvl;  // interval to sample for each pt. in the orbit - to normalize spectra
        
        // notification
        Subject    m_notification; 
        
};

inline std::istream&    operator>>(std::istream& i, GPS::Coords& c) {
    double  p, y, r, lt, ln, tm, ph;
    i >> lt; i >> ln; i >> p; i >> y; i >> r; i >> tm; i >> ph;
    c = GPS::Coords( lt, ln, p, y, r, tm, ph );
    return i;
}

inline std::ostream&    operator<<(std::ostream& o, const GPS::Coords& c) {
    o << ' ' << c.lat() << ' ' << c.lon() << ' ' 
        << c.pitch() << ' ' << c.yaw() << ' ' 
        << c.roll() << ' ' << c.time() <<' ' << c.phase();
    return o;
}
#endif // !defined(AFX_GPS_H__F9844433_4E64_11D2_B4DD_00A0C9960210__INCLUDED_)

---