loudpy 0.0.5__py3-none-any.whl

loudpy/Files_Loader/Analysis_Helpers.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+from pathlib import Path
+import matplotlib.tri as mtri
+import numpy as np
+
+from loudpy.Files_Loader.Load_Domains import Domain
+from loudpy.Files_Loader.Core_Models import Mesh, FreqSnapshot, Snapshot
+from loudpy.Files_Loader.Readers import FreqReader
+from loudpy.Files_Loader.Field_Operations_Helpers import scatter_dofs,  reduce_field, infer_dpn
+
+class NearestNodeProbe:
+    """Sample at the mesh node closest to a coordinate."""
+
+    def __init__(self, mesh: Mesh, xy):
+        self.mesh = mesh
+        self.idx, self.xy = mesh.nearest_node(xy)
+
+    def sample_snapshot(self, snap: Snapshot, field_name: str,
+                        component: str = "mag") -> float:
+        return float(snap.nodal(field_name, self.mesh, component=component)[self.idx])
+
+    def sample_matrix(self, mat: np.ndarray, dof_tags: np.ndarray | None,
+                      dpn: int, component: str) -> np.ndarray:
+        vals = np.empty(mat.shape[0])
+        for k in range(mat.shape[0]):
+            arr  = scatter_dofs(mat[k], dof_tags, self.mesh, dpn)
+            vals[k] = reduce_field(arr, component)[self.idx]
+        return vals
+
+
+class FieldProbe:
+    """Interpolate a scalar field at arbitrary (x, y) coordinates."""
+
+    def __init__(self, snap: Snapshot, mesh: Mesh, field_name: str):
+        self.snap, self.mesh, self.field_name = snap, mesh, field_name
+        val = snap.complex_nodal(field_name, mesh)
+        if val.ndim > 1:
+            raise ValueError("FieldProbe only handles scalar fields")
+        tri = mesh.triangulation
+        self._fr = mtri.LinearTriInterpolator(tri, val.real)
+        self._fi = mtri.LinearTriInterpolator(tri, val.imag)
+
+    def at(self, xy) -> np.ndarray:
+        xy = np.atleast_2d(xy)
+        return np.array([complex(float(self._fr(x, y)), float(self._fi(x, y)))
+                         for x, y in xy])
+
+
+class Directivity:
+    """Far-field directivity from a single FreqSnapshot."""
+
+    def __init__(self, snap: FreqSnapshot, mesh: Mesh,
+                 radius: float = 0.4, n_theta: int = 361,
+                 theta_min: float = 0, theta_max: float = 2*np.pi):
+        self.snap, self.mesh, self.radius = snap, mesh, radius
+        self.theta = np.linspace(theta_min, theta_max, n_theta)
+        probe = FieldProbe(snap, mesh, "p_acou")
+        xy = np.column_stack([radius * np.sin(self.theta),
+                              radius * np.cos(self.theta)])
+        self.p = probe.at(xy)
+
+
+class InterfaceExtractor:
+    """Extract complex DOFs along an interface, sorted along x."""
+
+    def __init__(self, snap: Snapshot, mesh: Mesh,
+                 iface_tags: np.ndarray, field_name: str = "u_meca"):
+        self.field_name = field_name
+        dof_tags = snap.dof_maps[field_name]
+        t2dof = {int(t): i for i, t in enumerate(dof_tags)}
+        rows  = np.array([t2dof[int(t)] for t in iface_tags if int(t) in t2dof])
+        raw   = snap.fields[field_name]
+        dpn   = infer_dpn(field_name)
+
+        if dpn == 1:
+            comps = {"v": raw[rows]}
+        else:
+            comps = {f"u{c}": raw[dpn * rows + d]
+                     for d, c in enumerate("xy"[:dpn])}
+
+        t2m = mesh.tag_to_row
+        mr  = [t2m[int(t)] for t in iface_tags if int(t) in t2m]
+        x, y = mesh.coords[mr, 0], mesh.coords[mr, 1]
+        order = np.argsort(x)
+
+        self.x, self.y = x[order], y[order]
+        self.components = {k: v[order] for k, v in comps.items()}
+
+
+class FrequencySweep:
+    """Sweep over a folder of snap_*.h5 — probes pressure at a point."""
+
+    def __init__(self, folder: str | Path, probe_xy=(0.4, 0.0)):
+        self.folder = Path(folder)
+        self.files  = sorted(self.folder.glob("snap_*.h5"))
+        if not self.files:
+            raise FileNotFoundError(f"No snap_*.h5 in {folder}")
+        self.probe_xy = probe_xy
+        self._freqs:    np.ndarray | None = None
+        self._pressure: np.ndarray | None = None
+
+    def run(self) -> tuple[np.ndarray, np.ndarray]:
+        fs, ps = [], []
+        for fp in self.files:
+            with FreqReader(fp) as r:
+                snap = r.load()
+                mesh = r.mesh(snap.mesh_id, Domain.ACOU)
+                ps.append(FieldProbe(snap, mesh, "p_acou").at(self.probe_xy)[0])
+                fs.append(snap.f)
+        self._freqs    = np.asarray(fs)
+        self._pressure = np.asarray(ps)
+        return self._freqs, self._pressure
+
+
+class MecaFrequencySweep:
+    """Sweep over a folder of snap_*.h5 — probes a mechanical DOF
+    (displacement, velocity, or acceleration) at the nearest node to `probe_xy`.
+
+    Parameters
+    ----------
+    folder    : directory containing snap_*.h5 files
+    probe_xy  : (x, y) coordinate on the MECA mesh
+    field     : stored mechanical field name (default 'u_meca')
+    component : 'ux', 'uy', 'uz' (alias for 'uy' in 2D), or 'mag'
+    quantity  : 'u' displacement, 'v' velocity (jω·u), 'a' acceleration (-ω²·u)
+    """
+
+    _COMP_ALIAS = {"uz": "uy"}  # 2D convention used elsewhere in loudpy
+
+    def __init__(self, folder: str | Path, probe_xy=(0.0, 0.0), *,
+                 field: str = "u_meca",
+                 component: str = "uz",
+                 quantity: str = "u"):
+        self.folder = Path(folder)
+        self.files  = sorted(self.folder.glob("snap_*.h5"))
+        if not self.files:
+            raise FileNotFoundError(f"No snap_*.h5 in {folder}")
+        if quantity not in ("u", "v", "a"):
+            raise ValueError("quantity must be 'u', 'v', or 'a'")
+
+        self.probe_xy  = probe_xy
+        self.field     = field
+        self.component = self._COMP_ALIAS.get(component, component)
+        self.quantity  = quantity
+
+        self._freqs:  np.ndarray | None = None
+        self._values: np.ndarray | None = None
+
+    def run(self) -> tuple[np.ndarray, np.ndarray]:
+        fs, vals = [], []
+        dpn = infer_dpn(self.field)
+
+        for fp in self.files:
+            with FreqReader(fp) as r:
+                snap = r.load()
+                mesh = r.mesh(snap.mesh_id, Domain.MECA)
+
+                # nearest node on the MECA mesh
+                probe = NearestNodeProbe(mesh, self.probe_xy)
+
+                # scatter complex DOFs to nodal values, then pick component
+                raw_dofs = snap.fields[self.field]                       # complex (n_dof,)
+                dof_tags = snap.dof_maps.get(self.field)
+                nodal    = scatter_dofs(raw_dofs, dof_tags, mesh, dpn)   # complex (n_nodes, dpn)
+                # keep it complex: reduce_field with 'ux'/'uy' just selects a column
+                if self.component in ("ux", "uy"):
+                    col = {"ux": 0, "uy": 1}[self.component]
+                    val = nodal[probe.idx, col] if nodal.ndim == 2 else nodal[probe.idx]
+                elif self.component == "mag":
+                    v = nodal[probe.idx]
+                    val = np.linalg.norm(v) if np.ndim(v) else v
+                else:
+                    raise ValueError(f"Unsupported component {self.component!r}")
+
+                # convert displacement -> velocity / acceleration in frequency domain
+                omega = 2 * np.pi * snap.f
+                if   self.quantity == "v": val = 1j * omega * val
+                elif self.quantity == "a": val = -(omega ** 2) * val
+
+                vals.append(complex(val))
+                fs.append(snap.f)
+
+        self._freqs  = np.asarray(fs)
+        self._values = np.asarray(vals)
+        return self._freqs, self._values

loudpy/Files_Loader/Core_Models.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from functools import cached_property
+from typing import ClassVar, Iterator
+import matplotlib.tri as mtri
+import numpy as np
+
+from loudpy.Files_Loader.Field_Operations_Helpers import (
+    infer_dpn, scatter_dofs, reduce_field
+)
+
+@dataclass(frozen=True)
+class Mesh:
+    tags:   np.ndarray   # (N,) global node tags
+    coords: np.ndarray   # (N, 2)
+    tris:   np.ndarray   # (M, 3) row indices
+
+    @property
+    def n_nodes(self) -> int: return len(self.tags)
+    @property
+    def n_tris(self)  -> int: return len(self.tris)
+
+    @cached_property
+    def tag_to_row(self) -> dict[int, int]:
+        return {int(t): i for i, t in enumerate(self.tags)}
+
+    @cached_property
+    def triangulation(self) -> mtri.Triangulation:
+        return mtri.Triangulation(self.coords[:, 0], self.coords[:, 1], self.tris)
+
+    def nearest_node(self, xy) -> tuple[int, np.ndarray]:
+        xy = np.asarray(xy, dtype=float)
+        idx = int(np.argmin(np.sum((self.coords - xy) ** 2, axis=1)))
+        return idx, self.coords[idx]
+
+
+@dataclass
+class Snapshot(ABC):
+    """Any field result on a mesh (freq / mode / time)."""
+    label:    str
+    fields:   dict[str, np.ndarray]
+    dof_maps: dict[str, np.ndarray]
+    mesh_id:  str
+    meta:     dict = field(default_factory=dict)
+
+    @abstractmethod
+    def coordinate(self) -> float: ...
+
+    def nodal(self, name: str, mesh: Mesh, *,
+              component: str = "mag", dpn: int | None = None) -> np.ndarray:
+        dpn = dpn or infer_dpn(name)
+        raw = self.fields[name]
+        arr = scatter_dofs(raw, self.dof_maps.get(name), mesh, dpn)
+        return reduce_field(arr, component)
+
+    def complex_nodal(self, name: str, mesh: Mesh,
+                      dpn: int | None = None) -> np.ndarray:
+        dpn = dpn or infer_dpn(name)
+        return scatter_dofs(self.fields[name],
+                            self.dof_maps.get(name), mesh, dpn)
+
+
+@dataclass
+class FreqSnapshot(Snapshot):
+    f: float = 0.0
+    def coordinate(self) -> float: return self.f
+
+
+@dataclass
+class ModeSnapshot(Snapshot):
+    freq:  float = 0.0
+    zeta:  float | None = None
+    index: int = 0
+    def coordinate(self) -> float: return self.freq
+
+
+@dataclass
+class TimeSnapshot(Snapshot):
+    t: float = 0.0
+    def coordinate(self) -> float: return self.t
+
+
+@dataclass
+class TimeRun:
+    """Bundles all arrays of a single transient run."""
+    time:     np.ndarray
+    U:        np.ndarray
+    V:        np.ndarray
+    A:        np.ndarray
+    dof_maps: dict[str, np.ndarray]
+    mesh_id:  str
+
+    _FIELD_MAP: ClassVar[dict[str, str]] = {
+        "u_meca": "U", "v_meca": "V", "a_meca": "A",
+    }
+
+    def array_for(self, field_name: str) -> np.ndarray:
+        return getattr(self, self._FIELD_MAP.get(field_name, "U"))
+
+    def snapshot_at(self, idx: int, field_name: str = "u_meca") -> TimeSnapshot:
+        arr = self.array_for(field_name)
+        return TimeSnapshot(
+            label    = f"t={self.time[idx]*1e3:.3f}ms",
+            fields   = {field_name: arr[idx]},
+            dof_maps = self.dof_maps,
+            mesh_id  = self.mesh_id,
+            t        = float(self.time[idx]),
+        )
+
+    def iter_snapshots(self, field_name: str = "u_meca") -> Iterator[TimeSnapshot]:
+        for i in range(len(self.time)):
+            yield self.snapshot_at(i, field_name)

loudpy/Files_Loader/Field_Operations_Helpers.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import numpy as np
+
+
+def infer_dpn(field_name: str) -> int:
+    _DPN_TABLE: dict[str, int] = {
+    "u_meca": 2, "v_meca": 2, "a_meca": 2,
+    "p_acou": 1, "phi_acou": 1,
+}
+    return _DPN_TABLE.get(field_name, 1)
+
+
+def scatter_dofs(raw: np.ndarray, tags: np.ndarray | None,
+                 mesh, dpn: int) -> np.ndarray:
+
+    """Place raw DOFs onto mesh nodes; returns (N,) or (N, dpn)."""
+    N = mesh.n_nodes
+    shape = (N,) if dpn == 1 else (N, dpn)
+    out = np.zeros(shape, dtype=complex if np.iscomplexobj(raw) else float)
+
+    if tags is None:
+        if dpn == 1:
+            n = min(len(raw), N); out[:n] = raw[:n]
+        else:
+            n = min(len(raw) // dpn, N)
+            out[:n] = raw[:dpn * n].reshape(n, dpn)
+        return out
+
+    t2r = mesh.tag_to_row
+    rows = np.fromiter((t2r[int(t)] for t in tags), dtype=int, count=len(tags))
+    if dpn == 1:
+        out[rows] = raw[: len(rows)]
+    else:
+        out[rows] = raw[: dpn * len(rows)].reshape(len(rows), dpn)
+    return out
+
+
+def reduce_field(arr: np.ndarray, component: str) -> np.ndarray:
+    """Reduce (N,) or (N,dpn) array to (N,) scalar per component."""
+    if component == "complex":
+        return arr
+    if arr.ndim == 1:
+        return {
+            "abs":   np.abs(arr),
+            "mag":   np.abs(arr),
+            "real":  arr.real,
+            "imag":  arr.imag,
+            "phase": np.angle(arr),
+        }.get(component, np.abs(arr))
+
+    # (N, dpn) — vector field
+    if component in ("mag", "abs"):
+        return np.linalg.norm(np.abs(arr), axis=1)
+    if component in ("ux", "x"):  return _real_of(arr[:, 0])
+    if component in ("uy", "y"):  return _real_of(arr[:, 1])
+    if component == "real":       return arr[:, 0].real
+    if component == "imag":       return arr[:, 0].imag
+    if component == "phase_dominant":
+        dom = np.argmax(np.abs(arr), axis=1)
+        return np.angle(arr[np.arange(arr.shape[0]), dom])
+    return np.linalg.norm(np.abs(arr), axis=1)
+
+
+def _real_of(x: np.ndarray) -> np.ndarray:
+    return x.real if np.iscomplexobj(x) else x
+
+
+def SPL(p_mag: np.ndarray, p_ref: float = 20e-6) -> np.ndarray:
+    return 20.0 * np.log10(np.maximum(np.abs(p_mag), 1e-30) / p_ref)

loudpy/Files_Loader/Load_Domains.py

@@ -0,0 +1,24 @@
+from enum import Enum
+
+class Domain(str, Enum):
+    """Physics-domain identifier — single source of truth."""
+    ACOU = "acou"
+    MECA = "meca"
+
+    @property
+    def field_name(self) -> str:
+        return {"acou": "p_acou", "meca": "u_meca"}[self.value]
+
+    @property
+    def default_dpn(self) -> int:
+        return {"acou": 1, "meca": 2}[self.value]
+
+    @property
+    def subgroup_prefixes(self) -> tuple[str, ...]:
+        return {"acou": ("subdomainacou",),
+                "meca": ("subdomainmeca",)}[self.value]
+
+    @classmethod
+    def coerce(cls, v: "Domain | str") -> "Domain":
+        return v if isinstance(v, cls) else cls(v)
+

loudpy/Files_Loader/Mesh_Loader.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+import h5py
+import numpy as np
+
+from loudpy.Files_Loader.Load_Domains import Domain
+from loudpy.Files_Loader.Core_Models import Mesh
+
+class MeshLoader:
+    """Loads a Mesh from any loudpy HDF5 layout."""
+
+    @staticmethod
+    def load(h5: h5py.File, mesh_id: str, domain: Domain | str) -> Mesh:
+        dom = Domain.coerce(domain)
+        g = h5[f"meshes/{mesh_id}"]
+
+        subgroups = MeshLoader._find_subgroups(g, dom)
+        if not subgroups and {"tags", "tris"} <= set(g.keys()):
+            subgroups = [g]
+        if not subgroups:
+            raise ValueError(f"No mesh data for domain '{dom.value}' in {mesh_id}")
+
+        all_tags, all_coords, all_tris = [], [], []
+        for sg in subgroups:
+            tags, coords, tris_tags = MeshLoader._extract_subgroup(sg)
+            all_tags.append(tags)
+            all_coords.append(coords)
+            all_tris.append(tris_tags)
+
+        return MeshLoader._merge(np.concatenate(all_tags),
+                                 np.concatenate(all_coords),
+                                 np.concatenate(all_tris))
+
+    @staticmethod
+    def _find_subgroups(g, dom: Domain) -> list:
+        return [g[k] for k in g.keys()
+                if isinstance(g[k], h5py.Group)
+                and any(k.startswith(p) for p in dom.subgroup_prefixes)]
+
+    @staticmethod
+    def _extract_subgroup(sg) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        tags      = sg["tags"][:]
+        coord_key = "coords" if "coords" in sg else "nodes"
+        coords    = sg[coord_key][:, :2]
+        tris      = sg["tris"][:, :3].astype(np.int64)
+        tris_tags = tris if tris.max() >= len(tags) else tags[tris]
+        return tags, coords, tris_tags
+
+    @staticmethod
+    def _merge(all_tags, all_coords, all_tris_tags) -> Mesh:
+        unique_tags, first_occ = np.unique(all_tags, return_index=True)
+        unique_coords = all_coords[first_occ]
+        tag2row = {int(t): i for i, t in enumerate(unique_tags)}
+        tris_idx = np.vectorize(tag2row.get)(all_tris_tags)
+        ok = ((tris_idx[:, 0] != tris_idx[:, 1])
+              & (tris_idx[:, 1] != tris_idx[:, 2])
+              & (tris_idx[:, 0] != tris_idx[:, 2]))
+        return Mesh(unique_tags, unique_coords, tris_idx[ok])
+