entity.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_MMESH_INTERFACE_ENTITY_HH
#define DUNE_MMESH_INTERFACE_ENTITY_HH
 
// Dune includes
#include <dune/grid/common/grid.hh>
#include <dune/mmesh/interface/common.hh>
#include <dune/mmesh/interface/incidentiterator.hh>
 
namespace Dune {
// External forward declarations
template <class Grid>
struct HostGridAccess;
 
//**********************************************************************
//
// --MMeshInterfaceGridEntity
// --Entity
//
template <int codim, int dim, class GridImp>
class MMeshInterfaceGridEntity
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    : public EntityDefaultImplementation<codim, dim, GridImp,
                                         MMeshInterfaceGridEntity>
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
{
  template <class GridImp_>
  friend class MMeshInterfaceGridLeafIndexSet;
 
  template <class GridImp_>
  friend class MMeshInterfaceGridLocalIdSet;
 
  template <class GridImp_>
  friend class MMeshInterfaceGridGlobalIdSet;
 
  friend struct HostGridAccess<typename std::remove_const<GridImp>::type>;
 
 private:
  typedef typename GridImp::ctype ctype;
 
  // equivalent entity in the host grid
  typedef typename GridImp::template MMeshInterfaceEntity<codim>
      MMeshInterfaceEntity;
 
  using IdType = MMeshImpl::MultiId;
 
 public:
  typedef typename GridImp::template Codim<codim>::Geometry Geometry;
 
  typedef typename GridImp::template Codim<codim>::EntitySeed EntitySeed;
 
  MMeshInterfaceGridEntity() : grid_(nullptr) {}
 
  MMeshInterfaceGridEntity(const GridImp* grid,
                           const MMeshInterfaceEntity& hostEntity)
      : hostEntity_(hostEntity), grid_(grid) {}
 
  MMeshInterfaceGridEntity(const GridImp* grid,
                           MMeshInterfaceEntity&& hostEntity)
      : hostEntity_(std::move(hostEntity)), grid_(grid) {}
 
  MMeshInterfaceGridEntity(const MMeshInterfaceGridEntity& original)
      : hostEntity_(original.hostEntity_), grid_(original.grid_) {}
 
  MMeshInterfaceGridEntity(MMeshInterfaceGridEntity&& original)
      : hostEntity_(std::move(original.hostEntity_)), grid_(original.grid_) {}
 
  MMeshInterfaceGridEntity& operator=(
      const MMeshInterfaceGridEntity& original) {
    if (this != &original) {
      grid_ = original.grid_;
      hostEntity_ = original.hostEntity_;
    }
    return *this;
  }
 
  MMeshInterfaceGridEntity& operator=(MMeshInterfaceGridEntity&& original) {
    if (this != &original) {
      grid_ = original.grid_;
      hostEntity_ = std::move(original.hostEntity_);
    }
    return *this;
  }
 
  // Comparator for vertices
  template <int cc = codim>
  std::enable_if_t<cc == dim, bool> equals(
      const MMeshInterfaceGridEntity& other) const {
    return hostEntity_ == other.hostEntity_;
  }
 
  // Comparator for edges
  template <int cc = codim>
  std::enable_if_t<cc == 1 && dim == 2, bool> equals(
      const MMeshInterfaceGridEntity& other) const {
    const auto& vh1 = hostEntity_.first->vertex(hostEntity_.second);
    const auto& vh2 = hostEntity_.first->vertex(hostEntity_.third);
    const auto& hostOther_ = other.hostEntity_;
    const auto& vo1 = hostOther_.first->vertex(hostOther_.second);
    const auto& vo2 = hostOther_.first->vertex(hostOther_.third);
 
    return ((vh1 == vo1) && (vh2 == vo2)) || ((vh1 == vo2) && (vh2 == vo1));
  }
 
  bool hasConnectedComponent() const { return false; }
 
  EntitySeed seed() const { return EntitySeed(hostEntity_); }
 
  int level() const {
    // we only have one level
    return 0;
  }
 
  PartitionType partitionType() const {
    return grid().getMMesh().partitionHelper().partitionType(
        grid().entity(hostEntity_));
  }
 
  unsigned int subEntities(unsigned int cc) const {
    if (dim == 1) return (cc == 0) ? 0 : 2;
 
    if (dim == 2) return (cc == 0) ? 0 : 3;
  }
 
  template <int cc>
  std::enable_if_t<cc == codim, typename GridImp::template Codim<cc>::Entity>
  subEntity(std::size_t i) const {
    return *this;
  }
 
  template <int cc>
  std::enable_if_t<cc == codim + 1,
                   typename GridImp::template Codim<cc>::Entity>
  subEntity(std::size_t i) const {
    DUNE_THROW(NotImplemented, "subEntity<1> for codim 1 entity");
    return typename GridImp::template Codim<cc>::Entity();
  }
 
  Geometry geometry() const { return Geometry(hostEntity_); }
 
  GeometryType type() const { return GeometryTypes::simplex(dim - codim); }
 
  bool isInterface() const { return true; }
 
  bool isTip() const {
    if constexpr (codim == dim) {
      if constexpr (dim == 2)
        return false;
      else {
        const auto& hostgrid = grid().getHostGrid();
 
        int count = 0;
        auto circulator = hostgrid.incident_edges(hostEntity_);
        for (std::size_t i = 0; i < CGAL::circulator_size(circulator);
             ++i, ++circulator) {
          // at boundary
          if (hostgrid.is_infinite(circulator)) return false;
 
          if (grid().isInterface(*circulator)) count++;
        }
 
        return (count == 1);
      }
    } else
      DUNE_THROW(NotImplemented, "isTip() for codim != dim");
  };
 
  int boundaryFlag() const {
    if constexpr (codim == dim)
      return hostEntity_->info().boundaryFlag;
    else
      DUNE_THROW(NotImplemented, "boundaryFlag() for codim != dim");
  }
 
  std::size_t insertionLevel() const {
    if constexpr (codim == dim)
      return hostEntity_->info().insertionLevel;
    else
      DUNE_THROW(NotImplemented, "boundaryFlag() for codim != dim");
  }
 
  auto incidentVerticesBegin(bool includeInfinite) const {
    if constexpr (codim == dim) {
      using Impl =
          typename MMeshIncidentVerticesIterator<GridImp>::Implementation;
      return MMeshIncidentVerticesIterator<GridImp>(
          Impl(grid_, hostEntity_, includeInfinite));
    } else
      DUNE_THROW(NotImplemented, "incidentVerticesBegin() for codim != dim");
  }
 
  auto incidentVerticesEnd(bool includeInfinite) const {
    if constexpr (codim == dim) {
      using Impl =
          typename MMeshIncidentVerticesIterator<GridImp>::Implementation;
      return MMeshIncidentVerticesIterator<GridImp>(
          Impl(grid_, hostEntity_, includeInfinite, true));
    } else
      DUNE_THROW(NotImplemented, "incidentVerticesEnd() for codim != dim");
  }
 
  auto incidentInterfaceVerticesBegin() const {
    if constexpr (codim == dim) {
      using Impl = typename MMeshIncidentInterfaceVerticesIterator<
          GridImp>::Implementation;
      return MMeshIncidentInterfaceVerticesIterator<GridImp>(
          Impl(grid_, hostEntity_));
    } else
      DUNE_THROW(NotImplemented,
                 "incidentInterfaceVerticesBegin() for codim != dim");
  }
 
  auto incidentInterfaceVerticesEnd() const {
    if constexpr (codim == dim) {
      using Impl = typename MMeshIncidentInterfaceVerticesIterator<
          GridImp>::Implementation;
      return MMeshIncidentInterfaceVerticesIterator<GridImp>(
          Impl(grid_, hostEntity_, true));
    } else
      DUNE_THROW(NotImplemented,
                 "incidentInterfaceVerticesEnd() for codim != dim");
  }
 
  auto incidentInterfaceElementsBegin() const {
    if constexpr (codim == dim) {
      using Impl = typename MMeshIncidentInterfaceElementsIterator<
          GridImp>::Implementation;
      return MMeshIncidentInterfaceElementsIterator<GridImp>(
          Impl(grid_, hostEntity_));
    } else if constexpr (codim == dim - 1) {
      using Impl = typename MMeshEdgeIncidentInterfaceElementsIterator<
          GridImp>::Implementation;
      return MMeshEdgeIncidentInterfaceElementsIterator<GridImp>(
          Impl(grid_, hostEntity_));
    } else
      DUNE_THROW(NotImplemented,
                 "incidentInterfaceElementsBegin() for codim <= dim-1");
  }
 
  auto incidentInterfaceElementsEnd() const {
    if constexpr (codim == dim) {
      using Impl = typename MMeshIncidentInterfaceElementsIterator<
          GridImp>::Implementation;
      return MMeshIncidentInterfaceElementsIterator<GridImp>(
          Impl(grid_, hostEntity_, true));
    } else if constexpr (codim == dim - 1) {
      using Impl = typename MMeshEdgeIncidentInterfaceElementsIterator<
          GridImp>::Implementation;
      return MMeshEdgeIncidentInterfaceElementsIterator<GridImp>(
          Impl(grid_, hostEntity_, true));
    } else
      DUNE_THROW(NotImplemented,
                 "incidentInterfaceElementsEnd() for codim != dim");
  }
 
  const MMeshInterfaceEntity& hostEntity() const { return hostEntity_; }
 
  IdType id() const {
    if constexpr (codim == dim)
      return hostEntity_->info().id;
    else
      return grid().globalIdSet().id(*this);
  }
 
  const GridImp& grid() const { return *grid_; }
 
 private:
  MMeshInterfaceEntity hostEntity_;
 
  const GridImp* grid_;
};
 
//***********************
//
//  --MMeshInterfaceGridEntity
//
//***********************
template <int dim, class GridImp>
class MMeshInterfaceGridEntity<0, dim, GridImp>
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    : public EntityDefaultImplementation<0, dim, GridImp,
                                         MMeshInterfaceGridEntity>
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
{
  friend struct HostGridAccess<typename std::remove_const<GridImp>::type>;
 
  typedef Entity<0, dim, GridImp, MMeshInterfaceGridEntity> EntityType;
 
 public:
  // equivalent entity in the host grid
  typedef typename GridImp::template MMeshInterfaceEntity<0>
      MMeshInterfaceEntity;
 
  typedef typename GridImp::template MMeshInterfaceEntity<dim>
      MMeshInterfaceVertex;
 
  typedef typename GridImp::template Codim<0>::Geometry Geometry;
 
  typedef typename GridImp::template Codim<0>::LocalGeometry LocalGeometry;
 
  typedef MMeshInterfaceGridLeafIntersectionIterator<GridImp>
      LeafIntersectionIterator;
 
  typedef MMeshHierarchicIterator<GridImp> HierarchicIterator;
 
  typedef typename GridImp::template Codim<0>::EntitySeed EntitySeed;
 
  typedef typename GridImp::ConnectedComponent ConnectedComponent;
 
  using IdType = MMeshImpl::MultiId;
 
  // type of global coordinate
  typedef typename Geometry::GlobalCoordinate GlobalCoordinate;
 
  // type of local coordinate
  typedef typename Geometry::LocalCoordinate LocalCoordinate;
 
  using VertexStorage = std::array<GlobalCoordinate, dim + 1>;
 
  MMeshInterfaceGridEntity() : grid_(nullptr), isLeaf_(true) {}
 
  MMeshInterfaceGridEntity(const GridImp* grid,
                           const MMeshInterfaceEntity& hostEntity)
      : hostEntity_(hostEntity), grid_(grid), isLeaf_(true) {
    if (grid->canBeMirrored(hostEntity_)) {
      const auto mirrored = grid_->mirrorHostEntity(hostEntity_);
      if (hostEntity_.first->info().insertionIndex >
          mirrored.first->info().insertionIndex)
        hostEntity_ = mirrored;
    }
  }
 
  MMeshInterfaceGridEntity(const GridImp* grid,
                           MMeshInterfaceEntity&& hostEntity)
      : hostEntity_(std::move(hostEntity)), grid_(grid), isLeaf_(true) {
    if (grid->canBeMirrored(hostEntity_)) {
      const auto mirrored = grid_->mirrorHostEntity(hostEntity_);
      if (hostEntity_.first->info().insertionIndex >
          mirrored.first->info().insertionIndex)
        hostEntity_ = mirrored;
    }
  }
 
  MMeshInterfaceGridEntity(const GridImp* grid,
                           const MMeshInterfaceEntity& hostEntity,
                           const IdType& id)
      : hostEntity_(hostEntity), id_(id), grid_(grid), isLeaf_(false) {}
 
  MMeshInterfaceGridEntity(const GridImp* grid, const VertexStorage& vertex)
      : id_(/*caching id*/ IdType({std::size_t(-3), std::size_t(-2)})),
        grid_(grid),
        isLeaf_(false),
        vertex_(vertex) {}
 
  MMeshInterfaceGridEntity(const MMeshInterfaceGridEntity& original)
      : hostEntity_(original.hostEntity_),
        id_(original.id_),
        grid_(original.grid_),
        isLeaf_(original.isLeaf_),
        vertex_(original.vertex_) {}
 
  MMeshInterfaceGridEntity(MMeshInterfaceGridEntity&& original)
      : hostEntity_(std::move(original.hostEntity_)),
        id_(original.id_),
        grid_(original.grid_),
        isLeaf_(original.isLeaf_),
        vertex_(original.vertex_) {}
 
  MMeshInterfaceGridEntity& operator=(
      const MMeshInterfaceGridEntity& original) {
    if (this != &original) {
      grid_ = original.grid_;
      hostEntity_ = original.hostEntity_;
      isLeaf_ = original.isLeaf_;
      id_ = original.id_;
      vertex_ = original.vertex_;
    }
    return *this;
  }
 
  MMeshInterfaceGridEntity& operator=(MMeshInterfaceGridEntity&& original) {
    if (this != &original) {
      grid_ = original.grid_;
      hostEntity_ = std::move(original.hostEntity_);
      isLeaf_ = original.isLeaf_;
      id_ = original.id_;
      vertex_ = original.vertex_;
    }
    return *this;
  }
 
  // Comparator for edges
  template <int d = dim>
  std::enable_if_t<d == 1, bool> equals(
      const MMeshInterfaceGridEntity& other) const {
    return hostEntity_ == other.hostEntity_;
  }
 
  // Comparator for facets
  template <int d = dim>
  std::enable_if_t<d == 2, bool> equals(
      const MMeshInterfaceGridEntity& other) const {
    return hostEntity_ == other.hostEntity_;
  }
 
  bool operator==(const MMeshInterfaceGridEntity& other) const {
    return this->equals(other);
  }
 
  bool operator<(const MMeshInterfaceGridEntity& other) const {
    return hostEntity_ < other.hostEntity_;
  }
 
  const ConnectedComponent& connectedComponent() const {
    return grid_->getConnectedComponent(*this);
  }
 
  bool hasConnectedComponent() const {
    return grid_->hasConnectedComponent(*this);
  }
 
  auto father() const {
    DUNE_THROW(InvalidStateException,
               "MMesh entities do no have a father, but a connectedComponent "
               "instead!");
    return *this;
  }
 
  bool hasFather() const { return false; }
 
  void bindFather(const EntityType& father) const { father_ = &father; }
 
  LocalGeometry geometryInFather() const {
    if constexpr (dim != 1)
      DUNE_THROW(NotImplemented, "geometryInFather() for dim != 1");
    else {
      assert(father_ != nullptr);
 
      auto thisPoints = this->vertex_;
 
      if (isLeaf_)
        for (int i = 0; i < 2; ++i) thisPoints[i] = geometry().corner(i);
 
      std::array<LocalCoordinate, 2> local;
      for (int i = 0; i < 2; ++i)
        local[i] = father_->impl().geometry().local(thisPoints[i]);
 
      return LocalGeometry(local);
    }
  }
 
  const bool isNew() const { return hasConnectedComponent(); }
 
  void setIsNew(bool isNew) const {}
 
  const bool mightVanish() const {
    return hostEntity_.first->info().mightVanish;
  }
 
  void setWillVanish(bool mightVanish) const {
    hostEntity_.first->info().mightVanish = mightVanish;
  }
 
  void mark(int refCount) const { hostEntity_.first->info().mark = refCount; }
 
  int getMark() const { return hostEntity_.first->info().mark; }
 
  EntitySeed seed() const { return EntitySeed(hostEntity_); }
 
  int level() const {
    // we only have one level
    return 0;
  }
 
  PartitionType partitionType() const {
    return grid().getMMesh().partitionHelper().partitionType(
        grid().entity(hostEntity_));
  }
 
  Geometry geometry() const {
    if (isLeaf_)
      return Geometry(hostEntity_);
    else
      return Geometry(this->vertex_);
  }
 
  std::size_t subEntities(std::size_t cc) const {
    if (dim == 1) return (cc == 0) ? 1 : 2;
 
    if (dim == 2) return (cc == 0) ? 1 : 3;
  }
 
  template <int cc>
  std::enable_if_t<cc == 0, typename GridImp::template Codim<cc>::Entity>
  subEntity(std::size_t i) const {
    return *this;
  }
 
  template <int cc>
  std::enable_if_t<cc == dim, typename GridImp::template Codim<cc>::Entity>
  subEntity(std::size_t i) const {
    assert(i < subEntities(cc));
 
    auto cgalIndex =
        MMeshInterfaceImpl::computeCGALIndices<MMeshInterfaceEntity, dim>(
            hostEntity_);
    return MMeshInterfaceGridEntity<cc, dim, GridImp>(
        grid_, hostEntity_.first->vertex(cgalIndex[i]));
  }
 
  template <int cc>
  std::enable_if_t<cc == 1 && dim == 2,
                   typename GridImp::template Codim<cc>::Entity>
  subEntity(std::size_t i) const {
    assert(i < subEntities(cc));
 
    auto cgalIndex =
        MMeshInterfaceImpl::computeCGALIndices<MMeshInterfaceEntity, dim>(
            hostEntity_);
    auto cell = hostEntity_.first;
 
    int v1 = cgalIndex[i == 2 ? 1 : 0];
    int v2 = cgalIndex[i == 0 ? 1 : 2];
 
    return MMeshInterfaceGridEntity<cc, dim, GridImp>(
        grid_, CGAL::Triple<decltype(cell), int, int>(cell, v1, v2));
  }
 
  MMeshInterfaceGridLeafIntersectionIterator<GridImp> ileafbegin() const {
    return MMeshInterfaceGridLeafIntersectionIterator<GridImp>(grid_,
                                                               hostEntity_);
  }
 
  MMeshInterfaceGridLeafIntersectionIterator<GridImp> ileafend() const {
    return MMeshInterfaceGridLeafIntersectionIterator<GridImp>(
        grid_, hostEntity_, true);
  }
 
  MMeshInterfaceGridLeafIntersectionIterator<GridImp> ilevelbegin() const {
    return ileafbegin();
  }
 
  MMeshInterfaceGridLeafIntersectionIterator<GridImp> ilevelend() const {
    return ileafend();
  }
 
  MMeshInterfaceGridHierarchicIterator<GridImp> hbegin(int maxlevel) const {
    return MMeshInterfaceGridHierarchicIterator<GridImp>(grid_, *this,
                                                         maxlevel);
  }
 
  MMeshInterfaceGridHierarchicIterator<GridImp> hend(int maxlevel) const {
    return MMeshInterfaceGridHierarchicIterator<GridImp>(grid_, *this, maxlevel,
                                                         true);
  }
 
  bool isLeaf() const { return isLeaf_ && !isNew(); }
 
  bool wasRefined() const { return false; }
 
  bool mightBeCoarsened() const { return false; }
 
  GeometryType type() const { return GeometryTypes::simplex(dim); }
 
  const MMeshInterfaceEntity& hostEntity() const { return hostEntity_; }
 
  const GridImp& grid() const { return *grid_; }
 
  IdType id() const {
    // cache id
    if (id_ == IdType()) {
      typename IdType::VT idlist(dim + 1);
      for (std::size_t i = 0; i < this->subEntities(dim); ++i)
        if (grid_->canBeMirrored(hostEntity_))
          idlist[i] = this->subEntity<dim>(i).impl().hostEntity()->info().id;
        else
          idlist[i] = -i;
      std::sort(idlist.begin(), idlist.end());
      id_ = IdType(idlist);
    }
 
    return id_;
  }
 
 private:
  MMeshInterfaceEntity hostEntity_;
 
  mutable IdType id_;
 
  const GridImp* grid_;
 
  bool isLeaf_;
 
 protected:
  VertexStorage vertex_;
 
  mutable const EntityType* father_;
 
};  // end of MMeshInterfaceGridEntity codim = 0
 
}  // namespace Dune
 
#endif