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_symmetry_angle () const;
    void set_symmetry_angle (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