AntennaControls.h

Go to the documentation of this file.

#ifndef CARMA_CONTROL_ANTENNA_CONTROLS_H
#define CARMA_CONTROL_ANTENNA_CONTROLS_H



#include <memory>
#include <vector>

#include "carma/corba/corba.h"
#include "carma/control/SubarrayControl.h"
#include "carma/monitor/ControlSubsystem.h"
#include "carma/services/Location.h"
#include "carma/services/Pad.h"
#include "carma/util/QuadraticInterpolatorNormal.h"


namespace carma {


namespace monitor {

class MonitorSystem;

}  // namespace carma::monitor


namespace control {


class AntennaHandle;
class DriveHandle;
class CalibratorHandle;
class CryoHandle;
class FocusHandle;
class OpticalTelHandle;
class RxSelectorHandle;


class AntennaControls {
    public:
        struct PersistentInfo {
            explicit PersistentInfo( );
            
            // The pad upon which this antenna rests.
            // Default constructor is carma reference position.
            services::Pad pad;
            
            // The East, North, Up offsets with respect to the
            // nominal Pad location (lon,lat,alt).
            // These represent how an antenna sits on a pad and
            // are the product of the baseline solution.
            // The antenna's absolute location (lon,lat,alt) is
            // Pad + pad offset + antenna offsets.
            services::Length eastPadOffset;
            services::Length northPadOffset;
            services::Length upPadOffset;
            
            // These represent static properties of a particular
            // antenna, e.g. the height of its receiver from the
            // ground.  They are given East, North, Up offsets with 
            // respect to the Pad location (lon,lat,alt).
            // The antenna's absolute location (lon,lat,alt) is
            // Pad + pad offset + antenna offsets.
            services::Length eastAntennaOffset;
            services::Length northAntennaOffset;
            services::Length upAntennaOffset;

            // The antenna total offset in ENU coords from
            // the array reference position. These don't contain
            // any information not contained in X,Y,Z coords
            // which are our standard, but easier for most
            // people to conceptualize. So use these to
            // create ENU monitor points for each antenna.
            services::Length totalEast;
            services::Length totalNorth;
            services::Length totalUp;

            // measure of the non-intersection of elevation and azimuth axes.
            services::Length axisMisalignment;

        };
        
        AntennaControls(
            unsigned short                           carmaAntNo,
            const PersistentInfo &                   persistentInfo,
            monitor::MonitorSystem &                 monitorSystem,
            monitor::ControlSubsystemBase::Antenna & antenna );

        AntennaControls(
            unsigned short          carmaAntNo,
            const PersistentInfo &  persistentInfo);


        virtual ~AntennaControls( );

        void forceFullReconnect( );

        void attemptToReconnectIfNeeded( );

        AntennaHandle * antennaHandle( ) const;

        CalibratorHandle * calibratorHandle( ) const;

        CryoHandle * cryoHandle( ) const;

        DriveHandle * driveHandle( ) const;

        FocusHandle * focusHandle( ) const;

        OpticalTelHandle * opticalTelHandle( ) const;

        RxSelectorHandle * rxSelectorHandle( ) const;

        services::Pad getPad( ) const;

        void setPad( const services::Pad & pad );

        ::std::vector< services::Length > getPadOffsets( ) const;

        void setPadOffsets( const services::Length & eastOffset,
                            const services::Length & northOffset,
                            const services::Length & upOffset );

        ::std::vector< services::Length > getAntennaOffsets( ) const;

        void setAntennaOffsets( 
                            const services::Length & eastOffset,
                            const services::Length & northOffset,
                            const services::Length & upOffset );

        ::std::vector< services::Length > getTotalEnu( ) const;

        // (pad + pad offsets + antenna offsets).
        services::Location getAbsoluteLocation( ) const;

        services::Length getAxisMisalignment( ) const;

        void setAxisMisalignment(const services::Length& axisMis);
    
        unsigned short getCarmaAntennaNo( ) const;

        ::std::string getCarmaAntennaName( ) const;
    
        ::std::string getTypedAntennaName( ) const;

        struct Uvw {
            double u;
            double v;
            double w;
            
            Uvw( );
            
            Uvw( double inU,
                 double inV,
                 double inW );
        };

        void updateUVWInterpolators( const float U, 
                                     const float V, 
                                     const float W, 
                                     const double mjd,
                                     const bool discontinuity );

        Uvw interpolateUVWfor( const double mjd );

    private:
        AntennaControls( const AntennaControls & rhs );
        AntennaControls & operator=( const AntennaControls & rhs );
        
        // common methods to compute a new total location when
        // antenna offsets or pad offset ar given.
        services::Location persistentInfoLocation() const;
        void computeNewLocation();

        // absolute CARMA antena number (1-23).
        const unsigned short carmaAntNo_;
        
        const ::std::auto_ptr< AntennaHandle >    antennaHandle_;
        const ::std::auto_ptr< CalibratorHandle > calibratorHandle_;
        const ::std::auto_ptr< CryoHandle >       cryoHandle_;
        const ::std::auto_ptr< DriveHandle >      driveHandle_;
        const ::std::auto_ptr< FocusHandle >      focusHandle_;
        const ::std::auto_ptr< OpticalTelHandle > opticalTelHandle_;
        const ::std::auto_ptr< RxSelectorHandle > rxSelectorHandle_;

        // Interpolators for the U,V,W coordinates.
        // They are calculated every 20 seconds by delay engine,
        // but science data need values on integration timescale.
        // Note these should hold the J2000 UV(W) coordinates, not the
        // current epoch.  These containers should be filled AFTER
        // precession done by rotateUVtoJ2000.  UVW are in meters.
        util::QuadraticInterpolatorNormal Uinterp_;
        util::QuadraticInterpolatorNormal Vinterp_;
        util::QuadraticInterpolatorNormal Winterp_;
        
        PersistentInfo persistentInfo_;

};  // class AntennaControls


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


inline
carma::control::AntennaControls::Uvw::Uvw( ) :
u( 0.0 ),
v( 0.0 ),
w( 0.0 )
{
}


inline
carma::control::AntennaControls::Uvw::Uvw(
    const double inU,
    const double inV,
    const double inW ) :
u( inU ),
v( inV ),
w( inW )
{
}


#endif