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;
    
    bool has_fluxcal () const;

    const Calibration::FluxCalManager* get_fluxcal (unsigned ichan) const;

    void set_normalize_by_invariant (bool set = true);

    double get_invariant (Integration* subint, unsigned ichan) override;
 
  protected:
    
    Reference::To<Calibration::StandardData> standard_data;

    MEAL::VectorRule<MEAL::Complex2>* unique;

    MEAL::Axis< unsigned > unique_axis;
 
    std::vector< Reference::To<Calibration::FluxCalManager> > fluxcal;
 
    typedef Reference::To<Calibration::SourceEstimate> SourceEstimate;

    std::vector< std::vector< SourceEstimate > > pulsar_estimate;
    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 init_model (unsigned ichan);

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

    bool match (const Archive*, bool throw_exception = true);
 
    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