Location.h

Go to the documentation of this file.

#ifndef GCP_UTIL_LOCATION_H
#define GCP_UTIL_LOCATION_H

#include "gcp/util/common/Angle.h"
#include "gcp/util/common/Astrometry.h"
#include "gcp/util/common/DecAngle.h"
#include "gcp/util/common/Delay.h"
#include "gcp/util/common/HourAngle.h"
#include "gcp/util/common/Vector.h"

namespace gcp {
  namespace util {
    
    class DelayLocation;
    class Source;
    
    class Location {
    public:
      
      enum ReqParam {
    NONE     = 0x0,
    SITE     = 0x2,
    LOCATION = 0x4,
    ALL      = SITE | LOCATION
      };
      
      Location();
      
      virtual ~Location();
      
      void setFiducialSite(Angle longitude, Angle latitude, double altitude);
      
      void setOffset(double up, double east, double north);
      
      bool canLocate();
      
      bool canBracket(double mjdUtc);
      
      bool changed();
      
      inline Angle longitude(bool fiducial) {
    return fiducial ? fiducialLongitude_ : actualLongitude_;
      }
      
      inline Angle latitude(bool fiducial) {
    return fiducial ? fiducialLatitude_ : actualLatitude_;
      }
      
      inline double altitude(bool fiducial) {
    return fiducial ? fiducialAltitude_ : actualAltitude_;
      }
      
      inline Vector<double> getXyz(bool geocentric=true) {
    if(geocentric)
      return geocentricXyz_;
    else
      return topocentricXyz_;
      }
      
      inline double X(bool ec=true) {
    return ec ? geocentricXyz_[0] : topocentricXyz_[0];
      }
      
      inline double Y(bool ec=true) {
    return ec ? geocentricXyz_[1] : topocentricXyz_[1];
      }
      
      inline double Z(bool ec=true) {
    return ec ? geocentricXyz_[2] : topocentricXyz_[2];
      }
      
      inline Vector<double> getUen() {
    return uen_;
      }
      
      inline double up() {
    return uen_[0];
      }
      
      inline double east() {
    return uen_[1];
      }
      
      inline double north() {
    return uen_[2];
      }
      
      Delay geometricDelay(HourAngle ha, DecAngle dec,
               Location& refLoc,
               bool doMotionCorrection);
      Delay geometricDelay(Angle az, Angle el,
               Location& refLoc);
      
      void registerLocationCallback(DelayLocation* delayLocation);
      
      HourAngle getLst(double mjd);
      
      HourAngle getHa(double mjdUtc, HourAngle ra);
      HourAngle getHa(double mjdUtc, Source* src);
      
      inline Astrometry& ephem() {
    return astrom_;
      }
      
    private:
      
      // A bitmask of lacking parameters required to determine a
      // location
      
      unsigned lacking_;
      
      // True if parameters for this object have changed 
      
      bool changed_;
      
      // The fiducial point
      
      Angle fiducialLongitude_;
      Angle fiducialLatitude_;
      double fiducialAltitude_;
      
      //------------------------------------------------------------
      // Different representations of this location
      
      // Absolute (L, L, A) of this location
      
      Angle actualLongitude_;    
      Angle actualLatitude_;
      double actualAltitude_;
      
      // (U, E, N) of this location, relative to the fiducial
      
      Vector<double> uen_; 
      
      // Geocentric (X, Y, Z) relative to the fiducial
      
      Vector<double> geocentricXyz_; 
      
      // Topocentric (X, Y, Z) relative to the fiducial
      
      Vector<double> topocentricXyz_;
      
      Astrometry astrom_;
      
      void updateCoordinates();
      
      // When coordinates are updated, this class can call a
      // DelayLocation object who has registered to be notified.
      
      friend class DelayLocation;
      
      DelayLocation* delayLocation_;
      
    }; // End class Location
    
  } // End namespace util
} // End namespace gcp




#endif // End #ifndef GCP_UTIL_LOCATION_H