DelayEngine.h

Go to the documentation of this file.

#ifndef CARMA_INTERFEROMETRY_DELAYENGINE_H
#define CARMA_INTERFEROMETRY_DELAYENGINE_H

#include "carma/services/Atmosphere.h"
#include "carma/interferometry/DelayInfo.h"
#include "carma/interferometry/DelayStatus.h"
#include "carma/monitor/DelayEngineSubsystem.h"
#include "carma/services/AntennaCoordinates.h"
#include "carma/services/AstroTime.h"
#include "carma/services/Ephemeris.h"
#include "carma/services/Frequency.h"
#include "carma/services/Types.h"

#include <vector>


namespace carma {

  namespace services {
      // forward declarations
      class Length;
      class Location;
      class Pressure;
      class Temperature;
  }

  namespace interferometry {

    typedef ::std::vector< const carma::monitor::DelayEngineSubsystem * >
             DelayFrameVec;
    class DelayEngine
    {

        public:
    DelayEngine();

    ~DelayEngine();

      void setAntennaCoordinates( unsigned short antennaNo,
                                  double x, double y, double z,
                                  services::AntennaCoordinateType acType,
                                  double axisMis );
      void setAntennaCoordinates( unsigned short antennaNo,
              const services::Location & location, 
          const services::Length &   axisMis);
      void setAxisMisalignment( unsigned short antennaNo,
                                const services::Length & axisMis);
      void setArrayReferencePoint(const services::Location & location);

      void setAntennaRaDec( unsigned short antennaNo,
                            double mjd,
                            double pntra, double pntdec,
                            double phsra, double phsdec,
                            bool logAction, const std::string& source
                           );

      void setAntennaLOFreq( unsigned short antennaNo, 
                             const services::Frequency & LO1freq);

      void setAllAntennaLOFreqs( const services::Frequency & LO1freq );
      
      void setAntennaAzEl( unsigned short antennaNo,
                           double mjd,
                           double pntaz, double pntel,
                           double phsaz, double phsel
                          );

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

      void setWeather( const services::Temperature & airTemp,
                       const services::Pressure & atmPressure,
                       double relHumid ) ;


      void setDelayOffset( unsigned short antennaNo, double delay );

      void setPadDelay( unsigned short antennaNo, double delay );

      void setAntennaDelays(unsigned short antennaNo, double antDelay,
            double opticsDelayMM, double opticsDelayCM, 
            double loCableDelayMM, double loCableDelayCM);

      void setAdjustableDelay( unsigned short antennaNo, double delay );

      void setRxDelayPol1(unsigned short antennaNo, double delay);

      void setRxDelayPol2(unsigned short antennaNo, double delay);

      void useAdjustableDelay( unsigned short antennaNo, bool useit );

      void useGeometricDelay( unsigned short antennaNo, bool useit );

      void useHeightDelay( unsigned short antennaNo, bool useit );

      void useIonosphericDelay( unsigned short antennaNo, bool useit );

      void useTroposphericDelay( unsigned short antennaNo, bool useit );

      void useThermalDelay( unsigned short antennaNo, bool useit );

      DelayFrameVec computeDelays(void);

      bool selfTest (bool verbose );

      void testAgainstBima(void);

    private: 

        // prevent copying and assignment
        DelayEngine( const DelayEngine& );
        DelayEngine &operator=( const DelayEngine& );

        void initialize(void) ;

        void finishCoordinates(unsigned short antennaNo,
                              double mjd,
                              double raPointingOffset,
                              double decPointingOffset,
                              double raPhaseOffset,
                              double decPhaseOffset,
                              bool isJ2000,
                              const std::string& source
                  );

        // subroutines to compute various delays
        
        double computeTotalFixedDelay(unsigned short antennaNo);
                                      
        double computeTotalDelay(unsigned short antennaNo, 
                                 DelayInfo & delayInfo,
                                 DelayInfo & refPtInfo);

        double computeAxisDelay(unsigned short antennaNo, 
                                DelayInfo & delayInfo);

        double computeGeometricDelay(unsigned short antennaNo, 
                                     DelayInfo & delayInfo);

        double computeHeightDelay(unsigned short antennaNo, 
                                  DelayInfo & delayInfo);


        double computeIonosphericDelay(unsigned short antennaNo, 
                                       DelayInfo & delayInfo);

        /*
         * Compute the delay due to thermal changes in the
         * antenna structure.
         * @param antennaNo Antenna identification
         * @param delayInfo The DelayInfo object from which to
         * use parameters for delay calculation.
         * @return Thermal delay, nanosec
         */
        double computeThermalDelay(unsigned short antennaNo, 
                                   DelayInfo & delayInfo);

        /*
         * Compute the delay due to propogation through the
         * troposphere. Along the way, this method also calculates
         * the pathlength and zenith refractivity, which are
         * Delay Engine monitor points.
         *
         * @param antennaNo Antenna identification
         * @param delayInfo The DelayInfo object from which to
         * use parameters for delay calculation.
         * @return Tropospheric delay, nanosec
         */
        double computeTroposphericDelay(unsigned short antennaNo, 
                                        DelayInfo & delayInfo);

        double computePointingCenterHourAngle(unsigned short antennaNo, 
                                              const DelayInfo & delayInfo);

        double computePhaseCenterHourAngle(unsigned short antennaNo,
                                           const DelayInfo & delayInfo);

        
        void setLocation( unsigned short antennaNo, 
                          const DelayInfo & delayInfo );

        void fillInMonitorPoints(
            const DelayInfo & delayInfo,
            monitor::DelayEngineSubsystem & monitorFrame );


        std::string debugPrint(const DelayInfo & delayInfo);

        double computeBimaDelay(unsigned short antennaNo, 
                                const DelayInfo & delayInfo);

 
        void computeDelays(unsigned short antennaNo);

    //-------------- MEMBER VARIABLES -----------------
    
    // units conversion helper
        carma::services::Units units_;

        carma::services::Ephemeris ephemeris_;

        carma::services::AstroTime astroTime_;

        carma::services::Atmosphere atm_;


        bool arrayRefPtSet_;  // false

        carma::services::AntennaCoordinates arrayRefPt_;

        DelayInfo current_;          /* 40 seconds from now */
        DelayInfo penultimate_;      /* 20 seconds from now */
        DelayInfo antepenultimate_;  /* now */
        DelayInfo modified_;         /* intermediate, temporary, to keep
                                     * current pristine so that current
                                     * can be copied to penultimate when
                                     * it is superceded.
                                     * modifed always
                                     * gets copied to current when 
                                     * computeDelays() 
                                     * is called 
                                     */

    /* For calculating various delays at the array
        * at the array reference point, which will be
    * subtracted from the associated delays at the
    * antenna.
        */
    std::vector<DelayInfo> refPtDelay_;

    // a container for the current, pen, ante DelayInfos
    std::vector<DelayInfo> dtriplet_;

    // for testing purposes against bima code
    DelayInfo bima_;

    DelayStatus* delayStatus_;

    std::vector<double> totalFixedDelay_; 
        
    std::vector<double> adjustableDelay_; 

    std::vector<double> delayOffset_; 

    std::vector<double> padDelay_; 

    std::vector<double> antDelay_; 
    std::vector<double> opticsDelayMM_; 
    std::vector<double> opticsDelayCM_; 
    std::vector<double> loCableDelayMM_; 
    std::vector<double> loCableDelayCM_; 

    std::vector<double> rxDelayPol1_; 

    std::vector<double> rxDelayPol2_; 


    static const std::string RaDec;
    static const std::string AzEl;
        
        static monitor::DelayEngineSubsystem &
        ensureAllocated( ::std::auto_ptr< monitor::DelayEngineSubsystem > & );
        
        ::std::auto_ptr< monitor::DelayEngineSubsystem > des0_;
        ::std::auto_ptr< monitor::DelayEngineSubsystem > des1_;
        ::std::auto_ptr< monitor::DelayEngineSubsystem > des2_;

    static const unsigned short ANTEPENULTIMATE = 0;
    static const unsigned short PENULTIMATE     = 1;
    static const unsigned short CURRENT         = 2;

    bool freqSet_;
    services::Frequency freq_; // GHz
    };
  } // namespace interferometry
} // namespace carma


#endif //CARMA_INTERFEROMETRY_DELAYENGINE_H