Make low-level default args not-default (#4082)

* Start fixing default args

* Fixes

* Fixes

* Update tests

* Lint

* Type hint fixes

* mypy updates

* Small fix

* Fixes

* Fixes

* Doc fixes

* Small updates

Author: garth-wells

cpp/dolfinx/mesh/generation.h

@@ -117,7 +117,7 @@ Mesh<T> create_box(MPI_Comm comm, MPI_Comm subcomm,
   }
 
   if (!partitioner and dolfinx::MPI::size(comm) > 1)
-    partitioner = create_cell_partitioner();
+    partitioner = create_cell_partitioner(mesh::GhostMode::none, 2);
 
   switch (celltype)
   {
@@ -193,7 +193,7 @@ Mesh<T> create_rectangle(MPI_Comm comm, std::array<std::array<T, 2>, 2> p,
   }
 
   if (!partitioner and dolfinx::MPI::size(comm) > 1)
-    partitioner = create_cell_partitioner();
+    partitioner = create_cell_partitioner(mesh::GhostMode::none, 2);
 
   switch (celltype)
   {
@@ -262,7 +262,7 @@ Mesh<T> create_interval(MPI_Comm comm, std::int64_t n, std::array<T, 2> p,
   }
 
   if (!partitioner and dolfinx::MPI::size(comm) > 1)
-    partitioner = create_cell_partitioner(ghost_mode);
+    partitioner = create_cell_partitioner(ghost_mode, 2);
 
   fem::CoordinateElement<T> element(CellType::interval, 1);
   if (dolfinx::MPI::rank(comm) == 0)

cpp/dolfinx/mesh/graphbuild.h

@@ -29,8 +29,8 @@ enum class CellType : std::int8_t;
 /// matched facet is not connected any cells on other processes. All
 /// facets connected to less than `max_facet_to_cell_links` cells are
 /// considered *unmatched* and parallel communication will check for
-/// further connections. Defaults to `2`, which covers non-branching
-/// manifold meshes. Passing std::nullopt (no upper bound) corresponds
+/// further connections. Equal to `2` for non-branching manifold meshes.
+/// Passing std::nullopt (no upper bound) corresponds.
 /// to `max_facet_to_cell_links`=∞, i.e. every facet is considered
 /// unmatched.
 ///
@@ -60,7 +60,7 @@ std::tuple<graph::AdjacencyList<std::int32_t>, std::vector<std::int64_t>,
            std::size_t, std::vector<std::int32_t>>
 build_local_dual_graph(std::span<const CellType> celltypes,
                        const std::vector<std::span<const std::int64_t>>& cells,
-                       std::optional<std::int32_t> max_facet_to_cell_links = 2);
+                       std::optional<std::int32_t> max_facet_to_cell_links);
 
 /// @brief Build distributed mesh dual graph (cell-cell connections via
 /// facets) from minimal mesh data.
@@ -96,6 +96,6 @@ build_local_dual_graph(std::span<const CellType> celltypes,
 graph::AdjacencyList<std::int64_t>
 build_dual_graph(MPI_Comm comm, std::span<const CellType> celltypes,
                  const std::vector<std::span<const std::int64_t>>& cells,
-                 std::optional<std::int32_t> max_facet_to_cell_links = 2);
+                 std::optional<std::int32_t> max_facet_to_cell_links);
 
 } // namespace dolfinx::mesh

cpp/dolfinx/mesh/utils.cpp

@@ -109,7 +109,7 @@ mesh::CellPartitionFunction mesh::create_cell_partitioner(
     spdlog::info("Compute partition of cells across ranks");
 
     // Compute distributed dual graph (for the cells on this process)
-    const graph::AdjacencyList dual_graph
+    graph::AdjacencyList dual_graph
         = build_dual_graph(comm, cell_types, cells, max_facet_to_cell_links);
 
     // Just flag any kind of ghosting for now
@@ -120,6 +120,14 @@ mesh::CellPartitionFunction mesh::create_cell_partitioner(
   };
 }
 //-----------------------------------------------------------------------------
+mesh::CellPartitionFunction mesh::create_cell_partitioner(
+    mesh::GhostMode ghost_mode,
+    std::optional<std::int32_t> max_facet_to_cell_links)
+{
+  return create_cell_partitioner(ghost_mode, &graph::partition_graph,
+                                 max_facet_to_cell_links);
+}
+//-----------------------------------------------------------------------------
 std::vector<std::int32_t>
 mesh::compute_incident_entities(const Topology& topology,
                                 std::span<const std::int32_t> entities, int d0,

cpp/dolfinx/mesh/utils.h

@@ -227,20 +227,23 @@ using CellReorderFunction = std::function<std::vector<std::int32_t>(
 /// TODO: offload to cpp?
 inline auto
 create_boundary_vertices_fn(const CellReorderFunction& reorder_fn,
-                            std::optional<std::int32_t> max_facet_to_cell_links
-                            = 2)
+                            std::optional<std::int32_t> max_facet_to_cell_links)
 {
-  /// brief Function that computes the process boundary vertices of a mesh
-  /// during creation.
-  /// param[in] celltypes List of celltypes in mesh.
-  /// param[in] doflayouts List of DOF layouts in mesh.
-  /// param[in] ghost_owners List of ghost owner per cell per celltype.
-  /// param[out] cells List of cells per celltpye. Reorderd during call.
-  /// param[out] cells_v List of vertices (no higher order nodes) of cell per
-  /// celltype. Reordered during call.
-  /// param[out] original_idx Contains the permutation applied to the cells per
-  /// celltype.
-  /// return Boundary vertices (for all cell types).
+  /// @cond
+  /// @brief Function that computes the process boundary vertices of a
+  /// mesh during creation.
+  ///
+  /// @param[in] celltypes List of celltypes in mesh.
+  /// @param[in] doflayouts List of DOF layouts in mesh.
+  /// @param[in] ghost_owners List of ghost owner per cell per celltype.
+  /// @param[out] cells List of cells per celltpye. Reorderd during
+  /// call.
+  /// @param[out] cells_v List of vertices (no higher order nodes) of
+  /// cell per celltype. Reordered during call.
+  /// @param[out] original_idx Contains the permutation applied to the
+  /// cells per celltype.
+  /// @return Boundary vertices (for all cell types).
+  /// @endcond
   return [&, max_facet_to_cell_links](
              const std::vector<CellType>& celltypes,
              const std::vector<fem::ElementDofLayout>& doflayouts,
@@ -955,17 +958,32 @@ entities_to_geometry(const Mesh<T>& mesh, int dim,
 /// @brief Create a function that computes destination rank for mesh
 /// cells on this rank by applying the default graph partitioner to the
 /// dual graph of the mesh.
+///
 /// @param[in] ghost_mode ghost mode of the created mesh, defaults to none
 /// @param[in] partfn Partitioning function for distributing cells
 /// across MPI ranks.
 /// @param[in] max_facet_to_cell_links Bound on the number of cells a
-/// facet needs to be connected to to be considered *matched* (not on boundary
-/// for non-branching meshes).
+/// facet needs to be connected to to be considered *matched* (not on
+/// boundary for non-branching meshes).
 /// @return Function that computes the destination ranks for each cell.
-CellPartitionFunction create_cell_partitioner(
-    mesh::GhostMode ghost_mode = mesh::GhostMode::none,
-    const graph::partition_fn& partfn = &graph::partition_graph,
-    std::optional<std::int32_t> max_facet_to_cell_links = 2);
+CellPartitionFunction
+create_cell_partitioner(mesh::GhostMode ghost_mode,
+                        const graph::partition_fn& partfn,
+                        std::optional<std::int32_t> max_facet_to_cell_links);
+
+/// @brief Create a function that computes destination rank for mesh
+/// cells on this rank by applying the default graph partitioner to the
+/// dual graph of the mesh.
+///
+/// @param[in] ghost_mode ghost mode of the created mesh, defaults to none
+/// @param[in] max_facet_to_cell_links Bound on the number of cells a
+/// facet needs to be connected to to be considered *matched* (not on
+/// boundary for non-branching meshes).
+/// @return Function that computes the destination ranks for each cell.
+CellPartitionFunction
+create_cell_partitioner(mesh::GhostMode ghost_mode,
+                        std::optional<std::int32_t> max_facet_to_cell_links
+                        = 2);
 
 /// @brief Compute incident entities.
 /// @param[in] topology The topology.
@@ -1244,7 +1262,7 @@ Mesh<typename std::remove_reference_t<typename U::value_type>> create_mesh(
         typename std::remove_reference_t<typename U::value_type>>& element,
     MPI_Comm commg, const U& x, std::array<std::size_t, 2> xshape,
     const CellPartitionFunction& partitioner,
-    std::optional<std::int32_t> max_facet_to_cell_links = 2,
+    std::optional<std::int32_t> max_facet_to_cell_links,
     const CellReorderFunction& reorder_fn = graph::reorder_gps)
 {
   return create_mesh(comm, commt, std::vector{cells}, std::vector{element},
@@ -1287,9 +1305,10 @@ create_mesh(MPI_Comm comm, std::span<const std::int64_t> cells,
   }
   else
   {
-    return create_mesh(comm, comm, std::vector{cells}, std::vector{elements},
-                       comm, x, xshape, create_cell_partitioner(ghost_mode),
-                       max_facet_to_cell_links);
+    return create_mesh(
+        comm, comm, std::vector{cells}, std::vector{elements}, comm, x, xshape,
+        create_cell_partitioner(ghost_mode, max_facet_to_cell_links),
+        max_facet_to_cell_links);
   }
 }
 

cpp/dolfinx/refinement/refine.h

@@ -74,7 +74,7 @@ create_identity_partitioner(const mesh::Mesh<T>& parent_mesh,
     if (comm == MPI_COMM_NULL)
       return graph::regular_adjacency_list(std::move(destinations), 1);
 
-    auto dual_graph = mesh::build_dual_graph(comm, cell_types, cells);
+    auto dual_graph = mesh::build_dual_graph(comm, cell_types, cells, 2);
     std::vector<std::int32_t> node_disp(MPI::size(comm) + 1, 0);
     std::int32_t local_size = dual_graph.num_nodes();
     MPI_Allgather(&local_size, 1, dolfinx::MPI::mpi_t<std::int32_t>,
@@ -153,7 +153,7 @@ refine(const mesh::Mesh<T>& mesh,
   mesh::Mesh<T> mesh1 = mesh::create_mesh(
       mesh.comm(), mesh.comm(), cell_adj.array(), mesh.geometry().cmap(),
       mesh.comm(), new_vertex_coords, xshape,
-      std::get<mesh::CellPartitionFunction>(partitioner));
+      std::get<mesh::CellPartitionFunction>(partitioner), 2);
 
   // Report the number of refined cells
   const int D = topology->dim();

cpp/dolfinx/refinement/uniform.h

@@ -19,6 +19,6 @@ template <typename T>
 mesh::Mesh<T>
 uniform_refine(const mesh::Mesh<T>& mesh,
                const mesh::CellPartitionFunction& partitioner
-               = mesh::create_cell_partitioner(mesh::GhostMode::none));
+               = mesh::create_cell_partitioner(mesh::GhostMode::none, 2));
 
 } // namespace dolfinx::refinement

cpp/test/matrix.cpp

@@ -30,7 +30,7 @@ namespace
 template <std::floating_point T>
 la::MatrixCSR<T> create_operator(MPI_Comm comm)
 {
-  auto part = mesh::create_cell_partitioner(mesh::GhostMode::none);
+  auto part = mesh::create_cell_partitioner(mesh::GhostMode::none, 2);
   auto mesh = std::make_shared<mesh::Mesh<T>>(
       mesh::create_box(comm, {{{0.0, 0.0, 0.0}, {1.0, 1.0, 1.0}}}, {12, 12, 12},
                        mesh::CellType::tetrahedron, part));
@@ -66,7 +66,7 @@ void test_matrix_norm()
 void test_matrix_apply()
 {
   MPI_Comm comm = MPI_COMM_WORLD;
-  auto part = mesh::create_cell_partitioner(mesh::GhostMode::none);
+  auto part = mesh::create_cell_partitioner(mesh::GhostMode::none, 2);
   auto mesh = std::make_shared<mesh::Mesh<double>>(
       mesh::create_box(comm, {{{0.0, 0.0, 0.0}, {1.0, 1.0, 1.0}}}, {12, 12, 12},
                        mesh::CellType::tetrahedron, part));

cpp/test/mesh/branching_manifold.cpp

@@ -48,7 +48,7 @@ TEST_CASE("dual_graph_branching")
   {
     // default
     auto [dual_graph, unmatched_facets, max_vertices_per_facet, cell_data]
-        = mesh::build_local_dual_graph(celltypes, {cells});
+        = mesh::build_local_dual_graph(celltypes, {cells}, 2);
 
     CHECK(dual_graph.num_nodes() == 4);
 

cpp/test/mesh/distributed_mesh.cpp

@@ -139,7 +139,7 @@ void test_distributed_mesh(const mesh::CellPartitionFunction& partitioner)
 
   // Build mesh
   mesh::Mesh mesh = mesh::create_mesh(comm, subset_comm, cells, cmap, comm, x,
-                                      xshape, partitioner);
+                                      xshape, partitioner, 2);
   auto t = mesh.topology();
   int tdim = t->dim();
   CHECK(t->index_map(tdim)->size_global() == 2 * N * N);
@@ -161,11 +161,11 @@ TEST_CASE("Create box", "[create_box]")
 {
 #ifdef HAS_PTSCOTCH
   CHECK_NOTHROW(test_create_box(mesh::create_cell_partitioner(
-      mesh::GhostMode::none, graph::scotch::partitioner())));
+      mesh::GhostMode::none, graph::scotch::partitioner(), 2)));
 #endif
 #ifdef HAS_PARMETIS
   CHECK_NOTHROW(test_create_box(mesh::create_cell_partitioner(
-      mesh::GhostMode::none, graph::parmetis::partitioner())));
+      mesh::GhostMode::none, graph::parmetis::partitioner(), 2)));
 #endif
   // #ifdef HAS_KAHIP
   //   CHECK_NOTHROW(test_create_box(mesh::create_cell_partitioner(
@@ -183,14 +183,14 @@ TEST_CASE("Distributed Mesh", "[distributed_mesh]")
 
 #ifdef HAS_PTSCOTCH
   CHECK_NOTHROW(test_distributed_mesh(mesh::create_cell_partitioner(
-      mesh::GhostMode::none, graph::scotch::partitioner())));
+      mesh::GhostMode::none, graph::scotch::partitioner(), 2)));
 #endif
 #ifdef HAS_PARMETIS
   CHECK_NOTHROW(test_distributed_mesh(mesh::create_cell_partitioner(
-      mesh::GhostMode::none, graph::parmetis::partitioner())));
+      mesh::GhostMode::none, graph::parmetis::partitioner(), 2)));
 #endif
 #ifdef HAS_KAHIP
   CHECK_NOTHROW(test_distributed_mesh(mesh::create_cell_partitioner(
-      mesh::GhostMode::none, graph::kahip::partitioner(1, 1, 0.03, false))));
+      mesh::GhostMode::none, graph::kahip::partitioner(1, 1, 0.03, false), 2)));
 #endif
 }

cpp/test/mesh/read_named_meshtags.cpp

@@ -29,7 +29,7 @@ void test_read_named_meshtags()
   constexpr std::int32_t material_value = 2;
 
   // Create mesh
-  auto part = mesh::create_cell_partitioner(mesh::GhostMode::none);
+  auto part = mesh::create_cell_partitioner(mesh::GhostMode::none, 2);
   auto mesh = std::make_shared<mesh::Mesh<double>>(
       mesh::create_rectangle(MPI_COMM_WORLD, {{{0.0, 0.0}, {1.0, 1.0}}}, {3, 3},
                              mesh::CellType::triangle, part));