DriveHandle.h

Go to the documentation of this file.

#ifndef CARMA_CONTROL_DRIVEHANDLE_H
#define CARMA_CONTROL_DRIVEHANDLE_H

#include <string>
#include <memory>
#include <vector>

#include "carma/corba/corba.h"
#include "carma/antenna/common/DriveControl.h"
#include "carma/control/antennaHandleUtils.h"
#include "carma/control/AzWrapMode.h"
#include "carma/control/MjdTriplet.h"
#include "carma/control/RemoteObjHandleT.h"
#include "carma/monitor/ControlSubsystem.h"
#include "carma/monitor/ControlSubsystemExt.h"
#include "carma/services/Ephemeris.h"
#include "carma/services/Location.h"
#include "carma/services/SourceChecker.h"
#include "carma/services/Source.h"
#include "carma/services/Types.h"

namespace carma {
// forward declarations
    namespace monitor {
        class MonitorSystem;
    } // namespaec monitor

    namespace services {
        class Angle;
        class Pressure;
        class Temperature;
        class Velocity;
    }  // namespace carma::services
// end forward declarations

namespace control {

typedef RemoteObjHandleT< antenna::common::DriveControl >
        DriveControlRemoteObjHandle;
        
class DriveHandle : public DriveControlRemoteObjHandle {
public:
    DriveHandle( unsigned short                   carmaAntNo,
                 const services::Location &       coords,
                 monitor::MonitorSystem &         monitorSystem,
                 monitor::ControlSubsystemBase::Antenna & antenna
               );

    virtual ~DriveHandle( );

    // note source and userCatalog cannot be string& because 
    // makeHandleMethodFunctorGroup barfs on that.
    void startTrack( const ::std::string source,
                     const carma::control::MjdTriplet mjdTriplet,
                     const ::std::string userCatalog,
                     const carma::control::AzWrapMode azWrapMode,
                     double time,
                     int preferredSequenceNo );
    
    // weird, need the "X" here (i.e. a different method name) 
    // or I get an unresolved overloaded
    // function in the makeHandleMethodFunctorGroup call in 
    // SubarrayControlTrack.cc line 208
    void startTrackX( const carma::services::Source source,
                     const carma::control::MjdTriplet mjdTriplet,
                     const carma::control::AzWrapMode azWrapMode,
                     double time,
                     int preferredSequenceNo );

    void trackCurrentSourceWithOffsets( 
        const carma::control::MjdTriplet mjdTriplet, 
        const ::std::string userCatalog,
        carma::control::AzWrapMode azWrapMode, 
        int preferredSequenceNo );

    void trackCurrentSourceWithOffsets( 
        const carma::control::MjdTriplet mjdTriplet, 
        carma::control::AzWrapMode azWrapMode, 
        int preferredSequenceNo );

    void setLocation( const services::Location & location );

    services::Location getLocation() const;

    services::Ephemeris getEphemeris() const;

    void setOffset (double azArcmin, double elArcmin, int preferredSequenceNo );

    void setAzOffset (double azArcmin, int preferredSequenceNo) ;

    void setElOffset (double elArcmin, int preferredSequenceNo) ;

    void setAzel( double azDegrees, double elDegrees, int preferredSequenceNo );

    void setAz( double azDegrees, int preferredSequenceNo );

    void setEl( double elDegrees, int preferredSequenceNo );

    void setMountOffset( double azArcmin, 
                         double elArcmin, 
                         int preferredSequenceNo );

    void stow( antenna::common::DriveControl::Position position,
               int preferredSequenceNo );

    void stop( );

    void setSafeRange(float azLow, float azHigh, float elLow, float elHigh);
    
    void updateTracking( double mjd );

    void updateWeather( double                        mjd,
                        const services::Temperature & airTemp,
                        const services::Pressure    & atmPressure,
                        double                        relhumid,
                        const services::Temperature & dewpointTemp, 
                        const services::Velocity    & windSpeed,
                        const services::Angle       & windDirection,
                        bool                          logGoodSend );

    void setEquatOffset(double ra, double dec);
    
    void checkModeForEquatOffset( void );


    unsigned short getCarmaAntennaNo( ) const;

    ::std::string getCarmaAntennaName( ) const;

    ::std::string getTypedAntennaName( ) const;

    ::std::string getSourceName() ;
    carma::services::Source getSource() ;

    void setOvroMountPointingConstants( double m1,
                                        double m2,
                                        double m3,
                                        double m4,
                                        double m5 );

    void setBimaMountPointingConstants( ::std::vector< double > dazCoefs,
                                        ::std::vector< double > delCoefs );


    void setSzaMountPointingConstants(
          double azEncoderCountsPerTurn,     double elEncoderCountsPerTurn,
          double azMinEncoderCount,          double azMaxEncoderCount,
          double elMinEncoderCount,          double elMaxEncoderCount,
          double azEncoderZeroDegrees,       double elEncoderZeroDegrees,
          double haTiltDegrees,              double latTiltDegrees, double elTiltDegrees,
          double opticalXCollimationDegrees, double opticalYCollimationDegrees, 
          double opticalFlexureSinDegrees,   double opticalFlexureCosDegrees,
          double radioXCollimationDegrees,   double radioYCollimationDegrees, 
          double radioFlexureSinDegrees,     double radioFlexureCosDegrees);


    void setSzaEncoderLimits(double azMinEncoderCount, 
                             double azMaxEncoderCount,
                             double elMinEncoderCount, 
                             double elMaxEncoderCount);


    void setSzaEncoderZeros(double azEncoderZeroDegrees, double elEncoderZeroDegrees);


    void setSzaTilts(double haTiltDegrees, double latTiltDegrees, double elTiltDegrees);

    void trackingThreshold(float hpbw) ;
        
    void conditionallyUpdateTrackTolerance(const double freq) ;

    void updateTrackTolerance(const float tolerance, const double freq); 
      
     bool isActionComplete( const monitor::MonitorSystem & monsys,
                            int                            monDataErrorLimit );
    
    typedef enum {
        SOURCE_MODE_RA_DEC,
        SOURCE_MODE_AZ_EL,
        SOURCE_MODE_IDLE,
        SOURCE_MODE_INVALID
    } SourceMode;
    

    SourceMode getSourceMode( ) const;

    void test( double aSeconds,
               double bSeconds,
               long   whichTest );
    
private:

    void trackFixed( const std::string & source, int preferredSequenceNo );

    void track( const ::std::string & source,
                const carma::control::MjdTriplet & triplet,
                bool                  resetTrackOffsets,
                const std::string &   userCatalog,
                carma::control::AzWrapMode azWrapMode,
                int preferredSequenceNo );

    void track( const carma::services::Source & source,
                const carma::control::MjdTriplet & triplet,
                bool                  resetTrackOffsets,
                carma::control::AzWrapMode azWrapMode,
                int preferredSequenceNo );

    void updateRaDec( const ::std::string & sourceName,
                      double mjd, double ra, double dec,
                      carma::control::AzWrapMode azWrapMode );

    void setSourceModeToIdle( );
    void setSourceModeToRaDec( );
    void setSourceModeToAzEl( );

    void updateAntennaSourceRaDec (double mjd) ;

    void setNextSequenceNo( int preferredSequenceNo );

    int nextSequenceNo_; 
    int consecutiveErrors_;
    int errLimit_;
    
    const unsigned short carmaAntNo_;
    const AntennaType antType_;
    
    monitor::MonitorSubsystem & antennaSubsystem_;
    monitor::MonitorSystem & monitorSystem_;
    
    monitor::ControlSubsystemBase::Antenna & antenna_;

    SourceMode sourceMode_;
    
    double trackToleranceFreq_; // LO freq used to compute track tol asec
    float trackTolerance_;      // In half power beam widths
    
    carma::services::Ephemeris localEphemeris_;

    carma::services::SourceChecker checker_;

    double raTrackingOffset_;
    double decTrackingOffset_;
    double raPhaseOffset_;
    double decPhaseOffset_;

    bool setSafeRangeCompleted_;

    double optimumWrapTime_;

    double timeToTrack_;

    carma::control::AzWrapMode lastControlWrapMode_;

    carma::antenna::common::DriveControl::AzWrapMode lastAntWrapMode_;


    void trackTriplet( const ::std::string & source,
                       const carma::control::MjdTriplet & mjdTriplet,
                       bool resetTrackOffsets,
                       const std::string & userCatalog,
                       carma::control::AzWrapMode azWrapMode, 
                       int preferredSequenceNo );

    void trackTriplet( const carma::services::Source & source,
                       const carma::control::MjdTriplet & mjdTriplet,
                       bool resetTrackOffsets,
                       carma::control::AzWrapMode azWrapMode, 
                       int preferredSequenceNo );


     void updateWrapLimits();

     void checkAgainstLimits(const double azDegrees, const double elDegrees,
                             const bool warnOnly );

     void defaultWrapLimits();

     antenna::common::DriveControl::AzWrapMode computeOptimumWrapValue();

     const ::std::string 
     azWrapModeToString( carma::control::AzWrapMode mode ) const;

     const ::std::string 
     azWrapModeToString( carma::antenna::common::DriveControl::AzWrapMode mode ) const;

     carma::antenna::common::DriveControl::AzWrapMode
         controlWrapToDriveWrap( control::AzWrapMode mode );


     // nb. could have overloaded a general toDriveWrap() method.
     antenna::common::DriveControl::AzWrapMode
         servicesWrapToDriveWrap( services::AzWrapType wrap ) const;

     control::AzWrapMode
         driveWrapToControlWrap( antenna::common::DriveControl::AzWrapMode ) const;

     services::AntennaType
         controlAntTypeToServicesAntType( control::AntennaType antType ) const;

};  // class DriveHandle


}  // End namespace carma::control
}  // End namespace carma


#endif