TDSPfft.h

Go to the documentation of this file.

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef TDSPFFT_H
#define TDSPFFT_H

#include <TDSPVector.h>
#include <TDSPMatrix.h>
#include <TDSPSignal.h>
#include <TDSPOperator.h>
#include <TDSPOutput1.h>

class TDSPfft : public TDSPOperator  {

  friend istream &operator>>(istream&,TDSPfft&);
  friend ostream &operator<<(ostream&,TDSPfft&);
  friend istream &operator>>(istream&,TDSPfft*);
  friend ostream &operator<<(ostream&,TDSPfft*);
 

 protected:

  static    Bool_t fFFTW; 
  Int_t     fDim; 
  Double_t  fOverSampling; 
  UInt_t    fCyclicPrefix; 

   // my Outputs
  TDSPSignal *fFFT_Signal; 
  TDSPSignal *fIFFT_Signal; 
    
  // low level routines from fftw-project
  //
  void *fftw_vec;         
  void *fftw_plan_forward;    
  void *fftw_plan_backward;   
 

  // my Slots
  TString Slot_FFT;
  TString Slot_IFFT;

  // my Signals
  TString Signal_FFT;
  TString Signal_IFFT;

  
 public:
 
  static Bool_t LoadFFTW(); 
  static void   EnableFFTW() { fFFTW=kTRUE;}; 
  static void   DisableFFTW() { fFFTW=kFALSE;}; 
  static Bool_t UsingFFTW()  { return fFFTW;}; 
    
  // When using tdsp in mex-files - fftw crashes in fftw_destroy_plan...

  static Bool_t _fftw_destroy_plans; 
  
  void do_fft( TComplex *, 
           TComplex *,
           Int_t     ndat, 
           Int_t     stepin       = 1, 
           Int_t     stepout      = 1,
           Int_t     cp           = 0,
           Double_t  oversampling = 1.0 );
 
  void do_ifft(TComplex *, 
           TComplex *, 
           Int_t     ndat, 
           Int_t     stepin       = 1, 
           Int_t     stepout      = 1,
           Int_t     cp           = 0,
           Double_t  oversampling = 1.0); 
  
  TDSPfft(char *name = NULL);
  ~TDSPfft();


  void        SetDim(Int_t d) { fDim=d;}; 
  Int_t       GetDim() const { return fDim;};

  TDSPSignal* GetFFTSignal() const { return fFFT_Signal;};
  TDSPSignal* GetIFFTSignal() const { return fIFFT_Signal;};
   
  // Register the slots and the signals of
  // fft-object
  
  void RegisterSignalsAndSlots() {
    
    // Add the Signals

    Signal_FFT     = AddSignal("FFT(TDSPSignal*)");
    Signal_IFFT    = AddSignal("IFFT(TDSPSignal*)");

    // Add the Slots
   
    Slot_FFT       = AddSlot("FFT(TDSPSignal*)");
    Slot_IFFT      = AddSlot("IFFT(TDSPSignal*)");
    
  }

  // Calculate the fft/ifft of vectors and matrices
  //
  void         fft(TComplex  *in, TComplex  *out, Int_t l, Int_t stepin=1, Int_t stepout=1);
  void        ifft(TComplex  *in, TComplex  *out, Int_t l, Int_t stepin=1, Int_t stepout=1);
  TDSPVector*  fft(TDSPVector*in, TDSPVector*out=NULL); 
  TDSPMatrix*  fft(TDSPMatrix*in, Int_t dim, TDSPMatrix*out=NULL);

  TDSPVector* ifft(TDSPVector*in, TDSPVector*out=NULL); 
  TDSPMatrix* ifft(TDSPMatrix*in, Int_t dim, TDSPMatrix*out=NULL);

  // Slot-Version
  //
  TDSPSignal* FFT(TDSPSignal *input);
  TDSPSignal* IFFT(TDSPSignal *input);
  
  // Get the Size of the output vector from the IFFT using
  // the current settings

  Int_t    GetIFFTLen(Int_t len) {return (Int_t)((len+fCyclicPrefix)*fOverSampling);}; // IFFT-outputlen translation
  Int_t    GetFFTLen(Int_t len)  {return (Int_t)((len/fOverSampling)-fCyclicPrefix);};  // FFT-outputlen translation

  // Set/Get the Oversampling Factor
  //
  void     SetOverSampling(Double_t o) {  fOverSampling = o; }; 
  Double_t GetOverSampling() const { return fOverSampling;}; 

  // Set/Get the Size of the Cyclic Prefix
  //
  void     SetCyclicPrefix(UInt_t c) {  fCyclicPrefix = c; }; 
  UInt_t   GetCyclicPrefix() const { return fCyclicPrefix;}; 

  ClassDef(TDSPfft,1)

};

// global fft-object

extern TDSPfft *gFFT; 

// global fft-routines

TDSPVector *fft(TDSPVector *in, Int_t N=0, TDSPVector *out = NULL); 
TDSPVector *ifft(TDSPVector *in, Int_t N=0, TDSPVector *out = NULL); 
TDSPMatrix *fft(TDSPMatrix *in, Int_t dim, TDSPMatrix *out = NULL); 
TDSPMatrix *ifft(TDSPMatrix *in, Int_t dim, TDSPMatrix *out = NULL);

#endif

---