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_EndZeroPadderOptimized.hh"
#include "MHO_MultidimensionalFastFourierTransform.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];
 
        //One resampling instruction: output rate bin k of channel c is the linear interpolation out:
        //(1-frac)*spectrum[lo] + frac*spectrum[hi], the interp parameters are precomputed per (ch,dr) so the hot loop
        //carries no fmod or index arithmetic.
        struct InterpEntry
        {
                int lo, hi;
                double frac;
        };
 
        void ApplyDataWeights(const XArgType2* in2, XArgType3* out);
        void ConditionallyResizeOutput(const std::size_t* dims, std::size_t size, XArgType3* out);
 
        void BuildResamplingTable(const XArgType1* in1);
 
        void ApplyInterpolation(const XArgType1* in1, 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_EndZeroPadderOptimized< visibility_type > fZeroPadder;
        FFT_ENGINE_TYPE fFFTEngine;
 
        int fDRSPSize;
        double fRefFreq;
 
        bool fInitialized;
 
        //Resampling instructions, indexed [ch*fDRSPSize + dr]. The lo/hi indices already
        //include the half-length shift that centres zero rate, so they address the raw
        //post-FFT array directly and no separate fftshift pass is needed.
        std::vector< InterpEntry > fInterpTable;
 
        //staging buffer for ApplyInterpolation: fDRSPSize rows x nsbd columns
        std::vector< sbd_type::value_type > fInterpWorkspace;
};
 
} // namespace hops
 
#endif