def plot_line_triangle(mesh: MeshContainer, label: str, **kwargs): """Plot line/triangle mesh together.""" assert set(mesh.cells_dict.keys()) == {'line', 'triangle'} fig, (ax1, ax2) = plt.subplots(ncols=2) mesh.plot_mpl('line', ax=ax1, label=label, **kwargs) mesh.plot_mpl('triangle', ax=ax2, label=label, **kwargs) return fig, (ax1, ax2)
def sample_mesh(): expected_fn = Path(__file__).parent / 'segmented_mesh_2d.msh' mesh = MeshContainer.read(expected_fn) sample_mesh = mesh.get('triangle') return sample_mesh
def test_write_read(mesh_square2d, tmp_path): def asserts(mesh): assert mesh.points.shape[1] == 2 assert 'physical' in mesh.cell_data assert 'gmsh:physical' not in mesh.cell_data assert 'gmsh:geometrical' not in mesh.cell_data filename = tmp_path / 'out.msh' asserts(mesh_square2d) mesh_square2d.write(filename, file_format='gmsh22') asserts(mesh_square2d) new_mesh = MeshContainer.read(filename) asserts(new_mesh) np.testing.assert_equal(mesh_square2d.points, new_mesh.points) assert len(mesh_square2d.cells) == len(new_mesh.cells) for (left, right) in zip(mesh_square2d.cells, new_mesh.cells): np.testing.assert_equal(left.data, right.data) for key, arrays in mesh_square2d.cell_data.items(): new_arrays = new_mesh.cell_data[key] for left, right in zip(arrays, new_arrays): np.testing.assert_equal(left, right)
def compare_mesh_results(mesh_container, expected_fn): """`result_mesh` is an instance of TetraMesh, and `expected_fn` the filename of the mesh to compare to.""" if expected_fn.exists(): expected_mesh_container = MeshContainer.read(expected_fn) else: mesh_container.write(expected_fn, file_format='gmsh22', binary=False) raise RuntimeError(f'Wrote expected mesh to {expected_fn.absolute()}') cell_type = 'tetra' mesh = mesh_container.get(cell_type) expected_mesh = expected_mesh_container.get(cell_type) assert mesh.points.shape == expected_mesh.points.shape assert mesh.cells.shape == expected_mesh.cells.shape np.testing.assert_allclose(mesh.points, expected_mesh.points) np.testing.assert_allclose(mesh.cells, expected_mesh.cells) np.testing.assert_allclose(mesh.region_markers, expected_mesh.region_markers) for key in expected_mesh.cell_data: try: np.testing.assert_allclose(mesh.cell_data[key], expected_mesh.cell_data[key]) except KeyError: if key not in ('physical', 'geometrical'): raise
def test_generate_2d_mesh(segmented): """Test 2D mesh generation and plot.""" expected_fn = Path(__file__).parent / 'segmented_mesh_2d.msh' np.random.seed(1234) # set seed for reproducible clustering mesh = generate_2d_mesh(segmented, max_contour_dist=4, plot=True) if expected_fn.exists(): expected_mesh = MeshContainer.read(expected_fn) else: mesh.write(expected_fn, file_format='gmsh22', binary=False) raise RuntimeError(f'Wrote expected mesh to {expected_fn.absolute()}') assert mesh.points.shape[1] == 2 assert mesh.points.shape == expected_mesh.points.shape np.testing.assert_allclose(mesh.points, expected_mesh.points) cell_types = mesh.cells_dict.keys() assert cell_types == expected_mesh.cells_dict.keys() for cell_type in cell_types: cells = mesh.cells_dict[cell_type] expected_cells = expected_mesh.cells_dict[cell_type] assert cells.shape == expected_cells.shape np.testing.assert_allclose(cells, expected_cells) data_keys = mesh.cell_data_dict.keys() for data_key in data_keys: for cell_type in cell_types: data = mesh.cell_data_dict[data_key][cell_type] expected_data = expected_mesh.cell_data_dict[data_key][cell_type] np.testing.assert_allclose(data, expected_data)
def test_tetgen_generate_3d_mesh(triangle_mesh): """Test 3D mesh generation.""" expected_fn = Path(__file__).parent / 'expected_tetra_mesh.msh' triangle_mesh.add_region_marker((10, np.array([0.5, 0.5, 0.5]))) triangle_mesh.add_region_marker((20, np.array([0.0, 2.0, 2.0]))) mesh_container = triangle_mesh.tetrahedralize() if expected_fn.exists(): expected_mesh_container = MeshContainer.read(expected_fn) else: mesh_container.write(expected_fn, file_format='gmsh22', binary=False) raise RuntimeError(f'Wrote expected mesh to {expected_fn.absolute()}') cell_type = 'tetra' mesh = mesh_container.get(cell_type) expected_mesh = expected_mesh_container.get(cell_type) assert mesh.points.shape == expected_mesh.points.shape assert mesh.cells.shape == expected_mesh.cells.shape np.testing.assert_allclose(mesh.points, expected_mesh.points) np.testing.assert_allclose(mesh.cells, expected_mesh.cells) np.testing.assert_allclose(mesh.region_markers, expected_mesh.region_markers)
def simple_triangulate(points: np.ndarray, *, segments: np.ndarray = None, regions: np.ndarray = None, opts: str = '') -> MeshContainer: """Simple triangulation using `triangle`. Parameters ---------- points : i,2 np.ndarray Vertex coordinates. segments : j,2 np.ndarray, optional Index array describing segments. Segments are edges whose presence in the triangulation is enforced (although each segment may be subdivided into smaller edges). Each segment is specified by listing the indices of its two endpoints. A closed set of segments describes a contour. regions : k,2 np.ndarray, optional Coordinates describing regions. A region is a coordinate inside (e.g. at the center) of a region/contour (i.e. enclosed by segments). opts : str, optional Additional options passed to `triangle.triangulate` documented here: https://rufat.be/triangle/API.html#triangle.triangulate Returns ------- mesh : MeshContainer Triangle mesh """ from nanomesh.mesh_container import MeshContainer triangle_dict_in = {'vertices': points} if segments is not None: triangle_dict_in['segments'] = segments if regions is not None: triangle_dict_in['regions'] = regions triangle_dict_out = tr.triangulate(triangle_dict_in, opts=opts) mesh = MeshContainer.from_triangle_dict(triangle_dict_out) return mesh
def test_mesh_container_triangle_2d(triangle_mesh_2d): mesh = MeshContainer.from_mesh(triangle_mesh_2d) assert isinstance(mesh, MeshContainer) assert isinstance(mesh.get('triangle'), TriangleMesh) assert isinstance(mesh.get(), TriangleMesh) assert isinstance(mesh, meshio.Mesh)
def test_mesh_container_tetra(tetra_mesh): mesh = MeshContainer.from_mesh(tetra_mesh) assert isinstance(mesh, MeshContainer) assert isinstance(mesh.get('tetra'), TetraMesh) assert isinstance(mesh.get(), TetraMesh) assert isinstance(mesh, meshio.Mesh)