struct_index_set.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/shape.hpp>
#include <kernel/geometry/index_set.hpp>
#include <kernel/geometry/intern/struct_num_entities.hpp>
#include <kernel/geometry/intern/struct_index_mapping.hpp>
 
namespace FEAT
{
  namespace Geometry
  {
    template<
      int shape_dim_,
      int cell_dim_,
      int face_dim_>
    class StructIndexSet
    {
      static_assert(shape_dim_ >= cell_dim_, "invalid shape dimension");
      static_assert(cell_dim_ > face_dim_, "invalid cell dimension");
      static_assert(face_dim_ >= 0, "invalid face dimension");
 
    public:
      typedef Shape::Hypercube<shape_dim_> ShapeType;
      typedef typename Shape::FaceTraits<ShapeType, cell_dim_>::ShapeType CellType;
      static constexpr int num_indices = Shape::FaceTraits<CellType, face_dim_>::count;
 
      class ImageIterator
      {
      private:
        const Index* _num_slices;
        Index _i;
        Index _j;
 
      public:
        ImageIterator() :
          _num_slices(nullptr),
          _i(0),
          _j(0)
        {
        }
 
        explicit ImageIterator(const Index* num_slices, Index i, Index j) :
          _num_slices(num_slices),
          _i(i),
          _j(j)
        {
        }
 
        Index operator*() const
        {
          return Intern::StructIndexMapping<shape_dim_, cell_dim_, face_dim_>::compute(_i, _j, _num_slices);
        }
 
        ImageIterator& operator++()
        {
          ++_j;
          return *this;
        }
 
        bool operator!=(const ImageIterator& other) const
        {
          return (_i != other._i) || (_j != other._j);
        }
      }; // class ImageIterator
 
      class IndexTupleType
      {
      public:
        static constexpr int num_indices = StructIndexSet::num_indices;
 
      private:
        const Index* _num_slices;
        Index _i;
 
      public:
        IndexTupleType() :
          _num_slices(nullptr),
          _i(0)
        {
        }
 
        explicit IndexTupleType(const Index* num_slices, Index i) :
          _num_slices(num_slices),
          _i(i)
        {
        }
 
        Index operator[](int j) const
        {
          return Intern::StructIndexMapping<shape_dim_, cell_dim_, face_dim_>::compute(_i, Index(j), _num_slices);
        }
      }; // class IndexTupleType
 
    private:
      Index _num_slices[shape_dim_];
      Index _num_entities;
      Index _index_bound;
 
    public:
      explicit StructIndexSet(const Index num_slices[]) :
        _num_entities(Intern::StructNumEntities<shape_dim_, cell_dim_>::compute(num_slices)),
        _index_bound(Intern::StructNumEntities<shape_dim_, face_dim_>::compute(num_slices))
      {
        for(int i(0); i < shape_dim_; ++i)
        {
          _num_slices[i] = num_slices[i];
        }
      }
 
      StructIndexSet(StructIndexSet&& other) :
        _num_entities(other._num_entities),
        _index_bound(other._index_bound)
      {
        for(int i(0); i < shape_dim_; ++i)
        {
          _num_slices[i] = other._num_slices[i];
        }
      }
 
      StructIndexSet& operator=(StructIndexSet&& other)
      {
        // avoid self-move
        if(this == &other)
          return *this;
 
        _num_entities = other._num_entities;
        _index_bound = other._index_bound;
        for(int i(0); i < shape_dim_; ++i)
        {
          _num_slices[i] = other._num_slices[i];
        }
        return *this;
      }
 
      std::size_t bytes() const
      {
        return std::size_t(0);
      }
 
      int get_num_indices() const
      {
        return num_indices;
      }
 
      Index get_num_entities() const
      {
        return _num_entities;
      }
 
      Index get_index_bound() const
      {
        return _index_bound;
      }
 
      IndexTupleType operator[](Index i) const
      {
        ASSERT(i < Index(_num_entities));
        return IndexTupleType(_num_slices, i);
      }
 
      Index operator()(Index i, int j) const
      {
        ASSERT(i < Index(_num_entities));
        ASSERT(j < num_indices);
        return Intern::StructIndexMapping<shape_dim_, cell_dim_, face_dim_>::compute(i, Index(j), _num_slices);
      }
 
      void copy_to(IndexSet<num_indices>& idx_set) const
      {
        XASSERT(idx_set.get_num_entities() == this->get_num_entities());
        XASSERT(idx_set.get_index_bound() == this->get_index_bound());
        for(Index i(0); i < _num_entities; ++i)
        {
          for(int j(0); j < num_indices; ++j)
          {
            idx_set(i, j) = Intern::StructIndexMapping<shape_dim_, cell_dim_, face_dim_>::compute(i, Index(j), _num_slices);
          }
        }
      }
 
      /* *************************************************************************************** */
      /*          A D J A C T O R     I N T E R F A C E     I M P L E M E N T A T I O N          */
      /* *************************************************************************************** */
      Index get_num_nodes_domain() const
      {
        return _num_entities;
      }
 
      Index get_num_nodes_image() const
      {
        return _index_bound;
      }
 
      ImageIterator image_begin(Index domain_node) const
      {
        ASSERT(domain_node < Index(_num_entities));
        return ImageIterator(_num_slices, domain_node, 0);
      }
 
      ImageIterator image_end(Index domain_node) const
      {
        ASSERT(domain_node < Index(_num_entities));
        return ImageIterator(_num_slices, domain_node, num_indices);
      }
    }; // class StructIndexSet<...>
 
 
    /* ***************************************************************************************** */
    /* ***************************************************************************************** */
    /* ***************************************************************************************** */
 
    template<
      int shape_dim_,
      int cell_dim_ = shape_dim_,
      int face_dim_ = cell_dim_ - 1>
    class StructIndexSetWrapper :
      public StructIndexSetWrapper<shape_dim_, cell_dim_, face_dim_ - 1>
    {
    protected:
      typedef StructIndexSetWrapper<shape_dim_, cell_dim_, face_dim_ - 1> BaseClass;
 
      StructIndexSet<shape_dim_, cell_dim_, face_dim_> _index_set;
 
    public:
      explicit StructIndexSetWrapper(const Index num_slices[]) :
        BaseClass(num_slices),
        _index_set(num_slices)
      {
      }
 
      StructIndexSetWrapper(StructIndexSetWrapper&& other) :
        BaseClass(std::forward<BaseClass>(other)),
        _index_set(std::forward<StructIndexSet<shape_dim_, cell_dim_, face_dim_>>(other._index_set))
      {
      }
 
      StructIndexSetWrapper& operator=(StructIndexSetWrapper&& other)
      {
        if(this == &other)
          return *this;
 
        BaseClass::operator=(std::forward<BaseClass>(other));
        _index_set = std::forward<StructIndexSet<shape_dim_, cell_dim_, face_dim_>>(other._index_set);
 
        return *this;
      }
 
      template<int face_dim__>
      const StructIndexSet<shape_dim_, cell_dim_, face_dim__>& get_index_set() const
      {
        static_assert((face_dim__ >= 0) && (face_dim__ <= face_dim_), "invalid face dimension");
        return StructIndexSetWrapper<shape_dim_, cell_dim_, face_dim__>::_index_set;
      }
 
      std::size_t bytes() const
      {
        return BaseClass::bytes() + _index_set.bytes();
      }
 
      void copy_to(IndexSetWrapper<Shape::Hypercube<cell_dim_>, face_dim_>& idx_set_wrp) const
      {
        BaseClass::copy_to(idx_set_wrp);
        _index_set.copy_to(idx_set_wrp.template get_index_set<face_dim_>());
      }
    };
 
    template<
      int shape_dim_,
      int cell_dim_>
    class StructIndexSetWrapper<shape_dim_, cell_dim_, 0>
    {
    protected:
      StructIndexSet<shape_dim_, cell_dim_, 0> _index_set;
 
    public:
      explicit StructIndexSetWrapper(const Index num_slices[]) :
        _index_set(num_slices)
      {
      }
 
      StructIndexSetWrapper(StructIndexSetWrapper&& other) :
        _index_set(std::forward<StructIndexSet<shape_dim_, cell_dim_, 0>>(other._index_set))
      {
      }
 
      StructIndexSetWrapper& operator=(StructIndexSetWrapper&& other)
      {
        if(this == &other)
          return *this;
 
        _index_set = std::forward<StructIndexSet<shape_dim_, cell_dim_, 0>>(other._index_set);
 
        return *this;
      }
 
      template<int face_dim__>
      const StructIndexSet<shape_dim_, cell_dim_, face_dim__>& get_index_set() const
      {
        static_assert(face_dim__ == 0, "invalid face dimension");
        return _index_set;
      }
 
      std::size_t bytes() const
      {
        return _index_set.bytes();
      }
 
      void copy_to(IndexSetWrapper<Shape::Hypercube<cell_dim_>, 0>& idx_set_wrp) const
      {
        _index_set.copy_to(idx_set_wrp.template get_index_set<0>());
      }
    };
 
    template<
      int shape_dim_,
      int cell_dim_ = shape_dim_>
    class StructIndexSetHolder :
      public StructIndexSetHolder<shape_dim_, cell_dim_ - 1>
    {
    protected:
      typedef StructIndexSetHolder<shape_dim_, cell_dim_ - 1> BaseClass;
 
      StructIndexSetWrapper<shape_dim_, cell_dim_> _index_set_wrapper;
 
    public:
      explicit StructIndexSetHolder(const Index num_slices[]) :
        BaseClass(num_slices),
        _index_set_wrapper(num_slices)
      {
      }
 
      StructIndexSetHolder(StructIndexSetHolder&& other) :
        BaseClass(std::forward<BaseClass>(other)),
        _index_set_wrapper(std::forward<StructIndexSetWrapper<shape_dim_, cell_dim_>>(other._index_set_wrapper))
      {
      }
 
      StructIndexSetHolder& operator=(StructIndexSetHolder&& other)
      {
        if(this == &other)
          return *this;
 
        BaseClass::operator=(std::forward<BaseClass>(other));
        _index_set_wrapper = std::forward<StructIndexSetWrapper<shape_dim_, cell_dim_>>(other._index_set_wrapper);
 
        return *this;
      }
 
      template<int cell_dim__>
      const StructIndexSetWrapper<shape_dim_, cell_dim__>& get_index_set_wrapper() const
      {
        return StructIndexSetHolder<shape_dim_, cell_dim__>::_index_set_wrapper;
      }
 
      template<int cell_dim__, int face_dim__>
      const StructIndexSet<shape_dim_, cell_dim__, face_dim__>& get_index_set() const
      {
        return get_index_set_wrapper<cell_dim__>().template get_index_set<face_dim__>();
      }
 
      std::size_t bytes() const
      {
        return BaseClass::bytes() + _index_set_wrapper.bytes();
      }
 
      void copy_to(IndexSetHolder<Shape::Hypercube<cell_dim_>>& idx_set_hld) const
      {
        BaseClass::copy_to(idx_set_hld);
        _index_set_wrapper.copy_to(idx_set_hld.template get_index_set_wrapper<cell_dim_>());
      }
    };
 
    template<int shape_dim_>
    class StructIndexSetHolder<shape_dim_, 0>
    {
    public:
      explicit StructIndexSetHolder(const Index /*num_slices*/[])
      {
      }
 
      StructIndexSetHolder(StructIndexSetHolder&&)
      {
      }
 
      StructIndexSetHolder& operator=(StructIndexSetHolder&&)
      {
        return *this;
      }
 
      std::size_t bytes() const
      {
        return std::size_t(0);
      }
 
      void copy_to(IndexSetHolder<Shape::Vertex>&) const
      {
      }
    };
  } // namespace Geometry
} // namespace FEAT