icplot 0.2.2__tar.gz → 0.2.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icplot
-Version: 0.2.2
+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
@@ -19,7 +19,8 @@ Requires-Dist: matplotlib
 Requires-Dist: vtk
 Requires-Dist: moviepy
 Requires-Dist: scipy
-Requires-Dist: iccore==0.2.2
+Requires-Dist: iccore==0.2.3
+Requires-Dist: graphviz
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"

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

@@ -1,6 +1,6 @@
 [project]
 name = "icplot"
-version = "0.2.2"
+version = "0.2.4"
 authors = [
   { name="James Grogan, Irish Centre for High End Computing", email="james.grogan@ichec.ie" },
 ]
@@ -21,7 +21,8 @@ dependencies = ["wand",
                "vtk",
                "moviepy",
                "scipy",
-	       "iccore==0.2.2"]
+	       "iccore==0.2.3",
+               "graphviz"]
 
 [project.urls]
 Repository = "https://git.ichec.ie/performance/toolshed/icplot"

icplot-0.2.4/src/icplot/geometry/__init__.py

@@ -0,0 +1,4 @@
+from .base import *  # NOQA
+from .operations import *  # NOQA
+from .shapes import *  # NOQA
+from .transform import *  # NOQA

icplot-0.2.4/src/icplot/geometry/base.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+from dataclasses import dataclass
+
+import numpy as np
+
+
+@dataclass(frozen=True)
+class Vector:
+    """
+    A 3d spatial vector
+    """
+
+    x: float
+    y: float = 0.0
+    z: float = 0.0
+
+    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])
+
+    def subtract(self, v: Vector) -> Vector:
+        return Vector(self.x - v.x, self.y - v.y, self.z - v.z)
+
+
+@dataclass(frozen=True)
+class Point:
+    """
+    A location in 3d space
+    """
+
+    x: float
+    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])
+
+    def subtract(self, v: Vector) -> Vector:
+        return Vector(self.x - v.x, self.y - v.y, self.z - v.z)
+
+
+@dataclass(frozen=True)
+class Bounds:
+    """
+    A bounding box
+    """
+
+    xmin: float
+    xmax: float
+    ymin: float
+    ymax: float
+    zmin: float = 0.0
+    zmax: float = 0.0

icplot-0.2.4/src/icplot/geometry/operations.py

@@ -0,0 +1,57 @@
+import numpy as np
+from scipy.spatial.transform import Rotation
+
+
+def get_rotation_matrix(vec0, vec1):
+    """
+    Get the matrix required to rotate vec0 to vec1
+    """
+    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_three_point_normal(p0, p1, p2):
+    """
+    Get the normal to the plane given by three points
+    """
+    direction = np.cross(p1 - p0, p2 - p0)
+    return direction / np.linalg.norm(direction)
+
+
+def segment_contains_point(v0, v1, p, tol: float = 1.0e-4) -> bool:
+    """
+    True if the line segment defined by v0 and v1 contains point p
+    """
+
+    dv0v1 = np.linalg.norm(v1 - v0)
+    dv0p = np.linalg.norm(v0 - p)
+    dv1p = np.linalg.norm(v1 - p)
+    return np.abs(dv0p + dv1p - dv0v1) < tol
+
+
+def get_point_distance(p0, p1) -> float:
+    """
+    Return the distance between two points
+    """
+    return float(np.linalg.norm(p1 - p0))
+
+
+def get_segment_distance(v0, v1, p) -> float:
+    """
+    Return the distance between the line segment v0-v1 and the point p
+    """
+
+    pv0 = p - v0
+    v1v0 = v1 - v0
+    side0 = np.dot(pv0, v1v0)
+    if side0 < 0.0:
+        return float(np.linalg.norm(pv0))
+    pv1 = p - v1
+    side1 = np.dot(pv1, v0 - v1)
+    if side1 < 0.0:
+        return float(np.linalg.norm(pv1))
+    length = np.linalg.norm(v1v0)
+    proj = (side1 * v0 + side0 * v1) / (length * length)
+    return float(np.linalg.norm(p - proj))

icplot-0.2.4/src/icplot/geometry/shapes.py

@@ -0,0 +1,155 @@
+"""
+Module for primitive geometries. This is used to keep dependencies simple,
+consider a real geometry library like cgal for more complex or performance
+dependent work.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass
+
+from .base import Point, Vector
+from .transform import Transform
+
+
+@dataclass(frozen=True)
+class Shape:
+    """
+    A shape in 3d space, defaults to having a normal to Z
+    """
+
+    transform: Transform = Transform()
+
+
+@dataclass(frozen=True)
+class Circle(Shape):
+
+    radius: float = 1.0
+
+
+@dataclass(frozen=True)
+class Annulus(Shape):
+
+    outer_radius: float = 1.0
+    inner_radius: float = 0.5
+    angle: float = 360  # degrees
+
+
+@dataclass(frozen=True)
+class Quad(Shape):
+    """
+    A regular quadrilateral in 3d space, defaults to be normal to Z
+    """
+
+    width: float = 1.0
+    height: float = 1.0
+
+    @property
+    def points(self) -> list[Point]:
+
+        locs = ((0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0))
+
+        points = [
+            self.transform.get_point_at_offset(
+                self.width * loc[0], self.height * loc[1], 0.0
+            )
+            for loc in locs
+        ]
+        points = self.transform.centre_points(points)
+        return self.transform.align_points_with_normal(points)
+
+    def translate(self, v: Vector) -> Quad:
+        return Quad(self.transform.translate(v), self.width, self.height)
+
+
+@dataclass(frozen=True)
+class Cuboid(Shape):
+    """
+    A regular cuboid
+    """
+
+    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(self.transform.translate(v), self.width, self.height, self.depth)
+
+    @property
+    def points(self) -> list[Point]:
+
+        base = Quad(
+            self.transform.translate(Vector(0.0, 0.0, -self.depth / 2.0)),
+            self.width,
+            self.height,
+        )
+
+        top = Quad(
+            self.transform.translate(Vector(0.0, 0.0, -self.depth / 2.0)),
+            self.width * self.top_width_scale,
+            self.height,
+        )
+        top = top.translate(self.transform.normal.scale(self.depth))
+        return base.points + top.points
+
+
+@dataclass(frozen=True)
+class Cylinder(Shape):
+    """
+    A cylinder
+    """
+
+    diameter: float = 1.0
+    length: float = 1.0
+
+    @property
+    def start(self) -> Point:
+        return self.transform.location
+
+    @property
+    def end(self) -> Point:
+        return self.transform.get_point_at_normal_offset(self.length)
+
+
+@dataclass(frozen=True)
+class Revolution(Shape):
+    """
+    A revolved profile sitting on the plane given by the loc
+    and normal and revolved about the normal.
+    """
+
+    diameter: float = 1.0
+    length: float = 1.0
+    profile: str = "arc"
+
+
+@dataclass(frozen=True)
+class CuboidGrid:
+    """
+    A irregular grid composed of cuboids. Can be useful for
+    generating topological meshes like OpenFoam's blockMesh.
+    """
+
+    x_locs: list[float]
+    y_locs: list[float]
+    z_locs: list[float]
+
+    @property
+    def cuboids(self) -> list[Cuboid]:
+        ret = []
+
+        for kdx, z in enumerate(self.z_locs[:-1]):
+            for jdx, y in enumerate(self.y_locs[:-1]):
+                for idx, x in enumerate(self.x_locs[:-1]):
+                    width = self.x_locs[idx + 1] - x
+                    height = self.y_locs[jdx + 1] - y
+                    depth = self.z_locs[kdx + 1] - z
+                    ret.append(
+                        Cuboid(
+                            Transform(location=Point(x, y, z)),
+                            width=width,
+                            height=height,
+                            depth=depth,
+                        )
+                    )
+        return ret

icplot-0.2.4/src/icplot/geometry/transform.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+from dataclasses import dataclass
+
+import numpy as np
+
+from .base import Point, Vector
+from .operations import get_three_point_normal, get_rotation_matrix
+
+
+_GLOBAL_Z = np.array([0.0, 0.0, 1.0])
+
+
+def get_normal_from_points(p0: Point, p1: Point, p2: Point):
+    return get_three_point_normal(p0.as_array(), p1.as_array(), p2.as_array())
+
+
+@dataclass(frozen=True)
+class Transform:
+    location: Point = Point(0.0, 0.0, 0.0)
+    normal: Vector = Vector(0.0, 0.0, 1.0)
+    scale: Vector = Vector(1.0, 1.0, 1.0)
+    angle: float = 0.0  # degrees
+
+    def translate(self, v: Vector) -> Transform:
+        return Transform(
+            self.location.translate(v), self.normal, self.scale, self.angle
+        )
+
+    def get_point_at_offset(self, x: float, y: float, z: float = 0.0) -> Point:
+        return self.location.translate(Vector(x, y, z))
+
+    def get_point_at_normal_offset(self, offset: float) -> Point:
+        return self.location.translate(self.normal.scale(offset))
+
+    def get_rotation_matrix(self, relative_to: Vector | None = None):
+        if relative_to:
+            return get_rotation_matrix(relative_to.as_array(), self.normal.as_array())
+        return get_rotation_matrix(_GLOBAL_Z, self.normal.as_array())
+
+    def centre_points(self, points: list[Point]) -> list[Point]:
+        x = sum(p.x for p in points) / len(points)
+        y = sum(p.y for p in points) / len(points)
+        z = sum(p.z for p in points) / len(points)
+        delta = self.location.subtract(Vector(x, y, z))
+        return [p.translate(delta) for p in points]
+
+    def align_points_with_normal(self, points: list[Point]) -> list[Point]:
+
+        rot = self.get_rotation_matrix()
+        rotated_points = [
+            Point.from_array(
+                rot.dot(p.as_array() - self.location.as_array())
+                + self.location.as_array()
+            )
+            for p in points
+        ]
+
+        plane_normal = get_normal_from_points(
+            rotated_points[0],
+            rotated_points[1],
+            rotated_points[3],
+        )
+
+        if np.dot(plane_normal, self.normal.as_array()) < 0:
+            rotated_points.reverse()
+        return rotated_points

icplot-0.2.4/src/icplot/mesh/__init__.py

@@ -0,0 +1,6 @@
+from .cell import *  # NOQA
+from .edge import *  # NOQA
+from .vertex import *  # NOQA
+from .mesh import *  # NOQA
+from .operations import *  # NOQA
+from .shapes import *  # NOQA

icplot-0.2.4/src/icplot/mesh/cell.py

@@ -0,0 +1,74 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Cell:
+    """
+    A mesh cell
+    """
+
+    vertices: tuple[int, ...]
+    type: str = ""
+
+    def get_edges(self) -> tuple:
+        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):
+    """
+    A hex mesh element - used in openfoam meshing
+    """
+
+    cell_counts: tuple[int, ...] = (1, 1, 1)
+    grading: str = "simpleGrading"
+    grading_ratios: tuple[int, ...] = (1, 1, 1)
+    type = "hex"
+
+    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()

icplot-0.2.4/src/icplot/mesh/edge.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+
+from icplot.geometry import Point, segment_contains_point, get_segment_distance
+
+from .vertex import Vertex
+
+
+@dataclass(frozen=True)
+class Edge:
+    """
+    A mesh edge - consists of two verts
+    """
+
+    vert0: int
+    vert1: int
+    type: str = "line"
+    interp_points: tuple[Point, ...] = ()
+
+
+def contains_point(v0: Vertex, v1: Vertex, p: Point, tol: float = 1.0e-4) -> bool:
+    """
+    True if the edge given by v0 and v1 contains point p
+    """
+    return segment_contains_point(v0.as_array(), v1.as_array(), p.as_array(), tol)
+
+
+def get_distance(v0: Vertex, v1: Vertex, p: Point) -> float:
+    """
+    Return the distance between the point and the edge
+    """
+    return get_segment_distance(v0.as_array(), v1.as_array(), p.as_array())

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

@@ -0,0 +1,107 @@
+"""
+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, Vector, Transform, Bounds
+
+from .vertex import Vertex, find_closest_vertex
+from .cell import Cell, flip_normals
+from .edge import Edge, contains_point, get_distance
+
+
+@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:
+
+    vertices: tuple[Vertex, ...]
+    cells: tuple[Cell, ...]
+    scale: float = 1.0
+    edges: tuple[Edge, ...] = ()
+    patches: tuple[Patch, ...] = ()
+
+    def get_bounds(self) -> Bounds:
+        if len(self.vertices) == 0:
+            raise RuntimeError("Can't get bounds on empty mesh")
+
+        xmin = self.vertices[0].x
+        xmax = xmin
+        ymin = self.vertices[0].y
+        ymax = ymin
+        zmin = self.vertices[0].z
+        zmax = zmin
+        for v in self.vertices:
+            xmin = min(xmin, v.x)
+            xmax = max(xmax, v.x)
+            ymin = min(ymin, v.y)
+            ymax = max(ymax, v.y)
+            zmin = min(zmin, v.z)
+            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)
+
+    def apply_transform(self, t: Transform) -> Mesh:
+        delta = t.location.subtract(self.get_location())
+        return 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:
+            for e in c.get_edges():
+                if contains_point(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_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
+        closest_edges: tuple[int, int] = (-1, -1)
+        for b in self.cells:
+            for e in b.get_edges():
+                dist = get_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 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.4/src/icplot/mesh/openfoam/__init__.py

@@ -0,0 +1,3 @@
+from .foamfile import *  # NOQA
+from .blockmesh import *  # NOQA
+from .polymesh import *  # NOQA