CalibratorInfo.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2012 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
#ifndef __Pulsar_CalibratorInfo_h
#define __Pulsar_CalibratorInfo_h
 
#include "Pulsar/MultiFrequency.h"
#include "Pulsar/CalibratorParameter.h"
 
namespace Pulsar {


  class CalibratorInfo : public MultiFrequency
  {
  public:

    CalibratorInfo ();

    TextInterface::Parser* get_interface ();
 
    // Text interface to the CalibratorInfo class
    class Interface : public TextInterface::To<CalibratorInfo> {
    public:
      Interface (CalibratorInfo* = 0);
    };

    void prepare (const Archive*);
 
    void set_between_panels (float x) { between_panels = x; }
    float get_between_panels () const { return between_panels; }
 
    void set_panels (const std::string& x) { panels = x; }
    std::string get_panels () const { return panels; }
 
    void set_calibrator_stokes (bool x) { calibrator_stokes = x; }
    bool get_calibrator_stokes () const { return calibrator_stokes; }
 
    void set_calibrator_stokes_degree (bool x);
    bool get_calibrator_stokes_degree () const;
 
    void set_correlation (int idx) { correlation = idx; }
    int get_correlation () const { return correlation; }
 
    void set_configurable_projection (bool x) { configurable_projection = x; }
    bool get_configurable_projection () const { return configurable_projection; }
 
    void set_reduced_chisq (bool x) { reduced_chisq = x; }
    bool get_reduced_chisq () const { return reduced_chisq; }
 
    void set_intrinsic_crosspol_ratio (bool x) { intrinsic_crosspol_ratio = x; }
    bool get_intrinsic_crosspol_ratio () const { return intrinsic_crosspol_ratio; }
 
    void set_constant_gain (bool x) { constant_gain = x; }
    bool get_constant_gain () const { return constant_gain; }
 
    void set_outlier_threshold (float t) { outlier_threshold = t; }
    float get_outlier_threshold () const { return outlier_threshold; }

    void set_subint (const Index& isub) { subint = isub; }
    Index get_subint () const { return subint; }
 
  protected:

    std::vector< Reference::To<CalibratorParameter> > parameter;


    float between_panels = 0.05;

    std::string panels;

    bool calibrator_stokes = false;

    bool calibrator_stokes_degree = false;
   
    bool configurable_projection = false;
 
    int correlation = -1;

    bool reduced_chisq = false;

    bool intrinsic_crosspol_ratio = false;

    bool constant_gain = false;

    float outlier_threshold = 0.0;
 
    // Sub-integration from which to derive a solution
    Index subint;
  };
 
}
 
#endif