MaskTmpl.h

#ifndef PRDC_MASK_TMPL_H
#define PRDC_MASK_TMPL_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/crystal/UnitCell.h>         // function parameter
#include <pscf/math/IntVec.h>              // function parameter
#include <util/containers/DArray.h>        // member template
#include <util/param/ParamComposite.h>     // base class
 
namespace Pscf {
namespace Prdc {
 
   using namespace Util;
 
   template <int D, typename FieldIo, typename RField>
   class MaskTmpl : public ParamComposite
   {
 
   public:
 
      MaskTmpl();
 
      ~MaskTmpl();
 
 
      void setFieldIo(FieldIo const & fieldIo);
 
      void allocateBasis(int nBasis);
 
      void allocateRGrid(IntVec<D> const & dimensions);
 
 
      void setBasis(DArray<double> const & field);
 
      void setRGrid(RField const & field, bool isSymmetric = false);
 
      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);
 
 
      DArray<double> const & basis() const;
 
      RField const & rgrid() const;
 
      double phiTot() const;
 
 
      bool isAllocatedBasis() const;
 
      bool isAllocatedRGrid() const;
 
      bool hasData() const;
 
      bool isSymmetric() const;
 
 
   protected:
 
      virtual double rGridAverage() const = 0;
 
   private:
 
      DArray<double> basis_;
 
      RField rgrid_;
 
      FieldIo const * fieldIoPtr_;
 
      IntVec<D> meshDimensions_;
 
      int meshSize_;
 
      int nBasis_;
 
      int nMonomer_;
 
      bool isAllocatedBasis_;
 
      bool isAllocatedRGrid_;
 
      bool hasData_;
 
      bool isSymmetric_;
 
   };
 
   // Inline member functions
 
   // Get field in basis format (const)
   template <int D, typename FieldIo, typename RField>
   inline DArray<double> const & MaskTmpl<D, FieldIo, RField>::basis() const
   {
      UTIL_ASSERT(hasData_);
      UTIL_ASSERT(isSymmetric_);
      return basis_;
   }
 
   // Get field in r-grid format (const)
   template <int D, typename FieldIo, typename RField>
   inline RField const & MaskTmpl<D, FieldIo, RField>::rgrid() const
   {
      UTIL_ASSERT(hasData_);
      return rgrid_;
   }
 
   // Has memory been allocated in basis format?
   template <int D, typename FieldIo, typename RField>
   inline bool MaskTmpl<D, FieldIo, RField>::isAllocatedBasis() const
   {  return isAllocatedBasis_; }
 
   // Has memory been allocated in rgrid format?
   template <int D, typename FieldIo, typename RField>
   inline bool MaskTmpl<D, FieldIo, RField>::isAllocatedRGrid() const
   {  return isAllocatedRGrid_; }
 
   // Have the field data been set?
   template <int D, typename FieldIo, typename RField>
   inline bool MaskTmpl<D, FieldIo, RField>::hasData() const
   {  return hasData_; }
 
   // Is the field symmetric under space group operations?
   template <int D, typename FieldIo, typename RField>
   inline bool MaskTmpl<D, FieldIo, RField>::isSymmetric() const
   {  return isSymmetric_; }
 
} // namespace Prdc
} // namespace Pscf
#endif