Simplify mesh creation interface and algorithms

cpp/demo/hyperelasticity/main.cpp

@@ -225,7 +225,7 @@ int main(int argc, char* argv[])
     // stress.
     constexpr auto family = basix::element::family::P;
     const auto cell_type
-        = mesh::cell_type_to_basix_type(mesh->topology()->cell_types()[0]);
+        = mesh::cell_type_to_basix_type(mesh->topology()->cell_type());
     constexpr int k = 0;
     constexpr bool discontinuous = true;
 

cpp/demo/interpolation_different_meshes/main.cpp

@@ -32,14 +32,14 @@ int main(int argc, char* argv[])
                          mesh::CellType::hexahedron));
 
     basix::FiniteElement element_tet = basix::element::create_lagrange<double>(
-        mesh::cell_type_to_basix_type(mesh_tet->topology()->cell_types()[0]), 1,
+        mesh::cell_type_to_basix_type(mesh_tet->topology()->cell_type()), 1,
         basix::element::lagrange_variant::equispaced, false);
     auto V_tet = std::make_shared<fem::FunctionSpace<double>>(
         fem::create_functionspace(mesh_tet, element_tet,
                                   std::vector<std::size_t>{3}));
 
     basix::FiniteElement element_hex = basix::element::create_lagrange<double>(
-        mesh::cell_type_to_basix_type(mesh_hex->topology()->cell_types()[0]), 2,
+        mesh::cell_type_to_basix_type(mesh_hex->topology()->cell_type()), 2,
         basix::element::lagrange_variant::equispaced, false);
     auto V_hex = std::make_shared<fem::FunctionSpace<double>>(
         fem::create_functionspace(mesh_hex, element_hex,

cpp/dolfinx/fem/DirichletBC.cpp

@@ -187,15 +187,11 @@ std::vector<std::int32_t> fem::locate_dofs_topological(
     const mesh::Topology& topology, const DofMap& dofmap, int dim,
     std::span<const std::int32_t> entities, bool remote)
 {
-  auto cell_types = topology.cell_types();
-  if (cell_types.size() > 1)
-  {
-    throw std::runtime_error("Multiple cell types in DirichletBC");
-  }
+  mesh::CellType cell_type = topology.cell_type();
 
   // Prepare an element - local dof layout for dofs on entities of the
   // entity_dim
-  const int num_cell_entities = mesh::cell_num_entities(cell_types.back(), dim);
+  const int num_cell_entities = mesh::cell_num_entities(cell_type, dim);
   std::vector<std::vector<int>> entity_dofs;
   for (int i = 0; i < num_cell_entities; ++i)
   {
@@ -306,13 +302,10 @@ std::array<std::vector<std::int32_t>, 2> fem::locate_dofs_topological(
   // Check that dof layouts are the same
   assert(dofmap0.element_dof_layout() == dofmap1.element_dof_layout());
 
-  auto cell_types = topology.cell_types();
-  if (cell_types.size() > 1)
-  {
-    throw std::runtime_error("Multiple cell types in DirichletBC");
-  }
+  mesh::CellType cell_type = topology.cell_type();
+
   // Build vector of local dofs for each cell entity
-  const int num_cell_entities = mesh::cell_num_entities(cell_types.back(), dim);
+  const int num_cell_entities = mesh::cell_num_entities(cell_type, dim);
   std::vector<std::vector<int>> entity_dofs;
   for (int i = 0; i < num_cell_entities; ++i)
   {

cpp/dolfinx/fem/DofMap.cpp

@@ -223,8 +223,8 @@ std::pair<DofMap, std::vector<std::int32_t>> DofMap::collapse(
       // Create new element dof layout and reset parent
       ElementDofLayout collapsed_dof_layout = layout.copy();
 
-      auto [_index_map, bs, dofmap] = build_dofmap_data(
-          comm, topology, {collapsed_dof_layout}, reorder_fn);
+      auto [_index_map, bs, dofmap]
+          = build_dofmap_data(comm, topology, collapsed_dof_layout, reorder_fn);
       auto index_map
           = std::make_shared<common::IndexMap>(std::move(_index_map));
       return DofMap(layout, index_map, bs, std::move(dofmap), bs);

cpp/dolfinx/fem/Expression.h

@@ -161,10 +161,9 @@ class Expression
     auto x_dofmap = mesh.geometry().dofmap();
 
     // Get geometry data
-    auto cmaps = mesh.geometry().cmaps();
-    assert(cmaps.size() == 1);
+    auto& cmap = mesh.geometry().cmap();
 
-    const std::size_t num_dofs_g = cmaps.back().dim();
+    const std::size_t num_dofs_g = cmap.dim();
     auto x_g = mesh.geometry().x();
 
     // Create data structures used in evaluation

cpp/dolfinx/fem/Function.h

@@ -415,12 +415,7 @@ class Function
     auto map = mesh->topology()->index_map(tdim);
 
     // Get coordinate map
-    if (mesh->geometry().cmaps().size() > 1)
-    {
-      throw std::runtime_error(
-          "Function with multiple geometry maps not implemented.");
-    }
-    const CoordinateElement<geometry_type>& cmap = mesh->geometry().cmaps()[0];
+    const CoordinateElement<geometry_type>& cmap = mesh->geometry().cmap();
 
     // Get geometry data
     auto x_dofmap = mesh->geometry().dofmap();

cpp/dolfinx/fem/FunctionSpace.h

@@ -214,9 +214,7 @@ class FunctionSpace
     const auto [X, Xshape] = _element->interpolation_points();
 
     // Get coordinate map
-    if (_mesh->geometry().cmaps().size() > 1)
-      throw std::runtime_error("Mixed topology not supported");
-    const CoordinateElement<geometry_type>& cmap = _mesh->geometry().cmaps()[0];
+    const CoordinateElement<geometry_type>& cmap = _mesh->geometry().cmap();
 
     // Prepare cell geometry
     auto x_dofmap = _mesh->geometry().dofmap();

cpp/dolfinx/fem/assemble_matrix_impl.h

@@ -426,8 +426,8 @@ void assemble_matrix(
         = coefficients.at({IntegralType::exterior_facet, i});
     impl::assemble_exterior_facets(
         mat_set, x_dofmap, x, a.domain(IntegralType::exterior_facet, i),
-        pre_dof_transform, dofs0, bs0, post_dof_transform, dofs1, bs1, bc0,
-        bc1, fn, coeffs, cstride, constants, cell_info);
+        pre_dof_transform, dofs0, bs0, post_dof_transform, dofs1, bs1, bc0, bc1,
+        fn, coeffs, cstride, constants, cell_info);
   }
 
   if (a.num_integrals(IntegralType::interior_facet) > 0)
@@ -443,11 +443,9 @@ void assemble_matrix(
     else
       get_perm = [](std::size_t) { return 0; };
 
-    auto cell_types = mesh->topology()->cell_types();
-    if (cell_types.size() > 1)
-      throw std::runtime_error("Multiple cell types in the assembler.");
-    int num_cell_facets = mesh::cell_num_entities(cell_types.back(),
-                                                  mesh->topology()->dim() - 1);
+    mesh::CellType cell_type = mesh->topology()->cell_type();
+    int num_cell_facets
+        = mesh::cell_num_entities(cell_type, mesh->topology()->dim() - 1);
     const std::vector<int> c_offsets = a.coefficient_offsets();
     for (int i : a.integral_ids(IntegralType::interior_facet))
     {
@@ -457,9 +455,9 @@ void assemble_matrix(
           = coefficients.at({IntegralType::interior_facet, i});
       impl::assemble_interior_facets(
           mat_set, x_dofmap, x, num_cell_facets,
-          a.domain(IntegralType::interior_facet, i), pre_dof_transform, *dofmap0,
-          bs0, post_dof_transform, *dofmap1, bs1, bc0, bc1, fn, coeffs,
-          cstride, c_offsets, constants, cell_info, get_perm);
+          a.domain(IntegralType::interior_facet, i), pre_dof_transform,
+          *dofmap0, bs0, post_dof_transform, *dofmap1, bs1, bc0, bc1, fn,
+          coeffs, cstride, c_offsets, constants, cell_info, get_perm);
     }
   }
 }

cpp/dolfinx/fem/assemble_scalar_impl.h

@@ -196,11 +196,9 @@ T assemble_scalar(
     mesh->topology_mutable()->create_entity_permutations();
     const std::vector<std::uint8_t>& perms
         = mesh->topology()->get_facet_permutations();
-    auto cell_types = mesh->topology()->cell_types();
-    if (cell_types.size() > 1)
-      throw std::runtime_error("Multiple cell types in the assembler");
-    int num_cell_facets = mesh::cell_num_entities(cell_types.back(),
-                                                  mesh->topology()->dim() - 1);
+    mesh::CellType cell_type = mesh->topology()->cell_type();
+    int num_cell_facets
+        = mesh::cell_num_entities(cell_type, mesh->topology()->dim() - 1);
     const std::vector<int> c_offsets = M.coefficient_offsets();
     for (int i : M.integral_ids(IntegralType::interior_facet))
     {

cpp/dolfinx/fem/assemble_vector_impl.h

@@ -841,11 +841,9 @@ void lift_bc(std::span<T> b, const Form<T, U>& a, mdspan2_t x_dofmap,
     else
       get_perm = [](std::size_t) { return 0; };
 
-    auto cell_types = mesh->topology()->cell_types();
-    if (cell_types.size() > 1)
-      throw std::runtime_error("Multiple cell types in the assembler");
-    int num_cell_facets = mesh::cell_num_entities(cell_types.back(),
-                                                  mesh->topology()->dim() - 1);
+    mesh::CellType cell_type = mesh->topology()->cell_type();
+    int num_cell_facets
+        = mesh::cell_num_entities(cell_type, mesh->topology()->dim() - 1);
     for (int i : a.integral_ids(IntegralType::interior_facet))
     {
       auto kernel = a.kernel(IntegralType::interior_facet, i);
@@ -1049,11 +1047,9 @@ void assemble_vector(
     else
       get_perm = [](std::size_t) { return 0; };
 
-    auto cell_types = mesh->topology()->cell_types();
-    if (cell_types.size() > 1)
-      throw std::runtime_error("Multiple cell types in the assembler");
-    int num_cell_facets = mesh::cell_num_entities(cell_types.back(),
-                                                  mesh->topology()->dim() - 1);
+    mesh::CellType cell_type = mesh->topology()->cell_type();
+    int num_cell_facets
+        = mesh::cell_num_entities(cell_type, mesh->topology()->dim() - 1);
     for (int i : L.integral_ids(IntegralType::interior_facet))
     {
       auto fn = L.kernel(IntegralType::interior_facet, i);

cpp/dolfinx/fem/discreteoperators.h

@@ -199,10 +199,7 @@ void interpolation_matrix(const FunctionSpace<U>& V0,
   const std::size_t value_size1 = e1->value_size() / bs1;
 
   // Get geometry data
-  auto cmaps = mesh->geometry().cmaps();
-  assert(cmaps.size() == 1);
-
-  const CoordinateElement<U>& cmap = cmaps.back();
+  const CoordinateElement<U>& cmap = mesh->geometry().cmap();
   auto x_dofmap = mesh->geometry().dofmap();
   const std::size_t num_dofs_g = cmap.dim();
   std::span<const U> x_g = mesh->geometry().x();