SourceChecker.h

Go to the documentation of this file.

#ifndef CARMA_SERVICES_SOURCECHECKER_H
#define CARMA_SERVICES_SOURCECHECKER_H

#include "carma/services/AstroTime.h"
#include "carma/services/Ephemeris.h"
#include "carma/services/Neighbor.h"
#include "carma/services/Types.h"
#include "carma/services/TelescopeStatus.h"
#include "carma/services/Units.h"
#include "carma/services/Velocity.h"

#include <vector>
#include <set>

namespace carma {
namespace services {

  class Angle;
  class Source;

  class SourceChecker {
  public:
    SourceChecker();

    virtual ~SourceChecker();

    void setSource(const Source& source);

    void setSource(const std::string& source, 
                   const std::string& catalog="");

    void setLocation(const Location& location);

    void setElevLimit(double elevDegrees);

    void setElevLimit(const Angle& elevation);

    void setElevUpperLimit(double elevDegrees);

    void setElevUpperLimit(const Angle& elevation);

    // NB: Should probably put the wrap limit info
    // into a separate Telescope class.
    // then SourceChecker::setTelescope(..)
    void setAzPositiveWrapLimit( const Angle & azimuth );

    void setAzNegativeWrapLimit( const Angle & azimuth );

    inline void useSexagesimal(bool sexa) 
    {
        sexa_ = sexa;
    }

    void useJ2000(bool j2000) 
    {
        j2000_ = j2000;
    }

    void showHeader(bool showit) ;

    Angle getElevLimit() const;

    Angle getElevUpperLimit() const;

    Angle  getAzPositiveWrapLimit() const;

    Angle  getAzNegativeWrapLimit() const;

    void setFrequency(double frequency);

    void setMJD( double mjd = carma::util::Time::MJD() );

    std::string info();

    bool isUp();

    double riseTime() ;

    double minutesSinceRise() ;

    double minutesSinceSet() ;

    double minutesUntilRise();

    double minutesUntilTransit();

    double minutesUntilAzLimit();

    double setTime() ;

    double minutesUntilSet();

    double lst() ;

    std::string localTime();

    std::string ut();

    carma::services::Angle getAzimuth();

    carma::services::Angle getElevation();

    TelescopeStatus getTelescopeStatus();

    double minutesUntilBlind();

    double minutesUntilAzWrapLimit();

    bool canBeTrackedOnNegativeWrap();

    services::AzWrapType computeOptimumWrapValue( 
            services::AntennaType antType,
            double antAzDegrees,
            double timeToTrack );


    services::NeighborSet 
        getNearest( const ::std::set< ::std::string > & sourceList, 
                    bool include,
                    unsigned short numReturn, bool ignoreNorthSouth,
                    coordSysType coordSys, 
                    sourcePntType pType, 
                    float fluxLimit );

    services::Neighbor createNeighbor( const Source & neighborSource,
                                       const coordSysType coordSys, Ephemeris & localEphemeris);

    double getMJD();

    bool slewWouldCrossNorthSouthBoundary( const Source & neighborSource );


  private:
    // lower elevation limit
    Angle*       elevLimit_;
    // upper elevation limit
    Angle*       elevUpperLimit_;
    // positive wrap azimuth limit
    Angle azPositiveWrapLimit_;
    // negative wrap azimuth limit
    Angle azNegativeWrapLimit_;
    // local sidereal time in HOURS when source hits positive azimuth limit;
    double       azPositiveWrapLimitLst_;
    AstroTime    at_;
    Ephemeris    ephem_;
    Units        units_;

    // Has the MJD for queries been set yet?
    bool  needsMjd_;

    // For source info output, do we need the header or not?
    // If looping over many sources, we don't want to spit
    // out the header each time.
    bool needsHeader_;

    // output angles in sexagesimal format if sexa_ =- true
    bool sexa_;

    // output RA/DEC in J2000 or not.
    bool j2000_;

    TelescopeStatus telescopeStatus_;

    std::string rise();

    std::string set();

    Velocity doppler();

    std::string header( Source source );

    double hourAngleAtElevLimit();

    double hourAngleAtElevUpperLimit();

    double hourAngleAtElevation( Angle * elev );

    void computeTelescopeStatus();

    // marker for source that never sets below elevation limit
    static const double NEVER_SETS;
    // marker for source that never rises above elevation limit
    static const double NEVER_RISES;

    // oft-used strings
    static const std::string NEVER_RISES_STR;
    static const std::string NEVER_SETS_STR;
    static const std::string UNSUPPORTED_COORDSYS_STR;

    // widths for info() formatting
    static const int SOURCE_WIDTH = 10;
    static const int ANGLE_WIDTH  = 13;
    static const int TEXT_WIDTH   = 10;
    static const int TIME_WIDTH   = 12;
    static const int DOPPLER_WIDTH=  8;


  }; 

} // end services
} // end carma

#endif // CARMA_SERVICES_SOURCECHECKER_H