src/FFT/FFTBase.h

Go to the documentation of this file.

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 *
 * Visit http://people.web.psi.ch/adelmann/ for more details
 *
 ***************************************************************************/

//--------------------------------------------------------------------------
// Class FFTBase
//--------------------------------------------------------------------------

#ifndef IPPL_FFT_FFTBASE_H
#define IPPL_FFT_FFTBASE_H

// include files
#include "Utility/PAssert.h"
#include "Index/NDIndex.h"
#include "Field/GuardCellSizes.h"

#if defined(IPPL_USE_SCSL_FFT)
#include "FFT/SCSL_FFT.h"
#else
#include "FFT/fftpack_FFT.h"
#endif

#ifdef IPPL_STDSTL
#include <map>
using std::map;
#else
#include <map.h>
#endif

#ifdef IPPL_USE_STANDARD_HEADERS
#include <iostream>
using namespace std;
#else
#include <iostream.h>
#endif

// forward declarations
template <unsigned Dim, class T> class FFTBase;
template <unsigned Dim, class T>
ostream& operator<<(ostream&, const FFTBase<Dim,T>&);

static char* transformTypeString_g[3] = { "complex-to-complex FFT",
                                          "real-to-complex FFT",
                                          "sine transform" };
template <unsigned Dim, class T>
class FFTBase {

public: 

    // Some externally visible typedefs and enums.
    enum { dimensions = Dim };               // dimension
    typedef T Precision_t;                   // precision
    typedef NDIndex<Dim> Domain_t;           // domain type

    // Enumeration of transform types, used by derived FFT classes
    enum FFT_e { ccFFT, rcFFT, sineFFT };

    // Type used for performing 1D FFTs
#if defined(IPPL_USE_SCSL_FFT)
    typedef SCSL<T> InternalFFT_t;
#else
    typedef FFTPACK<T> InternalFFT_t;
#endif

    FFTBase() {}  
  
    FFTBase(FFT_e transform, const Domain_t& domain,
            const bool transformTheseDims[Dim], bool compressTemps);
    
    FFTBase(FFT_e transform, const Domain_t& domain, bool compressTemps);
    
    // destructor
    virtual ~FFTBase(void) { delete [] activeDims_m; }
  
    void write(ostream& out) const;

    void setDirectionName(int direction, const char* directionName);

    void setNormFact(Precision_t nf) { normFact_m = nf; }

    int transVnodes() const {
        if (Ippl::maxFFTNodes() > 0 && Ippl::maxFFTNodes() <= Ippl::getNodes())
            return Ippl::maxFFTNodes();
        else
            return (-1);
    }

protected:


    static GuardCellSizes<Dim> nullGC;

    int getDirection(const char* directionName) const;

    bool transformDim(unsigned d) const;

    unsigned numTransformDims(void) const { return nTransformDims_m; }

    unsigned activeDimension(unsigned d) const;

    InternalFFT_t& getEngine(void) { return FFTEngine_m; }

    Precision_t& getNormFact(void) { return normFact_m; }

    const Domain_t& getDomain(void) const { return Domain_m; }

    bool checkDomain(const Domain_t& dom1, const Domain_t& dom2) const;

    bool compressTemps(void) const { return compressTempFields_m; }

private: 

    map<const char*,int> directions_m;

    FFT_e transformType_m;     
    bool transformDims_m[Dim]; 
    unsigned nTransformDims_m; 
    unsigned* activeDims_m;    

    InternalFFT_t FFTEngine_m;

    Precision_t normFact_m;

    Domain_t Domain_m;

    bool compressTempFields_m;
};


// Inline function definitions

template <unsigned Dim, class T>
inline ostream&
operator<<(ostream& out, const FFTBase<Dim,T>& fft)
{
    fft.write(out);
    return out;
}

template <unsigned Dim, class T>
inline void
FFTBase<Dim,T>::setDirectionName(int direction,
                                 const char* directionName) {
    PAssert(direction==+1 || direction==-1);
    directions_m[directionName] = direction;
    return;
}

template <unsigned Dim, class T>
inline int
FFTBase<Dim,T>::getDirection(const char* directionName) const {
    return (*(directions_m.find(directionName))).second;
}

template <unsigned Dim, class T>
inline bool
FFTBase<Dim,T>::transformDim(unsigned d) const {
    PAssert(d<Dim);
    return transformDims_m[d];
}

template <unsigned Dim, class T>
inline unsigned
FFTBase<Dim,T>::activeDimension(unsigned d) const {
    PAssert(d<nTransformDims_m);
    return activeDims_m[d];
}

template <unsigned Dim, class T>
inline bool
FFTBase<Dim,T>::checkDomain(const FFTBase<Dim,T>::Domain_t& dom1,
                            const FFTBase<Dim,T>::Domain_t& dom2) const {
    // check whether domains are equivalent
    // we require that some permutation of the axes gives a matching domain.
    static bool matched[Dim];
    bool found;
    unsigned d, d1;
    // initialize matched array to false
    for (d=0; d<Dim; ++d) matched[d] = false;
    d=0;
    while (d<Dim) {
        d1=0;
        found = false;
        while (!found && d1<Dim) {
            // if we have not yet found a match for this dimension,
            // compare length and base of Index objects
            if (!matched[d1]) {
                found = ( dom1[d].length()==dom2[d1].length() &&
                          dom1[d].sameBase(dom2[d1]) );
                // if equivalent, mark this dimension as matched
                if (found) matched[d1] = true;
            }
            ++d1;
        }
        if (!found) return false;
        ++d;
    }
    return true;
}

#include "FFT/FFTBase.cpp"

#endif // IPPL_FFT_FFTBASE_H

/***************************************************************************
 * $RCSfile: FFTBase.h,v $   $Author: adelmann $
 * $Revision: 1.1.1.1 $   $Date: 2003/01/23 07:40:25 $
 * IPPL_VERSION_ID: $Id: FFTBase.h,v 1.1.1.1 2003/01/23 07:40:25 adelmann Exp $ 
 ***************************************************************************/

---