MHO_ComputePlotData.hh

Go to the documentation of this file.

#ifndef MHO_ComputePlotData_HH__
#define MHO_ComputePlotData_HH__
 
#include "MHO_ContainerDefinitions.hh"
#include "MHO_TableContainer.hh"
 
#include "MHO_BinaryOperator.hh"
#include "MHO_ComplexConjugator.hh"
#include "MHO_CyclicRotator.hh"
#include "MHO_FringeRotation.hh"
#include "MHO_FunctorBroadcaster.hh"
#include "MHO_MathUtilities.hh"
#include "MHO_NaNMasker.hh"
#include "MHO_SubSample.hh"
 
#include "MHO_ContainerStore.hh"
#include "MHO_OperatorToolbox.hh"
#include "MHO_ParameterStore.hh"
 
#ifdef HOPS_USE_FFTW3
    #include "MHO_FFTWTypes.hh"
    #include "MHO_MultidimensionalFastFourierTransformFFTW.hh"
#else
    #include "MHO_FastFourierTransform.hh"
#endif
 
#include "MHO_MultidimensionalFastFourierTransform.hh"
 
#include "MHO_JSONHeaderWrapper.hh"
 
namespace hops
{
 
class MHO_ComputePlotData
{
    public:
        MHO_ComputePlotData();
        virtual ~MHO_ComputePlotData(){};
 
        void EnableOptimizeClosure() { fRot.SetOptimizeClosureTrue(); }
 
        void DisableOptimizeClosure() { fRot.SetOptimizeClosureFalse(); }
 
        void SetMBDAnchor(std::string flag) { fMBDAnchor = flag; }
 
        void SetOperatorToolbox(MHO_OperatorToolbox* toolbox) { fToolbox = toolbox; }
 
        void SetContainerStore(MHO_ContainerStore* cStore) { fContainerStore = cStore; }
 
        void SetParameterStore(MHO_ParameterStore* pStore) { fParamStore = pStore; }
 
        void SetVexInfo(const mho_json& vex_info) { fVexInfo = vex_info; }
 
        void Initialize();
 
        void DumpInfoToJSON(mho_json& plot_dict);
 
        void DumpSpectralLineInfoToJSON(mho_json& plot_dict);
 
        //protected:
 
        TODO_FIXME_MSG("TODO FIXME, temporary kludge to pass sbd amp data for test")
        xpower_amp_type calc_mbd();
        xpower_amp_type calc_sbd();
        phasor_type calc_segs();
        xpower_type calc_xpower_spec();
        xpower_amp_type calc_dr();
 
        // visibility_type* calc_corrected_vis();
        void correct_vis();
 
        double calc_phase();
 
        void calc_freqrms(phasor_type& phasors, double coh_avg_phase, double fringe_amp, double total_summed_weights,
                          double snr, double& freqrms_phase, double& freqrms_amp, double& inc_avg_amp_freq);
 
        void calc_timerms(phasor_type& phasors, std::size_t nseg, std::size_t apseg, double coh_avg_phase, double fringe_amp,
                          double total_summed_weights, double snr, double& timerms_phase, double& timerms_amp,
                          double& inc_avg_amp);
 
        //exports the multitone pcal data (if it was applied)
        //to the plot dictionary
        void dump_multitone_pcmodel(mho_json& plot_dict,
                                    int station_flag,           //0 = reference station, 1 = remote station,
                                    std::string pol,            //single char string
                                    std::string key_suffix = "" //appended to PLOT_INFO keys, e.g. "2" for second pol
        );
 
        //exports the manual pcal data (pc_phases)
        //to the plot dictionary
        void dump_manual_pcmodel(mho_json& plot_dict,
                                 int station_flag,           //0 = reference station, 1 = remote station,
                                 std::string pol,            //single char string
                                 std::string key_suffix = "" //appended to PLOT_INFO keys, e.g. "2" for second pol
        );
 
        std::string calc_quality_code(); //quality only, not error
 
        void precompute_chan_metadata();
 
        void precompute_vr_tables();
 
        void calc_sbd_and_xpower_spec(xpower_amp_type& sbd_amp, xpower_type& cp_spectrum);
 
        xpower_amp_type calc_dr_segs_phase(double& coh_avg_phase, phasor_type& phasor_segs);
 
        std::string calc_error_code(const mho_json& plot_dict);
 
        void smooth_dr_spectrum_tcohere(std::size_t drsp_size, double ap_delta);
 
        double fRefFreq;
        double fTotalSummedWeights;
        double fMBDelay;
        double fDelayRate;
        double fFringeRate;
        double fSBDelay;
        double fAmp;
 
        std::size_t fSBDMaxBin;
 
        bool fValid;
        visibility_type* fVisibilities;
        visibility_type* fSBDArray;
        weight_type* fWeights;
 
        xpower_type fDRWorkspace;
        xpower_amp_type fDRAmpWorkspace;
 
        xpower_type fMBDWorkspace;
        xpower_amp_type fMBDAmpWorkspace;
 
        xpower_type fFringe;
 
        MHO_ContainerStore* fContainerStore;
        MHO_ParameterStore* fParamStore;
        MHO_OperatorToolbox* fToolbox;
        mho_json fVexInfo;
 
        MHO_MultidimensionalFastFourierTransform< xpower_type > fFFTEngine;
        MHO_CyclicRotator< xpower_type > fCyclicRotator;
 
        //class which implements vrot
        MHO_FringeRotation fRot;
 
        //flag for mbd anchor
        std::string fMBDAnchor;
 
        //space for xpower spectrum and sbdbox
        std::vector< double > fSBDBox;
        std::vector< int > fNUSBAP;
        std::vector< int > fNLSBAP;
 
        //constants
        std::complex< double > fImagUnit;
 
        // Pre-computed per-channel metadata (populated by precompute_chan_metadata)
        std::size_t fNChan;
        std::size_t fNAP;
        std::vector< double > fChanFreq;      // sky frequency per channel
        std::vector< int > fChanSideband;     // sideband sign per channel: +1=USB, 0=DSB, -1=LSB
        std::vector< double > fChanBandwidth; // bandwidth per channel
 
        // Pre-computed vrot tables indexed as [ch * fNAP + ap] (populated by precompute_vr_tables)
        std::vector< std::complex< double > > fVRTable;      // default SBD params + fMBDelay
        std::vector< std::complex< double > > fVRMBD0Table;  // default SBD params + MBD=0
        std::vector< std::complex< double > > fVRPhaseTable; // proper SBD params + fMBDelay
 
        //lsb/usb validity segments
        std::vector< std::vector< double > > seg_frac_usb;
        std::vector< std::vector< double > > seg_frac_lsb;
};
 
} // namespace hops
 
#endif