icplot 0.1.6__tar.gz → 0.1.7__tar.gz

{icplot-0.1.6/src/icplot.egg-info → icplot-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icplot
-Version: 0.1.6
+Version: 0.1.7
 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
@@ -18,6 +18,7 @@ Requires-Dist: wand
 Requires-Dist: matplotlib
 Requires-Dist: vtk
 Requires-Dist: moviepy
+Requires-Dist: scipy
 Requires-Dist: iccore==0.1.13
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"

{icplot-0.1.6 → icplot-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "icplot"
-version = "0.1.6"
+version = "0.1.7"
 authors = [
   { name="James Grogan, Irish Centre for High End Computing", email="james.grogan@ichec.ie" },
 ]
@@ -20,6 +20,7 @@ dependencies = ["wand",
 	       "matplotlib",
                "vtk",
                "moviepy",
+               "scipy",
 	       "iccore==0.1.13"]
 
 [project.urls]
@@ -50,7 +51,7 @@ build-backend = "setuptools.build_meta"
 icplot = "icplot.main_cli:main_cli"
 
 [tool.setuptools.package-data]
-"icplot" = ["py.typed"]
+"icplot" = ["py.typed", "controlDict"]
 
 [tool.setuptools.packages.find]
 where = ["src"]
@@ -61,7 +62,7 @@ ignore_missing_imports = true
 [tool.pylint.main]
 
 source-roots = ["src"]
-fail-under = 9.33
+fail-under = 9.2
 
 [tool.pylint.basic]
 

{icplot-0.1.6 → icplot-0.1.7}/src/icplot/geometry.py

@@ -5,9 +5,11 @@ dependent work.
 """
 
 from __future__ import annotations
-import copy
 from dataclasses import dataclass
 
+import numpy as np
+from scipy.spatial.transform import Rotation
+
 
 @dataclass(frozen=True)
 class Vector:
@@ -22,6 +24,9 @@ class Vector:
     def scale(self, factor: float) -> Vector:
         return Vector(self.x * factor, self.y * factor, self.z * factor)
 
+    def as_array(self) -> np.ndarray:
+        return np.array([self.x, self.y, self.z])
+
 
 @dataclass(frozen=True)
 class Point:
@@ -33,9 +38,16 @@ class Point:
     y: float = 0.0
     z: float = 0.0
 
+    def as_array(self) -> np.ndarray:
+        return np.array([self.x, self.y, self.z])
+
     def translate(self, v: Vector) -> Point:
         return Point(self.x + v.x, self.y + v.y, self.z + v.z)
 
+    @staticmethod
+    def from_array(arr: np.ndarray) -> Point:
+        return Point(arr[0], arr[1], arr[2])
+
 
 @dataclass(frozen=True)
 class Shape:
@@ -43,10 +55,26 @@ class Shape:
     A shape in 3d space, defaults to having a normal to Z
     """
 
-    loc: Point
+    loc: Point = Point(0.0, 0.0, 0.0)
     normal: Vector = Vector(0.0, 0.0, 1.0)
 
 
+def get_rotation_matrix(vec0, vec1):
+    """get rotation matrix between two vectors using scipy"""
+    vec0 = np.reshape(vec0, (1, -1))
+    vec1 = np.reshape(vec1, (1, -1))
+    r = Rotation.align_vectors(vec0, vec1)
+    return r[0].as_matrix()
+
+
+def get_normal(p0, p1, p2):
+    direction = np.cross(p1 - p0, p2 - p0)
+    return direction / np.linalg.norm(direction)
+
+
+_GLOBAL_Z = np.array([0.0, 0.0, 1.0])
+
+
 @dataclass(frozen=True)
 class Quad(Shape):
     """
@@ -58,14 +86,32 @@ class Quad(Shape):
 
     @property
     def points(self) -> list[Point]:
-        p = copy.deepcopy(self.loc)
-        return [
-            p,
-            p.translate(Vector(self.width)),
-            p.translate(Vector(self.width, self.height)),
-            p.translate(Vector(0.0, self.height)),
+
+        points = [
+            self.loc.translate(Vector(-self.width / 2.0, -self.height / 2.0)),
+            self.loc.translate(Vector(self.width / 2.0, -self.height / 2.0)),
+            self.loc.translate(Vector(self.width / 2.0, self.height / 2.0)),
+            self.loc.translate(Vector(-self.width / 2.0, self.height / 2.0)),
+        ]
+
+        rot = get_rotation_matrix(_GLOBAL_Z, self.normal.as_array())
+        rotated_points = [
+            Point.from_array(
+                rot.dot(p.as_array() - self.loc.as_array()) + self.loc.as_array()
+            )
+            for p in points
         ]
 
+        plane_normal = get_normal(
+            rotated_points[0].as_array(),
+            rotated_points[1].as_array(),
+            rotated_points[3].as_array(),
+        )
+
+        if np.dot(plane_normal, self.normal.as_array()) < 0:
+            rotated_points.reverse()
+        return rotated_points
+
     def translate(self, v: Vector) -> Quad:
         return Quad(self.loc.translate(v), self.normal, self.width, self.height)
 
@@ -76,10 +122,10 @@ class Cuboid(Shape):
     A regular cuboid
     """
 
-    loc: Point
     width: float = 1.0
     height: float = 1.0
     depth: float = 1.0
+    top_width_scale: float = 1.0
 
     def translate(self, v: Vector) -> Cuboid:
         return Cuboid(
@@ -89,8 +135,20 @@ class Cuboid(Shape):
     @property
     def points(self) -> list[Point]:
 
-        base = Quad(self.loc, self.normal, self.width, self.height)
-        top = base.translate(self.normal.scale(self.depth))
+        base = Quad(
+            self.loc.translate(Vector(0.0, 0.0, -self.depth / 2.0)),
+            self.normal,
+            self.width,
+            self.height,
+        )
+
+        top = Quad(
+            self.loc.translate(Vector(0.0, 0.0, -self.depth / 2.0)),
+            self.normal,
+            self.width * self.top_width_scale,
+            self.height,
+        )
+        top = top.translate(self.normal.scale(self.depth))
         return base.points + top.points
 
 

{icplot-0.1.6 → icplot-0.1.7}/src/icplot/graph/vtk.py

@@ -1,17 +1,33 @@
 from pathlib import Path
+import logging
 
 import numpy as np
-import vtk
-from vtk.util import numpy_support
 
 from iccore.data.units import DateRange
 from iccore.data import Series
 
 from .plot_group import PlotGroup
 
+_HAS_VTK = True
+try:
+    import vtk
+    from vtk.util import numpy_support
+except ImportError as e:
+    logging.getLogger(__name__).warning(
+        "Disabling VTK stupport. Failed to load with: %s", e
+    )
+    _HAS_VTK = False
+
+
+def has_vtk() -> bool:
+    return _HAS_VTK
+
 
 def to_grid(series: Series, dates: DateRange | None):
 
+    if not has_vtk():
+        raise RuntimeError("VTK support failed to load")
+
     if not series.x:
         raise ValueError("Attempting to plot a series with no data")
 
@@ -45,6 +61,9 @@ def to_grid(series: Series, dates: DateRange | None):
 
 def save(path: Path, config: PlotGroup, series: Series, filename: str = "series"):
 
+    if not has_vtk():
+        raise RuntimeError("VTK support failed to load")
+
     grid = to_grid(series, config.date_range)
 
     writer = vtk.vtkStructuredGridWriter()

{icplot-0.1.6 → icplot-0.1.7}/src/icplot/image_utils.py

@@ -7,14 +7,36 @@ import logging
 import os
 from pathlib import Path
 
-from wand.image import Image
-from wand.color import Color
-import cairosvg
-
+_HAS_WAND = True
+try:
+    from wand.image import Image
+    from wand.color import Color
+except ImportError as e:
+    logging.getLogger(__name__).warning(
+        "Disabling Wand stupport. Failed to load with: %s", e
+    )
+    _HAS_WAND = False
+
+_HAS_CAIRO_SVG = True
+try:
+    import cairosvg
+except ImportError as e:
+    logging.getLogger(__name__).warning(
+        "Disabling CairoSVG stupport. Failed to load with: %s", e
+    )
+    _HAS_CAIRO_SVG = False
 
 logger = logging.getLogger(__name__)
 
 
+def has_wand() -> bool:
+    return _HAS_WAND
+
+
+def has_cairo_svg() -> bool:
+    return _HAS_CAIRO_SVG
+
+
 def _get_out_filename(source: Path, target: Path | None, extension: str) -> Path:
     if target:
         return target
@@ -26,6 +48,9 @@ def pdf_to_png(source: Path, target: Path | None = None, resolution: int = 300):
     Convert a pdf to png with white background
     """
 
+    if not has_wand():
+        raise RuntimeError("Loading Wand failed - no pdf to png support")
+
     outfile = _get_out_filename(source, target, "png")
     os.makedirs(outfile.parent, exist_ok=True)
 
@@ -41,6 +66,9 @@ def svg_to_png(source: Path, target: Path | None = None):
     Convert an svg to png
     """
 
+    if not has_cairo_svg():
+        raise RuntimeError("Loading Cairosvg failed - no svg to png support")
+
     outfile = _get_out_filename(source, target, "png")
     os.makedirs(outfile.parent, exist_ok=True)
     cairosvg.svg2png(url=str(source), write_to=str(outfile))
@@ -51,6 +79,9 @@ def svg_to_pdf(source: Path, target: Path | None = None):
     Convert an svg to pdf
     """
 
+    if not has_cairo_svg():
+        raise RuntimeError("Loading Cairosvg failed - no svg to pdf support")
+
     outfile = _get_out_filename(source, target, "pdf")
     os.makedirs(outfile.parent, exist_ok=True)
     cairosvg.svg2pdf(url=str(source), write_to=str(outfile))

icplot-0.1.7/src/icplot/mesh/foam.py

@@ -0,0 +1,140 @@
+"""
+Meshing utilities for use in openfoam
+"""
+
+import shutil
+import subprocess
+import os
+from pathlib import Path
+from dataclasses import dataclass
+
+from .mesh import Mesh, Block, Edge, Patch
+
+
+@dataclass(frozen=True)
+class FoamFile:
+
+    version: str = "2.0"
+    format: str = "ascii"
+    arch: str = "LSB;label=32;scalar=64"
+    foam_class: str = "dictionary"
+    location: str = "system"
+    object: str = "blockMeshDict"
+
+
+def _get_foam_header(spec: FoamFile) -> str:
+
+    output = "FoamFile\n{"
+    output += f"\tversion\t{spec.version};\n"
+    output += f"\tformat\t{spec.format};\n"
+    output += f'\tarch\t"{spec.arch}";\n'
+    output += f"\tclass\t{spec.foam_class};\n"
+    output += f'\tlocation\t"{spec.location}";\n'
+    output += f"\tobject\t{spec.object};\n"
+    output += "}\n\n"
+    return output
+
+
+def has_openfoam() -> bool:
+    return bool(shutil.which("openfoam")) and bool(shutil.which("blockMesh"))
+
+
+def _mesh_blocks(blocks: tuple[Block, ...]) -> str:
+
+    output = "blocks\n(\n"
+    for b in blocks:
+        verts = " ".join(str(v) for v in b.vertices)
+        output += f"\thex ({verts})\n"
+
+        counts = " ".join(str(c) for c in b.cell_counts)
+        output += f"\t({counts})\n"
+
+        grades = " ".join(str(g) for g in b.grading_ratios)
+        output += f"\t{b.grading} ({grades})\n"
+    output += ");\n\n"
+    return output
+
+
+def _mesh_edges(edges: tuple[Edge, ...]) -> str:
+
+    if not edges:
+        return ""
+
+    output = "edges\n(\n"
+    for e in edges:
+        if e.type == "line":
+            output += f"\tline {e.vert0} {e.vert1}\n"
+        else:
+            interps = ""
+            for p in e.interp_points:
+                interps += f"({p.x} {p.y} {p.z}) "
+            output += f"\t {e.type} {e.vert0} {e.vert1} {interps}\n"
+    output += ");\n\n"
+    return output
+
+
+def _mesh_boundaries(patches: tuple[Patch, ...]) -> str:
+
+    if not patches:
+        return ""
+
+    output = "boundary\n(\n"
+    for patch in patches:
+        output += f"\t{patch.name}\n"
+        output += "\t{\n"
+        output += f"\t\ttype {patch.type};\n"
+        output += "\t\tfaces\n\t\t(\n"
+        for f in patch.faces:
+            faces = " ".join(str(idx) for idx in f)
+            output += f"\t\t\t({faces})\n"
+        output += "\t\t);\n"
+        output += "\t}\n"
+    output += ");\n\n"
+    return output
+
+
+def mesh_to_foam(mesh: Mesh, spec: FoamFile = FoamFile()) -> str:
+    """
+    Given a mesh, write it in openfoam blockMesh format
+    """
+
+    output = _get_foam_header(spec)
+
+    output += f"scale\t{mesh.scale};\n"
+
+    output += "vertices\n(\n"
+    for idx, v in enumerate(mesh.vertices):
+        output += f"\t( {v.x} {v.y} {v.z} ) // # {idx} \n"
+    output += ");\n\n"
+
+    output += _mesh_edges(mesh.edges)
+
+    output += _mesh_blocks(mesh.blocks)
+
+    output += _mesh_boundaries(mesh.patches)
+
+    return output
+
+
+def generate_mesh(mesh: Mesh, case_dir: Path):
+
+    if not has_openfoam():
+        raise RuntimeError("Openfoam not found, can't generate mesh")
+
+    system_dir = case_dir / "system"
+    os.makedirs(system_dir, exist_ok=True)
+
+    mesh_str = mesh_to_foam(mesh)
+    mesh_file = system_dir / "blockMeshDict"
+    with open(mesh_file, "w", encoding="utf-8") as f:
+        f.write(mesh_str)
+
+    control_dict = system_dir / "controlDict"
+    if not control_dict.exists():
+        shutil.copy(Path(__file__).parent / "controlDict", control_dict)
+
+    cmd = f"blockMesh -case {case_dir}"
+    subprocess.run(cmd, cwd=case_dir, shell=True, check=True)
+
+    cmd = f"blockMesh -case {case_dir} -write-vtk"
+    subprocess.run(cmd, cwd=case_dir, shell=True, check=True)

icplot-0.1.7/src/icplot/mesh/mesh.py

@@ -0,0 +1,274 @@
+"""
+Module for describing mesh elements. Goes for simplicity and low dependencies
+over performance. Consider something else for high performance meshing.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass
+
+import numpy as np
+
+from icplot.geometry import Point, Vector, Cuboid, Cylinder
+
+
+@dataclass(frozen=True)
+class Vertex:
+    """
+    A mesh vertext
+    """
+
+    x: float
+    y: float
+    z: float = 0.0
+    id: int = -1
+
+    @staticmethod
+    def from_point(p: Point, id: int = -1) -> Vertex:
+        return Vertex(p.x, p.y, p.z, id)
+
+    def as_array(self) -> np.ndarray:
+        return np.array([self.x, self.y, self.z])
+
+    def get_distance(self, p: Point) -> float:
+        return float(np.linalg.norm(p.as_array() - self.as_array()))
+
+
+@dataclass(frozen=True)
+class Edge:
+    """
+    A mesh edge - consists of two verts
+    """
+
+    vert0: int
+    vert1: int
+    type: str = "line"
+    interp_points: tuple[Point, ...] = ()
+
+
+@dataclass(frozen=True)
+class Block:
+    """
+    A hex mesh element - used in openfoam meshing
+    """
+
+    vertices: tuple[int, ...]
+    cell_counts: tuple[int, ...] = (1, 1, 1)
+    grading: str = "simpleGrading"
+    grading_ratios: tuple[int, ...] = (1, 1, 1)
+
+    def get_top_edges(self) -> tuple:
+        return (
+            (self.vertices[0], self.vertices[1]),
+            (self.vertices[1], self.vertices[2]),
+            (self.vertices[2], self.vertices[3]),
+            (self.vertices[3], self.vertices[0]),
+        )
+
+    def get_bottom_edges(self) -> tuple:
+        return (
+            (self.vertices[4], self.vertices[5]),
+            (self.vertices[5], self.vertices[6]),
+            (self.vertices[6], self.vertices[7]),
+            (self.vertices[7], self.vertices[4]),
+        )
+
+    def get_side_edges(self) -> tuple:
+        return (
+            (self.vertices[0], self.vertices[4]),
+            (self.vertices[1], self.vertices[5]),
+            (self.vertices[2], self.vertices[6]),
+            (self.vertices[3], self.vertices[7]),
+        )
+
+    def get_edges(self) -> tuple:
+        return self.get_bottom_edges() + self.get_top_edges() + self.get_side_edges()
+
+
+@dataclass(frozen=True)
+class Patch:
+    """
+    A collection of mesh faces - used for openfoam boundaries
+    """
+
+    type: str
+    name: str
+    faces: tuple[tuple[int, ...], ...]
+
+
+def is_between(v0: Vertex, v1: Vertex, p: Point, tol: float = 1.0e-4) -> bool:
+
+    dv0v1 = np.linalg.norm(v1.as_array() - v0.as_array())
+    dv0p = np.linalg.norm(v0.as_array() - p.as_array())
+    dv1p = np.linalg.norm(v1.as_array() - p.as_array())
+    return np.abs(dv0p + dv1p - dv0v1) < tol
+
+
+def line_distance(v0: Vertex, v1: Vertex, p: Point) -> float:
+
+    pv0 = p.as_array() - v0.as_array()
+    v1v0 = v1.as_array() - v0.as_array()
+    side0 = np.dot(pv0, v1v0)
+    if side0 < 0.0:
+        return float(np.linalg.norm(pv0))
+    pv1 = p.as_array() - v1.as_array()
+    side1 = np.dot(pv1, v0.as_array() - v1.as_array())
+    if side1 < 0.0:
+        return float(np.linalg.norm(pv1))
+    length = np.linalg.norm(v1v0)
+    proj = (side1 * v0.as_array() + side0 * v1.as_array()) / (length * length)
+    return float(np.linalg.norm(p.as_array() - proj))
+
+
+@dataclass(frozen=True)
+class Mesh:
+    """
+    A mesh tailored for use in openfoam
+    """
+
+    vertices: tuple[Vertex, ...]
+    blocks: tuple[Block, ...]
+    edges: tuple[Edge, ...] = ()
+    patches: tuple[Patch, ...] = ()
+    scale: float = 1.0
+
+    def select_edge(self, p: Point) -> tuple[int, int]:
+
+        for b in self.blocks:
+            for e in b.get_edges():
+                if is_between(self.vertices[e[0]], self.vertices[e[1]], p):
+                    return (e[0], e[1])
+        raise RuntimeError("No edge found at selection point")
+
+    def get_closest_edge(self, p: Point) -> tuple[int, int]:
+
+        min_dist = -1.0
+        closest_edges: tuple[int, int] = (-1, -1)
+        for b in self.blocks:
+            for e in b.get_edges():
+                dist = line_distance(self.vertices[e[0]], self.vertices[e[1]], p)
+                if min_dist == -1.0:
+                    min_dist = dist
+                    closest_edges = (e[0], e[1])
+                    continue
+                if dist < min_dist:
+                    min_dist = dist
+                    closest_edges = (e[0], e[1])
+        return closest_edges
+
+
+def from_cuboid(cuboid: Cuboid, elements_per_dim: int = 5) -> Mesh:
+
+    verts = tuple(Vertex.from_point(p) for p in cuboid.points)
+
+    cell_counts = (elements_per_dim, elements_per_dim, elements_per_dim)
+    blocks = (Block(tuple(range(len(verts))), cell_counts),)
+    return Mesh(verts, blocks)
+
+
+def find_closest_vert(verts: list[Vertex], point: Point) -> int:
+
+    if not verts:
+        raise RuntimeError("Can't find nearest vert in empty list")
+
+    min_id = -1
+    min_distance = 0.0
+    for idx, v in enumerate(verts):
+
+        distance = v.get_distance(point)
+
+        if idx == 0:
+            min_id = idx
+            min_distance = distance
+            continue
+
+        if distance < min_distance:
+            min_id = idx
+            min_distance = distance
+
+    return min_id
+
+
+def from_cuboids(
+    cuboids: list[Cuboid], elements_per_dim: int = 5, merge_tolerance: float = 1.0e-4
+) -> Mesh:
+
+    verts: list = []
+    block_vert_ids: list = []
+    for cuboid in cuboids:
+        vert_ids = []
+        for p in cuboid.points:
+
+            if not verts:
+                verts.append(Vertex.from_point(p, 0))
+                vert_ids.append(0)
+                continue
+
+            nearest_id = find_closest_vert(verts, p)
+            if verts[nearest_id].get_distance(p) <= merge_tolerance:
+                vert_ids.append(nearest_id)
+            else:
+                end_id = len(verts)
+                verts.append(Vertex.from_point(p, end_id))
+                vert_ids.append(end_id)
+        block_vert_ids.append(vert_ids)
+
+    cell_counts = (elements_per_dim, elements_per_dim, elements_per_dim)
+    blocks = tuple(Block(tuple(b), cell_counts) for b in block_vert_ids)
+    return Mesh(tuple(verts), blocks)
+
+
+def from_cylinder(cylinder: Cylinder, boundary_frac: float = 0.66) -> Mesh:
+
+    depth = (cylinder.diameter - boundary_frac * cylinder.diameter) / 2.0
+    cuboids = [
+        Cuboid(
+            Point(0.0, 0.0, depth / 2.0),
+            width=cylinder.diameter,
+            height=cylinder.length,
+            depth=depth,
+            top_width_scale=boundary_frac,
+        ),
+        Cuboid(
+            Point(0.0, 0.0, cylinder.diameter + depth / 2.0),
+            width=cylinder.diameter,
+            height=cylinder.length,
+            depth=depth,
+            normal=Vector(0.0, 0.0, -1.0),
+            top_width_scale=boundary_frac,
+        ),
+        Cuboid(
+            Point(-cylinder.diameter / 2.0, 0.0, cylinder.diameter / 2.0 + depth / 2.0),
+            width=cylinder.diameter,
+            height=cylinder.length,
+            depth=depth,
+            normal=Vector(1.0, 0.0, 0.0),
+            top_width_scale=boundary_frac,
+        ),
+        Cuboid(
+            Point(cylinder.diameter / 2.0, 0.0, cylinder.diameter / 2.0 + depth / 2.0),
+            width=cylinder.diameter,
+            height=cylinder.length,
+            depth=depth,
+            normal=Vector(-1.0, 0.0, 0.0),
+            top_width_scale=boundary_frac,
+        ),
+        Cuboid(
+            Point(0.0, 0.0, cylinder.diameter * boundary_frac / 2.0 + depth),
+            width=cylinder.diameter * boundary_frac,
+            height=cylinder.length,
+            depth=boundary_frac * cylinder.diameter,
+        ),
+    ]
+
+    mesh = from_cuboids(cuboids)
+
+    top_front_edge = mesh.get_closest_edge(
+        Point(0.0, -cylinder.length / 2.0, cylinder.diameter + depth / 2.0)
+    )
+    top_front_arc = Point(
+        0.0, -cylinder.length / 2.0, cylinder.diameter + depth / 2.0 + 0.15
+    )
+
+    edges = (Edge(top_front_edge[0], top_front_edge[1], "arc", (top_front_arc,)),)
+
+    return Mesh(mesh.vertices, mesh.blocks, edges=edges)

icplot-0.1.7/src/icplot/mesh/vtk.py

@@ -0,0 +1,44 @@
+from pathlib import Path
+import os
+import logging
+
+from .mesh import Mesh
+
+_HAS_VTK = True
+try:
+    import vtk
+except ImportError as e:
+    logging.getLogger(__name__).warning(
+        "Disabling VTK stupport. Failed to load with: %s", e
+    )
+    _HAS_VTK = False
+
+
+def has_vtk() -> bool:
+    return _HAS_VTK
+
+
+def write_mesh(mesh: Mesh, path: Path):
+
+    if not has_vtk():
+        raise RuntimeError("VTK support failed to load")
+
+    os.makedirs(path.parent, exist_ok=True)
+
+    points = vtk.vtkPoints()
+    for v in mesh.vertices:
+        points.InsertNextPoint(v.x, v.y, v.z)
+
+    grid = vtk.vtkUnstructuredGrid()
+    grid.SetPoints(points)
+    for block in mesh.blocks:
+        cell = vtk.vtkHexahedron()
+        for idx, v_id in enumerate(block.vertices):
+            cell.GetPointIds().SetId(idx, v_id)
+        grid.InsertNextCell(cell.GetCellType(), cell.GetPointIds())
+
+    writer = vtk.vtkUnstructuredGridWriter()
+    writer.SetInputData(grid)
+    writer.SetFileName(path)
+    writer.SetFileTypeToASCII()
+    writer.Write()

{icplot-0.1.6 → icplot-0.1.7/src/icplot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icplot
-Version: 0.1.6
+Version: 0.1.7
 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
@@ -18,6 +18,7 @@ Requires-Dist: wand
 Requires-Dist: matplotlib
 Requires-Dist: vtk
 Requires-Dist: moviepy
+Requires-Dist: scipy
 Requires-Dist: iccore==0.1.13
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"

{icplot-0.1.6 → icplot-0.1.7}/src/icplot.egg-info/SOURCES.txt

@@ -36,10 +36,12 @@ src/icplot/graph/vtk.py
 src/icplot/mesh/__init__.py
 src/icplot/mesh/foam.py
 src/icplot/mesh/mesh.py
+src/icplot/mesh/vtk.py
 src/icplot/trace/__init__.py
 src/icplot/trace/trace.py
 test/test_cairo_interface.py
 test/test_gantt_chart.py
+test/test_geometry.py
 test/test_image_utils.py
 test/test_line_plots.py
 test/test_mermaid.py

{icplot-0.1.6 → icplot-0.1.7}/src/icplot.egg-info/requires.txt

@@ -2,6 +2,7 @@ wand
 matplotlib
 vtk
 moviepy
+scipy
 iccore==0.1.13
 
 [cairo]

icplot-0.1.7/test/test_geometry.py

@@ -0,0 +1,69 @@
+import pytest
+
+from icplot.geometry import Point, Vector, Quad, Cuboid
+
+
+def test_quad():
+
+    quad = Quad(Point(0.0, 0.0, 0.0))
+    points = quad.points
+
+    assert points[0].x == -0.5
+    assert points[0].y == -0.5
+
+    assert points[1].x == 0.5
+    assert points[1].y == -0.5
+
+
+def test_quad_with_rotation():
+
+    normal = Vector(0.0, 1.0, 0.0)
+
+    quad = Quad(Point(0.0, 0.0, 0.0), normal)
+    points = quad.points
+
+    assert points[0].x == pytest.approx(-0.5)
+    assert points[0].y == pytest.approx(0.0)
+    assert points[0].z == pytest.approx(0.5)
+
+    assert points[1].x == pytest.approx(0.5)
+    assert points[1].y == pytest.approx(0.0)
+    assert points[1].z == pytest.approx(0.5)
+
+
+def test_cuboid():
+
+    shape = Cuboid(Point(0.0, 0.0, 0.0))
+    points = shape.points
+
+    assert points[0].x == -0.5
+    assert points[0].y == -0.5
+    assert points[0].z == -0.5
+
+    assert points[1].x == 0.5
+    assert points[1].y == -0.5
+
+    assert points[4].x == -0.5
+    assert points[4].y == -0.5
+    assert points[4].z == 0.5
+
+
+def test_cuboid_rotation():
+
+    return
+
+    normal = Vector(0.0, 1.0, 0.0)
+
+    shape = Cuboid(Point(0.0, 0.0, 0.0), normal)
+    points = shape.points
+
+    assert points[0].x == -0.5
+    assert points[0].y == -0.5
+    assert points[0].z == -0.5
+
+    assert points[1].x == 0.5
+    assert points[1].y == -0.5
+
+    assert points[4].x == -0.5
+    assert points[4].y == -0.5
+    assert points[4].z == 0.5

icplot-0.1.7/test/test_mesh.py

@@ -0,0 +1,36 @@
+from iccore.test_utils import get_test_output_dir
+
+from icplot.geometry import Point, Cylinder, Cuboid
+from icplot.mesh import foam, vtk, from_cylinder, from_cuboid
+
+
+def test_closest_edge():
+
+    cuboid = Cuboid()
+
+    mesh = from_cuboid(cuboid)
+
+    closest_edge = mesh.get_closest_edge(Point(0.0, -0.5, -0.5))
+
+    assert closest_edge[0] == 0
+    assert closest_edge[1] == 1
+
+
+def test_mesh():
+
+    output_dir = get_test_output_dir()
+
+    cylinder = Cylinder(loc=Point(0.0, 0.0, 0.0), length=2.0, diameter=1.0)
+
+    mesh = from_cylinder(cylinder)
+    vtk.write_mesh(mesh, output_dir / "cylinder.vtk")
+    # return
+
+    foam_str = foam.mesh_to_foam(mesh)
+
+    assert foam_str
+
+    if not foam.has_openfoam():
+        return
+
+    foam.generate_mesh(mesh, output_dir)

icplot-0.1.6/src/icplot/mesh/foam.py

@@ -1,56 +0,0 @@
-"""
-Meshing utilities for use in openfoam
-"""
-
-from .mesh import Mesh
-
-
-def mesh_to_foam(mesh: Mesh) -> str:
-    """
-    Given a mesh, write it in openfoam blockMesh format
-    """
-
-    output = f"scale\t{mesh.scale}\n"
-
-    output += "vertices\n(\n"
-    for idx, v in enumerate(mesh.vertices):
-        output += f"\t( {v.x} {v.y} {v.z} ) // # {idx} \n"
-    output += ");\n\n"
-
-    output += "edges\n(\n"
-    for e in mesh.edges:
-        if e.type == "line":
-            output += f"\tline {e.vert0} {e.vert1}\n"
-        else:
-            interps = ""
-            for p in e.interp_points:
-                interps += f"({p.x} {p.y} {p.z}) "
-            output += f"\t {e.type} {e.vert0} {e.vert1} {interps}\n"
-    output += ");\n\n"
-
-    output += "blocks\n(\n"
-    for b in mesh.blocks:
-        verts = " ".join(str(v) for v in b.vertices)
-        output += f"\thex({verts})\n"
-
-        counts = " ".join(str(c) for c in b.cell_counts)
-        output += f"\t({counts})\n"
-
-        grades = " ".join(str(g) for g in b.grading_ratios)
-        output += f"\t{b.grading} ({grades})\n"
-    output += ");\n\n"
-
-    output += "boundary\n(\n"
-    for patch in mesh.patches:
-        output += f"\t{patch.name}\n"
-        output += "\t{\n"
-        output += f"\t\ttype {patch.type};\n"
-        output += "\t\tfaces\n\t\t(\n"
-        for f in patch.faces:
-            faces = " ".join(str(idx) for idx in f)
-            output += f"\t\t\t({faces})\n"
-        output += "\t\t);\n"
-        output += "\t}\n"
-    output += ");\n\n"
-
-    return output

icplot-0.1.6/src/icplot/mesh/mesh.py

@@ -1,79 +0,0 @@
-"""
-Module for describing mesh elements. Goes for simplicity and low dependencies
-over performance. Consider something else for high performance meshing.
-"""
-
-from __future__ import annotations
-from dataclasses import dataclass
-
-from icplot.geometry import Point, Cuboid
-
-
-@dataclass(frozen=True)
-class Vertex:
-    """
-    A mesh vertext
-    """
-
-    x: float
-    y: float
-    z: float = 0.0
-
-    @staticmethod
-    def from_point(p: Point) -> Vertex:
-        return Vertex(p.x, p.y, p.z)
-
-
-@dataclass(frozen=True)
-class Edge:
-    """
-    A mesh edge - consists of two verts
-    """
-
-    vert0: int
-    vert1: int
-    type: str = "line"
-    interp_points: tuple[Point, ...] = ()
-
-
-@dataclass(frozen=True)
-class Block:
-    """
-    A hex mesh element - used in openfoam meshing
-    """
-
-    vertices: tuple[int, ...]
-    cell_counts: tuple[int, ...] = (1, 1, 1)
-    grading: str = "simple"
-    grading_ratios: tuple[int, ...] = (1, 1, 1)
-
-
-@dataclass(frozen=True)
-class Patch:
-    """
-    A collection of mesh faces - used for openfoam boundaries
-    """
-
-    type: str
-    name: str
-    faces: tuple[tuple[int, ...], ...]
-
-
-@dataclass(frozen=True)
-class Mesh:
-    """
-    A mesh tailored for use in openfoam
-    """
-
-    vertices: tuple[Vertex, ...]
-    blocks: tuple[Block, ...]
-    edges: tuple[Edge, ...] = ()
-    patches: tuple[Patch, ...] = ()
-    scale: float = 1.0
-
-
-def from_cuboid(cuboid: Cuboid) -> Mesh:
-
-    verts = tuple(Vertex.from_point(p) for p in cuboid.points)
-    blocks = (Block(tuple(range(len(verts)))),)
-    return Mesh(verts, blocks)

icplot-0.1.6/test/test_mesh.py

@@ -1,13 +0,0 @@
-from icplot.geometry import Point, Cuboid
-from icplot.mesh import foam, from_cuboid
-
-
-def test_mesh():
-
-    cuboid = Cuboid(Point(0.0, 0.0, 0.0))
-
-    mesh = from_cuboid(cuboid)
-
-    foam_str = foam.mesh_to_foam(mesh)
-
-    assert foam_str