loudpy 0.0.5__tar.gz

loudpy-0.0.5/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.1
+Name: loudpy
+Version: 0.0.5
+Summary: Python API for Fluid-solid interaction FEM simulations
+Author-Email: Romain Degraeve <rom2graeve@gmail.com>
+License: GPL-3.0+
+Requires-Python: >=3.13
+Requires-Dist: numpy>=2.4.4
+Requires-Dist: numba>=0.65.0
+Requires-Dist: scipy>=1.17.1
+Requires-Dist: gmsh>=4.15.2
+Requires-Dist: h5py>=3.16.0
+Requires-Dist: matplotlib>=3.10.9
+Requires-Dist: pyvista>=0.48.4
+Description-Content-Type: text/markdown
+
+# loudpy
+
+A fem python API.
+
+## Installation
+
+### PDM Installation
+
+loudpy relies on the Python Development Master (PDM) for package management. 
+
+
+
+#### UV Installation
+
+UV is a modern Python package manager that provides a simple and efficient way to manage Python packages and environments. For example, different python intepreter can be installed through the commands:
+
+```bash
+uv python install 3.11 3.12 3.13
+```
+
+ThisPython API is developped under python 3.13, so with uv run:
+
+```bash
+uv python install 3.13
+```
+
+Then, to install PDM using UV, run the following command:
+
+```bash
+uv pip install pdm
+```
+
+#### PIPX Installation
+
+To install PDM using pipx, run the following command:
+
+```bash
+pipx install pdm
+```
+
+Prefer `pipx` as it allows you to install Python applications in isolated environments, preventing conflicts between packages.
+
+#### Verify PDM Installation
+
+When the installation is complete, you can verify that PDM is installed correctly by running:
+
+```bash
+pdm --version
+```
+
+### loudpy Installation
+
+To install loudpy for development purposes, use PDM to install it in editable mode. This allows you to make changes to the source code and have those changes reflected immediately without needing to reinstall the package. To do this, navigate to the directory where you have the loudpy source code and run:
+
+```bash
+pdm install -e .
+```

loudpy-0.0.5/README.md

@@ -0,0 +1,57 @@
+# loudpy
+
+A fem python API.
+
+## Installation
+
+### PDM Installation
+
+loudpy relies on the Python Development Master (PDM) for package management. 
+
+
+
+#### UV Installation
+
+UV is a modern Python package manager that provides a simple and efficient way to manage Python packages and environments. For example, different python intepreter can be installed through the commands:
+
+```bash
+uv python install 3.11 3.12 3.13
+```
+
+ThisPython API is developped under python 3.13, so with uv run:
+
+```bash
+uv python install 3.13
+```
+
+Then, to install PDM using UV, run the following command:
+
+```bash
+uv pip install pdm
+```
+
+#### PIPX Installation
+
+To install PDM using pipx, run the following command:
+
+```bash
+pipx install pdm
+```
+
+Prefer `pipx` as it allows you to install Python applications in isolated environments, preventing conflicts between packages.
+
+#### Verify PDM Installation
+
+When the installation is complete, you can verify that PDM is installed correctly by running:
+
+```bash
+pdm --version
+```
+
+### loudpy Installation
+
+To install loudpy for development purposes, use PDM to install it in editable mode. This allows you to make changes to the source code and have those changes reflected immediately without needing to reinstall the package. To do this, navigate to the directory where you have the loudpy source code and run:
+
+```bash
+pdm install -e .
+```

loudpy-0.0.5/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "loudpy"
+version = "0.0.5"
+description = "Python API for Fluid-solid interaction FEM simulations"
+authors = [
+    { name = "Romain Degraeve", email = "rom2graeve@gmail.com" },
+]
+dependencies = [
+    "numpy>=2.4.4",
+    "numba>=0.65.0",
+    "scipy>=1.17.1",
+    "gmsh>=4.15.2",
+    "h5py>=3.16.0",
+    "matplotlib>=3.10.9",
+    "pyvista>=0.48.4",
+]
+requires-python = ">=3.13"
+readme = "README.md"
+
+[project.license]
+text = "GPL-3.0+"
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[tool.pdm]
+distribution = true
+
+[tool.pdm.build]
+package-dir = "src"
+
+[dependency-groups]
+dev = [
+    "matplotlib>=3.10.8",
+    "ruff>=0.15.11",
+    "black>=26.3.1",
+]
+test = [
+    "pytest>=9.0.3",
+]

loudpy-0.0.5/src/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-0.0.5/src/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-0.0.5/src/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-0.0.5/src/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-0.0.5/src/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])
+