ReferenceCalibrator.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2004 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/Polarimetry/Pulsar/ReferenceCalibrator.h
 
#ifndef __Pulsar_ReferenceCalibrator_H
#define __Pulsar_ReferenceCalibrator_H
 
#include "Pulsar/PolnCalibrator.h"
#include "Pulsar/Config.h"
 
#include "Estimate.h"
#include "Stokes.h"
#include "Types.h"
 
namespace Pulsar {
 
  class Integration;

  class ReferenceCalibrator : public PolnCalibrator
  {
 
    void init ();
    
  public:

    static Option<bool> smooth_bandpass;

    static ReferenceCalibrator* factory (const Calibrator::Type*,
                                         const Archive*);

    ReferenceCalibrator (const Archive* archive);

    ReferenceCalibrator (const ReferenceCalibrator&);

    virtual ReferenceCalibrator* clone () const = 0;

    ~ReferenceCalibrator ();

    void set_reference_source (const Stokes< Estimate<double> >& stokes);

    Stokes< Estimate<double> > get_reference_source () const;
 
    void set_outlier_threshold (float f) { outlier_threshold = f; }

    float get_outlier_threshold () const { return outlier_threshold; }

    void get_levels (unsigned nchan,
                     std::vector<std::vector<Estimate<double> > >& hi,
                     std::vector<std::vector<Estimate<double> > >& lo) const;

    static void get_levels (const Archive* archive,
                            Index subint, unsigned nchan,
                            std::vector<std::vector<Estimate<double> > >& hi,
                            std::vector<std::vector<Estimate<double> > >& lo,
                            double outlier_threshold);

    static void get_levels (const Integration* integration, unsigned nchan,
                            std::vector<std::vector<Estimate<double> > >& hi,
                            std::vector<std::vector<Estimate<double> > >& lo,
                            double outlier_threshold);
 
    // ///////////////////////////////////////////////////////////////////
    //
    // Pulsar::PolnCalibrator over-ride
    //
    // ///////////////////////////////////////////////////////////////////

    virtual void set_nchan (unsigned nchan);
 
  protected:

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

    Stokes< Estimate<double> > reference_source;

    void set_calibrator (const Archive* archive);

    bool source_set;

    unsigned requested_nchan;

    double outlier_threshold;
    
    // ///////////////////////////////////////////////////////////////////
    //
    // Pulsar::Calibrator implementation
    //
    // ///////////////////////////////////////////////////////////////////

    void calculate_transformation ();

    void calculate (std::vector<std::vector<Estimate<double> > >& hi,
                    std::vector<std::vector<Estimate<double> > >& lo);

    virtual MEAL::Complex2* 
    solve (const std::vector<Estimate<double> >& hi,
           const std::vector<Estimate<double> >& lo) = 0;

    virtual void extra (unsigned ichan,
                        const std::vector< Estimate<double> >& source,
                        const std::vector< Estimate<double> >& sky) { }
 
  };
 
}
 
#endif