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