cp/field/CFields.h

#ifndef PRDC_CL_C_FIELDS_H
#define PRDC_CL_C_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 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 CFields 
   {
 
   public:

      CFields();

      ~CFields();


      void setFieldIo(FIT const & fieldIo);

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

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


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

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


      DArray< CFT > & fields();

      DArray< CFT > const & fields() const;

      CFT & field(int monomerId);

      CFT const & field(int monomerId) const;


      bool isAllocated() const;

      bool hasData() const;

      void setHasData(bool hasData);

 
   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 written by the write functions.
      */
      UnitCell<D> const * writeUnitCellPtr_;
 
      /*
      * Pointer to an associated FIT (field IO) object.
      */
      FIT const * fieldIoPtr_;
 
      /*
      * Has memory been allocated for the fields? 
      */
      bool isAllocated_;
 
      /*
      * Does this container hold up-to-date field data? 
      */
      bool hasData_;
 
   };
 
   // Inline member functions
 
   // Get the array of all fields (const reference)
   template <int D, class CFT, class FIT> inline
   DArray< CFT > const & CFields<D,CFT,FIT>::fields() const
   {
      UTIL_ASSERT(isAllocated_);
      return fields_;
   }
 
   // Get the array of all fields (non-const reference)
   template <int D, class CFT, class FIT> inline
   DArray< CFT > & CFields<D,CFT,FIT>::fields() 
   {
      UTIL_ASSERT(isAllocated_);
      return fields_;
   }
 
   // Get a single field (const reference)
   template <int D, class CFT, class FIT> inline
   CFT const & CFields<D,CFT,FIT>::field(int id) const
   {
      UTIL_ASSERT(isAllocated_);
      return fields_[id];
   }
 
   // Get a single field (non-const reference)
   template <int D, class CFT, class FIT> inline
   CFT & CFields<D,CFT,FIT>::field(int id)
   {
      UTIL_ASSERT(isAllocated_);
      return fields_[id];
   }
 
   // Has memory been allocated for fields ?
   template <int D, class CFT, class FIT> inline 
   bool CFields<D,CFT,FIT>::isAllocated() const
   {  return isAllocated_; }
 
   // Is data up to date ?
   template <int D, class CFT, class FIT> inline 
   bool CFields<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 & 
   CFields<D,CFT,FIT>::meshDimensions() const
   {  return meshDimensions_; }
 
   // Get mesh size (number of grid points).
   template <int D, class CFT, class FIT> inline 
   int CFields<D,CFT,FIT>::meshSize() const
   {  return meshSize_; }
 
   // Get number of monomer types.
   template <int D, class CFT, class FIT> inline 
   int CFields<D,CFT,FIT>::nMonomer() const
   {  return nMonomer_; }
 
   // Get the associated the field Io (FIT) object (const reference).
   template <int D, class CFT, class FIT> inline 
   FIT const & CFields<D,CFT,FIT>::fieldIo() const
   {
      UTIL_CHECK(fieldIoPtr_);
      return *fieldIoPtr_;
   }
 
} // namespace Cp
} // namespace Pscf
#endif