MHO_SpectralLineFringeSearch.hh

Go to the documentation of this file.

#ifndef MHO_SpectralLineFringeSearch_HH__
#define MHO_SpectralLineFringeSearch_HH__
 
#include <cmath>
#include <complex>
 
#include "MHO_ContainerDefinitions.hh"
#include "MHO_CyclicRotator.hh"
#include "MHO_InspectingOperator.hh"
 
#ifdef HOPS_USE_FFTW3
    #include "MHO_MultidimensionalFastFourierTransformFFTW.hh"
#else
    #include "MHO_MultidimensionalFastFourierTransform.hh"
#endif
 
namespace hops
{
 
class MHO_SpectralLineFringeSearch: public MHO_InspectingOperator< visibility_type >
{
    public:
        MHO_SpectralLineFringeSearch();
        virtual ~MHO_SpectralLineFringeSearch();
 
        void SetWeights(weight_type* wt_data) { fWeights = wt_data; }
 
        void SetReferenceFrequency(double ref_freq_mhz) { fRefFreq = ref_freq_mhz; }
 
        void SetDRWindow(double low, double high);
 
        void GetDRWindow(double& low, double& high) const;
 
        void SetFrequencyWindow(double low_mhz, double high_mhz);
 
        void GetFrequencyWindow(double& low_mhz, double& high_mhz) const;
 
        int GetChanMaxBin() const { return fChanMaxBin; }
 
        int GetDRMaxBin() const { return fDRMaxBin; }
 
        int GetFreqMaxBin() const { return fFreqMaxBin; }
 
        double GetCoarseDR() const { return fCoarseDR; }
 
        double GetCoarsePeakSkyFrequencyMHz() const { return fCoarsePeakSkyFreqMHz; }
 
        double GetSearchMaximumAmplitude() const { return fMax; }
 
        int GetNDRBins() const { return static_cast< int >(fNDR); }
 
        double GetDRBinSeparation() const { return fDRBinSep; }
 
        delay_rate_axis_type* GetDRAxis() { return &fDRAxis; }
 
        visibility_type* GetSpecDRData() { return &fSpecDRWorkspace; }
 
    protected:
        using XArgType = visibility_type;
 
        virtual bool InitializeImpl(const XArgType* in) override;
        virtual bool ExecuteImpl(const XArgType* in) override;
 
    private:
        void SetWindow(double* win, double low, double high);
 
        weight_type* fWeights;
        double fRefFreq; // MHz
 
        bool fDRWinSet;
        bool fFreqWinSet;
        double fDRWin[2];   // sec/sec
        double fFreqWin[2]; // MHz
 
        bool fInitialized;
 
        std::size_t fNAP;       // original number of accumulation periods
        std::size_t fNPaddedAP; // zero-padded size (next power of 2 >= 2*N_AP)
        std::size_t fNChan;
        std::size_t fNFreq;
        std::size_t fNDR; // = fNPaddedAP
 
        double fDRBinSep; // sec/sec
 
        int fChanMaxBin;
        int fDRMaxBin;
        int fFreqMaxBin;
 
        double fCoarseDR;
        double fCoarsePeakSkyFreqMHz;
        double fMax;
 
        delay_rate_axis_type fDRAxis;
 
        // Internal workspace: [1][N_chan][N_padded_AP][N_freq]
        // Filled with weighted visibilities, then transformed in-place by the FFT engine.
        visibility_type fSpecDRWorkspace;
 
#ifdef HOPS_USE_FFTW3
        using FFT_ENGINE_TYPE = MHO_MultidimensionalFastFourierTransformFFTW< visibility_type >;
#else
        using FFT_ENGINE_TYPE = MHO_MultidimensionalFastFourierTransform< visibility_type >;
#endif
 
        FFT_ENGINE_TYPE fFFTEngine;
        MHO_CyclicRotator< visibility_type > fCyclicRotator;
};
 
} // namespace hops
 
#endif