ManualPolnCalibrator.h

/***************************************************************************
 *
 *   Copyright (C) 2013 by Gregory Desvignes
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
#ifndef __CalibrationManualPolnCalibrator_H
#define __CalibrationManualPolnCalibrator_H
 
#include "Pulsar/PolnCalibrator.h"
#include "Jones.h"
 
namespace Pulsar {
 
  //class ReferenceCalibrator;
  //class CalibratorStokes;
 
 
  class ManualPolnCalibrator : public PolnCalibrator {
 
  public:
 
    ManualPolnCalibrator (const std::string ascii_model_filename);
 
    ManualPolnCalibrator (const ManualPolnCalibrator& s);
 
    //const ManualPolnCalibrator& operator = (const ManualPolnCalibrator& s);
 
    //ManualPolnCalibrator* clone () const;
 
    ~ManualPolnCalibrator ();
 
    virtual void load (const std::string& ascii_model_filename);
 
    // ///////////////////////////////////////////////////////////////////
    //
    // useful for calibrating
    //
    // ///////////////////////////////////////////////////////////////////
 
    virtual void set_response_nsub (unsigned nsub);
 
    virtual unsigned get_response_nsub () const;
 
    //virtual Jones<float> get_response (unsigned ichan) const;
 
    // ///////////////////////////////////////////////////////////////////
    //
    // Model implementation
    //
    // ///////////////////////////////////////////////////////////////////
 
    //std::string get_name () const;
    
    void calibrate (Archive* archive);
 
    class Entry {
 
    public:
 
      Entry () { init(); }
 
      explicit Entry (std::string& str) { load(str); }
    
      ~Entry();
 
      void load (const std::string& str);
 
      bool matches (const std::string& name) const;
 
      double ref_frequency; 
 
      MJD ref_epoch; 
 
      void set_response (const Jones<float> response_h) {entry_response = response_h;}
 
      Jones<float> get_response () {return entry_response;}
 
    private:
    
    protected:
 
      void init ();
 
    private:
      
      //double ref_frequency; 
 
      //MJD ref_epoch; 
 
      Jones<float> entry_response;
    };
 
    //void set_response (const Jones<float> response_h) {response = response_h;}
 
    //Jones<float> get_response () {return response;}
    
    std::vector<Entry> match (const MJD& epoch) const;
    const Entry& match (const MJD& epoch, double MHz) const;
 
    Entry get_entry (const unsigned idx) const { return entries[idx]; }
 
 
  protected:
 
    std::vector<std::vector<Jones<float> > > response;
 
    std::vector<Entry> entries;
 
    std::vector<Entry> matches_epoch (const MJD& epoch) const;
 
  private:
    
    std::string ascii_model_filename;
 
    //void init ();
 
 
 
  };
 
}
 
#endif