AntennaCoordinates.h

Go to the documentation of this file.

// $Id: AntennaCoordinates.h,v 1.17 2006/01/20 16:03:22 mpound Exp $
#ifndef CARMA_SERVICES_ANTENNA_COORDINATES_H
#define CARMA_SERVICES_ANTENNA_COORDINATES_H

#include "carma/services/Angle.h"
#include "carma/services/Location.h"
#include "carma/services/Vector.h"

namespace carma {
  namespace services {

    class Delay;
    class Distance;
    class HourAngle;
    
    class AntennaCoordinates : public Vector<double> {
    public:
      
      AntennaCoordinates();
      
      AntennaCoordinates(Angle longitude, Angle latitude, Length altitude);

      AntennaCoordinates(const carma::services::Location& location);

      AntennaCoordinates( const AntennaCoordinates & rhs );

      virtual ~AntennaCoordinates();
      

      AntennaCoordinates & operator=( const AntennaCoordinates & rhs );

      void setLla(Angle longitude, Angle latitude, Length altitude);
      
      void setLongitude(Angle longitude);
      
      void setLatitude(Angle latitude);
      
      void setAltitude(Length altitude);
      
      inline const Angle& longitude() const {
        return longitude_;
      }
      
      /*
       * Get the latitude of these coordinates.
       * @return carma::services::Angle representing the latitude 
       */
      inline const Angle& latitude() const {
        return latitude_;
      }
      
      inline const Length& altitude() const {
        return altitude_;
      }
      
      Vector<double> getAbsXyz(double up    = 0.0,
                               double east  = 0.0, 
                               double north = 0.0);
      
      Vector<double> getXyz(double up    = 0.0, 
                            double east  = 0.0, 
                            double north = 0.0,
                            bool geocentric = true);
      
      Vector<double> getUen(Angle longitude, Angle latitude, Length altitude);

      Vector<double> getUen(AntennaCoordinates& coords);
      
      Vector<double> getUvw(HourAngle ha, Angle declination);
      
      Vector<double> getLla(double up    = 0.0,
                            double east  = 0.0, 
                            double north = 0.0);
      
      Vector<Angle> getAzEl(Angle longitude, Angle latitude, Length altitude);

      Vector<Angle> getAzEl(AntennaCoordinates& coords);
      
      void add(double up, double east, double north);
      
      //------------------------------------------------------------
      // Static member functions
      //------------------------------------------------------------
      
      static Vector<double> llaAndUenToLla(Angle longitude,
                                           Angle latitude, 
                                           Length altitude, 
                                           double up, double east, double north);
      
      static Vector<double> llaAndLlaToUen(Angle fiducialLongitude, 
                                           Angle fiducialLatitude, 
                                           Length fiducialAltitude, 
                                           Angle longitude, Angle latitude, 
                                           Length altitude);
      
      static Vector<double> llaAndUenToAbsXyz(Angle longitude, 
                                              Angle latitude,
                                              Length altitude,
                                              double up, 
                                              double east, 
                                              double north);
      
      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, Length 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, Angle declination,
                                             double X, double Y, double Z);
      static Vector<double> haDecToXyz(HourAngle ha, Angle declination,
                                       Distance distance,
                                       bool geocentric=true
                                       );
      
      static Vector<Angle> 
        laAndHaDecToAzEl(Angle latitude, Length altitude,
                         HourAngle ha, Angle declination, 
                         Distance distance,
                         bool geocentric=true
                         );
      
      static Delay getGeometricDelay(HourAngle ha, Angle declination,
                                     double X, double Y, double Z,
                                     double X0, double Y0, double Z0,
                                     bool doMotionCorrection);
      
      static Delay getGeometricDelay(Angle latitude, 
                                     Length altitude, 
                                     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, Angle declination, 
                                    double X, double Y, double Z);

      static Vector<double> getd2Uvw(HourAngle ha, Angle declination, 
                                     double X, double Y, double Z);
      friend std::ostream& operator<<(std::ostream& os, const AntennaCoordinates& coords);
      
    private:

      Angle longitude_;
      Angle latitude_;
      Length altitude_;

      static Matrix<double> getUenToXyzLonRot(Angle longitude);
      
      static Matrix<double> getUenToXyzLatRot(Angle latitude);
      
      static Matrix<double> getXyzToUvwDecRot(Angle declination);
      
      static Matrix<double> getXyzToUvwHaRot(HourAngle ha);
      
      static Matrix<double> getdXyzToUvwHaRot(HourAngle ha);
      
      static Matrix<double> getd2XyzToUvwHaRot(HourAngle ha);
      
    }; // End class AntennaCoordinates
    
  } // End namespace services
} // End namespace carma


#endif // End #ifndef CARMA_SERVICES_ANTENNA_COORDINATES_H