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 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 ); 
 
}
 
#endif