Merge branch 'main' into schnellerhase/clang-tidy-2.0

Author: schnellerhase

.github/workflows/ccpp.yml

@@ -13,19 +13,6 @@ on:
     branches:
       - main
   workflow_dispatch:
-    inputs:
-      ffcx_ref:
-        description: "FFCx branch or tag"
-        default: "main"
-        type: string
-      basix_ref:
-        description: "Basix branch or tag"
-        default: "main"
-        type: string
-      ufl_ref:
-        description: "UFL branch or tag"
-        default: "main"
-        type: string
 
 jobs:
 
@@ -108,18 +95,11 @@ jobs:
         run: |
           pip install --upgrade -r python/build-requirements.txt
 
-      - name: Install FEniCS Python components (default branches/tags)
-        if: github.event_name != 'workflow_dispatch'
+      - name: Install FEniCS Python components
         run: |
           pip install git+https://github.com/fenics/ufl.git@${{ env.ufl_ref }}
           pip install git+https://github.com/fenics/basix.git@${{ env.basix_ref }}
           pip install git+https://github.com/fenics/ffcx.git@${{ env.ffcx_ref }}
-      - name: Install FEniCS Python components
-        if: github.event_name == 'workflow_dispatch'
-        run: |
-          pip install git+https://github.com/FEniCS/ufl.git@${{ env.ufl_ref }}
-          pip install git+https://github.com/FEniCS/basix.git@${{ env.basix_ref }}
-          pip install git+https://github.com/FEniCS/ffcx.git@${{ env.ffcx_ref }}
 
       - name: Configure and install C++
         run: |
@@ -195,15 +175,7 @@ jobs:
       - name: Load environment variables
         run: cat .github/workflows/fenicsx-refs.env >> $GITHUB_ENV
 
-      - name: Install FEniCS Python components (default branches/tags)
-        if: github.event_name != 'workflow_dispatch'
-        run: |
-          pip install git+https://github.com/FEniCS/ufl.git@${{ env.ufl_ref }}
-          pip install git+https://github.com/FEniCS/basix.git@${{ env.basix_ref }}
-          pip install git+https://github.com/FEniCS/ffcx.git@${{ env.ffcx_ref }}
-
       - name: Install FEniCS Python components
-        if: github.event_name == 'workflow_dispatch'
         run: |
           pip install git+https://github.com/FEniCS/ufl.git@${{ env.ufl_ref }}
           pip install git+https://github.com/FEniCS/basix.git@${{ env.basix_ref }}
@@ -290,14 +262,7 @@ jobs:
       - name: Load environment variables
         run: cat .github/workflows/fenicsx-refs.env >> $GITHUB_ENV
 
-      - name: Install FEniCS Python components (default branches/tags)
-        if: github.event_name != 'workflow_dispatch'
-        run: |
-          pip install git+https://github.com/FEniCS/ufl.git@${{ env.ufl_ref }}
-          pip install git+https://github.com/FEniCS/basix.git@${{ env.basix_ref }}
-          pip install git+https://github.com/FEniCS/ffcx.git@${{ env.ffcx_ref }}
       - name: Install FEniCS Python components
-        if: github.event_name == 'workflow_dispatch'
         run: |
           pip install git+https://github.com/FEniCS/ufl.git@${{ env.ufl_ref }}
           pip install git+https://github.com/FEniCS/basix.git@${{ env.basix_ref }}

python/dolfinx/io/gmshio.py

@@ -366,7 +366,7 @@ def model_to_mesh(
     if comm.rank != rank:
         x = np.empty([0, gdim], dtype=dtype)  # No nodes on other than root rank
     mesh = create_mesh(
-        comm, cell_connectivity, x[:, :gdim].astype(dtype, copy=False), ufl_domain, partitioner
+        comm, cell_connectivity, ufl_domain, x[:, :gdim].astype(dtype, copy=False), partitioner
     )
     assert tdim == mesh.topology.dim, (
         f"{mesh.topology.dim=} does not match Gmsh model dimension {tdim}"

python/dolfinx/io/utils.py

@@ -26,14 +26,6 @@
 __all__ = ["VTKFile", "XDMFFile", "cell_perm_gmsh", "cell_perm_vtk", "distribute_entity_data"]
 
 
-def _extract_cpp_objects(functions: typing.Union[Mesh, Function, tuple[Function], list[Function]]):
-    """Extract C++ objects"""
-    if isinstance(functions, (list, tuple)):
-        return [getattr(u, "_cpp_object", u) for u in functions]
-    else:
-        return [getattr(functions, "_cpp_object", functions)]
-
-
 # VTXWriter requires ADIOS2
 if _cpp.common.has_adios2:
     from dolfinx.cpp.io import VTXMeshPolicy  # F401
@@ -81,27 +73,29 @@ def __init__(
                 have the same element type.
             """
             # Get geometry type
-            try:
-                dtype = output.geometry.x.dtype  # type: ignore
-            except AttributeError:
-                try:
-                    dtype = output.function_space.mesh.geometry.x.dtype  # type: ignore
-                except AttributeError:
-                    dtype = output[0].function_space.mesh.geometry.x.dtype  # type: ignore
+            if isinstance(output, Mesh):
+                dtype = output.geometry.x.dtype
+            elif isinstance(output, Function):
+                dtype = output.function_space.mesh.geometry.x.dtype
+            else:
+                dtype = output[0].function_space.mesh.geometry.x.dtype
 
             if np.issubdtype(dtype, np.float32):
                 _vtxwriter = _cpp.io.VTXWriter_float32
             elif np.issubdtype(dtype, np.float64):
                 _vtxwriter = _cpp.io.VTXWriter_float64
+            else:
+                raise RuntimeError(f"VTXWriter does not support dtype={dtype}.")
 
-            try:
-                # Input is a mesh
+            if isinstance(output, Mesh):
                 self._cpp_object = _vtxwriter(comm, filename, output._cpp_object, engine)  # type: ignore[union-attr]
-            except (NotImplementedError, TypeError, AttributeError):
-                # Input is a single function or a list of functions
-                self._cpp_object = _vtxwriter(
-                    comm, filename, _extract_cpp_objects(output), engine, mesh_policy
-                )  # type: ignore[arg-type]
+            else:
+                cpp_objects = (
+                    [output._cpp_object]
+                    if isinstance(output, Function)
+                    else [o._cpp_object for o in output]
+                )
+                self._cpp_object = _vtxwriter(comm, filename, cpp_objects, engine, mesh_policy)
 
         def __enter__(self):
             return self
@@ -137,7 +131,8 @@ def write_mesh(self, mesh: Mesh, t: float = 0.0) -> None:
     def write_function(self, u: typing.Union[list[Function], Function], t: float = 0.0) -> None:
         """Write a single function or a list of functions to file for a
         given time (default 0.0)"""
-        super().write(_extract_cpp_objects(u), t)
+        cpp_objects = [u._cpp_object] if isinstance(u, Function) else [_u._cpp_object for _u in u]
+        super().write(cpp_objects, t)
 
 
 class XDMFFile(_cpp.io.XDMFFile):

python/dolfinx/mesh.py

@@ -683,13 +683,13 @@ def refine(
 def create_mesh(
     comm: _MPI.Comm,
     cells: npt.NDArray[np.int64],
-    x: npt.NDArray[np.floating],
     e: typing.Union[
         ufl.Mesh,
         basix.finite_element.FiniteElement,
         basix.ufl._BasixElement,
         _CoordinateElement,
     ],
+    x: npt.NDArray[np.floating],
     partitioner: typing.Optional[Callable] = None,
 ) -> Mesh:
     """Create a mesh from topology and geometry arrays.

python/test/unit/fem/test_assembler.py

@@ -274,7 +274,7 @@ def test_petsc_assemble_manifold(self):
                 dtype=default_real_type,
             )
         )
-        mesh = create_mesh(MPI.COMM_WORLD, cells, points, domain)
+        mesh = create_mesh(MPI.COMM_WORLD, cells, domain, points)
         assert mesh.geometry.dim == 2
         assert mesh.topology.dim == 1
 
@@ -1306,7 +1306,7 @@ def partitioner(comm, nparts, local_graph, num_ghost_nodes):
             cells = np.empty((0, 3), dtype=np.int64)
             x = np.empty((0, 2), dtype=default_real_type)
 
-        mesh = create_mesh(comm, cells, x, domain, partitioner)
+        mesh = create_mesh(comm, cells, domain, x, partitioner)
 
         V = functionspace(mesh, ("Lagrange", 2))
         u, v = ufl.TrialFunction(V), ufl.TestFunction(V)

python/test/unit/fem/test_dof_permuting.py

@@ -108,35 +108,35 @@ def randomly_ordered_mesh(cell_type):
 
         # On process 0, input mesh data and distribute to other
         # processes
-        return create_mesh(MPI.COMM_WORLD, cells, points, domain)
+        return create_mesh(MPI.COMM_WORLD, cells, domain, points)
     else:
         if cell_type == "triangle":
             return create_mesh(
                 MPI.COMM_WORLD,
                 np.ndarray((0, 3)),
-                np.ndarray((0, 2), dtype=default_real_type),
                 domain,
+                np.ndarray((0, 2), dtype=default_real_type),
             )
         elif cell_type == "quadrilateral":
             return create_mesh(
                 MPI.COMM_WORLD,
                 np.ndarray((0, 4)),
-                np.ndarray((0, 2), dtype=default_real_type),
                 domain,
+                np.ndarray((0, 2), dtype=default_real_type),
             )
         elif cell_type == "tetrahedron":
             return create_mesh(
                 MPI.COMM_WORLD,
                 np.ndarray((0, 4)),
-                np.ndarray((0, 3), dtype=default_real_type),
                 domain,
+                np.ndarray((0, 3), dtype=default_real_type),
             )
         elif cell_type == "hexahedron":
             return create_mesh(
                 MPI.COMM_WORLD,
                 np.ndarray((0, 8)),
-                np.ndarray((0, 3), dtype=default_real_type),
                 domain,
+                np.ndarray((0, 3), dtype=default_real_type),
             )
 
 
@@ -276,7 +276,7 @@ def random_evaluation_mesh(cell_type):
                 cell_order += [c + diff for c in cell_order]
 
         cells.append([order[cell[i]] for i in cell_order])
-    return create_mesh(MPI.COMM_WORLD, np.array(cells), points, domain)
+    return create_mesh(MPI.COMM_WORLD, np.array(cells), domain, points)
 
 
 @pytest.mark.skip_in_parallel

python/test/unit/fem/test_dofmap.py

@@ -324,7 +324,7 @@ def test_higher_order_coordinate_map(points, celltype, order):
     domain = ufl.Mesh(
         element("Lagrange", celltype.name, order, shape=(points.shape[1],), dtype=default_real_type)
     )
-    mesh = create_mesh(MPI.COMM_WORLD, cells, points, domain)
+    mesh = create_mesh(MPI.COMM_WORLD, cells, domain, points)
 
     V = functionspace(mesh, ("Lagrange", 2))
     X = V.element.interpolation_points
@@ -400,7 +400,7 @@ def test_higher_order_tetra_coordinate_map(order):
     domain = ufl.Mesh(
         element("Lagrange", celltype.name, order, shape=(3,), dtype=default_real_type)
     )
-    mesh = create_mesh(MPI.COMM_WORLD, cells, points, domain)
+    mesh = create_mesh(MPI.COMM_WORLD, cells, domain, points)
     V = functionspace(mesh, ("Lagrange", order))
     X = V.element.interpolation_points
     x_dofs = mesh.geometry.dofmap
@@ -439,7 +439,7 @@ def self_partitioner(comm: MPI.Intracomm, n, m, topo):
         # TODO: can we improve on this interface? I.e. warp to do cpp type conversion automatically
         return dolfinx.graph.adjacencylist(dests, offsets)._cpp_object
 
-    mesh = create_mesh(MPI.COMM_WORLD, cells, nodes, c_el, partitioner=self_partitioner)
+    mesh = create_mesh(MPI.COMM_WORLD, cells, c_el, nodes, partitioner=self_partitioner)
 
     el = element("Lagrange", "interval", 1, shape=(2,))
     V = functionspace(mesh, el)

python/test/unit/fem/test_element_integrals.py

@@ -104,7 +104,7 @@ def unit_cell(cell_type, dtype, random_order=True):
     domain = ufl.Mesh(
         element("Lagrange", cell_type.name, 1, shape=(ordered_points.shape[1],), dtype=dtype)
     )
-    mesh = create_mesh(MPI.COMM_WORLD, cells, ordered_points, domain)
+    mesh = create_mesh(MPI.COMM_WORLD, cells, domain, ordered_points)
     return mesh
 
 
@@ -188,7 +188,7 @@ def two_unit_cells(cell_type, dtype, agree=False, random_order=True, return_orde
     domain = ufl.Mesh(
         element("Lagrange", cell_type.name, 1, shape=(ordered_points.shape[1],), dtype=dtype)
     )
-    mesh = create_mesh(MPI.COMM_WORLD, ordered_cells, ordered_points, domain)
+    mesh = create_mesh(MPI.COMM_WORLD, ordered_cells, domain, ordered_points)
     if return_order:
         return mesh, order
     return mesh
@@ -525,7 +525,7 @@ def test_curl(space_type, order, dtype):
     for i in range(5):
         random.shuffle(cell)
         domain = ufl.Mesh(element("Lagrange", "tetrahedron", 1, shape=(3,), dtype=dtype))
-        mesh = create_mesh(MPI.COMM_WORLD, [cell], points, domain)
+        mesh = create_mesh(MPI.COMM_WORLD, [cell], domain, points)
         V = functionspace(mesh, (space_type, order))
         v = ufl.TestFunction(V)
         f = ufl.as_vector(tuple(1 if i == 0 else 0 for i in range(tdim)))
@@ -576,7 +576,7 @@ def create_quad_mesh(offset, dtype):
     x = np.array([[0, 0], [1, 0], [0, 0.5 + offset], [1, 0.5 - offset]], dtype=dtype)
     cells = np.array([[0, 1, 2, 3]])
     ufl_mesh = ufl.Mesh(element("Lagrange", "quadrilateral", 1, shape=(2,), dtype=dtype))
-    mesh = create_mesh(MPI.COMM_WORLD, cells, x, ufl_mesh)
+    mesh = create_mesh(MPI.COMM_WORLD, cells, ufl_mesh, x)
     return mesh
 
 

python/test/unit/fem/test_function.py

@@ -107,7 +107,7 @@ def test_eval_manifold():
     )
     cells = [(0, 1, 2), (0, 1, 3)]
     domain = ufl.Mesh(element("Lagrange", "triangle", 1, shape=(2,), dtype=default_real_type))
-    mesh = create_mesh(MPI.COMM_WORLD, cells, vertices, domain)
+    mesh = create_mesh(MPI.COMM_WORLD, cells, domain, vertices)
     Q = functionspace(mesh, ("Lagrange", 1))
     u = Function(Q)
     u.interpolate(lambda x: x[0] + x[1])

python/test/unit/fem/test_function_space.py

@@ -272,7 +272,7 @@ def test_vector_function_space_cell_type():
     domain = Mesh(element("Lagrange", "interval", 1, shape=(1,), dtype=default_real_type))
     cells = np.array([[0, 1]], dtype=np.int64)
     x = np.array([[0.0, 0.0], [1.0, 1.0]])
-    mesh = create_mesh(comm, cells, x, domain)
+    mesh = create_mesh(comm, cells, domain, x)
 
     # Create functions space over mesh, and check element cell
     # is correct
@@ -288,7 +288,7 @@ def test_manifold_spaces():
     )
     cells = [(0, 1, 2), (0, 1, 3)]
     domain = Mesh(element("Lagrange", "triangle", 1, shape=(2,), dtype=default_real_type))
-    mesh = create_mesh(MPI.COMM_WORLD, cells, vertices, domain)
+    mesh = create_mesh(MPI.COMM_WORLD, cells, domain, vertices)
     gdim = mesh.geometry.dim
     QV = functionspace(mesh, ("Lagrange", 1, (gdim,)))
     QT = functionspace(mesh, ("Lagrange", 1, (gdim, gdim)))