FFTW_MultiDFTs.h

Go to the documentation of this file.

#ifndef FFTW_MultiDFTs_H
#define FFTW_MultiDFTs_H

#include "FFTW_MultiLevelsDFT.h"

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

public:
  



private:

  
    // ASSOCIATIONS
    
    
protected: 
    // METHODS
    
    // CONSTRUCTORS 
    
    FFTW_MultiDFTs();
    
    
    
    // DESTRUCTORS 
    
    
    virtual ~FFTW_MultiDFTs(void);


public:
    //accessor operators
    //==================
 
    inline const tFFTWComplex&  operator()(const tUSInt& k,const tUIndex& i) const {
        return (*this)[i+getPointsNumber()*k];
    }
    inline tFFTWComplex&  operator()(const tUSInt& k,const tUIndex& i)  {
        return (*this)[i+getPointsNumber()*k];
    }

    
    //New constructors
    inline static SP::FFTW_MultiDFTs New() {
        SP::FFTW_MultiDFTs p(new FFTW_MultiDFTs(),
                             FFTW_MultiDFTs::Delete());
        p->setThis(p);
        return p;
    }
    inline static SP::FFTW_MultiDFTs New(const tUSInt& dim) {
        SP::FFTW_MultiDFTs p=New();
        p->setDimension(dim);
        return p;
    }
   
   
    virtual SP::FFTW_FFT NewInstance() const {
        return FFTW_MultiDFTs::New(getDimension());
    }
    
public:
   
    
    
    //copy operator
    //============

    virtual void copy(const FFTW_FFT& cdft);
  
      
    // SET methods
    //============
    
    virtual void clear();

    virtual void setSize(const CORE_UIndexArray& levels,
                         const tUSInt& dim) {
        setDimension(dim);
        tUIndex N=1;
        for (tUIndex i=0;i<levels.getSize();i++) {
            N*=levels[i];
        }
        setPointsNumber(N);
    }
    virtual void setFFTsNumber(const tUInt& n) {
        //set the number of plans by dimension
        setPlansNumber(n*getDimension());
    }
   
    virtual void setFFT(const tUInt& f,
                        const tSInt& dir,
                        const tBoolean& isInverse,
                        const tBoolean& optimize);
    virtual void setFFT(const tUInt& f,const tSInt& dir,const tBoolean& isInverse) {
        FFTW_FFT::setFFT(f,dir,isInverse);
    }
    
    virtual void setFFT(const tUInt& f,const tBoolean& isInverse) {
        FFTW_FFT::setFFT(f,isInverse);
    }

    //GET methods
    //==========
    virtual tUIndex getSize(CORE_UIndexArray& levels) const {
        levels.setSize(1);
        levels[0]=getPointsNumber();
        return getPointsNumber();
    }
   
    virtual tUInt getFFTsNumber() const {
        return FFTW_FFT::getPlansNumber()/getDimension();        
    }
  
    virtual void runFFT(const tUIndex& f);
    
     //PLAN Managment methods
    //======================
protected:
    virtual void setPlan(const tUIndex& i,FFTW_Plan& p) {
        //i=f*mDimension+k
        p.create(getPointsNumber(),
                 &getValues()[(i%getDimension())*getPointsNumber()],
                 CORE_Object::getThread().getThreadsNumber());
    }
};

#endif