rpc/field/FieldIo.h

#ifndef RPC_FIELD_IO_H
#define RPC_FIELD_IO_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 <rp/field/FieldIo.h>      // base class template
#include <prdc/cpu/RField.h>       // base class template argument
#include <prdc/cpu/RFieldDft.h>    // base class template argument
#include <prdc/cpu/FFT.h>          // base class template argument
 
// Forward declarations 
namespace Util {
   class FileMaster;
   template <typename T> class DArray;
}
namespace Pscf {
   namespace Prdc {
      template <int D> class UnitCell;
   }
}
 
namespace Pscf {
namespace Rpc {
 
   using namespace Util;
   using namespace Prdc;
   using namespace Prdc::Cpu;

   template <int D>
   class FieldIo 
     : public  Rp::FieldIo< D, RField<D>, RFieldDft<D>, FFT<D> >
   {
 
   public:
 
      FieldIo() = default;
      virtual ~FieldIo() = default;

      bool readFieldsRGrid(std::istream& in,
                           DArray< RField<D> >& fields,
                           UnitCell<D> & unitCell) const override;

      void readFieldsRGridData(std::istream& in,
                               DArray< RField<D> >& fields,
                               int nMonomer) const override;

      bool readFieldRGrid(std::istream &in,
                          RField<D> & field,
                          UnitCell<D>& unitCell) const override;

      void writeFieldsRGrid(std::ostream& out,
                            DArray< RField<D> > const & fields,
                            UnitCell<D> const & unitCell,
                            bool writeHeader = true,
                            bool isSymmetric = true,
                            bool writeMeshSize = true) const override;

      void writeFieldRGrid(std::ostream &out,
                           RField<D> const & field,
                           UnitCell<D> const & unitCell,
                           bool writeHeader = true,
                           bool isSymmetric = true) 
      const override;

      void readFieldsKGrid(std::istream& in,
                           DArray< RFieldDft<D> >& fields,
                           UnitCell<D> & unitCell) 
      const override;

      void writeFieldsKGrid(std::ostream& out,
                            DArray< RFieldDft<D> > const & fields,
                            UnitCell<D> const & unitCell,
                            bool isSymmetric = true) 
      const override;

      void convertBasisToKGrid(DArray<double> const & components,
                               RFieldDft<D>& dft) 
      const override;

      void convertKGridToBasis(RFieldDft<D> const & in,
                               DArray<double> & out,
                               bool checkSymmetry = true,
                               double epsilon = 1.0e-8) 
      const override;

      bool hasSymmetry(RFieldDft<D> const & in, 
                       double epsilon = 1.0e-8,
                       bool verbose = true) 
      const override;

      void compareFieldsRGrid(DArray< RField<D> > const & field1,
                              DArray< RField<D> > const & field2) 
      const override;

      void scaleFieldRGrid(RField<D>& field, double factor) 
      const override;

      void expandRGridDimension(
                          std::ostream &out,
                          DArray<RField<D> > const & fields,
                          UnitCell<D> const & unitCell,
                          int d,
                          DArray<int> const& newGridDimensions) 
      const override;
 
      void replicateUnitCell(
                          std::ostream& out,
                          DArray< RField<D> > const & fields,
                          UnitCell<D> const & unitCell,
                          IntVec<D> const & replicas) 
      const override;

      typedef Rp::FieldIo<D, RField<D>, RFieldDft<D>, FFT<D> > Base;
 
      // Inherited public member functions (to avoid hiding)
      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::replicateUnitCell;
      using Base::expandRGridDimension;
      using Base::convertBasisToKGrid;
      using Base::convertKGridToBasis;
      using Base::hasSymmetry;
      using Base::compareFieldsRGrid;
      using Base::scaleFieldsRGrid;
 
   };
 
} // namespace Rpc
} // namespace Pscf 
 
// Explicit instantiation declarations
namespace Pscf {
   namespace Rp {
      using namespace Prdc;
      extern template 
      class Rp::FieldIo<1, Cpu::RField<1>, Cpu::RFieldDft<1>, Cpu::FFT<1>>;
      extern template 
      class Rp::FieldIo<2, Cpu::RField<2>, Cpu::RFieldDft<2>, Cpu::FFT<2>>;
      extern template 
      class Rp::FieldIo<3, Cpu::RField<3>, Cpu::RFieldDft<3>, Cpu::FFT<3>>;
   }
   namespace Rpc {
      extern template class FieldIo<1>;
      extern template class FieldIo<2>;
      extern template class FieldIo<3>;
   }
} 
#endif