RDField.h

#ifndef PSPG_R_DFIELD_H
#define PSPG_R_DFIELD_H
 
/*
* PSCF Package 
*
* Copyright 2016 - 2022, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include "DField.h"
#include <pscf/math/IntVec.h>
#include <util/global.h>
#include <pspg/math/GpuResources.h>
 
#include <cufft.h>
 
namespace Pscf {
namespace Pspg
{
 
   using namespace Util;
   using namespace Pscf;
 
   template <int D>
   class RDField : public DField<cudaReal>
   {
 
   public:
 
      RDField();
 
      RDField(const RDField& other);
 
      virtual ~RDField();
 
      RDField& operator = (const RDField& other);
 
      void allocate(const IntVec<D>& meshDimensions);
 
      const IntVec<D>& meshDimensions() const;
 
      template <class Archive>
      void serialize(Archive& ar, const unsigned int version);
 
      using DField<cudaReal>::allocate;
      using DField<cudaReal>::operator=;
 
   private:
 
      // Vector containing number of grid points in each direction.
      IntVec<D> meshDimensions_;
 
   };
 
   /*
   * Allocate the underlying C array for an FFT grid.
   */
   template <int D>
   void RDField<D>::allocate(const IntVec<D>& meshDimensions)
   {
      int size = 1;
      for (int i = 0; i < D; ++i) {
         UTIL_CHECK(meshDimensions[i] > 0);
         meshDimensions_[i] = meshDimensions[i];
         size *= meshDimensions[i];
      }
      DField<cudaReal>::allocate(size);
   }
 
   /*
   * Return mesh dimensions by constant reference.
   */
   template <int D>
   inline const IntVec<D>& RDField<D>::meshDimensions() const
   {  return meshDimensions_; }
 
   /*
   * Serialize a Field to/from an Archive.
   */
   template <int D>
   template <class Archive>
   void RDField<D>::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 Field capacities");
            }
         }
      }
 
      if (isAllocated()) {
         double* tempData = new double[capacity];
         cudaMemcpy(tempData, data_, capacity * sizeof(cudaReal), 
                    cudaMemcpyDeviceToHost);
         for (int i = 0; i < capacity_; ++i) {
            ar & tempData[i];
         }
         delete[] tempData;
      }
      ar & meshDimensions_;
   }
 
      
 
 
 
}
}
#include "RDField.tpp"
#endif