cpu/RFieldDft.h

#ifndef PRDC_CPU_R_FIELD_DFT_H
#define PRDC_CPU_R_FIELD_DFT_H
 
/*
* PSCF Package 
*
* Copyright 2016 - 2022, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <prdc/cpu/FftwDArray.h>
#include <prdc/cpu/complex.h>
#include <pscf/math/IntVec.h>
#include <util/global.h>
 
#include <fftw3.h>
 
namespace Pscf {
namespace Prdc {
namespace Cpu {
 
   using namespace Util;
   using namespace Pscf;
 
   template <int D>
   class RFieldDft : public FftwDArray<fftw_complex>
   {
 
   public:
 
      // Typedefs
 
      typedef fftw_complex ElementType;
 
      typedef fftw_complex Complex;
 
      typedef double Real;
 
      // Member functions
 
      RFieldDft();
 
      RFieldDft(RFieldDft<D> const & other);
 
      virtual ~RFieldDft();
 
      RFieldDft<D>& operator = (RFieldDft<D> const & other);
 
      void allocate(IntVec<D> const & meshDimensions);
 
      virtual void deallocate();
 
      IntVec<D> const & meshDimensions() const;
 
      IntVec<D> const & dftDimensions() const;
 
      template <class Archive>
      void serialize(Archive& ar, const unsigned int version);
 
   private:
 
      // Vector containing number of grid points in each direction.
      IntVec<D> meshDimensions_;
 
      // Vector containing dimensions of dft (Fourier) grid.
      IntVec<D> dftDimensions_;
 
      using FftwDArray<fftw_complex>::allocate;
 
   };
 
   #if 0
   /*
   * Allocate the underlying C array for an FFT grid.
   */
   template <int D>
   void RFieldDft<D>::allocate(IntVec<D> const & meshDimensions)
   {
      int size = 1;
      for (int i = 0; i < D; ++i) {
         UTIL_CHECK(meshDimensions[i] > 0);
         meshDimensions_[i] = meshDimensions[i];
         if (i < D - 1) {
            dftDimensions_[i] = meshDimensions[i];
            size *= meshDimensions[i];
         } else {
            dftDimensions_[i] = (meshDimensions[i]/2 + 1);
            size *= dftDimensions_[i];
         }
      }
      FftwDArray<fftw_complex>::allocate(size);
   }
   #endif
 
   /*
   * Return mesh dimensions by constant reference.
   */
   template <int D>
   inline IntVec<D> const & RFieldDft<D>::meshDimensions() const
   {  return meshDimensions_; }
 
   /*
   * Return dimensions of dft grid by constant reference.
   */
   template <int D>
   inline IntVec<D> const & RFieldDft<D>::dftDimensions() const
   {  return dftDimensions_; }
 
   /*
   * Serialize a Field to/from an Archive.
   */
   template <int D>
   template <class Archive>
   void RFieldDft<D>::serialize(Archive& ar, const unsigned int version)
   {
      FftwDArray<fftw_complex>::serialize(ar, version);
      ar & meshDimensions_;
      ar & dftDimensions_;
   }
 
   #ifndef PRDC_R_FIELD_DFT_TPP
   extern template class RFieldDft<1>;
   extern template class RFieldDft<2>;
   extern template class RFieldDft<3>;
   #endif
 
}
}
}
#endif