quantized-lab 0.8.0__py3-none-any.whl

quantized/calc/surface_fit.py

@@ -0,0 +1,290 @@
+"""Bounded 2D least-squares surface fitting. Port of MATLAB ``fitting.surfaceFit``.
+
+Fits a named 2D model (``calc/surface_models``) to scattered ``(x, y, z)`` data.
+The MATLAB original minimises the sum of squared residuals with **fminsearch
+(Nelder-Mead)** over a **bounded → unbounded parameter transform** (the same
+idiosyncratic scheme ``curveFit`` uses), so this port replicates the transform
+and uses scipy's Nelder-Mead rather than delegating to a different bounded
+optimiser. Parameter errors come from the numerical Hessian of the cost at the
+optimum, mapped back through the transform Jacobian.
+
+Pure calc layer — ndarray in -> dict out; no fastapi/pydantic. ``p0`` (initial
+guess) is required here; the MATLAB auto-guess (``surfaceAutoGuess``) is a
+separate, still-to-port file.
+"""
+
+from __future__ import annotations
+
+import sys
+from collections.abc import Sequence
+from typing import Any
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+from scipy.optimize import minimize
+
+from quantized.calc.surface_models import SurfaceModel, get_surface_model
+
+__all__ = ["surface_fit", "surface_auto_guess"]
+
+_EPS = sys.float_info.epsilon
+
+
+def _weighted_centroid(
+    xa: NDArray[np.float64], ya: NDArray[np.float64], za: NDArray[np.float64], z_min: float
+) -> tuple[float, float]:
+    """Intensity-weighted (x, y) centre (weights = z - z_min, clamped >= 0)."""
+    wts = np.maximum(za - z_min, 0.0)
+    w_sum = max(float(np.sum(wts)), _EPS)
+    return float(np.sum(wts * xa) / w_sum), float(np.sum(wts * ya) / w_sum)
+
+
+def surface_auto_guess(
+    model: str | SurfaceModel,
+    x: ArrayLike,
+    y: ArrayLike,
+    z: ArrayLike,
+) -> NDArray[np.float64]:
+    """Heuristic initial parameter guess for a 2D model. Port of
+    ``fitting.surfaceAutoGuess``: linear models solve normal equations; peak
+    models use ``z``-range amplitude, an intensity-weighted centroid, and
+    range/4 widths."""
+    mdl = get_surface_model(model) if isinstance(model, str) else model
+    xa = np.asarray(x, dtype=float).ravel()
+    ya = np.asarray(y, dtype=float).ravel()
+    za = np.asarray(z, dtype=float).ravel()
+    n = za.size
+
+    x_rng = max(float(xa.max() - xa.min()), _EPS)
+    y_rng = max(float(ya.max() - ya.min()), _EPS)
+    z_min = float(za.min())
+    z_rng = max(float(za.max() - z_min), _EPS)
+    z_mean = float(za.mean())
+
+    name = mdl.name
+    if name == "Plane":
+        amat = np.column_stack([xa, ya, np.ones(n)])
+        return _lstsq_or(amat, za, [0.0, 0.0, z_mean])
+    if name == "Paraboloid":
+        amat = np.column_stack([xa**2, ya**2, xa * ya, xa, ya, np.ones(n)])
+        return _lstsq_or(amat, za, [0.0, 0.0, 0.0, 0.0, 0.0, z_mean])
+    if name == "Polynomial 2D":
+        amat = np.column_stack([np.ones(n), xa, ya, xa**2, xa * ya, ya**2])
+        return _lstsq_or(amat, za, [z_mean, 0.0, 0.0, 0.0, 0.0, 0.0])
+    if name in ("2D Gaussian", "2D Lorentzian", "2D Pseudo-Voigt"):
+        amp = float(za.max()) - z_min
+        x0, y0 = _weighted_centroid(xa, ya, za, z_min)
+        guess = [amp, x0, x_rng / 4, y0, y_rng / 4, z_min]
+        if name == "2D Pseudo-Voigt":
+            guess.append(0.5)  # eta
+        return np.asarray(guess, dtype=float)
+    if name == "Exponential Decay 2D":
+        return np.asarray([z_rng, x_rng / 3, y_rng / 3, z_min], dtype=float)
+
+    # Generic fallback for any other model.
+    out = np.ones(mdl.n_params, dtype=float)
+    defaults = [z_rng, (float(xa.min()) + float(xa.max())) / 2, x_rng / 4,
+                (float(ya.min()) + float(ya.max())) / 2, y_rng / 4, z_min]
+    for i, val in enumerate(defaults[: mdl.n_params]):
+        out[i] = val
+    return out
+
+
+def _lstsq_or(
+    amat: NDArray[np.float64], z: NDArray[np.float64], fallback: list[float]
+) -> NDArray[np.float64]:
+    """Least-squares solve (MATLAB ``A \\ z``), falling back on a singular system."""
+    try:
+        coeffs, *_ = np.linalg.lstsq(amat, z, rcond=None)
+        return np.asarray(coeffs, dtype=float).ravel()
+    except np.linalg.LinAlgError:
+        return np.asarray(fallback, dtype=float)
+
+
+def _bound_to_free(pb: float, lo: float, hi: float) -> float:
+    if lo == -np.inf and hi == np.inf:
+        return pb
+    if lo > -np.inf and hi == np.inf:
+        return float(np.log(pb - lo + _EPS))
+    if lo == -np.inf and hi < np.inf:
+        return float(-np.log(hi - pb + _EPS))
+    t = (pb - lo) / (hi - lo)
+    t = max(min(t, 1 - _EPS), _EPS)
+    return float(np.log(t / (1 - t)))
+
+
+def _free_to_bound(pf: float, lo: float, hi: float) -> float:
+    if lo == -np.inf and hi == np.inf:
+        return pf
+    if lo > -np.inf and hi == np.inf:
+        return float(lo + np.exp(pf))
+    if lo == -np.inf and hi < np.inf:
+        return float(hi - np.exp(-pf))
+    return float(lo + (hi - lo) / (1 + np.exp(-pf)))
+
+
+def _bound_jacobian(pf: float, lo: float, hi: float) -> float:
+    if lo == -np.inf and hi == np.inf:
+        return 1.0
+    if lo > -np.inf and hi == np.inf:
+        return float(np.exp(pf))
+    if lo == -np.inf and hi < np.inf:
+        return float(np.exp(-pf))
+    s = 1.0 / (1.0 + np.exp(-pf))
+    return float((hi - lo) * s * (1 - s))
+
+
+def _numerical_hessian(fun: Any, x0: NDArray[np.float64]) -> NDArray[np.float64]:
+    """Central-difference Hessian (matches the MATLAB step ``max(|x|·1e-4, 1e-6)``)."""
+    n = x0.size
+    hess = np.zeros((n, n), dtype=float)
+    f0 = fun(x0)
+    h = np.maximum(np.abs(x0) * 1e-4, 1e-6)
+    for i in range(n):
+        xp = x0.copy()
+        xp[i] += h[i]
+        xm = x0.copy()
+        xm[i] -= h[i]
+        hess[i, i] = (fun(xp) - 2 * f0 + fun(xm)) / h[i] ** 2
+        for j in range(i + 1, n):
+            xpp, xpm, xmp, xmm = x0.copy(), x0.copy(), x0.copy(), x0.copy()
+            xpp[i] += h[i]
+            xpp[j] += h[j]
+            xpm[i] += h[i]
+            xpm[j] -= h[j]
+            xmp[i] -= h[i]
+            xmp[j] += h[j]
+            xmm[i] -= h[i]
+            xmm[j] -= h[j]
+            hess[i, j] = (fun(xpp) - fun(xpm) - fun(xmp) + fun(xmm)) / (4 * h[i] * h[j])
+            hess[j, i] = hess[i, j]
+    return hess
+
+
+def _bounds(
+    bound: Sequence[float] | None, n: int, default: float, name: str
+) -> NDArray[np.float64]:
+    if bound is None:
+        return np.full(n, default, dtype=float)
+    arr = np.asarray(bound, dtype=float)
+    if arr.size != n:
+        raise ValueError(f"{name} must have {n} elements, got {arr.size}")
+    return arr
+
+
+def surface_fit(
+    x: ArrayLike,
+    y: ArrayLike,
+    z: ArrayLike,
+    model: str | SurfaceModel,
+    *,
+    p0: Sequence[float] | None = None,
+    lower: Sequence[float] | None = None,
+    upper: Sequence[float] | None = None,
+    max_iter: int = 10000,
+) -> dict[str, Any]:
+    """Fit ``model`` to scattered ``(x, y, z)``.
+
+    ``p0`` is the initial guess; when omitted it is derived via
+    :func:`surface_auto_guess`. ``lower``/``upper`` bound each parameter
+    (defaults ``-inf``/``+inf``). Returns a dict with ``params``,
+    ``param_names``, ``errors`` (1-sigma, NaN if the Hessian is singular),
+    ``residuals``, ``z_fit``, ``r2``, ``rmse``, ``chi_sq_red``, ``model_name``,
+    ``n_points``, ``n_free``, ``exit_flag``.
+    """
+    mdl = get_surface_model(model) if isinstance(model, str) else model
+    xa = np.asarray(x, dtype=float).ravel()
+    ya = np.asarray(y, dtype=float).ravel()
+    za = np.asarray(z, dtype=float).ravel()
+    n_pts = za.size
+    n_p = mdl.n_params
+
+    if p0 is None:
+        p0_arr = surface_auto_guess(mdl, xa, ya, za)
+    else:
+        p0_arr = np.asarray(p0, dtype=float).ravel()
+    if p0_arr.size != n_p:
+        raise ValueError(f"p0 must have {n_p} elements for {mdl.name!r}, got {p0_arr.size}")
+    lb = _bounds(lower, n_p, -np.inf, "lower")
+    ub = _bounds(upper, n_p, np.inf, "upper")
+
+    p0_arr = np.clip(p0_arr, lb, ub)
+
+    def to_free(pb: NDArray[np.float64]) -> NDArray[np.float64]:
+        out = np.empty(n_p, dtype=float)
+        for k in range(n_p):
+            out[k] = _bound_to_free(float(pb[k]), float(lb[k]), float(ub[k]))
+        return out
+
+    def from_free(pf: NDArray[np.float64]) -> NDArray[np.float64]:
+        out = np.empty(n_p, dtype=float)
+        for k in range(n_p):
+            out[k] = _free_to_bound(float(pf[k]), float(lb[k]), float(ub[k]))
+        return out
+
+    def cost(p_free: NDArray[np.float64]) -> float:
+        p_full = from_free(p_free)
+        resid = za - mdl.func(p_full, xa, ya).ravel()
+        return float(np.sum(resid**2))
+
+    p_free0 = to_free(p0_arr)
+    res = minimize(
+        cost,
+        p_free0,
+        method="Nelder-Mead",
+        options={"xatol": 1e-10, "fatol": 1e-12, "maxiter": max_iter, "maxfev": max_iter * 2},
+    )
+    p_free_opt = np.asarray(res.x, dtype=float)
+    p_opt = from_free(p_free_opt)
+    z_fit = np.asarray(mdl.func(p_opt, xa, ya).ravel(), dtype=float)
+    residuals = za - z_fit
+
+    ss_res = float(np.sum(residuals**2))
+    ss_tot = float(np.sum((za - za.mean()) ** 2))
+    r2 = 1 - ss_res / max(ss_tot, _EPS)
+    dof = n_pts - n_p
+    chi_sq_red = ss_res / max(dof, 1)
+    rmse = float(np.sqrt(ss_res / n_pts))
+
+    errors = _param_errors(cost, p_free_opt, lb, ub, dof, chi_sq_red, n_p)
+
+    return {
+        "params": p_opt,
+        "param_names": list(mdl.param_names),
+        "errors": errors,
+        "residuals": residuals,
+        "z_fit": z_fit,
+        "r2": r2,
+        "rmse": rmse,
+        "chi_sq_red": chi_sq_red,
+        "model_name": mdl.name,
+        "n_points": int(n_pts),
+        "n_free": int(n_p),
+        "exit_flag": 1 if res.success else 0,
+    }
+
+
+def _param_errors(
+    cost: Any,
+    p_free_opt: NDArray[np.float64],
+    lb: NDArray[np.float64],
+    ub: NDArray[np.float64],
+    dof: int,
+    chi_sq_red: float,
+    n_p: int,
+) -> NDArray[np.float64]:
+    """1-sigma errors via the numerical Hessian, mapped through the transform Jacobian."""
+    errors = np.full(n_p, np.nan, dtype=float)
+    if dof <= 0:
+        return errors
+    hess = _numerical_hessian(cost, p_free_opt)
+    try:
+        cov_free = np.linalg.inv(hess / 2) * chi_sq_red
+    except np.linalg.LinAlgError:
+        return errors
+    diag = np.diag(cov_free)
+    if np.all(diag >= 0):
+        se_free = np.sqrt(diag)
+        for k in range(n_p):
+            errors[k] = se_free[k] * abs(_bound_jacobian(p_free_opt[k], lb[k], ub[k]))
+    return errors

quantized/calc/surface_models.py

@@ -0,0 +1,156 @@
+"""2D surface model library. Port of MATLAB ``fitting.surfaceModels``.
+
+A registry of named ``z = f(p, x, y)`` surface models (the 2D analogue of
+``calc/peakshapes``) used by 2D surface fitting and RSM peak extraction. Each
+model carries its parameter names and a human-readable equation. Widths/sigmas
+are floored at machine epsilon (matching MATLAB's ``max(p, eps)``) so a
+degenerate fit never divides by zero.
+
+Pure calc layer — ndarray in -> ndarray out; no fastapi/pydantic.
+"""
+
+from __future__ import annotations
+
+import sys
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+__all__ = ["SurfaceModel", "surface_models", "get_surface_model"]
+
+_EPS = sys.float_info.epsilon
+
+_Arr = NDArray[np.float64]
+# Parameter vector: a plain sequence or a numpy array (both index the same way).
+PVec = Sequence[float] | _Arr
+SurfaceFunc = Callable[[PVec, _Arr, _Arr], _Arr]
+
+
+@dataclass(frozen=True, slots=True)
+class SurfaceModel:
+    name: str
+    func: SurfaceFunc
+    param_names: tuple[str, ...]
+    description: str
+
+    @property
+    def n_params(self) -> int:
+        return len(self.param_names)
+
+
+def _xy(x: ArrayLike, y: ArrayLike) -> tuple[_Arr, _Arr]:
+    return np.asarray(x, dtype=float), np.asarray(y, dtype=float)
+
+
+def _plane(p: PVec, x: _Arr, y: _Arr) -> _Arr:
+    return np.asarray(p[0] * x + p[1] * y + p[2], dtype=float)
+
+
+def _paraboloid(p: PVec, x: _Arr, y: _Arr) -> _Arr:
+    return np.asarray(
+        p[0] * x**2 + p[1] * y**2 + p[2] * x * y + p[3] * x + p[4] * y + p[5], dtype=float
+    )
+
+
+def _gaussian2d(p: PVec, x: _Arr, y: _Arr) -> _Arr:
+    sx = max(p[2], _EPS)
+    sy = max(p[4], _EPS)
+    z = p[0] * np.exp(-((x - p[1]) ** 2 / (2 * sx**2) + (y - p[3]) ** 2 / (2 * sy**2))) + p[5]
+    return np.asarray(z, dtype=float)
+
+
+def _lorentzian2d(p: PVec, x: _Arr, y: _Arr) -> _Arr:
+    wx = max(p[2], _EPS)
+    wy = max(p[4], _EPS)
+    z = p[0] / (1 + ((x - p[1]) / wx) ** 2 + ((y - p[3]) / wy) ** 2) + p[5]
+    return np.asarray(z, dtype=float)
+
+
+def _pseudo_voigt2d(p: PVec, x: _Arr, y: _Arr) -> _Arr:
+    amp, x0, y0, z0 = p[0], p[1], p[3], p[5]
+    wx = max(p[2], _EPS)
+    wy = max(p[4], _EPS)
+    eta = max(min(p[6], 1.0), 0.0)  # clamp to [0, 1]
+    gauss = amp * np.exp(-((x - x0) ** 2 / (2 * wx**2) + (y - y0) ** 2 / (2 * wy**2)))
+    loren = amp / (1 + ((x - x0) / wx) ** 2 + ((y - y0) / wy) ** 2)
+    return np.asarray(eta * loren + (1 - eta) * gauss + z0, dtype=float)
+
+
+def _poly2d(p: PVec, x: _Arr, y: _Arr) -> _Arr:
+    return np.asarray(
+        p[0] + p[1] * x + p[2] * y + p[3] * x**2 + p[4] * x * y + p[5] * y**2, dtype=float
+    )
+
+
+def _exp_decay2d(p: PVec, x: _Arr, y: _Arr) -> _Arr:
+    tx = max(p[1], _EPS)
+    ty = max(p[2], _EPS)
+    return np.asarray(p[0] * np.exp(-x / tx - y / ty) + p[3], dtype=float)
+
+
+# Wrap each kernel so callers may pass any array-like x/y (matches MATLAB's
+# element-wise handles) and always receive float64 ndarrays.
+def _wrap(fn: SurfaceFunc) -> SurfaceFunc:
+    def wrapped(p: PVec, x: ArrayLike, y: ArrayLike) -> NDArray[np.float64]:
+        xa, ya = _xy(x, y)
+        return fn(p, xa, ya)
+
+    return wrapped
+
+
+_CATALOG: tuple[SurfaceModel, ...] = (
+    SurfaceModel("Plane", _wrap(_plane), ("a", "b", "c"), "z = a·x + b·y + c"),
+    SurfaceModel(
+        "Paraboloid",
+        _wrap(_paraboloid),
+        ("a", "b", "c", "d", "e", "f"),
+        "z = a·x² + b·y² + c·xy + d·x + e·y + f",
+    ),
+    SurfaceModel(
+        "2D Gaussian",
+        _wrap(_gaussian2d),
+        ("A", "x0", "sx", "y0", "sy", "z0"),
+        "z = A·exp(-((x-x0)²/(2σx²) + (y-y0)²/(2σy²))) + z0",
+    ),
+    SurfaceModel(
+        "2D Lorentzian",
+        _wrap(_lorentzian2d),
+        ("A", "x0", "wx", "y0", "wy", "z0"),
+        "z = A / (1 + ((x-x0)/wx)² + ((y-y0)/wy)²) + z0",
+    ),
+    SurfaceModel(
+        "2D Pseudo-Voigt",
+        _wrap(_pseudo_voigt2d),
+        ("A", "x0", "wx", "y0", "wy", "z0", "eta"),
+        "z = η·Lorentzian + (1-η)·Gaussian + z0  (0 ≤ η ≤ 1)",
+    ),
+    SurfaceModel(
+        "Polynomial 2D",
+        _wrap(_poly2d),
+        ("a00", "a10", "a01", "a20", "a11", "a02"),
+        "z = a00 + a10·x + a01·y + a20·x² + a11·xy + a02·y²",
+    ),
+    SurfaceModel(
+        "Exponential Decay 2D",
+        _wrap(_exp_decay2d),
+        ("A", "tx", "ty", "z0"),
+        "z = A·exp(-x/τx - y/τy) + z0",
+    ),
+)
+
+_BY_NAME = {m.name: m for m in _CATALOG}
+
+
+def surface_models() -> tuple[SurfaceModel, ...]:
+    """The built-in 2D surface model catalog (in display order)."""
+    return _CATALOG
+
+
+def get_surface_model(name: str) -> SurfaceModel:
+    """Look up a model by display name (e.g. ``"2D Gaussian"``)."""
+    try:
+        return _BY_NAME[name]
+    except KeyError:
+        raise ValueError(f"unknown surface model {name!r}") from None

quantized/calc/thermal.py

@@ -0,0 +1,119 @@
+r"""Thermal-property calculators (DiraCulator ``buildThermalTab``).
+
+Pure calc layer — closed-form scalars in, result dicts out. No fastapi /
+pydantic imports. Ports the three MATLAB ``buildThermalTab`` cards verbatim:
+
+.. math::
+
+    \kappa = L_0\,\sigma\,T \qquad
+    \Theta_D = \frac{\hbar}{k_B}\,v_s\,(6\pi^2 n)^{1/3} \qquad
+    \alpha = \frac{\kappa}{\rho\,c_p}
+
+Units follow the MATLAB toolbox (the behavioural reference): the
+Wiedemann-Franz card takes electrical conductivity σ in S/cm (converted to
+S/m internally) and temperature T in K, returning thermal conductivity κ in
+W/(m·K). The Debye card takes the average sound velocity v_s in m/s and the
+atomic number density n in atoms/m³, returning Θ_D in K. The diffusivity card
+takes κ in W/(m·K), mass density ρ in kg/m³ and specific heat c_p in J/(kg·K),
+returning α in m²/s (and mm²/s).
+
+Reference values (closed-form physics, no MATLAB freeze available):
+  - ``wiedemann_franz(6e5, 300) -> kappa = 439.2`` W/(m·K)  (Cu-like)
+  - ``debye_temperature(5000, 5e28) -> theta_D ≈ 548`` K
+  - ``thermal_diffusivity(150, 2329, 700) -> alpha ≈ 9.2e-5`` m²/s  (Si)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from quantized.calc.constants import constants
+
+__all__ = [
+    "debye_temperature",
+    "thermal_diffusivity",
+    "wiedemann_franz",
+]
+
+# Lorenz number (Sommerfeld value): L0 = pi^2 kB^2 / (3 e^2) = 2.44e-8 W*Ohm/K^2.
+# Calibrated constant copied verbatim from the MATLAB source (do not "fix").
+_LORENZ = 2.44e-8  # W*Ohm/K^2
+
+_S_PER_CM_TO_S_PER_M = 100.0  # 1 S/cm = 100 S/m
+
+
+def wiedemann_franz(sigma: float, temperature: float) -> dict[str, float]:
+    """Electronic thermal conductivity κ = L₀·σ·T (W/(m·K)).
+
+    Wiedemann-Franz law linking electrical and thermal conductivity. The
+    electrical conductivity σ is given in S/cm (Cu ≈ 6e5, Au ≈ 4.5e5,
+    Al ≈ 3.8e5) and converted to S/m internally; T is in K.
+
+    Args:
+        sigma: electrical conductivity (S/cm), ≥ 0.
+        temperature: temperature (K), > 0.
+
+    >>> round(wiedemann_franz(6e5, 300.0)["kappa"], 1)
+    439.2
+    """
+    if sigma < 0:
+        raise ValueError("conductivity sigma must be non-negative")
+    if temperature <= 0:
+        raise ValueError("temperature must be positive")
+    sigma_si = sigma * _S_PER_CM_TO_S_PER_M  # S/cm -> S/m
+    kappa = _LORENZ * sigma_si * temperature  # W/(m*K)
+    return {
+        "kappa": kappa,
+        "sigma": sigma,
+        "temperature": temperature,
+        "lorenz": _LORENZ,
+    }
+
+
+def debye_temperature(v_s: float, n: float) -> dict[str, float]:
+    """Debye temperature Θ_D = (ħ/k_B)·v_s·(6π²·n)^(1/3) (K).
+
+    From an average sound velocity and the atomic number density.
+
+    Args:
+        v_s: average sound velocity (m/s), > 0.
+        n: atomic number density (atoms/m³), > 0.
+
+    >>> round(debye_temperature(5000.0, 5e28)["theta_D"])
+    548
+    """
+    if v_s <= 0:
+        raise ValueError("sound velocity v_s must be positive")
+    if n <= 0:
+        raise ValueError("atom number density n must be positive")
+    consts = constants()
+    hbar = consts["hbar"]
+    k_b = consts["kB"]
+    theta_d = (hbar / k_b) * v_s * (6.0 * 3.141592653589793**2 * n) ** (1.0 / 3.0)
+    return {"theta_D": theta_d, "v_s": v_s, "n": n}
+
+
+def thermal_diffusivity(kappa: float, rho: float, cp: float) -> dict[str, Any]:
+    """Thermal diffusivity α = κ/(ρ·c_p) (m²/s).
+
+    Governs transient heat conduction — smaller α means slower thermal
+    equilibration. Also reports α in mm²/s (α·1e6).
+
+    Args:
+        kappa: thermal conductivity (W/(m·K)), > 0.
+        rho: mass density (kg/m³), > 0.
+        cp: specific heat (J/(kg·K)), > 0.
+
+    >>> round(thermal_diffusivity(150.0, 2329.0, 700.0)["alpha"], 7)
+    9.2e-05
+    """
+    if kappa <= 0 or rho <= 0 or cp <= 0:
+        raise ValueError("kappa, rho and cp must be positive")
+    alpha = kappa / (rho * cp)  # m^2/s
+    return {
+        "alpha": alpha,
+        "alpha_mm2": alpha * 1e6,  # mm^2/s
+        "kappa": kappa,
+        "rho": rho,
+        "cp": cp,
+    }