fieldIoUtil.h

#ifndef PRDC_FIELD_IO_UTIL_H
#define PRDC_FIELD_IO_UTIL_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 <pscf/math/IntVec.h>   // Template with a default parameter
 
// Forward class declarations 
namespace Util {
   template <typename T> class DArray;
}
namespace Pscf {
   template <int D> class Mesh;
   namespace Prdc {
      template <int D> class UnitCell;
      template <int D> class Basis;
   }
}
 
namespace Pscf {
namespace Prdc {
 
   using namespace Util;
   using namespace Pscf;
 
   // Utilities for checking field and array dimensions
 
   template <int D, class FT>
   void checkAllocateField(FT& field, IntVec<D> const& dimensions); 
 
   template <int D, class FT>
   void checkAllocateFields(DArray< FT >& fields, 
                            int nMonomer,
                            IntVec<D> const& dimensions);
 
   template <int D, class FT>
   void inspectFields(DArray<FT> const & fields,
                      int & nMonomer,
                      IntVec<D> & dimensions);
 
   template <int D, class AT>
   void checkAllocateArrays(DArray< AT >& arrays, 
                            int nMonomer,
                            int capacity);
 
   template <class AT>
   void inspectArrays(DArray<AT> const & arrays,
                      int & nMonomer, 
                      int & capacity);
 
 
   // Templates for RGrid data IO
 
   template <int D>
   void readMeshDimensions(std::istream& in,
                           IntVec<D> const& meshDimensions);
 
   template <int D>
   void writeMeshDimensions(std::ostream &out,
                            IntVec<D> const& meshDimensions);
 
   template <int D, class AT>
   void readRGridData(std::istream& in,
                      DArray<AT>& fields,
                      int nMonomer,
                      IntVec<D> const& dimensions);
 
   template <int D, class AT>
   void readRGridData(std::istream& in, 
                      AT& field,
                      IntVec<D> const& dimensions);
 
   template <int D, class AT>
   void writeRGridData(std::ostream& out, 
                       DArray<AT> const& fields,
                       int nMonomer,
                       IntVec<D> const& dimensions);
 
   template <int D, class AT>
   void writeRGridData(std::ostream& out, 
                       AT const& field,
                       IntVec<D> const& dimensions);
 
   // Templates for KGrid data IO
 
   template <int D, class AT>
   void readKGridData(std::istream& in,
                      DArray<AT>& fields,
                      int nMonomer,
                      IntVec<D> const& dftDimensions);
 
   template <int D, class AT>
   void readKGridData(std::istream& in, 
                      AT& field,
                      IntVec<D> const& dftDimensions);
 
   template <int D, class AT>
   void writeKGridData(std::ostream& out, 
                       DArray<AT> const& fields,
                       int nMonomer,
                       IntVec<D> const& dftDimensions);
 
   template <int D, class AT>
   void writeKGridData(std::ostream& in, 
                       AT const& field,
                       IntVec<D> const& dftDimensions);
 
   // Templates for Io of symmetrized basis format
 
   int readNBasis(std::istream& in);
   
   void writeNBasis(std::ostream& out, int nBasis);
   
   template <int D>
   void readBasisData(std::istream& in,
                      DArray< DArray<double> >& fields,
                      UnitCell<D> const& unitCell,
                      Mesh<D> const& mesh,
                      Basis<D> const& basis,
                      int nStarIn);
 
   template <int D>
   void writeBasisData(std::ostream &out,
                       DArray<DArray<double> > const & fields,
                       Basis<D> const & basis);
 
   template <int D, class AT>
   void convertBasisToKGrid(DArray<double> const & components,
                            AT& dft,
                            Basis<D> const& basis,
                            IntVec<D> const& dftDimensions);
 
   template <int D, class AT>
   void convertKGridToBasis(AT const & in,
                            DArray<double> & out,
                            Basis<D> const& basis,
                            IntVec<D> const& dftDimensions,
                            bool checkSymmetry = true,
                            double epsilon = 1.0e-8);
 
   template <int D, class AT>
   bool hasSymmetry(AT const& in, 
                    Basis<D> const& basis,
                    IntVec<D> const& dftDimensions,
                    double epsilon = 1.0e-8,
                    bool verbose = true);
 
   // Field manipulation utilities
 
   template <int D, class AT>
   void replicateUnitCell(std::ostream& out,
                          DArray<AT > const & fields,
                          IntVec<D> const & meshDimensions,
                          UnitCell<D> const & unitCell,
                          IntVec<D> const & replicas);
 
   template <int D, class AT>
   void expandRGridDimension(std::ostream &out,
                             DArray< AT > const & fields,
                             IntVec<D> const & meshDimensions,
                             UnitCell<D> const & unitCell,
                             int d,
                             DArray<int> newGridDimensions);
 
} // namespace Prdc
} // namespace Pscf
#include "fieldIoUtil.tpp"
#endif