spectral_flux 0.1.3__tar.gz

spectral_flux-0.1.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Peter Carlip
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

spectral_flux-0.1.3/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: spectral_flux
+Version: 0.1.3
+Summary: Python tools for calculating spectral flux from fluid velocities
+Author: pcarlip
+Author-email: pcarlip <peter.carlip@proton.me>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: cupy-xarray>=0.1.5
+Requires-Dist: numpy>=2.5.2
+Requires-Dist: pandas>=3.0.5
+Requires-Dist: scipy>=1.18.1
+Requires-Dist: xarray>=2026.7.0
+Requires-Dist: xarray-extras>=0.6.0
+Requires-Dist: xrft
+Requires-Dist: xrscipy>=3.1.0
+Requires-Dist: cupy-cuda12x ; extra == 'cupy12'
+Requires-Dist: cupy-cuda13x ; extra == 'cupy13'
+Requires-Python: >=3.13
+Project-URL: Homepage, https://github.com/pcarlip/spec_flux
+Project-URL: Issues, https://github.com/pcarlip/spec_flux/issues
+Provides-Extra: cupy12
+Provides-Extra: cupy13
+Description-Content-Type: text/markdown
+
+# spec_flux
+Python tools for calculating spectral flux from fluid velocities

spectral_flux-0.1.3/README.md

@@ -0,0 +1,2 @@
+# spec_flux
+Python tools for calculating spectral flux from fluid velocities

spectral_flux-0.1.3/pyproject.toml

@@ -0,0 +1,112 @@
+[project]
+name = "spectral_flux"
+version = "0.1.3"
+description = "Python tools for calculating spectral flux from fluid velocities"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "cupy-xarray>=0.1.5",
+    "numpy>=2.5.2",
+    "pandas>=3.0.5",
+    "scipy>=1.18.1",
+    "xarray>=2026.7.0",
+    "xarray-extras>=0.6.0",
+    "xrft",
+    "xrscipy>=3.1.0",
+]
+license = "MIT"
+license-files = ["LICENSE"]
+
+[[project.authors]]
+name = "pcarlip"
+email = "peter.carlip@proton.me"
+
+[project.urls]
+Homepage = "https://github.com/pcarlip/spec_flux"
+Issues = "https://github.com/pcarlip/spec_flux/issues"
+
+[project.optional-dependencies]
+cupy12 = ["cupy-cuda12x"]
+cupy13 = ["cupy-cuda13x"]
+
+[project.scripts]
+spec-flux = "spec_flux:main"
+
+[tool.uv]
+conflicts = [[
+    { extra = "cuda12" },
+    { extra = "cuda13" },
+]]
+
+[tool.uv.sources.xrft]
+git = "https://github.com/pcarlip/xrft.git"
+branch = "cupy"
+
+[tool.ruff]
+exclude = [
+    ".git",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "venv",
+]
+line-length = 90
+indent-width = 4
+target-version = "py313"
+
+[tool.ruff.lint]
+select = [
+    "F",
+    "B",
+    "UP",
+    "I",
+    "ANN",
+    "E",
+    "A",
+    "C4",
+    "ICN",
+    "PIE",
+    "SIM",
+    "PLE",
+    "PLC",
+    "PLR",
+    "PLW",
+    "NPY",
+    "RUF",
+    "PD",
+    "PYI",
+    "PERF",
+    "C",
+    "FURB",
+]
+ignore = [
+    "F401",
+    "PLR0913",
+    "E203",
+    "B018",
+    "PLR0917",
+    "PLR0914",
+    "RUF003",
+    "PLR0915",
+]
+fixable = ["ALL"]
+unfixable = []
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+
+[build-system]
+requires = ["uv_build>=0.12.7,<0.13.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = ["ruff>=0.16.5"]
+test = [
+    "fluidsf>=0.2.2",
+    "pytest>=9.1.1",
+]

spectral_flux-0.1.3/pyproject.toml.orig

@@ -0,0 +1,115 @@
+[project]
+name = "spectral_flux"
+version = "0.1.3"
+description = "Python tools for calculating spectral flux from fluid velocities"
+readme = "README.md"
+authors = [{ name = "pcarlip", email = "peter.carlip@proton.me" }]
+requires-python = ">=3.13"
+dependencies = [
+    "cupy-xarray>=0.1.5",
+    "numpy>=2.5.2",
+    "pandas>=3.0.5",
+    "scipy>=1.18.1",
+    "xarray>=2026.7.0",
+    "xarray-extras>=0.6.0",
+    "xrft",
+    "xrscipy>=3.1.0",
+]
+license = "MIT"
+license-files = ["LICENSE"]
+
+
+[project.urls]
+Homepage = "https://github.com/pcarlip/spec_flux"
+Issues = "https://github.com/pcarlip/spec_flux/issues"
+
+[project.optional-dependencies]
+cupy12 = ["cupy-cuda12x"]
+cupy13 = ["cupy-cuda13x"]
+
+[tool.uv]
+conflicts = [[{ extra = "cuda12" }, { extra = "cuda13" }]]
+
+[project.scripts]
+spec-flux = "spec_flux:main"
+
+[build-system]
+requires = ["uv_build>=0.12.7,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.uv.sources]
+xrft = { git = "https://github.com/pcarlip/xrft.git", branch = "cupy" }
+# currently using my own branch of xrft which supports cupy
+# will switch to main branch if my PR is accepted
+
+[dependency-groups]
+dev = ["ruff>=0.16.5"]
+test = ["fluidsf>=0.2.2", "pytest>=9.1.1"]
+
+[tool.ruff]
+exclude = [
+    ".git",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "venv",
+]
+
+line-length = 90
+indent-width = 4
+target-version = "py313"
+
+[tool.ruff.lint]
+select = [
+    "F",
+    "B",
+    "UP",
+    "I",
+    "ANN",
+    "E",
+    "A",
+    "C4",
+    "ICN",
+    "PIE",
+    "SIM",
+    "PLE",
+    "PLC",
+    "PLR",
+    "PLW",
+    "NPY",
+    "RUF",
+    "PD",
+    "PYI",
+    "PERF",
+    "C",
+    "FURB",
+]
+
+ignore = [
+    "F401",
+    "PLR0913",
+    "E203",
+    "B018",
+    "PLR0917",
+    "PLR0914",
+    "RUF003",
+    "PLR0915",
+]
+fixable = ["ALL"]
+unfixable = []
+
+
+[tool.ruff.format]
+# Like Black, use double quotes for strings.
+quote-style = "double"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"

spectral_flux-0.1.3/src/spectral_flux/__init__.py

@@ -0,0 +1 @@
+

spectral_flux-0.1.3/src/spectral_flux/advection.py

@@ -0,0 +1,89 @@
+from typing import Literal
+
+import cupy_xarray
+import xarray as xr
+
+from .utils import (
+    Axis,
+    GradMethod,
+    krange_fft,
+    ndarray,
+    xp_fft,
+)
+
+
+def spectral_der(vel_hat: ndarray, k_grid: ndarray) -> ndarray:
+    """Approximate dv/dx as IFT(ik FT(v)), with cupy acceleration
+
+    Parameters
+    ----------
+    vel_hat : np.ndarray | cp.ndarray
+        Fourier transform of a velocity component
+    k_grid : np.ndarray | cp.ndarray
+        meshgrid component of k values along an axis
+
+    Returns
+    -------
+    np.ndarray | cp.ndarray
+        Realspace derivative of velocity with respect to the direction from the k-grid
+    """
+    xp, genfft = xp_fft(vel_hat)
+    return xp.real(genfft.ifftn(genfft.ifftshift(1j * k_grid * vel_hat)))
+
+
+def advection_xr(
+    data: xr.Dataset,
+    axis: Axis,
+    method: GradMethod,
+    ax_names: tuple[str, str, str] = ("z_aac", "y_aca", "x_caa"),
+    edge_order: Literal[1, 2] = 1,
+) -> xr.DataArray:
+    """Calculate (realspace) advection of a velocity array
+
+    Parameters
+    ----------
+    data : xr.Dataset
+        Dataset with velocity and (optionally) advection data
+    axis : Axis
+        Velocity direction to use
+    method : GradMethod
+        Method for calculating velocity gradients
+    ax_names : tuple[str, str, str], optional
+        names of z, y, and x axes in dataset, by default ("z_aac", "y_aca", "x_caa")
+    edge_order : Literal[1, 2], optional
+        Order of finite difference gradients if using GradMethod.numpy, by default 1
+
+    Returns
+    -------
+    xr.DataArray
+        xarray object containing advection along the specified axis
+
+    Raises
+    ------
+    Exception
+        Attempt to use GradMethod.oceananigans (precalculated advection) when
+        input data doesn't include that information
+    """
+    vel = (data["w"], data["v"], data["u"])[axis.value]
+    if method == GradMethod.precalc:
+        if "uadv" in data and "vadv" in data and "wadv" in data:
+            adv = (data["wadv"], data["vadv"], data["uadv"])[axis.value]
+        else:
+            raise Exception("Include advection arrays to use precalculated gradients")
+    elif method == GradMethod.numpy:
+        adv = (
+            data["u"] * vel.differentiate(ax_names[2], edge_order)
+            + data["v"] * vel.differentiate(ax_names[1], edge_order)
+            + data["w"] * vel.differentiate(ax_names[0], edge_order)
+        )
+    else:
+        xp, genfft = xp_fft(vel.data)
+        k_ranges = krange_fft(data)
+        k_mesh = xp.meshgrid(*k_ranges, indexing="ij")
+        vel_hat = genfft.fftshift(genfft.fftn(vel.data))
+        adv = (
+            data["w"] * spectral_der(vel_hat, k_mesh[0])
+            + data["v"] * spectral_der(vel_hat, k_mesh[1])
+            + data["u"] * spectral_der(vel_hat, k_mesh[2])
+        )
+    return adv

spectral_flux-0.1.3/src/spectral_flux/coarse_calc.py

@@ -0,0 +1,69 @@
+from collections.abc import Iterable
+
+import cupy as cp
+import cupy_xarray
+import xarray as xr
+from cupyx.scipy.ndimage import gaussian_filter
+
+
+def pi_cg_gauss_nd(
+    data: xr.Dataset,
+    k: float,
+    skip_dims: tuple[str, ...] = ("time",),
+    vel_names: tuple[str, str, str] = ("u", "v", "w"),
+    axes: tuple[str, str, str] = ("z_aac", "y_aca", "x_caa"),
+    periodic: tuple[bool, ...] = (True, True, True),
+) -> xr.DataArray:
+
+    # <f(s)> = ∫dr G(r)f(s+r), for which I use "gaussian_filter"
+    # τ_ij = <u_i u_j> - <u_i> <u_j>
+    # Π = -(∂_i <u_j>) τ_ij
+
+    smooth_dims = [i for i in axes if i not in skip_dims]
+    smooth_axes = [data[vel_names[0]].dims.index(i) for i in smooth_dims]
+
+    vels = tuple(data[i] for i in vel_names)
+    dz = float(data[axes[0]][1] - data[axes[0]][0])
+    dy = float(data[axes[1]][1] - data[axes[1]][0])
+    dx = float(data[axes[2]][1] - data[axes[2]][0])
+    size = ((1 / k) / dz, (1 / k) / dy, (1 / k) / dx)
+
+    modes = ["wrap" if i else "nearest" for i in periodic]
+    gauss_kwargs = {"sigma": size, "mode": modes, "axes": smooth_axes}
+
+    smoothed_vels = [
+        xr.apply_ufunc(gaussian_filter, vels[i], kwargs=gauss_kwargs) for i in range(3)
+    ]
+    running_sum = xr.DataArray(0.0, {"time": data.time, "k": k})
+
+    for i in range(3):
+        for j in range(3):
+            tau_1 = xr.apply_ufunc(
+                gaussian_filter, vels[i] * vels[j], kwargs=gauss_kwargs
+            )
+            tau_2 = smoothed_vels[i] * smoothed_vels[j]
+            tau = tau_1 - tau_2
+            grad = vels[i].differentiate(axes[j], 2)
+            running_sum -= cp.mean(tau * grad).data.get()
+
+    return running_sum
+
+
+def pi_cg_gauss_xr(
+    data: xr.Dataset,
+    k: float,
+    vel_names: tuple[str, str, str] = ("u", "v", "w"),
+    axes: tuple[str, str, str] = ("z_aac", "y_aca", "x_caa"),
+    periodic: tuple[bool, bool, bool] = (True, True, True),
+) -> xr.DataArray:
+    return pi_cg_gauss_nd(data, k, vel_names=vel_names, axes=axes, periodic=periodic)
+
+
+def pi_cg_lst_xr(data: xr.Dataset, k_cg: Iterable[float]) -> xr.DataArray:
+    return xr.concat([pi_cg_gauss_xr(data, k) for k in k_cg], "k")
+
+
+def pi_cg_lst_nd(
+    data: xr.Dataset, k_cg: Iterable[float], skip_dims: tuple[str, ...] = ("time",)
+) -> xr.DataArray:
+    return xr.concat([pi_cg_gauss_nd(data, k, skip_dims) for k in k_cg], "k")

spectral_flux-0.1.3/src/spectral_flux/fluidsf_compat.py

@@ -0,0 +1,78 @@
+import cupy as cp
+import numpy as np
+import xarray as xr
+
+from .sf_au import sf_au_dir_xr
+from .sf_ln import sf_ln_dir_xr
+from .utils import Axis, ndarray
+
+
+def fluidsf_compat(
+    u: ndarray,
+    v: ndarray,
+    w: ndarray,
+    x: ndarray,
+    y: ndarray,
+    z: ndarray,
+    sf_names: list[str],
+) -> dict[str, np.ndarray]:
+    """Get structure functions with compatible input ant output to fluidsf, using my
+    existing structure function methods
+    Arrays must be indexed as (z,y,x)
+
+    Parameters
+    ----------
+    u : ndarray
+        velocity along x
+    v : ndarray
+        velocity along y
+    w : ndarray
+        velocity along z
+    x : ndarray
+        locations along x
+    y : ndarray
+        locations along y
+    z : ndarray
+        locations along z
+    sf_names : list[str]
+        structure functions to calculate (supports 'ASF_V', 'LL', and 'LLL')
+
+    Returns
+    -------
+    dict[str, np.ndarray]
+        dictionary of directional structure function names and values
+    """
+
+    dims = ("z_aac", "y_aca", "x_caa")
+    ds = xr.Dataset(
+        {"u": (dims, u), "v": (dims, v), "w": (dims, w)},
+        coords={"z_aac": z, "y_aca": y, "x_caa": x},
+    )
+
+    L = len(z) // 2
+    M = len(y) // 2
+    N = len(x) // 2
+
+    dz = z[:L] - z[0]
+    dy = y[:M] - y[0]
+    dx = x[:N] - x[0]
+
+    out = {"x-diffs": dx, "y-diffs": dy, "z-diffs": dz}
+    if "ASF_V" in sf_names:
+        out["SF_advection_velocity_x"] = sf_au_dir_xr(ds, Axis.x).data
+        out["SF_advection_velocity_y"] = sf_au_dir_xr(ds, Axis.y).data
+        out["SF_advection_velocity_z"] = sf_au_dir_xr(ds, Axis.z).data
+    if "LLL" in sf_names:
+        out["SF_LLL_x"] = sf_ln_dir_xr(ds, Axis.x, 3).data
+        out["SF_LLL_y"] = sf_ln_dir_xr(ds, Axis.y, 3).data
+        out["SF_LLL_z"] = sf_ln_dir_xr(ds, Axis.z, 3).data
+    if "LL" in sf_names:
+        out["SF_LL_x"] = sf_ln_dir_xr(ds, Axis.x, 2).data
+        out["SF_LL_y"] = sf_ln_dir_xr(ds, Axis.y, 2).data
+        out["SF_LL_z"] = sf_ln_dir_xr(ds, Axis.z, 2).data
+
+    if cp.get_array_module(u).__name__ == "cupy":
+        for key, val in out.items():
+            out[key] = val.get()
+
+    return out

spectral_flux-0.1.3/src/spectral_flux/fourier_calc.py

@@ -0,0 +1,183 @@
+from collections.abc import Collection, Iterable
+from typing import Literal
+
+import cupy_xarray
+import numpy as np
+import xarray as xr
+import xrft
+from xrscipy.integrate import cumulative_simpson
+
+from .advection import advection_xr
+from .utils import Axis, GradMethod, axis_name
+
+
+def pi_int_dir_xr(
+    data: xr.Dataset,
+    axis: Axis,
+    method: GradMethod,
+    edge_order: Literal[1, 2] = 2,
+) -> xr.DataArray:
+    """Generate a component of  array to integrate: Re[FT(u)* • FT((u•∇)u)],
+    with optional cupy acceleration
+
+    Parameters
+    ----------
+    data : xr.Dataset
+        Dataset with realspace velocity components (on the same grid)
+    axis : Axis
+        Axis along which to generate the component
+    method : GradMethod
+        Method for calculating gradients
+    edge_order : Literal[1, 2], optional
+        Order of finite difference gradients at domain edges, by default 2
+
+    Returns
+    -------
+    xr.DataArray
+        Directional component of Re[FT(u)* • FT((u•∇)u)]
+    """
+    vel = (data.w, data.v, data.u)[axis.value]
+    adv_realspace = advection_xr(data, axis, method, edge_order=edge_order)
+    vel_hat = np.conj(xrft.fft(vel, dim=["x_caa", "y_aca", "z_aac"]))
+    adv_spec = xrft.fft(adv_realspace, dim=["x_caa", "y_aca", "z_aac"])
+    return np.conj(adv_spec * vel_hat)  # type: ignore
+
+
+def fourier_prep_xr(
+    data: xr.Dataset,
+    grad_method: GradMethod = GradMethod.numpy,
+    edge_order: Literal[1, 2] = 2,
+) -> xr.Dataset:
+    """Calculate integrand for spectral flux via fourier methods, with optional cupy
+    acceleration
+
+    Parameters
+    ----------
+    data : xr.Dataset
+        Dataset with realspace velocity components (on the same grid)
+    grad_method : GradMethod, optional
+        Method for calculating gradients, by default GradMethod.numpy
+    edge_order : Literal[1, 2], optional
+        Order of finite difference gradients at domain edges, by default 2
+
+    Returns
+    -------
+    xr.Dataset
+        Dataset with integrand values, k magnitudes
+    """
+    pi_int = (
+        pi_int_dir_xr(data, Axis.x, grad_method, edge_order)
+        + pi_int_dir_xr(data, Axis.y, grad_method, edge_order)
+        + pi_int_dir_xr(data, Axis.z, grad_method, edge_order)
+    ).rename("pi_int")
+    k = (pi_int.freq_x_caa**2 + pi_int.freq_y_aca**2 + pi_int.freq_z_aac**2).rename("k")
+    out = xr.merge([pi_int, k]).assign_attrs({"L": data.x_caa[-1] - data.x_caa[0]})
+    if pi_int.cupy.is_cupy:
+        return out.as_cupy()
+    else:
+        return out
+
+
+def fourier_int_xr(data: xr.Dataset, klim: float) -> xr.DataArray:
+    """Calculate spectral flux of energy dissipation through a fourier transform
+    at a specific wavenumber
+
+    Parameters
+    ----------
+    data : xr.Dataset
+        Dataset containing integrand, k magnitudes
+    klim : float
+        K value to integrate up to
+
+    Returns
+    -------
+    xr.DataArray
+        Spectral flux at klim
+    """
+    masked = data["pi_int"].where(data["k"] <= (klim / (2 * np.pi)) ** 2, 0.0)
+    val = masked.integrate(["freq_x_caa", "freq_y_aca", "freq_z_aac"])
+    num = np.real(val.item()) / data.L**3
+    return xr.DataArray(num, {"time": data.time, "k": klim})
+
+
+def fourier_int_xr_lst(data: xr.Dataset, k_lst: Iterable[float]) -> xr.DataArray:
+    """Calculate spectral flux of energy dissipation through a fourier transform
+    over a list of wavenumbers
+
+    Parameters
+    ----------
+    data : xr.Dataset
+        Dataset containing integrand, k magnitudes
+    k_lst : Iterable[float]
+        List of k values to integrate to
+
+    Returns
+    -------
+    xr.DataArray
+        Spectral flux as a function of k, at given k values
+    """
+    return xr.concat([fourier_int_xr(data, k) for k in k_lst], "k")
+
+
+def van_atta_prep(
+    data: xr.Dataset, cor_ax: Axis, vel_ax: Axis, periodic: bool = True
+) -> xr.DataArray:
+    """Triple product calculation of transfer function using Van Atta and Chen (1969)
+    velocities are assumed to be: u along x_caa, v along y_aca, w along z_aac
+
+    Parameters
+    ----------
+    data : xr.Dataset
+        n-dimensional velocity data in all directions, must include the cor_ax
+        but need not include other dimensions
+    cor_ax : Axis
+        axis along which to take the correlations
+    vel_ax : Axis
+        second axis from which to use velocities (may be the same as cor_ax)
+    periodic : bool
+        whether to rotate (if periodic) or shift (if not) the velocities along cor_ax
+
+    Returns
+    -------
+    xr.DataArray
+        transfer function as a function of k
+    """
+    cor_ax_name = axis_name(cor_ax)
+    cor_ax_xr = data[cor_ax_name]
+    cor_vel = data[("w", "v", "u")[cor_ax.value]]
+    shift_vel = data[("w", "v", "u")[vel_ax.value]]
+    n_shifts = len(cor_ax_xr) // 2 if periodic else len(cor_ax_xr)
+    shift_range = range(-n_shifts, n_shifts + 1)
+    dx = cor_ax_xr[1] - cor_ax_xr[0]
+    if periodic:
+        si1i = xr.concat(
+            [
+                (shift_vel * cor_vel * shift_vel.roll({cor_ax_name: i}))
+                .mean(cor_ax_name)
+                .expand_dims({"r": [i * dx]})
+                for i in shift_range
+            ],
+            "r",
+        )
+    else:
+        si1i = xr.concat(
+            [
+                (shift_vel * cor_vel * shift_vel.shift({cor_ax_name: i}))
+                .mean(cor_ax_name, skipna=True)
+                .expand_dims({"r": [i * dx]})
+                for i in shift_range
+            ],
+            "r",
+        )
+    si1i = 0.5 * (si1i - si1i.isel(r=slice(None, None, -1)).data)
+    l1 = xrft.fft(si1i, dim="r", real_dim="r").as_numpy()
+    l1 = l1.assign_coords(k=("freq_r", l1["freq_r"].data * 2 * np.pi))
+    l1 = l1 * 1j * l1["k"] / (2 * np.pi)
+    return 4 * l1 - 2 * l1["k"] * l1.differentiate("k")
+
+
+def van_atta_int(data: xr.DataArray, mean_axes: Collection[str]) -> xr.DataArray:
+    out: xr.DataArray = cumulative_simpson(data, coord="k")  # type: ignore
+    mean = out.isel(freq_r=slice(None, -1)).mean(mean_axes).real
+    norm = mean - mean.isel(freq_r=-1)
+    return norm.assign_coords(k=("freq_r", mean["freq_r"].data * 2 * np.pi))