icplot 0.2.3__tar.gz → 0.2.4__tar.gz

{icplot-0.2.3/src/icplot.egg-info → icplot-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icplot
-Version: 0.2.3
+Version: 0.2.4
 Summary: Utilities for generating plots and graphics for technical reports.
 Author-email: "James Grogan, Irish Centre for High End Computing" <james.grogan@ichec.ie>
 Project-URL: Repository, https://git.ichec.ie/performance/toolshed/icplot

{icplot-0.2.3 → icplot-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "icplot"
-version = "0.2.3"
+version = "0.2.4"
 authors = [
   { name="James Grogan, Irish Centre for High End Computing", email="james.grogan@ichec.ie" },
 ]

{icplot-0.2.3 → icplot-0.2.4}/src/icplot/mesh/cell.py

@@ -14,6 +14,27 @@ class Cell:
         raise NotImplementedError()
 
 
+def flip_normals(cell: Cell) -> Cell:
+    if cell.type == "quad":
+        return Cell(type=cell.type, vertices=tuple(reversed(cell.vertices)))
+    else:
+        raise RuntimeError("Not implemented for this cell type")
+
+
+def get_hex_faces(cell: Cell) -> tuple[tuple[int, ...], ...]:
+    if cell.type != "hex":
+        raise RuntimeError("Can only get hex faces for hex cells")
+
+    return (
+        (cell.vertices[0], cell.vertices[1], cell.vertices[5], cell.vertices[4]),
+        (cell.vertices[1], cell.vertices[2], cell.vertices[6], cell.vertices[5]),
+        (cell.vertices[2], cell.vertices[3], cell.vertices[7], cell.vertices[6]),
+        (cell.vertices[3], cell.vertices[0], cell.vertices[4], cell.vertices[7]),
+        (cell.vertices[0], cell.vertices[3], cell.vertices[2], cell.vertices[1]),
+        (cell.vertices[4], cell.vertices[5], cell.vertices[6], cell.vertices[7]),
+    )
+
+
 @dataclass(frozen=True)
 class HexCell(Cell):
     """

{icplot-0.2.3 → icplot-0.2.4}/src/icplot/mesh/mesh.py

@@ -8,8 +8,8 @@ from dataclasses import dataclass
 
 from icplot.geometry import Point, Vector, Transform, Bounds
 
-from .vertex import Vertex
-from .cell import Cell
+from .vertex import Vertex, find_closest_vertex
+from .cell import Cell, flip_normals
 from .edge import Edge, contains_point, get_distance
 
 
@@ -52,6 +52,11 @@ class Mesh:
             zmax = min(zmax, v.z)
         return Bounds(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax)
 
+    def flip_normals(self) -> Mesh:
+        return Mesh(
+            vertices=self.vertices, cells=tuple(flip_normals(c) for c in self.cells)
+        )
+
     def get_location(self) -> Vector:
         bounds = self.get_bounds()
         return Vector(bounds.xmin, bounds.ymin, bounds.zmin)
@@ -62,6 +67,12 @@ class Mesh:
             vertices=tuple(v.translate(delta) for v in self.vertices), cells=self.cells
         )
 
+    def move_by(self, x: float, y: float, z: float) -> Mesh:
+        delta = Vector(x, y, z)
+        return Mesh(
+            vertices=tuple(v.translate(delta) for v in self.vertices), cells=self.cells
+        )
+
     def select_edge(self, p: Point) -> tuple[int, int]:
 
         for c in self.cells:
@@ -70,6 +81,9 @@ class Mesh:
                     return (e[0], e[1])
         raise RuntimeError("No edge found at selection point")
 
+    def get_closest_vertex(self, v: Vertex) -> Vertex:
+        return find_closest_vertex(self.vertices, v)
+
     def get_closest_edge(self, p: Point) -> tuple[int, int]:
 
         min_dist = -1.0
@@ -85,3 +99,9 @@ class Mesh:
                     min_dist = dist
                     closest_edges = (e[0], e[1])
         return closest_edges
+
+    def copy(self) -> Mesh:
+        return Mesh(
+            vertices=tuple(Vertex(v.x, v.y, v.z, v.id) for v in self.vertices),
+            cells=tuple(Cell(c.vertices, c.type) for c in self.cells),
+        )

{icplot-0.2.3 → icplot-0.2.4}/src/icplot/mesh/openfoam/foamfile.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 
 
@@ -14,8 +14,9 @@ class FoamFile:
     body: tuple[str, ...] = ()
     version: float = 2.0
     format: str = "ascii"
-    arch: str = '"LSB;label=32;scalar=64"'
+    arch: str = "LSB;label=32;scalar=64"
     foam_class: str = "vectorField"
+    meta: dict[str, tuple] = field(default_factory=dict)
 
 
 def write_header(spec: FoamFile) -> str:
@@ -27,6 +28,13 @@ def write_header(spec: FoamFile) -> str:
     output += f"\tclass\t{spec.foam_class};\n"
     output += f'\tlocation\t"{spec.location}";\n'
     output += f"\tobject\t{spec.foam_object};\n"
+    if spec.meta:
+        output += "\tmeta\n{\n"
+        for key, value in spec.meta.items():
+            values = list(value)
+            value_items = " ".join(str(item) for item in values)
+            output += f"\t{key} {len(values)}({value_items});\n"
+        output += "}\n"
     output += "}\n\n"
     return output
 

icplot-0.2.4/src/icplot/mesh/openfoam/polymesh.py

@@ -0,0 +1,315 @@
+from dataclasses import dataclass
+from pathlib import Path
+from functools import cmp_to_key
+
+from icplot.geometry import Point
+from icplot.mesh import Vertex, Mesh, get_hex_faces
+
+from .foamfile import read_foamfile, FoamFile, write_header
+
+
+@dataclass(frozen=True)
+class Face:
+    """
+    A mesh face, which is a sequence of vertices
+    """
+
+    vertices: tuple[int, ...]
+    id: int = -1
+    owner: int = -1
+    neighbour: int = -1
+
+    def get_centre(self, mesh: Mesh) -> Point:
+        x = sum(mesh.vertices[idx].x for idx in self.vertices)
+        y = sum(mesh.vertices[idx].y for idx in self.vertices)
+        z = sum(mesh.vertices[idx].z for idx in self.vertices)
+        return Point(
+            x / len(self.vertices), y / len(self.vertices), z / len(self.vertices)
+        )
+
+
+@dataclass(frozen=True)
+class Cell:
+    """
+    A mesh cell, which is a squence of faces
+    """
+
+    faces: tuple[int, ...]
+    id: int = -1
+
+
+@dataclass(frozen=True)
+class Polymesh:
+    """
+    The polymesh
+    """
+
+    vertices: tuple[Vertex, ...]
+    faces: tuple[Face, ...]
+    cells: tuple[Cell, ...]
+
+
+@dataclass(frozen=True)
+class PolymeshPatch:
+    name: str
+    faces: tuple[Face, ...]
+    startFace: int
+    type: str = "patch"
+
+    def has_face(self, face: Face) -> bool:
+        for f in self.faces:
+            if f.id == face.id:
+                return True
+        return False
+
+
+def read_polymesh(path: Path) -> Polymesh:
+
+    points_file = read_foamfile(path / "points")
+    # faces_file = read_foamfile(path / "faces")
+    print(points_file)
+    # print(faces_file)
+    return Polymesh((), (), ())
+
+
+def _write_points(vertices: tuple[Vertex, ...]) -> str:
+
+    # Write file header
+    header = FoamFile(
+        location="constant/polyMesh", foam_object="points", foam_class="vectorField"
+    )
+    ret = write_header(header)
+
+    ret += f"{len(vertices)}\n(\n"
+    for v in vertices:
+        ret += f"({v.x} {v.y} {v.z})\n"
+    ret += ")\n"
+    return ret
+
+
+def _write_faces(internal_faces: tuple[Face, ...], patches: list[PolymeshPatch]) -> str:
+    header = FoamFile(
+        location="constant/polyMesh", foam_object="faces", foam_class="faceList"
+    )
+    ret = write_header(header)
+
+    num_patch_faces = sum(len(p.faces) for p in patches)
+    num_faces = len(internal_faces) + num_patch_faces
+
+    ret += f"{num_faces}\n(\n"
+    for f in internal_faces:
+        verts = f.vertices
+        ret += f"{len(verts)}({verts[0]} {verts[1]} {verts[2]} {verts[3]})\n"
+
+    for p in patches:
+        for f in p.faces:
+            verts = f.vertices
+            ret += f"{len(verts)}({verts[0]} {verts[1]} {verts[2]} {verts[3]})\n"
+    ret += ")\n"
+    return ret
+
+
+def _write_owners(
+    internal_faces: tuple[Face, ...], patches: list[PolymeshPatch]
+) -> str:
+    header = FoamFile(
+        location="constant/polyMesh", foam_object="owner", foam_class="labelList"
+    )
+    ret = write_header(header)
+
+    num_patch_faces = sum(len(p.faces) for p in patches)
+    num_faces = len(internal_faces) + num_patch_faces
+
+    ret += f"{num_faces}\n(\n"
+    for f in internal_faces:
+        ret += f"{f.owner}\n"
+    for p in patches:
+        for f in p.faces:
+            ret += f"{f.owner}\n"
+    ret += ")\n"
+    return ret
+
+
+def _write_neighbours(
+    internal_faces: tuple[Face, ...], patches: list[PolymeshPatch]
+) -> str:
+    header = FoamFile(
+        location="constant/polyMesh", foam_object="neighbour", foam_class="labelList"
+    )
+    ret = write_header(header)
+
+    num_patch_faces = sum(len(p.faces) for p in patches)
+    num_faces = len(internal_faces) + num_patch_faces
+
+    ret += f"{num_faces}\n(\n"
+    for f in internal_faces:
+        ret += f"{f.neighbour}\n"
+    for p in patches:
+        for f in p.faces:
+            ret += f"{f.neighbour}\n"
+    ret += ")\n"
+    return ret
+
+
+"""
+def _write_face_zones(zones: list[FaceZone]) -> str:
+
+    header = FoamFile(
+        location="constant/polyMesh",
+        foam_object="faceZones",
+        foam_class="regIOobject",
+        meta={"names": tuple(zone.name for zone in zones)},
+    )
+    ret = write_header(header)
+
+    ret += f"{len(zones)}\n( "
+    for zone in zones:
+        ret += f"{zone.name}\n{{"
+        ret += "\ttype\tfaceZone;\n\tfaceLabels\tList<label>\n"
+        ret += f"{len(zone.faces)}\n("
+        for face in zone.faces:
+            ret += f"{face}\n"
+        ret += ");\n"
+        ret += "\tflipMap\tList<bool>\n"
+        ret += f"{len(zone.faces)}\n("
+        for face in zone.faces:
+            ret += "0\n"
+        ret += ");\n"
+        ret += "}\n\n"
+    ret += ")"
+    return ret
+"""
+
+
+def _write_boundaries(patches: list[PolymeshPatch]):
+
+    header = FoamFile(
+        location="constant/polyMesh",
+        foam_object="boundary",
+        foam_class="polyBoundaryMesh",
+    )
+    ret = write_header(header)
+
+    ret += f"{len(patches)}(\n"
+    for p in patches:
+        ret += f"{p.name}\n{{"
+        ret += f"\ttype\t{p.type};\n"
+        ret += f"\tnFaces\t{len(p.faces)};\n"
+        ret += f"\tstartFace\t{p.startFace};\n"
+        ret += "}\n\n"
+    ret += ")"
+    return ret
+
+
+def _faces_equal(f0, f1):
+    return set(f0) == set(f1)
+
+
+def _compare_faces(f0: Face, f1: Face):
+    if f0.owner == f1.owner:
+        if f0.neighbour == f1.neighbour:
+            return 0
+        elif f0.neighbour > f1.neighbour:
+            return 1
+        else:
+            return -1
+    else:
+        if f0.owner > f1.owner:
+            return 1
+        else:
+            return -1
+
+
+def _build_faces(mesh: Mesh) -> list[Face]:
+    faces: list[Face] = []
+
+    count = 0
+    for idx, cell in enumerate(mesh.cells):
+        hex_faces = get_hex_faces(cell)
+        for hex_face in hex_faces:
+            found = False
+            for face in faces:
+                if _faces_equal(hex_face, face.vertices):
+                    if idx < face.owner:
+                        faces[face.id] = Face(
+                            vertices=tuple(list(reversed(face.vertices))),
+                            owner=idx,
+                            id=face.id,
+                            neighbour=face.owner,
+                        )
+                    else:
+                        faces[face.id] = Face(
+                            vertices=face.vertices,
+                            owner=face.owner,
+                            id=face.id,
+                            neighbour=idx,
+                        )
+                    found = True
+                    break
+            if not found:
+                faces.append(Face(id=count, vertices=hex_face, owner=idx, neighbour=-1))
+                count += 1
+
+    faces.sort(key=cmp_to_key(_compare_faces))
+    return faces
+
+
+def _get_external_faces(faces: tuple[Face, ...]) -> tuple[Face, ...]:
+    return tuple(f for f in faces if f.neighbour == -1)
+
+
+def _get_internal_faces(faces: tuple[Face, ...]) -> tuple[Face, ...]:
+    return tuple(f for f in faces if f.neighbour != -1)
+
+
+def write_polymesh(path: Path, mesh: Mesh, patch_funcs: dict):
+
+    # Write points
+    with open(path / "points", "w", encoding="utf-8") as f:
+        f.write(_write_points(mesh.vertices))
+
+    # Prepare faces, owners and neighbours
+    faces = _build_faces(mesh)
+
+    internal_faces = _get_internal_faces(tuple(faces))
+    external_faces = _get_external_faces(tuple(faces))
+
+    # Get patches
+    count = len(internal_faces)
+    patches = []
+    for name, func in patch_funcs.items():
+        patch_faces = tuple(f for f in external_faces if func(f.get_centre(mesh)))
+        patches.append(PolymeshPatch(name=name, faces=patch_faces, startFace=count))
+        count += len(patch_faces)
+
+    # Add a default wall patch
+    wall_faces = []
+    for face in external_faces:
+        found = False
+        for patch in patches:
+            if patch.has_face(face):
+                found = True
+                break
+        if not found:
+            wall_faces.append(face)
+    patches.append(
+        PolymeshPatch(
+            name="wall",
+            type="wall",
+            faces=tuple(f for f in wall_faces),
+            startFace=count,
+        )
+    )
+
+    with open(path / "faces", "w", encoding="utf-8") as f:
+        f.write(_write_faces(internal_faces, patches))
+
+    with open(path / "owner", "w", encoding="utf-8") as f:
+        f.write(_write_owners(internal_faces, patches))
+
+    with open(path / "neighbour", "w", encoding="utf-8") as f:
+        f.write(_write_neighbours(internal_faces, patches))
+
+    # Write boundaries
+    with open(path / "boundary", "w", encoding="utf-8") as f:
+        f.write(_write_boundaries(patches))

{icplot-0.2.3 → icplot-0.2.4}/src/icplot/mesh/shapes.py

@@ -15,7 +15,7 @@ from .mesh import Mesh
 from .vertex import Vertex, find_closest
 from .cell import Cell, HexCell
 
-from .operations import map_radial, close_mesh, merge_meshes
+from .operations import map_radial, close_mesh, merge_meshes, mesh_extrude
 
 
 def mesh_rectangle(rect: Quad, num_width: int = 10, num_height: int = 10) -> Mesh:
@@ -64,13 +64,80 @@ def mesh_annulus(
         num_width=num_circumferential,
         num_height=num_radial,
     )
-    radial_mesh = map_radial(rect_mesh, annulus.angle)
+    radial_mesh = map_radial(rect_mesh, annulus.angle).flip_normals()
 
     if annulus.angle == 360:
         return close_mesh(radial_mesh)
     return radial_mesh
 
 
+def _rotate_list(lst, n):
+    return lst[n:] + lst[:n]
+
+
+def _close_circle(inner_mesh: Mesh, outer_mesh: Mesh, num_circumferential: int) -> Mesh:
+
+    num_side = int(num_circumferential / 4)
+    inner_verts = []
+
+    # Base
+    for idx in range(num_side + 1):
+        inner_verts.append(idx)
+
+    # RHS
+    for idx in range(1, num_side + 1):
+        inner_verts.append((idx + 1) * (num_side + 1) - 1)
+
+    # Top
+    for idx in range(2, num_side + 2):
+        inner_verts.append((num_side + 1) * (num_side + 1) - idx)
+
+    # Left
+    for idx in range(2, num_side + 1):
+        inner_verts.append((num_side + 1) * (num_side + 1 - idx))
+
+    inner_verts = _rotate_list(inner_verts, num_side + 1 + int((num_side + 1) / 2) - 1)
+
+    new_nodes = []
+    new_cells = []
+    count = 0
+    for idx in range(num_circumferential):
+
+        next_id = idx + 1
+        if next_id == num_circumferential:
+            next_id = 0
+
+        outer_next = outer_mesh.vertices[next_id]
+        nearest_next = inner_mesh.vertices[inner_verts[next_id]]
+
+        if idx == 0:
+            outer = outer_mesh.vertices[idx]
+            nearest = inner_mesh.vertices[inner_verts[idx]]
+
+            new_nodes.append(Vertex(x=nearest.x, y=nearest.y, z=nearest.z, id=count))
+            new_nodes.append(Vertex(x=outer.x, y=outer.y, z=outer.z, id=count + 1))
+            count += 2
+
+        new_nodes.append(
+            Vertex(x=nearest_next.x, y=nearest_next.y, z=nearest_next.z, id=count)
+        )
+        new_nodes.append(
+            Vertex(x=outer_next.x, y=outer_next.y, z=outer_next.z, id=count + 1)
+        )
+        count += 2
+        new_cells.append(
+            Cell(type="quad", vertices=(count - 2, count - 4, count - 3, count - 1))
+        )
+
+    # Create mesh interface layer
+    mesh_interface = Mesh(cells=tuple(new_cells), vertices=tuple(new_nodes))
+    mesh_interface = close_mesh(mesh_interface)
+
+    # Merge mesh interface layer
+    inner_merged = merge_meshes(inner_mesh, mesh_interface)
+    return merge_meshes(inner_merged, outer_mesh)
+
+
 def mesh_circle(
     circle: Circle,
     boundary_frac: float = 0.5,
@@ -97,8 +164,59 @@ def mesh_circle(
         num_height=int(num_circumferential / 4),
     )
 
-    merged = merge_meshes(annulus_mesh, inner_mesh)
-    return merged
+    return _close_circle(inner_mesh, annulus_mesh, num_circumferential)
+
+
+def mesh_cylinder_basic(
+    cylinder: Cylinder,
+    boundary_frac: float = 0.5,
+    num_radial: int = 2,
+    num_circumferential: int = 8,
+    num_height=5,
+) -> Mesh:
+
+    return mesh_extrude(
+        mesh_circle(
+            Circle(radius=cylinder.diameter / 2),
+            boundary_frac,
+            num_radial,
+            num_circumferential,
+        ),
+        cylinder.length,
+        num_height,
+    )
+
+
+def mesh_compound_cylinder(
+    inlet_radius,
+    inlet_height,
+    radius,
+    height,
+    boundary_fraction,
+    num_circumferential,
+    num_radial,
+    num_height,
+) -> Mesh:
+
+    inner = mesh_cylinder_basic(
+        Cylinder(diameter=inlet_radius * 2, length=2 * inlet_height + height),
+        boundary_fraction,
+        num_radial,
+        num_circumferential,
+        num_height * int(height / inlet_height) + 2 * num_height,
+    )
+
+    main_body = mesh_annulus(
+        Annulus(outer_radius=radius, inner_radius=inlet_radius),
+        num_radial=num_radial,
+        num_circumferential=num_circumferential,
+    )
+    main_body = mesh_extrude(
+        main_body, height, num_cells=num_height * int(height / inlet_height)
+    )
+
+    main_body = main_body.move_by(0.0, 0.0, inlet_height)
+    return merge_meshes(main_body, inner)
 
 
 def mesh_cuboid(cuboid: Cuboid, elements_per_dim: int = 5) -> Mesh:

{icplot-0.2.3 → icplot-0.2.4}/src/icplot/mesh/vertex.py

@@ -55,3 +55,26 @@ def find_closest(verts: list[Vertex], point: Point) -> int:
             min_distance = distance
 
     return min_id
+
+
+def find_closest_vertex(verts: tuple[Vertex, ...], v: Vertex) -> Vertex:
+
+    if not verts:
+        raise RuntimeError("Can't find nearest vert in empty list")
+
+    min_id = -1
+    min_distance = 0.0
+    for idx, vert in enumerate(verts):
+
+        distance = vert.get_vertex_distance(v)
+
+        if idx == 0:
+            min_id = idx
+            min_distance = distance
+            continue
+
+        if distance < min_distance:
+            min_id = idx
+            min_distance = distance
+
+    return verts[min_id]

{icplot-0.2.3 → icplot-0.2.4/src/icplot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icplot
-Version: 0.2.3
+Version: 0.2.4
 Summary: Utilities for generating plots and graphics for technical reports.
 Author-email: "James Grogan, Irish Centre for High End Computing" <james.grogan@ichec.ie>
 Project-URL: Repository, https://git.ichec.ie/performance/toolshed/icplot

icplot-0.2.4/test/test_meshing.py

@@ -0,0 +1,94 @@
+from iccore.test_utils import get_test_output_dir
+
+from icplot.geometry import Quad, Annulus, Circle, Cylinder
+from icplot.mesh import (
+    vtk,
+    mesh_rectangle,
+    mesh_annulus,
+    mesh_circle,
+    mesh_extrude,
+    mesh_cylinder_basic,
+    mesh_compound_cylinder,
+)
+
+
+def test_mesh_rectangle():
+
+    output_dir = get_test_output_dir()
+
+    rect = Quad(width=5.0, height=5.0)
+    mesh = mesh_rectangle(rect, 5, 5)
+
+    vtk.write_unstructured_grid(mesh, output_dir / "rectangle.vtk")
+
+
+def test_annulus():
+
+    output_dir = get_test_output_dir()
+
+    shape = Annulus(outer_radius=1.0, inner_radius=0.5, angle=360)
+    mesh = mesh_annulus(shape, 2, 8)
+
+    vtk.write_unstructured_grid(mesh, output_dir / "annulus.vtk")
+    vtk.write_unstructured_grid(
+        mesh_extrude(mesh, 5, 5), output_dir / "annulus_extruded.vtk"
+    )
+
+
+def test_circle():
+
+    output_dir = get_test_output_dir()
+
+    shape = Circle(radius=1.0)
+    mesh = mesh_circle(shape, 0.7, 4, 24)
+
+    vtk.write_unstructured_grid(mesh, output_dir / "circle.vtk")
+
+
+def test_extrude():
+
+    output_dir = get_test_output_dir()
+
+    rect = Quad(width=5.0, height=5.0)
+    mesh = mesh_rectangle(rect, 5, 5)
+
+    extruded_mesh = mesh_extrude(mesh, 5, 5)
+
+    vtk.write_unstructured_grid(extruded_mesh, output_dir / "extrude.vtk")
+
+
+def test_cylinder():
+
+    output_dir = get_test_output_dir()
+
+    shape = Cylinder(diameter=2.0, length=5.0)
+    mesh = mesh_cylinder_basic(shape, 0.5, 2, 16, 5)
+
+    vtk.write_unstructured_grid(mesh, output_dir / "cylinder.vtk")
+
+
+def xtest_compound_cylinder():
+
+    output_dir = get_test_output_dir()
+
+    inlet_radius = 0.5
+    inlet_height = 1.0
+    radius = 2.0
+    height = 5.0
+    boundary_fraction = 0.5
+    num_circumferential = 16
+    num_radial = 4
+    num_height = 4
+
+    mesh = mesh_compound_cylinder(
+        inlet_radius,
+        inlet_height,
+        radius,
+        height,
+        boundary_fraction,
+        num_circumferential,
+        num_radial,
+        num_height,
+    )
+
+    vtk.write_unstructured_grid(mesh, output_dir / "compound_cylinder.vtk")

icplot-0.2.4/test/test_polymesh.py

@@ -0,0 +1,124 @@
+from pathlib import Path
+import shutil
+
+from icplot.mesh.openfoam import polymesh
+from icplot.mesh import (
+    mesh_cylinder_basic,
+    mesh_compound_cylinder,
+    mesh_rectangle,
+    mesh_extrude,
+    vtk,
+)
+from icplot.geometry import Cylinder, Point, Quad
+
+from iccore.test_utils import get_test_data_dir, get_test_output_dir
+
+
+def xtest_read_polymesh():
+
+    data_dir = get_test_data_dir()
+
+    mesh = polymesh.read_polymesh(data_dir / "openfoam/polymesh/basic")
+    print(mesh)
+
+
+def inlet_func(face_centre: Point):
+    return face_centre.z == 0.0
+
+
+def outlet_func(face_centre: Point):
+    return face_centre.z == 5.0
+
+
+def test_polymesh_cube():
+
+    output_dir = get_test_output_dir()
+    polymesh_dir = output_dir / "constant/polyMesh"
+    polymesh_dir.mkdir(parents=True, exist_ok=True)
+
+    system_dir = output_dir / "system"
+    system_dir.mkdir(parents=True, exist_ok=True)
+
+    control_path = Path(__file__).parent.parent / "src/icplot/mesh/openfoam/controlDict"
+    shutil.copy(control_path, system_dir)
+
+    shape = Quad(width=1.0, height=1.0)
+    mesh = mesh_rectangle(shape, 2, 2)
+    mesh = mesh_extrude(mesh, 5.0, 2)
+
+    vtk.write_unstructured_grid(mesh, output_dir / "cube.vtk")
+
+    polymesh.write_polymesh(
+        polymesh_dir, mesh, {"inlet": inlet_func, "outlet": outlet_func}
+    )
+
+
+def test_polymesh_cylinder():
+
+    output_dir = get_test_output_dir()
+    polymesh_dir = output_dir / "constant/polyMesh"
+    polymesh_dir.mkdir(parents=True, exist_ok=True)
+
+    system_dir = output_dir / "system"
+    system_dir.mkdir(parents=True, exist_ok=True)
+
+    control_path = Path(__file__).parent.parent / "src/icplot/mesh/openfoam/controlDict"
+    shutil.copy(control_path, system_dir)
+
+    shape = Cylinder(diameter=2.0, length=5.0)
+    mesh = mesh_cylinder_basic(shape, 0.5, 2, 8, 2)
+
+    vtk.write_unstructured_grid(mesh, output_dir / "cylinder.vtk")
+
+    polymesh.write_polymesh(
+        polymesh_dir, mesh, {"inlet": inlet_func, "outlet": outlet_func}
+    )
+
+
+def compound_inlet_func(face_centre: Point):
+    return face_centre.z == 0.0
+
+
+def compound_outlet_func(face_centre: Point):
+    return face_centre.z == 7.0
+
+
+def xtest_polymesh_compound_cylinder():
+
+    output_dir = get_test_output_dir()
+    polymesh_dir = output_dir / "constant/polyMesh"
+    polymesh_dir.mkdir(parents=True, exist_ok=True)
+
+    system_dir = output_dir / "system"
+    system_dir.mkdir(parents=True, exist_ok=True)
+
+    control_path = Path(__file__).parent.parent / "src/icplot/mesh/openfoam/controlDict"
+    shutil.copy(control_path, system_dir)
+
+    inlet_radius = 0.5
+    inlet_height = 1.0
+    radius = 2.0
+    height = 5.0
+    boundary_fraction = 0.5
+    num_circumferential = 16
+    num_radial = 4
+    num_height = 4
+
+    mesh = mesh_compound_cylinder(
+        inlet_radius,
+        inlet_height,
+        radius,
+        height,
+        boundary_fraction,
+        num_circumferential,
+        num_radial,
+        num_height,
+    )
+
+    vtk.write_unstructured_grid(mesh, output_dir / "compound_cylinder.vtk")
+
+    polymesh.write_polymesh(
+        polymesh_dir,
+        mesh,
+        {"inlet": compound_inlet_func, "outlet": compound_outlet_func},
+    )

icplot-0.2.3/src/icplot/mesh/openfoam/polymesh.py

@@ -1,46 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-
-from icplot.mesh import Vertex
-
-from .foamfile import read_foamfile
-
-
-@dataclass(frozen=True)
-class Face:
-    """
-    A mesh face, which is a sequence of points
-    """
-
-    points: tuple[int, ...]
-    id: int = -1
-
-
-@dataclass(frozen=True)
-class Cell:
-    """
-    A mesh cell, which is a squence of faces
-    """
-
-    faces: tuple[int, ...]
-    id: int = -1
-
-
-@dataclass(frozen=True)
-class Polymesh:
-    """
-    The polymesh
-    """
-
-    points: tuple[Vertex, ...]
-    faces: tuple[Face, ...]
-    cells: tuple[Cell, ...]
-
-
-def read_polymesh(path: Path) -> Polymesh:
-
-    points_file = read_foamfile(path / "points")
-    # faces_file = read_foamfile(path / "faces")
-    print(points_file)
-    # print(faces_file)
-    return Polymesh((), (), ())

icplot-0.2.3/test/test_meshing.py

@@ -1,49 +0,0 @@
-from iccore.test_utils import get_test_output_dir
-
-from icplot.geometry import Quad, Annulus, Circle
-from icplot.mesh import vtk, mesh_rectangle, mesh_annulus, mesh_circle, mesh_extrude
-
-
-def test_mesh_rectangle():
-
-    output_dir = get_test_output_dir()
-
-    rect = Quad(width=5.0, height=5.0)
-    mesh = mesh_rectangle(rect, 5, 5)
-
-    vtk.write_unstructured_grid(mesh, output_dir / "rectangle.vtk")
-
-
-def test_annulus():
-
-    output_dir = get_test_output_dir()
-
-    shape = Annulus(outer_radius=1.0, inner_radius=0.5, angle=360)
-    mesh = mesh_annulus(shape, 2, 8)
-
-    vtk.write_unstructured_grid(mesh, output_dir / "annulus.vtk")
-    vtk.write_unstructured_grid(
-        mesh_extrude(mesh, 5, 5), output_dir / "annulus_extruded.vtk"
-    )
-
-
-def test_circle():
-
-    output_dir = get_test_output_dir()
-
-    shape = Circle(radius=1.0)
-    mesh = mesh_circle(shape, 0.5, 2, 8)
-
-    vtk.write_unstructured_grid(mesh, output_dir / "circle.vtk")
-
-
-def test_extrude():
-
-    output_dir = get_test_output_dir()
-
-    rect = Quad(width=5.0, height=5.0)
-    mesh = mesh_rectangle(rect, 5, 5)
-
-    extruded_mesh = mesh_extrude(mesh, 5, 5)
-
-    vtk.write_unstructured_grid(extruded_mesh, output_dir / "extrude.vtk")

icplot-0.2.3/test/test_polymesh.py

@@ -1,10 +0,0 @@
-from icplot.mesh.openfoam import polymesh
-from iccore.test_utils import get_test_data_dir
-
-
-def test_read_polymesh():
-
-    data_dir = get_test_data_dir()
-
-    mesh = polymesh.read_polymesh(data_dir / "openfoam/polymesh/basic")
-    print(mesh)