field/Mask.h

#ifndef RP_MASK_H
#define RP_MASK_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 Rp {
 
   using namespace Util;
   using namespace Prdc;

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


      void setFieldIo(FIT const & fieldIo);

      void setReadUnitCell(UnitCell<D>& cell);

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

      void allocateBasis(int nBasis);

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


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

      void setRGrid(RFT const & field, 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 writeBasis(std::ostream& out) const;

      void writeBasis(std::string filename) const;

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

      void writeRGrid(std::string filename) const;


      DArray<double> const & basis() const;

      RFT const & rgrid() const;

      double phiTot() const;

      Signal<void>& signal();


      bool isAllocatedBasis() const;

      bool isAllocatedRGrid() const;

      bool hasData() const;

      bool isSymmetric() const;

 
   protected:

      Mask();

      ~Mask();

      IntVec<D> const & meshDimensions() const
      {  return meshDimensions_; }

      int meshSize() const
      {  return meshSize_; }

      int nBasis() const
      {  return nBasis_; }

      FIT const & fieldIo() const
      {
         UTIL_CHECK(fieldIoPtr_);
         return *fieldIoPtr_;
      }
 
   private:

      DArray<double> basis_;

      RFT rgrid_;

      IntVec<D> meshDimensions_;

      int meshSize_;

      int nBasis_;
 
      /*
      * Pointer to unit cell modified by read functions.
      */
      UnitCell<D> * readUnitCellPtr_;
 
      /*
      * Pointer to unit cell access by write functions.
      */
      UnitCell<D> const * writeUnitCellPtr_;

      FIT const * fieldIoPtr_;
 
      /*
      * Pointer to a Signal that is triggered by field modification.
      */
      Signal<void>* signalPtr_;

      bool isAllocatedBasis_;

      bool isAllocatedRGrid_;

      bool hasData_;

      bool isSymmetric_;
 
   };
 
   // Inline member functions
 
   // Get field in basis format (const)
   template <int D, class RFT, class FIT>
   inline DArray<double> const & Mask<D,RFT,FIT>::basis() const
   {
      UTIL_ASSERT(hasData_);
      UTIL_ASSERT(isSymmetric_);
      return basis_;
   }
 
   // Get field in r-grid format (const)
   template <int D, class RFT, class FIT>
   inline RFT const & Mask<D,RFT,FIT>::rgrid() const
   {
      UTIL_ASSERT(hasData_);
      return rgrid_;
   }
 
   // Has memory been allocated in basis format?
   template <int D, class RFT, class FIT>
   inline bool Mask<D,RFT,FIT>::isAllocatedBasis() const
   {  return isAllocatedBasis_; }
 
   // Has memory been allocated in rgrid format?
   template <int D, class RFT, class FIT>
   inline bool Mask<D,RFT,FIT>::isAllocatedRGrid() const
   {  return isAllocatedRGrid_; }
 
   // Have the field data been set?
   template <int D, class RFT, class FIT>
   inline bool Mask<D,RFT,FIT>::hasData() const
   {  return hasData_; }
 
   // Is the field symmetric under space group operations?
   template <int D, class RFT, class FIT>
   inline bool Mask<D,RFT,FIT>::isSymmetric() const
   {  return isSymmetric_; }
 
} // namespace Rp
} // namespace Pscf
#endif