Mesh.h

#ifndef PSCF_MESH_H
#define PSCF_MESH_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>    // member
#include <iostream>              // interface
#include <util/format/Int.h>     // operator << implementation
 
namespace Pscf 
{
 
   using namespace Util;
 
   // Forward declaration
   template <int D> class Mesh;
 
   template <int D>
   std::istream& operator >> (std::istream& in, Mesh<D>& mesh);
 
   template <int D>
   std::ostream& operator << (std::ostream& out, Mesh<D> const & mesh);
 
   template <int D>
   class Mesh
   {
 
   public:
 
      Mesh();
 
      Mesh(Mesh<D> const & other);
 
      Mesh(IntVec<D> const & dimensions);
 
      Mesh<D>& operator = (Mesh<D> const & other);
 
      void setDimensions(IntVec<D> const & dimensions);
 
      IntVec<D> dimensions() const;
 
      int dimension(int i) const;
 
      int size() const;
 
      IntVec<D> position(int rank) const;
 
      int rank(IntVec<D> const & position) const;
 
      bool isInMesh(int coordinate, int i) const;
 
      bool isInMesh(IntVec<D> const & position) const;
 
      int shift(int& coordinate, int i) const;
 
      IntVec<D> shift(IntVec<D>& position) const;
 
      template <class Archive>
      void serialize(Archive& ar, const unsigned int version);
 
   private:
 
      IntVec<D> dimensions_;
 
      IntVec<D> offsets_;
 
      int size_;
 
   //friends:
 
      friend std::istream& operator >> <>(std::istream&, Mesh<D> & );
 
      friend std::ostream& operator << <>(std::ostream&, Mesh<D> const & );
 
 
   };
 
   // Inline member function implementations
 
   template <int D>
   inline IntVec<D> Mesh<D>::dimensions() const
   {  return dimensions_; }
 
   template <int D>
   inline int Mesh<D>::dimension(int i) const
   {
      assert(i >=0);
      assert(i < Dimension);
      return dimensions_[i];
   }
 
   template <int D>
   inline int Mesh<D>::size() const
   {  return size_; }
 
   /*
   * Serialize Mesh to/from an archive.
   */
   template <int D>
   template <class Archive>
   void Mesh<D>::serialize(Archive& ar, const unsigned int version)
   {
      for (int i=0; i < D; ++i) {
         ar & dimensions_[0];
      }
   }
 
   template <int D>
   std::istream& operator >> (std::istream& in, Mesh<D>& mesh)
   {
      IntVec<D> dimensions;
      in >> dimensions;
      for (int i = 0; i < D; ++i) {
         UTIL_CHECK(dimensions[i] > 0);
      }
      mesh.setDimensions(dimensions);
      return in;
   }
 
   template <int D>
   std::ostream& operator << (std::ostream& out, Mesh<D> const & mesh)
   {
      for (int i = 0; i < D; ++i) {
         out << " " << Int(mesh.dimensions_[i], 6);
      }
      return out;
   }
 
   #ifndef PSCF_MESH_TPP
   // Suppress implicit instantiation
   extern template class Mesh<1>;
   extern template class Mesh<2>;
   extern template class Mesh<3>;
   #endif
 
}
//#include "Mesh.tpp"
#endif