FieldIoReal.h

#ifndef RPC_FIELD_IO_REAL_H
#define RPC_FIELD_IO_REAL_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 <prdc/crystal/UnitCell.h>     // nested LatticeSystem enum
#include <pscf/math/IntVec.h>          // template with default
 
// Forward declarations for classes used in interfaces
namespace Util {
   class FileMaster;
   template <typename T> class DArray;
}
namespace Pscf {
   template <int D> class Mesh;
   namespace Prdc {
      template <int D> class Basis;
      template <int D> class SpaceGroup;
      namespace Cpu {
         template <int D> class FFT;
         template <int D> class RField;
      }
   }
}
 
namespace Pscf {
namespace Prdc {
 
   using namespace Util;
   using namespace Pscf;
   using namespace Pscf::Prdc;
 
   template <int D, class RFRT, class RFKT, class FFTT>
   class FieldIoReal
   {
 
   public:
 
 
      FieldIoReal();
 
      virtual ~FieldIoReal();
 
      void associate(Mesh<D> const & mesh,
                     FFTT const & fft,
                     typename UnitCell<D>::LatticeSystem const & lattice,
                     bool const & hasGroup,
                     std::string const & groupName,
                     SpaceGroup<D> const & group,
                     Basis<D> & basis);
 
      void setFileMaster(FileMaster const & fileMaster);
 
 
      void
      readFieldsBasis(std::istream& in, DArray< DArray<double> > & fields,
                      UnitCell<D> & unitCell) const;
 
      void readFieldsBasis(std::string filename,
                           DArray< DArray<double> > & fields,
                           UnitCell<D> & unitCell) const;
 
      void readFieldBasis(std::istream& in, DArray<double>& field,
                          UnitCell<D> & unitCell) const;
 
      void readFieldBasis(std::string filename, DArray<double>& field,
                          UnitCell<D> & unitCell) const;
 
      void writeFieldBasis(std::string filename,
                           DArray<double> const & field,
                           UnitCell<D> const & unitCell) const;
 
      void writeFieldsBasis(std::ostream& out,
                            DArray< DArray<double> > const & fields,
                            UnitCell<D> const & unitCell) const;
 
      void writeFieldsBasis(std::string filename,
                            DArray< DArray<double> > const & fields,
                            UnitCell<D> const & unitCell) const;
 
      void writeFieldBasis(std::ostream& out,
                           DArray<double> const & field,
                           UnitCell<D> const & unitCell) const;
 
 
      virtual
      void readFieldsRGrid(std::istream& in,
                           DArray<RFRT>& fields,
                           UnitCell<D> & unitCell) const;
 
      void readFieldsRGrid(std::string filename,
                           DArray<RFRT>& fields,
                           UnitCell<D> & unitCell) const;
 
      virtual
      void readFieldsRGridData(std::istream& in,
                               DArray<RFRT>& fields,
                               int nMonomer) const;
 
      virtual
      void readFieldRGrid(std::istream &in,
                           RFRT & field,
                           UnitCell<D>& unitCell) const;
 
      void readFieldRGrid(std::string filename,
                           RFRT & field,
                           UnitCell<D>& unitCell) const;
 
      virtual
      void writeFieldsRGrid(std::ostream& out,
                            DArray<RFRT> const & fields,
                            UnitCell<D> const & unitCell,
                            bool writeHeader = true,
                            bool isSymmetric = true,
                            bool writeMeshSize = true) const;
 
      void writeFieldsRGrid(std::string filename,
                            DArray<RFRT> const & fields,
                            UnitCell<D> const & unitCell,
                            bool isSymmetric = true) const;
 
      virtual
      void writeFieldRGrid(std::ostream &out,
                           RFRT const & field,
                           UnitCell<D> const & unitCell,
                           bool writeHeader = true,
                           bool isSymmetric = true) const;
 
      void writeFieldRGrid(std::string filename,
                           RFRT const & field,
                           UnitCell<D> const & unitCell,
                           bool isSymmetric = true) const;
 
 
      virtual
      void readFieldsKGrid(std::istream& in,
                           DArray<RFKT>& fields,
                           UnitCell<D> & unitCell) const;
 
      void readFieldsKGrid(std::string filename,
                           DArray<RFKT>& fields,
                           UnitCell<D> & unitCell) const;
 
      virtual
      void writeFieldsKGrid(std::ostream& out,
                            DArray<RFKT> const & fields,
                            UnitCell<D> const & unitCell,
                            bool isSymmetric = true) const;
 
      void writeFieldsKGrid(std::string filename,
                           DArray<RFKT> const & fields,
                           UnitCell<D> const & unitCell,
                           bool isSymmetric = true) const;
 
 
      virtual
      void convertBasisToKGrid(DArray<double> const & components,
                               RFKT& dft) const;
 
      void convertBasisToKGrid(DArray< DArray<double> > const & in,
                               DArray<RFKT>& out) const;
 
      virtual
      void convertKGridToBasis(RFKT const & in,
                               DArray<double> & out,
                               bool checkSymmetry = true,
                               double epsilon = 1.0e-8) const;
 
      void convertKGridToBasis(DArray<RFKT> const & in,
                               DArray< DArray<double> > & out,
                               bool checkSymmetry = true,
                               double epsilon = 1.0e-8) const;
 
      void convertBasisToRGrid(DArray<double> const & in,
                               RFRT & out) const;
 
      void convertBasisToRGrid(DArray< DArray<double> > const & in,
                               DArray<RFRT> & out) const ;
 
      void convertRGridToBasis(RFRT const & in,
                               DArray<double> & out,
                               bool checkSymmetry = true,
                               double epsilon = 1.0e-8) const;
 
      void convertRGridToBasis(DArray<RFRT> const & in,
                               DArray< DArray<double> > & out,
                               bool checkSymmetry = true,
                               double epsilon = 1.0e-8) const;
 
      void convertKGridToRGrid(DArray<RFKT> const & in,
                               DArray<RFRT> & out) const;
 
      void convertKGridToRGrid(RFKT const & in,
                               RFRT & out) const;
 
      void convertRGridToKGrid(DArray<RFRT> const & in,
                               DArray<RFKT> & out) const;
 
      void convertRGridToKGrid(RFRT const & in,
                               RFKT & out) const;
 
 
      virtual
      bool hasSymmetry(RFKT const & in, double epsilon = 1.0e-8,
                       bool verbose = true) const;
 
      bool hasSymmetry(RFRT const & in, double epsilon = 1.0e-8,
                       bool verbose = true) const;
 
 
      virtual
      void scaleFieldBasis(DArray<double>& field, double factor) const;
 
      void scaleFieldsBasis(DArray< DArray<double> >& fields, double factor) 
      const;
 
      virtual
      void scaleFieldRGrid(RFRT& field, double factor) const;
 
      void scaleFieldsRGrid(DArray<RFRT> & fields, double factor) const;
 
 
      virtual
      void replicateUnitCell(std::ostream& out,
                             DArray<RFRT> const & fields,
                             UnitCell<D> const & unitCell,
                             IntVec<D> const & replicas) const;
 
      void replicateUnitCell(std::string filename,
                             DArray<RFRT> const & fields,
                             UnitCell<D> const & unitCell,
                             IntVec<D> const & replicas) const;
 
      virtual
      void expandRGridDimension(std::ostream &out,
                                DArray<RFRT > const & fields,
                                UnitCell<D> const & unitCell,
                                int d,
                                DArray<int> const& newGridDimensions) 
      const;
 
      void expandRGridDimension(std::string filename,
                                DArray<RFRT > const & fields,
                                UnitCell<D> const & unitCell,
                                int d,
                                DArray<int> newGridDimensions) const;
 
 
 
      void readFieldHeader(std::istream& in, int& nMonomer,
                           UnitCell<D> & unitCell,
                           bool & isSymmetric) const;
 
      void writeFieldHeader(std::ostream& out, int nMonomer,
                            UnitCell<D> const & unitCell,
                            bool isSymmetric = true) const;
 
 
   private:
 
      // DFT work array for conversions basis <-> kgrid <-> r-grid
      mutable RFKT workDft_;
 
      // Pointers to associated external data
 
      Mesh<D> const * meshPtr_;
 
      FFTT const * fftPtr_;
 
      typename UnitCell<D>::LatticeSystem const * latticePtr_;
 
      bool const * hasGroupPtr_;
 
      std::string const * groupNamePtr_;
 
      SpaceGroup<D> const * groupPtr_;
 
      Basis<D> * basisPtr_;
 
      FileMaster const * fileMasterPtr_;
 
   protected:
 
      // Private accessor functions for associated external data
 
      Mesh<D> const & mesh() const
      {
         UTIL_ASSERT(meshPtr_);
         return *meshPtr_;
      }
 
      FFTT const & fft() const
      {
         UTIL_ASSERT(fftPtr_);
         return *fftPtr_;
      }
 
      typename UnitCell<D>::LatticeSystem const & lattice() const
      {
         UTIL_ASSERT(latticePtr_);
         return *latticePtr_;
      }
 
      bool hasGroup() const
      {
         UTIL_ASSERT(hasGroupPtr_);
         return *hasGroupPtr_;
      }
 
      std::string const & groupName() const
      {
         UTIL_ASSERT(groupNamePtr_);
         return *groupNamePtr_;
      }
 
      SpaceGroup<D> const & group() const
      {
         UTIL_ASSERT(groupPtr_);
         return *groupPtr_;
      }
 
      Basis<D> const & basis() const
      {
         UTIL_ASSERT(basisPtr_);
         return *basisPtr_;
      }
 
      FileMaster const & fileMaster() const
      {
         UTIL_ASSERT(fileMasterPtr_);
         return *fileMasterPtr_;
      }
 
   };
 
} // namespace Prdc
} // namespace Pscf
#endif