cht_utils 2.0.0__py3-none-any.whl

cht_utils/physics/deshoal.py

@@ -0,0 +1,63 @@
+"""Wave shoaling adjustment for significant wave height."""
+
+from typing import Union
+
+import numpy as np
+
+from cht_utils.physics.disper import disper
+
+
+def deshoal(
+    hm0: Union[float, np.ndarray],
+    Tp: float,
+    d_profile: Union[float, np.ndarray],
+    d_BC: float,
+) -> Union[float, np.ndarray]:
+    """Adjust significant wave height for shoaling.
+
+    Parameters
+    ----------
+    hm0 : float or np.ndarray
+        Significant wave height at the boundary.
+    Tp : float
+        Peak wave period.
+    d_profile : float or np.ndarray
+        Water depth(s) along the profile.
+    d_BC : float
+        Water depth at the boundary condition location.
+
+    Returns
+    -------
+    float or np.ndarray
+        De-shoaled significant wave height.
+    """
+    cg_profile = wavecelerity(Tp, d_profile)
+    cg_BC = wavecelerity(Tp, d_BC)
+    return hm0 * np.sqrt(cg_profile / cg_BC)
+
+
+def wavecelerity(
+    Tp: float,
+    d: Union[float, np.ndarray],
+    g: float = 9.81,
+) -> Union[float, np.ndarray]:
+    """Compute wave group velocity.
+
+    Parameters
+    ----------
+    Tp : float
+        Peak wave period.
+    d : float or np.ndarray
+        Water depth.
+    g : float
+        Gravitational acceleration.
+
+    Returns
+    -------
+    float or np.ndarray
+        Group velocity.
+    """
+    k = disper(2 * np.pi / Tp, d, g)
+    n = 0.5 * (1 + 2 * k * d / np.sinh(2 * k * d))
+    c = g * Tp / (2 * np.pi) * np.tanh(k * d)
+    return n * c

cht_utils/physics/disper.py

@@ -0,0 +1,91 @@
+"""Linear wave dispersion relation solver.
+
+Absolute error in k*h < 5.0e-16 for all k*h.
+
+Example::
+
+    k = disper(2 * np.pi / 5, 5, 9.81)
+"""
+
+from typing import List, Union
+
+import numpy as np
+
+
+def disper(
+    w: Union[float, List[float]],
+    h: Union[float, List[float]],
+    g: float = 9.81,
+) -> np.ndarray:
+    """Solve the linear dispersion relation for wave number.
+
+    Parameters
+    ----------
+    w : float or list of float
+        Angular frequency (2*pi/T).
+    h : float or list of float
+        Water depth.
+    g : float
+        Gravitational acceleration.
+
+    Returns
+    -------
+    np.ndarray
+        Wave number(s).
+    """
+    if not isinstance(w, list):
+        w = [w]
+    if not isinstance(h, list):
+        h = [h]
+
+    w2 = [iw**2 * ih / g for iw, ih in zip(w, h)]
+    q = [iw2 / (1 - np.exp(-(iw2 ** (5 / 4)))) ** (2 / 5) for iw2 in w2]
+
+    the = np.tanh(q)
+    the2 = 1 - the**2
+
+    a = (1 - q * the) * the2
+    b = the + q * the2
+    c = q * the - w2
+
+    D = b**2 - 4 * a * c
+    arg = (-b + np.sqrt(D)) / (2 * a)
+    iq = np.where(D < 0)[0]
+    if len(iq) > 0:
+        arg[iq] = -c[iq] / b[iq]
+    q = q + arg
+
+    k = np.sign(w) * q / h
+    if np.isnan(k).any():
+        k = np.array(k)
+        k[np.isnan(k)] = 0
+
+    return k
+
+
+def disper_fentonmckee(
+    sigma: Union[float, np.ndarray],
+    d: Union[float, np.ndarray],
+    g: float = 9.81,
+) -> Union[float, np.ndarray]:
+    """Fenton-McKee approximation of the linear dispersion relation.
+
+    Parameters
+    ----------
+    sigma : float or np.ndarray
+        Angular frequency.
+    d : float or np.ndarray
+        Water depth.
+    g : float
+        Gravitational acceleration.
+
+    Returns
+    -------
+    float or np.ndarray
+        Approximate wave number(s).
+    """
+
+    def coth(x):
+        return 1.0 / np.tanh(x)
+
+    return (sigma**2 / g) * (coth(sigma * np.sqrt(d / g)) ** (3 / 2)) ** (2 / 3)

cht_utils/physics/runup_vo21.py

@@ -0,0 +1,229 @@
+"""Wave runup prediction using Van Ormondt (2021) empirical formulation.
+
+Computes the 2% exceedance runup level from offshore wave conditions
+and nearshore profile information, decomposed into setup, low-frequency,
+and high-frequency components with directional spreading corrections.
+"""
+
+from typing import Any, Union
+
+import numpy as np
+from scipy import interpolate as intp
+
+from cht_utils.physics.disper import disper
+
+
+class runup_vo21:
+    """Wave runup calculator following Van Ormondt (2021).
+
+    Parameters
+    ----------
+    hm0 : np.ndarray
+        Significant wave height.
+    tp : float
+        Peak wave period.
+    ztide : float or np.ndarray
+        Tidal water level.
+    sl1 : float, np.ndarray, or dict
+        Surf slope parameter. Interpretation depends on *sl1opt*.
+    sl2 : float or np.ndarray
+        Beach slope (foreshore).
+    sl1opt : str
+        Slope option: ``"ad"`` (adaptive), ``"slope"`` (direct), or
+        ``"xz"`` (cross-shore profile dict with keys ``"x"`` and ``"z"``).
+    """
+
+    def __init__(
+        self,
+        hm0: np.ndarray,
+        tp: float,
+        ztide: Union[float, np.ndarray],
+        sl1: Any,
+        sl2: Union[float, np.ndarray],
+        sl1opt: str,
+    ) -> None:
+        self.hm0 = hm0
+        self.tp = tp
+        self.h = self.tp * 10
+
+        k = disper(2 * np.pi / self.tp, self.h, 9.81)
+        self.l1 = 2 * np.pi / k
+        self.steepness = self.hm0 / self.l1
+
+        if np.size(ztide) == 1:
+            ztide = np.zeros(np.size(self.hm0)) + ztide
+        if np.size(sl2) == 1:
+            sl2 = np.zeros(np.size(self.hm0)) + sl2
+
+        if sl1opt == "ad":
+            gambr = 1
+            fh = 1 / gambr
+            surfslope2 = np.zeros(np.size(ztide))
+            surfslope2[0] = (fh * self.hm0) / (fh * self.hm0 / self.surfslope) ** 1.5
+            for itide in range(np.size(ztide)):
+                if ztide[itide] == 0:
+                    pass
+                else:
+                    xxx = np.arange(-1000, 5005, 5)
+                    yyy0 = -sl1[itide] * xxx ** (2 / 3)
+                    yyy0[np.argwhere(xxx < 0)] = -xxx[np.argwhere(xxx < 0)] * sl2[itide]
+                    yyy = yyy0 - ztide[itide]
+                    ii1 = np.argwhere(yyy < 0)[0]
+                    ii2 = np.argwhere(yyy < -self.hm0[itide] / gambr)[0]
+                    surfslope2[itide] = (yyy[ii1] - yyy[ii2]) / (xxx[ii2] - xxx[ii1])
+        elif sl1opt == "slope":
+            surfslope2 = sl1
+        elif sl1opt == "xz":
+            gambr = 1
+            xxxx = np.arange(sl1["x"][0], sl1["x"][-1], 1)
+            zzzz = intp.interp1d(sl1["x"], sl1["z"])(xxxx)
+            sl1["x"] = xxxx
+            sl1["z"] = zzzz
+            surfslope2 = np.zeros(np.size(ztide))
+            xxx = sl1["x"]
+            yyy0 = sl1["z"]
+            for itide in range(np.size(ztide)):
+                yyy = yyy0 - ztide[itide]
+                ii1 = np.argwhere(yyy < 0)[0]
+                ii2 = np.argwhere(yyy < -self.hm0[itide] / gambr)[0]
+                surfslope2[itide] = (yyy[ii1] - yyy[ii2]) / (xxx[ii2] - xxx[ii1])
+
+        self.sl2 = sl2
+        self.ztide = ztide
+        self.surfslope = surfslope2
+        self.ksis = self.surfslope / np.sqrt(self.hm0 / self.l1)
+
+    def compute_r2p(self, drspr: np.ndarray, phi: np.ndarray) -> None:
+        """Compute the 2% exceedance runup level.
+
+        Parameters
+        ----------
+        drspr : np.ndarray
+            Directional spreading (degrees).
+        phi : np.ndarray
+            Wave direction relative to shore normal (degrees).
+        """
+        ksi1 = self.surfslope / np.sqrt(self.hm0 / self.l1)
+        ksi2 = self.sl2 / np.sqrt(self.hm0 / self.l1)
+
+        self.compute_setup(drspr, phi)
+        self.compute_hm0_lf(drspr, phi)
+        self.compute_hm0_hf(drspr, phi)
+
+        self.r2p = self.setup + 0.82396 * np.sqrt(
+            (0.82694 * self.hm0_lf) ** 2 + (0.73965 * self.hm0_hf) ** 2
+        ) * ksi2**0.15201 * ksi1 ** (-0.086635)
+
+    def compute_setup(self, drspr: np.ndarray, phi: np.ndarray) -> None:
+        """Compute wave setup component."""
+        b = [
+            4.0455506e00,
+            2.3740615e-02,
+            2.0340287e00,
+            4.6497588e-01,
+            7.0244541e-01,
+            5.0000000e-01,
+            -3.1727583e-01,
+        ]
+        ksib = self.sl2 / np.sqrt(self.hm0 / self.l1)
+        v = (
+            b[0]
+            * self.hm0
+            * (b[1] + np.exp(-b[2] * self.ksis ** b[6] * ksib ** b[3]) * ksib ** b[4])
+        )
+        fac1 = self._dirspreadfac_setup(drspr)
+        fac2 = self._directionfac_setup(phi)
+        self.setup = v * fac1 * fac2
+
+    def compute_hm0_lf(self, drspr: np.ndarray, phi: np.ndarray) -> None:
+        """Compute low-frequency wave height component."""
+        b = [
+            3.4547125e00,
+            5.8790748e-01,
+            3.6906975e00,
+            2.3378556e-01,
+            2.3038164e00,
+            0,
+            5.0000000e-01,
+            0,
+        ]
+
+        self.tm0_ig = self._compute_tm01_ig()
+        self.IG = self._compute_ig_in()
+
+        l0 = np.squeeze(np.sqrt(9.81 * 0.33333 * self.hm0) * self.tm0_ig)
+        ksib = np.squeeze(self.sl2 / np.sqrt(self.IG / l0))
+        ksib = np.maximum(ksib - b[5], 0)
+        ksibm = b[4] * self.surfslope ** b[3]
+        psibd = b[0] * ksib ** b[1]
+        psibr = (b[0] * ksibm ** b[1] - 2.0) * np.exp(-(ksib - ksibm) / b[2]) + 2
+        psib = psibd.copy()
+        ind = np.argwhere(ksib > ksibm)
+        psib[ind] = psibr[ind]
+
+        v = self.IG * psib
+        fac1 = self._dirspreadfac_lf(drspr)
+        fac2 = self._directionfac_lf(phi)
+        self.hm0_lf = v * fac1 * fac2
+
+    def compute_hm0_hf(self, drspr: np.ndarray, phi: np.ndarray) -> None:
+        """Compute high-frequency wave height component."""
+        b = [
+            9.5635099e-01,
+            2.0143005e00,
+            5.3602429e-01,
+            2.0000000e00,
+            0.0000000e00,
+            6.1856544e-01,
+            1.0000000e00,
+            0.0000000e00,
+        ]
+        ksib = self.sl2 / np.sqrt(self.hm0 / self.l1)
+        self.hm0_hf = (
+            b[0]
+            * self.hm0
+            * ksib ** b[1]
+            * np.tanh((self.ksis + b[4]) ** b[5] / (b[2] * ksib ** b[3]))
+        )
+
+    def _compute_tm01_ig(self) -> np.ndarray:
+        """Compute infragravity wave period."""
+        b = [4.4021341e-07, 1.8635421e00, -4.2705433e-01, 7.2541023e-02, 2.0058478e01]
+        tm0_ig = (
+            b[0]
+            + b[1] * self.surfslope ** b[2] * self.steepness ** b[3]
+            + b[4] * self.surfslope
+        )
+        return tm0_ig * self.tp
+
+    def _compute_ig_in(self) -> np.ndarray:
+        """Compute incoming infragravity wave amplitude."""
+        b = [2.2740842e00, 1.0, 0.5, 2.7211454e03, 2.0, 1.7794945e01, 1.8728433e-01]
+        return self.hm0 * (
+            b[0] * self.surfslope ** b[2] * np.exp(-b[5] * self.surfslope ** b[1])
+            + b[6] * np.exp(-b[3] * self.steepness ** b[4])
+        )
+
+    def _directionfac_setup(self, phi: np.ndarray) -> np.ndarray:
+        b = [1.4291, 0.0035124, 0.31891]
+        return 1 - b[1] * self.steepness ** b[2] * np.absolute(phi) ** b[0]
+
+    def _dirspreadfac_setup(self, drspr: np.ndarray) -> np.ndarray:
+        b = [0.031448, 0.69432, 0.66677]
+        return np.exp(-b[0] * drspr ** b[1] * (1.0 - np.tanh(b[2] * self.ksis)))
+
+    def _dirspreadfac_lf(self, drspr: np.ndarray) -> np.ndarray:
+        b = [0.047593, 0.67228, 0.50777]
+        return np.exp(-b[0] * drspr ** b[1] * (1.0 - np.tanh(b[2] * self.ksis)))
+
+    def _directionfac_lf(self, phi: np.ndarray) -> np.ndarray:
+        b = [0.40488, 2.7073]
+        return np.cos(phi * np.pi / 180) ** (b[0] + b[1] * self.surfslope)
+
+    def _directionfac_hf(self, phi: np.ndarray) -> np.ndarray:
+        b = [4.1355e-10]
+        return np.cos(phi * np.pi / 180) ** b[0]
+
+    def _dirspreadfac_hf(self, drspr: np.ndarray) -> np.ndarray:
+        b = [0.044544, 1, 21.1281]
+        return np.exp(-b[0] * drspr ** b[1] * (1.0 - np.tanh(b[2] * self.ksis)))

cht_utils/physics/waves.py

@@ -0,0 +1,59 @@
+"""Wave decomposition utilities."""
+
+import numpy as np
+import pandas as pd
+from scipy.signal import detrend
+
+
+def split_waves_guza(df: pd.DataFrame, zb: float) -> pd.DataFrame:
+    """Decompose water surface into incident and reflected waves (Guza method).
+
+    Performs a time-domain decomposition of the water surface elevation and
+    velocity into incoming and outgoing components using shallow-water theory.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        DataFrame with columns ``"z"`` (water level) and ``"u"`` (velocity).
+    zb : float
+        Bed level elevation.
+
+    Returns
+    -------
+    pd.DataFrame
+        Input DataFrame with added columns ``"zin"``, ``"zout"``,
+        ``"uin"``, ``"uout"``.
+    """
+    g = 9.81
+
+    zsi = df["z"].values
+    umi = df["u"].values
+
+    zsm = np.mean(zsi)
+    umm = np.mean(umi)
+    h = zsm - zb
+
+    zs = zsi - zsm
+    um = umi - umm
+
+    zsd = detrend(zs, type="linear")
+    umd = detrend(um, type="linear")
+
+    zsm = zsm + (zs - zsd)
+    zs = zsd
+    umm = umm + (um - umd)
+    um = umd
+
+    hh = zs + h
+    c = np.sqrt(g * hh)
+    q = umd * hh
+
+    ein = (zs * c + q) / (2 * c)
+    eout = (zs * c - q) / (2 * c)
+
+    df["zin"] = ein + zsm
+    df["zout"] = eout + zsm
+    df["uin"] = np.sqrt(1.0 / hh**2) * c * ein + umm
+    df["uout"] = -np.sqrt(1.0 / hh**2) * c * eout + umm
+
+    return df

cht_utils/probabilistic/__init__.py

@@ -0,0 +1,5 @@
+"""Probabilistic post-processing for ensemble model output."""
+
+from cht_utils.probabilistic.prob_maps import merge_nc_his as merge_nc_his
+from cht_utils.probabilistic.prob_maps import merge_nc_map as merge_nc_map
+from cht_utils.probabilistic.prob_maps import prob_floodmaps as prob_floodmaps

cht_utils/probabilistic/prob_maps.py

@@ -0,0 +1,263 @@
+"""Generate probability maps and merge ensemble NetCDF output.
+
+Supports both regular grids and quadtree (unstructured mesh) datasets.
+"""
+
+from typing import List, Optional
+
+import numpy as np
+import xarray as xr
+
+from cht_utils.fileops import delete_file
+
+
+def prob_floodmaps(
+    file_list: List[str],
+    variables: List[str],
+    prcs: List[float],
+    delete: bool = False,
+    output_file_name: Optional[str] = None,
+) -> None:
+    """Generate probability flood maps from ensemble NetCDF files.
+
+    Parameters
+    ----------
+    file_list : List[str]
+        Paths to ensemble member NetCDF files.
+    variables : List[str]
+        Variable names to process.
+    prcs : List[float]
+        Percentiles to compute (0-100 scale).
+    delete : bool
+        Delete input files after reading.
+    output_file_name : str or None
+        Output NetCDF file path.
+    """
+    ds_concat = []
+    for file in file_list:
+        dsin = xr.open_dataset(file)
+        ds_concat.append(dsin[variables])
+        if delete:
+            delete_file(file)
+
+    combined_ds = xr.concat(ds_concat, dim="ensemble")
+
+    out_qq = {}
+    for v in variables:
+        combined_ds[v] = xr.where(np.isnan(combined_ds[v]), 0, combined_ds[v])
+        out_qq[v] = np.percentile(combined_ds[v], prcs, axis=0)
+        out_qq[v] = np.where(out_qq[v] == 0, np.nan, out_qq[v])
+
+    dsin = xr.open_dataset(file_list[0])
+    for i, p in enumerate(prcs):
+        for v in variables:
+            dsin[f"{v}_{p}"] = xr.DataArray(out_qq[v][i], dims=dsin[v].dims)
+            dsin[f"{v}_{p}"].attrs["long_name"] = f"{v}_{p}"
+
+    try:
+        delete_file(output_file_name)
+    except Exception:
+        pass
+    dsin.to_netcdf(path=output_file_name)
+    dsin.close()
+
+
+def merge_nc_his(
+    file_list: List[str],
+    variables: List[str],
+    prcs: Optional[List[float]] = None,
+    delete: bool = False,
+    output_file_name: Optional[str] = None,
+) -> None:
+    """Merge ensemble history files and compute quantiles.
+
+    Parameters
+    ----------
+    file_list : List[str]
+        Paths to ensemble member NetCDF files.
+    variables : List[str]
+        Variable names to merge.
+    prcs : List[float] or None
+        Quantile probabilities (0-1 scale). Defaults to ``[0.05, 0.5, 0.95]``.
+    delete : bool
+        Delete input files after reading.
+    output_file_name : str or None
+        Output NetCDF file path.
+    """
+    if prcs is None:
+        prcs = [0.05, 0.5, 0.95]
+    if len(file_list) == 0:
+        print("his-file list is empty")
+        return
+
+    nens = len(file_list)
+    ds = xr.open_dataset(file_list[0])
+    if "runtime" in ds.dims:
+        ds = ds.drop_dims("runtime")
+    if "structures" in ds.dims:
+        ds = ds.drop_dims("structures")
+
+    dimensions = list(ds.dims.keys())
+    dimensions = ["time"] + [d for d in dimensions if d != "time"]
+    new_dimensions = dimensions + ["ensemble"]
+    ens = range(nens)
+
+    for v in variables:
+        ds[v] = xr.DataArray(
+            data=np.zeros(
+                tuple(ds.dims[d] if d in ds.dims else nens for d in new_dimensions)
+            ),
+            dims=new_dimensions,
+            coords={d: ds[d] if d in ds.dims else ens for d in new_dimensions},
+        )
+
+    for iens, file in enumerate(file_list):
+        dsin = xr.open_dataset(file)
+        if "runtime" in dsin.dims:
+            dsin = dsin.drop_dims("runtime")
+        if "structures" in dsin.dims:
+            dsin = dsin.drop_dims("structures")
+        for v in variables:
+            ds[v][:, :, iens] = dsin[v].transpose("time", ...)
+
+    for v in variables:
+        arr = ds[v].fillna(-999.0).quantile(prcs, dim="ensemble")
+        for ip, p in enumerate(prcs):
+            ds[f"{v}_{round(p * 100)}"] = arr[ip, :, :]
+
+    try:
+        delete_file(output_file_name)
+    except Exception:
+        pass
+    ds.to_netcdf(path=output_file_name)
+    ds.close()
+
+
+def merge_nc_map(
+    file_list: List[str],
+    variables: List[str],
+    prcs: Optional[List[float]] = None,
+    delete: bool = False,
+    output_file_name: Optional[str] = None,
+) -> None:
+    """Merge ensemble map files and compute quantiles.
+
+    Supports both regular grids and quadtree (unstructured) meshes.
+    Uses sorting instead of ``xr.quantile`` for performance.
+
+    Parameters
+    ----------
+    file_list : List[str]
+        Paths to ensemble member NetCDF files.
+    variables : List[str]
+        Variable names to merge.
+    prcs : List[float] or None
+        Quantile probabilities (0-1 scale). Defaults to ``[0.9]``.
+    delete : bool
+        Delete input files after reading.
+    output_file_name : str or None
+        Output NetCDF file path.
+    """
+    if prcs is None:
+        prcs = [0.9]
+
+    nens = len(file_list)
+    ds = xr.open_dataset(file_list[0])
+
+    if "mesh2d_face_nodes" in ds:
+        _merge_quadtree(ds, file_list, variables, prcs, nens)
+    else:
+        _merge_regular(ds, file_list, variables, prcs, nens)
+
+    # Remove original variables
+    to_drop = ["zs", "zsmax", "cumprcp", "cuminf", "qinf", "hm0max"]
+    for v in to_drop:
+        if v in ds:
+            ds = ds.drop(v)
+
+    try:
+        delete_file(output_file_name)
+    except Exception:
+        pass
+    ds.to_netcdf(path=output_file_name)
+    ds.close()
+
+
+def _merge_quadtree(
+    ds: xr.Dataset,
+    file_list: List[str],
+    variables: List[str],
+    prcs: List[float],
+    nens: int,
+) -> None:
+    """Merge quadtree (unstructured) map data."""
+    npoints = ds["nmesh2d_face"].size
+    for v in variables:
+        attrs = ds[v].attrs
+        timedim = ds[v].dims[0]
+        ntimes = ds.sizes[timedim]
+
+        arr = xr.DataArray(
+            data=np.zeros((ntimes, npoints, nens)),
+            dims=(timedim, "nmesh2d_face", "ensemble"),
+            coords={timedim: ds[timedim], "ensemble": range(nens)},
+        )
+        ds[v] = arr
+
+        for iens, file in enumerate(file_list):
+            dsin = xr.open_dataset(file)
+            ds[v][:, :, iens] = dsin[v]
+            dsin.close()
+
+        sorted_arr = np.sort(ds[v].values, axis=2)
+        for ip, p in enumerate(prcs):
+            indx = min(max(int(np.ceil(p * nens)) - 1, 0), nens - 1)
+            da = xr.DataArray(
+                data=sorted_arr[:, :, indx],
+                dims=(timedim, "nmesh2d_face"),
+                coords={timedim: ds[timedim]},
+            )
+            da.attrs = attrs
+            ds[f"{v}_{round(p * 100)}"] = da
+
+
+def _merge_regular(
+    ds: xr.Dataset,
+    file_list: List[str],
+    variables: List[str],
+    prcs: List[float],
+    nens: int,
+) -> None:
+    """Merge regular grid map data."""
+    for v in variables:
+        attrs = ds[v].attrs
+        timedim = ds[v].dims[0]
+        ntimes = ds.sizes[timedim]
+
+        arr = xr.DataArray(
+            data=np.zeros((ntimes, ds.x.shape[0], ds.x.shape[1], nens)),
+            dims=(timedim, "n", "m", "ensemble"),
+            coords={
+                timedim: ds[timedim],
+                "x": ds.x,
+                "y": ds.y,
+                "ensemble": range(nens),
+            },
+        )
+        ds[v] = arr
+
+        for iens, file in enumerate(file_list):
+            dsin = xr.open_dataset(file)
+            ds[v][:, :, :, iens] = dsin[v]
+            dsin.close()
+
+        sorted_arr = np.sort(ds[v].values, axis=3)
+        for ip, p in enumerate(prcs):
+            indx = min(max(int(np.ceil(p * nens)) - 1, 0), nens - 1)
+            da = xr.DataArray(
+                data=sorted_arr[:, :, :, indx],
+                dims=(timedim, "n", "m"),
+                coords={timedim: ds[timedim], "x": ds.x, "y": ds.y},
+            )
+            da.attrs = attrs
+            ds[f"{v}_{round(p * 100)}"] = da