cp/field/FieldIo.h

#ifndef PRDC_CL_FIELD_IO_H
#define PRDC_CL_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 <prdc/crystal/UnitCell.h>     // nested LatticeSystem enum
#include <pscf/math/IntVec.h>          // template with default
#include <util/containers/DArray.h>    // member
 
// Forward declarations 
namespace Util {
   class FileMaster;
}
namespace Pscf {
   template <int D> class Mesh;
}
 
namespace Pscf {
namespace Cp {
 
   using namespace Util;
   using namespace Prdc;

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


      FieldIo();

      virtual ~FieldIo();

      void associate(Mesh<D> const & mesh,
                     FFT const & fft,
                     typename UnitCell<D>::LatticeSystem const & lattice);

      void setFileMaster(FileMaster const & fileMaster);

      void setNMonomer(int nMonomer);


      virtual
      void readFields(std::istream& in,
                      DArray<CFT>& fields,
                      UnitCell<D> & unitCell) const = 0;

      void readFields(std::string filename,
                      DArray<CFT>& fields,
                      UnitCell<D> & unitCell) const;

      virtual
      void readFieldsData(std::istream& in,
                           DArray<CFT>& fields,
                           int nMonomer) const = 0;

      virtual
      void readField(std::istream &in,
                     CFT & field,
                     UnitCell<D>& unitCell) const = 0;

      void readField(std::string filename,
                     CFT & field,
                     UnitCell<D>& unitCell) const;

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

      void writeFields(std::string filename,
                       DArray<CFT> const & fields,
                       UnitCell<D> const & unitCell) const;

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

      void writeField(std::string filename,
                      CFT const & field,
                      UnitCell<D> const & unitCell) const;


      void convertRGridToKGrid(DArray<CFT> const & in,
                               DArray<CFT> & out) const;

      void convertRGridToKGrid(std::string const & inFileName,
                               std::string const & outFileName) const;

      void convertKGridToRGrid(DArray<CFT> const & in,
                               DArray<CFT> & out) const;

      void convertKGridToRGrid(std::string const & inFileName,
                               std::string const & outFileName) const;

      #if 0

      virtual
      void compareFields(DArray< CFT > const & field1,
                         DArray< CFT > const & field2) const = 0;

      void compareFields(std::string const & filename1,
                         std::string const & filename2) const;

      #endif


      void readFieldHeader(std::istream& in,
                           int& nMonomer,
                           UnitCell<D> & unitCell) const;

      void writeFieldHeader(std::ostream& out,
                            int nMonomer,
                            UnitCell<D> const & unitCell) const;


      Mesh<D> const & mesh() const
      {
         UTIL_ASSERT(meshPtr_);
         return *meshPtr_;
      }

      FileMaster const & fileMaster() const
      {
         UTIL_ASSERT(fileMasterPtr_);
         return *fileMasterPtr_;
      }

 
   protected:

      typename UnitCell<D>::LatticeSystem const & lattice() const
      {
         UTIL_ASSERT(latticePtr_);
         return *latticePtr_;
      }

      FFT const & fft() const
      {
         UTIL_ASSERT(fftPtr_);
         return *fftPtr_;
      }

      void checkAllocate() const;
 
   private:

      Mesh<D> const * meshPtr_;

      FFT const * fftPtr_;

      typename UnitCell<D>::LatticeSystem const * latticePtr_;

      FileMaster const * fileMasterPtr_;

      int nMonomer_;
 
      // Mutable work space used by functions that read field files

      mutable DArray<CFT> tmpFields_;

      mutable bool isAllocated_;
 
   };
 
} // namespace Cp
} // namespace Pscf
#endif