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