Dune::Concept::Grid Concept Reference

Requirements for implementations of the Dune::Grid interface. More...

#include <dune/grid/concepts/grid.hh>

Concept definition

template<class G>
concept Dune::Concept::Grid = 
  GridView<typename G::LeafGridView> &&
  GridView<typename G::LevelGridView> &&
  Intersection<typename G::LeafIntersection> &&
  Intersection<typename G::LevelIntersection> &&
  IntersectionIterator<typename G::LeafIntersectionIterator> &&
  IntersectionIterator<typename G::LevelIntersectionIterator> &&
  IndexSet<typename G::LevelIndexSet> &&
  IndexSet<typename G::LeafIndexSet> &&
  IdSet<typename G::GlobalIdSet> &&
  IdSet<typename G::LocalIdSet> &&
requires(const G cg, int level, int codim, Dune::GeometryType type)
{
  
  { G::dimension      } -> std::convertible_to<int>;
  { G::dimensionworld } -> std::convertible_to<int>;
 
  
  requires std::same_as<G,typename G::LeafGridView::Grid>;
  requires std::same_as<G,typename G::LevelGridView::Grid>;
  typename G::ctype;
  typename G::HierarchicIterator;
 
  
  { cg.maxLevel()            } -> std::convertible_to<int>;
  { cg.size(level, codim)    } -> std::convertible_to<int>;
  { cg.size(codim)           } -> std::convertible_to<int>;
  { cg.size(level, type)     } -> std::convertible_to<int>;
  { cg.size(type)            } -> std::convertible_to<int>;
  { cg.numBoundarySegments() } -> std::convertible_to<std::size_t>;
  { cg.levelGridView(level)  } -> std::same_as<typename G::LevelGridView>;
  { cg.leafGridView()        } -> std::same_as<typename G::LeafGridView>;
  { cg.globalIdSet()         } -> std::same_as<const typename G::GlobalIdSet&>;
  { cg.localIdSet()          } -> std::same_as<const typename G::LocalIdSet&>;
  { cg.levelIndexSet(level)  } -> std::same_as<const typename G::LevelIndexSet&>;
  { cg.leafIndexSet()        } -> std::same_as<const typename G::LeafIndexSet&>;
  { cg.comm()                } -> std::convertible_to<typename G::Communication>;
 
  
  requires requires(G g, int refCount, const typename G::template Codim<0>::Entity& entity)
  {
    { g.mark(refCount,entity)  } -> std::convertible_to<bool>;
    { g.getMark(entity)        } -> std::convertible_to<int>;
    { g.preAdapt()             } -> std::convertible_to<bool>;
    { g.adapt()                } -> std::convertible_to<bool>;
    { g.loadBalance()          } -> std::convertible_to<bool>;
    g.globalRefine(refCount);
    g.postAdapt();
  };
} &&
Impl::GridCodim<G,0> &&
requires (index_constant<1> from, index_constant<G::dimension+1> to) {
  Impl::gridAllCodims<G>(range(from, to).to_integer_sequence());
}

Detailed Description

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>