MHO_DelayRate.hh

Go to the documentation of this file.

#ifndef MHO_DelayRate_HH__
#define MHO_DelayRate_HH__
 
#include <cmath>
#include <complex>
 
#include "MHO_ContainerDefinitions.hh"
#include "MHO_TableContainer.hh"
 
#include "MHO_BinaryOperator.hh"
#include "MHO_CyclicRotator.hh"
#include "MHO_EndZeroPadderOptimized.hh"
#include "MHO_MultidimensionalFastFourierTransform.hh"
#include "MHO_SubSample.hh"
 
#ifdef HOPS_USE_FFTW3
    #include "MHO_MultidimensionalFastFourierTransformFFTW.hh"
#endif
 
namespace hops
{
 
class MHO_DelayRate: public MHO_BinaryOperator< visibility_type, weight_type, sbd_type >
{
    public:
        MHO_DelayRate();
        virtual ~MHO_DelayRate();
 
        void SetReferenceFrequency(double ref_freq) { fRefFreq = ref_freq; };
 
        int GetDelayRateSearchSpaceSize() const { return fDRSPSize; }
 
        unsigned int CalculateSearchSpaceSize(unsigned int input_size);
 
    protected:
        using XArgType1 = visibility_type;
        using XArgType2 = weight_type;
        using XArgType3 = sbd_type;
 
        virtual bool InitializeImpl(const XArgType1* in1, const XArgType2* in2, XArgType3* out) override;
        virtual bool ExecuteImpl(const XArgType1* in1, const XArgType2* in2, XArgType3* out) override;
 
    private:
        std::size_t fInDims[VIS_NDIM];
        std::size_t fOutDims[VIS_NDIM];
 
        //precomputed per-(ch,dr) interpolation entries - avoids fmod in hot loop.
        //Declared here so it is visible to all method signatures below.
        struct InterpEntry
        {
                int l0, l1;
                double w;
        };
 
        void ApplyDataWeights(const XArgType2* in2, XArgType3* out);
        void ConditionallyResizeOutput(const std::size_t* dims, std::size_t size, XArgType3* out);
 
        void ApplyInterpolation(const XArgType1* in1, XArgType3* out);
 
        void ApplyInterpolationOptimized(const XArgType1* in1, XArgType3* out, const std::vector< InterpEntry >& table);
 
        bool ExecuteImplLegacy(const XArgType1* in1, const XArgType2* in2, XArgType3* out);
 
        bool ExecuteImplOptimized(const XArgType1* in1, const XArgType2* in2, XArgType3* out);
 
#ifdef HOPS_USE_FFTW3
        using FFT_ENGINE_TYPE = MHO_MultidimensionalFastFourierTransformFFTW< visibility_type >;
#else
        using FFT_ENGINE_TYPE = MHO_MultidimensionalFastFourierTransform< visibility_type >;
#endif
 
        MHO_SubSample< sbd_type > fSubSampler;
        MHO_CyclicRotator< sbd_type > fCyclicRotator;
 
        MHO_EndZeroPadderOptimized< visibility_type > fZeroPadder;
        FFT_ENGINE_TYPE fFFTEngine;
 
        int fDRSPSize;
        double fRefFreq;
 
        bool fInitialized;
 
        std::vector< InterpEntry > fInterpTable;
 
        //pre-rotated version of fInterpTable: l0/l1 adjusted by +np/2 (mod np) so that
        //ApplyInterpolationOptimized can read directly from the post-FFT (pre-rotation) array,
        //eliminating the separate CyclicRotator pass from ExecuteImplOptimized.
        std::vector< InterpEntry > fPreRotatedInterpTable;
 
        //staging buffer for ApplyInterpolationOptimized: fDRSPSize rows x nsbd columns
        std::vector< sbd_type::value_type > fInterpWorkspace;
};
 
} // namespace hops
 
#endif