WFieldsReal.h

#ifndef PRDC_W_FIELDS_REAL_H
#define PRDC_W_FIELDS_REAL_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/math/IntVec.h>              // member
#include <util/containers/DArray.h>        // member template
 
// Forward declarations
namespace Util {
   template <typename T> class Signal;
   template <> class Signal<void>;
}
namespace Pscf {
   namespace Prdc {
      template <int D> class UnitCell;
   }
}
 
namespace Pscf {
namespace Prdc {
 
 
   using namespace Util;

   template <int D, class RFT, class FIT>
   class WFieldsReal 
   {
 
   public:

      WFieldsReal();

      ~WFieldsReal();


      void setFieldIo(FIT const & fieldIo);

      void setReadUnitCell(UnitCell<D>& cell);

      void setWriteUnitCell(UnitCell<D> const & cell);

      void setNMonomer(int nMonomer);

      void allocateRGrid(IntVec<D> const & dimensions);

      void allocateBasis(int nBasis);

      void allocate(int nMonomer, int nBasis, IntVec<D> const & dimensions);


      void setBasis(DArray< DArray<double> > const & fields);

      void setRGrid(DArray< RFT > const & fields,
                    bool isSymmetric = false);

      void readBasis(std::istream& in);

      void readBasis(std::string filename);

      void readRGrid(std::istream& in, bool isSymmetric = false);

      void readRGrid(std::string filename, bool isSymmetric = false);

      void symmetrize();

      void clear();

      Signal<void>& signal();


      void writeBasis(std::ostream& out) const;

      void writeBasis(std::string filename) const;

      void writeRGrid(std::ostream& out) const;

      void writeRGrid(std::string filename) const;


      DArray< DArray<double> > const & basis() const;

      DArray<double> const & basis(int monomerId) const;

      DArray< RFT > const & rgrid() const;

      RFT const & rgrid(int monomerId) const;


      bool isAllocatedRGrid() const;

      bool isAllocatedBasis() const;

      bool hasData() const;

      bool isSymmetric() const;

 
   protected:

      IntVec<D> const & meshDimensions() const;

      int meshSize() const;

      int nBasis() const;

      int nMonomer() const;

      FIT const & fieldIo() 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 RFT that contains values of the
      * field associated with monomer i on the nodes of a regular mesh.
      */
      DArray< RFT > rgrid_;
 
      /*
      * 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_;
 
      /*
      * Pointer to unit cell modified by read functions.
      */
      UnitCell<D> * readUnitCellPtr_;
 
      /*
      * Pointer to unit cell access by write functions.
      */
      UnitCell<D> const * writeUnitCellPtr_;
 
      /*
      * Pointer to an associated FIT object.
      */
      FIT const * fieldIoPtr_;
 
      /*
      * Pointer to a Signal that is triggered by field modification.
      *
      * The Signal is constructed and owned by this field container.
      */
      Signal<void>* signalPtr_;
 
      /*
      * 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_;
 
      /*
      *  Assign one RFT to another: lhs = rhs.
      *  
      *  \param lhs  left hand side of assignment
      *  \param rhs  right hand side of assignment
      */
      virtual void assignRField(RFT& lhs, RFT const & rhs) const;
 
   };
 
   // Inline member functions
 
   // Clear data stored in this object without deallocating
   template <int D, class RField, class FieldIo>
   inline void WFieldsReal<D,RField,FieldIo>::clear()
   {  hasData_ = false; }
 
   // Get array of all fields in basis format (const)
   template <int D, class RFT, class FIT>
   inline
   DArray< DArray<double> > const & 
   WFieldsReal<D,RFT,FIT>::basis() const
   {
      UTIL_ASSERT(isAllocatedBasis_);
      return basis_;
   }
 
   // Get one field in basis format (const)
   template <int D, class RFT, class FIT>
   inline
   DArray<double> const & WFieldsReal<D,RFT,FIT>::basis(int id)
   const
   {
      UTIL_ASSERT(isAllocatedBasis_);
      return basis_[id];
   }
 
   // Get all fields in r-grid format (const)
   template <int D, class RFT, class FIT>
   inline
   DArray< RFT > const &
   WFieldsReal<D,RFT,FIT>::rgrid() const
   {
      UTIL_ASSERT(isAllocatedRGrid_);
      return rgrid_;
   }
 
   // Get one field in r-grid format (const)
   template <int D, class RFT, class FIT>
   inline
   RFT const & WFieldsReal<D,RFT,FIT>::rgrid(int id) const
   {
      UTIL_ASSERT(isAllocatedRGrid_);
      return rgrid_[id];
   }
 
   // Has memory been allocated for fields in r-grid format?
   template <int D, class RFT, class FIT>
   inline 
   bool WFieldsReal<D,RFT,FIT>::isAllocatedRGrid() const
   {  return isAllocatedRGrid_; }
 
   // Has memory been allocated for fields in basis format?
   template <int D, class RFT, class FIT>
   inline 
   bool WFieldsReal<D,RFT,FIT>::isAllocatedBasis() const
   {  return isAllocatedBasis_; }
 
   // Has field data been initialized ?
   template <int D, class RFT, class FIT>
   inline 
   bool WFieldsReal<D,RFT,FIT>::hasData() const
   {  return hasData_; }
 
   // Are the fields symmetric under space group operations?
   template <int D, class RFT, class FIT>
   inline 
   bool WFieldsReal<D,RFT,FIT>::isSymmetric() const
   {  return isSymmetric_; }
 
   // Protected inline member functions
   
   // Get mesh dimensions in each direction, set on r-grid allocation.
   template <int D, class RFT, class FIT>
   inline 
   IntVec<D> const & 
   WFieldsReal<D,RFT,FIT>::meshDimensions() const
   {  return meshDimensions_; }
 
   // Get mesh size (number of grid points), set on r-grid allocation.
   template <int D, class RFT, class FIT>
   inline 
   int WFieldsReal<D,RFT,FIT>::meshSize() const
   {  return meshSize_; }
 
   // Get number of basis functions, set on basis allocation.
   template <int D, class RFT, class FIT>
   inline 
   int WFieldsReal<D,RFT,FIT>::nBasis() const
   {  return nBasis_; }
 
   // Get number of monomer types.
   template <int D, class RFT, class FIT>
   inline 
   int WFieldsReal<D,RFT,FIT>::nMonomer() const
   {  return nMonomer_; }
 
   // Associated FieldIo object (const reference).
   template <int D, class RFT, class FIT>
   inline 
   FIT const & WFieldsReal<D,RFT,FIT>::fieldIo() const
   {
      UTIL_CHECK(fieldIoPtr_);
      return *fieldIoPtr_;
   }
 
} // namespace Prdc
} // namespace Pscf
#endif