WaveList.h

#ifndef RPG_WAVE_LIST_H
#define RPG_WAVE_LIST_H
/*
* PSCF - Polymer Self-Consistent Field Theory
*
* Copyright 2016 - 2022, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <prdc/cuda/RField.h>
#include <prdc/crystal/UnitCell.h>
 
#include <pscf/mesh/Mesh.h>
#include <pscf/math/IntVec.h>
#include <pscf/cuda/DeviceArray.h> 
 
#include <util/containers/DArray.h>
 
namespace Pscf {
namespace Rpg {
 
   using namespace Util;
   using namespace Pscf::Prdc;
   using namespace Pscf::Prdc::Cuda;
 
   template <int D>
   class WaveList
   {
   public:
 
      WaveList();
 
      ~WaveList();
 
      void allocate(Mesh<D> const & m, UnitCell<D> const & c);
 
      void clearUnitCellData();
 
      void computeMinimumImages();
 
      void computeKSq();
 
      void computedKSq();
 
      DeviceArray<int> const & minImages() const;
 
      RField<D> const & kSq() const;
 
      DeviceArray<cudaReal> const & dKSq() const;
 
      RField<D> const & dKSq(int i) const;
 
      DeviceArray<bool> const & implicitInverse() const;
 
      bool hasVariableAngle() const;
 
      bool isAllocated() const
      {  return isAllocated_; }
 
      bool hasMinimumImages() const
      {  return hasMinimumImages_; }
 
      bool hasKSq() const
      {  return hasKSq_; }
 
      bool hasdKSq() const
      {  return hasdKSq_; }
 
   private:
 
      DeviceArray<int> minImages_;
 
      RField<D> kSq_;
 
      DeviceArray<cudaReal> dKSq_;
 
      DArray<RField<D> > dKSqSlices_;
 
      DeviceArray<bool> implicitInverse_;
 
      IntVec<D> kMeshDimensions_;
 
      int kSize_;
 
      bool isAllocated_;
 
      bool hasMinimumImages_;
 
      bool hasKSq_;
 
      bool hasdKSq_;
 
      UnitCell<D> const * unitCellPtr_;
 
      Mesh<D> const * meshPtr_;
 
      UnitCell<D> const & unitCell() const
      {  return *unitCellPtr_; }
 
      Mesh<D> const & mesh() const
      {  return *meshPtr_; }
 
   };
 
   // Get the array of minimum images on the device by reference.
   template <int D>
   inline DeviceArray<int> const & WaveList<D>::minImages() const
   {  
      UTIL_CHECK(hasMinimumImages_);
      return minImages_; 
   }
   
   // Get the kSq array on the device by reference.
   template <int D>
   inline RField<D> const & WaveList<D>::kSq() const
   {  
      UTIL_CHECK(hasKSq_);
      return kSq_; 
   }
 
   // Get the full dKSq array on the device by reference.
   template <int D>
   inline DeviceArray<cudaReal> const & WaveList<D>::dKSq() const
   {  
      UTIL_CHECK(hasdKSq_);
      return dKSq_; 
   }
 
   // Get a slice of the dKSq array on the device by reference.
   template <int D>
   inline RField<D> const & WaveList<D>::dKSq(int i) const
   {  
      UTIL_CHECK(hasdKSq_);
      return dKSqSlices_[i];
   }
 
   // Get the implicitInverse array by reference.
   template <int D>
   inline DeviceArray<bool> const & WaveList<D>::implicitInverse() const
   {  
      UTIL_CHECK(isAllocated_);
      return implicitInverse_;
   }
 
   #ifndef RPG_WAVE_LIST_TPP
   // Suppress implicit instantiation
   extern template class WaveList<1>;
   extern template class WaveList<2>;
   extern template class WaveList<3>;
   #endif
 
}
}
//#include "WaveList.tpp"
#endif