FFTW_MultiLevelsDFT.h

Go to the documentation of this file.

#ifndef FFTW_MultiLevelsDFT_H
#define FFTW_MultiLevelsDFT_H

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

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

public:
  



private:

    //the number of points by level
    CORE_UIndexArray mLevels;
    
   
    // ASSOCIATIONS
    
    //number of threads by levels
    CORE_UIntegerArray mThreadsNumber;
    
    //plan values
    FFTW_ComplexArray *mY;


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

private:
    void allocatePlanValues(const tUIndex& n);
    void desallocatePlanValues();

public:

    //New constrctors
    inline static SP::FFTW_MultiLevelsDFT New() {
        SP::FFTW_MultiLevelsDFT p(new FFTW_MultiLevelsDFT(),FFTW_MultiLevelsDFT::Delete());
        p->setThis(p);
        return p;
    }
   
   
    virtual SP::FFTW_FFT NewInstance() const {
        return FFTW_MultiLevelsDFT::New();
    }
    
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];
    }
  
    
    
    
    //copy operator
    //============
   
    
    
    virtual void copy(const FFTW_FFT& c);
    
    // SET methods
    //============
    
    virtual void clear();

    virtual void setSize(const CORE_UIndexArray& levels,
                         const tUSInt& dim) {
        setLevels(levels.getSize(),&levels[0],dim);
    }
    
    tUIndex setLevels(const tUInt& nLevels,
                      const tUIndex levels[],
                      const tUSInt& dim);
    
    
    virtual tUIndex setLevels(const CORE_UIndexArray& levels,const tUSInt& dim) {
        return setLevels(levels.getSize(),&levels[0],dim);
    }
    
    virtual void setFFTsNumber(const tUInt& n) {
        tUIndex sT=0;
        const tUInteger *Tu=&mThreadsNumber[0];
        const tUIndex *Nu=&mLevels[0];
        for (tUIndex u=0;u<mLevels.getSize();u++) {
            sT+=(*Tu);
            Nu++;
            Tu++;
        }
        //set the number of plans
        setPlansNumber(n*sT*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
   

 
public:
    virtual tULLInt getMemorySize() const {
        return FFTW_FFT::getMemorySize()+((mY==null)?0:mY->getMemorySize());
    }
    virtual tUInt getFFTsNumber() const {
        tUIndex sT=0;
        const tUInteger *Tu=&mThreadsNumber[0];
        const tUIndex *Nu=&mLevels[0];
        for (tUIndex u=0;u<mLevels.getSize();u++) {
            sT+=(*Tu);
            Nu++;
            Tu++;
        }
        return FFTW_FFT::getPlansNumber()/(sT*getDimension());        
    }
    virtual tUIndex getSize(CORE_UIndexArray& levels) const{
        levels.copy(mLevels);
        return getPointsNumber();
    }
   
    
    inline const tUIndex& getSize(const tUInt& l) const {
        return mLevels[l];
    }
    
    const CORE_UIndexArray& getLevels() const {
        return mLevels;
    }

    inline const tUIndex & getLevelsNumber() const {
        return mLevels.getSize();
    }
    


    // OTHERS methods


    virtual void runFFT(const tUIndex& f);
 
  

    //FFT methods
    
    
private:

    inline tUIndex getProjectionsNumber(const tUInt& l) const {
        return getPointsNumber()/mLevels[l];
    }

    //methods 1 based on global projection index
    //===========================================
    tUIndex computeProjection(const tUIndex& nLevels,const tUIndex* levels,const tUIndex& l,const tUIndex p,tUIndex& index0,tUIndex& step) const;
    
    void project(const tUIndex& nLevels,const tUIndex* levels,const tUIndex& l,const tUIndex& p,const tFFTWComplex* V,tFFTWComplex* A) const;
    
    void  recover(const tUIndex& nLevels,const tUIndex* levels,const tUIndex& l,const tUIndex& p,const tFFTWComplex* A,tFFTWComplex* V) const;

    //methods 2 based on  projection indices
    //======================================
    void computeProjectionIndex(const tUIndex& nLevels,const tUIndex *levels,
                                const tUIndex& l,const tUIndex& p,
                                tUIndex* I) const;

    void nextIndices(const tUIndex& nLevels,const tUIndex* levels,const tUIndex& l,tUIndex* I) const;

    void  project(const tUIndex& nLevels,const tUIndex* levels,const tUIndex* I,const tUIndex& step,const tUIndex& N,
                  const tFFTWComplex* V,tFFTWComplex *Y) const;

    void  recover(const tUIndex& nLevels,const tUIndex* levels,const tUIndex* I,const tUIndex& step,const tUIndex& N,
                  const tFFTWComplex* Y,tFFTWComplex *V) const;
    
    //PLAN Managment methods
    //======================
protected:
    virtual void setPlan(const tUIndex& i,FFTW_Plan& p);

};

#endif