FluxCalibratorExtension.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2004 - 2019 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Base/Extensions/Pulsar/FluxCalibratorExtension.h
 
#ifndef __FluxCalibratorExtension_h
#define __FluxCalibratorExtension_h
 
#include "Pulsar/CalibratorExtension.h"
 
namespace Pulsar
{
 
  class FluxCalibrator;

 
  class FluxCalibratorExtension : public CalibratorExtension
  {
    friend class FluxCalibrator;
 
  public:

    FluxCalibratorExtension ();

    FluxCalibratorExtension (const FluxCalibratorExtension&);

    const FluxCalibratorExtension& operator= (const FluxCalibratorExtension&);

    ~FluxCalibratorExtension ();

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

    TextInterface::Parser* get_interface();
 
    // Text interface to a FluxCalibratorExtension
    class Interface : public TextInterface::To<FluxCalibratorExtension>
    {
      public:
        Interface( FluxCalibratorExtension *s_instance = NULL );
    };

    FluxCalibratorExtension (const FluxCalibrator*);

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

    void set_nchan (unsigned nchan);

    unsigned int get_nchan( void ) const;

    void remove_chan (unsigned first, unsigned last);
 
    class Solution;

    Solution* get_solution (unsigned c);
    const Solution* get_solution (unsigned c) const;

    void set_nreceptor (unsigned nreceptor);

    unsigned get_nreceptor () const;

    bool has_scale () const { return scale_available; }
    void has_scale (bool flag) { scale_available = flag; }

    unsigned get_nparam () const;

    Estimate<float> get_Estimate ( unsigned iparam, unsigned ichan ) const;
    void set_Estimate ( unsigned iparam, unsigned ichan, const Estimate<float>& );
 
    bool get_valid (unsigned ichan) const;
    void set_valid (unsigned ichan, bool valid);

    void frequency_append (Archive* to, const Archive* from);
 
  protected:

    unsigned nreceptor;

    bool scale_available;

    std::vector<Solution> solution;
  };

  class FluxCalibratorExtension::Solution : public Reference::Able
  {
  public:
 
    friend class FluxCalibrator;
    friend class FluxCalibratorExtension;

    unsigned get_nreceptor () const;

    void resize (unsigned nreceptor);

    void set_S_sys (unsigned receptor, const Estimate<double>&);
    Estimate<double> get_S_sys (unsigned receptor) const;
 
    void set_S_cal (unsigned receptor, const Estimate<double>&);
    Estimate<double> get_S_cal (unsigned receptor) const;

    void set_scale (unsigned receptor, const Estimate<double>&);
    Estimate<double> get_scale (unsigned receptor) const;

    void set_gain_ratio (unsigned r, const Estimate<double>&);
    Estimate<double> get_gain_ratio (unsigned receptor) const;
 
    // Text interface to a FluxCalibratorExtension::Solution instance
    class Interface : public TextInterface::To<Solution>
    {
      public:
        Interface();
    };
 
  protected:


    std::vector< Estimate<double> > S_sys;


    std::vector< Estimate<double> > S_cal;


    std::vector< Estimate<double> > scale;


    std::vector< Estimate<double> > ratio;
 
  };
 
 
}
 
#endif