Make facet optional return value

FEniCS · Aug 5, 2024 · c40d4f6 · c40d4f6
1 parent b34b090
commit c40d4f6
Show file tree

Hide file tree

Showing 4 changed files with 21 additions and 13 deletions.
diff --git a/cpp/dolfinx/refinement/interval.h b/cpp/dolfinx/refinement/interval.h
@@ -34,7 +34,7 @@ namespace dolfinx::refinement::interval
 template <std::floating_point T>
 std::tuple<graph::AdjacencyList<std::int64_t>, std::vector<T>,
            std::array<std::size_t, 2>, std::optional<std::vector<std::int32_t>>,
-           std::vector<std::int8_t>>
+           std::optional<std::vector<std::int8_t>>>
 compute_refinement_data(const mesh::Mesh<T>& mesh,
                         std::optional<std::span<const std::int32_t>> cells,
                         Option option)
@@ -183,7 +183,7 @@ compute_refinement_data(const mesh::Mesh<T>& mesh,
   graph::AdjacencyList cell_adj(std::move(cell_topology), std::move(offsets));
 
   return {std::move(cell_adj), std::move(new_vertex_coords), xshape,
-          std::move(parent_cell), {}};
+          std::move(parent_cell), std::nullopt};
 }
 
 } // namespace dolfinx::refinement::interval
diff --git a/cpp/dolfinx/refinement/plaza.h b/cpp/dolfinx/refinement/plaza.h
@@ -286,7 +286,7 @@ face_long_edge(const mesh::Mesh<T>& mesh)
 template <std::floating_point T>
 std::tuple<graph::AdjacencyList<std::int64_t>, std::vector<T>,
            std::array<std::size_t, 2>, std::optional<std::vector<std::int32_t>>,
-           std::vector<std::int8_t>>
+           std::optional<std::vector<std::int8_t>>>
 compute_refinement(MPI_Comm neighbor_comm,
                    std::span<const std::int8_t> marked_edges,
                    const graph::AdjacencyList<int>& shared_edges,
@@ -309,7 +309,10 @@ compute_refinement(MPI_Comm neighbor_comm,
   if (compute_parent_cell)
     parent_cell.emplace();
 
-  std::vector<std::int8_t> parent_facet;
+  std::optional<std::vector<std::int8_t>> parent_facet(std::nullopt);
+  if (compute_facets)
+    parent_facet.emplace();
+
   std::vector<std::int64_t> indices(num_cell_vertices + num_cell_edges);
   std::vector<std::int32_t> simplex_set;
 
@@ -371,9 +374,9 @@ compute_refinement(MPI_Comm neighbor_comm,
       if (compute_facets)
       {
         if (tdim == 3)
-          parent_facet.insert(parent_facet.end(), {0, 1, 2, 3});
+          parent_facet->insert(parent_facet->end(), {0, 1, 2, 3});
         else
-          parent_facet.insert(parent_facet.end(), {0, 1, 2});
+          parent_facet->insert(parent_facet->end(), {0, 1, 2});
       }
     }
     else
@@ -416,14 +419,14 @@ compute_refinement(MPI_Comm neighbor_comm,
         if (tdim == 3)
         {
           auto npf = compute_parent_facets<3>(simplex_set);
-          parent_facet.insert(parent_facet.end(), npf.begin(),
-                              std::next(npf.begin(), simplex_set.size()));
+          parent_facet->insert(parent_facet->end(), npf.begin(),
+                               std::next(npf.begin(), simplex_set.size()));
         }
         else
         {
           auto npf = compute_parent_facets<2>(simplex_set);
-          parent_facet.insert(parent_facet.end(), npf.begin(),
-                              std::next(npf.begin(), simplex_set.size()));
+          parent_facet->insert(parent_facet->end(), npf.begin(),
+                               std::next(npf.begin(), simplex_set.size()));
         }
       }
 
@@ -457,7 +460,7 @@ compute_refinement(MPI_Comm neighbor_comm,
 template <std::floating_point T>
 std::tuple<graph::AdjacencyList<std::int64_t>, std::vector<T>,
            std::array<std::size_t, 2>, std::optional<std::vector<std::int32_t>>,
-           std::vector<std::int8_t>>
+           std::optional<std::vector<std::int8_t>>>
 compute_refinement_data(const mesh::Mesh<T>& mesh,
                         std::optional<std::span<const std::int32_t>> edges,
                         Option option)

diff --git a/cpp/dolfinx/refinement/refine.h b/cpp/dolfinx/refinement/refine.h
@@ -62,7 +62,7 @@ create_refined_mesh(const mesh::Mesh<T>& mesh,
 /// @return New Mesh and optional parent cell index, parent facet indices
 template <std::floating_point T>
 std::tuple<mesh::Mesh<T>, std::optional<std::vector<std::int32_t>>,
-           std::vector<std::int8_t>>
+           std::optional<std::vector<std::int8_t>>>
 refine(const mesh::Mesh<T>& mesh,
        std::optional<std::span<const std::int32_t>> edges, bool redistribute,
        mesh::GhostMode ghost_mode = mesh::GhostMode::shared_facet,

diff --git a/python/dolfinx/wrappers/refinement.cpp b/python/dolfinx/wrappers/refinement.cpp
@@ -56,8 +56,13 @@ void export_refinement_with_variable_mesh_type(nb::module_& m)
         if (cell.has_value())
           python_cell.emplace(as_nbarray(std::move(cell.value())));
 
+        std::optional<nb::ndarray<std::int8_t, nb::numpy>> python_facet(
+            std::nullopt);
+        if (facet.has_value())
+          python_facet.emplace(as_nbarray(std::move(facet.value())));
+
         return std::tuple{std::move(mesh1), std::move(python_cell),
-                          as_nbarray(std::move(facet))};
+                          std::move(python_facet)};
       },
       nb::arg("mesh"), nb::arg("edges") = nb::none(), nb::arg("redistribute"),
       nb::arg("ghost_mode"), nb::arg("option"));