pspg/field/FieldIo.h

#ifndef PSPG_FIELD_IO_H
#define PSPG_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 <pspg/field/FFT.h>                 // member
#include <pspg/field/RDField.h>             // function parameter
#include <pspg/field/RDFieldDft.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 Pspg
{
   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 
      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 readFieldsRGrid(std::istream& in, 
                           DArray< RDField<D> >& fields,
                           UnitCell<D>& unitCell) const;
 
      void readFieldsRGrid(std::string filename, 
                           DArray< RDField<D> >& fields,
                           UnitCell<D>& unitCell) const;
 
      void writeFieldsRGrid(std::ostream& out, 
                            DArray< RDField<D> > const& fields,
                            UnitCell<D> const & unitCell) const;
 
      void writeFieldsRGrid(std::string filename,
                            DArray< RDField<D> > const& fields,
                            UnitCell<D> const & unitCell) const;
 
 
      void readFieldRGrid(std::istream& in, RDField<D> &field,
                          UnitCell<D>& unitCell) const;
 
      void readFieldRGrid(std::string filename, RDField<D> &field,
                          UnitCell<D>& unitCell) const;
 
      void writeFieldRGrid(std::ostream& out, 
                           RDField<D> const & field,
                           UnitCell<D> const & unitCell,
                           bool writeHeader = true) const;
 
      void writeFieldRGrid(std::string filename, RDField<D> const & field,
                           UnitCell<D> const & unitCell) const;
 
      void readFieldsKGrid(std::istream& in, 
                           DArray< RDFieldDft<D> >& fields,
                           UnitCell<D>& unitCell) const;
 
      void readFieldsKGrid(std::string filename, 
                           DArray< RDFieldDft<D> >& fields,
                           UnitCell<D>& unitCell) const;
 
      void writeFieldsKGrid(std::ostream& out, 
                            DArray< RDFieldDft<D> > const& fields,
                            UnitCell<D> const & unitCell) const;
   
      void writeFieldsKGrid(std::string filename, 
                           DArray< RDFieldDft<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, 
                               RDFieldDft<D>& dft) const;
   
      void convertBasisToKGrid(DArray< DArray<double> > const & in,
                               DArray< RDFieldDft<D> >& out) const;
 
      void convertKGridToBasis(RDFieldDft<D> const& dft, 
                               DArray<double>& components) const;
 
      void convertKGridToBasis(DArray< RDFieldDft<D> > const & in,
                               DArray< DArray<double> > & out) const;
 
      void convertBasisToRGrid(DArray< DArray<double> > const & in,
                               DArray< RDField<D> >& out) const;
 
      void convertRGridToBasis(DArray< RDField<D> > const & in,
                               DArray< DArray<double> > & out) const;
 
      void convertKGridToRGrid(DArray< RDFieldDft<D> > const & in,
                               DArray< RDField<D> > & out) const;
 
      void convertRGridToKGrid(DArray< RDField<D> > const & in,
                              DArray< RDFieldDft<D> > & out) const;
 
 
   private:
 
      // DFT work array for two-step conversion basis <-> kgrid <-> rgrid.
      mutable RDFieldDft<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(basisPtr_);  
         return *groupPtr_; 
      }
 
      Basis<D> & basis() const
      {
         UTIL_ASSERT(basisPtr_);  
         return *basisPtr_; 
      }
 
      FileMaster const & fileMaster() const
      {  
         UTIL_ASSERT(fileMasterPtr_);  
         return *fileMasterPtr_; 
      }
 
      void checkWorkDft() const;
 
   };
 
   #ifndef PSPG_FIELD_IO_TPP
   extern template class FieldIo<1>;
   extern template class FieldIo<2>;
   extern template class FieldIo<3>;
   #endif
 
} // namespace Pspc
} // namespace Pscf
#endif