Grid Concepts

Collaboration diagram for 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.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. 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. More...

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.

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.

Note

The type typename E::template Codim<0>Entity is required to satisfy the EntityGeneral concept only if the type exists (i.e. substitution failure is allowed).

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

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.

GridView

template<class GV >

concept Dune::Concept::GridView

Model of a grid view.

Dune::GridView is a template for this model

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

Note

The type typename IS::template Codim<0>Entity is required to satisfy the EntityGeneral concept only if the type exists (i.e. substitution failure is allowed).

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::convertible_to<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

Note

The type typename IS::template Codim<0>Entity is required to satisfy the EntityGeneral concept only if the type exists (i.e. substitution failure is allowed).

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

MessageBuffer

template<class MB , class DataType >

concept Dune::Concept::MessageBuffer

Initial value:

= requires(MB mb, DataType& data)
{
  mb.write(data);
  mb.read(data);
}

Model of a message buffer.