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/Variable.h"
#include "MEAL/Gain.h"
#include "MEAL/Axis.h"
#include "MEAL/Real4.h"
 
namespace Calibration
{
  class VariableBackend;
  class VariableBackendEstimate;
  

 
  class SignalPath : public Reference::Able
  {
    std::string name;
 
  public:

    static bool verbose;

    SignalPath (Pulsar::Calibrator::Type*);

    void set_name (const std::string& _name) { name = _name; }

    void copy (SignalPath* other);


    void share (SignalPath* other);
    
    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 ();

    bool get_time_variations_engaged () const { return time_variations_engaged; }

    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; }
 
    void set_projection (MEAL::Variable<MEAL::Complex2>*);
    MEAL::Variable<MEAL::Complex2>* get_projection ()
    { return projection; }
 
    void set_faraday_rotation (MEAL::Variable<MEAL::Complex2>*);
    MEAL::Variable<MEAL::Complex2>* get_faraday_rotation ()
    { return faraday_rotation; }
 
 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::Variable<MEAL::Complex2> > projection;

    Reference::To< MEAL::Variable<MEAL::Complex2> > faraday_rotation;

    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;

    bool sharing;
    
    void build ();

    void const_build () const;
 
  };
  
 
 
 
}
 
#endif