plot3d 1.7.7__tar.gz → 1.7.9__tar.gz

{plot3d-1.7.7 → plot3d-1.7.9}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: plot3d
-Version: 1.7.7
+Version: 1.7.9
 Summary: Plot3D python utilities for reading and writing and also finding connectivity between blocks
 Author: Paht Juangphanich
 Author-email: paht.juangphanich@nasa.gov
@@ -8,6 +8,8 @@ Requires-Python: >=3.10.12,<4.0.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: matplotlib
 Requires-Dist: networkx
 Requires-Dist: numpy

{plot3d-1.7.7 → plot3d-1.7.9}/plot3d/glennht/class_definitions.py

@@ -8,11 +8,11 @@ from typing import Any, Dict, List, Optional
 # Enums (mirror your C#)
 # ----------------------------
 class BoundaryConditionType(IntEnum):
-    Inlet = 0
-    Outlet = 1
-    SymmetryOrSlip = 2
-    Wall = 3
-    GIF = 4
+    Inlet = 1
+    Outlet = 2
+    SymmetryOrSlip = 3
+    Wall = 4
+    GIF = 1000
 
 class InletBC_Subtype(IntEnum):
     Normal = 0

{plot3d-1.7.7 → plot3d-1.7.9}/plot3d/glennht/export_functions.py

@@ -331,29 +331,57 @@ def export_to_boundary_condition(
     }
     json_path.write_text(json.dumps(json_payload, indent=4))
 
-    # ---- Robust reference defaults (use inlet values if missing)
+    # ---- Robust reference defaults (use highest-pressure inlet if available)
     ref = job_settings.ReferenceCondFull
-    first_inlet = bc_group.Inlets[0] if bc_group.Inlets else None
+
+    def _reference_inlet(inlets: List[Any]) -> Tuple[Any | None, float | None]:
+        best = None
+        best_pa: float | None = None
+        for inlet in inlets:
+            p0 = getattr(inlet, "P0_const", None)
+            if p0 is None:
+                continue
+            phys_pa = to_pa(p0, getattr(inlet, "P0_const_unit", "Pa"))
+            if phys_pa is None:
+                continue
+            if best_pa is None or phys_pa > best_pa:
+                best = inlet
+                best_pa = phys_pa
+        if best is None and inlets:
+            return inlets[0], None
+        return best, best_pa
+
+    ref_inlet, ref_inlet_pa = _reference_inlet(bc_group.Inlets)
 
     # refLen: default 1.0 if missing
     if getattr(ref, "reflen", None) in (None, 0):
         ref.reflen = 1.0  # type: ignore
 
-    # refP0: from first inlet (convert to Pa) if missing
+    # refP0: from highest-pressure inlet (convert to Pa) if missing
     if getattr(ref, "refP0", None) in (None, 0):
-        if first_inlet and getattr(first_inlet, "P0_const", None) is not None:
-            phys_pa = to_pa(first_inlet.P0_const, getattr(first_inlet, "P0_const_unit", "Pa"))
-            ref.refP0 = phys_pa  # type: ignore
+        if ref_inlet_pa not in (None, 0):
+            ref.refP0 = ref_inlet_pa  # type: ignore
 
     # refT0: from first inlet if missing
     if getattr(ref, "refT0", None) in (None, 0):
-        if first_inlet and getattr(first_inlet, "T0_const", None) is not None:
-            ref.refT0 = first_inlet.T0_const  # type: ignore
+        if ref_inlet and getattr(ref_inlet, "T0_const", None) is not None:
+            ref.refT0 = ref_inlet.T0_const  # type: ignore
+
+    def _dedupe_by_bc_id(objs: Iterable[Any]) -> List[Any]:
+        seen: set[int] = set()
+        unique: List[Any] = []
+        for obj in objs:
+            sid = obj.get("id") if isinstance(obj, dict) else getattr(obj, "SurfaceID", None)
+            if sid is None or sid in seen:
+                continue
+            seen.add(sid)
+            unique.append(obj)
+        return unique
 
     # ---- Write .bcs file
     with path.open("w", encoding="utf-8") as w:
         # INLETS (normalize to refP0, refT0, refLen)
-        for inlet in bc_group.Inlets:
+        for inlet in _dedupe_by_bc_id(bc_group.Inlets):
             if getattr(inlet, "P0_const", None) is not None:
                 phys_pa = to_pa(inlet.P0_const, getattr(inlet, "P0_const_unit", "Pa"))
                 if phys_pa is not None and ref.refP0 not in (None, 0):
@@ -369,7 +397,7 @@ def export_to_boundary_condition(
             _write_bsurf_spec(w, inlet)
 
         # OUTLETS (normalize back-pressure by refP0)
-        for outlet in bc_group.Outlets:
+        for outlet in _dedupe_by_bc_id(bc_group.Outlets):
             if getattr(outlet, "Pback_const", None) is not None and ref.refP0 not in (None, 0):
                 phys_pa = to_pa(outlet.Pback_const, getattr(outlet, "Pback_const_unit", "Pa"))
                 if phys_pa is not None:
@@ -377,9 +405,9 @@ def export_to_boundary_condition(
             _write_bsurf_spec(w, outlet)
 
         # SLIPS / WALLS
-        for slip in bc_group.SymmetricSlips:
+        for slip in _dedupe_by_bc_id(bc_group.SymmetricSlips):
             _write_bsurf_spec(w, slip)
-        for wall in bc_group.Walls:
+        for wall in _dedupe_by_bc_id(bc_group.Walls):
             _write_bsurf_spec(w, wall)
 
         # GIFS (dicts or dataclasses)
@@ -636,5 +664,3 @@ if __name__ == "__main__":
 
     export_to_boundary_condition("boundary_conditions.bcs", job, bcg, gifs=gifs, volume_zones=volume_zones)
     export_to_job_file(job, "jobfile", title="SingleBlade")
-
-

{plot3d-1.7.7 → plot3d-1.7.9}/plot3d/graph.py

@@ -182,7 +182,7 @@ def _metis_part_graph_compat(
 # ---------------------------------------------------------------------------
 def partition_from_face_matches(
     face_matches: List[dict],
-    blocks: Sequence[Block],
+    block_sizes: List[int],
     nparts: int,
     favor_blocksize: bool = True,
     aggregate: str = "sum",
@@ -216,7 +216,7 @@ def partition_from_face_matches(
             "Install pymetis (Linux/macOS) or run on a platform where it is supported."
         )
 
-    n_blocks = len(blocks)
+    n_blocks = len(block_sizes)
     adj_list, edge_w = build_weighted_graph_from_face_matches(
         face_matches, n_blocks,
         aggregate=aggregate,
@@ -226,7 +226,7 @@ def partition_from_face_matches(
 
     vwgt: Optional[List[int]] = None
     if favor_blocksize:
-        vwgt = [b.size for b in blocks]
+        vwgt = block_sizes
 
     _edgecut, parts = _metis_part_graph_compat(
         nparts=nparts,
@@ -243,7 +243,7 @@ def partition_from_face_matches(
 # ---------------------------------------------------------------------------
 def write_ddcmp(
     parts: Sequence[int],
-    blocks: Sequence[Block],
+    blocksizes: List[int],
     adj_list: Dict[int, List[int]],
     edge_weights: Optional[Dict[int, Dict[int, int]]] = None,
     filename: str = "ddcmp.dat",
@@ -272,12 +272,12 @@ def write_ddcmp(
     partition_edge_weights = [0] * n_proc
     volume_nodes = [0] * n_proc
 
-    for b, blk in enumerate(blocks):
+    for b, bsize in enumerate(blocksizes):
         pid = parts[b]
-        volume_nodes[pid] += blk.size
+        volume_nodes[pid] += bsize
 
     ew = edge_weights or {}
-    for b in range(len(blocks)):
+    for b in range(len(blocksizes)):
         pid = parts[b]
         for nbr in adj_list.get(b, []):
             nbr_pid = parts[nbr]

plot3d-1.7.9/plot3d/gridpro/__init__.py

@@ -0,0 +1,6 @@
+from __future__ import absolute_import
+from .import_functions import (
+    read_gridpro_to_blocks,
+    read_gridpro_connectivity,
+    bc_faces_by_type,
+)

{plot3d-1.7.7 → plot3d-1.7.9}/plot3d/gridpro/import_functions.py

@@ -1,5 +1,6 @@
-from typing import Dict, List, Tuple, Optional
+from typing import Dict, List, Tuple, Optional, Union, Set
 import numpy as np
+import pandas as pd
 from tqdm import tqdm
 from typing import List, Tuple, Optional, Any
 from plot3d import Block
@@ -15,19 +16,23 @@ def _parse_header(line: str) -> Optional[Tuple[int,int,int]]:
     except ValueError:
         return None
 
-def read_gridpro_to_blocks(filename: str,encoding: str = "utf-8", comment_prefixes: Tuple[str, ...] = ("#", "//")) -> List[Block]:
-    """_summary_
+def read_gridpro_to_blocks(
+    filename: str,
+    encoding: str = "utf-8",
+    comment_prefixes: Tuple[str, ...] = ("#", "//"),
+) -> List[Block]:
+    """Read a structured GridPro text grid into Plot3D Block objects.
 
     Args:
-        filename (str): _description_
-        encoding (str, optional): _description_. Defaults to "utf-8".
-        comment_prefixes (Tuple[str, ...], optional): _description_. Defaults to ("#", "//").
+        filename: Path to the GridPro grid file.
+        encoding: Encoding to use while reading the text file.
+        comment_prefixes: Line prefixes that should be treated as comments.
 
     Raises:
-        ValueError: _description_
+        ValueError: If a block does not contain the expected number of floats.
 
     Returns:
-        List[Block]: _description_
+        List[Block]: A list of Block objects representing each GridPro block.
     """
     blocks = []
 
@@ -82,10 +87,10 @@ def read_gridpro_connectivity(
     file_path: str,
     sb_zero_based_in_file: bool = True,     # False if sb1/sb2 are 1-based in file
     index_zero_based_in_file: bool = True,  # False if IMIN..KMAX are 1-based in file
-    inlet_ids: Optional[List[int]] = None,
-    outlet_ids: Optional[List[int]] = None,
-    wall_ids: Optional[List[int]] = None,
-    symm_slip_ids: Optional[List[int]] = None,
+    inlet_ids: Optional[Union[List[int], Dict[str, Any]]] = None,
+    outlet_ids: Optional[Union[List[int], Dict[str, Any]]] = None,
+    wall_ids: Optional[Union[List[int], Dict[str, Any]]] = None,
+    symm_slip_ids: Optional[Union[List[int], Dict[str, Any]]] = None,
     custom_bc_ids: Optional[Dict[str, List[int]]] = None,
 ) -> Dict[str, object]:
     """Parse a GridPro connectivity file into plot3d.connectivity_fast-like structures.
@@ -94,33 +99,45 @@ def read_gridpro_connectivity(
     ``P pid sb1 sf1 sb2 sf2 fmap L1i L1j L1k H1i H1j H1k L2i L2j L2k H2i H2j H2k pty lbid``
 
     Boundary-condition IDs default to GridPro's PTY values but can be overridden
-    via the provided *_ids lists or extended via ``custom_bc_ids={"name": [ids]}``.
+    via the provided *_ids arguments (either a list of PTY ints or
+    ``{"name": str, "ids": [...]}``) or extended via
+    ``custom_bc_ids={"name": [ids]}``.
 
     Args:
         file_path: Path to the GridPro connectivity file.
         sb_zero_based_in_file: Set False if ``sb1/sb2`` are 1-based in the file.
         index_zero_based_in_file: Set False if IMIN..KMAX are 1-based in the file.
         inlet_ids: PTY ids to treat as inlet; defaults to ``[5]``.
-        outlet_ids: PTY ids to treat as outlet; defaults to ``[6]``.
-        wall_ids: PTY ids to treat as wall; defaults to ``[2]``.
-        symm_slip_ids: PTY ids to treat as symmetry/slip; defaults to ``[4]``.
+            Pass a dict ``{"name": "...", "ids": [...]}`` to rename the group, or
+            provide a mapping like ``{"Inlet": [...], "Pressure Inlet": [...]}``
+            to emit multiple named inlet groups. Each named group remembers its
+            base type in the returned ``bc_group`` mapping.
+        outlet_ids: PTY ids to treat as outlet; defaults to ``[6]`` (same dict
+            options as ``inlet_ids``).
+        wall_ids: PTY ids to treat as wall; defaults to ``[2]`` (same dict options).
+        symm_slip_ids: PTY ids to treat as symmetry/slip; defaults to ``[4]`` (same dict options).
         custom_bc_ids: Optional mapping of ``group_name -> [pty ids]`` for any
             additional boundary-condition groupings (e.g., ``{"cooling": [500]}``).
 
     Returns:
         Dict[str, object]: A dictionary with keys:
             - ``face_matches``: list of face-pair dictionaries for connected blocks.
-            - ``outer_faces``: list of faces on the exterior (no neighbor).
-            - ``bc_group``: mapping of bc name to list of faces (inlet/outlet/etc.).
+            - ``all_surfaces``: list of faces on the exterior (no neighbor).
+            - ``ungrouped_surfaces``: exterior faces whose PTY does not belong to any BC group.
+            - ``bc_group``: mapping of bc name to a metadata dict
+              ``{"type": base_type, "pty_ids": [...], "faces": [...]}``. Each
+              face dict also includes ``bc_name`` (group label) and ``bc_type``.
             - ``gif_faces``: list of faces tagged as GIF (pty 12..21 or 1000).
             - ``periodic_faces``: list of paired periodic faces (pty 3).
             - ``volume_zones``: list describing volume zone type per superblock.
+            - ``blocksizes``: list of per-superblock cell counts (I*J*K).
+            - ``patches``: pandas DataFrame of raw patch records.
 
     Examples:
         Basic usage with defaults::
 
             data = read_gridpro_connectivity("connectivity.dat")
-            inlet_faces = data["bc_group"]["inlet"]
+            inlet_faces = data["bc_group"]["inlet"]["faces"]
 
         Override built-in BC ids and add a custom group::
 
@@ -129,11 +146,12 @@ def read_gridpro_connectivity(
                 inlet_ids=[5, 105],
                 custom_bc_ids={"cooling_hole1": [500]},
             )
-            cooling_faces = data["bc_group"]["cooling_hole1"]
+            cooling_faces = data["bc_group"]["cooling_hole1"]["faces"]
     """
     # ---------------------------- parsing ----------------------------
     superblock_ptys: List[int] = []
-    patches: List[Dict[str, object]] = []
+    superblock_sizes: List[int] = []
+    patch_rows: List[Dict[str, object]] = []
 
     sb_offset = 0 if sb_zero_based_in_file else -1
     idx_offset = 0 if index_zero_based_in_file else -1  # convert to 0-based if file is 1-based
@@ -175,7 +193,7 @@ def read_gridpro_connectivity(
         except Exception as e:
             raise ValueError(f"Failed to parse patch line: {' '.join(tokens)}") from e
 
-        patches.append({
+        patch_rows.append({
             "pid": pid, "sb1": sb1, "sf1": sf1, "sb2": sb2, "sf2": sf2,
             "fmap": fmap,
             "L1i": L1i, "L1j": L1j, "L1k": L1k, "H1i": H1i, "H1j": H1j, "H1k": H1k,
@@ -192,9 +210,18 @@ def read_gridpro_connectivity(
             tag = toks[0]
             if tag == "SB":
                 superblock_ptys.append(int(toks[-2]))
+                try:
+                    I_dim = int(toks[2])
+                    J_dim = int(toks[3])
+                    K_dim = int(toks[4])
+                    superblock_sizes.append(I_dim * J_dim * K_dim)
+                except (IndexError, ValueError):
+                    superblock_sizes.append(0)
             elif tag == "P":
                 parse_patch(toks)
 
+    patches_df = pd.DataFrame(patch_rows)
+
     # ---------------------------- helpers ----------------------------
     def face_dict(sb: int, imin: int, jmin: int, kmin: int, imax: int, jmax: int, kmax: int, pty:int=-1) -> Dict[str, int]:
         # Matches plot3d.connectivity_fast single-face dict shape
@@ -217,66 +244,123 @@ def read_gridpro_connectivity(
     # ------------------------- build outputs -------------------------
     # Connections: sb2 != -1 (i.e., not "none") and pty in {1,3}
     connections: List[Dict[str, Dict[str, int]]] = []
-    for p in patches:
-        if p["sb2"] != -1 and (p["pty"] in (1, 3)):
+    for p in patches_df.itertuples(index=False):
+        if p.sb2 != -1 and (p.pty in (1, 3)):
             connections.append(
                 pair_dict(
-                    p["sb1"], (p["L1i"], p["L1j"], p["L1k"], p["H1i"], p["H1j"], p["H1k"]), # type: ignore
-                    p["sb2"], (p["L2i"], p["L2j"], p["L2k"], p["H2i"], p["H2j"], p["H2k"]), # type: ignore
+                    p.sb1, (p.L1i, p.L1j, p.L1k, p.H1i, p.H1j, p.H1k),
+                    p.sb2, (p.L2i, p.L2j, p.L2k, p.H2i, p.H2j, p.H2k),
                 )
             )
 
-    # Outer faces: sb2 == -1 (means '0' in file when sb_zero_based_in_file=False; or literal 0 if already zero-based)
-    # To cover both cases, treat original token value 0 as "no neighbor".
-    # Since we already applied sb_offset, "no neighbor" now appears as -1.
-    outer_faces: List[Dict[str, int]] = []
-    pty_exclude = [6,5,4,2]
-    for p in patches:
-        if p["sb2"] == -1 and (p["pty"] not in pty_exclude):
-            outer_faces.append(
-                face_dict(p["sb1"], p["L1i"], p["L1j"], p["L1k"], p["H1i"], p["H1j"], p["H1k"], p["pty"]) # type: ignore
-            )
-
     # Boundary-condition groups (by pty)
-    def bc_faces_for(pty_vals: List[int]) -> List[Dict[str, int]]:
+    def bc_faces_for(name: str, pty_vals: List[int], bc_type: str) -> List[Dict[str, int]]:
         targets = set(pty_vals)
-        return [
-            face_dict(p["sb1"], p["L1i"], p["L1j"], p["L1k"], p["H1i"], p["H1j"], p["H1k"], p["pty"]) # type: ignore
-            for p in patches if p["pty"] in targets
-        ]
-
-    bc_group = {
-        "inlet":     bc_faces_for(inlet_ids or [5]),
-        "outlet":    bc_faces_for(outlet_ids or [6]),
-        "symm_slip": bc_faces_for(symm_slip_ids or [4]),
-        "wall":      bc_faces_for(wall_ids or [2]),
-    }
+        faces: List[Dict[str, int]] = []
+        for p in patches_df.itertuples(index=False):
+            if p.pty in targets:
+                face = face_dict(p.sb1, p.L1i, p.L1j, p.L1k, p.H1i, p.H1j, p.H1k, p.pty)
+                face["bc_name"] = name  # type: ignore
+                face["bc_type"] = bc_type  # type: ignore
+                faces.append(face)
+        return faces
+
+    def normalize_bc_arg(
+        arg: Optional[Union[List[int], Dict[str, Any]]],
+        bc_type: str,
+        default_ids: List[int],
+    ) -> List[Tuple[str, List[int]]]:
+        def coerce_ids(values: Any) -> List[int]:
+            if values is None:
+                return []
+            # Allow nested {"ids": [...]} dictionaries to be passed directly
+            if isinstance(values, dict):
+                return coerce_ids(values.get("ids"))
+            if isinstance(values, (list, tuple, set)):
+                return [int(v) for v in values if v is not None]
+            return [int(values)]
+
+        if arg is None:
+            return [(bc_type, coerce_ids(default_ids))]
+
+        if isinstance(arg, dict):
+            # Support legacy {"name": str, "ids": [...]} as well as
+            # {"CustomName": [...], "AnotherName": [...]} mappings.
+            if "ids" in arg or "name" in arg:
+                ids = coerce_ids(arg.get("ids", default_ids))
+                name = str(arg.get("name", bc_type) or bc_type)
+                return [(name, ids)]
+
+            normalized: List[Tuple[str, List[int]]] = []
+            for name, ids_val in arg.items():
+                ids_list = coerce_ids(ids_val)
+                if ids_list:
+                    normalized.append((str(name), ids_list))
+            return normalized
+
+        ids = coerce_ids(arg)
+        return [(bc_type, ids)]
+
+    bc_group: Dict[str, Dict[str, Any]] = {}
+    grouped_bc_ids: Set[int] = set()
+
+    def add_bc_group(name: str, ids: List[int], bc_type: str) -> None:
+        normalized_ids = sorted({int(i) for i in ids if i is not None})
+        faces = bc_faces_for(name, normalized_ids, bc_type) if normalized_ids else []
+        if not faces:
+            return
+        bc_group[name] = {
+            "type": bc_type,
+            "pty_ids": normalized_ids,
+            "faces": faces,
+        }
+        grouped_bc_ids.update(normalized_ids)
+
+    for bc_type, group in [
+        ("inlet", normalize_bc_arg(inlet_ids, "inlet", [5])),
+        ("outlet", normalize_bc_arg(outlet_ids, "outlet", [6])),
+        ("symm_slip", normalize_bc_arg(symm_slip_ids, "symm_slip", [4])),
+        ("wall", normalize_bc_arg(wall_ids, "wall", [2])),
+    ]:
+        for name, ids in group:
+            add_bc_group(name, ids, bc_type)
 
     # add any user-defined boundary groups keyed by name -> list of pty ids
     if custom_bc_ids:
         for name, ids in custom_bc_ids.items():
-            if ids:
-                bc_group[name] = bc_faces_for(ids)
-    
+            add_bc_group(name, ids or [], name)
+
+    # Outer faces: sb2 == -1 (means '0' in file when sb_zero_based_in_file=False; or literal 0 if already zero-based)
+    # To cover both cases, treat original token value 0 as "no neighbor".
+    # Since we already applied sb_offset, "no neighbor" now appears as -1.
+    all_surfaces: List[Dict[str, int]] = []
+    ungrouped_surfaces: List[Dict[str, int]] = []
+    for p in patches_df.itertuples(index=False):
+        if p.sb2 == -1:
+            face = face_dict(p.sb1, p.L1i, p.L1j, p.L1k, p.H1i, p.H1j, p.H1k, p.pty)
+            all_surfaces.append(face)
+            if p.pty not in grouped_bc_ids:
+                ungrouped_surfaces.append(face.copy())
+
     # Periodic faces: pty == 3 (explicit pairs)
     periodic_faces: List[Dict[str, Dict[str, int]]] = []
-    for p in patches:
-        if p["pty"] == 3 and p["sb2"] != -1:
+    for p in patches_df.itertuples(index=False):
+        if p.pty == 3 and p.sb2 != -1:
             periodic_faces.append(
                 pair_dict(
-                    p["sb1"], (p["L1i"], p["L1j"], p["L1k"], p["H1i"], p["H1j"], p["H1k"]), # type: ignore
-                    p["sb2"], (p["L2i"], p["L2j"], p["L2k"], p["H2i"], p["H2j"], p["H2k"]), # type: ignore
+                    p.sb1, (p.L1i, p.L1j, p.L1k, p.H1i, p.H1j, p.H1k),
+                    p.sb2, (p.L2i, p.L2j, p.L2k, p.H2i, p.H2j, p.H2k),
                 )
             )
             
     # GIF faces grouped by sf1 for pty in 12..21 or == 1000
     gif_faces: List[Dict[str, int]] = []
-    for p in patches:
+    for p in patches_df.itertuples(index=False):
 #? This is how we identify gifs inside of a grid pro connectivity file. 
 #? If the PTY is between 12 and 21 these are gifs
-        if (12 <= p["pty"] <= 21) or (p["pty"] == 1000): # type: ignore
-            face_temp = face_dict(p["sb1"], p["L1i"], p["L1j"], p["L1k"], p["H1i"], p["H1j"], p["H1k"]) # type: ignore
-            face_temp["id"] = p["pty"] # type: ignore
+        if (12 <= p.pty <= 21) or (p.pty == 1000):
+            face_temp = face_dict(p.sb1, p.L1i, p.L1j, p.L1k, p.H1i, p.H1j, p.H1k)
+            face_temp["id"] = p.pty  # type: ignore
             gif_faces.append(face_temp)
 
     # Volume zones (unique superblock ptys; odd→fluid, even→solid) with contiguous ids
@@ -293,9 +377,59 @@ def read_gridpro_connectivity(
 
     return {
         "face_matches": connections,
-        "outer_faces": outer_faces,
+        "all_surfaces": all_surfaces,
+        "ungrouped_surfaces": ungrouped_surfaces,
         "bc_group": bc_group,
         "gif_faces": gif_faces,
         "periodic_faces": periodic_faces,
         "volume_zones": volume_zones,
+        "blocksizes": superblock_sizes,
+        "patches": patches_df,
     }
+
+
+def bc_faces_by_type(
+    bc_group: Dict[str, Any],
+    bc_type: str,
+    *,
+    unique: bool = False,
+) -> List[Dict[str, int]]:
+    """Collect faces for a specific boundary-condition type across all named groups.
+
+    Args:
+        bc_group: Mapping returned by :func:`read_gridpro_connectivity` (supports
+            both the legacy ``{name: [faces]}`` and the new
+            ``{name: {"type": ..., "faces": [...]}}`` shapes).
+        bc_type: Base BC type (``"inlet"``, ``"outlet"``, ``"wall"``, ``"symm_slip"``).
+        unique: When True, keep only the first face per unique ``id``.
+
+    Returns:
+        List of face dictionaries belonging to the requested base type.
+    """
+    faces: List[Dict[str, int]] = []
+    seen: Set[int] = set()
+    target = (bc_type or "").lower()
+
+    for entry in bc_group.values():
+        entry_type = None
+        entry_faces: List[Dict[str, int]] = []
+
+        if isinstance(entry, dict) and "faces" in entry:
+            entry_faces = entry.get("faces", []) or []
+            entry_type = entry.get("type") or entry.get("bc_type")
+        elif isinstance(entry, list):
+            entry_faces = entry
+        else:
+            continue
+
+        for face in entry_faces:
+            ftype = entry_type or face.get("bc_type") or face.get("bc_name")
+            if not isinstance(ftype, str) or ftype.lower() != target:
+                continue
+            fid = face.get("id")
+            if unique and isinstance(fid, int):
+                if fid in seen:
+                    continue
+                seen.add(fid)
+            faces.append(face)
+    return faces

{plot3d-1.7.7 → plot3d-1.7.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "plot3d"
-version = "1.7.7"
+version = "1.7.9"
 description = "Plot3D python utilities for reading and writing and also finding connectivity between blocks"
 authors = ["Paht Juangphanich <paht.juangphanich@nasa.gov>"]
 

plot3d-1.7.7/plot3d/gridpro/__init__.py

@@ -1,2 +0,0 @@
-from __future__ import absolute_import
-from .import_functions import read_gridpro_to_blocks, read_gridpro_connectivity