cuda/CField.h

#ifndef PRDC_CUDA_C_FIELD_H
#define PRDC_CUDA_C_FIELD_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 <pscf/cuda/cudaTypes.h>
#include <pscf/cuda/DeviceArray.h>
#include <pscf/cuda/HostDArray.h>
#include <pscf/math/IntVec.h>
#include <util/global.h>
 
namespace Pscf {
namespace Prdc {
namespace Cuda {
 
   using namespace Util;
   using namespace Pscf;

   template <int D>
   class CField : public DeviceArray<cudaComplex>
   {
   
   public:

      CField();

      CField(IntVec<D> const & meshDimensions);

      CField(CField const & other);

      virtual ~CField();

      CField<D>& operator = (CField<D> const & other);

      CField<D>& operator = (HostDArray<cudaComplex> const & other);

      void allocate(IntVec<D> const & meshDimensions);

      void associate(DeviceArray<cudaComplex>& arr, int beginId, 
                     IntVec<D> const & meshDimensions);

      IntVec<D> const & meshDimensions() const;

      template <class Archive>
      void serialize(Archive& ar, const unsigned int version);
 
   private:
 
      // Vector containing number of grid points in each dimension.
      IntVec<D> meshDimensions_;
 
      // Make private to prevent allocation without mesh dimensions.
      using DeviceArray<cudaComplex>::allocate;
 
      // Make private to prevent association without mesh dimensions.
      using DeviceArray<cudaComplex>::associate;
 
      // Make private to prevent assignment without mesh dimensions.
      using DeviceArray<cudaComplex>::operator=;
 
   };
 
   /*
   * Return mesh dimensions by constant reference.
   */
   template <int D>
   inline const IntVec<D>& CField<D>::meshDimensions() const
   {  return meshDimensions_; }
 
   /*
   * Serialize a Field to/from an Archive.
   */
   template <int D>
   template <class Archive>
   void CField<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()) {
         HostDArray<cudaComplex> tempData(capacity);
         tempData = this; // copy this object's data from device to host
         for (int i = 0; i < capacity_; ++i) {
            ar & tempData[i].x;
            ar & tempData[i].y;
         }
      }
      ar & meshDimensions_;
   }
 
   #ifndef PRDC_CUDA_C_FIELD_TPP
   extern template class CField<1>;
   extern template class CField<2>;
   extern template class CField<3>;
   #endif
 
}
}
}
#endif