Grid Concepts

Variables
template<class S >
concept	Dune::Concept::EntitySeed
	Model of an entity seed. More...
template<class E >
concept	Dune::Concept::EntityGeneral
	Model of a grid entity for any codimension. More...
template<class E >
concept	Dune::Concept::EntityExtended
	Model of a grid entity with extended requirements for codimension 0. More...
template<class E >
concept	Dune::Concept::Entity = EntityGeneral<E> && ((E::codimension != 0) || EntityExtended<E>)
	Model of a grid entity. More...
template<class It >
concept	Dune::Concept::EntityIterator
	Model of an entity iterator. More...
template<class G >
concept	Dune::Concept::Geometry
	Model of a geometry object. More...
template<class G >
concept	Dune::Concept::Grid
	Requirements for implementations of the Dune::Grid interface. More...
template<class GV >
concept	Dune::Concept::GridView
	Model of a grid view. More...
template<class IS >
concept	Dune::Concept::IndexSet
	Model of an index set. More...
template<class IS >
concept	Dune::Concept::IdSet
	Model of an id set. More...
template<class I >
concept	Dune::Concept::Intersection
	Model of an intersection. More...
template<class It >
concept	Dune::Concept::IntersectionIterator
	Model of an intersection iterator. More...
template<class MB , class DataType >
concept	Dune::Concept::MessageBuffer
	Model of a message buffer.

Detailed Description

Description

This group gathers several concepts related to grids.

Variable Documentation

Entity

template<class E >

concept Dune::Concept::Entity = EntityGeneral<E> && ((E::codimension != 0) || EntityExtended<E>)

Model of a grid entity.

Codimension 0 entities are required to have an extended interface. Dune::Entity is a template for this model.

Referenced by Dune::YaspIntersection< GridImp >::inside(), and Dune::YaspIntersection< GridImp >::outside().

EntityExtended

template<class E >

concept Dune::Concept::EntityExtended

Initial value:

= EntityGeneral<E> &&
  Geometry<typename E::LocalGeometry> &&
requires(const E e, int maxLevel)
{
  requires (E::codimension == 0);
  { e.father()                   } -> std::same_as<E>;
  { e.hasFather()                } -> std::convertible_to<bool>;
  { e.isLeaf()                   } -> std::convertible_to<bool>;
  { e.isRegular()                } -> std::convertible_to<bool>;
  { e.geometryInFather()         } -> std::same_as<typename E::LocalGeometry>;
  { e.hbegin(maxLevel)           } -> std::same_as<typename E::HierarchicIterator>;
  { e.hend(maxLevel)             } -> std::same_as<typename E::HierarchicIterator>;
  { e.isNew()                    } -> std::convertible_to<bool>;
  { e.mightVanish()              } -> std::convertible_to<bool>;
  { e.hasBoundaryIntersections() } -> std::convertible_to<bool>;
 
  requires std::same_as<E, typename E::template Codim<0>::Entity>;
} &&
Impl::EntityCodimExtended<E,0> &&
requires (index_constant<1> from, index_constant<E::dimension+1> to) {
  Impl::entityAllCodimsExtended<E>(range(from, to).to_integer_sequence());
}

Model of a grid entity with extended requirements for codimension 0.

Dune::Entity of codimension 0 is a template for this model.

EntityGeneral

template<class E >

concept Dune::Concept::EntityGeneral

Initial value:

= std::regular<E> &&
  Geometry<typename E::Geometry> &&
  EntitySeed<typename E::EntitySeed> &&
requires(const E e, unsigned int codim)
{
  requires E::mydimension == (E::dimension - E::codimension);
  { e.level()            } -> std::convertible_to<int>;
  { e.partitionType()    } -> std::same_as<Dune::PartitionType>;
  { e.geometry()         } -> std::same_as<typename E::Geometry>;
  { e.type()             } -> std::same_as<Dune::GeometryType>;
  { e.subEntities(codim) } -> std::convertible_to<unsigned int>;
  { e.seed()             } -> std::same_as<typename E::EntitySeed>;
}

Model of a grid entity for any codimension.

Dune::Entity is a template for this model.

EntityIterator

template<class It >

concept Dune::Concept::EntityIterator

Initial value:

=
  std::forward_iterator<It> &&
  std::default_initializable<It> &&
  Entity<typename It::Entity>

Model of an entity iterator.

Dune::EntityIterator is a template for this model

EntitySeed

template<class S >

concept Dune::Concept::EntitySeed

Initial value:

= std::semiregular<S> && requires(const S seed)
{
  { S::codimension  } -> std::convertible_to<int>;
  { seed.isValid()  } -> std::convertible_to<bool>;
}

Model of an entity seed.

Dune::EntitySeed is a template for this model

Geometry

template<class G >

concept Dune::Concept::Geometry

Initial value:

= requires(const G g, typename G::GlobalCoordinate global, typename G::LocalCoordinate local)
{
  typename G::ctype;
  { G::mydimension                     } -> std::convertible_to<int>;
  { G::coorddimension                  } -> std::convertible_to<int>;
  { g.type()                           } -> std::same_as<Dune::GeometryType>;
  { g.affine()                         } -> std::convertible_to<bool>;
  { g.corners()                        } -> std::convertible_to<int>;
  { g.corner( int{})              } -> std::convertible_to<typename G::GlobalCoordinate>;
  { g.global(local)                    } -> std::convertible_to<typename G::GlobalCoordinate>;
  { g.local(global)                    } -> std::convertible_to<typename G::LocalCoordinate>;
  { g.integrationElement(local)        } -> std::convertible_to<typename G::Volume>;
  { g.volume()                         } -> std::convertible_to<typename G::Volume>;
  { g.center()                         } -> std::convertible_to<typename G::GlobalCoordinate>;
  { g.jacobian(local)                  } -> std::convertible_to<typename G::Jacobian>;
  { g.jacobianInverse(local)           } -> std::convertible_to<typename G::JacobianInverse>;
  { g.jacobianTransposed(local)        } -> std::convertible_to<typename G::JacobianTransposed>;
  { g.jacobianInverseTransposed(local) } -> std::convertible_to<typename G::JacobianInverseTransposed>;
  { referenceElement(g)                } -> ReferenceElement;
}

Model of a geometry object.

Dune::Geometry is a template for this model

Referenced by Dune::HierarchicSearch< Grid, IS >::findEntity(), Dune::AlbertaGridEntity< codim, dim, Grid >::geometry(), Dune::GeoGrid::EntityBase< codim, Grid, false >::geometry(), Dune::GeoGrid::EntityBase< codim, Grid, true >::geometry(), and Dune::YaspIntersection< GridImp >::geometry().

Grid

template<class G >

concept Dune::Concept::Grid

Requirements for implementations of the Dune::Grid interface.

The Grid concept defines interface requirements of a parallel, in general nonconforming, locally refined and hierarchical finite element mesh. It consists of sub-concepts for Dune::Concept::GridView, Dune::Concept::IndexSet, Dune::Concept::IdSet, and Dune::Concept::Intersection.

See Dune::Grid for an "abstract" interface definition of this concept.

Models:

• Dune::AlbertaGrid<dim,dow>
• Dune::GeometryGrid<G,F> if G is a model of Dune::Concept::Grid.
• Dune::IdentityGrid<G> if G is a model of Dune::Concept::Grid.
• Dune::OneDGrid
• Dune::UGGrid<dim>
• Dune::YaspGrid<dim, Coordinates>

Examples

recipe-integration.cc, and recipe-iterate-over-grid.cc.

Referenced by Dune::BackupRestoreFacility< YaspGrid< dim, TensorProductCoordinates< ctype, dim > > >::restore().

GridView

template<class GV >

concept Dune::Concept::GridView

Initial value:

= std::copyable<GV> &&
  IndexSet<typename GV::IndexSet> &&
  Intersection<typename GV::Intersection> &&
  IntersectionIterator<typename GV::IntersectionIterator> &&
requires(const GV gv, int codim, Dune::GeometryType type)
{
  typename GV::Traits;
  typename GV::ctype;
  { GV::conforming        } -> std::convertible_to<bool>;
  { GV::dimension         } -> std::convertible_to<int>;
  { GV::dimensionworld    } -> std::convertible_to<int>;
  { gv.grid()             } -> std::same_as<const typename GV::Grid&>;
  { gv.indexSet()         } -> std::same_as<const typename GV::IndexSet&>;
  { gv.size(codim)        } -> std::convertible_to<int>;
  { gv.size(type)         } -> std::convertible_to<int>;
  { gv.comm()             } -> std::convertible_to<typename GV::Communication>;
  { gv.overlapSize(codim) } -> std::convertible_to<int>;
  { gv.ghostSize(codim)   } -> std::convertible_to<int>;
 
  requires requires(Archetypes::CommDataHandle<std::byte>& handle,
                    InterfaceType iface, CommunicationDirection dir)
  {
    gv.communicate(handle, iface, dir);
  };
} &&
Impl::GridViewCodim<GV,0> &&
requires (index_constant<1> from, index_constant<GV::dimension+1> to) {
  Impl::gridViewAllCodims<GV>(range(from, to).to_integer_sequence());
}

Model of a grid view.

Dune::GridView is a template for this model

Referenced by Dune::GridPtr< GridType >::parameters().

IdSet

template<class IS >

concept Dune::Concept::IdSet

Initial value:

= requires(const IS is, const typename IS::template Codim<0>::Entity& entity, int i, unsigned int cc)
{
  requires Hashable<typename IS::IdType>;
  requires std::totally_ordered<typename IS::IdType>;
  { is.subId(entity,i,cc) } -> std::same_as<typename IS::IdType>;
} &&
Impl::IdSetEntityCodim<IS,0> &&
requires (index_constant<1> from, index_constant<IS::dimension+1> to) {
  Impl::idSetEntityAllCodims<IS>(range(from, to).to_integer_sequence());
}

Model of an id set.

Dune::Grid::GlobalIdSet and Dune::Grid::LocalIdSet are templates for this model

IndexSet

template<class IS >

concept Dune::Concept::IndexSet

Initial value:

= requires(const IS is, Dune::GeometryType type, int codim)
{
  { IS::dimension   } -> std::convertible_to<int>;
 
  requires RandomAccessContainer<typename IS::Types>;
  { is.types(codim) } -> std::same_as<typename IS::Types>;
 
  requires std::integral<typename IS::IndexType>;
  { is.size(type)   } -> std::convertible_to<typename IS::IndexType>;
  { is.size(codim)  } -> std::convertible_to<typename IS::IndexType>;
} &&
Impl::IndexSetEntityCodim<IS,0> &&
requires (index_constant<1> from, index_constant<IS::dimension+1> to) {
  Impl::indexSetEntityAllCodims<IS>(range(from, to).to_integer_sequence());
}

Model of an index set.

Dune::Grid::LevelIndexSet and Dune::Grid::LeafIndexSet are templates for this model

Referenced by Dune::fillGridViewInfoSerial().

Intersection

template<class I >

concept Dune::Concept::Intersection

Initial value:

= std::regular<I> &&
  EntityGeneral<typename I::Entity> &&
  Geometry<typename I::Geometry> &&
  Geometry<typename I::LocalGeometry> &&
requires(const I i, typename I::LocalCoordinate local)
{
  typename I::ctype;
  { I::mydimension                  } -> std::convertible_to<int>;
  { I::dimensionworld               } -> std::convertible_to<int>;
  { i.boundary()                    } -> std::convertible_to<bool>;
  { i.boundarySegmentIndex()        } -> std::convertible_to<std::size_t>;
  { i.neighbor()                    } -> std::convertible_to<bool>;
  { i.inside()                      } -> std::same_as<typename I::Entity>;
  { i.outside()                     } -> std::same_as<typename I::Entity>;
  { i.conforming()                  } -> std::convertible_to<bool>;
  { i.geometryInInside()            } -> std::same_as<typename I::LocalGeometry>;
  { i.geometryInOutside()           } -> std::same_as<typename I::LocalGeometry>;
  { i.geometry()                    } -> std::same_as<typename I::Geometry>;
  { i.type()                        } -> std::same_as<Dune::GeometryType>;
  { i.indexInInside()               } -> std::convertible_to<int>;
  { i.indexInOutside()              } -> std::convertible_to<int>;
  { i.outerNormal(local)            } -> std::convertible_to<typename I::GlobalCoordinate>;
  { i.integrationOuterNormal(local) } -> std::convertible_to<typename I::GlobalCoordinate>;
  { i.unitOuterNormal(local)        } -> std::convertible_to<typename I::GlobalCoordinate>;
  { i.centerUnitOuterNormal()       } -> std::convertible_to<typename I::GlobalCoordinate>;
}

Model of an intersection.

Dune::Grid::Intersection is a template for this model

IntersectionIterator

template<class It >

concept Dune::Concept::IntersectionIterator

Initial value:

=
  std::forward_iterator<It> &&
  std::default_initializable<It> &&
  Intersection<typename It::Intersection>

Model of an intersection iterator.

Dune::IntersectionIterator is a template for this model

Referenced by Dune::EntityDefaultImplementation< 0, dim, GridImp, EntityImp >::hasBoundaryIntersections(), and Dune::printGrid().