icplot 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

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/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/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/mesh/openfoam/polymesh.py

@@ -1,19 +1,31 @@
 from dataclasses import dataclass
 from pathlib import Path
+from functools import cmp_to_key
 
-from icplot.mesh import Vertex
+from icplot.geometry import Point
+from icplot.mesh import Vertex, Mesh, get_hex_faces
 
-from .foamfile import read_foamfile
+from .foamfile import read_foamfile, FoamFile, write_header
 
 
 @dataclass(frozen=True)
 class Face:
     """
-    A mesh face, which is a sequence of points
+    A mesh face, which is a sequence of vertices
     """
 
-    points: tuple[int, ...]
+    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)
@@ -32,11 +44,25 @@ class Polymesh:
     The polymesh
     """
 
-    points: tuple[Vertex, ...]
+    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")
@@ -44,3 +70,246 @@ def read_polymesh(path: Path) -> Polymesh:
     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/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/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.dist-info → icplot-0.2.4.dist-info}/METADATA

@@ -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.dist-info → icplot-0.2.4.dist-info}/RECORD

@@ -29,22 +29,22 @@ icplot/graph/series.py,sha256=ppzQeFPY9w6Tx8RPPjEt98YXbyhNRv9QfvCJVglmtm4,3164
 icplot/graph/video.py,sha256=NxE6WanX3pS9t8XTQyaNwdkiaZL85qlJn1TwPZ-81-I,748
 icplot/graph/vtk.py,sha256=om-zujuxDKqT8IUfPkiNpanoTWwaYuXOpL2WjaLX7Xs,1918
 icplot/mesh/__init__.py,sha256=H0TKi_J8mPhd-9kRIm_9IrJh_dtx-77tAXKPFCEGptA,178
-icplot/mesh/cell.py,sha256=f13N5wY_-BX1JbZgGsnGXGTb5HpmjvgTnBVMQhZGtb0,1407
+icplot/mesh/cell.py,sha256=kNlo5xWKAFQkqFZxWA4FHMG5sgFQ1m68uV8xGlcdJK0,2297
 icplot/mesh/edge.py,sha256=C33Trp9JKhUhEp28Bflwh6T7occ--Mh-qOWWenZq7qw,784
-icplot/mesh/mesh.py,sha256=8CkdW43rrApb0QnozABjiWg2mkNdP8xonQTW8KdrW0g,2651
+icplot/mesh/mesh.py,sha256=iw24box7maKpFNbkCaCJYTedV3eVV0pjqaxepP3PjIw,3372
 icplot/mesh/operations.py,sha256=KI8Viup-qRAzPXytKYIMJko2Vko-I2VJKGXs1I6N_RA,3672
-icplot/mesh/shapes.py,sha256=M0JvOXbEE48FddL3FMBIU2HZs4r1rsFH-0b2aY64vFI,6005
-icplot/mesh/vertex.py,sha256=5gtcxzRVONqyWe0JSoTZMRg3lRD0QE817OaKeEpfKjE,1334
+icplot/mesh/shapes.py,sha256=WvrDwTgz-PAjRRrWfFtsXAzW9b8GVUY9v7Uqk7zkUik,9321
+icplot/mesh/vertex.py,sha256=Nh2pTaXJuOANAp8rb03D4OpMG3nk_i_JWQHQWnynXpQ,1851
 icplot/mesh/vtk.py,sha256=BIBi4i6j7veGqcGamzS9RJA3D6C5JRiV-lyOCL0Z3vM,1148
 icplot/mesh/openfoam/__init__.py,sha256=oTBDlpRpOUHlzyyAZvnkvO5ZAOVk1LMc3kZhHTwXL-I,97
 icplot/mesh/openfoam/blockmesh.py,sha256=0Y-n_tARdeLxcVmLScjvnNDB-wnigMiZQFrUh9OlXm8,3417
-icplot/mesh/openfoam/foamfile.py,sha256=dsqqSlsnKMyTrw9L88Csgzqep-TS-vxLuSIlQpUU0c0,3005
-icplot/mesh/openfoam/polymesh.py,sha256=EBkxr5bS-QXUQLI7vxYhBIrzGYOpvlpyCbxqJXMdUUo,805
+icplot/mesh/openfoam/foamfile.py,sha256=WQVdE0bNsPB5gOFvNdwVcVxfPbN2gVjtxtD2PlxIHAk,3349
+icplot/mesh/openfoam/polymesh.py,sha256=32QEJM6MtWvCeMV0bVcuXjCwkZp-qobo9sjx2vyZUkM,8547
 icplot/trace/__init__.py,sha256=JL9a1GQa-Ty4nujQ3dLv2dETX8J1iGDm8PlGL2Ug1dQ,29
 icplot/trace/trace.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-icplot-0.2.3.dist-info/licenses/LICENSE,sha256=JedcPd23DfREo3CH5_Sc8He0jmmbOWIm1_sQaisXZ9E,34592
-icplot-0.2.3.dist-info/METADATA,sha256=49i7jqU4jlMKti9zQZ0Uk0SoMuLyG8fkXrfWmAaxTtA,2791
-icplot-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-icplot-0.2.3.dist-info/entry_points.txt,sha256=6CdEGO5Z4NTQoOeRITTKGtzT3xNX47CGHZuWNWxZuZs,52
-icplot-0.2.3.dist-info/top_level.txt,sha256=T_ecIGmXlOO4_xP86S-OFL8nnoxmDQFXjcDoIwpiHQk,7
-icplot-0.2.3.dist-info/RECORD,,
+icplot-0.2.4.dist-info/licenses/LICENSE,sha256=JedcPd23DfREo3CH5_Sc8He0jmmbOWIm1_sQaisXZ9E,34592
+icplot-0.2.4.dist-info/METADATA,sha256=deb2q2lchW9ZfJ68OeBKQK00kX6ccgVd2ILpPY1cob0,2791
+icplot-0.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+icplot-0.2.4.dist-info/entry_points.txt,sha256=6CdEGO5Z4NTQoOeRITTKGtzT3xNX47CGHZuWNWxZuZs,52
+icplot-0.2.4.dist-info/top_level.txt,sha256=T_ecIGmXlOO4_xP86S-OFL8nnoxmDQFXjcDoIwpiHQk,7
+icplot-0.2.4.dist-info/RECORD,,