target_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/adjacency/permutation.hpp>
 
// includes, system
#include <vector>
 
namespace FEAT
{
  namespace Geometry
  {
    class TargetSet
    {
    protected:
      std::vector<Index> _indices;
 
      explicit TargetSet(const std::vector<Index>& idx) :
        _indices(idx)
      {
      }
 
    public:
      TargetSet() :
        _indices()
      {
      }
 
      explicit TargetSet(Index num_entities) :
        _indices(std::size_t(num_entities))
      {
      }
 
      TargetSet(TargetSet&& other) :
        _indices(std::forward<std::vector<Index>>(other._indices))
      {
      }
 
      TargetSet& operator=(TargetSet&& other)
      {
        // avoid self-move
        if(this == &other)
          return *this;
 
        _indices = std::forward<std::vector<Index>>(other._indices);
 
        return *this;
      }
 
      virtual ~TargetSet()
      {
      }
 
      TargetSet clone() const
      {
        return TargetSet(this->_indices);
      }
 
      std::size_t bytes() const
      {
        return _indices.size() * sizeof(Index);
      }
 
      Index get_num_entities() const
      {
        return Index(_indices.size());
      }
 
      Index* get_indices()
      {
        return _indices.data();
      }
 
      const Index* get_indices() const
      {
        return _indices.data();
      }
 
      Index& operator[](Index i)
      {
        ASSERT(i < get_num_entities());
        return _indices[i];
      }
 
      const Index& operator[](Index i) const
      {
        ASSERT(i < get_num_entities());
        return _indices[i];
      }
 
      void permute_map(const Adjacency::Permutation& inv_perm)
      {
        if(!inv_perm.empty())
        {
          for(std::size_t i(0); i < _indices.size(); ++i)
            _indices.at(i) = inv_perm.map(_indices.at(i));
        }
      }
    }; // class TargetSet
 
 
    template<typename Shape_>
    class TargetSetHolder :
      public TargetSetHolder<typename Shape::FaceTraits<Shape_, Shape_::dimension - 1>::ShapeType>
    {
    public:
      typedef Shape_ ShapeType;
      static constexpr int shape_dim = ShapeType::dimension;
 
    protected:
      typedef TargetSetHolder<typename Shape::FaceTraits<ShapeType, shape_dim - 1>::ShapeType> BaseClass;
 
      TargetSet _target_set;
 
    public:
      TargetSetHolder() :
        BaseClass(),
        _target_set()
      {
      }
 
      explicit TargetSetHolder(const Index num_entities[]) :
        BaseClass(num_entities),
        _target_set(num_entities[shape_dim])
      {
      }
 
      TargetSetHolder(TargetSetHolder&& other) :
        BaseClass(std::forward<BaseClass>(other)),
        _target_set(std::forward<TargetSet>(other._target_set))
      {
      }
 
      TargetSetHolder& operator=(TargetSetHolder&& other)
      {
        if(this == &other)
          return *this;
        BaseClass::operator=(std::forward<BaseClass>(other));
        _target_set = std::forward<TargetSet>(other._target_set);
        return *this;
      }
 
      void clone(const TargetSetHolder& other)
      {
        BaseClass::clone(other);
        this->_target_set = other._target_set.clone();
      }
 
      TargetSetHolder clone() const
      {
        TargetSetHolder tsh;
        tsh.clone(*this);
        return tsh;
      }
 
      virtual ~TargetSetHolder()
      {
      }
 
      std::size_t bytes() const
      {
        return BaseClass::bytes() + _target_set.bytes();
      }
 
      template<int dim_>
      TargetSet& get_target_set()
      {
        static_assert(dim_ >= 0, "invalid dimension");
        static_assert(dim_ <= shape_dim, "invalid dimension");
        typedef typename Shape::FaceTraits<Shape_, dim_>::ShapeType CellType;
        return TargetSetHolder<CellType>::_target_set;
      }
 
      template<int dim_>
      const TargetSet& get_target_set() const
      {
        static_assert(dim_ >= 0, "invalid dimension");
        static_assert(dim_ <= shape_dim, "invalid dimension");
        typedef typename Shape::FaceTraits<Shape_, dim_>::ShapeType CellType;
        return TargetSetHolder<CellType>::_target_set;
      }
 
      Index get_num_entities(int dim) const
      {
        XASSERTM(dim <= shape_dim, "invalid dimension parameter");
        if(dim == shape_dim)
        {
          return _target_set.get_num_entities();
        }
        return BaseClass::get_num_entities(dim);
      }
 
      template<std::size_t np_>
      void permute_map(const std::array<Adjacency::Permutation, np_>& inv_perms)
      {
        BaseClass::permute_map(inv_perms);
        _target_set.permute_map(inv_perms.at(shape_dim));
      }
 
      static String name()
      {
        return "TargetSetHolder<" + Shape_::name() + ">";
      }
    };
 
    template<>
    class TargetSetHolder<Shape::Vertex>
    {
    public:
      typedef Shape::Vertex ShapeType;
      static constexpr int shape_dim = ShapeType::dimension;
 
    protected:
      TargetSet _target_set;
 
    public:
      TargetSetHolder() :
        _target_set()
      {
      }
 
      explicit TargetSetHolder(const Index num_entities[]) :
        _target_set(num_entities[0])
      {
      }
 
      TargetSetHolder(TargetSetHolder&& other) :
        _target_set(std::forward<TargetSet>(other._target_set))
      {
      }
 
      TargetSetHolder& operator=(TargetSetHolder&& other)
      {
        if(this == &other)
          return *this;
        _target_set = std::forward<TargetSet>(other._target_set);
        return *this;
      }
 
      virtual ~TargetSetHolder()
      {
      }
 
      void clone(const TargetSetHolder& other)
      {
        this->_target_set = other._target_set.clone();
      }
 
      TargetSetHolder clone() const
      {
        TargetSetHolder tsh;
        tsh.clone(*this);
        return tsh;
      }
 
      std::size_t bytes() const
      {
        return _target_set.bytes();
      }
 
      template<int dim_>
      TargetSet& get_target_set()
      {
        static_assert(dim_ == 0, "invalid dimension");
        return _target_set;
      }
 
      template<int dim_>
      const TargetSet& get_target_set() const
      {
        static_assert(dim_ == 0, "invalid dimension");
        return _target_set;
      }
 
      Index get_num_entities(int dim) const
      {
        XASSERTM(dim == 0, "invalid dimension parameter");
        return _target_set.get_num_entities();
      }
 
      template<std::size_t np_>
      void permute_map(const std::array<Adjacency::Permutation, np_>& inv_perms)
      {
        _target_set.permute_map(inv_perms.at(0));
      }
 
      static String name()
      {
        return "TargetSetHolder<Vertex>";
      }
    };
  } // namespace Geometry
} // namespace FEAT