DelayLocation.h

Go to the documentation of this file.

#ifndef SZA_UTIL_DELAYLOCATION_H
#define SZA_UTIL_DELAYLOCATION_H

#include "carma/szautil/Debug.h"
#include "carma/szautil/Delay.h"
#include "carma/szautil/Location.h"
#include "carma/szautil/Source.h"

namespace sza {
  namespace util {
    
    class DelayAntennaLocation;
    class DelayManager;
    class MonitorPoint;
    class MonitorPointManager;
    
    class DelayLocation : public Location {
    public:
      
      DelayLocation();
      
      virtual ~DelayLocation();
      
      void setFixedDelay(Delay delay);
      
      void setAdjustableDelay(Delay delay);
      
      inline Delay adjustableDelay() {
        return referredAdjustableDelay_;
      }
      
      inline Delay fixedDelay() {
        return referredFixedDelay_;
      }
      
      inline Location& location() {
        return (Location&) *this;
      }
      
      virtual void locationChanged(Location* loc);
      
      // Toggle using various delays
      
      void useAdjustableDelay(bool use);
      void useFixedDelay(bool use);
      void useGeometricDelay(bool use);
      void useIonosphericDelay(bool use);
      void useTroposphericDelay(bool use);
      void useThermalDelay(bool use);
      
      Delay totalDelay(double mjd, sza::util::Source* src,
                       DelayAntennaLocation* refDLoc,
                       bool doMotionCorrection);

      Delay totalDelay(Angle az, Angle el,
                       DelayAntennaLocation* refDLoc);
      
      Delay geometricDelay(DelayAntennaLocation* refDLoc,
                           bool doMotionCorrection);
      
      Delay geometricDelay(Angle az, Angle el,
                           DelayAntennaLocation* refDLoc);
      
      Delay troposphericDelay(DelayAntennaLocation* refDLoc);
      
      inline bool discontinuity() {
        return discontinuity_;
      }

      void markAsDiscontinuous(bool disc) {
        discontinuity_ = disc;
      }
      
    protected:
      
      // DelayManager is a friend of this class
      
      friend class DelayManager;
      
      DelayManager* delayListener_;

      DelayManager* locationListener_;
      
    public:
      // The physical location associated with this object
      
      Location location_;
      
    protected:
      // A manager for monitor points

      MonitorPointManager* monitor_;

      MonitorPoint* monAdjustableDelay_;
      MonitorPoint* monUseAdjustableDelay_;
      MonitorPoint* monFixedDelay_;
      MonitorPoint* monUseFixedDelay_;
      MonitorPoint* monGeometricDelay_;
      MonitorPoint* monUseGeometricDelay_;
      MonitorPoint* monTroposphericDelay_;
      MonitorPoint* monUseTroposphericDelay_;
      MonitorPoint* monLocation_;

      // Update monitor points managed by this object in the register
      // database

      virtual void updateMonitors();

    protected:
      
      // True if this location's parameters have changed

      bool discontinuity_;

      // The fixed delay relative to some fiducial point
      
      Delay fiducialFixedDelay_;

      // A user-adjustable delay relative to some fixed point
      
      Delay fiducialAdjustableDelay_;
      
      // The fixed delay relative to an arbitrary reference point
      
      Delay referredFixedDelay_;
      
      // A user-adjustable delay relative to an arbitrary reference point
      
      Delay referredAdjustableDelay_;
      
      // The last calculated geometric delay
      
      Delay lastGeometricDelay_;

      // The last calculated tropospheric delay
      
      Delay lastTroposphericDelay_;

      // Toggle using various delays
      
      bool useAdjustableDelay_;
      bool useFixedDelay_;
      bool useGeometricDelay_;
      bool useIonosphericDelay_;
      bool useTroposphericDelay_;
      bool useThermalDelay_;
      
      void registerDelayCallback(DelayManager* delayListener);
      
      void registerLocationCallback(DelayManager* locationListener);

      void referFixedDelayTo(Delay delay);
      
      void referAdjustableDelayTo(Delay delay);
      
      inline Delay fiducialFixedDelay() {
        return fiducialFixedDelay_;
      }
      
      inline Delay fiducialAdjustableDelay() {
        return fiducialAdjustableDelay_;
      }
      
      // Update values in the register database

      void updateUseAdjustableDelay();
      void updateUseFixedDelay();
      void updateUseGeometricDelay();
      void updateUseTroposphericDelay();

      void updateAdjustableDelay();
      void updateFixedDelay();
      void updateGeometricDelay();
      void updateTroposphericDelay();

      void updateLocation();
      
    }; // End class DelayLocation
    
  } // End namespace util
} // End namespace sza



#endif // End #ifndef SZA_UTIL_DELAYLOCATION_H