Receiver.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2004 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Base/Extensions/Pulsar/Receiver.h
 
#ifndef __ReceiverExtension_h
#define __ReceiverExtension_h
 
#include "Pulsar/ArchiveExtension.h"
#include "Jones.h"
#include "Stokes.h"
#include "Angle.h"
 
namespace Pulsar {
  
 
  class Receiver : public Archive::Extension {
 
  public:
    
    static Receiver* load (const std::string& filename);
 
    static Receiver* new_Receiver (const std::string& text);
 
    Receiver ();
 
    Receiver (const Receiver& extension);
 
    const Receiver& operator= (const Receiver& extension);
 
    ~Receiver ();
 
    Receiver* clone () const { return new Receiver(*this); }
 
    std::string get_short_name () const { return "rcvr"; }
 
    TextInterface::Parser* get_interface();
 
    class Interface;
 
    void parse (std::string text);
 
    enum Tracking {
      Feed,
      Celestial,
      Galactic
    };
    
    Tracking get_tracking_mode () const { return tracking_mode; }
    void set_tracking_mode (Tracking mode) { tracking_mode = mode; }
 
    Angle get_tracking_angle () const { return tracking_angle; }
    void set_tracking_angle (const Angle& angle) { tracking_angle = angle; }
 
    std::string get_name () const { return name; }
    void set_name (const std::string& _name) { name = _name; }
    
    int get_nrcvr( void ) { return nrcvr; }
    void set_nrcvr( const int s_nrcvr ) { nrcvr = s_nrcvr; }
 
    Signal::Basis get_basis () const { return state->get_basis(); }
    
    void set_basis (Signal::Basis basis);
 
 
    Angle get_orientation () const { return state->get_orientation(); }
    void set_orientation (const Angle& celestial_position_angle);
 
    Signal::Hand get_hand () const { return state->get_hand(); }
    void set_hand (Signal::Hand);
 
    Angle get_reference_source_phase () const
    { return state->get_reference_source_phase(); }
    void set_reference_source_phase (const Angle& phase);
 
 
 
    Angle get_field_orientation () const;
    void set_field_orientation (const Angle& celestial_position_angle);
 
 
 
    Angle get_X_offset () const;
    void set_X_offset (const Angle& offset);
 
    Angle get_Y_offset () const;
    void set_Y_offset (const Angle& offset);
 
    Angle get_calibrator_offset () const;
    void set_calibrator_offset (const Angle& offset);
 
 
    bool get_basis_corrected () const { return basis_corrected; }
    void set_basis_corrected (bool);
 
    bool get_projection_corrected () const { return projection_corrected; }
    void set_projection_corrected (bool val) { projection_corrected = val; }
 
    float get_atten_a () const { return atten_a; }
    void set_atten_a (float atten) { atten_a = atten; }
 
    float get_atten_b () const { return atten_b; }
    void set_atten_b (float atten) { atten_b = atten; }
 
    bool match (const Receiver* receiver, std::string& reason) const;
 
    std::string get_tracking_mode_string() const;
 
    Stokes<double> get_reference_source () const;
 
    class State : public Reference::Able {
    public:
 
      virtual Signal::Basis get_basis () const = 0;
 
      virtual Signal::Hand get_hand () const = 0;
 
      virtual Angle get_orientation () const = 0;
 
 
      virtual Angle get_reference_source_phase () const = 0;
 
      virtual void copy (const State*) = 0;
 
    };
 
    class Native;
    class Linear;
    class Field;
 
  protected:
 
    template<class StateType> StateType* get() const;
 
    std::string name;
    
    int nrcvr;
 
    Reference::To<State> state;
 
    Tracking tracking_mode;
 
 
    Angle tracking_angle;
 
 
    bool basis_corrected;
 
 
    bool projection_corrected;
 
 
    float atten_a;
 
 
    float atten_b;
 
  };
 
}
 
#endif