FftwDArray.h

#ifndef PRDC_CPU_FFTW_D_ARRAY_H
#define PRDC_CPU_FFTW_D_ARRAY_H
 
/*
* PSCF - Polymer Self-Consistent Field 
*
* Copyright 2015 - 2025, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <util/containers/Array.h>
#include <util/global.h>
 
#include <fftw3.h>
 
namespace Pscf {
namespace Prdc {
namespace Cpu {
 
   using namespace Util;

   template <typename Data>
   class FftwDArray : public Array<Data>
   {
 
   public:

      using ValueType = Data;

      FftwDArray();

      virtual ~FftwDArray();

      void allocate(int capacity);

      virtual void deallocate();

      bool isAllocated() const;

      template <class Archive>
      void serialize(Archive& ar, const unsigned int version);
 
   protected:
 
       using Array<Data>:: data_;
       using Array<Data>:: capacity_;
 
   private:

      FftwDArray(FftwDArray<Data> const & other);

      FftwDArray<Data>& operator = (FftwDArray<Data> const & other);
 
   };
 
   /*
   * Return true if the FftwDArray has been allocated, false otherwise.
   */
   template <typename Data>
   inline bool FftwDArray<Data>::isAllocated() const
   {  return (bool) data_; }
 
   /*
   * Serialize a FftwDArray to/from an Archive.
   */
   template <typename Data>
   template <class Archive>
   void FftwDArray<Data>::serialize(Archive& ar, const unsigned int version)
   {
      int capacity;
      if (Archive::is_saving()) {
         capacity = capacity_;
      }
      ar & capacity;
      if (Archive::is_loading()) {
         if (!isAllocated()) {
            if (capacity > 0) {
               allocate(capacity);
            }
         } else {
            if (capacity != capacity_) {
               UTIL_THROW("Inconsistent FftwDArray capacities");
            }
         }
      }
      if (isAllocated()) {
         for (int i = 0; i < capacity_; ++i) {
            ar & data_[i];
         }
      }
   }
 
}
}
}
#include "FftwDArray.tpp"
#endif