pyfuga 0.2.0__tar.gz → 0.4.0__tar.gz

{pyfuga-0.2.0 → pyfuga-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyfuga
-Version: 0.2.0
+Version: 0.4.0
 Summary: Linearised CFD wake model (PyFuga)
 Author-email: PyFuga team <lalc@dtu.dk>
 License-Expression: MIT
@@ -43,6 +43,9 @@ Provides-Extra: lint
 Requires-Dist: ruff>0.14; extra == "lint"
 Requires-Dist: black[jupyter]>=26.1.0; extra == "lint"
 Requires-Dist: mypy>=1.19.1; extra == "lint"
+Requires-Dist: packaging>=24; extra == "lint"
+Requires-Dist: scipy-stubs<1.18,>=1.10; extra == "lint"
+Requires-Dist: types-tqdm>=4.0; extra == "lint"
 Provides-Extra: docs
 Requires-Dist: sphinx==7.4.7; extra == "docs"
 Requires-Dist: sphinx-autobuild==2024.10.3; extra == "docs"
@@ -69,9 +72,8 @@ PyFuga is part of the [**PyWake**](https://gitlab.windenergy.dtu.dk/TOPFARM/PyWa
 
 [![pipeline status](https://gitlab.windenergy.dtu.dk/TOPFARM/PyFuga/badges/main/pipeline.svg)](https://gitlab.windenergy.dtu.dk/TOPFARM/PyFuga/-/commits/main)
 [![coverage report](https://gitlab.windenergy.dtu.dk/TOPFARM/PyFuga/badges/main/coverage.svg)](https://gitlab.windenergy.dtu.dk/TOPFARM/PyFuga/-/commits/main)
-[![documentation](https://img.shields.io/badge/docs-latest-brightgreen.svg)](https://topfarm.pages.windenergy.dtu.dk/PyFuga/main/index.html)
-<!-- Replace 000000000 with the Zenodo badge id after first deposit -->
-[![DOI](https://zenodo.org/badge/000000000.svg)](https://zenodo.org/badge/latestdoi/000000000)
+[![documentation](https://img.shields.io/badge/docs-latest-brightgreen.svg)](https://topfarm.pages.windenergy.dtu.dk/PyFuga)
+[![All versions DOI (Zenodo)](https://zenodo.org/badge/DOI/10.5281/zenodo.19569518.svg)](https://doi.org/10.5281/zenodo.19569518)
 
 ## Installation
 
@@ -97,7 +99,7 @@ A minimal example to get you started is available in **[the QuickStart Jupyter n
 
 ## Documentation
 
-Learn more about PyFuga at the **[official documentation](https://topfarm.pages.windenergy.dtu.dk/PyFuga/main/index.html)**.
+Learn more about PyFuga at the **[official documentation](https://topfarm.pages.windenergy.dtu.dk/PyFuga)**.
 
 ## Release history
 
@@ -113,7 +115,19 @@ Issues and feature requests can be submitted through the project's [**GitLab iss
 
 ## Citing PyFuga
 
-Please cite both the underlying Fuga theory and the PyFuga software implementation. See the "Citing PyFuga" section in the documentation for recommended references and BibTeX entries.
+Please cite both the underlying Fuga theory and the PyFuga software implementation.
+
+For PyFuga itself, **use the DOI on the Zenodo record for the release version you used** (this is the canonical source of truth). The repository `CITATION.cff` mirrors this metadata for convenience.
+
+The badge above points to the latest release DOI. For scientific citation, always use the DOI for the exact release version used in your work.
+
+If you have PyFuga installed, you can print a Zenodo search link for your installed version:
+
+```bash
+python scripts/citation.py
+```
+
+See the "Citing PyFuga" section in the documentation for recommended references and BibTeX entries.
 
 ## Authors and acknowledgements
 

{pyfuga-0.2.0 → pyfuga-0.4.0}/README.md

@@ -8,9 +8,8 @@ PyFuga is part of the [**PyWake**](https://gitlab.windenergy.dtu.dk/TOPFARM/PyWa
 
 [![pipeline status](https://gitlab.windenergy.dtu.dk/TOPFARM/PyFuga/badges/main/pipeline.svg)](https://gitlab.windenergy.dtu.dk/TOPFARM/PyFuga/-/commits/main)
 [![coverage report](https://gitlab.windenergy.dtu.dk/TOPFARM/PyFuga/badges/main/coverage.svg)](https://gitlab.windenergy.dtu.dk/TOPFARM/PyFuga/-/commits/main)
-[![documentation](https://img.shields.io/badge/docs-latest-brightgreen.svg)](https://topfarm.pages.windenergy.dtu.dk/PyFuga/main/index.html)
-<!-- Replace 000000000 with the Zenodo badge id after first deposit -->
-[![DOI](https://zenodo.org/badge/000000000.svg)](https://zenodo.org/badge/latestdoi/000000000)
+[![documentation](https://img.shields.io/badge/docs-latest-brightgreen.svg)](https://topfarm.pages.windenergy.dtu.dk/PyFuga)
+[![All versions DOI (Zenodo)](https://zenodo.org/badge/DOI/10.5281/zenodo.19569518.svg)](https://doi.org/10.5281/zenodo.19569518)
 
 ## Installation
 
@@ -36,7 +35,7 @@ A minimal example to get you started is available in **[the QuickStart Jupyter n
 
 ## Documentation
 
-Learn more about PyFuga at the **[official documentation](https://topfarm.pages.windenergy.dtu.dk/PyFuga/main/index.html)**.
+Learn more about PyFuga at the **[official documentation](https://topfarm.pages.windenergy.dtu.dk/PyFuga)**.
 
 ## Release history
 
@@ -52,7 +51,19 @@ Issues and feature requests can be submitted through the project's [**GitLab iss
 
 ## Citing PyFuga
 
-Please cite both the underlying Fuga theory and the PyFuga software implementation. See the "Citing PyFuga" section in the documentation for recommended references and BibTeX entries.
+Please cite both the underlying Fuga theory and the PyFuga software implementation.
+
+For PyFuga itself, **use the DOI on the Zenodo record for the release version you used** (this is the canonical source of truth). The repository `CITATION.cff` mirrors this metadata for convenience.
+
+The badge above points to the latest release DOI. For scientific citation, always use the DOI for the exact release version used in your work.
+
+If you have PyFuga installed, you can print a Zenodo search link for your installed version:
+
+```bash
+python scripts/citation.py
+```
+
+See the "Citing PyFuga" section in the documentation for recommended references and BibTeX entries.
 
 ## Authors and acknowledgements
 

{pyfuga-0.2.0 → pyfuga-0.4.0}/pyfuga/__init__.py

@@ -1,6 +1,7 @@
 import functools
 import inspect
 from importlib.metadata import PackageNotFoundError, version
+from typing import Any
 
 from . import _fuga
 
@@ -13,20 +14,20 @@ __all__ = ["get_luts", "get_fluts", "get_preluts", "__version__"]
 
 
 @functools.wraps(_fuga.get_luts)
-def get_luts(*args, **kwargs):
+def get_luts(*args: Any, **kwargs: Any) -> Any:
     return _fuga.get_luts(*args, **kwargs)
 
 
 @functools.wraps(_fuga.get_fluts)
-def get_fluts(*args, **kwargs):
+def get_fluts(*args: Any, **kwargs: Any) -> Any:
     return _fuga.get_fluts(*args, **kwargs)
 
 
 @functools.wraps(_fuga.get_preluts)
-def get_preluts(*args, **kwargs):
+def get_preluts(*args: Any, **kwargs: Any) -> Any:
     return _fuga.get_preluts(*args, **kwargs)
 
 
-get_luts.__signature__ = inspect.signature(_fuga.get_luts)
-get_fluts.__signature__ = inspect.signature(_fuga.get_fluts)
-get_preluts.__signature__ = inspect.signature(_fuga.get_preluts)
+get_luts.__signature__ = inspect.signature(_fuga.get_luts)  # type: ignore[attr-defined]
+get_fluts.__signature__ = inspect.signature(_fuga.get_fluts)  # type: ignore[attr-defined]
+get_preluts.__signature__ = inspect.signature(_fuga.get_preluts)  # type: ignore[attr-defined]

{pyfuga-0.2.0 → pyfuga-0.4.0}/pyfuga/_fuga.py

@@ -27,28 +27,29 @@ from pyfuga.flut import FourierLUTGenerator
 from pyfuga.paths import get_fluts_path, get_level_range, get_luts_path, get_preluts_path
 from pyfuga.preluts import PreLUTs
 from pyfuga.trafalgar import Trafalgar
-from pyfuga.utils import ComplexXRDataset, get_beta_lst, get_kz0_lst
+from pyfuga.utils import ComplexXRDataset, NCpuStageConfig, get_beta_lst, get_kz0_lst
 
 
 def get_luts(
-    folder,
-    zeta0,
-    nkz0,
-    nbeta,
-    diameter,
-    zhub,
-    z0,
-    zi,
-    zlow,
-    zhigh,
-    lut_vars=UVW_LT,
-    nx=2048,
-    ny=512,
-    dx=None,
-    dy=None,
-    jit=True,
-    n_cpu=1,
-):  # pragma: no cover
+    folder: str | Path,
+    zeta0: float,
+    nkz0: int,
+    nbeta: int,
+    diameter: float,
+    zhub: float,
+    z0: float,
+    zi: float,
+    zlow: float,
+    zhigh: float,
+    lut_vars: list[str] = UVW_LT,
+    nx: int = 2048,
+    ny: int = 512,
+    dx: float | None = None,
+    dy: float | None = None,
+    jit: bool = True,
+    n_cpu: int | None = None,
+    n_cpu_stage: NCpuStageConfig | None = None,
+) -> xr.Dataset:  # pragma: no cover
     """Generate physical-space wake look-up tables via the full PyFuga pipeline.
 
     This function orchestrates the three-stage PyFuga pipeline:
@@ -97,7 +98,17 @@ def get_luts(
     jit : bool, optional
         Enable JIT compilation (Numba). Default is True.
     n_cpu : int or None, optional
-        CPU cores for parallel computation. None uses all; 1 disables parallelisation.
+        Optional global worker-count override. If ``None`` (default), stage-aware
+        defaults are used and all stages run on all CPUs. If an integer is provided, that
+        worker count is applied to all stages unless overridden by
+        ``n_cpu_stage``. Large ``nx``/``ny`` and multiple workers can increase
+        memory use substantially.
+    n_cpu_stage : dict, optional
+        Optional per-stage overrides for worker counts. Supported keys are
+        ``"preluts"``, ``"fluts"``, and ``"trafalgar"``. Provided keys override
+        the resolved default/global setting for that stage. Precedence is:
+        defaults -> global ``n_cpu`` (if provided) -> ``n_cpu_stage`` keys.
+        A stage value may be ``None`` meaning all CPUs for that stage only.
 
     Returns
     -------
@@ -112,73 +123,100 @@ def get_luts(
     """
     folder = Path(folder)
     folder.mkdir(parents=True, exist_ok=True)
+    resolved_n_cpu = utils.resolve_n_cpu_stage(n_cpu, n_cpu_stage)
     dx = dx or diameter / 4
     dy = dy or diameter / 16
 
     luts_path = get_luts_path(folder, zeta0, nkz0, nbeta, diameter, zhub, z0, zi, zlow, zhigh, lut_vars, nx, ny, dx, dy)
     if luts_path.exists():
         luts = xr.load_dataset(luts_path)
-        luts.attrs["name"] = luts_path.stem
-        return luts
-
-    fluts = get_fluts(folder, zeta0, nkz0, nbeta, diameter, zhub, z0, zi, zlow, zhigh, lut_vars, jit, n_cpu)
-    luts = Trafalgar(fluts, nx, ny, dx, dy).make_luts(3)
+        if utils.load_lut_if_current(luts, luts_path):
+            luts.attrs["name"] = luts_path.stem
+            return luts
+
+    fluts = get_fluts(
+        folder,
+        zeta0,
+        nkz0,
+        nbeta,
+        diameter,
+        zhub,
+        z0,
+        zi,
+        zlow,
+        zhigh,
+        lut_vars,
+        jit,
+        resolved_n_cpu["fluts"],
+        n_cpu_stage={"preluts": resolved_n_cpu["preluts"]},
+    )
+    luts = Trafalgar(fluts, nx, ny, dx, dy).make_luts(interpolation_order=3, n_cpu=resolved_n_cpu["trafalgar"])
+    utils.stamp_lut_metadata(luts)
     luts.to_netcdf(luts_path)
     luts.attrs["name"] = luts_path.stem
     return luts
 
 
 def get_fluts(
-    folder,
-    zeta0,
-    nkz0,
-    nbeta,
-    diameter,
-    zhub,
-    z0,
-    zi,
-    zlow,
-    zhigh,
-    lut_vars=UVW_LT,
-    jit=True,
-    n_cpu=1,
-):  # pragma: no cover
+    folder: str | Path,
+    zeta0: float,
+    nkz0: int,
+    nbeta: int,
+    diameter: float,
+    zhub: float,
+    z0: float,
+    zi: float,
+    zlow: float,
+    zhigh: float,
+    lut_vars: list[str] = UVW_LT,
+    jit: bool = True,
+    n_cpu: int | None = None,
+    n_cpu_stage: NCpuStageConfig | None = None,
+) -> ComplexXRDataset:  # pragma: no cover
     folder = Path(folder)
     folder.mkdir(parents=True, exist_ok=True)
+    resolved_n_cpu = utils.resolve_n_cpu_stage(n_cpu, n_cpu_stage)
 
     fluts_path = get_fluts_path(folder, zeta0, nkz0, nbeta, diameter, zhub, z0, zi, zlow, zhigh, lut_vars)
     if fluts_path.exists():
-        return ComplexXRDataset.from_netcdf(fluts_path)
+        fluts = ComplexXRDataset.from_netcdf(fluts_path)
+        if utils.load_lut_if_current(fluts, fluts_path):
+            return fluts
 
     utils.compile(jit)
-    preluts = get_preluts(folder, zeta0, nkz0, nbeta, jit, n_cpu)
+    preluts = get_preluts(folder, zeta0, nkz0, nbeta, jit, resolved_n_cpu["preluts"], None)
 
     low_level_out, high_level_out = get_level_range(zlow, zhigh, zhub, z0)
 
     flut_generator = FourierLUTGenerator(preluts, zhub, diameter, zi)
     if low_level_out == high_level_out == 9999:
-        fluts = flut_generator.make_hubheight_luts(z0, lut_vars, n_cpu=n_cpu)
+        fluts = flut_generator.make_hubheight_luts(z0, lut_vars, n_cpu=resolved_n_cpu["fluts"])
     else:
-        fluts = flut_generator.make_lut(z0, low_level_out, high_level_out, lut_vars, n_cpu=n_cpu)
+        fluts = flut_generator.make_lut(z0, low_level_out, high_level_out, lut_vars, n_cpu=resolved_n_cpu["fluts"])
 
+    utils.stamp_lut_metadata(fluts)
     fluts.save(fluts_path)
     return fluts
 
 
 def get_preluts(
-    folder,
-    zeta0,
-    nkz0,
-    nbeta,
-    jit=True,
-    n_cpu=1,
-):  # pragma: no cover
+    folder: str | Path,
+    zeta0: float,
+    nkz0: int,
+    nbeta: int,
+    jit: bool = True,
+    n_cpu: int | None = None,
+    n_cpu_stage: NCpuStageConfig | None = None,
+) -> PreLUTs:  # pragma: no cover
     folder = Path(folder)
     folder.mkdir(parents=True, exist_ok=True)
+    resolved_n_cpu = utils.resolve_n_cpu_stage(n_cpu, n_cpu_stage)
 
     preluts_path = get_preluts_path(folder, zeta0, nkz0, nbeta)
     if preluts_path.exists():
-        return PreLUTs.from_netcdf(preluts_path)
+        preluts = PreLUTs.from_netcdf(preluts_path)
+        if utils.load_lut_if_current(preluts, preluts_path):
+            return preluts
 
     utils.compile(jit)
     preluts = PreLUTs.make_preluts(
@@ -189,15 +227,16 @@ def get_preluts(
         ds=DS,
         accgoal=0.0001,
         jit=jit,
-        n_cpu=n_cpu,
+        n_cpu=resolved_n_cpu["preluts"],
     )
     preluts.attrs["nkz0"] = nkz0
     preluts.attrs["nbeta"] = nbeta
+    utils.stamp_lut_metadata(preluts)
     preluts.save(preluts_path)
     return preluts
 
 
-def main():
+def main() -> None:
     if __name__ == "__main__":  # pragma: no cover
         luts = get_luts(
             folder=Path(__file__).parent.parent,

{pyfuga-0.2.0 → pyfuga-0.4.0}/pyfuga/common.py

@@ -16,6 +16,7 @@ Key components:
 """
 
 import numpy as np
+import numpy.typing as npt
 
 from pyfuga.utils import jit
 
@@ -23,7 +24,7 @@ from .constants import CM_STABLE, CM_UNSTABLE
 
 
 @jit("double(double,double)")
-def get_cdivkL(zeta0, kz0):
+def get_cdivkL(zeta0: float, kz0: float) -> float:
     """c/(k*L), c is a stability constant: depending on the stability (0, Cm1, Cm2)"""
     if abs(zeta0) < 1e-10:  # Neutral
         return 0.0
@@ -35,7 +36,7 @@ def get_cdivkL(zeta0, kz0):
 
 
 @jit("double(double,double)")
-def get_phi_inverse(kz, cdivkl):
+def get_phi_inverse(kz: float, cdivkl: float) -> float:
     """
     Inverse of stability function phi_m
     for unstable conditions
@@ -45,7 +46,7 @@ def get_phi_inverse(kz, cdivkl):
 
 
 @jit("double(double,double,double)")
-def get_psi(zeta0, kz, cdivkl):
+def get_psi(zeta0: float, kz: float, cdivkl: float) -> float:
     """Stability function -psi_m"""
     if zeta0 < 0:
         # Unstable: -psi_m=-ln(1/8*(1+phi_m**-2)*(1+phi_m**-1)**2)+2*atan(phi_m**-1)-pi/2
@@ -58,7 +59,7 @@ def get_psi(zeta0, kz, cdivkl):
 
 
 @jit("double(double,double,double)")
-def get_phi(zeta0, kz, cdivkl):
+def get_phi(zeta0: float, kz: float, cdivkl: float) -> float:
     """Stability function phi_m"""
     if zeta0 < 0:  # Unstable: phi_m=(1+Cm1*z/L)**(-1/4)
         return (1.0 + cdivkl * kz) ** (-0.25)
@@ -67,13 +68,18 @@ def get_phi(zeta0, kz, cdivkl):
 
 
 @jit("double[:](complex128[:,:],int32)")
-def complex_norm(arr, axis=0):
+def complex_norm(arr: npt.NDArray[np.complex128], axis: int = 0) -> npt.NDArray[np.float64]:
     """Compute the norm of a complex array along the first axis"""
     return np.sqrt((np.abs(arr) ** 2).sum(0))
 
 
 @jit("double(double,double,complex128[:,:],complex128[:,:])")
-def get_new_h2(h, acc, Yerr, Y):
+def get_new_h2(
+    h: float,
+    acc: float,
+    Yerr: npt.NDArray[np.complex128],
+    Y: npt.NDArray[np.complex128],
+) -> float:
     """Get new step size based on error between integration estimates"""
     err = np.max(complex_norm(Yerr, axis=0) / complex_norm(Y, axis=0))
     return np.maximum(np.minimum(0.9 * h * (acc / err) ** (1 / 3), 4.0e-1), 1.0e-4)

pyfuga-0.4.0/pyfuga/constants.py

@@ -0,0 +1,44 @@
+"""constants.py
+==============
+Global constants for atmospheric stability, numerical algorithms, and data structure sizes.
+
+Key constants:
+    - **Stability (MO)**: CM_STABLE, CM_UNSTABLE for Monin-Obukhov relations
+    - **Numerics**: KAPPA (von Kármán), MAX_NODES (max preLUT nodes),
+      Y_NORM_THRESHOLD (threshold to trigger QR decomposition and substations
+      between nodes)
+    - **Data**: N_EQ (number of differential equations), UVW_LT (variable names)
+    - **Coordinate systems**: COORD_T (log profile), COORD_S (kz)
+"""
+
+# PreLUT constants
+CM_STABLE: float = 5.0  # MO Stability constant in phi_m (stable)
+CM_UNSTABLE: float = -19.0  # MO Stability constant in phi_m (unstable) Hogstrom (1988)
+N_EQ: int = 6  # ! Number of equations
+KAPPA: float = 0.4  # Von Karman constant
+KAPPA_SQUARED: float = 0.16  # Square of kappa
+P_SCALE: int = 1  # Pressure normalisation variable
+MAX_NODES: int = 400
+Y_NORM_THRESHOLD: int = 100  # Max value of Ynorm before a sublevel is made
+
+# LUT constant
+FIRST_Z_OUTPUT: float = 1.0  # First height level in output
+DS: float = 0.05  # Vertical grid spacing in log-height coordinate s = ln(z/z0)
+
+# On-disk LUT cache compatibility version. Cached LUTs (preLUTs/fLUTs/LUTs) whose
+# stored ``lut_format_version`` differs from this value - or which predate versioning
+# entirely (legacy PyFuga caches) - are rejected and regenerated instead of loaded.
+#
+# Bump this for SEMANTIC/NUMERICAL changes to LUT output that keep the same on-disk
+# structure (e.g. a physics bug-fix that changes values). STRUCTURAL changes (added,
+# removed or renamed variables/dimensions) are additionally caught automatically by the
+# ``lut_schema_fingerprint`` attribute and by the schema guard test in
+# ``tests/test_lut_schema.py``, which fails and reminds you to bump this too.
+LUT_FORMAT_VERSION: int = 1
+
+# Other constants
+UVW_LT: list[str] = ["UL", "UT", "VL", "VT", "WL", "WT", "PL", "PT"]
+
+# Coordinate system indicators
+COORD_T: int = 1  # t = u0 * KAPPA
+COORD_S: int = 2  # s = kz

{pyfuga-0.2.0 → pyfuga-0.4.0}/pyfuga/file_readers.py

@@ -10,26 +10,34 @@ with legacy simulation data.
 
 import os
 import struct
+from io import BufferedReader
 from pathlib import Path
+from typing import Any, TypeAlias
 
 import numpy as np
 import xarray as xr
 from numpy import newaxis as na
 
+PathLike: TypeAlias = str | os.PathLike[str]
+PrelutTuple: TypeAlias = tuple[float, float, float, float, float, float]
+PrelutListEntry: TypeAlias = tuple[str, float, float, float, float, float, float]
+
 
 class BinaryReader:
-    def s(self, n):
+    fid: BufferedReader
+
+    def s(self, n: int) -> str:
         return self.fid.read(n).decode().strip()
 
-    def i(self):
-        return struct.unpack("i", self.fid.read(4))[0]
+    def i(self) -> int:
+        return int(struct.unpack("i", self.fid.read(4))[0])
 
-    def d(self):
-        return struct.unpack("d", self.fid.read(8))[0]
+    def d(self) -> float:
+        return float(struct.unpack("d", self.fid.read(8))[0])
 
 
 class Parameters(BinaryReader):
-    def __init__(self, folder):
+    def __init__(self, folder: PathLike) -> None:
         i, d, s = self.i, self.d, self.s
         with open(Path(folder) / "parameters.bin", "rb") as self.fid:
             self.prelutname = s(127)
@@ -50,7 +58,7 @@ class Parameters(BinaryReader):
 
 
 class CaseData(BinaryReader):
-    def __init__(self, folder):
+    def __init__(self, folder: PathLike) -> None:
         i, d, s = self.i, self.d, self.s
 
         with open(Path(folder) / "CaseData.bin", "rb") as self.fid:
@@ -65,31 +73,31 @@ class CaseData(BinaryReader):
             self.closure = i()
 
 
-def eof(fid):
+def eof(fid: BufferedReader) -> int:
     fid.seek(-1, 2)  # go to the file end.
     eof = fid.tell() + 1  # get the end of file location
     fid.seek(0, 0)  # go back to file beginning
     return eof
 
 
-def read_prelut_list(folder, dict=True):
+def read_prelut_list(folder: PathLike, dict: bool = True) -> dict[str, PrelutTuple] | list[PrelutListEntry]:
 
     folder = Path(folder)
     with open(folder / "prelut_list.lst", "rb") as fid:
         fid.seek(18)
         n = 24 if fid.read(6) == b"\x00\x00\x00\x00\x00\x00" else 18
 
-        N = eof(fid) // (n + 48)
+        n_rows = eof(fid) // (n + 48)
 
         # list of filename (18 or 18+6xNull), ds, smaxx, kz0, beta, kzmax, accgoal
         if dict:
-            return {fid.read(n)[:18].decode(): struct.unpack("d" * 6, fid.read(8 * 6)) for _ in range(N)}
+            return {fid.read(n)[:18].decode(): struct.unpack("d" * 6, fid.read(8 * 6)) for _ in range(n_rows)}
 
         else:
-            return [(fid.read(n)[:18].decode(),) + struct.unpack("d" * 6, fid.read(8 * 6)) for _ in range(N)]
+            return [(fid.read(n)[:18].decode(),) + struct.unpack("d" * 6, fid.read(8 * 6)) for _ in range(n_rows)]
 
 
-def read_pre_file(filename):
+def read_pre_file(filename: PathLike) -> dict[str, tuple[list[str], Any]]:
     with open(filename, "rb") as fid:
         d = np.fromfile(fid, float, -1).reshape((-1, 291))
         Yleft, Rleft, Rright, dy = np.moveaxis((d[:, :288:2] + d[:, 1:288:2] * 1j).reshape((-1, 4, 6, 6)), 1, 0)
@@ -112,15 +120,16 @@ def read_pre_file(filename):
     }
 
 
-def read_lut_file(filename, prelut_folder):
+def read_lut_file(filename: PathLike, prelut_folder: PathLike) -> xr.Dataset:
+    filename_path = Path(filename)
     parameters = Parameters(prelut_folder)
-    casedata = CaseData(os.path.dirname(filename))
-    var = os.path.basename(filename)[:2]
-    level = int(filename[-8:-4])
+    casedata = CaseData(filename_path.parent)
+    var = filename_path.name[:2]
+    level = int(filename_path.name[-8:-4])
     z = casedata.zhub if level == 9999 else casedata.z0 * np.exp(casedata.ds * level)
 
-    lut = np.fromfile(filename, complex, -1).reshape((len(parameters.kz0_lst) + 1, len(parameters.beta_lst)))
-    lut = lut[1:].T
+    raw = np.fromfile(filename, complex, -1).reshape((len(parameters.kz0_lst) + 1, len(parameters.beta_lst)))
+    lut = raw[1:].T
     return xr.Dataset(
         {
             var: (("beta", "kz0", "level"), lut[:, :, na]),
@@ -133,7 +142,7 @@ def read_lut_file(filename, prelut_folder):
     )
 
 
-def read_lut_dat_file(filename, nx, ny, dx, dy):
+def read_lut_dat_file(filename: PathLike, nx: int, ny: int, dx: float, dy: float) -> xr.DataArray:
     dat = np.fromfile(filename, np.dtype("<f"), -1).astype(float).reshape((ny // 2, nx))
     x_lst = np.arange(-nx // 4, nx * 3 / 4) * dx  # rotor is located 1/4 downstream