cachingentity.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_CACHINGENTITY_HH
#define DUNE_MMESH_INTERFACE_CACHINGENTITY_HH
 
#include <set>
 
// Dune includes
#include <dune/grid/common/grid.hh>
 
// MMesh includes
#include <dune/mmesh/grid/multiid.hh>
#include <dune/mmesh/grid/pointfieldvector.hh>
 
namespace Dune {
// Forward declarations
template <int codim, int dim, class GridImp>
class MMeshInterfaceCachingEntity;
 
//**********************************************************************
//
// --MMeshInterfaceCachingEntity
// --Entity
//
template <int dim, class GridImp>
class MMeshInterfaceCachingEntity<0, dim, GridImp>
    : public MMeshInterfaceGridEntity<0, dim, GridImp> {
  template <class GridImp_>
  friend class MMeshInterfaceGridLeafIndexSet;
 
  template <class GridImp_>
  friend class MMeshInterfaceGridLocalIdSet;
 
  template <class GridImp_>
  friend class MMeshInterfaceGridGlobalIdSet;
 
 private:
  // this type
  typedef MMeshInterfaceCachingEntity<0, dim, GridImp> ThisType;
 
  // base type
  typedef MMeshInterfaceGridEntity<0, dim, GridImp> BaseType;
 
  // type of scalars
  typedef typename GridImp::ctype ctype;
 
  // type of the host grid
  typedef typename GridImp::HostGridType HostGrid;
 
  // type of entity
  typedef typename GridImp::template Codim<0>::Entity Element;
 
  // standard MMesh entity implementation
  typedef typename GridImp::template Codim<0>::Entity MMeshEntity;
 
  // type of ids
  typedef MMeshImpl::MultiId IdType;
 
 public:
  // geometry type
  typedef AffineGeometry<ctype, dim, dim + 1> Geometry;
 
  // type of global coordinate
  typedef typename Geometry::GlobalCoordinate GlobalCoordinate;
 
  MMeshInterfaceCachingEntity() = delete;
 
  explicit MMeshInterfaceCachingEntity(const Element& element)
      : BaseType(&element.impl().grid(), element.impl().hostEntity(),
                 element.impl().grid().globalIdSet().id(element)) {
    for (int i = 0; i < dim + 1; ++i)
      this->vertex_[i] = element.geometry().corner(i);
  }
 
  bool equals(const MMeshInterfaceCachingEntity& other) const {
    return this->id_ == other.id_;
  }
 
  bool operator==(const MMeshInterfaceCachingEntity& other) const {
    return this->equals(other);
  }
 
  bool operator==(const MMeshEntity& entity) const {
    return this->id_ == entity.impl().grid()->globalIdSet().id(entity);
  }
 
  bool operator<(const MMeshInterfaceCachingEntity& other) const {
    return this->id_ < other.id_;
  }
 
  bool hasFather() const { return false; }
 
  const bool isNew() const { return false; }
 
  const bool mightVanish() const { return true; }
 
  int level() const {
    // we only have one level
    return 0;
  }
 
  PartitionType partitionType() const {
    return PartitionType::InteriorEntity; /* dummy */
  }
 
  Geometry geometry() const {
    return Geometry(GeometryTypes::simplex(dim), this->vertex_);
  }
 
  unsigned int subEntities(unsigned int cc) const {
    // we have a simplex grid
    int n = dim + 1;
    int k = dim - cc + 1;
 
    // binomial: n over k
    int binomial = 1;
    for (int i = n - k + 1; i <= n; i++) binomial *= i;
    for (long i = 2; i <= k; i++) binomial /= i;
 
    return binomial;
  }
 
  bool isLeaf() const { return false; }
 
  // calculates the intersection volume with another entity
  ctype intersectionVolume(const MMeshEntity& entity) const {
    // assuming simple components (of 2 entities)
    return std::min(geometry().volume(), entity.geometry().volume());
  }
 
};  // end of MMeshInterfaceCachingEntity codim = 0
 
}  // namespace Dune
 
#endif