cpc/field/FieldIo.h

#ifndef CPC_FIELD_IO_H
#define CPC_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 <cp/field/FieldIo.h>         // base class template
#include <prdc/cpu/CField.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;
   }
}
 
// Explicit instantiation declaration for base class
namespace Pscf {
   namespace Cp {
      using namespace Prdc::Cpu;
      extern template class FieldIo<1, CField<1>, FFT<1> >;
      extern template class FieldIo<2, CField<2>, FFT<2> >;
      extern template class FieldIo<3, CField<3>, FFT<3> >;
   }
}
 
namespace Pscf {
namespace Cpc {
 
   using namespace Util;
   using namespace Pscf::Prdc;
   using namespace Pscf::Prdc::Cpu;

   template <int D>
   class FieldIo
     : public  Cp::FieldIo< D, CField<D>, FFT<D> >
   {
 
   public:


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

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

      void readField(std::istream &in,
                     CField<D> & field,
                     UnitCell<D>& unitCell) const override;

      void readFieldsRGrid(std::istream &in,
                           DArray< CField<D> > & fields,
                           UnitCell<D>& unitCell) const;


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

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

      #if 0

      void compareFields(DArray< CField<D> > const & field1,
                         DArray< CField<D> > const & field2)
      const override;
      #endif

      using Base = Cp::FieldIo< D, CField<D>, FFT<D> >;
 
      // Inherited public member functions
      using Base::associate;
      using Base::setFileMaster;
      using Base::readFields;
      using Base::readFieldsData;
      using Base::readField;
      using Base::writeFields;
      using Base::writeField;
      //using Base::convertKGridToRGrid;
      //using Base::convertRGridToKGrid;
      //using Base::compareFieldsRGrid;
      using Base::readFieldHeader;
      using Base::writeFieldHeader;
      using Base::mesh;
      using Base::fileMaster;
 
   protected:
 
      // Inherited protected member functions
      using Base::lattice;
      using Base::fft;
 
   };
 
   // Explicit instantiation declarations
   extern template class FieldIo<1>;
   extern template class FieldIo<2>;
   extern template class FieldIo<3>;
 
} // namespace Cpc
 
} // namespace Pscf
#endif