Convolution.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2002 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// dspsr/Signal/General/dsp/Convolution.h
 
#ifndef __Convolution_h
#define __Convolution_h
 
#include "dsp/Response.h"
#include "dsp/ResponseProduct.h"
#include "dsp/ScalarFilter.h"
 
#include "dsp/Transformation.h"
#include "dsp/TimeSeries.h"
#include "FTransformAgent.h"
 
namespace dsp {
 
  class Apodization;
 
 
  class Convolution: public Transformation <TimeSeries, TimeSeries> {
 
  public:
 
    class Config;
 
    Convolution (const char* name = "Convolution", Behaviour type = outofplace);
 
    virtual ~Convolution ();
 
    void prepare ();
 
    void reserve ();
 
    uint64_t get_minimum_samples () { return nsamp_fft; }
 
    uint64_t get_minimum_samples_lost () { return nsamp_overlap; }
 
    double get_delay_time () const override;
 
    //virtual const string descriptor () const;
 
    //virtual void initialize (const string& descriptor);
 
    virtual void set_response (Response* response);
 
    virtual void set_temporal_apodization (Apodization*);
 
    virtual void set_spectral_apodization (Apodization*);
 
    virtual void set_passband (Response* passband);
 
    bool has_response () const;
 
    virtual const Response* get_response() const;
    virtual Response* get_response();
 
    bool has_passband () const;
 
    virtual const Response* get_passband() const;
    virtual Response* get_passband();
 
    bool has_temporal_apodization() const;
 
    virtual const Apodization* get_temporal_apodization() const;
    virtual Apodization* get_temporal_apodization();
 
    bool has_spectral_apodization() const;
 
    virtual const Apodization* get_spectral_apodization() const;
    virtual Apodization* get_spectral_apodization();
 
    bool get_matrix_convolution () const { return matrix_convolution; };
 
    void set_critically_sampled_output (bool flag = true);
    bool get_critically_sampled_output () { return critically_sampled_ouptut; }
 
    void set_device (Memory *);
 
    class Engine;
 
    void set_engine (Engine*);
 
    Engine* get_engine();
 
    bool get_zero_DM () const { return zero_DM; }
 
    void set_zero_DM (bool _zero_DM) { zero_DM = _zero_DM; }
 
    bool has_zero_DM_output () const;
 
    virtual void set_zero_DM_output (TimeSeries* zero_DM_output);
 
    virtual const TimeSeries* get_zero_DM_output() const;
    virtual TimeSeries* get_zero_DM_output();
 
    bool has_zero_DM_response () const;
 
    virtual const Response* get_zero_DM_response() const;
    virtual Response* get_zero_DM_response();
 
    virtual void set_zero_DM_response (Response* response);
 
 
  protected:
 
    virtual void transformation ();
 
    Reference::To<ScalarFilter> normalizer;
 
    Reference::To<Response> response;
 
    Reference::To<Response> zero_DM_response;
 
    Reference::To<ResponseProduct> response_product;
 
    Reference::To<ResponseProduct> zero_dm_response_product;
 
    Reference::To<Apodization> temporal_apodization;
 
    Reference::To<Apodization> spectral_apodization;
 
    Reference::To<Response> passband;
 
    void prepare_output ();
 
    void prepare_temporal_apodization ();
 
    void prepare_spectral_apodization ( unsigned bcc_nfft );
 
    void prepare_spectral_apodization ( unsigned bcc_nfft, bool dual_sideband );
 
    void prepare_passband ();
 
    bool zero_DM;
 
    Reference::To<dsp::TimeSeries> zero_DM_output;
 
  private:
 
    friend class Filterbank;
    friend class InverseFilterbank;
    friend class TFPFilterbank;
    friend class SKFilterbank;
 
    Reference::To<Memory> memory;
 
    unsigned nfilt_tot{0};
    unsigned nfilt_pos{0};
    unsigned nfilt_neg{0};
 
    unsigned nsamp_overlap{0};
    unsigned nsamp_step{0};
    unsigned nsamp_fft{0};
 
    double scalefac{1.0};
 
    bool matrix_convolution{false};
    bool critically_sampled_ouptut{false};
 
    FTransform::Plan* forward{nullptr};
    FTransform::Plan* backward{nullptr};
 
    unsigned scratch_needed{0};
    uint64_t npart{0};
    unsigned n_fft{0};
 
    Reference::To<Engine> engine;
  };
}
 
class dsp::Convolution::Engine : public Reference::Able
{
  public:
 
    virtual void set_scratch (void *) = 0;
 
    virtual void prepare (dsp::Convolution * convolution) = 0;
 
    virtual void perform (const dsp::TimeSeries* in, dsp::TimeSeries* out, unsigned npart) = 0;
 
    virtual void perform (const dsp::TimeSeries* in, dsp::TimeSeries* out, dsp::TimeSeries* zero_DM_out, unsigned npart) = 0;
};
 
#endif