PolnCalibrator.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2003 - 2022 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/Polarimetry/Pulsar/PolnCalibrator.h
 
#ifndef __Pulsar_PolnCalibrator_H
#define __Pulsar_PolnCalibrator_H
 
#include "Pulsar/Calibrator.h"
#include "Pulsar/Index.h"
 
#include "MEAL/LeastSquares.h"
#include "MEAL/Complex2.h"
 
#include "ReferenceVector.h"
#include "Jones.h"
 
namespace Pulsar {
 
  class PolnCalibratorExtension;
  class FeedExtension;
  class Receiver;
  class Integration;
 
 
  class PolnCalibrator : public Calibrator
  {
 
  public:
 
 
    static Option<double> minimum_determinant;
    
    PolnCalibrator (const Archive* archive = 0);
 
    PolnCalibrator (const PolnCalibrator& calibrator);
 
    virtual ~PolnCalibrator ();
 
    void set_calibrator (const Archive* archive);
 
    void set_subint (const Index& isub);
 
    // ///////////////////////////////////////////////////////////////////
    //
    // useful for calibrating
    //
 
    virtual void set_response_nchan (unsigned nchan);
    virtual unsigned get_response_nchan () const;
 
    virtual Jones<float> get_response (unsigned ichan) const;
 
    bool has_Receiver () const;
 
    const Receiver* get_Receiver () const;
 
    void set_Receiver (const Archive*);
    std::string get_receiver_basis_filename () const;
 
 
    // ///////////////////////////////////////////////////////////////////
    //
    // useful for unloading
    //
 
    void transformation_resize (unsigned nchan);
 
    bool get_transformation_valid (unsigned ch) const;
 
    void set_transformation_invalid (unsigned ch, const std::string& reason);
 
    const std::string& get_transformation_invalid_reason (unsigned ichan) const;
 
    const MEAL::Complex2* get_transformation (unsigned ichan) const;
 
    MEAL::Complex2* get_transformation (unsigned ichan);
 
    void set_transformation (unsigned ichan, MEAL::Complex2*);
 
    bool has_covariance () const;
 
    void get_covariance (unsigned ichan, std::vector<double>&) const;
 
    virtual bool has_solver () const;
 
    virtual const MEAL::LeastSquares* get_solver (unsigned ichan) const;
    MEAL::LeastSquares* get_solver (unsigned ichan);
 
    // ///////////////////////////////////////////////////////////////////
    //
    // Pulsar::Calibrator implementation
    //
    // ///////////////////////////////////////////////////////////////////
 
    void set_backend_correction (bool f) { do_backend_correction = f; }
 
    virtual void calibrate (Archive* archive);
 
    virtual const Type* get_type () const;
 
    virtual unsigned get_nchan () const;
 
    unsigned get_nchan (bool build_if_needed) const;
 
    CalibratorExtension* new_Extension () const;
 
    Calibrator::Info* get_Info () const;
 
    class Info;
 
    void calibration_setup (const Archive* arch);
 
  private:
 
    Reference::Vector<MEAL::Complex2> transformation;
 
    std::vector< std::string> invalid_reason;
 
  protected:
 
    std::vector< std::vector<double> > covariance;
 
    void setup_transformation () const;
 
    std::vector< Jones<float> > response;
 
    Reference::To<const PolnCalibratorExtension> poln_extension;
 
    Reference::To<const FeedExtension> feed;
 
    bool built;
 
    unsigned observation_nchan;
 
    bool do_backend_correction;
 
    virtual void calculate_transformation ();
 
    virtual bool get_valid (unsigned ichan) const;
 
    float get_weight (unsigned ichan) const;
 
    virtual unsigned get_maximum_nchan () const;
 
    Index subint;
    
  private:
 
    void build (unsigned nchan = 0);
    
    mutable Reference::Vector<MEAL::LeastSquares> tmp_solver;
 
    std::vector<bool> bad;
    unsigned bad_count;
 
    void build_response();
    void patch_response();
 
    Reference::To<const Receiver> receiver;
    std::string receiver_basis_filename;
 
    void init ();
 
  };
 
  MEAL::Complex2*
  new_transformation (const PolnCalibratorExtension*, unsigned ichan);
 
  MEAL::Complex2* new_transformation( const Calibrator::Type* type );
 
  MEAL::Complex2* transformation_factory (const std::string& name);
 
  MEAL::Complex2* load_transformation (const std::string& filename);
 
  Calibrator::Type* new_CalibratorType( const MEAL::Complex2* xform ); 
 
 
  class PolnCalibrator::Info : public Calibrator::Info
  {
 
  public:
 
    static PolnCalibrator::Info* create (const PolnCalibrator* calibrator);
    
    Info (const PolnCalibrator* calibrator);
    
    std::string get_title () const;
 
    unsigned get_nchan () const;
 
    unsigned get_nclass () const;
    
    std::string get_name (unsigned iclass) const;
    
    unsigned get_nparam (unsigned iclass) const;
    
    Estimate<float> get_param (unsigned ichan, unsigned iclass,
                               unsigned iparam) const;
    
    int get_colour_index (unsigned iclass, unsigned iparam) const;
    
    int get_graph_marker (unsigned iclass, unsigned iparam) const;
    
  protected:
    
    Reference::To<const PolnCalibrator> calibrator;
 
    unsigned nparam;
    
  };
 
}
 
#endif