CyclicFold.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2011 by Paul Demorest
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
#ifndef __baseband_dsp_CyclicFold_h
#define __baseband_dsp_CyclicFold_h
 
#include "dsp/Transformation.h"
#include "dsp/TimeSeries.h"
#include "dsp/PhaseSeries.h"
#include "dsp/Fold.h"
#include "FTransformAgent.h"
#include "dsp/Apodization.h"
 
namespace dsp {
 
 
  class CyclicFold : public Fold {
 
    /* TODO:
     * Need to figure out how to overlap input by nlag points...
     */
 
  public:
    
    CyclicFold ();
    
    ~CyclicFold ();
 
    virtual void prepare ();
 
    void set_engine(Engine*);
 
    void set_nlag(unsigned _nlag) { nlag = _nlag; }
    unsigned get_nlag() const { return nlag; }
 
    void set_mover(unsigned _mover) { mover = _mover; }
    unsigned get_mover() const { return mover; }
 
    void set_nchan(unsigned nchan) { set_nlag(mover*nchan/2 + 1); }
 
    void set_npol(unsigned _npol) { npol = _npol; }
    unsigned get_npol() const { return npol; }
 
  protected:
 
    virtual void check_input();
 
    virtual void prepare_output();
 
    virtual void setup_engine();
 
    unsigned nlag;
 
    unsigned mover;
 
    unsigned npol;
 
  };
 
 
  class CyclicFoldEngine : public Fold::Engine
  {
  public:
 
    CyclicFoldEngine();
    ~CyclicFoldEngine();
 
    virtual void set_nlag (unsigned _nlag);
 
    virtual void set_mover (unsigned _mover);
 
    virtual void set_nbin (unsigned _nbin) { nbin = _nbin; }
 
    virtual void set_npol (unsigned _npol) { npol_out = _npol; }
 
    virtual void set_bin (uint64_t idat, double ibin, double bins_per_samp);
 
    uint64_t set_bins (double phi, double phase_per_sample, uint64_t ndat, uint64_t idat_start);
 
    uint64_t get_bin_hits (int ibin);
 
    virtual PhaseSeries* get_profiles ();
 
    void set_profiles (PhaseSeries* _out) { out = _out; }
 
    virtual void fold ();
 
    virtual void synch (PhaseSeries*);
 
    virtual void zero ();
 
    virtual void set_ndat (uint64_t ndat, uint64_t idat_start);
 
    uint64_t get_ndat_folded () const override;
 
  protected:
 
    // Copy of output
    PhaseSeries* out;
 
    unsigned nlag;
    unsigned mover;
    unsigned nbin;
    unsigned npol_out;
 
    uint64_t nval_folded {0};
 
    // Array of bins to fold into
    unsigned* binplan[2];
    uint64_t binplan_size;
 
    // Temp array to accumulate lag-domain results
    float* lagdata {nullptr};
    // Size of the lagdata array
    uint64_t lagdata_size {0};
    // Return the base address of the lag data for the specified coordinates
    float* get_lagdata_ptr(unsigned ichan, unsigned ipol, unsigned ibin);
 
    // Temp array to accumulate lag-domain hits (counts of integrated samples)
    unsigned* laghits {nullptr};
    // Size of the laghits array
    uint64_t laghits_size {0};
    // Return the base address of the lag hits for the specified coordinates
    unsigned* get_laghits_ptr(unsigned ichan, unsigned ibin);
 
    // FFT plan for going from lags to channels
    FTransform::Plan* lag2chan;
  }; 
 
}
 
#endif // !defined(__CyclicFold_h)