additional test

Author: jhdark

test/conftest.py

@@ -0,0 +1,16 @@
+import zipfile
+from pathlib import Path
+
+import pytest
+
+from foam2dolfinx import OpenFOAMReader
+
+
+@pytest.fixture
+def two_regions_reader(tmp_path):
+    zip_path = Path("test/data/test_2Regions.zip")
+    extract_path = tmp_path / "test_2Regions"
+    with zipfile.ZipFile(zip_path, "r") as zf:
+        zf.extractall(extract_path)
+    foam_file = extract_path / "test_2Regions/pv.foam"
+    return OpenFOAMReader(filename=str(foam_file), cell_type=12)

test/test_get_connectivity.py

@@ -0,0 +1,72 @@
+import dolfinx
+import numpy as np
+import pytest
+from pyvista import examples
+
+from foam2dolfinx import OpenFOAMReader
+
+
+@pytest.fixture
+def hex_reader():
+    return OpenFOAMReader(filename=examples.download_cavity(load=False), cell_type=12)
+
+
+@pytest.fixture
+def tet_reader():
+    return OpenFOAMReader(filename=examples.download_cavity(load=False), cell_type=10)
+
+
+@pytest.mark.parametrize(
+    "cell_type, n_verts, expected_shape",
+    [(12, 8, "hexahedron"), (10, 4, "tetrahedron")],
+)
+def test_get_connectivity_returns_correct_shape_name(cell_type, n_verts, expected_shape):
+    reader = OpenFOAMReader(filename=examples.download_cavity(load=False), cell_type=cell_type)
+    shape_name, _ = reader._get_connectivity(np.zeros((3, n_verts), dtype=int))
+    assert shape_name == expected_shape
+
+
+@pytest.mark.parametrize("cell_type, n_verts", [(12, 8), (10, 4)])
+def test_get_connectivity_output_shape_matches_input(cell_type, n_verts):
+    reader = OpenFOAMReader(filename=examples.download_cavity(load=False), cell_type=cell_type)
+    cells = np.arange(5 * n_verts).reshape(5, n_verts)
+    _, connectivity = reader._get_connectivity(cells)
+    assert connectivity.shape == cells.shape
+
+
+def test_get_connectivity_raises_for_unsupported_cell_type():
+    reader = OpenFOAMReader(filename=examples.download_cavity(load=False), cell_type=12)
+    reader._cell_type = 5
+    with pytest.raises(ValueError, match="not supported"):
+        reader._get_connectivity(np.zeros((3, 4), dtype=int))
+
+
+def test_get_connectivity_hexahedron_applies_vtk_to_dolfinx_permutation(hex_reader):
+    cells = np.arange(8).reshape(1, 8)
+    _, connectivity = hex_reader._get_connectivity(cells)
+    np.testing.assert_array_equal(connectivity[0], [0, 1, 3, 2, 4, 5, 7, 6])
+
+
+def test_get_connectivity_tetrahedron_sorts_vertices(tet_reader):
+    cells = np.array([[40, 10, 30, 20]])
+    _, connectivity = tet_reader._get_connectivity(cells)
+    np.testing.assert_array_equal(connectivity[0], [10, 20, 30, 40])
+
+
+def test_build_dolfinx_mesh_returns_dolfinx_mesh(hex_reader):
+    hex_reader._read_with_pyvista(t=0)
+    shape, connectivity = hex_reader._get_connectivity(hex_reader.OF_cells_dict["default"])
+    result = hex_reader._build_dolfinx_mesh(
+        hex_reader.OF_meshes_dict["default"].points, connectivity, shape
+    )
+    assert isinstance(result, dolfinx.mesh.Mesh)
+
+
+@pytest.mark.parametrize("attr", ["mesh_vector_element", "mesh_scalar_element"])
+def test_build_dolfinx_mesh_sets_element_attributes(hex_reader, attr):
+    hex_reader._read_with_pyvista(t=0)
+    shape, connectivity = hex_reader._get_connectivity(hex_reader.OF_cells_dict["default"])
+    hex_reader._build_dolfinx_mesh(
+        hex_reader.OF_meshes_dict["default"].points, connectivity, shape
+    )
+    assert getattr(hex_reader, attr) is not None

test/test_meshtags.py

@@ -0,0 +1,81 @@
+import numpy as np
+import pytest
+from pyvista import examples
+
+from foam2dolfinx import OpenFOAMReader
+
+
+# --- create_cell_meshtags: multidomain ---
+
+
+def test_create_cell_meshtags_dim_equals_mesh_dim(two_regions_reader):
+    ct = two_regions_reader.create_cell_meshtags()
+    mesh = two_regions_reader.dolfinx_meshes_dict["_global"]
+    assert ct.dim == mesh.topology.dim
+
+
+def test_create_cell_meshtags_multidomain_fluid_count(two_regions_reader):
+    ct = two_regions_reader.create_cell_meshtags()
+    assert np.sum(ct.values == 1) == 2100
+
+
+def test_create_cell_meshtags_multidomain_solid_count(two_regions_reader):
+    ct = two_regions_reader.create_cell_meshtags()
+    assert np.sum(ct.values == 2) == 945
+
+
+def test_create_cell_meshtags_multidomain_no_untagged_cells(two_regions_reader):
+    ct = two_regions_reader.create_cell_meshtags()
+    assert np.all(ct.values > 0)
+
+
+# --- create_cell_meshtags: single domain ---
+
+
+def test_create_cell_meshtags_single_domain_dim_equals_mesh_dim():
+    reader = OpenFOAMReader(filename=examples.download_cavity(load=False), cell_type=12)
+    ct = reader.create_cell_meshtags(t=0)
+    mesh = reader.dolfinx_meshes_dict["default"]
+    assert ct.dim == mesh.topology.dim
+
+
+def test_create_cell_meshtags_single_domain_all_values_are_one():
+    reader = OpenFOAMReader(filename=examples.download_cavity(load=False), cell_type=12)
+    ct = reader.create_cell_meshtags(t=0)
+    assert np.all(ct.values == 1)
+
+
+# --- create_facet_meshtags: multidomain ---
+
+
+def test_create_facet_meshtags_dim_equals_fdim(two_regions_reader):
+    ft = two_regions_reader.create_facet_meshtags()
+    mesh = two_regions_reader.dolfinx_meshes_dict["_global"]
+    assert ft.dim == mesh.topology.dim - 1
+
+
+@pytest.mark.parametrize("tag, expected_count", [(1, 15), (2, 15), (3, 70)])
+def test_create_facet_meshtags_boundary_patch_counts(two_regions_reader, tag, expected_count):
+    ft = two_regions_reader.create_facet_meshtags()
+    assert np.sum(ft.values == tag) == expected_count
+
+
+def test_create_facet_meshtags_interface_count(two_regions_reader):
+    ft = two_regions_reader.create_facet_meshtags()
+    # interface facets receive the highest tag (assigned after all boundary patches)
+    assert np.sum(ft.values == ft.values.max()) == 60
+
+
+def test_create_facet_meshtags_all_tag_values_positive(two_regions_reader):
+    ft = two_regions_reader.create_facet_meshtags()
+    assert np.all(ft.values > 0)
+
+
+# --- create_facet_meshtags: single domain ---
+
+
+def test_create_facet_meshtags_single_domain_dim_equals_fdim():
+    reader = OpenFOAMReader(filename=examples.download_cavity(load=False), cell_type=12)
+    ft = reader.create_facet_meshtags()
+    mesh = reader.dolfinx_meshes_dict["default"]
+    assert ft.dim == mesh.topology.dim - 1

test/test_read_with_pyvista.py

@@ -52,6 +52,48 @@ def test_error_rasied_when_wrong_subdomain_given_in_multidomain_case(tmpdir):
         my_of_reader._read_with_pyvista(t=20.0, subdomain="coucou")
 
 
+def test_read_with_pyvista_no_subdomain_single_domain_populates_cells():
+    reader = OpenFOAMReader(filename=examples.download_cavity(load=False), cell_type=12)
+    reader._read_with_pyvista(t=0)
+    assert "default" in reader.OF_cells_dict
+    assert reader.OF_cells_dict["default"] is not None
+
+
+def test_read_with_pyvista_no_subdomain_single_domain_sets_multidomain_false():
+    reader = OpenFOAMReader(filename=examples.download_cavity(load=False), cell_type=12)
+    reader._read_with_pyvista(t=0)
+    assert reader.multidomain is False
+
+
+def test_read_with_pyvista_no_subdomain_multidomain_populates_all_meshes(
+    two_regions_reader,
+):
+    two_regions_reader._read_with_pyvista(t=20.0)
+    assert "fluid" in two_regions_reader.OF_meshes_dict
+    assert "solid" in two_regions_reader.OF_meshes_dict
+
+
+def test_read_with_pyvista_no_subdomain_multidomain_excludes_defaultRegion(
+    two_regions_reader,
+):
+    two_regions_reader._read_with_pyvista(t=20.0)
+    assert "defaultRegion" not in two_regions_reader.OF_meshes_dict
+
+
+def test_read_with_pyvista_no_subdomain_multidomain_does_not_populate_cells(
+    two_regions_reader,
+):
+    two_regions_reader._read_with_pyvista(t=20.0)
+    assert len(two_regions_reader.OF_cells_dict) == 0
+
+
+def test_read_with_pyvista_no_subdomain_multidomain_sets_multidomain_true(
+    two_regions_reader,
+):
+    two_regions_reader._read_with_pyvista(t=20.0)
+    assert two_regions_reader.multidomain is True
+
+
 @pytest.mark.parametrize("subdomain", ["fluid", "solid"])
 def test_read_with_pyvista_finds_all_mesh_data(tmpdir, subdomain):
     zip_path = Path("test/data/test_2Regions.zip")

test/test_tag_boundary_patch.py

@@ -0,0 +1,71 @@
+import dolfinx.mesh
+import numpy as np
+import pyvista
+import pytest
+from mpi4py import MPI
+from scipy.spatial import cKDTree
+from dolfinx.mesh import exterior_facet_indices
+
+from foam2dolfinx.helpers import tag_boundary_patch
+
+
+@pytest.fixture
+def unit_cube_topology():
+    mesh = dolfinx.mesh.create_box(
+        MPI.COMM_WORLD, [[0, 0, 0], [1, 1, 1]], [2, 2, 2], dolfinx.mesh.CellType.hexahedron
+    )
+    fdim = mesh.topology.dim - 1
+    mesh.topology.create_connectivity(fdim, 0)
+    mesh.topology.create_connectivity(0, fdim)
+    mesh.topology.create_connectivity(fdim, mesh.topology.dim)
+    facet_indices = exterior_facet_indices(mesh.topology)
+    c_to_v = mesh.topology.connectivity(fdim, 0)
+    facet_vertices = np.vstack([c_to_v.links(f) for f in facet_indices])
+    tree = cKDTree(mesh.geometry.x)
+    return mesh, tree, facet_indices, facet_vertices
+
+
+def test_tag_boundary_patch_returns_empty_when_no_points_match(unit_cube_topology):
+    mesh, tree, facet_indices, facet_vertices = unit_cube_topology
+    patch = pyvista.PolyData(np.array([[100.0, 100.0, 100.0]]))
+    matched, tags = tag_boundary_patch(
+        mesh, patch, 1, tree=tree, facet_indices=facet_indices, facet_vertices=facet_vertices
+    )
+    assert len(matched) == 0
+    assert len(tags) == 0
+
+
+def test_tag_boundary_patch_tags_equal_patch_id(unit_cube_topology):
+    mesh, tree, facet_indices, facet_vertices = unit_cube_topology
+    x0_points = mesh.geometry.x[mesh.geometry.x[:, 0] < 1e-10]
+    patch = pyvista.PolyData(x0_points)
+    _, tags = tag_boundary_patch(
+        mesh, patch, 42, tree=tree, facet_indices=facet_indices, facet_vertices=facet_vertices
+    )
+    assert np.all(tags == 42)
+
+
+def test_tag_boundary_patch_matched_facets_are_subset_of_exterior(unit_cube_topology):
+    mesh, tree, facet_indices, facet_vertices = unit_cube_topology
+    x0_points = mesh.geometry.x[mesh.geometry.x[:, 0] < 1e-10]
+    patch = pyvista.PolyData(x0_points)
+    matched, _ = tag_boundary_patch(
+        mesh, patch, 1, tree=tree, facet_indices=facet_indices, facet_vertices=facet_vertices
+    )
+    assert np.all(np.isin(matched, facet_indices))
+
+
+@pytest.mark.parametrize("patch_points", [
+    np.array([[100.0, 100.0, 100.0]]),       # no match
+    None,                                     # match (x=0 face, filled below)
+])
+def test_tag_boundary_patch_output_arrays_are_int32(unit_cube_topology, patch_points):
+    mesh, tree, facet_indices, facet_vertices = unit_cube_topology
+    if patch_points is None:
+        patch_points = mesh.geometry.x[mesh.geometry.x[:, 0] < 1e-10]
+    patch = pyvista.PolyData(patch_points)
+    matched, tags = tag_boundary_patch(
+        mesh, patch, 1, tree=tree, facet_indices=facet_indices, facet_vertices=facet_vertices
+    )
+    assert matched.dtype == np.int32
+    assert tags.dtype == np.int32