Coordinates.h

Go to the documentation of this file.

#ifndef SZA_UTIL_COORDINATES_H
#define SZA_UTIL_COORDINATES_H

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

namespace sza {
  namespace util {
    
    class Coordinates : public Vector<double> {
    public:
      
      enum SrcDist {
        ACTUAL, // Actual source distance
        INF     // Source at infinity
      };
      
      Coordinates();
      
      Coordinates(Angle longitude, Angle latitude, double altitude);
      
      Coordinates(Coordinates& coord);
      
      virtual ~Coordinates();
      
      void setLla(Angle longitude, Angle latitude, double altitude);
      
      void setLongitude(Angle longitude);
      
      void setLatitude(Angle latitude);
      
      void setAltitude(double altitude);
      
      inline Angle& longitude() {
        return longitude_;
      }
      
      inline Angle& latitude() {
        return latitude_;
      }
      
      inline double& altitude() {
        return altitude_;
      }
      
      Vector<double> getAbsXyz(double east=0.0, double north=0.0, double up=0.0);
      
      Vector<double> getXyz(double east=0.0, double north=0.0, double up=0.0,
                            bool geocentric=true);
      
      Vector<double> getUen(Angle longitude, Angle latitude, double altitude);
      Vector<double> getUen(Coordinates& coords);
      
      Vector<double> getUvw(HourAngle ha, DecAngle declination);
      
      Vector<double> getLla(double east=0.0, double north=0.0, double up=0.0);
      
      Vector<Angle> getAzEl(Angle longitude, Angle latitude, double altitude);
      Vector<Angle> getAzEl(Coordinates& coords);
      
      void add(double up, double east, double north);
      
      //------------------------------------------------------------
      // Static member functions
      //------------------------------------------------------------
      
      static Vector<double> 
        lngLatAndAzElToLngLat(Angle& lng,       Angle& lat,
                              Angle& az,        Angle& el);

      static Vector<double> llaAndUenToLla(Angle longitude, Angle latitude, 
                                           double altitude, 
                                           double up, double east, double north);
      
      static Vector<double> llaAndLlaToUen(Angle fiducialLongitude, 
                                           Angle fiducialLatitude, 
                                           double fiducialAltitude, 
                                           Angle longitude, Angle latitude, 
                                           double altitude);
      
      static Vector<double> llaAndUenToAbsXyz(Angle longitude, Angle latitude,
                                              double altitude,
                                              double up, double east, double north, bool doTrans=true);
      
      static Vector<double> topoXYZToUen(double X, double Y, double Z, 
                                         Angle latitude);
      
      static Vector<double> absXyzToLla(double XA, double YA, double ZA);
      
      static Vector<double> absXyzAndUenToLla(double XA, double YA, double ZA,
                                              double up=0.0, double east=0.0, 
                                              double north=0.0);
      
      static Vector<double> laAndUenToXyz(Angle latitude, double altitude,
                                          double up=0.0, double east=0.0, 
                                          double north=0.0,
                                          bool geocentric=true);
      
      static Vector<double> azElToUen(Angle az, Angle el, double r=1.0);
      
      static Vector<Angle> uenToAzEl(double U, double E, double N);
      static Vector<Angle> uenToAzEl(Vector<double>& uen);
      
      static Vector<double> haDecAndXyzToUvw(HourAngle ha, DecAngle declination,
                                             double X, double Y, double Z);
      static Vector<double> haDecToXyz(HourAngle ha, DecAngle declination,
                                       bool geocentric=true, 
                                       SrcDist type=INF, double r=0.0);
      
      //=======================================================================
      // Given a delta HA and delta DEC, return the XYZ (direction
      // cosines only) coordinate
      //=======================================================================

      static Vector<double> dHaDdecToXyz(HourAngle dHa, Angle dDec);
      
      static void xyzToDhaDdec(double X, double Y, double Z, 
                               HourAngle& dHa, Angle& dDec);
      
      static void xyzToDhaDdec(Vector<double>& xyzVals, 
                               HourAngle& dHa, Angle& dDec);
      
      //=======================================================================
      // Given polar offsets on the sky from a given dec position
      // (assumed to be at HA=0h), theta (azimuthal) and rho (radial),
      // return the XYZ direction cosines.
      //=======================================================================

      static Vector<double> thetaRhoToXyz(Declination& dec, Angle& theta, Angle& rho);

      static Matrix<double> getThetaRhoToXyzDecRot(Declination& dec);
      static Matrix<double> getThetaRhoToXyzThetaRot(Angle& theta);
      static Matrix<double> getThetaRhoToXyzRhoRot(Angle& rho);
      
      static void raDecAndThetaRhoToRaDec(HourAngle& ra0, Declination& dec0, 
                                          Angle& theta, Angle& rho, 
                                          HourAngle& ra, Declination& dec);

      static Vector<Angle> 
        laAndHaDecToAzEl(Angle latitude, double altitude,
                         HourAngle ha, DecAngle declination, 
                         bool geocentric=true, 
                         SrcDist type=INF, double dist=1.0);
      
      static Delay getGeometricDelay(HourAngle ha, DecAngle declination,
                                     double X, double Y, double Z,
                                     double X0, double Y0, double Z0,
                                     bool doMotionCorrection);
      
      static Delay getGeometricDelay(Angle latitude, 
                                     Angle az, Angle el,
                                     double X, double Y, double Z);
      
      //------------------------------------------------------------
      // Some utility methods which it may be convenient to leave 
      // public
      //------------------------------------------------------------
      
      static Vector<double> getdUvw(HourAngle ha, DecAngle declination, 
                                    double X, double Y, double Z);
      
      static Vector<double> getd2Uvw(HourAngle ha, DecAngle declination, 
                                     double X, double Y, double Z);
      friend std::ostream& operator<<(std::ostream& os, Coordinates& coords);
      
    public:
      
      /*
       * Radius of the earth (meters)
       */
      static const double earthEqRadiusMeters_;
      
      static const double earthFlattening_;
      
      /*o
       * Speed of light (meters/sec)
       */
      static const double lightSpeed_;
      
      static const double auToMeters_;
      
      static const double earthRotVelRadPerSec_;
      
    private:
      
      Angle longitude_;
      Angle latitude_;
      double altitude_;
      
      static Matrix<double> getUenToXyzLonRot(Angle longitude);
      
      static Matrix<double> getUenToXyzLatRot(Angle latitude);
      
      static Matrix<double> getXyzToUvwDecRot(DecAngle declination);
      
      static Matrix<double> getXyzToUvwHaRot(HourAngle ha);
      
      static Matrix<double> getdXyzToUvwHaRot(HourAngle ha);
      
      static Matrix<double> getd2XyzToUvwHaRot(HourAngle ha);
      
    }; // End class Coordinates
    
  } // End namespace util
} // End namespace sza


#endif // End #ifndef SZA_UTIL_COORDINATES_H