CoherencyMeasurement.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2004 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/Polarimetry/Pulsar/CoherencyMeasurement.h
 
#ifndef __Calibration_CoherencyMeasurement_H
#define __Calibration_CoherencyMeasurement_H
 
#include "MEAL/Argument.h"
#include "Reference.h"
#include "Estimate.h"
#include "Stokes.h"
#include "Jones.h"
 
#include <complex>
 
namespace Calibration {

  /* Among other things, this class implements the interface of the
     MEAL::WeightingScheme class used by MEAL::LevenbergMacquardt */
  class CoherencyMeasurement {
 
  public:

    class Uncertainty;

    CoherencyMeasurement (unsigned input_index = 0);

    void set_input_index (unsigned index);

    unsigned get_input_index () const;

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

    void set_stokes (const Stokes< std::complex<double> >& stokes,
                     const Stokes<double>& variance);

    void set_stokes (const Stokes< std::complex<double> >& stokes, Uncertainty*);

    unsigned get_nconstraint () const;

    Jones<double> get_coherency () const;

    Stokes< Estimate<double> > get_stokes () const;

    Stokes< std::complex< Estimate<double> > > get_complex_stokes () const;

    double get_weighted_norm (const Jones<double>& matrix) const;

    Jones<double> get_weighted_conjugate (const Jones<double>& matrix) const;
 
    void get_weighted_components (const Jones<double>&, std::vector<double>& components) const;

    const Uncertainty* get_uncertainty () const { return uncertainty; }

    void add_coordinate (MEAL::Argument::Value* abscissa);

    void set_coordinates () const;


    void scale (double);
 
  protected:

    std::vector< Reference::To<MEAL::Argument::Value> > coordinates;

    unsigned input_index;

    unsigned nconstraint;

    Jones<double> rho;

    Stokes<double> variance;

    Reference::To<Uncertainty> uncertainty;
 
  };

  class CoherencyMeasurement::Uncertainty : public Reference::Able
  {
  public:

    virtual Uncertainty* clone () const = 0;

    virtual void add (const Uncertainty*) = 0;
    
    virtual double get_weighted_norm (const Jones<double>&) const = 0;
    
    virtual Jones<double> get_weighted_conjugate (const Jones<double>&) const = 0;
 
    virtual Stokes<std::complex<double>> get_weighted_components (const Jones<double>&) const = 0;

    virtual Stokes<std::complex<double>> get_variance () const = 0;

    virtual void scale (double) = 0;
  };
}
 
 
 
#endif