PulsarCalibrator.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2004 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/Polarimetry/Pulsar/PulsarCalibrator.h
 
#ifndef __Pulsar_PulsarCalibrator_H
#define __Pulsar_PulsarCalibrator_H
 
#include "Pulsar/SystemCalibrator.h"
#include "Pulsar/PhaseWeight.h"
 
#include "MEAL/Mean.h"
 
#include "toa.h"
 
#include <stdio.h>
 
namespace Pulsar {
 
  class Archive;
  class Integration;
  class PolnProfileFit;
  class ReferenceCalibrator;


  class PulsarCalibrator : public SystemCalibrator {
    
  public:
    
    PulsarCalibrator (Calibrator::Type* = 0);

    ~PulsarCalibrator ();

    bool calibrator_match (const Archive*, std::string& reason_for_not_matching);

    void set_fixed_phase (bool flag = true);

    void share_phase ();

    unsigned get_nchan () const;

    unsigned get_nstate_pulsar () const;

    void set_maximum_harmonic (unsigned max);

    void set_choose_maximum_harmonic (bool flag = true);

    unsigned get_nharmonic () const;

    void set_standard (const Archive* data);

    void set_solve_each (bool = true);

    void set_unload_each (Unloader*);

    void wait ();

    void update_solution ();

    MEAL::Complex2* get_transformation (const Archive* data, unsigned isub, unsigned ichan);

    const PolnProfileFit* get_mtm (unsigned ichan) const;

    bool monitor_gimbal_lock;

    double get_invariant (Integration* subint, unsigned ichan) override;
 
  protected:
    
    friend class MatrixTemplateMatching;

    Reference::To<Pulsar::Archive> standard;

    bool solve_each;

    typedef std::map< unsigned, Reference::Vector<MEAL::Complex2> > Storage;
    Storage store_each;

    Reference::To<Unloader> unload_each;

    MEAL::Complex2* new_transformation (unsigned ichan);

    Reference::Vector<PolnProfileFit> mtm;

    std::vector<float> reduced_chisq;
 
    typedef MEAL::Mean< MEAL::Complex2 > MeanXform;

    Reference::Vector<MeanXform> solution;

    bool fixed_phase;

    bool shared_phase;

    unsigned maximum_harmonic;

    bool choose_maximum_harmonic;

    unsigned chosen_maximum_harmonic;

    PhaseWeight onpulse;

    PhaseWeight baseline;

    void init_model (unsigned ichan);

    void solve1 (const Calibration::CoherencyMeasurementSet& measurements);

    void setup (const Integration* data, unsigned ichan);

    virtual void export_prepare () const;

    virtual bool match (const Archive*, bool throw_exception = true);

    virtual void add_pulsar (const Archive* data, unsigned isub);

    virtual void add_pulsar (Calibration::CoherencyMeasurementSet&,
                             const Integration*, unsigned ichan);

    virtual void add_calibrator (const ReferenceCalibrator*);
 
  private:
 
    // used to communicate between solve and add_observation
    unsigned big_difference;

    void build (unsigned nchan);
 
  };
 
}
 
#endif