FFT.h

Go to the documentation of this file.

 
#ifndef __fft__
#define __fft__
 
#include "CUtils.h"
#include <fftw3.h>
 
using namespace std;
 
class fft {
  
 public:
  
  fft(const unsigned int aSize_t, const string aPlan = "FFTW_ESTIMATE", const string aType="c2c");
 
  virtual ~fft(void);// destructor
  inline void Forward(void){ fftw_execute(FFT_Forward); };
 
  inline void Backward(void){ fftw_execute(FFT_Backward); };
 
  bool Forward(double *aRe_t, double *aIm_t);
 
  bool Forward(double *aRe_t);
 
  bool Backward(double *aRe_f, double *aIm_f);
 
  bool Backward(double *aRe_f);
 
  inline double GetNorm2_f(const unsigned int aIndex){
    return x_f[aIndex][0]*x_f[aIndex][0] + x_f[aIndex][1]*x_f[aIndex][1];
  };
 
  inline double GetNorm2_t(const unsigned int aIndex){
    if(fType) return xc_t[aIndex][0]*xc_t[aIndex][0] + xc_t[aIndex][1]*xc_t[aIndex][1];
    return xr_t[aIndex]*xr_t[aIndex];
  };
 
  inline double GetNorm_f(const unsigned int aIndex){
    return sqrt(GetNorm2_f(aIndex));
  };
 
  inline double GetNorm_t(const unsigned int aIndex){
    return sqrt(GetNorm2_t(aIndex));
  };
 
  inline double GetRe_f(const unsigned int aIndex){
    return x_f[aIndex][0];
  };
 
  inline double GetRe_t(const unsigned int aIndex){
    if(fType) return xc_t[aIndex][0];
    return xr_t[aIndex];
  };
 
  inline double GetIm_f(const unsigned int aIndex){
    return x_f[aIndex][1];
  };
 
  inline double GetIm_t(const unsigned int aIndex){
    if(fType) return xc_t[aIndex][1];
    return 0.0;
  };
 
  inline double GetPhase_f(const unsigned int aIndex){
    return atan2(x_f[aIndex][1], x_f[aIndex][0]);
  };
 
  inline double GetPhase_t(const unsigned int aIndex){
    if(fType) return atan2(xc_t[aIndex][1], xc_t[aIndex][0]);
    else return 0.0;
  };
 
  double* GetNorm2_f(const double aNorm=1.0);
 
  double* GetNorm2_t(const double aNorm=1.0);
 
  double* GetNorm_f(const double aNorm=1.0);
 
  double* GetNorm_t(const double aNorm=1.0);
 
  double* GetRe_f(const double aNorm=1.0);
 
  double* GetRe_t(const double aNorm=1.0);
 
  double* GetIm_f(const double aNorm=1.0);
 
  double* GetIm_t(const double aNorm=1.0);
 
  double* GetPhase_f(void);
 
  double* GetPhase_t(void);
 
  inline unsigned int GetSize_t(void){ return fSize_t; };
 
  inline unsigned int GetSize_f(void){ return fSize_f; };
 
  inline void SetRe_t(const unsigned int aIndex, const double aValue){
    if(fType) xc_t[aIndex][0]=aValue;
    else      xr_t[aIndex]=aValue;
  };
 
  inline void SetIm_t(const unsigned int aIndex, const double aValue){
    xc_t[aIndex][1]=aValue;
  };
 
  inline void SetRe_f(const unsigned int aIndex, const double aValue){
    x_f[aIndex][0]=aValue;
  };
 
  inline void SetIm_f(const unsigned int aIndex, const double aValue){
    x_f[aIndex][1]=aValue;
  };
 
  
 private:
  unsigned int fSize_t;    
  unsigned int fSize_f;    
  string fPlan;            
  bool fType;              
 
  fftw_complex* xc_t;      
  double* xr_t;            
  fftw_complex* x_f;       
  fftw_plan FFT_Forward;   
  fftw_plan FFT_Backward;  
};
 
 
#endif