rpc/field/Domain.h

#ifndef RPC_DOMAIN_H
#define RPC_DOMAIN_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 <util/param/ParamComposite.h>     // base class
 
#include <rpc/field/FieldIo.h>            // member
 
#include <prdc/cpu/FFT.h>                  // member
#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>
 
namespace Pscf {
namespace Rpc
{
 
   using namespace Util;
   using namespace Pscf::Prdc;
   using namespace Pscf::Prdc::Cpu;
 
   template <int D>
   class Domain : public ParamComposite
   {
 
   public:
 
 
      Domain();
 
      ~Domain();
 
 
      void setFileMaster(FileMaster& fileMaster);
 
      virtual void readParameters(std::istream& in);
 
      void readRGridFieldHeader(std::istream& in, int& nMonomer);
 
      void setUnitCell(UnitCell<D> const & unitCell);
 
      void setUnitCell(typename UnitCell<D>::LatticeSystem lattice,
                       FSArray<double, 6> const & parameters);
 
      void setUnitCell(FSArray<double, 6> const & parameters);
 
      void makeBasis();
 
 
      UnitCell<D>& unitCell();
 
      UnitCell<D> const & unitCell() const;
 
      Mesh<D>& mesh();
 
      Mesh<D> const & mesh() const;
 
      SpaceGroup<D> const & group() const ;
 
      Basis<D>& basis();
 
      Basis<D> const & basis() const ;
 
      FFT<D>& fft();
 
      FFT<D> const & fft() const;
 
      FieldIo<D>& fieldIo();
 
      FieldIo<D> const & fieldIo() const;
 
 
      typename UnitCell<D>::LatticeSystem lattice() const;
 
      std::string groupName() const;
 
      bool hasGroup() const;
 
      bool hasBasis() const;
 
 
   private:
 
      // Private member variables
 
      UnitCell<D> unitCell_;
 
      Mesh<D> mesh_;
 
      SpaceGroup<D> group_;
 
      Basis<D> basis_;
 
      FFT<D> fft_;
 
      FieldIo<D> fieldIo_;
 
      typename UnitCell<D>::LatticeSystem lattice_;
 
      std::string groupName_;
 
      bool hasGroup_;
 
      bool hasFileMaster_;
 
      bool isInitialized_;
 
      // members of parent class with non-dependent names
      using ParamComposite::read;
      using ParamComposite::readOptional;
 
   };
 
   // Inline member functions
 
   // Get the UnitCell<D> object by non-const reference.
   template <int D>
   inline UnitCell<D>& Domain<D>::unitCell()
   {  return unitCell_; }
 
   // Get the UnitCell<D> object by const reference.
   template <int D>
   inline UnitCell<D> const & Domain<D>::unitCell() const
   {  return unitCell_; }
 
   // Get the Mesh<D> object by reference.
   template <int D>
   inline Mesh<D>& Domain<D>::mesh()
   {  return mesh_; }
 
   // Get the Mesh<D> object by const reference.
   template <int D>
   inline Mesh<D> const & Domain<D>::mesh() const
   {  return mesh_; }
 
   // Get the SpaceGroup<D> object by const reference.
   template <int D>
   inline SpaceGroup<D> const & Domain<D>::group() const
   {  return group_; }
 
   // Get the Basis<D> object by non-const reference.
   template <int D>
   inline Basis<D>& Domain<D>::basis()
   {  return basis_; }
 
   // Get the Basis<D> object by const reference.
   template <int D>
   inline Basis<D> const & Domain<D>::basis() const
   {  return basis_; }
 
   // Get the FFT<D> object.
   template <int D>
   inline FFT<D>& Domain<D>::fft()
   {  return fft_; }
 
   // Get the FFT<D> object.
   template <int D>
   inline FFT<D> const & Domain<D>::fft() const
   {  return fft_; }
 
   // Get the FieldIo<D> object.
   template <int D>
   inline FieldIo<D>& Domain<D>::fieldIo()
   {  return fieldIo_; }
 
   // Get the FieldIo<D> object by const reference.
   template <int D>
   inline FieldIo<D> const & Domain<D>::fieldIo() const
   {  return fieldIo_; }
 
   // Get the lattice system enumeration value
   template <int D>
   inline 
   typename UnitCell<D>::LatticeSystem Domain<D>::lattice() 
   const
   {  return lattice_; }
 
   // Get the groupName string.
   template <int D>
   inline std::string Domain<D>::groupName() const
   {  return groupName_; }
 
   // Has a space group been identified?
   template <int D>
   inline bool Domain<D>::hasGroup() const
   {  return hasGroup_; }
 
   // Has a symmetry-adapted Fourier basis been initialized ?
   template <int D>
   inline bool Domain<D>::hasBasis() const
   {  return basis_.isInitialized(); }
 
   #ifndef RPC_DOMAIN_TPP
   // Suppress implicit instantiation
   extern template class Domain<1>;
   extern template class Domain<2>;
   extern template class Domain<3>;
   #endif
 
} // namespace Rpc
} // namespace Pscf
#endif