rp/field/Domain.h

#ifndef RP_DOMAIN_H
#define RP_DOMAIN_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/param/ParamComposite.h>    // base class
#include <prdc/crystal/UnitCell.h>        // member
#include <pscf/mesh/Mesh.h>               // member
#include <string>                         // member (groupName)
 
// Forward declarations
namespace Util {
   class FileMaster;
   template <typename T> class Signal;
   template <> class Signal<void>;
}
namespace Pscf {
   namespace Prdc {
      template <int D> class SpaceGroup;
      template <int D> class Basis;
   }
}
 
namespace Pscf {
namespace Rp {
 
   using namespace Util;
   using namespace Pscf::Prdc;

   template <int D, class FFT, class WLT, class FIT>
   class Domain : public ParamComposite
   {
 
   public:


      void setFileMaster(FileMaster& fileMaster);

      virtual void readParameters(std::istream& in);

      void readRGridFieldHeader(std::istream& in, int& nMonomer);

      void makeBasis();


      Mesh<D>& mesh();

      Mesh<D> const & mesh() const;

      UnitCell<D>& unitCell();

      UnitCell<D> const & unitCell() const;

      SpaceGroup<D> const & group() const ;

      Basis<D>& basis();

      Basis<D> const & basis() const;

      FFT& fft();

      FFT const & fft() const;

      WLT& waveList();

      WLT const & waveList() const;

      FIT& fieldIo();

      FIT const & fieldIo() const;


      typename UnitCell<D>::LatticeSystem lattice() const;

      std::string groupName() const;

      bool hasGroup() const;

      bool hasBasis() const;


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

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

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

 
   protected:

      Domain();

      ~Domain();
 
   private:
 
      // Private member variables

      Mesh<D> mesh_;

      UnitCell<D> unitCell_;

      typename UnitCell<D>::LatticeSystem lattice_;

      std::string groupName_;
 
      // Pointers to owned and associated objects.

      SpaceGroup<D>* groupPtr_;

      Basis<D>* basisPtr_;

      FFT* fftPtr_;

      WLT* waveListPtr_;

      FIT* fieldIoPtr_;

      Signal<void>* signalPtr_;

      FileMaster* fileMasterPtr_;
 
      // Boolean flags

      bool hasGroup_;

      bool isInitialized_;
 
      // Private member function
 
      /*
      * Get FileMaster as const reference.
      */
      FileMaster const & fileMaster() const;
 
   };
 
   // Public inline member functions
 
   // Get the UnitCell by non-const reference.
   template <int D, class FFT, class WLT, class FIT> inline 
   UnitCell<D>& Domain<D,FFT,WLT,FIT>::unitCell()
   {  return unitCell_; }
 
   // Get the UnitCell by const reference.
   template <int D, class FFT, class WLT, class FIT> inline 
   UnitCell<D> const & Domain<D,FFT,WLT,FIT>::unitCell() const
   {  return unitCell_; }
 
   // Get the Mesh by non-const reference.
   template <int D, class FFT, class WLT, class FIT> inline 
   Mesh<D>& Domain<D,FFT,WLT,FIT>::mesh()
   {  return mesh_; }
 
   // Get the Mesh by const reference.
   template <int D, class FFT, class WLT, class FIT> inline 
   Mesh<D> const & Domain<D,FFT,WLT,FIT>::mesh() const
   {  return mesh_; }
 
   // Get the SpaceGroup by const reference.
   template <int D, class FFT, class WLT, class FIT> inline 
   SpaceGroup<D> const & Domain<D,FFT,WLT,FIT>::group() const
   {  return *groupPtr_; }
 
   // Get the Basis by non-const reference.
   template <int D, class FFT, class WLT, class FIT> inline 
   Basis<D>& Domain<D,FFT,WLT,FIT>::basis()
   {  return *basisPtr_; }
 
   // Get the Basis by const reference.
   template <int D, class FFT, class WLT, class FIT> inline 
   Basis<D> const & Domain<D,FFT,WLT,FIT>::basis() const
   {  return *basisPtr_; }
 
   // Get the FFT by non-const reference.
   template <int D, class FFT, class WLT, class FIT> inline 
   FFT& Domain<D,FFT,WLT,FIT>::fft()
   {  return *fftPtr_; }
 
   // Get the FFT by const reference.
   template <int D, class FFT, class WLT, class FIT> inline 
   FFT const & Domain<D,FFT,WLT,FIT>::fft() const
   {  return *fftPtr_; }
 
   // Get the WaveList by non-const reference.
   template <int D, class FFT, class WLT, class FIT> inline 
   WLT& Domain<D,FFT,WLT,FIT>::waveList()
   {  return *waveListPtr_; }
 
   // Get the WaveList by const reference.
   template <int D, class FFT, class WLT, class FIT> inline 
   WLT const & Domain<D,FFT,WLT,FIT>::waveList() const
   {  return *waveListPtr_; }
 
   // Get the FieldIo by const reference.
   template <int D, class FFT, class WLT, class FIT> inline
   FIT& Domain<D,FFT,WLT,FIT>::fieldIo()
   {  return *fieldIoPtr_; }
 
   // Get the FieldIo by const reference.
   template <int D, class FFT, class WLT, class FIT> inline
   FIT const & Domain<D,FFT,WLT,FIT>::fieldIo() const
   {  return *fieldIoPtr_; }
 
   // Get the lattice type enumeration value.
   template <int D, class FFT, class WLT, class FIT> inline
   typename UnitCell<D>::LatticeSystem Domain<D,FFT,WLT,FIT>::lattice()
   const
   {  return lattice_; }
 
   // Get the groupName string identifier.
   template <int D, class FFT, class WLT, class FIT>
   inline std::string Domain<D,FFT,WLT,FIT>::groupName() const
   {  return groupName_; }
 
   // Has a space group been identified?
   template <int D, class FFT, class WLT, class FIT>
   inline bool Domain<D,FFT,WLT,FIT>::hasGroup() const
   {  return hasGroup_; }
 
   // Private inline member function
 
   // Get FileMaster as const reference.
   template <int D, class FFT, class WLT, class FIT> inline
   FileMaster const & Domain<D,FFT,WLT,FIT>::fileMaster() const
   {
      UTIL_CHECK(fileMasterPtr_);
      return * fileMasterPtr_;
   }
 
} // namespace Rp
} // namespace Pscf
#endif