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, 
                     const Uncertainty* var);
 
    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;
 
  protected:
 
    std::vector< Reference::To<MEAL::Argument::Value> > coordinates;
 
    unsigned input_index;
 
    unsigned nconstraint;
 
    Jones<double> rho;
 
    Stokes<double> variance;
 
    Reference::To<const 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;
 
  };
}
 
 
 
#endif