PolnProfileFit.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2003-2009 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/Polarimetry/Pulsar/PolnProfileFit.h
 
#ifndef __Pulsar_PolnProfileFit_h
#define __Pulsar_PolnProfileFit_h
 
#include "Pulsar/CoherencyMeasurementSet.h"
#include "Pulsar/PhaseWeight.h"
 
#include "MEAL/Axis.h"
#include "Matrix.h"
#include "Estimate.h"
#include "Stokes.h"
#include "FTransformAgent.h"
#include "toa.h"
 
// forward declarations
namespace MEAL
{
  class Complex2;
  template<typename T> class PhaseGradients;
}
 
namespace Calibration
{
  class ReceptionModel;
  class TemplateUncertainty;
  class StandardSpectra;
}
 
namespace Pulsar
{
  class PolnProfile;
  class Profile;


 
  class PolnProfileFit : public Reference::Able
  {
    
  public:

    static bool verbose;

    class Analysis;

    PolnProfileFit ();

    PolnProfileFit (const PolnProfileFit& fit);

    PolnProfileFit& operator = (const PolnProfileFit& fit);

    ~PolnProfileFit ();

    PolnProfileFit* clone () const;

    void set_maximum_harmonic (unsigned max);

    unsigned get_maximum_harmonic () const { return maximum_harmonic; }

    unsigned get_nharmonic () const { return n_harmonic; }

    void set_regions (const PhaseWeight& pulse, const PhaseWeight& baseline);

    void set_standard (const PolnProfile* standard);

    const PolnProfile* get_standard () const;

    void add_observation ( Calibration::CoherencyMeasurementSet&, const PolnProfile* );

    void add_observation ( const PolnProfile* );

    void set_observation ( const PolnProfile* );

    void delete_observations ();
    
    void set_measurement_set (const Calibration::CoherencyMeasurementSet&);

    void set_transformation (MEAL::Complex2* xform);

    MEAL::Complex2* get_transformation () const;

    void set_fit_debug (bool flag = true);

    void set_normalize_by_invariant (bool set = true);

    void fit (const PolnProfile* observation);

    void solve ();

    void set_plan (FTransform::Plan*);

    Calibration::ReceptionModel* get_equation ();
    const Calibration::ReceptionModel* get_equation () const;
    void set_equation (Calibration::ReceptionModel*);

    Estimate<double> get_phase () const;

    double get_reduced_chisq () const;

    void set_phase (const Estimate<double>& phase);

    void set_phase_lock (bool locked);

    void share_phase ();

    void remove_phase ();

    Tempo::toa get_toa (const PolnProfile* observation,
                        const MJD& mjd, double period,
                        const std::string& nsite);

    float ccf_max_phase (const Profile* std, const Profile* obs) const;

    bool choose_maximum_harmonic;

    bool manage_equation_transformation;

    Calibration::StandardSpectra* get_spectra ();

    Estimate<double> get_total_squared_invariant (const PolnProfile*);
 
  protected:
 
    friend class ScalarProfileFitAnalysis;

    unsigned maximum_harmonic;

    unsigned n_harmonic;

    bool shared_phase;

    bool phase_lock;

    Reference::To<const PolnProfile> standard;

    Reference::To<const PolnProfile> standard_fourier;

    Reference::To<MEAL::Complex2> transformation;

    Reference::To<Calibration::StandardSpectra> standard_data;

    Reference::To<Calibration::ReceptionModel> equation;

    std::vector< Reference::To<Calibration::TemplateUncertainty> > uncertainty;

    Reference::To< MEAL::PhaseGradients<MEAL::Complex2> > phases;

    std::vector<unsigned> input_index;
    
    MEAL::Axis<double> phase_axis;

    MEAL::Axis<unsigned> index_axis;

    Calibration::CoherencyMeasurementSet measurement_set;

    bool fit_debug;

    void init ();
 
    Stokes< std::complex<double> > standard_variance;
 
  private:

    bool regions_set;
 
  };
 
}
 
#endif