MHO_AdhocPhaseCorrection.hh

Go to the documentation of this file.

#ifndef MHO_AdhocPhaseCorrection_HH__
#define MHO_AdhocPhaseCorrection_HH__
 
#include <complex>
#include <string>
#include <vector>
 
#include "MHO_Clock.hh"
#include "MHO_Constants.hh"
#include "MHO_Message.hh"
 
#include "MHO_ContainerDefinitions.hh"
#include "MHO_TableContainer.hh"
#include "MHO_UnaryOperator.hh"
 
namespace hops
{
 
enum class AdhocPhaseMode
{
    NONE = 0,
    SINEWAVE = 1,
    POLYNOMIAL = 2,
    PHYLE = 3
};
 
class MHO_AdhocPhaseCorrection: public MHO_UnaryOperator< visibility_type >
{
    public:
        MHO_AdhocPhaseCorrection();
        virtual ~MHO_AdhocPhaseCorrection();
 
        // ---------------------------------------------------------------
        // Mode
        // ---------------------------------------------------------------
 
        void SetMode(AdhocPhaseMode mode) { fMode = mode; }
 
        AdhocPhaseMode GetMode() const { return fMode; }
 
        // ---------------------------------------------------------------
        // SINEWAVE and POLYNOMIAL shared parameter
        // ---------------------------------------------------------------
 
        void SetTRef(double tref_sec_from_scan_start) { fTRef = tref_sec_from_scan_start; }
 
        double GetTRef() const { return fTRef; }
 
        // ---------------------------------------------------------------
        // SINEWAVE parameters
        // ---------------------------------------------------------------
 
        void SetPeriod(double period_sec) { fPeriod = period_sec; }
 
        double GetPeriod() const { return fPeriod; }
 
        void SetAmplitude(double amp_rad) { fAmplitude = amp_rad; }
 
        double GetAmplitude() const { return fAmplitude; }
 
        // ---------------------------------------------------------------
        // POLYNOMIAL parameters
        // ---------------------------------------------------------------
 
        void SetPolynomialCoeffs(const std::vector< double >& coeffs);
 
        const double* GetPolynomialCoeffs() const { return fPolyCoeffs; }
 
        // ---------------------------------------------------------------
        // PHYLE parameters
        // ---------------------------------------------------------------
 
        void SetRefAdhocFile(const std::string& filename, const std::string& chans);
 
        void GetRefAdhocFile(std::string& filename, std::string& chans) const;
 
        void SetRemAdhocFile(const std::string& filename, const std::string& chans);
 
        void GetRemAdhocFile(std::string& filename, std::string& chans) const;
 
    protected:
        virtual bool InitializeInPlace(visibility_type* in) override;
        virtual bool InitializeOutOfPlace(const visibility_type* in, visibility_type* out) override;
        virtual bool ExecuteInPlace(visibility_type* in) override;
 
    private:
        bool LoadAdhocFile(std::size_t stn_idx);
 
        double ComputeZeta(const std::string& chan_label, double ap_center_sec) const;
 
        double InterpolateFilePhase(std::size_t stn_idx, char fcode, double t_fpday) const;
 
        // ---------------------------------------------------------------
        // Configuration
        // ---------------------------------------------------------------
        AdhocPhaseMode fMode;
 
        // SINEWAVE / POLYNOMIAL shared reference time (seconds from scan start)
        double fTRef;
 
        // SINEWAVE
        double fPeriod;    // seconds
        double fAmplitude; // radians
 
        // POLYNOMIAL (6 coefficients, units: rad / s^n)
        double fPolyCoeffs[6];
 
        // PHYLE: filenames and channel-code strings for [ref=0, rem=1]
        std::string fAhFile[2];
        std::string fAhFileChans[2];
 
        // Parsed PHYLE data. fFileData[stn] is a row-major flat vector:
        //   row k occupies indices [k*(nchan+1) .. (k+1)*(nchan+1))
        //   column 0 is the time (fpday); columns 1..nchan are phases (degrees).
        std::vector< double > fFileData[2];
        std::size_t fNFileRows[2]; // number of data rows read per station
        std::size_t fNFileCols[2]; // number of columns per row (= nchan + 1)
 
        // ---------------------------------------------------------------
        // Scan timing (filled during Initialize)
        // ---------------------------------------------------------------
        double fScanStartFpDay;       // scan start as fractional days since BOY
        double fScanStartSecPastHour; //scan start in seconds past the most recent hour
        int fScanYear;                // year of scan start
        double fAccPeriod;            // accumulation period duration in seconds
 
        // ---------------------------------------------------------------
        // Constants / key strings
        // ---------------------------------------------------------------
        std::complex< double > fImagUnit;
        std::string fChannelLabelKey; // "channel_label"
        std::string fStartKey;        // "start"
};
 
} // namespace hops
 
#endif