FFTBase.h

Go to the documentation of this file.

//
// IPPL FFT
//
// Copyright (c) 2008-2018
// Paul Scherrer Institut, Villigen PSI, Switzerland
// All rights reserved.
//
// OPAL is licensed under GNU GPL version 3.
//
 
//--------------------------------------------------------------------------
// 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"
 
#include "FFT/fftpack_FFT.h"
 
#include <map>
#include <iostream>
 
// forward declarations
template <unsigned Dim, class T> class FFTBase;
template <unsigned Dim, class T>
std::ostream& operator<<(std::ostream&, const FFTBase<Dim,T>&);

inline 
std::string getTransformType(unsigned int i) 
{
    static const char* transformTypeString_g[4] = { "complex-to-complex FFT",
                                                    "real-to-complex FFT",
                                                    "sine transform",
                                                    "cosine transform" };
 
    return std::string(transformTypeString_g[i % 4]);
}

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, cosineFFT };
 
    // Type used for performing 1D FFTs
    typedef FFTPACK<T> InternalFFT_t;
 
    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(std::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: 

    std::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 std::ostream&
operator<<(std::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_EQ(std::abs(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_LT(d, Dim);
    return transformDims_m[d];
}

template <unsigned Dim, class T>
inline unsigned
FFTBase<Dim,T>::activeDimension(unsigned d) const {
    PAssert_LT(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.hpp"
 
#endif // IPPL_FFT_FFTBASE_H