fft_manager.h

Go to the documentation of this file.

/*
Arroyo - software for the simulation of electromagnetic wave propagation
through turbulence and optics.

Copyright (c) 2000-2004 California Institute of Technology.  Written by
Dr. Matthew Britton.  For comments or questions about this software,
please contact the author at mbritton@astro.caltech.edu.

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.

This program is provided "as is" and distributed in the hope that it
will be useful, but WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  In no
event shall California Institute of Technology be liable to any party
for direct, indirect, special, incidental or consequential damages,
including lost profits, arising out of the use of this software and its
documentation, even if the California Institute of Technology has been
advised of the possibility of such damage.   The California Institute of
Technology has no obligation to provide maintenance, support, updates,
enhancements or modifications.  See the GNU General Public License for
more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
*/

#ifndef FFT_MANAGER_H
#define FFT_MANAGER_H

#ifndef FFTW_REAL_TO_COMPLEX
#define FFTW_REAL_TO_COMPLEX FFTW_FORWARD
#define FFTW_COMPLEX_TO_REAL FFTW_BACKWARD
#endif

#include <fftw3.h>
#include <iostream>
#include <vector>
#include <string>
#include "AO_cpp.h"


namespace Arroyo {

  using std::string;
  using std::vector;
  using std::ostream;


  template<class T>
    class fft_manager {

    private:
  

    protected:


    public:

    fft_manager();

    fft_manager(const fft_manager<T> & fft_mgr);

    ~fft_manager();

    fft_manager<T> & operator=(const fft_manager<T> & fft_mgr);

    void forward_fft(const vector<long> & in_array_dimens,
                        bool estimate, bool in_place,
                        T * in, T * out = NULL);
  
    void forward_fft(const vector<long> & in_array_dimens,
                        bool estimate, bool in_place,
                        int howmany, T * in, int istride, int idist, 
                        T * out=NULL, int ostride=1, int odist=1);
  
    void backward_fft(const vector<long> & in_array_dimens,
                        bool estimate, bool in_place,
                        T * in, T * out = NULL);

    void backward_fft(const vector<long> & in_array_dimens,
                        bool estimate, bool in_place,
                        int howmany, T * in, int istride, int idist, 
                        T * out=NULL, int ostride=1, int odist=1);

    static int verbose_level;

  };

  template<class T>
    int fft_manager<T>::verbose_level = 0;

  template<class T>
    fft_manager<T>::fft_manager(const fft_manager<T> & fft_mgr){

    this->operator=(fft_mgr);
  }

  template<class T>
    fft_manager<T>::~fft_manager(){
  }

  template<class T>
    fft_manager<T> & fft_manager<T>::operator=(const fft_manager<T> & fft_mgr){
    if(this==&fft_mgr) 
      return(*this);

    return(*this);
  }

  template<class T>
    void fft_manager<T>::forward_fft(const vector<long> & in_array_dimens,
                        bool estimate, bool in_place,
                        T * in, T * out) {
      this->forward_fft(in_array_dimens, estimate, in_place, 1, in, 1, 1, out, 1, 1);
  }

  template<class T>
    void fft_manager<T>::backward_fft(const vector<long> & in_array_dimens,
                        bool estimate, bool in_place,
                        T * in, T * out) {
    this->backward_fft(in_array_dimens, estimate, in_place, 1, in, 1, 1, out, 1, 1);
  }



  template<class T>
    class rfft_manager {

    private:
  
 
    protected:


    public:

    rfft_manager();

    rfft_manager(const rfft_manager<T> & rfft_mgr);

    ~rfft_manager();

    rfft_manager<T> & operator=(const rfft_manager<T> & rfft_mgr);

    void real_to_complex_fft(const vector<long> & in_array_dimens,
                        bool estimate, bool in_place,
                        T * in, T * out = NULL) ;

    void real_to_complex_fft(const vector<long> & in_array_dimens,
                        bool estimate, bool in_place,
                        int howmany, T * in, int istride, int idist, 
                        T * out=NULL, int ostride=1, int odist=1) ;
 
    void complex_to_real_fft(const vector<long> & in_array_dimens,
                        bool estimate, bool in_place,
                        T * in, T * out = NULL) ;

    void complex_to_real_fft(const vector<long> & in_array_dimens,
                        bool estimate, bool in_place,
                        int howmany, T * in, int istride, int idist, 
                        T * out=NULL, int ostride=1, int odist=1) ;
 
    static int verbose_level;

  };

  template<class T>
    int rfft_manager<T>::verbose_level = 0;


  template<class T>
    rfft_manager<T>::rfft_manager(const rfft_manager<T> & rfft_mgr){

    this->operator=(rfft_mgr);
  }

  template<class T>
    rfft_manager<T>::~rfft_manager(){

  }

  template<class T>
    rfft_manager<T> & rfft_manager<T>::operator=(const rfft_manager<T> & rfft_mgr){
    if(this==&rfft_mgr) 
      return(*this);

    return(*this);
  }

  template<class T>
    void rfft_manager<T>::real_to_complex_fft(
                const vector<long> & in_array_dimens,
                bool estimate, bool in_place,
                T * in, T * out) {
      this->real_to_complex_fft(in_array_dimens, estimate, in_place,
                                1, in, 1, 1, out, 1, 1);
  }

  template<class T>
    void rfft_manager<T>::complex_to_real_fft(
                const vector<long> & in_array_dimens,
                bool estimate, bool in_place,
                T * in, T * out) {
      this->complex_to_real_fft(in_array_dimens, estimate, in_place,
                                1, in, 1, 1, out, 1, 1);
  }

}

#endif

---