pspc/field/FieldIo.h

#ifndef PSPC_FIELD_IO_H
#define PSPC_FIELD_IO_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 <pspc/field/FFT.h>                // member
#include <pspc/field/RField.h>             // function parameter
#include <pspc/field/RFieldDft.h>          // function parameter
 
#include <pscf/crystal/Basis.h>            // member
#include <pscf/crystal/SpaceGroup.h>       // member
#include <pscf/crystal/UnitCell.h>         // member
#include <pscf/mesh/Mesh.h>                // member
 
#include <util/misc/FileMaster.h>          // member
#include <util/containers/DArray.h>        // function parameter
#include <util/containers/Array.h>         // function parameter
 
namespace Pscf {
namespace Pspc
{
   using namespace Util;
   using namespace Pscf;
 
   template <int D>
   class FieldIo 
   {
 
   public:
 
      FieldIo();
 
      ~FieldIo();
 
      void associate(Mesh<D> const & mesh,
                     FFT<D> const & fft,
                     typename UnitCell<D>::LatticeSystem & lattice,
                     std::string & groupName,
                     SpaceGroup<D> & group,
                     Basis<D> & basis,
                     FileMaster const & fileMaster);
 
 
      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::ostream& out, 
                           DArray<double> const & field,
                           UnitCell<D> const & unitCell) const;
 
      void writeFieldBasis(std::string filename, 
                           DArray<double> const & field,
                           UnitCell<D> const & unitCell) const;
      
      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 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 readFieldRGrid(std::istream &in, 
                           RField<D> & field, 
                           UnitCell<D>& unitCell) const;
 
      void readFieldRGrid(std::string filename, 
                           RField<D> & field, 
                           UnitCell<D>& unitCell) const;
 
      void readFieldsRGrid(std::istream& in, DArray< RField<D> >& fields, 
                           UnitCell<D> & unitCell) const;
 
      void readFieldsRGrid(std::string filename, 
                           DArray< RField<D> >& fields, 
                           UnitCell<D> & unitCell) const;
 
      void writeFieldRGrid(std::ostream &out, 
                           RField<D> const & field, 
                           UnitCell<D> const & unitCell,
                           bool writeHeader = true) 
      const;
 
      void writeFieldRGrid(std::string filename, 
                           RField<D> const & field, 
                           UnitCell<D> const & unitCell) const;
 
      void writeFieldsRGrid(std::ostream& out, 
                            DArray< RField<D> > const & fields, 
                            UnitCell<D> const & unitCell) const;
 
      void writeFieldsRGrid(std::string filename,
                            DArray< RField<D> > const & fields, 
                            UnitCell<D> const & unitCell) const;
 
 
      void readFieldsKGrid(std::istream& in, 
                           DArray< RFieldDft<D> >& fields, 
                           UnitCell<D> & unitCell) const;
 
      void readFieldsKGrid(std::string filename, 
                           DArray< RFieldDft<D> >& fields, 
                           UnitCell<D> & unitCell) const;
 
      void writeFieldsKGrid(std::ostream& out, 
                            DArray< RFieldDft<D> > const & fields, 
                            UnitCell<D> const & unitCell) const;
   
      void writeFieldsKGrid(std::string filename, 
                           DArray< RFieldDft<D> > const & fields, 
                           UnitCell<D> const & unitCell) const;
 
 
      void readFieldHeader(std::istream& in, int& nMonomer, 
                           UnitCell<D> & unitCell) const;
 
      void writeFieldHeader(std::ostream& out, int nMonomer,
                            UnitCell<D> const & unitCell) const;
 
 
      void convertBasisToKGrid(DArray<double> const & components, 
                               RFieldDft<D>& dft) const;
   
      void convertBasisToKGrid(DArray< DArray<double> > const & in,
                               DArray< RFieldDft<D> >& out) const;
 
      void convertKGridToBasis(RFieldDft<D> const & in, 
                               DArray<double> & out,
                               bool checkSymmetry = true,
                               double epsilon = 1.0e-8) const;
 
      void convertKGridToBasis(DArray< RFieldDft<D> > const & in,
                               DArray< DArray<double> > & out,
                               bool checkSymmetry = true,
                               double epsilon = 1.0e-8) const;
 
      void convertBasisToRGrid(DArray<double> const & in,
                               RField<D> & out) const;
 
      void convertBasisToRGrid(DArray< DArray<double> > const & in,
                               DArray< RField<D> > & out) const ;
 
      void convertRGridToBasis(RField<D> const & in,
                               DArray<double> & out,
                               bool checkSymmetry = true, 
                               double epsilon = 1.0e-8) const;
 
      void convertRGridToBasis(DArray< RField<D> > const & in,
                               DArray< DArray<double> > & out,
                               bool checkSymmetry = true, 
                               double epsilon = 1.0e-8) const;
 
      void convertKGridToRGrid(DArray< RFieldDft<D> > & in,
                               DArray< RField<D> > & out) const;
 
      void convertKGridToRGrid(RFieldDft<D> & in,
                               RField<D> & out) const;
 
      void convertRGridToKGrid(DArray< RField<D> > const & in,
                               DArray< RFieldDft<D> > & out) const;
 
      void convertRGridToKGrid(RField<D> const & in,
                               RFieldDft<D> & out) const;
 
 
      bool hasSymmetry(RField<D> const & in, double epsilon = 1.0e-8,
                       bool verbose = true) const;
 
      bool hasSymmetry(RFieldDft<D> const & in, double epsilon = 1.0e-8,
                       bool verbose = true) const;
 
 
   private:
 
      // DFT work array for two-step conversion basis <-> kgrid <-> r-grid.
      mutable RFieldDft<D> workDft_;
 
      // Pointers to associated objects.
 
      Mesh<D> const * meshPtr_;
 
      FFT<D> const * fftPtr_;
 
      typename UnitCell<D>::LatticeSystem * latticePtr_;
 
      std::string * groupNamePtr_;
 
      SpaceGroup<D> * groupPtr_;
 
      Basis<D> * basisPtr_;
 
      FileMaster const * fileMasterPtr_;
 
      // Private accessor functions:
 
      Mesh<D> const & mesh() const
      {  
         UTIL_ASSERT(meshPtr_);  
         return *meshPtr_; 
      }
 
      FFT<D> const & fft() const
      {
         UTIL_ASSERT(fftPtr_);  
         return *fftPtr_; 
      }
 
      typename UnitCell<D>::LatticeSystem & lattice() const
      {  
         UTIL_ASSERT(latticePtr_);  
         return *latticePtr_; 
      }
 
      std::string & groupName() const
      {  
         UTIL_ASSERT(groupNamePtr_);  
         return *groupNamePtr_; 
      }
 
      SpaceGroup<D> & group() const
      {
         UTIL_ASSERT(groupPtr_);  
         return *groupPtr_; 
      }
 
      Basis<D> & basis() const
      {
         UTIL_ASSERT(basisPtr_);  
         return *basisPtr_; 
      }
 
      FileMaster const & fileMaster() const
      {  
         UTIL_ASSERT(fileMasterPtr_);  
         return *fileMasterPtr_; 
      }
 
      void checkWorkDft() const;
 
   };
 
   #ifndef PSPC_FIELD_IO_TPP
   extern template class FieldIo<1>;
   extern template class FieldIo<2>;
   extern template class FieldIo<3>;
   #endif
 
} // namespace Pspc
} // namespace Pscf
#endif