rpg/field/FieldIo.h

#ifndef RPG_FIELD_IO_H
#define RPG_FIELD_IO_H
 
/*
* PSCF - Polymer Self-Consistent Field Theory
*
* Copyright 2016 - 2025, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <prdc/field/FieldIoReal.h>     // base class template
#include <prdc/cuda/RField.h>           // template parameter
#include <prdc/cuda/RFieldDft.h>        // template parameter
#include <prdc/cuda/FFT.h>              // template parameter
 
// Forward declarations for classes used only via references or pointers
namespace Util {
   class FileMaster;
   template <typename T> class DArray;
}
namespace Pscf {
   namespace Prdc {
      template <int D> class UnitCell;
   }
}
 
namespace Pscf {
namespace Rpg {
 
   using namespace Util;
   using namespace Pscf::Prdc;
   using namespace Pscf::Prdc::Cuda;
 
   template <int D>
   class FieldIo 
     : public  FieldIoReal< D, RField<D>, RFieldDft<D>, FFT<D> >
   {
 
   public:
 
      typedef FieldIoReal<D, RField<D>, RFieldDft<D>, FFT<D> > Base;
 
      // Inherited public member functions
      using Base::associate;
      using Base::setFileMaster;
      using Base::readFieldsBasis;
      using Base::readFieldBasis;
      using Base::writeFieldBasis;
      using Base::writeFieldsBasis;
      using Base::readFieldsRGrid;
      using Base::readFieldsRGridData;
      using Base::readFieldRGrid;
      using Base::writeFieldsRGrid;
      using Base::writeFieldRGrid;
      using Base::readFieldsKGrid;
      using Base::writeFieldsKGrid;
      using Base::convertBasisToKGrid;
      using Base::convertKGridToBasis;
      using Base::convertBasisToRGrid;
      using Base::convertRGridToBasis;
      using Base::convertKGridToRGrid;
      using Base::convertRGridToKGrid;
      using Base::hasSymmetry;
      using Base::scaleFieldsBasis;
      using Base::scaleFieldsRGrid;
      using Base::replicateUnitCell;
      using Base::expandRGridDimension;
      using Base::readFieldHeader;
      using Base::writeFieldHeader;
 
      FieldIo();
 
      ~FieldIo();
 
      void readFieldsRGrid(std::istream& in,
                           DArray< RField<D> >& fields,
                           UnitCell<D> & unitCell) const;
 
      void readFieldsRGridData(std::istream& in,
                               DArray< RField<D> >& fields,
                               int nMonomer) const;
 
      void readFieldRGrid(std::istream &in,
                           RField<D> & field,
                           UnitCell<D>& unitCell) const;
 
      void writeFieldsRGrid(std::ostream& out,
                            DArray< RField<D> > const & fields,
                            UnitCell<D> const & unitCell,
                            bool writeHeader = true,
                            bool isSymmetric = true,
                            bool writeMeshSize = true) const;
 
      void writeFieldRGrid(std::ostream &out,
                           RField<D> const & field,
                           UnitCell<D> const & unitCell,
                           bool writeHeader = true,
                           bool isSymmetric = true) const;
 
      void readFieldsKGrid(std::istream& in,
                           DArray< RFieldDft<D> >& fields,
                           UnitCell<D> & unitCell) const;
 
      void writeFieldsKGrid(std::ostream& out,
                            DArray< RFieldDft<D> > const & fields,
                            UnitCell<D> const & unitCell,
                            bool isSymmetric = true) const;
 
      void convertBasisToKGrid(DArray<double> const & components,
                               RFieldDft<D>& dft) const;
 
      void convertKGridToBasis(RFieldDft<D> const & in,
                               DArray<double> & out,
                               bool checkSymmetry = true,
                               double epsilon = 1.0e-8) const;
 
      bool hasSymmetry(RFieldDft<D> const & in, 
                       double epsilon = 1.0e-8,
                       bool verbose = true) const;
 
      void scaleFieldBasis(DArray<double>& field, double factor) const;
 
      void scaleFieldRGrid(RField<D>& field, double factor) const;
      
      void expandRGridDimension(
                          std::ostream &out,
                          DArray<RField<D> > const & fields,
                          UnitCell<D> const & unitCell,
                          int d,
                          DArray<int> const& newGridDimensions) const;
 
      void replicateUnitCell(
                          std::ostream& out,
                          DArray< RField<D> > const & fields,
                          UnitCell<D> const & unitCell,
                          IntVec<D> const & replicas) const;
 
   protected:
 
      using Base::mesh;
      using Base::fft;
      using Base::lattice;
      using Base::hasGroup;
      using Base::groupName;
      using Base::group;
      using Base::basis;
      using Base::fileMaster;
 
   };
 
   #ifndef RPG_FIELD_IO_TPP
   extern template class FieldIo<1>;
   extern template class FieldIo<2>;
   extern template class FieldIo<3>;
   #endif
 
} // namespace Rpg
 
#ifndef RPG_FIELD_IO_TPP
namespace Prdc {
   using namespace Pscf::Prdc::Cuda;
   extern template class FieldIoReal<1, RField<1>, RFieldDft<1>, FFT<1>>;
   extern template class FieldIoReal<2, RField<2>, RFieldDft<2>, FFT<2>>;
   extern template class FieldIoReal<3, RField<3>, RFieldDft<3>, FFT<3>>;
} 
#endif
 
} // namespace Pscf
#endif