DomainReal.h

#ifndef PRDC_DOMAIN_REAL_H
#define PRDC_DOMAIN_REAL_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/Basis.h>           // member
#include <prdc/crystal/SpaceGroup.h>      // member
#include <prdc/crystal/UnitCell.h>        // member
#include <pscf/mesh/Mesh.h>               // member
#include <string>                         // member (groupName)
 
// Forward declaration
namespace Util{
   class FileMaster;
   template <typename T> class Signal;
   template <> class Signal<void>;
}
 
namespace Pscf {
namespace Prdc {
 
   using namespace Util;
   using namespace Pscf::Prdc;

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

      DomainReal();

      ~DomainReal();


      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;

 
   private:
 
      // Private member variables

      Mesh<D> mesh_;

      UnitCell<D> unitCell_;

      SpaceGroup<D> group_;

      Basis<D> basis_;

      FFT fft_;

      WLT waveList_;

      FIT fieldIo_;

      typename UnitCell<D>::LatticeSystem lattice_;

      std::string groupName_;

      Signal<void>* signalPtr_;

      FileMaster* fileMasterPtr_;

      bool hasGroup_;

      bool isInitialized_;
 
      /*
      * Get FileMaster as const reference.
      */
      FileMaster const & fileMaster() const
      {
         UTIL_CHECK(fileMasterPtr_);
         return * fileMasterPtr_;
      }
 
      // Members of parent class with non-dependent names
      using ParamComposite::read;
      using ParamComposite::readOptional;
 
   };
 
   // Inline member functions
 
   // Get the UnitCell by non-const reference.
   template <int D, class FFT, class WLT, class FIT>
   inline UnitCell<D>& DomainReal<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 & DomainReal<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>& DomainReal<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 & DomainReal<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 & DomainReal<D,FFT,WLT,FIT>::group() const
   {  return group_; }
 
   // Get the Basis by non-const reference.
   template <int D, class FFT, class WLT, class FIT>
   inline Basis<D>& DomainReal<D,FFT,WLT,FIT>::basis()
   {  return basis_; }
 
   // Get the Basis by const reference.
   template <int D, class FFT, class WLT, class FIT>
   inline Basis<D> const & DomainReal<D,FFT,WLT,FIT>::basis() const
   {  return basis_; }
 
   // Get the FFT by non-const reference.
   template <int D, class FFT, class WLT, class FIT>
   inline FFT& DomainReal<D,FFT,WLT,FIT>::fft()
   {  return fft_; }
 
   // Get the FFT by const reference.
   template <int D, class FFT, class WLT, class FIT>
   inline FFT const & DomainReal<D,FFT,WLT,FIT>::fft() const
   {  return fft_; }
 
   // Get the WaveList by non-const reference.
   template <int D, class FFT, class WLT, class FIT>
   inline WLT& DomainReal<D,FFT,WLT,FIT>::waveList()
   {  return waveList_; }
 
   // Get the WaveList by const reference.
   template <int D, class FFT, class WLT, class FIT>
   inline WLT const & DomainReal<D,FFT,WLT,FIT>::waveList() const
   {  return waveList_; }
 
   // Get the FieldIo by const reference.
   template <int D, class FFT, class WLT, class FIT>
   inline FIT& DomainReal<D,FFT,WLT,FIT>::fieldIo()
   {  return fieldIo_; }
 
   // Get the FieldIo by const reference.
   template <int D, class FFT, class WLT, class FIT>
   inline FIT const & DomainReal<D,FFT,WLT,FIT>::fieldIo() const
   {  return fieldIo_; }
 
   // Get the lattice system enumeration value
   template <int D, class FFT, class WLT, class FIT>
   inline 
   typename UnitCell<D>::LatticeSystem DomainReal<D,FFT,WLT,FIT>::lattice() 
   const
   {  return lattice_; }
 
   // Get the groupName string.
   template <int D, class FFT, class WLT, class FIT>
   inline std::string DomainReal<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 DomainReal<D,FFT,WLT,FIT>::hasGroup() const
   {  return hasGroup_; }
 
   // Has a symmetry-adapted Fourier basis been initialized ?
   template <int D, class FFT, class WLT, class FIT>
   inline bool DomainReal<D,FFT,WLT,FIT>::hasBasis() const
   {  return basis_.isInitialized(); }
 
} // namespace Prdc
} // namespace Pscf
#endif