Skip to content

K-Dense-AI/scientific-agent-skills / skills/openpiv

openpiv

Verified

Performs Particle Image Velocimetry (PIV) analysis with OpenPIV. Use when extracting velocity fields from PIV image pairs, analyzing fluid dynamics or flow visualization experiments, cross-correlating interrogation windows, validating and replacing spurious PIV vectors, or computing vorticity, strain rate, and turbulence statistics from measured velocity fields.

FileKindSize
SKILL.mdskill md18.6 KB
references/advanced_algorithms.mdmarkdown14.8 KB
scripts/__init__.pyscript29 B
scripts/analyze.pyscript6.1 KB
scripts/run_example.pyscript2.8 KB
scripts/runner.pyscript10.1 KB

scripts/analyze.py

View on GitHub
"""Post-processing helpers for a params.npz written by runner.py.

Verified against openpiv 0.26.1. Pure numpy -- no OpenPIV import needed here.
"""

from pathlib import Path
from typing import Dict, Optional, Tuple

import numpy as np


class PIVAnalyzer:
    """Derived quantities from a saved PIV velocity field.

    The fields in params.npz are already scaled to physical units by runner.py, so
    x and y are in the same unit as the scaling factor and u and v are that unit per
    second. Gradient methods infer spacing and orientation from saved coordinates.
    Derivatives use interpolated fluid vectors; permanently masked regions stay NaN.
    """

    def __init__(self, params_file: str):
        self.params_file = Path(params_file)

        with np.load(self.params_file, allow_pickle=False) as data:
            self.x = data["x"]
            self.y = data["y"]
            self.u = data["u"]
            self.v = data["v"]
            self.flags = data["flags"].astype(bool)
            self.mask = data["mask"].astype(bool) if "mask" in data else np.zeros_like(self.flags)
        self.u = np.where(self.mask, np.nan, self.u)
        self.v = np.where(self.mask, np.nan, self.v)

    @property
    def grid_spacing(self) -> Tuple[float, float]:
        """(dx, dy) inferred from the coordinate arrays, in physical units."""
        dx = float(np.abs(np.diff(self.x, axis=1)).mean()) if self.x.shape[1] > 1 else 1.0
        dy = float(np.abs(np.diff(self.y, axis=0)).mean()) if self.y.shape[0] > 1 else 1.0
        return dx, dy

    @property
    def axis_signs(self) -> Tuple[float, float]:
        """(+-1, +-1): whether x and y increase or decrease along the array axes.

        runner.py converts to a physical right-handed (y-up) frame while leaving rows in
        image order -- so physical y *decreases* as the row index grows. np.gradient
        only sees the array, so differentiating with a positive spacing would return
        -du/dy there and change the vorticity and shear-strain contributions.
        These signs put the derivatives back on the physical axes.
        """
        x_sign = -1.0 if self.x.shape[1] > 1 and self.x[0, 1] < self.x[0, 0] else 1.0
        y_sign = -1.0 if self.y.shape[0] > 1 and self.y[1, 0] < self.y[0, 0] else 1.0
        return x_sign, y_sign

    def _steps(
        self, dx: Optional[float], dy: Optional[float]
    ) -> Tuple[float, float, float, float]:
        """(dx, dy, x_sign, y_sign) for a gradient call, defaulting to the grid."""
        gx, gy = self.grid_spacing
        x_sign, y_sign = self.axis_signs
        return (
            gx if dx is None else abs(float(dx)),
            gy if dy is None else abs(float(dy)),
            x_sign,
            y_sign,
        )

    def plot_vector_field(
        self,
        scale: int = 50,
        width: float = 0.0035,
        save_path: Optional[str] = None,
    ):
        """Quiver plot of the valid vectors. Saves to save_path, or shows interactively."""
        import matplotlib.pyplot as plt

        valid = ~(self.flags | self.mask) & np.isfinite(self.u) & np.isfinite(self.v)
        fig, ax = plt.subplots(figsize=(10, 8))
        ax.quiver(
            self.x[valid],
            self.y[valid],
            self.u[valid],
            self.v[valid],
            scale=scale,
            width=width,
        )
        ax.set_xlabel("x")
        ax.set_ylabel("y")
        ax.set_title("Velocity Field")
        ax.set_aspect("equal")
        if save_path:
            fig.savefig(save_path, dpi=150, bbox_inches="tight")
            plt.close(fig)
        else:
            plt.show()
        return fig

    def get_velocity_magnitude(self) -> np.ndarray:
        return np.sqrt(self.u**2 + self.v**2)

    def compute_vorticity(
        self, dx: Optional[float] = None, dy: Optional[float] = None
    ) -> np.ndarray:
        """Out-of-plane vorticity, dv/dx - du/dy. Defaults to the inferred grid spacing.

        dx and dy are spacing magnitudes; the axis orientation comes from the saved
        coordinates (see axis_signs), so a counter-clockwise flow gives positive
        vorticity whichever way the rows run.
        """
        dx, dy, x_sign, y_sign = self._steps(dx, dy)
        dv_dx = x_sign * np.gradient(self.v, dx, axis=1)
        du_dy = y_sign * np.gradient(self.u, dy, axis=0)
        return dv_dx - du_dy

    def compute_strain(
        self, dx: Optional[float] = None, dy: Optional[float] = None
    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
        """Return (exx, eyy, exy) of the 2D strain-rate tensor."""
        dx, dy, x_sign, y_sign = self._steps(dx, dy)
        du_dx = x_sign * np.gradient(self.u, dx, axis=1)
        du_dy = y_sign * np.gradient(self.u, dy, axis=0)
        dv_dx = x_sign * np.gradient(self.v, dx, axis=1)
        dv_dy = y_sign * np.gradient(self.v, dy, axis=0)
        return du_dx, dv_dy, 0.5 * (du_dy + dv_dx)

    def compute_statistics(self, include_interpolated: bool = False) -> Dict[str, float]:
        """Spatial mean and RMS over this single frame.

        This is NOT Reynolds decomposition: subtracting one frame's spatial mean
        measures spatial variance, which equals turbulent intensity only for a
        homogeneous field. True turbulence statistics need an ensemble of pairs --
        average over the time axis, then subtract that mean field from each frame.
        By default exclude flagged/interpolated vectors and masked obstacles.
        The legacy key 'tke' is only two-component spatial variance energy, not
        three-component turbulent kinetic energy.
        """
        valid = ~self.mask & np.isfinite(self.u) & np.isfinite(self.v)
        if not include_interpolated:
            valid &= ~self.flags
        if not valid.any():
            raise ValueError("No valid fluid vectors remain for statistics")
        u, v = self.u[valid], self.v[valid]
        u_prime = u - np.mean(u)
        v_prime = v - np.mean(v)
        rms_u = float(np.nanstd(u_prime))
        rms_v = float(np.nanstd(v_prime))
        return {
            "u_mean": float(np.mean(u)),
            "v_mean": float(np.mean(v)),
            "rms_u": rms_u,
            "rms_v": rms_v,
            "tke": 0.5 * (rms_u**2 + rms_v**2),
        }
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 194kUpdated Claude CodeCodexVerifiedInstall