ReceptionCalibrator.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2003 - 2012 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/Polarimetry/Pulsar/ReceptionCalibrator.h
 
#ifndef __Pulsar_ReceptionCalibrator_H
#define __Pulsar_ReceptionCalibrator_H
 
#include "Pulsar/SystemCalibrator.h"
#include "Pulsar/ReflectStokes.h"
 
#include "Pulsar/FluxCalManager.h"
#include "Pulsar/StandardData.h"
 
#include "MEAL/VectorRule.h"
 
namespace Pulsar
{
 
  class Archive;
  class Integration;
  class ReferenceCalibrator;
  class FluxCalibrator;
  
 
  class ReceptionCalibrator : public SystemCalibrator
  {
   
  public:
    
    friend class ReceptionCalibratorPlotter;
    friend class SourceInfo;
    
    ReceptionCalibrator (Calibrator::Type*);
 
    ~ReceptionCalibrator ();
 
    bool degenerate_V_boost;
 
    bool measure_cal_V;
 
    bool degenerate_V_rotation;
 
    bool measure_cal_Q;
 
    bool equal_ellipticities;
 
    bool physical_coherency;
 
    bool independent_gains;
 
    bool check_pointing;
 
    bool output_report;
 
    bool multiple_flux_calibrators;
 
    bool model_fluxcal_on_minus_off;
    
    ReflectStokes reflections;
 
    void add_state (unsigned pulse_phase_bin);
    
    unsigned get_nstate_pulsar () const;
    
    Calibrator::Info* new_info_pulsar (unsigned istate) const;
 
    void set_standard_data (const Archive* data);
 
    const PhaseWeight* get_baseline () const;
 
    const PhaseWeight* get_onpulse () const;
 
    void add_calibrator (const Archive* data);
    
    void add_calibrator (const ReferenceCalibrator* polncal);
    
    bool has_fluxcal () const;
 
    const Calibration::FluxCalManager* get_fluxcal (unsigned ichan) const;
 
    void set_previous (const Archive* data);
 
    void set_normalize_by_invariant (bool set = true);
 
    void solve ();
    
  protected:
    
    Reference::To<Calibration::StandardData> standard_data;
 
    MEAL::VectorRule<MEAL::Complex2>* unique;
 
    MEAL::Axis< unsigned > unique_axis;
 
    std::vector< Reference::To<Calibration::FluxCalManager> > fluxcal;
 
    std::vector< std::vector<Calibration::SourceEstimate> > pulsar;
    std::vector< unsigned > phase_bins;
 
    std::vector<MJD> calibrator_epochs;
 
    // counts the number of times that add_data failed
    unsigned add_data_fail;
 
    // counts the number of times that add_data is called
    unsigned add_data_call;
 
    unsigned nthread;
 
    void initialize ();
 
    void init_model (unsigned ichan);
 
    void check_ready (const char* method, bool init = true);
 
    void initial_observation (const Archive* data);
 
    void valid_mask (const std::vector<Calibration::SourceEstimate>&);
 
 
    void add_data (std::vector<Calibration::CoherencyMeasurement>& bins,
                   Calibration::SourceEstimate& estimate,
                   const MJD& epoch, unsigned ichan);
 
    void prepare_calibrator_estimate (Signal::Source);
    std::vector<bool> fluxcal_observation_added;
 
    void submit_calibrator_data (Calibration::CoherencyMeasurementSet&,
                                 const Calibration::SourceObservation&);
 
    void integrate_calibrator_data (const Calibration::SourceObservation&);
 
    void integrate_calibrator_solution (const Calibration::SourceObservation&);
 
    void submit_calibrator_data ();
 
    void match (const Archive*);
 
    void add_pulsar (Calibration::CoherencyMeasurementSet&,
                     const Integration*, unsigned ichan);
 
    Calibration::SourceEstimate& get_estimate (unsigned index,
                                               unsigned ichan);
 
    void integrate_pulsar_data (const Calibration::CoherencyMeasurementSet&);
 
    void integrate_pulsar_data (const Calibration::CoherencyMeasurement&,
                                Calibration::SourceEstimate&,
                                const MJD& epoch, unsigned ichan);
      
    void solve_prepare ();
 
    void export_prepare () const;
 
    void setup_calibrators ();
    void setup_poln_calibrator (Calibration::SourceEstimate&);
    void setup_flux_calibrator (Calibration::FluxCalManager*);
 
    void ensure_consistent_onpulse ();
   };
 
}
 
#endif