FFTW_FFT.h

Go to the documentation of this file.

#ifndef FFTW_FFT_H
#define FFTW_FFT_H

#include "FFTW_Object.h"

#include "FFTW_ComplexArray.h"
#include "FFTW_Plan.h"

DEFINE_SPTR(FFTW_FFT);
class FFTW_FFT : public virtual FFTW_Object {
    SP_OBJECT(FFTW_FFT);
    // ATTRIBUTES

public:
  



private:

    //dimension of each point
    tUSInt mDimension;

    //number of points
    tUIndex mPointsNumber;
    
    //list of plans to excute FFTs
    SV::FFTW_Plan mPlans;

    //values of size mDimension*mPointsNUmber
    FFTW_ComplexArray mValues;
    
protected: 
    // METHODS
    
    // CONSTRUCTORS 
    
    FFTW_FFT();
    
    
    // DESTRUCTORS 
    
    
    virtual ~FFTW_FFT(void);

public:

    //New constructors
   
   
    virtual SP::FFTW_FFT NewInstance() const=0;
    
    
public:
    //accessor operators
    //==================
    inline const tFFTWComplex&  operator[](const tUIndex& i) const {
        return mValues[i];
    }
    inline tFFTWComplex&  operator[](const tUIndex& i)  {
        return mValues[i];
    }
  
    //copy operators
    inline FFTW_FFT& operator=(const tReal& v) {
        mValues=v;
        return (*this);
    }
    inline FFTW_FFT& operator=(const tFFTWComplex& v) {
        mValues=v;
        return (*this);
    }
    inline FFTW_FFT& operator=(const FFTW_FFT& Y) {
        copy(Y);
        return (*this);
    }
    


    //arithmetic operator
    
    inline FFTW_FFT& operator*=(const FFTW_FFT& Y) {
        multiply(Y);
        return (*this);
    }

    
    virtual void clear();
    
    virtual void copy(const FFTW_FFT& c);

    // SET methods
    //============
    
    inline void setPointsNumber(const tUIndex& n) {
        mPointsNumber=n;
        mValues.setSize(n*mDimension);
    }

    virtual void setDimension(const tUSInt& n) {
        mDimension=n;
    }

    virtual void setSize(const CORE_UIndexArray& levels,
                         const tUSInt& dim)=0;
    
    
    
    virtual void setFFTsNumber(const tUInt& nFFTs)=0;
    
    
    
    virtual void setFFT(const tUInt& f,
                        const tSInt& dir,
                        const tBoolean& isInverse,
                        const tBoolean& optimize)=0;

    
    virtual void setFFT(const tUInt& f,const tSInt& dir,const tBoolean& isInverse) {
        setFFT(f,dir,isInverse,false);
    }
    
    virtual void setFFT(const tUInt& f,const tBoolean& isInverse) {
        setFFT(f,FFTW_Plan::BACKWARD,isInverse,false);
    }


    //GET methods
    //===========
  
    virtual tULLInt getMemorySize() const {
        return mValues.getMemorySize();
    }
    
    inline const FFTW_ComplexArray& getArray() const {
        return mValues;
    }
    inline FFTW_ComplexArray& getArray() {
        return mValues;
    }

    inline const tFFTWComplex* getValues() const {
        return &mValues[0];
    }
    inline tFFTWComplex* getValues()  {
        return &mValues[0];
    }

    inline const tUIndex& getValuesNumber() const {
        return mValues.getSize();
    }
    inline const tUSInt& getDimension() const {
        return mDimension;
    }
    inline  const tUIndex& getPointsNumber() const {
        return mPointsNumber;
    }
    virtual tUIndex getSize(CORE_UIndexArray& levels) const=0;
    
    //operators on values
    //===================
    
    virtual void multiply(const FFTW_FFT& Y) {
        mValues*=Y.getArray();
    }
    
    virtual void runFFT(const tUIndex& f)=0;
    
    
    //PLAN Managment methods
    //======================

protected:
    
    inline void setPlansNumber(const tUIndex& n) {
        mPlans.setSize(n);
    }
    
    inline tUIndex getPlansNumber() const {
        return mPlans.getSize();
    }
    
    inline const SV::FFTW_Plan& getPlans()  const {
        return mPlans;
    }
    inline SV::FFTW_Plan& getPlans()   {
        return mPlans;
    }
    
    virtual void setPlan(const tUIndex& i,FFTW_Plan& p)=0;
       
    
    
    
};

#endif