CalibrationInterpolatorExtension.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2022 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Base/Extensions/Pulsar/CalibrationInterpolatorExtension.h
 
#ifndef __CalibrationInterpolatorExtension_h
#define __CalibrationInterpolatorExtension_h
 
#include "Pulsar/ArchiveExtension.h"
#include "Pulsar/CalibratorType.h"
#include "Pulsar/CalibratorStokes.h"
 
namespace Pulsar {


  class CalibrationInterpolatorExtension : public Archive::Extension
  {   
  public:
    
    CalibrationInterpolatorExtension
    (const char* name = "CalibrationInterpolatorExtension");

    CalibrationInterpolatorExtension (const CalibrationInterpolatorExtension&);

    const CalibrationInterpolatorExtension&
    operator= (const CalibrationInterpolatorExtension&);

    ~CalibrationInterpolatorExtension ();

    CalibrationInterpolatorExtension* clone () const
    { return new CalibrationInterpolatorExtension( *this ); }

    bool has_data () const;

    void set_type (const Calibrator::Type* t);// { type = t; }
    const Calibrator::Type* get_type () const;// { return type; }

    void set_coupling_point (CalibratorStokes::CouplingPoint point)
    { coupling_point = point; }
    
    CalibratorStokes::CouplingPoint get_coupling_point () const
    { return coupling_point; }

    void set_nreceptor (unsigned n) { nreceptor = n; }
    unsigned get_nreceptor () const { return nreceptor; }

    bool get_native_scale () const { return native_scale; }
    void set_native_scale (bool flag) { native_scale = flag; }

    unsigned get_nsub_input () const { return nsub_input; }
    void set_nsub_input (unsigned n) { nsub_input = n; }

    void set_reference_epoch (const MJD& epoch) { reference_epoch = epoch; }
    MJD get_reference_epoch () const { return reference_epoch; }

    void set_minimum_epoch (const MJD& epoch) { minimum_epoch = epoch; }
    MJD get_minimum_epoch () const { return minimum_epoch; }

    void set_maximum_epoch (const MJD& epoch) { maximum_epoch = epoch; }
    MJD get_maximum_epoch () const { return maximum_epoch; }

    unsigned get_nchan_input () const { return nchan_input; }
    void set_nchan_input (unsigned n) { nchan_input = n; }

    void set_reference_frequency (double freq) { reference_frequency = freq; }
    double get_reference_frequency () const { return reference_frequency; }

    void set_minimum_frequency (double freq) { minimum_frequency = freq; }
    double get_minimum_frequency () const { return minimum_frequency; }

    void set_maximum_frequency (double freq) { maximum_frequency = freq; }
    double get_maximum_frequency () const { return maximum_frequency; }

    std::string get_short_name () const { return "pcmint"; }

    class Interface
      : public TextInterface::To<CalibrationInterpolatorExtension>
    {
    public:
      Interface (CalibrationInterpolatorExtension* = 0);
    };
    
    TextInterface::Parser* get_interface();
 
    class Parameter : public Reference::Able
    {
    public:

      class Interface
        : public TextInterface::To<Parameter>
      {
      public:
        Interface (Parameter* = 0);
      };

      enum Type
      {
        FrontendParameter = 1,
        CalibratorStokesParameter = 2,
        FluxCalibratorParameter = 3
      };
      
      Type code;
      Type get_code () const { return code; }
 
      unsigned iparam;
      unsigned get_iparam () const { return iparam; }
 
      float log10_smoothing_factor;
      float get_log10_smoothing_factor () const { return log10_smoothing_factor; }
      float total_chi_squared;
      float get_total_chi_squared () const { return total_chi_squared; }
      
      unsigned ndat_input;
      unsigned get_ndat_input () const { return ndat_input; }
      
      unsigned ndat_flagged_before;
      unsigned get_ndat_flagged_before () const { return ndat_flagged_before; }
      
      unsigned ndat_flagged_after;
      unsigned get_ndat_flagged_after () const { return ndat_flagged_after; }
      
      std::string interpolator;
    };
 
    void add_parameter (Parameter* p) { parameter.push_back(p); }
    unsigned get_nparam () const { return parameter.size(); }
    
    Parameter* get_parameter (unsigned iparam)
    { return parameter.at(iparam); }
    const Parameter* get_parameter (unsigned iparam) const
    { return parameter.at(iparam); }
    
    protected:

    Reference::To<const Calibrator::Type> type;

    CalibratorStokes::CouplingPoint coupling_point;

    unsigned nreceptor;

    bool native_scale;
    
    unsigned nsub_input;
    
    MJD reference_epoch;
    MJD minimum_epoch;
    MJD maximum_epoch;

    unsigned nchan_input;
    
    double reference_frequency;
    double minimum_frequency;
    double maximum_frequency;
 
    std::vector< Reference::To<Parameter> > parameter;
  };
 
  std::ostream& operator << (std::ostream& ostr,
                             CalibrationInterpolatorExtension::Parameter::Type);
 
}
 
#endif