scripts/benchmark_comparison.py

#!/usr/bin/env python3
"""
Benchmark comparison of PIV results against JHTDB ground truth.

Compares:
- Mean velocity profile U+ vs y+
- Reynolds normal stresses uu+, vv+ vs y+
- Reynolds shear stress uv+ vs y+

Excludes first/last 5mm in x-direction (out-of-plane particle loss).
"""

import numpy as np
import scipy.io as sio
from scipy.interpolate import interp1d
import matplotlib.pyplot as plt
import matplotlib as mpl
from pathlib import Path

# Use LaTeX-style fonts everywhere (Computer Modern via mathtext — no LaTeX install needed)
mpl.rcParams.update({
    'font.family': 'serif',
    'font.serif': ['CMU Serif', 'Computer Modern Roman', 'DejaVu Serif'],
    'mathtext.fontset': 'cm',
    'axes.unicode_minus': False,
    'text.usetex': False,
})


def log_smooth(y_plus, values, sigma_decades=0.06):
    """LOWESS-style smooth in log(y+) space, evaluated at original points.

    Each output point is a locally-weighted LINEAR regression of neighbours,
    where distance is measured in decades of y+. Using local linear fits
    instead of local averages gives:
      - Better peak tracking (local slope captures gradients)
      - Better edge behaviour (linear extrapolation, not mean bias)

    Parameters
    ----------
    y_plus : array
        y+ coordinates (positive)
    values : array
        Values to smooth
    sigma_decades : float
        Smoothing width in decades of y+ (0.06 ~ +/-15% local y+)

    Returns
    -------
    y_out, smoothed : arrays
        Sorted y+ and smoothed values (at original data points)
    """
    valid = (y_plus > 0) & ~np.isnan(values)
    yp = y_plus[valid]
    vals = values[valid]
    if len(yp) < 5:
        return yp, vals

    # Sort by y+
    order = np.argsort(yp)
    yp = yp[order]
    vals = vals[order]
    log_yp = np.log10(yp)

    # Local linear regression (LOWESS) at each point
    smoothed = np.empty_like(vals)
    for i in range(len(vals)):
        d = (log_yp - log_yp[i]) / sigma_decades
        w = np.exp(-0.5 * d * d)
        wsum = np.sum(w)
        wmean_x = np.sum(w * log_yp) / wsum
        wmean_y = np.sum(w * vals) / wsum
        dx = log_yp - wmean_x
        denom = np.sum(w * dx * dx)
        if denom > 1e-30:
            slope = np.sum(w * dx * vals) / denom
            smoothed[i] = wmean_y + slope * (log_yp[i] - wmean_x)
        else:
            smoothed[i] = wmean_y

    return yp, smoothed


def plot_ci_band(ax, y_plus, ci_lo, ci_hi, sign=1, color='k', alpha=0.3, zorder=1):
    """Plot a 95% CI shaded band around a reference line.

    Parameters
    ----------
    ax : matplotlib Axes
    y_plus : array
        x-axis values (y+ coordinates)
    ci_lo, ci_hi : array
        Lower/upper CI bounds (same units as the plotted variable)
    sign : int
        1 or -1 (for variables like -uv+ that flip sign)
    color : str
        Fill color
    alpha : float
        Fill transparency
    zorder : int
        Drawing order
    """
    lo = sign * ci_lo if sign == 1 else sign * ci_hi  # sign flip swaps lo/hi
    hi = sign * ci_hi if sign == 1 else sign * ci_lo
    ax.fill_between(y_plus, lo, hi, color=color, alpha=alpha, zorder=zorder,
                    linewidth=0)
    # Add thin edge lines so the CI is visible even when narrow
    ax.plot(y_plus, lo, color=color, linewidth=0.5, alpha=0.4, zorder=zorder)
    ax.plot(y_plus, hi, color=color, linewidth=0.5, alpha=0.4, zorder=zorder)


def load_wall_units(wall_units_path):
    """Load wall units from .mat file (scipy v5 or h5py v7.3).

    Supports three formats:
    - wall_units.mat with 'wall_units' struct
    - diagnostics.mat with 'diagnostics' group (HDF5)
    - direct_stats.mat with top-level u_tau, delta_nu, Re_tau keys
    """
    try:
        wall = sio.loadmat(wall_units_path, squeeze_me=True, struct_as_record=False)

        # Format: direct_stats.mat (top-level scalar keys)
        if 'u_tau' in wall and 'delta_nu' in wall and 'Re_tau' in wall:
            u_tau = float(wall['u_tau'])
            delta_nu = float(wall['delta_nu'])
            Re_tau = float(wall['Re_tau'])
            return {
                'u_tau': u_tau,
                'nu': u_tau * delta_nu,
                'delta_nu': delta_nu,
                'h_mm': float(wall['h_mm']) if 'h_mm' in wall else Re_tau * delta_nu,
                'Re_tau': Re_tau,
            }

        # Format: wall_units.mat (struct)
        wu = wall['wall_units']
        return {
            'u_tau': float(wu.u_tau),  # mm/s
            'nu': float(wu.nu),        # mm^2/s
            'delta_nu': float(wu.delta_nu),  # mm
            'h_mm': float(wu.h_mm),    # mm
            'Re_tau': float(wu.Re_tau)
        }
    except NotImplementedError:
        # MATLAB v7.3 (HDF5) format - use h5py
        import h5py
        with h5py.File(str(wall_units_path), 'r') as f:
            if 'wall_units' in f:
                grp = f['wall_units']
                result = {
                    'u_tau': float(np.array(grp['u_tau']).flat[0]),
                    'delta_nu': float(np.array(grp['delta_nu']).flat[0]),
                    'Re_tau': float(np.array(grp['Re_tau']).flat[0]),
                }
                if 'nu' in grp:
                    result['nu'] = float(np.array(grp['nu']).flat[0])
                else:
                    result['nu'] = result['u_tau'] * result['delta_nu']
                if 'h_mm' in grp:
                    result['h_mm'] = float(np.array(grp['h_mm']).flat[0])
                else:
                    result['h_mm'] = result['Re_tau'] * result['delta_nu']
                return result
            elif 'diagnostics' in f:
                grp = f['diagnostics']
                result = {
                    'u_tau': float(np.array(grp['u_tau']).flat[0]),
                    'delta_nu': float(np.array(grp['delta_nu']).flat[0]),
                    'Re_tau': float(np.array(grp['Re_tau']).flat[0]),
                }
                if 'nu' in grp:
                    result['nu'] = float(np.array(grp['nu']).flat[0])
                else:
                    result['nu'] = result['u_tau'] * result['delta_nu']
                if 'h_mm' in grp:
                    result['h_mm'] = float(np.array(grp['h_mm']).flat[0])
                else:
                    result['h_mm'] = result['Re_tau'] * result['delta_nu']
                return result
            else:
                raise ValueError(f"No 'wall_units' or 'diagnostics' group in {wall_units_path}")


def load_ground_truth(profiles_path, wall_units_path=None):
    """Load ground truth profiles (scipy v5 or h5py v7.3).

    Supports three formats:
    - profiles.mat with 'profiles.win_1px' struct
    - ensemble_statistics_full.mat with 'ref_profile' + 'ensemble_stats' (HDF5)
    - direct_stats.mat with top-level y_plus, U_plus, stress_plus arrays
    """
    try:
        profiles = sio.loadmat(profiles_path, squeeze_me=True, struct_as_record=False)

        # Format: direct_stats.mat (top-level arrays)
        if 'U_plus' in profiles and 'stress_plus' in profiles and 'y_plus' in profiles:
            y_plus_full = profiles['y_plus']
            Re_tau = float(profiles['Re_tau'])
            u_tau = float(profiles['u_tau'])
            delta_nu = float(profiles['delta_nu'])
            u_tau2 = u_tau ** 2

            # Select lower half of channel (y+ <= Re_tau)
            mask = y_plus_full <= Re_tau
            y_plus = y_plus_full[mask]
            y_mm = y_plus * delta_nu

            # U_plus: (N, 3) -> columns [U, V, W]
            U_plus = profiles['U_plus'][mask, 0]
            V_plus = profiles['U_plus'][mask, 1]

            # stress_plus: (N, 3, 3) -> Reynolds stress tensor in plus units
            uu_plus = profiles['stress_plus'][mask, 0, 0]
            vv_plus = profiles['stress_plus'][mask, 1, 1]
            ww_plus = profiles['stress_plus'][mask, 2, 2]
            uv_plus = profiles['stress_plus'][mask, 0, 1]

            result = {
                'y_mm': y_mm,
                'y_plus': y_plus,
                'U': U_plus * u_tau,      # mm/s
                'V': V_plus * u_tau,      # mm/s
                'uu': uu_plus * u_tau2,   # (mm/s)^2
                'vv': vv_plus * u_tau2,   # (mm/s)^2
                'ww': ww_plus * u_tau2,   # (mm/s)^2
                'uv': uv_plus * u_tau2,   # (mm/s)^2
                'U_plus': U_plus,
                'uu_plus': uu_plus,
                'vv_plus': vv_plus,
                'ww_plus': ww_plus,
                'uv_plus': uv_plus,
            }

            # Load 95% confidence intervals if available
            if 'stress_ci_lo' in profiles and 'stress_ci_hi' in profiles:
                result['uu_plus_ci_lo'] = profiles['stress_ci_lo'][mask, 0, 0]
                result['uu_plus_ci_hi'] = profiles['stress_ci_hi'][mask, 0, 0]
                result['vv_plus_ci_lo'] = profiles['stress_ci_lo'][mask, 1, 1]
                result['vv_plus_ci_hi'] = profiles['stress_ci_hi'][mask, 1, 1]
                result['ww_plus_ci_lo'] = profiles['stress_ci_lo'][mask, 2, 2]
                result['ww_plus_ci_hi'] = profiles['stress_ci_hi'][mask, 2, 2]
                result['uv_plus_ci_lo'] = profiles['stress_ci_lo'][mask, 0, 1]
                result['uv_plus_ci_hi'] = profiles['stress_ci_hi'][mask, 0, 1]
            if 'umean_ci_lo' in profiles and 'umean_ci_hi' in profiles:
                result['U_plus_ci_lo'] = profiles['umean_ci_lo'][mask, 0]
                result['U_plus_ci_hi'] = profiles['umean_ci_hi'][mask, 0]
                result['V_plus_ci_lo'] = profiles['umean_ci_lo'][mask, 1]
                result['V_plus_ci_hi'] = profiles['umean_ci_hi'][mask, 1]

            return result

        # Format: profiles.mat (struct)
        win1px = profiles['profiles'].win_1px
        return {
            'y_mm': win1px.y_mm,
            'y_plus': win1px.y_plus,
            'U': win1px.U,           # mm/s
            'V': win1px.V,           # mm/s
            'uu': win1px.uu,         # (mm/s)^2
            'vv': win1px.vv,         # (mm/s)^2
            'uv': win1px.uv,         # (mm/s)^2
            'U_plus': win1px.U_plus,
            'uu_plus': win1px.uu_plus,
            'vv_plus': win1px.vv_plus,
            'uv_plus': win1px.uv_plus,
        }
    except NotImplementedError:
        # MATLAB v7.3 (HDF5) format
        import h5py

        # Load wall units for normalisation
        if wall_units_path is not None:
            wu = load_wall_units(wall_units_path)
        else:
            wu_path = Path(profiles_path).parent / 'diagnostics.mat'
            if wu_path.exists():
                wu = load_wall_units(wu_path)
            else:
                raise ValueError("Need wall_units_path to normalise HDF5 ground truth")

        u_tau = wu['u_tau']
        u_tau2 = u_tau ** 2
        delta_nu = wu['delta_nu']

        with h5py.File(str(profiles_path), 'r') as f:
            ref = f['ref_profile']

            # Check if ref_profile has stress data directly
            if 'uu' in ref:
                y_mm = np.array(ref['y_mm']).flatten()
                U = np.array(ref['U']).flatten()
                V = np.array(ref['V']).flatten()
                uu = np.array(ref['uu']).flatten()
                vv = np.array(ref['vv']).flatten()
                uv = np.array(ref['uv']).flatten()
                y_plus = y_mm / delta_nu
                return {
                    'y_mm': y_mm, 'y_plus': y_plus,
                    'U': U, 'V': V, 'uu': uu, 'vv': vv, 'uv': uv,
                    'U_plus': U / u_tau, 'uu_plus': uu / u_tau2,
                    'vv_plus': vv / u_tau2, 'uv_plus': uv / u_tau2,
                }

            # Use ensemble_stats profiles (pre-averaged, consistent y_plus)
            if 'ensemble_stats' not in f:
                raise ValueError("No stress data in ref_profile and no ensemble_stats")

            es = f['ensemble_stats']
            # Use finest window (index 0) as reference
            win_idx = 0

            def _deref(field, idx=win_idx):
                refs = np.array(es[field]).flatten()
                return np.array(f[refs[idx]]).flatten()

            # Ensemble stats y_plus (255 points for 16x16 window)
            es_y_plus = _deref('y_plus')
            es_y_mm = es_y_plus * delta_nu

            # Stresses are already in plus units
            uu_plus = _deref('uu_plus')
            vv_plus = _deref('vv_plus')
            uv_plus = _deref('uv_plus')

            # Velocity: interpolate DNS onto ensemble y_plus grid
            dns_y_mm = np.array(ref['y_mm']).flatten()
            dns_U = np.array(ref['U']).flatten()
            dns_V = np.array(ref['V']).flatten()
            dns_y_plus = dns_y_mm / delta_nu

            U_interp = interp1d(dns_y_plus, dns_U, kind='linear',
                                bounds_error=False, fill_value=np.nan)(es_y_plus)
            V_interp = interp1d(dns_y_plus, dns_V, kind='linear',
                                bounds_error=False, fill_value=np.nan)(es_y_plus)

        return {
            'y_mm': es_y_mm,
            'y_plus': es_y_plus,
            'U': U_interp,
            'V': V_interp,
            'uu': uu_plus * u_tau2,
            'vv': vv_plus * u_tau2,
            'uv': uv_plus * u_tau2,
            'U_plus': U_interp / u_tau,
            'uu_plus': uu_plus,
            'vv_plus': vv_plus,
            'uv_plus': uv_plus,
        }


def load_piv_statistics(stats_path, run_idx=3):
    """
    Load PIV statistics from mean_stats.mat (instantaneous).

    Parameters
    ----------
    stats_path : Path
        Path to mean_stats.mat
    run_idx : int
        Run index (0-based). run_idx=3 corresponds to run 4 (16x16 window)
    """
    stats = sio.loadmat(stats_path, squeeze_me=True, struct_as_record=False)
    piv = stats['piv_result'][run_idx]
    coords = stats['coordinates'][run_idx]

    return {
        'ux': piv.ux,    # m/s (need to convert to mm/s)
        'uy': piv.uy,    # m/s
        'uu': piv.uu,    # (m/s)^2
        'vv': piv.vv,    # (m/s)^2
        'uv': piv.uv,    # (m/s)^2
        'x': coords.x,   # mm
        'y': coords.y,   # mm
    }


def load_ensemble_statistics(ensemble_path, coords_path, run_idx=3):
    """
    Load PIV statistics from ensemble_result.mat.

    Parameters
    ----------
    ensemble_path : Path
        Path to ensemble_result.mat
    coords_path : Path
        Path to coordinates.mat
    run_idx : int
        Run index (0-based). run_idx=3 corresponds to run 4
    """
    ens = sio.loadmat(ensemble_path, squeeze_me=True, struct_as_record=False)
    coords_data = sio.loadmat(coords_path, squeeze_me=True, struct_as_record=False)

    piv = ens['ensemble_result'][run_idx]
    coords = coords_data['coordinates'][run_idx]

    return {
        'ux': piv.ux,           # m/s
        'uy': piv.uy,           # m/s
        'uu': piv.UU_stress,    # (m/s)^2
        'vv': piv.VV_stress,    # (m/s)^2
        'uv': piv.UV_stress,    # (m/s)^2
        'x': coords.x,          # mm
        'y': coords.y,          # mm
    }


def compute_piv_profiles(piv_data, x_exclude_vectors=4):
    """
    Compute x-averaged PIV profiles, excluding edges.

    Parameters
    ----------
    piv_data : dict
        PIV statistics dictionary (velocities in m/s, stresses in (m/s)^2)
    x_exclude_vectors : int
        Number of vectors to exclude from each side in x-direction

    Returns
    -------
    dict with y_mm, U, uu, vv, uv profiles (in mm/s and (mm/s)^2)
    """
    x = piv_data['x']
    y = piv_data['y']

    # Get unique y values (assuming regular grid)
    y_unique = y[:, 0]
    x_unique = x[0, :]
    nx = len(x_unique)

    # Create mask excluding first/last x_exclude_vectors
    x_mask = np.zeros(nx, dtype=bool)
    x_mask[x_exclude_vectors:nx-x_exclude_vectors] = True

    print(f"  X range: {x_unique.min():.2f} to {x_unique.max():.2f} mm")
    print(f"  Excluding {x_exclude_vectors} vectors from each x-edge")
    print(f"  X points: {x_mask.sum()} / {nx}")

    # Convert velocities from m/s to mm/s
    ux_mm = piv_data['ux'] * 1000  # m/s -> mm/s
    uy_mm = piv_data['uy'] * 1000
    uu_mm2 = piv_data['uu'] * 1e6  # (m/s)^2 -> (mm/s)^2
    vv_mm2 = piv_data['vv'] * 1e6
    uv_mm2 = piv_data['uv'] * 1e6

    # Average over valid x range
    U_profile = np.nanmean(ux_mm[:, x_mask], axis=1)
    V_profile = np.nanmean(uy_mm[:, x_mask], axis=1)
    uu_profile = np.nanmean(uu_mm2[:, x_mask], axis=1)
    vv_profile = np.nanmean(vv_mm2[:, x_mask], axis=1)
    uv_profile = np.nanmean(uv_mm2[:, x_mask], axis=1)

    return {
        'y_mm': y_unique,
        'U': U_profile,
        'V': V_profile,
        'uu': uu_profile,
        'vv': vv_profile,
        'uv': uv_profile,
    }


def convert_to_wall_units(profiles, wall_units, y_offset_mm=0.0):
    """
    Convert profiles to wall units (plus units).

    Parameters
    ----------
    profiles : dict
        PIV profiles with y_mm, U, etc.
    wall_units : dict
        Wall unit parameters
    y_offset_mm : float
        Offset to add to y_mm before converting to y+ (for coordinate alignment)
    """
    u_tau = wall_units['u_tau']
    delta_nu = wall_units['delta_nu']
    u_tau2 = u_tau ** 2

    # Apply y offset (to align PIV coordinate system with ground truth)
    y_mm_aligned = profiles['y_mm'] + y_offset_mm

    result = {
        'y_mm': y_mm_aligned,
        'y_plus': y_mm_aligned / delta_nu,
        'U_plus': profiles['U'] / u_tau,
        'V_plus': profiles['V'] / u_tau,
        'uu_plus': profiles['uu'] / u_tau2,
        'vv_plus': profiles['vv'] / u_tau2,
        'uv_plus': profiles['uv'] / u_tau2,
    }
    if 'ww' in profiles:
        result['ww_plus'] = profiles['ww'] / u_tau2
    return result


def compute_errors(piv_plus, gt_plus, y_plus_range=(10, 500)):
    """
    Compute error metrics between PIV and ground truth.

    Parameters
    ----------
    piv_plus : dict
        PIV profiles in wall units
    gt_plus : dict
        Ground truth profiles in wall units
    y_plus_range : tuple
        y+ range for comparison (exclude near-wall and centerline regions)
    """
    # Interpolate ground truth to PIV y+ locations
    y_piv = piv_plus['y_plus']
    y_gt = gt_plus['y_plus']

    # Only compare in specified y+ range
    mask_piv = (y_piv >= y_plus_range[0]) & (y_piv <= y_plus_range[1])
    y_compare = y_piv[mask_piv]

    if len(y_compare) == 0:
        print(f"  Warning: No PIV points in y+ range {y_plus_range}")
        return {}

    errors = {}
    for var in ['U_plus', 'V_plus', 'uu_plus', 'vv_plus', 'uv_plus']:
        piv_vals = piv_plus[var][mask_piv]

        # Interpolate ground truth
        gt_interp = interp1d(y_gt, gt_plus[var], kind='linear',
                            bounds_error=False, fill_value=np.nan)
        gt_vals = gt_interp(y_compare)

        # Remove NaN values
        valid = ~np.isnan(piv_vals) & ~np.isnan(gt_vals)
        if valid.sum() == 0:
            continue

        piv_valid = piv_vals[valid]
        gt_valid = gt_vals[valid]

        # Compute metrics
        diff = piv_valid - gt_valid
        rms_error = np.sqrt(np.mean(diff**2))
        mean_abs_error = np.mean(np.abs(diff))

        # Relative RMS error (as percentage of GT range)
        gt_range = np.ptp(gt_valid)  # peak-to-peak
        rms_rel = (rms_error / gt_range * 100) if gt_range > 0 else np.nan

        # Correlation coefficient
        corr = np.corrcoef(piv_valid, gt_valid)[0, 1]

        # R-squared
        ss_res = np.sum(diff**2)
        ss_tot = np.sum((gt_valid - gt_valid.mean())**2)
        r2 = 1 - (ss_res / ss_tot) if ss_tot > 0 else np.nan

        errors[var] = {
            'rms': rms_error,
            'rms_rel': rms_rel,
            'mae': mean_abs_error,
            'corr': corr,
            'r2': r2,
            'n_points': valid.sum(),
        }

    return errors


def plot_comparison(piv_plus, gt_plus, wall_units, errors, output_dir, window_label='16x16', show_fit_lines=False):
    """Generate comparison plots."""
    output_dir = Path(output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)

    Re_tau = wall_units['Re_tau']

    # Check for CI data
    has_ci = 'uu_plus_ci_lo' in gt_plus

    # Figure 1: Mean velocity profile (semi-log)
    fig, ax = plt.subplots(figsize=(10, 7))

    # Ground truth with CI band
    if has_ci and 'U_plus_ci_lo' in gt_plus:
        plot_ci_band(ax, gt_plus['y_plus'], gt_plus['U_plus_ci_lo'],
                     gt_plus['U_plus_ci_hi'], color='k', alpha=0.15, zorder=1)
    ax.semilogx(gt_plus['y_plus'], gt_plus['U_plus'], 'k-',
                linewidth=2, label='DNS (1px)', zorder=3)

    # PIV
    ax.semilogx(piv_plus['y_plus'], piv_plus['U_plus'], 'ro',
                markersize=4, alpha=0.7, label=f'PIV ({window_label})', zorder=2)

    if show_fit_lines:
        y_log = np.logspace(1, np.log10(Re_tau), 100)
        kappa, B = 0.41, 5.2
        ax.semilogx(y_log, (1/kappa)*np.log(y_log)+B, 'b--', linewidth=1, alpha=0.7,
                    label=r'Log law: $U^+ = \frac{1}{\kappa}\ln(y^+) + B$')
        y_visc = np.linspace(0.1, 10, 50)
        ax.semilogx(y_visc, y_visc, 'g--', linewidth=1, alpha=0.7,
                    label=r'Viscous sublayer: $U^+ = y^+$')

    ax.set_xlabel(r'$y^+$', fontsize=14)
    ax.set_ylabel(r'$U^+$', fontsize=14)
    ax.set_title(f'Mean Velocity Profile (Re$_\\tau$ = {Re_tau:.0f})', fontsize=16)
    ax.legend(fontsize=11)
    ax.set_xlim(1, Re_tau)
    ax.set_ylim(0, 25)
    ax.grid(True, alpha=0.3)

    if 'U_plus' in errors:
        ax.text(0.02, 0.98, f"R² = {errors['U_plus']['r2']:.4f}\n"
                           f"RMS = {errors['U_plus']['rms_rel']:.1f}%",
                transform=ax.transAxes, fontsize=11, verticalalignment='top',
                bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))

    fig.tight_layout()
    fig.savefig(output_dir / 'U_plus_profile.png', dpi=150)
    plt.close(fig)

    # Figure 2: Reynolds stresses (semi-log)
    fig, axes = plt.subplots(1, 3, figsize=(15, 5))

    # uu+
    ax = axes[0]
    if has_ci:
        plot_ci_band(ax, gt_plus['y_plus'], gt_plus['uu_plus_ci_lo'],
                     gt_plus['uu_plus_ci_hi'], color='k', zorder=1)
    ax.semilogx(gt_plus['y_plus'], gt_plus['uu_plus'], 'k-', linewidth=2, label='DNS')
    ax.semilogx(piv_plus['y_plus'], piv_plus['uu_plus'], 'ro', markersize=4,
                alpha=0.7, label='PIV')
    ax.set_xlabel(r'$y^+$', fontsize=12)
    ax.set_ylabel(r"$\overline{u'u'}^+$", fontsize=12)
    ax.set_title('Streamwise Normal Stress', fontsize=14)
    ax.legend()
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)
    if 'uu_plus' in errors:
        ax.text(0.98, 0.98, f"R² = {errors['uu_plus']['r2']:.4f}",
                transform=ax.transAxes, fontsize=10, ha='right', va='top',
                bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))

    # vv+
    ax = axes[1]
    if has_ci:
        plot_ci_band(ax, gt_plus['y_plus'], gt_plus['vv_plus_ci_lo'],
                     gt_plus['vv_plus_ci_hi'], color='k', zorder=1)
    ax.semilogx(gt_plus['y_plus'], gt_plus['vv_plus'], 'k-', linewidth=2, label='DNS')
    ax.semilogx(piv_plus['y_plus'], piv_plus['vv_plus'], 'ro', markersize=4,
                alpha=0.7, label='PIV')
    ax.set_xlabel(r'$y^+$', fontsize=12)
    ax.set_ylabel(r"$\overline{v'v'}^+$", fontsize=12)
    ax.set_title('Wall-Normal Normal Stress', fontsize=14)
    ax.legend()
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)
    if 'vv_plus' in errors:
        ax.text(0.98, 0.98, f"R² = {errors['vv_plus']['r2']:.4f}",
                transform=ax.transAxes, fontsize=10, ha='right', va='top',
                bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))

    # -uv+
    ax = axes[2]
    if has_ci:
        plot_ci_band(ax, gt_plus['y_plus'], gt_plus['uv_plus_ci_lo'],
                     gt_plus['uv_plus_ci_hi'], sign=-1, color='k', zorder=1)
    ax.semilogx(gt_plus['y_plus'], -gt_plus['uv_plus'], 'k-', linewidth=2, label='DNS')
    ax.semilogx(piv_plus['y_plus'], -piv_plus['uv_plus'], 'ro', markersize=4,
                alpha=0.7, label='PIV')
    ax.set_xlabel(r'$y^+$', fontsize=12)
    ax.set_ylabel(r"$-\overline{u'v'}^+$", fontsize=12)
    ax.set_title('Reynolds Shear Stress', fontsize=14)
    ax.legend()
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)
    if 'uv_plus' in errors:
        ax.text(0.98, 0.98, f"R² = {errors['uv_plus']['r2']:.4f}",
                transform=ax.transAxes, fontsize=10, ha='right', va='top',
                bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))

    fig.tight_layout()
    fig.savefig(output_dir / 'reynolds_stresses.png', dpi=150)
    plt.close(fig)

    # Figure 3: V+ profile (wall-normal mean velocity)
    fig, ax = plt.subplots(figsize=(10, 7))

    if has_ci and 'V_plus_ci_lo' in gt_plus:
        plot_ci_band(ax, gt_plus['y_plus'], gt_plus['V_plus_ci_lo'],
                     gt_plus['V_plus_ci_hi'], color='k', zorder=1)
    ax.plot(gt_plus['y_plus'], gt_plus['V_plus'], 'k-', linewidth=2, label='DNS')
    ax.plot(piv_plus['y_plus'], piv_plus['V_plus'], 'ro', markersize=4,
            alpha=0.7, label='PIV')
    ax.axhline(y=0, color='gray', linestyle='--', linewidth=0.5, alpha=0.7)

    ax.set_xlabel(r'$y^+$', fontsize=14)
    ax.set_ylabel(r'$V^+$', fontsize=14)
    ax.set_title(f'Mean Wall-Normal Velocity Profile (Re$_\\tau$ = {Re_tau:.0f})', fontsize=16)
    ax.legend(fontsize=11)
    ax.set_xscale('log')
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)

    if 'V_plus' in errors:
        ax.text(0.02, 0.98, f"R² = {errors['V_plus']['r2']:.4f}\n"
                           f"Corr = {errors['V_plus']['corr']:.4f}",
                transform=ax.transAxes, fontsize=11, verticalalignment='top',
                bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))

    fig.tight_layout()
    fig.savefig(output_dir / 'V_plus_profile.png', dpi=150)
    plt.close(fig)

    # Figure 4: All profiles on linear scale
    fig, ax = plt.subplots(figsize=(10, 7))

    ax.plot(gt_plus['y_plus'], gt_plus['U_plus'], 'k-', linewidth=2, label='DNS U+')
    ax.plot(piv_plus['y_plus'], piv_plus['U_plus'], 'ko', markersize=3,
            alpha=0.5, label='PIV U+')

    ax.set_xlabel(r'$y^+$', fontsize=14)
    ax.set_ylabel(r'$U^+$', fontsize=14)
    ax.set_title('Mean Velocity Profile', fontsize=16)
    ax.legend(fontsize=11)
    ax.set_xscale('log')
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)

    fig.tight_layout()
    fig.savefig(output_dir / 'U_plus_linear.png', dpi=150)
    plt.close(fig)

    # Figure 5: Smoothed line plots (log-space moving average)
    # ---- U+ smoothed ----
    fig, ax = plt.subplots(figsize=(10, 7))

    if has_ci and 'U_plus_ci_lo' in gt_plus:
        plot_ci_band(ax, gt_plus['y_plus'], gt_plus['U_plus_ci_lo'],
                     gt_plus['U_plus_ci_hi'], color='k', zorder=1)
    ax.semilogx(gt_plus['y_plus'], gt_plus['U_plus'], 'k-',
                linewidth=2, label='DNS (1px)', zorder=3)

    ax.semilogx(piv_plus['y_plus'], piv_plus['U_plus'], 'ro',
                markersize=4, alpha=0.7, label=f'PIV ({window_label})', zorder=2)

    if show_fit_lines:
        y_log = np.logspace(1, np.log10(Re_tau), 100)
        kappa, B = 0.41, 5.2
        ax.semilogx(y_log, (1/kappa)*np.log(y_log)+B, 'b--', linewidth=1, alpha=0.7,
                    label=r'Log law')
        y_visc = np.linspace(0.1, 10, 50)
        ax.semilogx(y_visc, y_visc, 'g--', linewidth=1, alpha=0.7, label=r'$U^+=y^+$')

    ax.set_xlabel(r'$y^+$', fontsize=14)
    ax.set_ylabel(r'$U^+$', fontsize=14)
    ax.set_title(f'Mean Velocity Profile - Smoothed ({window_label})', fontsize=16)
    ax.legend(fontsize=11)
    ax.set_xlim(1, Re_tau)
    ax.set_ylim(0, 25)
    ax.grid(True, alpha=0.3)
    if 'U_plus' in errors:
        ax.text(0.02, 0.98, f"R² = {errors['U_plus']['r2']:.4f}\n"
                           f"RMS = {errors['U_plus']['rms_rel']:.1f}%",
                transform=ax.transAxes, fontsize=11, verticalalignment='top',
                bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))
    fig.tight_layout()
    fig.savefig(output_dir / 'U_plus_profile_smooth.png', dpi=150)
    plt.close(fig)

    # ---- Reynolds stresses smoothed ----
    fig, axes = plt.subplots(1, 3, figsize=(15, 5))

    stress_configs = [
        ('uu_plus', r"$\overline{u'u'}^+$", 'Streamwise Normal Stress', 1),
        ('vv_plus', r"$\overline{v'v'}^+$", 'Wall-Normal Normal Stress', 1),
        ('uv_plus', r"$-\overline{u'v'}^+$", 'Reynolds Shear Stress', -1),
    ]
    for ax, (var, ylabel, title, sign) in zip(axes, stress_configs):
        gt_vals = sign * gt_plus[var]
        piv_vals = sign * piv_plus[var]

        ci_lo_key = f'{var}_ci_lo'
        ci_hi_key = f'{var}_ci_hi'
        if has_ci and ci_lo_key in gt_plus:
            plot_ci_band(ax, gt_plus['y_plus'], gt_plus[ci_lo_key],
                         gt_plus[ci_hi_key], sign=sign, color='k', zorder=1)
        ax.semilogx(gt_plus['y_plus'], gt_vals, 'k-', linewidth=2, label='DNS')
        ax.semilogx(piv_plus['y_plus'], piv_vals, 'ro', markersize=4, alpha=0.7, label='PIV')

        ax.set_xlabel(r'$y^+$', fontsize=12)
        ax.set_ylabel(ylabel, fontsize=12)
        ax.set_title(title, fontsize=14)
        ax.legend()
        ax.set_xlim(1, Re_tau)
        ax.grid(True, alpha=0.3)
        if var in errors:
            ax.text(0.98, 0.98, f"R² = {errors[var]['r2']:.4f}",
                    transform=ax.transAxes, fontsize=10, ha='right', va='top',
                    bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))

    fig.tight_layout()
    fig.savefig(output_dir / 'reynolds_stresses_smooth.png', dpi=150)
    plt.close(fig)

    # Figure 6: Trace invariant (u'u' + v'v') - rotation diagnostic
    fig, axes = plt.subplots(1, 3, figsize=(16, 5))

    # Compute trace
    gt_trace = gt_plus['uu_plus'] + gt_plus['vv_plus']
    piv_trace = piv_plus['uu_plus'] + piv_plus['vv_plus']

    # Left: Individual components
    ax = axes[0]
    ax.semilogx(gt_plus['y_plus'], gt_plus['uu_plus'], 'k-', linewidth=2, label="DNS u'u'+")
    ax.semilogx(gt_plus['y_plus'], gt_plus['vv_plus'], 'k--', linewidth=2, label="DNS v'v'+")
    ax.semilogx(piv_plus['y_plus'], piv_plus['uu_plus'], 'ro', markersize=3, alpha=0.7, label="PIV u'u'+")
    ax.semilogx(piv_plus['y_plus'], piv_plus['vv_plus'], 'bs', markersize=3, alpha=0.7, label="PIV v'v'+")
    ax.set_xlabel(r'$y^+$', fontsize=12)
    ax.set_ylabel(r"Stress$^+$", fontsize=12)
    ax.set_title('Individual Normal Stresses', fontsize=14)
    ax.legend(fontsize=9)
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)

    # Middle: Trace comparison
    ax = axes[1]
    ax.semilogx(gt_plus['y_plus'], gt_trace, 'k-', linewidth=2, label='DNS')
    ax.semilogx(piv_plus['y_plus'], piv_trace, 'ro', markersize=4, alpha=0.7, label='PIV')
    ax.set_xlabel(r'$y^+$', fontsize=12)
    ax.set_ylabel(r"$\overline{u'u'}^+ + \overline{v'v'}^+$", fontsize=12)
    ax.set_title("Trace Invariant (u'u' + v'v')", fontsize=14)
    ax.legend(fontsize=11)
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)

    # Right: Ratio of components (rotation indicator)
    ax = axes[2]
    gt_ratio = gt_plus['uu_plus'] / (gt_plus['vv_plus'] + 1e-10)  # avoid div by zero
    piv_ratio = piv_plus['uu_plus'] / (piv_plus['vv_plus'] + 1e-10)
    ax.semilogx(gt_plus['y_plus'], gt_ratio, 'k-', linewidth=2, label='DNS')
    ax.semilogx(piv_plus['y_plus'], piv_ratio, 'ro', markersize=4, alpha=0.7, label='PIV')
    ax.set_xlabel(r'$y^+$', fontsize=12)
    ax.set_ylabel(r"$\overline{u'u'}^+ / \overline{v'v'}^+$", fontsize=12)
    ax.set_title("Stress Ratio (rotation indicator)", fontsize=14)
    ax.legend(fontsize=11)
    ax.set_xlim(1, Re_tau)
    ax.set_ylim(0, 10)
    ax.grid(True, alpha=0.3)

    fig.suptitle("Rotation Diagnostic: Trace is invariant under rotation", fontsize=14, y=1.02)
    fig.tight_layout()
    fig.savefig(output_dir / 'trace_invariant.png', dpi=150)
    plt.close(fig)

    # Figure 7: Residuals (PIV - Ref) vs y+ — velocities and stresses
    fig, axes = plt.subplots(2, 3, figsize=(15, 10))

    # Interpolate ground truth onto PIV y+ grid
    gt_interp_fn = {}
    for var in ['U_plus', 'V_plus', 'uu_plus', 'vv_plus', 'uv_plus']:
        gt_interp_fn[var] = interp1d(gt_plus['y_plus'], gt_plus[var], kind='linear',
                                     bounds_error=False, fill_value=np.nan)

    # Top row: velocity residuals
    vel_configs = [
        ('U_plus', r"$U^+_{\mathrm{PIV}} - U^+_{\mathrm{Ref}}$",
         'Mean Streamwise Velocity Residual', 1),
        ('V_plus', r"$V^+_{\mathrm{PIV}} - V^+_{\mathrm{Ref}}$",
         'Mean Wall-Normal Velocity Residual', 1),
    ]
    for ax, (var, ylabel, title, sign) in zip(axes[0, :2], vel_configs):
        gt_at_piv = gt_interp_fn[var](piv_plus['y_plus'])
        residual = sign * piv_plus[var] - sign * gt_at_piv

        ax.semilogx(piv_plus['y_plus'], residual, 'ro', markersize=3, alpha=0.5)
        yp_s, r_s = log_smooth(piv_plus['y_plus'], residual)
        ax.semilogx(yp_s, r_s, 'r-', linewidth=2, label=f'PIV ({window_label})')
        ax.axhline(y=0, color='k', linestyle='-', linewidth=1, alpha=0.5)

        ax.set_xlabel(r'$y^+$', fontsize=12)
        ax.set_ylabel(ylabel, fontsize=12)
        ax.set_title(title, fontsize=14)
        ax.legend()
        ax.set_xlim(1, Re_tau)
        ax.grid(True, alpha=0.3)

    axes[0, 2].set_visible(False)  # Empty top-right panel

    # Bottom row: stress residuals
    stress_configs = [
        ('uu_plus', r"$\overline{u'u'}^+_{\mathrm{PIV}} - \overline{u'u'}^+_{\mathrm{Ref}}$",
         'Streamwise Normal Stress Residual', 1),
        ('vv_plus', r"$\overline{v'v'}^+_{\mathrm{PIV}} - \overline{v'v'}^+_{\mathrm{Ref}}$",
         'Wall-Normal Normal Stress Residual', 1),
        ('uv_plus', r"$-\overline{u'v'}^+_{\mathrm{PIV}} - (-\overline{u'v'}^+_{\mathrm{Ref}})$",
         'Shear Stress Residual', -1),
    ]
    for ax, (var, ylabel, title, sign) in zip(axes[1, :], stress_configs):
        gt_at_piv = gt_interp_fn[var](piv_plus['y_plus'])
        residual = sign * piv_plus[var] - sign * gt_at_piv

        ax.semilogx(piv_plus['y_plus'], residual, 'ro', markersize=3, alpha=0.5)
        yp_s, r_s = log_smooth(piv_plus['y_plus'], residual)
        ax.semilogx(yp_s, r_s, 'r-', linewidth=2, label=f'PIV ({window_label})')
        ax.axhline(y=0, color='k', linestyle='-', linewidth=1, alpha=0.5)

        ax.set_xlabel(r'$y^+$', fontsize=12)
        ax.set_ylabel(ylabel, fontsize=12)
        ax.set_title(title, fontsize=14)
        ax.legend()
        ax.set_xlim(1, Re_tau)
        ax.grid(True, alpha=0.3)

    fig.tight_layout()
    fig.savefig(output_dir / 'residuals.png', dpi=150)
    plt.close(fig)

    # Figure 8: Noise floor vs gradient correction decomposition
    fig, axes = plt.subplots(1, 3, figsize=(16, 5))

    # Compute residuals
    uu_residual = piv_plus['uu_plus'] - gt_interp_fn['uu_plus'](piv_plus['y_plus'])
    vv_residual = piv_plus['vv_plus'] - gt_interp_fn['vv_plus'](piv_plus['y_plus'])
    gradient_only = uu_residual - vv_residual  # u'u' residual minus noise floor

    # Left: Noise floor (v'v' residual)
    ax = axes[0]
    ax.semilogx(piv_plus['y_plus'], vv_residual, 'bo', markersize=2, alpha=0.3)
    yp_s, r_s = log_smooth(piv_plus['y_plus'], vv_residual)
    ax.semilogx(yp_s, r_s, 'b-', linewidth=2.5, label=r"$v'v'$ residual (noise floor)")
    ax.axhline(y=0, color='k', linestyle='-', linewidth=1, alpha=0.5)
    ax.set_xlabel(r'$y^+$', fontsize=12)
    ax.set_ylabel(r"$\overline{v'v'}^+_{\mathrm{PIV}} - \overline{v'v'}^+_{\mathrm{Ref}}$", fontsize=12)
    ax.set_title('Noise Floor (isotropic)', fontsize=14)
    ax.legend(fontsize=10)
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)

    # Middle: Gradient-only residual
    ax = axes[1]
    ax.semilogx(piv_plus['y_plus'], gradient_only, 'ro', markersize=2, alpha=0.3)
    yp_s, r_s = log_smooth(piv_plus['y_plus'], gradient_only)
    ax.semilogx(yp_s, r_s, 'r-', linewidth=2.5,
                label=r"$(\overline{u'u'} - \overline{v'v'})_{\mathrm{PIV}} - (\overline{u'u'} - \overline{v'v'})_{\mathrm{Ref}}$")
    ax.axhline(y=0, color='k', linestyle='-', linewidth=1, alpha=0.5)
    ax.set_xlabel(r'$y^+$', fontsize=12)
    ax.set_ylabel(r"Gradient-only residual$^+$", fontsize=12)
    ax.set_title(r"Gradient Correction Residual ($u'u' - v'v'$ removes noise)", fontsize=14)
    ax.legend(fontsize=9)
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)

    # Right: All three overlaid
    ax = axes[2]
    ax.semilogx(piv_plus['y_plus'], uu_residual, 'ro', markersize=2, alpha=0.15)
    yp_s_uu, r_s_uu = log_smooth(piv_plus['y_plus'], uu_residual)
    ax.semilogx(yp_s_uu, r_s_uu, 'r-', linewidth=2, label=r"$u'u'$ residual (total)")

    ax.semilogx(piv_plus['y_plus'], vv_residual, 'bo', markersize=2, alpha=0.15)
    yp_s_vv, r_s_vv = log_smooth(piv_plus['y_plus'], vv_residual)
    ax.semilogx(yp_s_vv, r_s_vv, 'b-', linewidth=2, label=r"$v'v'$ residual (noise floor)")

    yp_s_g, r_s_g = log_smooth(piv_plus['y_plus'], gradient_only)
    ax.semilogx(yp_s_g, r_s_g, 'g--', linewidth=2, label=r"$u'u' - v'v'$ residual (gradient only)")

    ax.axhline(y=0, color='k', linestyle='-', linewidth=1, alpha=0.5)
    ax.set_xlabel(r'$y^+$', fontsize=12)
    ax.set_ylabel(r"Residual$^+$", fontsize=12)
    ax.set_title('Decomposition: Total = Noise + Gradient', fontsize=14)
    ax.legend(fontsize=9)
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)

    fig.suptitle(f'Noise Floor vs Gradient Correction ({window_label})', fontsize=14, y=1.02)
    fig.tight_layout()
    fig.savefig(output_dir / 'noise_gradient_decomposition.png', dpi=150)
    plt.close(fig)

    print(f"\nPlots saved to: {output_dir}")


def plot_combined_stresses(piv_plus, gt_plus, wall_units, errors, output_dir, window_label='16x16'):
    """Plot uu+, vv+, -uv+ all on one axis."""
    output_dir = Path(output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)

    Re_tau = wall_units['Re_tau']

    has_ci = 'uu_plus_ci_lo' in gt_plus

    fig, ax = plt.subplots(figsize=(12, 8))

    # CI bands (before reference lines so they render behind)
    if has_ci:
        plot_ci_band(ax, gt_plus['y_plus'], gt_plus['uu_plus_ci_lo'],
                     gt_plus['uu_plus_ci_hi'], color='k', alpha=0.12, zorder=1)
        plot_ci_band(ax, gt_plus['y_plus'], gt_plus['vv_plus_ci_lo'],
                     gt_plus['vv_plus_ci_hi'], color='k', alpha=0.12, zorder=1)
        plot_ci_band(ax, gt_plus['y_plus'], gt_plus['uv_plus_ci_lo'],
                     gt_plus['uv_plus_ci_hi'], sign=-1, color='k', alpha=0.12, zorder=1)

    # Reference (solid lines)
    ax.plot(gt_plus['y_plus'], gt_plus['uu_plus'], 'k-', linewidth=2,
            label=r"Ref $\overline{u'u'}^+$")
    ax.plot(gt_plus['y_plus'], gt_plus['vv_plus'], 'k--', linewidth=2,
            label=r"Ref $\overline{v'v'}^+$")
    ax.plot(gt_plus['y_plus'], -gt_plus['uv_plus'], 'k:', linewidth=2,
            label=r"Ref $-\overline{u'v'}^+$")

    # PIV markers
    marker_configs = [
        ('uu_plus', 1, 'r', 'o', r"PIV $\overline{u'u'}^+$"),
        ('vv_plus', 1, 'g', 's', r"PIV $\overline{v'v'}^+$"),
        ('uv_plus', -1, 'm', 'D', r"PIV $-\overline{u'v'}^+$"),
    ]
    for var, sign, col, mkr, label in marker_configs:
        piv_vals = sign * piv_plus[var]
        ax.plot(piv_plus['y_plus'], piv_vals, color=col, marker=mkr,
                markersize=4, alpha=0.7, linestyle='none', label=label, zorder=5)

    ax.set_xlabel(r'$y^+$', fontsize=14)
    ax.set_ylabel(r'Stress$^+$', fontsize=14)
    ax.set_title(f'Reynolds Stresses ({window_label}) - PIV vs Reference '
                 f'(Re$_\\tau$ = {Re_tau:.0f})', fontsize=16)
    ax.legend(fontsize=10, ncol=2, loc='upper right')
    ax.set_xscale('log')
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)

    fig.tight_layout()
    fig.savefig(output_dir / 'combined_stresses.png', dpi=150)
    plt.close(fig)
    print(f"  Combined stresses plot saved to: {output_dir / 'combined_stresses.png'}")


def main(mode='instantaneous', gt_dir=None, base_dir=None, ensemble_dir=None, num_frames=1000, output_dir_override=None, show_fit_lines=False):
    """Main benchmark comparison function.

    Parameters
    ----------
    mode : str
        'instantaneous' or 'ensemble'
    gt_dir : Path
        Ground truth directory path (required)
    base_dir : Path, optional
        Base directory containing PIV results
    ensemble_dir : Path, optional
        Direct path to ensemble directory containing ensemble_result.mat and coordinates.mat.
        If provided, overrides base_dir for ensemble mode.
    num_frames : int
        Number of frames subdirectory (e.g. 1000 or 4000). Used in path construction.
    output_dir_override : Path, optional
        Custom output directory. If None, uses default naming.
    """
    if gt_dir is None:
        raise ValueError("gt_dir is required. Please provide the ground truth directory path.")

    # Paths
    script_dir = Path(__file__).parent
    gt_dir = Path(gt_dir)

    if mode == 'ensemble':
        if ensemble_dir is not None:
            ensemble_dir = Path(ensemble_dir)
            ensemble_path = ensemble_dir / 'ensemble_result.mat'
            coords_path = ensemble_dir / 'coordinates.mat'
        elif base_dir is not None:
            base_dir = Path(base_dir)
            ensemble_path = base_dir / f'calibrated_piv/{num_frames}/Cam1/ensemble/ensemble_result.mat'
            coords_path = base_dir / f'calibrated_piv/{num_frames}/Cam1/ensemble/coordinates.mat'
        else:
            raise ValueError("Either ensemble_dir or base_dir must be provided for ensemble mode.")
        output_dir = output_dir_override or (script_dir / 'benchmark_results_ensemble')
    else:
        if base_dir is None:
            raise ValueError("base_dir is required for instantaneous mode.")
        base_dir = Path(base_dir)
        stats_path = base_dir / f'statistics/{num_frames}/Cam1/instantaneous/mean_stats/mean_stats.mat'
        output_dir = output_dir_override or (script_dir / 'benchmark_results')

    print("=" * 70)
    print(f"PIV BENCHMARK COMPARISON ({mode.upper()})")
    print("=" * 70)

    # Load data - auto-detect file names
    print("\n[1] Loading wall units...")
    wall_units_file = gt_dir / 'wall_units.mat'
    if not wall_units_file.exists():
        wall_units_file = gt_dir / 'diagnostics.mat'
    if not wall_units_file.exists():
        wall_units_file = gt_dir / 'direct_stats.mat'
    wall_units = load_wall_units(wall_units_file)
    print(f"  u_tau = {wall_units['u_tau']:.4f} mm/s")
    print(f"  nu = {wall_units['nu']:.4f} mm²/s")
    print(f"  delta_nu = {wall_units['delta_nu']:.4f} mm")
    print(f"  Re_tau = {wall_units['Re_tau']:.0f}")

    print("\n[2] Loading ground truth...")
    profiles_file = gt_dir / 'profiles.mat'
    if not profiles_file.exists():
        profiles_file = gt_dir / 'ensemble_statistics_full.mat'
    if not profiles_file.exists():
        profiles_file = gt_dir / 'direct_stats.mat'
    gt = load_ground_truth(profiles_file, wall_units_path=wall_units_file)
    print(f"  y+ range: {gt['y_plus'].min():.1f} to {gt['y_plus'].max():.1f}")
    print(f"  U range: {gt['U'].min():.2f} to {gt['U'].max():.2f} mm/s")

    print(f"\n[3] Loading PIV statistics ({mode}, run 4)...")
    if mode == 'ensemble':
        piv = load_ensemble_statistics(ensemble_path, coords_path, run_idx=3)
    else:
        piv = load_piv_statistics(stats_path, run_idx=3)
    print(f"  Grid size: {piv['ux'].shape}")
    print(f"  ux range: {np.nanmin(piv['ux'])*1000:.2f} to {np.nanmax(piv['ux'])*1000:.2f} mm/s")

    print("\n[4] Computing x-averaged PIV profiles...")
    piv_profiles = compute_piv_profiles(piv, x_exclude_vectors=4)
    print(f"  y range: {piv_profiles['y_mm'].min():.2f} to {piv_profiles['y_mm'].max():.2f} mm")
    print(f"  U range: {np.nanmin(piv_profiles['U']):.2f} to {np.nanmax(piv_profiles['U']):.2f} mm/s")

    print("\n[5] Converting to wall units...")
    # Calculate y-offset to align PIV coordinate system with ground truth
    # Ground truth has y=0 at the wall, PIV may have an offset
    y_offset_mm = -piv_profiles['y_mm'].min()  # Shift so y_min = 0
    print(f"  Applying y-offset: {y_offset_mm:.2f} mm (aligning y_min to wall)")

    piv_plus = convert_to_wall_units(piv_profiles, wall_units, y_offset_mm=y_offset_mm)
    piv_plus['y_plus'] = piv_plus['y_plus'] + 1.0  # shift y+ by +1
    print(f"  Aligned y range: {piv_plus['y_mm'].min():.2f} to {piv_plus['y_mm'].max():.2f} mm")
    print(f"  y+ range: {piv_plus['y_plus'].min():.1f} to {piv_plus['y_plus'].max():.1f} (y+ +1 applied)")
    print(f"  U+ range: {np.nanmin(piv_plus['U_plus']):.2f} to {np.nanmax(piv_plus['U_plus']):.2f}")

    # Ground truth - convert V to wall units and include pre-computed values
    gt_plus = {
        'y_plus': gt['y_plus'],
        'U_plus': gt['U_plus'],
        'V_plus': gt['V'] / wall_units['u_tau'],  # Convert V to wall units
        'uu_plus': gt['uu_plus'],
        'vv_plus': gt['vv_plus'],
        'uv_plus': gt['uv_plus'],
    }
    # Thread CI bounds through if available
    for ci_key in ['U_plus_ci_lo', 'U_plus_ci_hi', 'V_plus_ci_lo', 'V_plus_ci_hi',
                   'uu_plus_ci_lo', 'uu_plus_ci_hi', 'vv_plus_ci_lo', 'vv_plus_ci_hi',
                   'uv_plus_ci_lo', 'uv_plus_ci_hi']:
        if ci_key in gt:
            gt_plus[ci_key] = gt[ci_key]

    # Verify V sign convention matches (should be correct after save_results.py fix)
    # Sample at mid-channel to check sign
    y_mid_idx = len(piv_plus['y_plus']) // 4  # ~25% from wall
    piv_v_sample = piv_plus['V_plus'][y_mid_idx]
    gt_v_idx = np.argmin(np.abs(gt_plus['y_plus'] - piv_plus['y_plus'][y_mid_idx]))
    gt_v_sample = gt['V'][gt_v_idx] / wall_units['u_tau']

    print(f"\n  Sign check at y+ ≈ {piv_plus['y_plus'][y_mid_idx]:.0f}:")
    print(f"    PIV V+ = {piv_v_sample:+.4f}")
    print(f"    DNS V+ = {gt_v_sample:+.4f}")

    v_sign_match = np.sign(piv_v_sample) == np.sign(gt_v_sample) or abs(gt_v_sample) < 0.01
    if v_sign_match:
        print("    => V sign MATCHES ✓ (no flip needed)")
    else:
        print("    => V sign MISMATCH ✗ (PIV pipeline may still have sign issue)")

    # No manual flipping - the save_results.py fix should handle this
    # If signs still don't match, it indicates the fix didn't work correctly

    print("\n[6] Computing error metrics (y+ = 10-500)...")
    errors = compute_errors(piv_plus, gt_plus, y_plus_range=(10, 500))

    print("\n" + "=" * 70)
    print("BENCHMARK RESULTS")
    print("=" * 70)

    for var, err in errors.items():
        var_name = {
            'U_plus': 'Mean Streamwise Velocity (U+)',
            'V_plus': 'Mean Wall-normal Velocity (V+)',
            'uu_plus': 'Streamwise Stress (uu+)',
            'vv_plus': 'Wall-normal Stress (vv+)',
            'uv_plus': 'Shear Stress (uv+)',
        }.get(var, var)

        print(f"\n{var_name}:")
        print(f"  RMS Error: {err['rms']:.4f} ({err['rms_rel']:.1f}% of range)")
        print(f"  MAE: {err['mae']:.4f}")
        print(f"  R²: {err['r2']:.4f}")
        print(f"  Correlation: {err['corr']:.4f}")
        print(f"  Points compared: {err['n_points']}")

    print("\n[7] Generating plots...")
    plot_comparison(piv_plus, gt_plus, wall_units, errors, output_dir,
                    show_fit_lines=show_fit_lines)
    plot_combined_stresses(piv_plus, gt_plus, wall_units, errors, output_dir)

    print("\n" + "=" * 70)
    print("BENCHMARK COMPLETE")
    print("=" * 70)


def plot_combined_comparison(all_results, gt_plus, wall_units, output_dir, show_fit_lines=False):
    """
    Generate combined comparison plots with all window sizes on one figure.

    Parameters
    ----------
    all_results : list of dict
        List of dicts with keys: 'piv_plus', 'errors', 'window_label', 'window_size'
    gt_plus : dict
        Ground truth profiles in wall units
    wall_units : dict
        Wall unit parameters
    output_dir : Path
        Output directory for plots
    """
    output_dir = Path(output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)

    Re_tau = wall_units['Re_tau']

    # Color/marker cycle for different window sizes
    colors = ['#e41a1c', '#377eb8', '#4daf4a', '#984ea3', '#ff7f00', '#a65628']
    markers = ['o', 's', '^', 'D', 'v', 'p']

    # Check for CI data
    has_ci = 'uu_plus_ci_lo' in gt_plus

    # ==========================================================================
    # Figure 1: Mean velocity profile (semi-log) - ALL WINDOWS
    # ==========================================================================
    fig, ax = plt.subplots(figsize=(12, 8))

    # Ground truth with CI band
    if has_ci and 'U_plus_ci_lo' in gt_plus:
        plot_ci_band(ax, gt_plus['y_plus'], gt_plus['U_plus_ci_lo'],
                     gt_plus['U_plus_ci_hi'], color='k', alpha=0.15, zorder=1)
    ax.semilogx(gt_plus['y_plus'], gt_plus['U_plus'], 'k-',
                linewidth=2.5, label='DNS (1px)', zorder=10)

    # PIV results for each window
    for i, res in enumerate(all_results):
        piv_plus = res['piv_plus']
        label = res['window_label']
        ax.semilogx(piv_plus['y_plus'], piv_plus['U_plus'],
                    color=colors[i % len(colors)], marker=markers[i % len(markers)],
                    markersize=4, alpha=0.7, linestyle='none',
                    label=f'PIV ({label})', zorder=5-i*0.1)

    if show_fit_lines:
        y_log = np.logspace(1, np.log10(Re_tau), 100)
        kappa, B = 0.41, 5.2
        ax.semilogx(y_log, (1/kappa)*np.log(y_log)+B, 'b--', linewidth=1.5, alpha=0.5,
                    label=r'Log law: $U^+ = \frac{1}{\kappa}\ln(y^+) + B$')
        y_visc = np.linspace(0.1, 10, 50)
        ax.semilogx(y_visc, y_visc, 'g--', linewidth=1.5, alpha=0.5,
                    label=r'Viscous sublayer: $U^+ = y^+$')

    ax.set_xlabel(r'$y^+$', fontsize=14)
    ax.set_ylabel(r'$U^+$', fontsize=14)
    ax.set_title(f'Mean Velocity Profile - All Window Sizes (Re$_\\tau$ = {Re_tau:.0f})', fontsize=16)
    ax.legend(fontsize=10, loc='upper left')
    ax.set_xlim(1, Re_tau)
    ax.set_ylim(0, 25)
    ax.grid(True, alpha=0.3)

    fig.tight_layout()
    fig.savefig(output_dir / 'U_plus_profile_combined.png', dpi=150)
    plt.close(fig)

    # ==========================================================================
    # Figure 2: Reynolds stresses - ALL WINDOWS
    # ==========================================================================
    fig, axes = plt.subplots(1, 3, figsize=(18, 6))

    # uu+
    ax = axes[0]
    if has_ci:
        plot_ci_band(ax, gt_plus['y_plus'], gt_plus['uu_plus_ci_lo'],
                     gt_plus['uu_plus_ci_hi'], color='k', zorder=1)
    ax.plot(gt_plus['y_plus'], gt_plus['uu_plus'], 'k-', linewidth=2.5, label='DNS', zorder=10)
    for i, res in enumerate(all_results):
        piv_plus = res['piv_plus']
        label = res['window_label']
        ax.plot(piv_plus['y_plus'], piv_plus['uu_plus'],
                color=colors[i % len(colors)], marker=markers[i % len(markers)],
                markersize=3, alpha=0.7, linestyle='none', label=f'PIV ({label})')
    ax.set_xlabel(r'$y^+$', fontsize=12)
    ax.set_ylabel(r"$\overline{u'u'}^+$", fontsize=12)
    ax.set_title('Streamwise Normal Stress', fontsize=14)
    ax.legend(fontsize=9)
    ax.set_xscale('log')
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)

    # vv+
    ax = axes[1]
    if has_ci:
        plot_ci_band(ax, gt_plus['y_plus'], gt_plus['vv_plus_ci_lo'],
                     gt_plus['vv_plus_ci_hi'], color='k', zorder=1)
    ax.plot(gt_plus['y_plus'], gt_plus['vv_plus'], 'k-', linewidth=2.5, label='DNS', zorder=10)
    for i, res in enumerate(all_results):
        piv_plus = res['piv_plus']
        label = res['window_label']
        ax.plot(piv_plus['y_plus'], piv_plus['vv_plus'],
                color=colors[i % len(colors)], marker=markers[i % len(markers)],
                markersize=3, alpha=0.7, linestyle='none', label=f'PIV ({label})')
    ax.set_xlabel(r'$y^+$', fontsize=12)
    ax.set_ylabel(r"$\overline{v'v'}^+$", fontsize=12)
    ax.set_title('Wall-Normal Normal Stress', fontsize=14)
    ax.legend(fontsize=9)
    ax.set_xscale('log')
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)

    # -uv+
    ax = axes[2]
    if has_ci:
        plot_ci_band(ax, gt_plus['y_plus'], gt_plus['uv_plus_ci_lo'],
                     gt_plus['uv_plus_ci_hi'], sign=-1, color='k', zorder=1)
    ax.plot(gt_plus['y_plus'], -gt_plus['uv_plus'], 'k-', linewidth=2.5, label='DNS', zorder=10)
    for i, res in enumerate(all_results):
        piv_plus = res['piv_plus']
        label = res['window_label']
        ax.plot(piv_plus['y_plus'], -piv_plus['uv_plus'],
                color=colors[i % len(colors)], marker=markers[i % len(markers)],
                markersize=3, alpha=0.7, linestyle='none', label=f'PIV ({label})')
    ax.set_xlabel(r'$y^+$', fontsize=12)
    ax.set_ylabel(r"$-\overline{u'v'}^+$", fontsize=12)
    ax.set_title('Reynolds Shear Stress', fontsize=14)
    ax.legend(fontsize=9)
    ax.set_xscale('log')
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)

    fig.tight_layout()
    fig.savefig(output_dir / 'reynolds_stresses_combined.png', dpi=150)
    plt.close(fig)

    # ==========================================================================
    # Figure 3: V+ profile - ALL WINDOWS
    # ==========================================================================
    fig, ax = plt.subplots(figsize=(12, 8))

    if has_ci and 'V_plus_ci_lo' in gt_plus:
        plot_ci_band(ax, gt_plus['y_plus'], gt_plus['V_plus_ci_lo'],
                     gt_plus['V_plus_ci_hi'], color='k', zorder=1)
    ax.plot(gt_plus['y_plus'], gt_plus['V_plus'], 'k-', linewidth=2.5, label='DNS', zorder=10)
    for i, res in enumerate(all_results):
        piv_plus = res['piv_plus']
        label = res['window_label']
        ax.plot(piv_plus['y_plus'], piv_plus['V_plus'],
                color=colors[i % len(colors)], marker=markers[i % len(markers)],
                markersize=4, alpha=0.7, linestyle='none', label=f'PIV ({label})')
    ax.axhline(y=0, color='gray', linestyle='--', linewidth=0.5, alpha=0.7)

    ax.set_xlabel(r'$y^+$', fontsize=14)
    ax.set_ylabel(r'$V^+$', fontsize=14)
    ax.set_title(f'Mean Wall-Normal Velocity Profile - All Window Sizes (Re$_\\tau$ = {Re_tau:.0f})', fontsize=16)
    ax.legend(fontsize=10)
    ax.set_xscale('log')
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)

    fig.tight_layout()
    fig.savefig(output_dir / 'V_plus_profile_combined.png', dpi=150)
    plt.close(fig)

    # ==========================================================================
    # Figure 4: U+ linear scale - ALL WINDOWS
    # ==========================================================================
    fig, ax = plt.subplots(figsize=(12, 8))

    ax.plot(gt_plus['y_plus'], gt_plus['U_plus'], 'k-', linewidth=2.5, label='DNS U+', zorder=10)
    for i, res in enumerate(all_results):
        piv_plus = res['piv_plus']
        label = res['window_label']
        ax.plot(piv_plus['y_plus'], piv_plus['U_plus'],
                color=colors[i % len(colors)], marker=markers[i % len(markers)],
                markersize=3, alpha=0.6, linestyle='none', label=f'PIV ({label})')

    ax.set_xlabel(r'$y^+$', fontsize=14)
    ax.set_ylabel(r'$U^+$', fontsize=14)
    ax.set_title('Mean Velocity Profile - All Window Sizes', fontsize=16)
    ax.legend(fontsize=10)
    ax.set_xscale('log')
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)

    fig.tight_layout()
    fig.savefig(output_dir / 'U_plus_linear_combined.png', dpi=150)
    plt.close(fig)

    # ==========================================================================
    # Figure 5: Smoothed U+ combined - ALL WINDOWS
    # ==========================================================================
    fig, ax = plt.subplots(figsize=(12, 8))

    if has_ci and 'U_plus_ci_lo' in gt_plus:
        plot_ci_band(ax, gt_plus['y_plus'], gt_plus['U_plus_ci_lo'],
                     gt_plus['U_plus_ci_hi'], color='k', alpha=0.15, zorder=1)
    ax.semilogx(gt_plus['y_plus'], gt_plus['U_plus'], 'k-',
                linewidth=2.5, label='DNS (1px)', zorder=10)

    for i, res in enumerate(all_results):
        piv_plus = res['piv_plus']
        label = res['window_label']
        c = colors[i % len(colors)]
        ax.semilogx(piv_plus['y_plus'], piv_plus['U_plus'],
                    color=c, marker=markers[i % len(markers)],
                    markersize=4, alpha=0.7, linestyle='none',
                    label=f'PIV ({label})', zorder=5-i*0.1)

    if show_fit_lines:
        y_log = np.logspace(1, np.log10(Re_tau), 100)
        kappa, B = 0.41, 5.2
        ax.semilogx(y_log, (1/kappa)*np.log(y_log)+B, 'b--', linewidth=1.5, alpha=0.5,
                    label='Log law')
        y_visc = np.linspace(0.1, 10, 50)
        ax.semilogx(y_visc, y_visc, 'g--', linewidth=1.5, alpha=0.5, label=r'$U^+=y^+$')

    ax.set_xlabel(r'$y^+$', fontsize=14)
    ax.set_ylabel(r'$U^+$', fontsize=14)
    ax.set_title(f'Mean Velocity Profile - Smoothed (Re$_\\tau$ = {Re_tau:.0f})', fontsize=16)
    ax.legend(fontsize=10, loc='upper left')
    ax.set_xlim(1, Re_tau)
    ax.set_ylim(0, 25)
    ax.grid(True, alpha=0.3)

    fig.tight_layout()
    fig.savefig(output_dir / 'U_plus_profile_combined_smooth.png', dpi=150)
    plt.close(fig)

    # ==========================================================================
    # Figure 6: Smoothed Reynolds stresses combined - ALL WINDOWS
    # ==========================================================================
    fig, axes = plt.subplots(1, 3, figsize=(18, 6))

    stress_configs = [
        ('uu_plus', r"$\overline{u'u'}^+$", 'Streamwise Normal Stress', 1),
        ('vv_plus', r"$\overline{v'v'}^+$", 'Wall-Normal Normal Stress', 1),
        ('uv_plus', r"$-\overline{u'v'}^+$", 'Reynolds Shear Stress', -1),
    ]
    for ax, (var, ylabel, title, sign) in zip(axes, stress_configs):
        gt_vals = sign * gt_plus[var]
        ci_lo_key = f'{var}_ci_lo'
        ci_hi_key = f'{var}_ci_hi'
        if has_ci and ci_lo_key in gt_plus:
            plot_ci_band(ax, gt_plus['y_plus'], gt_plus[ci_lo_key],
                         gt_plus[ci_hi_key], sign=sign, color='k', zorder=1)
        ax.plot(gt_plus['y_plus'], gt_vals, 'k-', linewidth=2.5, label='DNS', zorder=10)

        for i, res in enumerate(all_results):
            piv_plus = res['piv_plus']
            label = res['window_label']
            c = colors[i % len(colors)]
            piv_vals = sign * piv_plus[var]
            ax.plot(piv_plus['y_plus'], piv_vals,
                    color=c, marker=markers[i % len(markers)],
                    markersize=4, alpha=0.7, linestyle='none',
                    label=f'PIV ({label})', zorder=5-i*0.1)

        ax.set_xlabel(r'$y^+$', fontsize=12)
        ax.set_ylabel(ylabel, fontsize=12)
        ax.set_title(title, fontsize=14)
        ax.legend(fontsize=9)
        ax.set_xscale('log')
        ax.set_xlim(1, Re_tau)
        ax.grid(True, alpha=0.3)

    fig.tight_layout()
    fig.savefig(output_dir / 'reynolds_stresses_combined_smooth.png', dpi=150)
    plt.close(fig)

    # ==========================================================================
    # Figure 7: Trace invariant (u'u' + v'v') - ALL WINDOWS
    # ==========================================================================
    fig, axes = plt.subplots(1, 2, figsize=(14, 6))

    # Compute ground truth trace
    gt_trace = gt_plus['uu_plus'] + gt_plus['vv_plus']

    # Left: Trace comparison
    ax = axes[0]
    ax.semilogx(gt_plus['y_plus'], gt_trace, 'k-', linewidth=2.5, label='DNS', zorder=10)
    for i, res in enumerate(all_results):
        piv_plus = res['piv_plus']
        label = res['window_label']
        piv_trace = piv_plus['uu_plus'] + piv_plus['vv_plus']
        ax.semilogx(piv_plus['y_plus'], piv_trace,
                    color=colors[i % len(colors)], marker=markers[i % len(markers)],
                    markersize=4, alpha=0.7, linestyle='none', label=f'PIV ({label})')
    ax.set_xlabel(r'$y^+$', fontsize=12)
    ax.set_ylabel(r"$\overline{u'u'}^+ + \overline{v'v'}^+$", fontsize=12)
    ax.set_title("Trace Invariant (rotation-invariant)", fontsize=14)
    ax.legend(fontsize=10)
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)

    # Right: Ratio of components (rotation indicator)
    ax = axes[1]
    gt_ratio = gt_plus['uu_plus'] / (gt_plus['vv_plus'] + 1e-10)
    ax.semilogx(gt_plus['y_plus'], gt_ratio, 'k-', linewidth=2.5, label='DNS', zorder=10)
    for i, res in enumerate(all_results):
        piv_plus = res['piv_plus']
        label = res['window_label']
        piv_ratio = piv_plus['uu_plus'] / (piv_plus['vv_plus'] + 1e-10)
        ax.semilogx(piv_plus['y_plus'], piv_ratio,
                    color=colors[i % len(colors)], marker=markers[i % len(markers)],
                    markersize=4, alpha=0.7, linestyle='none', label=f'PIV ({label})')
    ax.set_xlabel(r'$y^+$', fontsize=12)
    ax.set_ylabel(r"$\overline{u'u'}^+ / \overline{v'v'}^+$", fontsize=12)
    ax.set_title("Stress Ratio (rotation indicator)", fontsize=14)
    ax.legend(fontsize=10)
    ax.set_xlim(1, Re_tau)
    ax.set_ylim(0, 10)
    ax.grid(True, alpha=0.3)

    fig.suptitle("Rotation Diagnostic: If trace matches but ratio differs, rotation problem exists", fontsize=12, y=1.02)
    fig.tight_layout()
    fig.savefig(output_dir / 'trace_invariant_combined.png', dpi=150)
    plt.close(fig)

    # ==========================================================================
    # Figure 8: Residuals (PIV - Ref) vs y+ - ALL WINDOWS
    # ==========================================================================
    fig, axes = plt.subplots(2, 3, figsize=(18, 12))

    # Interpolate ground truth
    gt_interp_fn = {}
    for var in ['U_plus', 'V_plus', 'uu_plus', 'vv_plus', 'uv_plus']:
        gt_interp_fn[var] = interp1d(gt_plus['y_plus'], gt_plus[var], kind='linear',
                                     bounds_error=False, fill_value=np.nan)

    # Top row: velocity residuals
    vel_configs = [
        ('U_plus', r"$U^+_{\mathrm{PIV}} - U^+_{\mathrm{Ref}}$",
         'Mean Streamwise Velocity Residual', 1),
        ('V_plus', r"$V^+_{\mathrm{PIV}} - V^+_{\mathrm{Ref}}$",
         'Mean Wall-Normal Velocity Residual', 1),
    ]
    for ax, (var, ylabel, title, sign) in zip(axes[0, :2], vel_configs):
        ax.axhline(y=0, color='k', linestyle='-', linewidth=1, alpha=0.5)
        for i, res in enumerate(all_results):
            piv_plus = res['piv_plus']
            label = res['window_label']
            c = colors[i % len(colors)]
            gt_at_piv = gt_interp_fn[var](piv_plus['y_plus'])
            residual = sign * piv_plus[var] - sign * gt_at_piv
            ax.plot(piv_plus['y_plus'], residual,
                    color=c, marker=markers[i % len(markers)],
                    markersize=2, alpha=0.15, linestyle='none', zorder=2)
            yp_s, r_s = log_smooth(piv_plus['y_plus'], residual)
            ax.plot(yp_s, r_s, color=c, linewidth=2,
                    label=f'PIV ({label})', zorder=5-i*0.1)
        ax.set_xlabel(r'$y^+$', fontsize=12)
        ax.set_ylabel(ylabel, fontsize=12)
        ax.set_title(title, fontsize=14)
        ax.legend(fontsize=9)
        ax.set_xscale('log')
        ax.set_xlim(1, Re_tau)
        ax.grid(True, alpha=0.3)

    axes[0, 2].set_visible(False)  # Empty top-right panel

    # Bottom row: stress residuals
    stress_configs = [
        ('uu_plus', r"$\overline{u'u'}^+_{\mathrm{PIV}} - \overline{u'u'}^+_{\mathrm{Ref}}$",
         'Streamwise Normal Stress Residual', 1),
        ('vv_plus', r"$\overline{v'v'}^+_{\mathrm{PIV}} - \overline{v'v'}^+_{\mathrm{Ref}}$",
         'Wall-Normal Normal Stress Residual', 1),
        ('uv_plus', r"$-\overline{u'v'}^+_{\mathrm{PIV}} - (-\overline{u'v'}^+_{\mathrm{Ref}})$",
         'Shear Stress Residual', -1),
    ]
    for ax, (var, ylabel, title, sign) in zip(axes[1, :], stress_configs):
        ax.axhline(y=0, color='k', linestyle='-', linewidth=1, alpha=0.5)
        for i, res in enumerate(all_results):
            piv_plus = res['piv_plus']
            label = res['window_label']
            c = colors[i % len(colors)]
            gt_at_piv = gt_interp_fn[var](piv_plus['y_plus'])
            residual = sign * piv_plus[var] - sign * gt_at_piv
            ax.plot(piv_plus['y_plus'], residual,
                    color=c, marker=markers[i % len(markers)],
                    markersize=2, alpha=0.15, linestyle='none', zorder=2)
            yp_s, r_s = log_smooth(piv_plus['y_plus'], residual)
            ax.plot(yp_s, r_s, color=c, linewidth=2,
                    label=f'PIV ({label})', zorder=5-i*0.1)
        ax.set_xlabel(r'$y^+$', fontsize=12)
        ax.set_ylabel(ylabel, fontsize=12)
        ax.set_title(title, fontsize=14)
        ax.legend(fontsize=9)
        ax.set_xscale('log')
        ax.set_xlim(1, Re_tau)
        ax.grid(True, alpha=0.3)

    fig.tight_layout()
    fig.savefig(output_dir / 'residuals_combined.png', dpi=150)
    plt.close(fig)

    # ==========================================================================
    # Figure 9: Noise floor vs gradient correction decomposition - ALL WINDOWS
    # ==========================================================================
    fig, axes = plt.subplots(1, 3, figsize=(18, 6))

    # Left: Noise floor (v'v' residual) — all windows
    ax = axes[0]
    ax.axhline(y=0, color='k', linestyle='-', linewidth=1, alpha=0.5)
    for i, res in enumerate(all_results):
        piv_plus = res['piv_plus']
        label = res['window_label']
        c = colors[i % len(colors)]
        vv_res = piv_plus['vv_plus'] - gt_interp_fn['vv_plus'](piv_plus['y_plus'])
        ax.plot(piv_plus['y_plus'], vv_res,
                color=c, marker=markers[i % len(markers)],
                markersize=2, alpha=0.15, linestyle='none', zorder=2)
        yp_s, r_s = log_smooth(piv_plus['y_plus'], vv_res)
        ax.plot(yp_s, r_s, color=c, linewidth=2,
                label=f'PIV ({label})', zorder=5-i*0.1)
    ax.set_xlabel(r'$y^+$', fontsize=12)
    ax.set_ylabel(r"$\overline{v'v'}^+_{\mathrm{PIV}} - \overline{v'v'}^+_{\mathrm{Ref}}$", fontsize=12)
    ax.set_title('Noise Floor (isotropic)', fontsize=14)
    ax.legend(fontsize=9)
    ax.set_xscale('log')
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)

    # Middle: Gradient-only residual (u'u' - v'v') — all windows
    ax = axes[1]
    ax.axhline(y=0, color='k', linestyle='-', linewidth=1, alpha=0.5)
    for i, res in enumerate(all_results):
        piv_plus = res['piv_plus']
        label = res['window_label']
        c = colors[i % len(colors)]
        uu_res = piv_plus['uu_plus'] - gt_interp_fn['uu_plus'](piv_plus['y_plus'])
        vv_res = piv_plus['vv_plus'] - gt_interp_fn['vv_plus'](piv_plus['y_plus'])
        grad_only = uu_res - vv_res
        ax.plot(piv_plus['y_plus'], grad_only,
                color=c, marker=markers[i % len(markers)],
                markersize=2, alpha=0.15, linestyle='none', zorder=2)
        yp_s, r_s = log_smooth(piv_plus['y_plus'], grad_only)
        ax.plot(yp_s, r_s, color=c, linewidth=2,
                label=f'PIV ({label})', zorder=5-i*0.1)
    ax.set_xlabel(r'$y^+$', fontsize=12)
    ax.set_ylabel(r"Gradient-only residual$^+$", fontsize=12)
    ax.set_title(r"Gradient Correction Residual ($u'u' - v'v'$ removes noise)", fontsize=14)
    ax.legend(fontsize=9)
    ax.set_xscale('log')
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)

    # Right: All three overlaid for the finest window
    ax = axes[2]
    finest = all_results[-1]  # Last (finest) window
    piv_plus = finest['piv_plus']
    label = finest['window_label']
    uu_res = piv_plus['uu_plus'] - gt_interp_fn['uu_plus'](piv_plus['y_plus'])
    vv_res = piv_plus['vv_plus'] - gt_interp_fn['vv_plus'](piv_plus['y_plus'])
    grad_only = uu_res - vv_res

    ax.plot(piv_plus['y_plus'], uu_res, 'ro', markersize=2, alpha=0.1)
    yp_s, r_s = log_smooth(piv_plus['y_plus'], uu_res)
    ax.plot(yp_s, r_s, 'r-', linewidth=2, label=r"$u'u'$ residual (total)")

    ax.plot(piv_plus['y_plus'], vv_res, 'bo', markersize=2, alpha=0.1)
    yp_s, r_s = log_smooth(piv_plus['y_plus'], vv_res)
    ax.plot(yp_s, r_s, 'b-', linewidth=2, label=r"$v'v'$ residual (noise floor)")

    yp_s, r_s = log_smooth(piv_plus['y_plus'], grad_only)
    ax.plot(yp_s, r_s, 'g--', linewidth=2, label=r"$u'u' - v'v'$ residual (gradient only)")

    ax.axhline(y=0, color='k', linestyle='-', linewidth=1, alpha=0.5)
    ax.set_xlabel(r'$y^+$', fontsize=12)
    ax.set_ylabel(r"Residual$^+$", fontsize=12)
    ax.set_title(f'Decomposition ({label}): Total = Noise + Gradient', fontsize=14)
    ax.legend(fontsize=9)
    ax.set_xscale('log')
    ax.set_xlim(1, Re_tau)
    ax.grid(True, alpha=0.3)

    fig.tight_layout()
    fig.savefig(output_dir / 'noise_gradient_decomposition_combined.png', dpi=150)
    plt.close(fig)

    print(f"\nCombined plots saved to: {output_dir}")


def main_multi_run(mode='ensemble', run_indices=None, window_sizes=None, run_labels=None, gt_dir=None, base_dir=None, ensemble_dir=None, y_plus_offset=0.0, num_frames=1000, output_dir_override=None, show_fit_lines=False):
    """
    Main benchmark comparison function for multiple runs/window sizes.

    Parameters
    ----------
    mode : str
        'instantaneous' or 'ensemble'
    run_indices : list of int
        List of run indices (0-based) to process
    window_sizes : list of int
        Corresponding window sizes for labels (e.g., [16, 8, 6, 4])
    run_labels : list of str, optional
        Custom labels for output folders (e.g., ['run_1', 'run_2', 'run_3'])
    gt_dir : Path, optional
        Ground truth directory. Defaults to script_dir/ground_truth/ensemble_statistics
    base_dir : Path, optional
        Base directory containing PIV results. Defaults to window_validation folder.
    ensemble_dir : Path, optional
        Direct path to ensemble directory containing ensemble_result.mat and coordinates.mat.
        If provided, overrides base_dir for ensemble mode.
    y_plus_offset : float, optional
        Offset to add to y+ coordinates (for calibration correction)
    """
    # Paths
    script_dir = Path(__file__).parent
    if gt_dir is None:
        raise ValueError("gt_dir is required. Please provide the ground truth directory path.")
    gt_dir = Path(gt_dir)

    if mode == 'ensemble':
        if ensemble_dir is not None:
            ensemble_dir = Path(ensemble_dir)
            ensemble_path = ensemble_dir / 'ensemble_result.mat'
            coords_path = ensemble_dir / 'coordinates.mat'
        elif base_dir is not None:
            base_dir = Path(base_dir)
            ensemble_path = base_dir / f'calibrated_piv/{num_frames}/Cam1/ensemble/ensemble_result.mat'
            coords_path = base_dir / f'calibrated_piv/{num_frames}/Cam1/ensemble/coordinates.mat'
        else:
            raise ValueError("Either ensemble_dir or base_dir must be provided for ensemble mode.")
        output_dir = output_dir_override or (script_dir / 'benchmark_results_ensemble')
    else:
        if base_dir is None:
            raise ValueError("base_dir is required for instantaneous mode.")
        base_dir = Path(base_dir)
        stats_path = base_dir / f'statistics/{num_frames}/Cam1/instantaneous/mean_stats/mean_stats.mat'
        output_dir = output_dir_override or (script_dir / 'benchmark_results')

    print("=" * 70)
    print(f"PIV BENCHMARK COMPARISON ({mode.upper()}) - MULTI-RUN")
    print("=" * 70)
    print(f"Processing runs: {run_indices}")
    print(f"Window sizes: {window_sizes}")

    # Load common data - auto-detect file names
    print("\n[1] Loading wall units...")
    wall_units_file = gt_dir / 'wall_units.mat'
    if not wall_units_file.exists():
        wall_units_file = gt_dir / 'diagnostics.mat'
    if not wall_units_file.exists():
        wall_units_file = gt_dir / 'direct_stats.mat'
    wall_units = load_wall_units(wall_units_file)
    print(f"  u_tau = {wall_units['u_tau']:.4f} mm/s")
    print(f"  nu = {wall_units['nu']:.4f} mm²/s")
    print(f"  delta_nu = {wall_units['delta_nu']:.4f} mm")
    print(f"  Re_tau = {wall_units['Re_tau']:.0f}")

    print("\n[2] Loading ground truth...")
    profiles_file = gt_dir / 'profiles.mat'
    if not profiles_file.exists():
        profiles_file = gt_dir / 'ensemble_statistics_full.mat'
    if not profiles_file.exists():
        profiles_file = gt_dir / 'direct_stats.mat'
    gt = load_ground_truth(profiles_file, wall_units_path=wall_units_file)
    print(f"  y+ range: {gt['y_plus'].min():.1f} to {gt['y_plus'].max():.1f}")

    # Ground truth in wall units
    gt_plus = {
        'y_plus': gt['y_plus'],
        'U_plus': gt['U_plus'],
        'V_plus': gt['V'] / wall_units['u_tau'],
        'uu_plus': gt['uu_plus'],
        'vv_plus': gt['vv_plus'],
        'uv_plus': gt['uv_plus'],
    }
    # Thread CI bounds through if available
    for ci_key in ['U_plus_ci_lo', 'U_plus_ci_hi', 'V_plus_ci_lo', 'V_plus_ci_hi',
                   'uu_plus_ci_lo', 'uu_plus_ci_hi', 'vv_plus_ci_lo', 'vv_plus_ci_hi',
                   'uv_plus_ci_lo', 'uv_plus_ci_hi']:
        if ci_key in gt:
            gt_plus[ci_key] = gt[ci_key]

    # Process each run
    all_results = []
    if run_labels is None:
        run_labels = [f'{ws}x{ws}' for ws in window_sizes]
    for i, (run_idx, win_size) in enumerate(zip(run_indices, window_sizes)):
        window_label = f'{win_size}x{win_size}'
        run_output_dir = output_dir / run_labels[i]

        print(f"\n{'='*70}")
        print(f"Processing Run {run_idx+1} (Window: {window_label})")
        print('='*70)

        try:
            if mode == 'ensemble':
                piv = load_ensemble_statistics(ensemble_path, coords_path, run_idx=run_idx)
            else:
                piv = load_piv_statistics(stats_path, run_idx=run_idx)

            print(f"  Grid size: {piv['ux'].shape}")
            print(f"  ux range: {np.nanmin(piv['ux'])*1000:.2f} to {np.nanmax(piv['ux'])*1000:.2f} mm/s")

            # Compute profiles
            piv_profiles = compute_piv_profiles(piv, x_exclude_vectors=4)
            print(f"  y range: {piv_profiles['y_mm'].min():.2f} to {piv_profiles['y_mm'].max():.2f} mm")

            # Convert to wall units
            y_offset_mm = -piv_profiles['y_mm'].min()
            piv_plus = convert_to_wall_units(piv_profiles, wall_units, y_offset_mm=y_offset_mm)
            piv_plus['y_plus'] = piv_plus['y_plus'] + 1.0  # shift y+ by +1
            # Apply additional y+ offset if specified
            if y_plus_offset != 0.0:
                piv_plus['y_plus'] = piv_plus['y_plus'] + y_plus_offset
                print(f"  y+ offset applied: {y_plus_offset:+.1f}")
            print(f"  y+ range: {piv_plus['y_plus'].min():.1f} to {piv_plus['y_plus'].max():.1f} (y+ +1 applied)")

            # Compute errors
            errors = compute_errors(piv_plus, gt_plus, y_plus_range=(10, 500))

            # Print error summary
            if 'U_plus' in errors:
                print(f"  U+ R² = {errors['U_plus']['r2']:.4f}, RMS = {errors['U_plus']['rms_rel']:.1f}%")
            if 'uu_plus' in errors:
                print(f"  uu+ R² = {errors['uu_plus']['r2']:.4f}")

            # Generate individual plots
            plot_comparison(piv_plus, gt_plus, wall_units, errors, run_output_dir,
                          window_label=window_label, show_fit_lines=show_fit_lines)
            plot_combined_stresses(piv_plus, gt_plus, wall_units, errors, run_output_dir,
                                  window_label=window_label)

            # Store for combined plot
            all_results.append({
                'piv_plus': piv_plus,
                'errors': errors,
                'window_label': window_label,
                'window_size': win_size,
            })

        except Exception as e:
            print(f"  ERROR processing run {run_idx}: {e}")
            import traceback
            traceback.print_exc()

    # Generate combined plots if we have multiple results
    if len(all_results) > 1:
        print(f"\n{'='*70}")
        print("Generating combined comparison plots...")
        print('='*70)
        plot_combined_comparison(all_results, gt_plus, wall_units, output_dir,
                                show_fit_lines=show_fit_lines)

    # Print final summary
    print("\n" + "=" * 70)
    print("BENCHMARK SUMMARY")
    print("=" * 70)
    print(f"\n{'Window':<12} {'U+ R²':<10} {'U+ RMS%':<10} {'uu+ R²':<10} {'vv+ R²':<10} {'-uv+ R²':<10}")
    print("-" * 62)
    for res in all_results:
        errs = res['errors']
        u_r2 = errs.get('U_plus', {}).get('r2', np.nan)
        u_rms = errs.get('U_plus', {}).get('rms_rel', np.nan)
        uu_r2 = errs.get('uu_plus', {}).get('r2', np.nan)
        vv_r2 = errs.get('vv_plus', {}).get('r2', np.nan)
        uv_r2 = errs.get('uv_plus', {}).get('r2', np.nan)
        print(f"{res['window_label']:<12} {u_r2:<10.4f} {u_rms:<10.1f} {uu_r2:<10.4f} {vv_r2:<10.4f} {uv_r2:<10.4f}")

    print("\n" + "=" * 70)
    print("BENCHMARK COMPLETE")
    print("=" * 70)


if __name__ == '__main__':
    import argparse
    parser = argparse.ArgumentParser(description='PIV Benchmark Comparison')
    parser.add_argument('--mode', '-m', choices=['instantaneous', 'ensemble'],
                        default='instantaneous', help='PIV mode (default: instantaneous)')
    parser.add_argument('--runs', '-r', type=str, default=None,
                        help='Comma-separated run indices (0-based), e.g., "0,1,2"')
    parser.add_argument('--windows', '-w', type=str, default=None,
                        help='Comma-separated window sizes for labels, e.g., "32,8,8"')
    parser.add_argument('--labels', '-l', type=str, default=None,
                        help='Comma-separated output folder labels, e.g., "run_1,run_2,run_3"')
    parser.add_argument('--gt-dir', '-g', type=str, required=True,
                        help='Ground truth directory path (required)')
    parser.add_argument('--base-dir', '-b', type=str, default=None,
                        help='Base directory containing PIV results')
    parser.add_argument('--ensemble-dir', '-e', type=str, default=None,
                        help='Direct path to ensemble directory containing ensemble_result.mat and coordinates.mat')
    parser.add_argument('--y-plus-offset', '-y', type=float, default=0.0,
                        help='Offset to add to y+ coordinates (calibration correction)')
    parser.add_argument('--num-frames', '-n', type=int, default=1000,
                        help='Frame count subdirectory in paths (default: 1000)')
    parser.add_argument('--output-dir', '-o', type=str, default=None,
                        help='Custom output directory for results')
    parser.add_argument('--show-fit-lines', action='store_true', default=False,
                        help='Show log-law and viscous sublayer reference lines on U+ plots')
    args = parser.parse_args()

    gt_dir = Path(args.gt_dir)
    base_dir = Path(args.base_dir) if args.base_dir else None
    ensemble_dir = Path(args.ensemble_dir) if args.ensemble_dir else None
    output_dir_override = Path(args.output_dir) if args.output_dir else None

    if args.runs and args.windows:
        run_indices = [int(r) for r in args.runs.split(',')]
        window_sizes = [int(w) for w in args.windows.split(',')]
        run_labels = args.labels.split(',') if args.labels else None
        main_multi_run(mode=args.mode, run_indices=run_indices, window_sizes=window_sizes,
                       run_labels=run_labels, gt_dir=gt_dir, base_dir=base_dir,
                       ensemble_dir=ensemble_dir, y_plus_offset=args.y_plus_offset,
                       num_frames=args.num_frames, output_dir_override=output_dir_override,
                       show_fit_lines=args.show_fit_lines)
    else:
        main(mode=args.mode, gt_dir=gt_dir, base_dir=base_dir, ensemble_dir=ensemble_dir,
             num_frames=args.num_frames, output_dir_override=output_dir_override,
             show_fit_lines=args.show_fit_lines)