DomainTmpl.h

#ifndef PRDC_DOMAIN_TMPL_H
#define PRDC_DOMAIN_TMPL_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 Prdc {
 
   using namespace Util;
   using namespace Pscf::Prdc;

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

      DomainTmpl();

      ~DomainTmpl();


      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_;

      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
      {
         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>& DomainTmpl<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 & DomainTmpl<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>& DomainTmpl<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 & DomainTmpl<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 & DomainTmpl<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>& DomainTmpl<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 & DomainTmpl<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& DomainTmpl<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 & DomainTmpl<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& DomainTmpl<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 & DomainTmpl<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& DomainTmpl<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 & DomainTmpl<D,FFT,WLT,FIT>::fieldIo() const
   {  return *fieldIoPtr_; }
 
   // Get the lattice system enumeration value.
   template <int D, class FFT, class WLT, class FIT>
   inline
   typename UnitCell<D>::LatticeSystem DomainTmpl<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 DomainTmpl<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 DomainTmpl<D,FFT,WLT,FIT>::hasGroup() const
   {  return hasGroup_; }
 
} // namespace Prdc
} // namespace Pscf
#endif