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;
 
    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 ();
 
  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;
 
    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