rpg/field/WFieldContainer.h

#ifndef RPG_W_FIELD_CONTAINER_H
#define RPG_W_FIELD_CONTAINER_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>              // member template parameter
#include <prdc/crystal/UnitCell.h>         // function parameter
#include <pscf/math/IntVec.h>              // function parameter
#include <pscf/cuda/DeviceArray.h>         // function parameter
#include <util/param/ParamComposite.h>     // base class
#include <util/containers/DArray.h>        // member template
 
namespace Pscf {
namespace Rpg {
 
   template <int D> class FieldIo;
 
   using namespace Util;
   using namespace Pscf::Prdc;
   using namespace Pscf::Prdc::Cuda;
 
   template <int D>
   class WFieldContainer : public ParamComposite
   {
 
   public:
 
      WFieldContainer();
 
      ~WFieldContainer();
 
      void setFieldIo(FieldIo<D> const & fieldIo);
 
      void setNMonomer(int nMonomer);
 
      void allocateRGrid(IntVec<D> const & dimensions);
 
      void deallocateRGrid();
 
      void allocateBasis(int nBasis);
 
      void deallocateBasis();
 
      void allocate(int nMonomer, int nBasis, IntVec<D> const & dimensions);
 
      void setBasis(DArray< DArray<double> > const & fields);
 
      void setRGrid(DArray< RField<D> > const & fields, 
                    bool isSymmetric = false);
 
      void setRGrid(DeviceArray<cudaReal> & fields);
 
      void readBasis(std::istream& in, UnitCell<D>& unitCell);
 
      void readBasis(std::string filename, UnitCell<D>& unitCell);
 
      void readRGrid(std::istream& in, UnitCell<D>& unitCell,
                     bool isSymmetric = false);
 
      void readRGrid(std::string filename, UnitCell<D>& unitCell,
                     bool isSymmetric = false);
 
      void symmetrize();
 
      DArray< DArray<double> > const & basis() const;
 
      DArray<double> const & basis(int monomerId) const;
 
      DArray< RField<D> > const & rgrid() const;
 
      RField<D> const & rgrid(int monomerId) const;
 
      bool isAllocatedRGrid() const;
 
      bool isAllocatedBasis() const;
 
      bool hasData() const;
 
      bool isSymmetric() const;
 
   private:
 
      /*
      * Array of fields in symmetry-adapted basis format
      *
      * Element basis_[i] is an array that contains the components
      * of the field associated with monomer i, in a symmetry-adapted
      * Fourier expansion. 
      */
      DArray< DArray<double> > basis_;
 
      /*
      * Array of fields in real-space grid (r-grid) format
      *
      * Element basis_[i] is an RField<D> that contains values of the 
      * field associated with monomer i on the nodes of a regular mesh.
      */
      DArray< RField<D> > rgrid_;
 
      /*
      * Pointer to associated FieldIo object
      */
      FieldIo<D> const * fieldIoPtr_;
 
      /*
      * Integer vector of grid dimensions.
      *
      * Element i is the number of grid points along direction i
      */
      IntVec<D> meshDimensions_;
 
      /*
      * Total number grid points (product of mesh dimensions)
      */
      int meshSize_;
 
      /*
      * Number of basis functions in symmetry-adapted basis
      */
      int nBasis_;
 
      /*
      * Number of monomer types (number of fields)
      */
      int nMonomer_;
 
      /*
      * Has memory been allocated for fields in r-grid format?
      */
      bool isAllocatedRGrid_;
 
      /*
      * Has memory been allocated for fields in basis format?
      */
      bool isAllocatedBasis_;
 
      /*
      * Has field data been initialized ?
      */
      bool hasData_;
 
      /*
      * Are the fields symmetric under space group operations?
      *
      * Set true when fields are set using the symmetry adapted basis
      * format via function setBasis. False by otherwise.
      */
      bool isSymmetric_;
 
   };
 
   // Inline member functions
 
   // Get array of all fields in basis format (const)
   template <int D>
   inline
   DArray< DArray<double> > const & WFieldContainer<D>::basis() const
   {  return basis_; }
 
   // Get one field in basis format (const)
   template <int D>
   inline
   DArray<double> const & WFieldContainer<D>::basis(int id) const
   {  return basis_[id]; }
 
   // Get all fields in r-grid format (const)
   template <int D>
   inline
   DArray< RField<D> > const &
   WFieldContainer<D>::rgrid() const
   {  return rgrid_; }
 
   // Get one field in r-grid format (const)
   template <int D>
   inline
   RField<D> const & WFieldContainer<D>::rgrid(int id) const
   {  return rgrid_[id]; }
 
   // Has memory been allocated for fields in r-grid format?
   template <int D>
   inline bool WFieldContainer<D>::isAllocatedRGrid() const
   {  return isAllocatedRGrid_; }
 
   // Has memory been allocated for fields in basis format?
   template <int D>
   inline bool WFieldContainer<D>::isAllocatedBasis() const
   {  return isAllocatedBasis_; }
 
   // Has field data been initialized ?
   template <int D>
   inline bool WFieldContainer<D>::hasData() const
   {  return hasData_; }
 
   // Are the fields symmetric under space group operations?
   template <int D>
   inline bool WFieldContainer<D>::isSymmetric() const
   {  return isSymmetric_; }
 
   #ifndef RPG_W_FIELD_CONTAINER_TPP
   // Suppress implicit instantiation
   extern template class WFieldContainer<1>;
   extern template class WFieldContainer<2>;
   extern template class WFieldContainer<3>;
   #endif
 
} // namespace Rpg
} // namespace Pscf
#endif