/afs/in2p3.fr/throng/virgo/virgoDev/SoftFlorent/GWOLLUM/v2r2/src/Utils/FFT.h

Go to the documentation of this file.

//  Author : florent robinet (LAL - Orsay): robinet@lal.in2p3.fr
#ifndef __fft__
#define __fft__

#include "CUtils.h"

// __float128 is not supported in CINT
#ifdef __CINT__
typedef struct {char a[7];} __float128; /* 7 chars have the same size as one __float128 */
#endif
//#include <complex.h>
#include "fftw3.h"

using namespace std;


class fft {
  
 public:
  
  fft(const 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 int aIndex){
    return x_f[aIndex][0]*x_f[aIndex][0] + x_f[aIndex][1]*x_f[aIndex][1];
  };

  inline double GetNorm2_t(const 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 int aIndex){
    return sqrt(GetNorm2_f(aIndex));
  };

  inline double GetNorm_t(const int aIndex){
    return sqrt(GetNorm2_t(aIndex));
  };

  inline double GetRe_f(const int aIndex){
    return x_f[aIndex][0];
  };

  inline double GetRe_t(const int aIndex){
    if(fType) return xc_t[aIndex][0];
    return xr_t[aIndex];
  };

  inline double GetIm_f(const int aIndex){
    return x_f[aIndex][1];
  };

  inline double GetIm_t(const int aIndex){
    if(fType) return xc_t[aIndex][1];
    return 0.0;
  };

  inline double GetPhase_f(const int aIndex){
    return atan2(x_f[aIndex][1], x_f[aIndex][0]);
  };

  inline double GetPhase_t(const 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 int GetSize_t(void){ return fSize_t; };

  inline int GetSize_f(void){ return fSize_f; };

  inline void SetRe_t(const int aIndex, const double aValue){
    if(fType) xc_t[aIndex][0]=aValue;
    else      xr_t[aIndex]=aValue;
  };

  inline void SetIm_t(const int aIndex, const double aValue){
    xc_t[aIndex][1]=aValue;
  };

  inline void SetRe_f(const int aIndex, const double aValue){
    x_f[aIndex][0]=aValue;
  };

  inline void SetIm_f(const int aIndex, const double aValue){
    x_f[aIndex][1]=aValue;
  };

  
 private:
  int fSize_t;             
  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

---