Ephemeris.h

Go to the documentation of this file.

// -*- c++ -*-

#ifndef CARMA_SERVICES_EPHEMERIS_H
#define CARMA_SERVICES_EPHEMERIS_H

// just in case (novas itself also define _NOVAS_)
// but *nobody* should ever need to know this. See also services::novasWrapper
#define HAVE_LIBNOVAS


// debug also uses some static variables, so don't use this in production mode
// where threading is used.
//#define EPHEM_DEBUG

#include "carma/services/Vector.h"
#include "carma/services/Distance.h"
#include "carma/services/Length.h"
#include "carma/services/Velocity.h"
#include "carma/services/Source.h"
#include "carma/services/AntennaCoordinates.h"
#include "carma/services/AstroTime.h"
#include "carma/services/IERSTable.h"
#include "carma/services/EphemerisTable.h"
#include "carma/services/novasWrapper.h"

#include "carma/services/Atmosphere.h"


namespace carma {
  namespace services {

    class Ephemeris {
    public:

      Ephemeris();

      Ephemeris(const std::string &sourceName, 
                const std::string &catalogName="");

      virtual ~Ephemeris();

      Ephemeris(const Source &source);

      Ephemeris(const Location& location);


      void setLocation(const Location &location);

      void setLocation(const std::string &observatory, bool topocentric=true);

      Location getLocation(void) const;


      void setWeather(const double atmPressure, const double airTemp, 
                      const double relHumid);

      void setFreq(const double freq);

      double getFreq( void ) const;

      void setRefraction(const bool refract);

      void setBody(const int type, const int number, const std::string &name);

      void setBody(const std::string &name);

      void setMJD(const double mjd=0);

      double getMJD() const
      {
          return mjd_;
      }


      void setDeltaT(const double deltat=0);

      void setSource(const Source &source);

      void setSource(const std::string& sourceName, 
                     const std::string& catalogName = "");


      void setEphemerisTableSource(const double ra2000, const double dec2000, const double doppler, const double distance);

      Source getSource();

      void setRaDecOffsets(const double dra, const double ddec);

      void setAzElOffsets(const double daz, const double del);

      // some user friendly things, all in the current epoch, topocentric

      double getRa(void);

      double getDec(void);

      double getAz(void);

      double getEl(void);

      double getRefrac(void) const;

      double getDoppler(velocityFrameType frameType = FRAME_TOPOGRAPHIC);

      Vector<double> getRaDec(double mjd, double az, double el);

      Vector<double> getAzEl(double mjd, double ra, double dec);


      Vector<Angle> getAzEl(double mjd, const Angle &ra, const Angle &dec);

      void Debug(void);

      void planetDebug(void);

       double angle2000(void);


      void ShowVector(void);

      void SetSpinningBodySpot(double majorAxis, double minorAxis, double axisAngle, double tiltAngle,
                               double mjd,  double Longitude, double Latitude, double SpinRate);
      


    protected:
      void initialize(void);

      double refract(const double elevation);

      void compute(void);

      void ComputeFixedAzEl(void);

      bool my_set_body(short int type, short int number, const std::string& sourceName);

      Vector<double> hms(double angle);
      
      Vector<double> dms(double angle);






    private:
      novas::body      earth_;    // novas:: *we* always observe from here   body{0,3,'earth'}
      std::string      obs_;      // name of the site (via Location)
      novas::site_info site_;     // novas:: where we are (a novas:: struct)
      Location         location_; // copy of the original Location object
      
      novas::body      body_;     // novas:: the 'other' point of interest (or: SolarSystemBody)
      novas::cat_entry cat_;      // novas:: source info (dra/ddec are normally applied to ra/dec)
      novas::cat_entry fake_;     // novas:: fake source for quick ra/dec -> az,al lookup (getAzEl)
      bool             is_cat_;   // use body_ or cat_ to look at
      bool             is_eph_;   // body to be obtained from an RADEC table ephemeris?
      EphemerisTable   et_;       // if is_eph_, this is populated

      bool            fixed_;     // source is a fixed position on the planet (e.g. transmitter)
      Location fixed_object_;     // some nearby object that's fixed w.r.t. antennae
      double       fixed_az_;     // the computed (az,el) of fixed_object_ as seen from antennae
      double       fixed_el_;
 
      double     tjd_tt_;  // TT time at site [julian date]   -- not used at the time --
      double     tjd_;     // JD at site [utc]
      double     mjd_;     // MJD at site [utc]

      AstroTime  at_;      // our timekeeper (we don't use location dependant operations)

      
                           // things to look up from IERS tables
      //      IERSTable  iers_;    


      double     deltat_;  // TT-UT1 [seconds]
      double     tdbmtdt_; // TDB-TDT [seconds]  ** we don't use it **
      double     xpole_;   // x-coordinate of celestial ephemeris pole w.r.t. IERS reference pole (arcsec)
      double     ypole_;   // y-coordinate 

      double     freq_;    // Observing frequency [Hz]
      double     relhum_;  // Relative humidity [percent]
      bool       do_refract_;  // overall boolean that controls if refraction applied

      Source     source_;      // alternate for source, if given
      bool       use_source_;  // boolean to control what kind of 'source' is used (instead of ra/dec)
      std::string sourceName_; // The source name
      double     ra2000_;      // RA from catalog (J2000) [deg]
      double     dec2000_;     // DEC from catalog (J2000) [deg]
                               // Offsets are applied either in Ra,Dec *or* Az,El, not both
      int        offsetMode_;  // 0=none 1=ra/dec 2=az/el
      double     dra_;         // offet applied to any RA for mosaicing etc. [deg]
      double     ddec_;        // offet applied to any DEC for mosaicing etc.[deg]
      double     daz_;         // offset in Az [deg]
      double     del_;         // offset in El [deg]

      double     ra_;      // current RA/DEC, all topocentric  [deg]
      double     dec_;     // note these also have the DRA/DDEC applied  [deg]
      double     dis_;     // distance (0 if at infinity) [au]
      double     doppler_; // doppler velocity for this source  [km/s]
      double     az_;      // current AZ/EL [deg]
      double     el_;      // note these have the DRA/DDEC applied [deg]
      double     vearth_;  // local earth projection to source [km/s]
      double     vrest_;   // LSR projection to source (note sign) [km/s]
      double     vplanet_; // planet projection to earth [km/s]

      double     refr_;    // refraction coefficient [deg]

      // Units      units_;   // aid for unit conversion
      std::string  jpleph_;// filename of JPL planet ephemeris catalog (usually CARMA/conf/data/ephem/jpl.eph)

      carma::services::Atmosphere atm_;   // the atmosphere, for more sophosticated modeling (see also site_ )

      bool initialized_;    // keep track of overall initialization (since we have a few "constructor" type entry points)
      bool topocentric_;    // topocentric (alternative is geocentric, which we actually don't officially use)
      static const double deg2rad_;      // 180/PI  (multiply degrees with this to get to radians)
      static const double rad2deg_;      // PI/180  (multiply radians with this to get to degrees)

      bool recompute_;             // need to call compute() to recompute state ?
#ifdef EPHEM_DEBUG
      static int  ncall_;          // debugging, keep track how often expensive compute's are done
#endif

      void setSource(const double ra2000, 
                     const double dec2000, 
                     const double doppler, 
                     const double distance = 0.0)
          __attribute__((deprecated));


      bool isEphem(const std::string& sourceName);

      bool isPlanet(const std::string& sourceName);

public:
      bool isFixed(const std::string& sourceName);

      bool useSource(void) const {
        return use_source_;
      }


    }; // class Ephemeris
  } // namespace services
} // namespace carma

 
#endif