Location.h

#ifndef SZA_UTIL_LOCATION_H
#define SZA_UTIL_LOCATION_H

#include "carma/szautil/Angle.h"
#include "carma/szautil/Astrometry.h"
#include "carma/szautil/Atmosphere.h"
#include "carma/szautil/DecAngle.h"
#include "carma/szautil/Delay.h"
#include "carma/szautil/HourAngle.h"
#include "carma/szautil/Vector.h"

namespace sza {
  namespace util {
    
    class DelayLocation;
    class DelayAntennaLocation;
    class Source;
    
    class Location {
    public:
      
      enum ReqParam {
        NONE     = 0x0,
        SITE     = 0x2,
        LOCATION = 0x4,
        ALL      = SITE | LOCATION
      };
      
      Location();
      Location(Location& location);
      Location(const Location& location);

      void operator=(Location& loc)
        {
        }

      void operator=(const Location& loc)
        {
        }

      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 virtual double X(bool ec=true) {
        return ec ? geocentricXyz_[0] : topocentricXyz_[0];
      }
      
      inline virtual double Y(bool ec=true) {
        return ec ? geocentricXyz_[1] : topocentricXyz_[1];
      }
      
      inline virtual 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];
      }
      
      virtual Delay geometricDelay(DelayAntennaLocation* refDLoc,
                                   bool doMotionCorrection);
      virtual Delay geometricDelay(Angle az, Angle el, DelayAntennaLocation* refDLoc);
      
      Delay troposphericDelay(DelayAntennaLocation* refDLoc);

      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_;
      }

      inline Atmosphere& atmos() {
        return atmos_;
      }
 
      Angle& azimuth() {
        return azimuth_;
      }

      Angle& elevation() {
        return elevation_;
      }

    protected:
      
      HourAngle ha_;
      DecAngle dec_;
      Angle azimuth_;
      Angle elevation_;

      // 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_;
      
      Atmosphere atmos_;

      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 sza



#endif // End #ifndef SZA_UTIL_LOCATION_H