structured_mesh.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// includes, FEAT
#include <kernel/geometry/factory.hpp>
#include <kernel/geometry/struct_index_set.hpp>
#include <kernel/geometry/intern/structured_vertex_refiner.hpp>
 
namespace FEAT
{
  namespace Geometry
  {
    template<
      int shape_dim_,
      int num_coords_ = shape_dim_,
      typename Coord_ = Real>
    class StructuredMesh
    {
      static_assert(shape_dim_ > 0, "invalid shape dimension");
      static_assert(num_coords_ >= shape_dim_, "invalid number of coordinates");
 
    public:
      typedef Shape::Hypercube<shape_dim_> ShapeType;
 
      typedef Coord_ CoordType;
 
      typedef VertexSet<num_coords_, Coord_> VertexSetType;
 
      typedef StructIndexSetHolder<shape_dim_> IndexSetHolderType;
 
      static constexpr int shape_dim = shape_dim_;
      static constexpr int world_dim = num_coords_;
 
      static constexpr bool is_structured = true;
 
      template<
        int cell_dim_,
        int face_dim_>
      struct IndexSet
      {
        static_assert(cell_dim_ <= shape_dim, "invalid cell dimension");
        static_assert(face_dim_ < cell_dim_, "invalid face/cell dimension");
        static_assert(face_dim_ >= 0, "invalid face dimension");
 
        typedef StructIndexSet<shape_dim_, cell_dim_, face_dim_> Type;
      }; // struct IndexSet<...>
 
    protected:
      Index _num_slices[shape_dim];
      Index _num_entities[shape_dim + 1];
 
      VertexSetType _vertex_set;
 
      IndexSetHolderType _index_set_holder;
 
    private:
      StructuredMesh& operator=(const StructuredMesh&);
 
    public:
      explicit StructuredMesh(const Index num_slices[]) :
        _vertex_set(Intern::StructNumEntities<shape_dim_, 0>::compute(num_slices)),
        _index_set_holder(num_slices)
      {
        XASSERT(num_slices != nullptr);
 
        // store slice counts
        for(int i(0); i < shape_dim; ++i)
        {
          XASSERT(num_slices[i] > 0);
          _num_slices[i] = num_slices[i];
        }
 
        // calculate number of entities
        Intern::StructNumEntitiesWrapper<shape_dim_>::compute(_num_entities, _num_slices);
      }
 
      explicit StructuredMesh(Factory<StructuredMesh>& factory) :
        _vertex_set(
          Intern::StructNumEntities<shape_dim_, 0>::compute(
            Intern::NumSlicesWrapper<shape_dim>(factory).num_slices)),
        _index_set_holder(Intern::NumSlicesWrapper<shape_dim>(factory).num_slices)
      {
        // store slice count
        Intern::NumSlicesWrapper<shape_dim>::apply(factory, _num_slices);
 
        // calculate number of entities
        Intern::StructNumEntitiesWrapper<shape_dim_>::compute(_num_entities, _num_slices);
 
        // fill vertex set
        factory.fill_vertex_set(_vertex_set);
      }
 
      StructuredMesh(const StructuredMesh& other) :
        _vertex_set(other.get_vertex_set()),
        _index_set_holder(other.get_num_slices())
      {
        for(int i(0); i < shape_dim_; ++i)
        {
          _num_slices[i] = other.get_num_slices(i);
        }
 
        // calculate number of entities
        Intern::StructNumEntitiesWrapper<shape_dim_>::compute(_num_entities, _num_slices);
      }
 
      virtual ~StructuredMesh()
      {
      }
 
      std::size_t bytes() const
      {
        return _vertex_set.bytes() + _index_set_holder.bytes();
      }
 
      Index get_num_slices(int dir) const
      {
        XASSERT(dir >= 0);
        XASSERT(dir < shape_dim);
        return _num_slices[dir];
      }
 
      const Index* get_num_slices() const
      {
        return _num_slices;
      }
 
      Index get_num_entities(int dim) const
      {
        XASSERT(dim >= 0);
        XASSERT(dim <= shape_dim);
        return _num_entities[dim];
      }
 
      Index get_num_vertices() const
      {
        return _num_entities[0];
      }
 
      Index get_num_elements() const
      {
        return _num_entities[shape_dim];
      }
 
      VertexSetType& get_vertex_set()
      {
        return _vertex_set;
      }
 
      const VertexSetType& get_vertex_set() const
      {
        return _vertex_set;
      }
 
      template<
        int cell_dim_,
        int face_dim_>
      const StructIndexSet<shape_dim_, cell_dim_, face_dim_>& get_index_set() const
      {
        return _index_set_holder.template get_index_set<cell_dim_, face_dim_>();
      }
 
      IndexSetHolderType& get_index_set_holder()
      {
        return _index_set_holder;
      }
 
      const IndexSetHolderType& get_index_set_holder() const
      {
        return _index_set_holder;
      }
 
      IndexSetHolderType* get_topology()
      {
        return &_index_set_holder;
      }
 
      const IndexSetHolderType* get_topology() const
      {
        return &_index_set_holder;
      }
 
      static String name()
      {
        return "StructuredMesh<...>";
      }
    }; // class StructuredMesh<...>
 
    /* ************************************************************************************************************* */
 
    template<
      int shape_dim_,
      int num_coords_,
      typename Coord_>
    class Factory< StructuredMesh<shape_dim_, num_coords_, Coord_> >
    {
    public:
      typedef StructuredMesh<shape_dim_, num_coords_, Coord_> MeshType;
      typedef typename MeshType::VertexSetType VertexSetType;
 
    public:
      virtual ~Factory()
      {
      }
 
      virtual Index get_num_slices(int dir) = 0;
 
      virtual void fill_vertex_set(VertexSetType& vertex_set) = 0;
    }; // class Factory<StructuredMesh<...>>
 
    /* ************************************************************************************************************* */
 
    template<
      int shape_dim_,
      int num_coords_,
      typename Coord_>
    class StandardRefinery<StructuredMesh<shape_dim_, num_coords_, Coord_> > :
      public Factory< StructuredMesh<shape_dim_, num_coords_, Coord_> >
    {
    public:
      typedef StructuredMesh<shape_dim_, num_coords_, Coord_> MeshType;
      typedef typename MeshType::ShapeType ShapeType;
      typedef typename MeshType::VertexSetType VertexSetType;
 
      static constexpr int shape_dim = ShapeType::dimension;
 
    protected:
      const MeshType& _coarse_mesh;
      Index _num_slices_coarse[shape_dim];
 
    public:
      explicit StandardRefinery(const MeshType& coarse_mesh) :
        _coarse_mesh(coarse_mesh)
      {
        for(int i(0); i < shape_dim; ++i)
        {
          _num_slices_coarse[i] = coarse_mesh.get_num_slices(i);
        }
      }
 
      virtual Index get_num_slices(int dir) override
      {
        return 2 * _coarse_mesh.get_num_slices(dir);
      }
 
      virtual void fill_vertex_set(VertexSetType& vertex_set) override
      {
        // refine vertices
        Intern::StructuredVertexRefiner<ShapeType, VertexSetType>
          ::refine(vertex_set, _coarse_mesh.get_vertex_set(), _num_slices_coarse);
      }
    }; // class StandardRefinery<StructuredMesh<...>>
  } // namespace Geometry
} // namespace FEAT