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* invconv) const;
 
    void get_linear (Profile* linear) const;
 
    double get_linear_variance () const;
 
    double get_linear_variance (std::pair<double,double>& qu_var) const;
 
    void get_circular (Profile* circular) const;
 
    void get_polarized (Profile* polarized) 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_rss( Profile* rss, unsigned jpol, unsigned kpol,
                  BaselineEstimator* baseline_estimator = 0 ) const;
 
  };
 
}
 
 
#endif