cp/field/WFields.h

#ifndef PRDC_CL_W_FIELDS_H
#define PRDC_CL_W_FIELDS_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 <util/containers/DArray.h>      // member template
#include <pscf/math/IntVec.h>            // member
 
// 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 Cp {
 
   using namespace Util;
   using namespace Prdc;

   template <int D, class CFT, class FIT>
   class WFields 
   {
 
   public:

      WFields();

      ~WFields();


      void setFieldIo(FIT const & fieldIo);

      void setReadUnitCell(UnitCell<D>& cell);

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

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


      void setFields(DArray< CFT > const & fields);

      void readFields(std::istream& in);

      void readFields(std::string const & filename);

      void clear();

      Signal<void>& signal();


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

      void writeFields(std::string const & filename) const;


      DArray< CFT > const & fields() const;

      CFT const & field(int monomerId) const;


      bool isAllocated() const;

      bool hasData() const;

 
   protected:

      IntVec<D> const & meshDimensions() const;

      int meshSize() const;

      int nMonomer() const;

      FIT const & fieldIo() const;
 
   private:
 
      /*
      * Array of complex valued fields.
      *
      * Element fields_[i] is a CFT (complex field type) object that 
      * contains values of the field associated with monomer i on the 
      * nodes of a regular mesh.
      */
      DArray< CFT > fields_;
 
      /*
      * 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 all mesh dimensions).
      */
      int meshSize_;
 
      /*
      * Number of monomer types (number of fields).
      */
      int nMonomer_;
 
      /*
      * Pointer to unit cell modified by the read functions.
      */
      UnitCell<D> * readUnitCellPtr_;
 
      /*
      * Pointer to unit cell written by the write functions.
      */
      UnitCell<D> const * writeUnitCellPtr_;
 
      /*
      * Pointer to an associated FIT (i.e., FieldIo<D>) object.
      */
      FIT const * fieldIoPtr_;
 
      /*
      * Pointer to a Signal that is triggered by field modification.
      *
      * The Signal is constructed and owned by this container.
      */
      Signal<void>* signalPtr_;
 
      /*
      * Has memory been allocated for the fields? 
      */
      bool isAllocated_;
 
      /*
      * Has field data been set since it was last cleared?
      */
      bool hasData_;
 
      /*
      *  Assign one complex field (CFT) to another: lhs = rhs.
      *  
      *  \param lhs  left hand side of assignment
      *  \param rhs  right hand side of assignment
      */
      virtual void assignField(CFT& lhs, CFT const & rhs) const;
 
   };
 
   // Inline member functions
 
   // Mark field data stored in this object as invalid or outdated.
   template <int D, class CFT, class FIT> inline 
   void WFields<D,CFT,FIT>::clear()
   {  hasData_ = false; }
 
   // Get the array of all fields (const reference).
   template <int D, class CFT, class FIT> inline
   DArray< CFT > const & WFields<D,CFT,FIT>::fields() const
   {
      UTIL_ASSERT(isAllocated_);
      return fields_;
   }
 
   // Get a single field (const reference).
   template <int D, class CFT, class FIT> inline
   CFT const & WFields<D,CFT,FIT>::field(int id) const
   {
      UTIL_ASSERT(isAllocated_);
      return fields_[id];
   }
 
   // Has memory been allocated for fields ?
   template <int D, class CFT, class FIT> inline 
   bool WFields<D,CFT,FIT>::isAllocated() const
   {  return isAllocated_; }
 
   // Has field data been initialized ?
   template <int D, class CFT, class FIT> inline 
   bool WFields<D,CFT,FIT>::hasData() const
   {  return hasData_; }
 
   // Protected inline member functions
   
   // Get mesh dimensions in each direction.
   template <int D, class CFT, class FIT> inline 
   IntVec<D> const & 
   WFields<D,CFT,FIT>::meshDimensions() const
   {  return meshDimensions_; }
 
   // Get mesh size (number of grid points).
   template <int D, class CFT, class FIT> inline 
   int WFields<D,CFT,FIT>::meshSize() const
   {  return meshSize_; }
 
   // Get number of monomer types.
   template <int D, class CFT, class FIT> inline 
   int WFields<D,CFT,FIT>::nMonomer() const
   {  return nMonomer_; }
 
   // Get the associated FIT (FieldIo<D>) object (const reference).
   template <int D, class CFT, class FIT> inline 
   FIT const & WFields<D,CFT,FIT>::fieldIo() const
   {
      UTIL_CHECK(fieldIoPtr_);
      return *fieldIoPtr_;
   }
 
} // namespace Cp
} // namespace Pscf
#endif