PolnProfile.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2003 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/Polarimetry/Pulsar/PolnProfile.h
 
#ifndef __Pulsar_PolnProfile_h
#define __Pulsar_PolnProfile_h
 
#include "Pulsar/Profile.h"
 
#include "Stokes.h"
#include "Jones.h"
#include "Matrix.h"
#include "Quaternion.h"
 
namespace Pulsar {
 
  class StokesCovariance;
  class BaselineEstimator;


  class PolnProfile : public Container {
    
  public:

    static bool normalize_weight_by_absolute_gain;

    PolnProfile ();

    PolnProfile (unsigned nbin);

    PolnProfile (Signal::Basis basis, Signal::State state,
                 Profile* p0, Profile* p1, Profile* p2, Profile* p3);
    
    virtual ~PolnProfile();

    virtual PolnProfile* clone () const;

    void resize (unsigned nbin);

    unsigned get_nbin () const;

    const Profile* get_Profile (unsigned ipol) const;

    Profile* get_Profile (unsigned ipol);

    const float* get_amps (unsigned ipol) const;

    float* get_amps (unsigned ipol);

    void set_amps (unsigned ipol, float* amps);

    void set_baseline (PhaseWeight*);

    PhaseWeight* get_baseline () const;

    void sum (const PolnProfile* that);

    void diff (const PolnProfile* that);

    Signal::Basis get_basis () const { return basis; }

    Signal::State get_state () const { return state; }

    Stokes<float> get_Stokes (unsigned ibin) const;

    void set_Stokes (unsigned ibin, const Stokes<float>&);

    Jones<double> get_coherence (unsigned ibin) const;

    void set_coherence (unsigned ibin, const Jones<double>&);

    Quaternion<float,Hermitian> get_pseudoStokes (unsigned ibin) const;

    void set_pseudoStokes (unsigned ibin, const Quaternion<float,Hermitian>&);

    double sum (int bin_start=0, int bin_end=0) const;

    double sumsq (int bin_start=0, int bin_end=0) const;

    void scale (double scale);

    void rotate_phase (double turns);

    void transform (const Jones<double>& response);

    void transform (const Matrix<4,4,double>& response);

    void convert_state (Signal::State state);

    void convert_basis (Signal::Basis basis);

    void invint (Profile* invint, bool second = true) const;

    void invconv (Profile*) const;

    void get_linear (Profile*) const;

    void get_linear_squared (Profile*) const;

    double get_linear_variance () const;

    double get_linear_variance (std::pair<double,double>& qu_var) const;

    void get_circular (Profile*) const;

    void get_polarized (Profile*) const;

    void get_polarized_squared (Profile*) const;

    void get_orientation (std::vector< Estimate<double> >&, float sigma) const;

    void get_ellipticity (std::vector< Estimate<double> >&, float sigma) const;
 
    void get_linear (std::vector< std::complex< Estimate<double> > >& L, float sigma) const;
 
    const StokesCovariance* get_covariance () const;
    StokesCovariance* get_covariance ();
 
  protected:

    Signal::Basis basis;

    Signal::State state;

    Reference::To<Profile> profile[4];

    Reference::To<PhaseWeight> baseline;

    mutable Reference::To<PhaseWeight> my_baseline;

    Reference::To<StokesCovariance> covariance;

    void check (const char* method, Signal::State want_state, unsigned want_ibin) const;

    void sum_difference (Profile* sum, Profile* difference);

    void init ();

    void get_root_sum_squared(Profile* rss, unsigned jpol, unsigned kpol,
                              BaselineEstimator* baseline_estimator = 0) const;

    void get_sum_squared(Profile* rss, unsigned jpol, unsigned kpol) const;
  };
 
}
 
 
#endif