SignalPath.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2005-2009 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/Polarimetry/Pulsar/SignalPath.h
 
#ifndef __Calibration_SignalPath_H
#define __Calibration_SignalPath_H
 
// Reception Model and its management
#include "Pulsar/ReceptionModel.h"
#include "Pulsar/ReceptionModelSolver.h"
 
#include "Pulsar/CalibratorType.h"
#include "Pulsar/ConvertMJD.h"
 
#include "MEAL/ProductRule.h"
#include "MEAL/ChainRule.h"
#include "MEAL/Univariate.h"
#include "MEAL/Gain.h"
#include "MEAL/Axis.h"
#include "MEAL/Real4.h"
 
namespace Calibration
{
 
  class VariableBackendEstimate;
  class VariableBackend;
  class BackendEstimate;
  
  class SignalPath : public Reference::Able
  {
  public:
 
    static bool verbose;
 
    SignalPath (Pulsar::Calibrator::Type*);
 
    void copy (SignalPath*);
 
    void set_response (MEAL::Complex2*);
 
    void reset ();
 
    void set_response_variation (unsigned iparam,
                                 MEAL::Univariate<MEAL::Scalar>*);
 
    const MEAL::Univariate<MEAL::Scalar>*
    get_response_variation (unsigned iparam) const;
 
    void set_impurity (MEAL::Real4*);
 
    void set_basis (MEAL::Complex2*);
 
    bool has_basis () const { return basis; }
    MEAL::Complex2* get_basis () { return basis; }
    const MEAL::Complex2* get_basis () const { return basis; }
 
    void set_constant_pulsar_gain (bool = true);
 
    class PulsarPath;
 
    class PolnCalPath;
 
    void set_foreach_calibrator (const MEAL::Complex2*);
 
    void set_stepeach_calibrator (const VariableBackend*);
 
    void set_gain_variation (MEAL::Univariate<MEAL::Scalar>*);
 
    void set_diff_gain_variation (MEAL::Univariate<MEAL::Scalar>*);
 
    void set_diff_phase_variation (MEAL::Univariate<MEAL::Scalar>*);
 
    const MEAL::Scalar* get_gain_variation () const
    { return gain_variation; }
    
    const MEAL::Scalar* get_diff_gain_variation () const
    { return diff_gain_variation; }
 
    const MEAL::Scalar* get_diff_phase_variation () const
    { return diff_phase_variation; }
 
    void add_calibrator_epoch (const MJD&);
 
    void add_gain_step (const MJD&);
 
    void add_diff_gain_step (const MJD&);
 
    void add_diff_phase_step (const MJD&);
 
    void add_step (const MJD& mjd,
                   Calibration::VariableBackend* backend = 0);
 
    void add_observation_epoch (const MJD&);
 
    void set_reference_epoch (const MJD& epoch);
 
    void update ();
 
    void fit_gain (bool flag);
 
    void equal_ellipticities ();
 
    bool reduce_nfree ();
 
    void check_constraints ();
 
    void solve ();
 
    void add_psr_path (VariableBackendEstimate*);
 
    void add_cal_path (VariableBackendEstimate*);
 
    void fix_orientation ();
 
    unsigned get_cal_path_index (const MJD&) const;
 
    unsigned get_psr_path_index (const MJD&) const;
 
    VariableBackendEstimate* get_backend (const MJD& epoch) const;
 
    VariableBackendEstimate* max_weight_backend ();
  
    void integrate_calibrator (const MJD& epoch,
                               const MEAL::Complex2* xform);
 
    Calibration::ReceptionModel* get_equation ();
    const Calibration::ReceptionModel* get_equation () const;
 
    void set_equation (Calibration::ReceptionModel*);
 
    void set_solver (Calibration::ReceptionModel::Solver*);
 
    void copy_transformation (const MEAL::Complex2*);
 
    const MEAL::Complex2* get_transformation () const;
 
    MEAL::Complex2* get_transformation ();
 
    void add_transformation (MEAL::Complex2*);
 
    const MEAL::Complex2* get_pulsar_transformation (const MJD&) const;
 
    void get_covariance( std::vector<double>& covar, const MJD& epoch );
 
    MEAL::Axis<MJD> time;
 
    void disengage_time_variations (const MJD& epoch);
 
    void engage_time_variations ();
 
    void set_step_after_cal (bool flag = true);
 
    void set_refcal_through_frontend (bool flag = true);
 
    void set_valid (bool f, const char* reason = 0);
    bool get_valid () const { return valid; }
    std::string get_invalid_reason () const { return invalid_reason; }
 
    MEAL::Axis< Jones<double> >& get_projection () { return projection; }
 
 protected:
 
    bool valid;
 
    std::string invalid_reason;
 
    Reference::To< Calibration::ReceptionModel > equation;
 
    Reference::To< Calibration::ReceptionModel::Solver > solver;
 
    
    Reference::To< MEAL::Complex2 > response;
 
    Reference::To< MEAL::Complex2 > initial_response;
 
    Reference::To<MEAL::Complex2> basis;
 
    Reference::To< MEAL::ProductRule<MEAL::Complex2> > instrument;
 
    Reference::To<MEAL::Complex2> celestial;
 
 
    MEAL::Axis< Jones<double> > projection;
 
    Reference::To< MEAL::ChainRule<MEAL::Complex2> > response_chain;
 
    typedef Reference::To<MEAL::Univariate<MEAL::Scalar> > ScalarReference;
    std::map< unsigned, ScalarReference > response_variation;
 
    Calibration::ConvertMJD convert;
 
 
    std::vector< Reference::To< VariableBackendEstimate > > backends;
 
    VariableBackendEstimate* new_backend (MEAL::Complex2* response = 0);
 
    Reference::To< const MEAL::Complex2 > foreach_pcal;
    Reference::To< const MEAL::Complex2 > foreach_fcal;
 
    Reference::To< const Calibration::VariableBackend > stepeach_pcal;
 
    Reference::To< MEAL::Univariate<MEAL::Scalar> > gain_variation;
    Reference::To< MEAL::Univariate<MEAL::Scalar> > diff_gain_variation;
    Reference::To< MEAL::Univariate<MEAL::Scalar> > diff_phase_variation;
 
    Reference::To< MEAL::Real4 > impurity;
 
 
    Reference::To< MEAL::Complex2 > solution_response;
 
    void integrate_parameter (MEAL::Scalar* function, double value);
 
    void update_parameter (MEAL::Scalar* function, double value);
 
    void set_min_step (MEAL::Scalar* function, double minimum);
 
    void offset_steps (MEAL::Scalar* function, double offset);
 
    void set_free (unsigned iparam, const MJD& mjd);
 
    void fix_last_step (MEAL::Scalar* function);
 
    bool time_variations_engaged;
    bool step_after_cal;
    bool constant_pulsar_gain;
    bool refcal_through_frontend;
    
    MJD min_epoch, max_epoch;
 
  private:
 
    Reference::To<Pulsar::Calibrator::Type> type;
 
    bool built;
 
    void build ();
 
    void const_build () const;
 
  };
  
 
 
 
}
 
#endif