Add extraction utilities and dataset notes

data/README.md

@@ -0,0 +1,44 @@
+# Extended 3D Dataset — NeurIPS Closure Challenge additions
+
+Three 3D cases added to extend the closure challenge beyond the existing 2D set:
+
+| Folder | Case | Source | Required metrics |
+|--------|------|--------|------------------|
+| `ERCOFTAC_AhmedBody25/` | Ahmed Body 25° slant | ERCOFTAC case082 (Lienhart-Becker-Stoots 2003) | LDA velocity + Reynolds stresses on canonical x-z and y-z planes; rear surface Cp |
+| `NASA_FaithHill/` | Faith Hill 3-D smooth-body separation | NASA TMR (Bell et al. 2012) | PIV centerline U/V/W + Reynolds stresses; PSP centerline Cp; FISF surface Cf |
+| `ERCOFTAC_WingBodyJunction/` | Wing-body junction (NACA0020) | ERCOFTAC kbwiki DNS 1-6 (Bassi et al. 2023) | 10 symmetry-plane profiles upstream of root; bottom-wall + wing-root Cp lines |
+
+## Per-case layout
+```
+<CASE>/
+├── README.md                     case description, refs, submission format
+├── 0/, <converged>/, constant/,
+│   system/, postProcessing/      OpenFOAM case (rsync from OF_Baseline_Cases)
+├── baseline_komegasst/           k-ω SST RANS extracted at experimental locations (.csv)
+├── highfidelity/                 LDA / PIV / DNS reference data (.csv + raw .dat where applicable)
+└── plots/
+    ├── plot_profiles.py          set MODEL_DIR env var to overlay submitted model
+    └── *.pdf                     pre-rendered baseline-vs-experiment figures
+```
+
+## Tools at this level
+- `commented_dat_to_csv.py` — converts simple `#`-commented headed .dat files (Ahmed format) to flat CSV
+- `faith_hill_to_csv.py` — Faith Hill ingester; merges 14 single-scalar Tecplot POINT files per PIV dataset into one CSV; converts PSP and FISF too
+- `extract_wbj_surface_lines.py` — Python+vtk script that reads the WingBody surface `.pvtu+_NNNN.vtu` partitioned files and extracts bottom-wall centerline (z/T=0) and wing-root chord (y/T~0.05) Cp strips
+
+Re-run any of these by passing the source dir/file as arg.
+
+## Cases skipped or excluded
+- **Ahmed Body 35°**: 35° configuration data is in the same archive but excluded from this packaging — only the canonical 25° case (the famous one bracketing the critical 30° angle) is shipped.
+- **Faith Hill Cobra probe**: 4-hole probe with 40° acceptance cone — cannot measure inside reverse-flow regions. Including it would mislead participants. PIV is the velocity reference; Cobra is intentionally not provided.
+- **DNS 1-6 volume data**: 60–70 GB per scalar field (averaged_pressure, averaged_velocity_{x,y,z}, Reynolds_stress_{xx,xy,...,zz}, Taylor/Kolmogorov scales). Far too large to ship. The 10 pre-curated profile CSVs + 2 surface line CSVs (~5 MB total) are the curated equivalent.
+
+## Decisions log (2026-04-29)
+- Case naming: mixed prefixes — `NASA_FaithHill` (NASA TMR), `ERCOFTAC_AhmedBody25` and `ERCOFTAC_WingBodyJunction` (ERCOFTAC sources). Reflects source authority.
+- Faith Hill OF: case is non-dimensional (U_inlet=1.0); sampled p maps to Cp directly. Documented in case README.
+- Wing-body 5000/ extra fields (`Pk, PkDelta, Prodk, Rall, nutSwitch`) kept as-is (matches "keep as is" preference).
+- Wing-body surface data: ship BOTH the extracted CSV centerline lines (primary) AND the raw partitioned `.pvtu+_NNNN.vtu` archives in `highfidelity/raw_surface/` (~298 MB) for full self-containment.
+- Wing-body OF: WBJ provides constant/system/postProcessing/log; **time dirs 0 and 5000 are taken from `revised_inflow/`** (Inlet pressure changed from `zeroGradient` to `fixedValue uniform 0` — better convergence). 90+14 Windows `:Zone.Identifier` files skipped on copy.
+
+## TODO
+- `baseline_komegasst/` content per case — needs OpenFOAM post-hoc sampling at experimental locations. See `*/run_baseline_extraction.sh` (per-case script).

data/README_2D_cases.md

@@ -0,0 +1,42 @@
+# Extended 2D Dataset — NeurIPS Closure Challenge additions
+
+Three new 2D cases added to the closure challenge from the **NASA TMR Collaborative Testing Challenge 2022** ([turb-prs2022](https://tmbwg.github.io/turbmodels/turb-prs2022.html)):
+
+| Folder | Case | Required metrics |
+|--------|------|------------------|
+| `NASA_2DZP/`  | 2D Zero-Pressure-Gradient flat plate    | Cf(x); u⁺(log y⁺) at x=0.97 — vs theory |
+| `NASA_ASJ/`   | Axisymmetric Subsonic Jet (M_jet ≈ 0.5) | u/Uj along axis; u/Uj and u'v'/Uj² at 5 stations — vs Bridges & Wernet PIV |
+| `NASA_2DN00/` | NACA 0012 airfoil, α = 10/15/17/18°     | CL(α), CD vs CL, Cp(x/c), Cf(x/c upper) — vs Ladson + Gregory |
+
+## Per-case layout
+```
+NASA_<CASE>/
+├── README.md                  Case description, refs, submission format
+├── baseline_komegasst/        k-ω SST RANS baseline (.dat NASA Tecplot + .csv flat)
+│   └── README.md
+├── highfidelity/              Theory / experiment / CFD-cross-check references
+│   └── README.md
+└── plots/
+    ├── plot_profiles.py       Adapt: set MODEL_DIR env var to overlay your model
+    └── *.pdf                  Pre-rendered baseline-vs-experiment plots
+```
+
+## Tools at this level
+- `dat_to_csv.py` — converts NASA Tecplot zone-format `.dat` files to flat CSV (single `zone` column to preserve zone identity). Re-run after editing data:
+  ```
+  python dat_to_csv.py NASA_2DZP/baseline_komegasst NASA_2DZP/highfidelity \
+                        NASA_ASJ/baseline_komegasst NASA_ASJ/highfidelity \
+                        NASA_2DN00/baseline_komegasst NASA_2DN00/highfidelity
+  ```
+
+## Provenance
+All `.dat` files copied from `OLD_NASA_CHALLENGE_SUBMISSION/finalModel/` (a baseline RANS submission to the 2022 NASA TMR Collaborative Testing Challenge), folders `baselineResults/` (k-ω SST baseline) and `NASAResults/` (theory / experiment) — see [plotFinal.py:10-14](OLD_NASA_CHALLENGE_SUBMISSION/finalModel/plotFinal.py#L10-L14) for the original mapping. The corresponding OpenFOAM cases live under `OLD_SETUPS/{00_2DZP, 02_ASJ, 04_2DN00}/00Baseline/`.
+
+## TODO — full OpenFOAM `00Baseline_Data/` per case
+The integral profiles + plots are complete. To match the structure of the existing 4 challenge cases (`ML4Fluids_2D_Dataset/{CBFS, NASA_2DWMH, PH_Breuer, Parm_PH_29}/00Baseline_Data/`), each new case still needs the converged k-ω SST OpenFOAM run packaged. Candidate sources:
+
+| Case | OpenFOAM source | Notes |
+|------|-----------------|-------|
+| 2DZP  | `OLD_SETUPS/00_2DZP/00Baseline/simpleFoam/` | `kOmegaSST`, converged at t=10000 |
+| ASJ   | `OLD_SETUPS/02_ASJ/BaselineRenzhi/Case/` or `00Baseline/CFDDomain/compressibleTransient/` | both `kOmegaSST`; pick one |
+| 2DN00 | `OLD_SETUPS/04_2DN00/00Baseline/rhoSimpleFoam_Final/Case2/{10,15,17,18}_deg/` | only initial state — needs to be run, OR use the per-AoA cases under `OLD_NASA_CHALLENGE_SUBMISSION/finalModel/04_2DN00/` (latter were run with `propagationClassifierkOmegaSST` augmented model, not pure baseline) |

data/commented_dat_to_csv.py

@@ -0,0 +1,106 @@
+"""Convert simple commented-header .dat files (Ahmed Body, Faith Hill PIV/PSP/FISF
+formats) to flat CSV.
+
+Different from the NASA Tecplot zone parser (Extended_2D_Dataset/dat_to_csv.py).
+These .dat files are:
+    - Header: any number of '#'-prefixed lines
+    - The last '#' line contains the column names, possibly with units in brackets
+    - Data: whitespace-separated floats, one row per measurement point
+
+Usage:
+    python commented_dat_to_csv.py <dir_or_file> [<dir_or_file> ...]
+"""
+
+import sys
+import os
+import re
+import glob
+import numpy as np
+import pandas as pd
+
+
+# Match e.g. "x[mm]" or "U[m/s]" -> capture name and unit
+_NAMED_UNIT_RE = re.compile(r'(\S+?)\[([^\]]+)\]')
+
+
+def _parse_columns_from_header_line(line):
+    """Parse a header line like '# x[mm] y[mm] z[mm] U[m/s] ...' -> list of column names.
+
+    Spatial coords gain a unit suffix ("x_mm", "y_in", "z_m") so downstream tooling
+    can map experiment coords to the OF mesh scale unambiguously. Non-spatial
+    columns retain their original names.
+    """
+    s = line.lstrip('#').strip()
+    out = []
+    for tok in s.split():
+        m = _NAMED_UNIT_RE.match(tok)
+        if not m:
+            out.append(tok)
+            continue
+        name, unit = m.group(1), m.group(2).strip()
+        # only attach unit suffix to spatial coordinate columns
+        if name.lower() in ('x', 'y', 'z') and unit in ('mm', 'm', 'in', 'cm'):
+            out.append(f'{name}_{unit}')
+        else:
+            out.append(name)
+    return out
+
+
+def read_commented_dat(path):
+    """Read a commented-header .dat file -> pandas DataFrame.
+
+    The last header line beginning with '#' is treated as the column-name line.
+    All other '#' lines are skipped. Data rows are whitespace-separated floats.
+    """
+    with open(path) as f:
+        lines = f.readlines()
+
+    last_header_idx = -1
+    for i, line in enumerate(lines):
+        if line.lstrip().startswith('#'):
+            last_header_idx = i
+        else:
+            if line.strip():
+                break
+
+    if last_header_idx < 0:
+        raise ValueError(f'{path}: no commented header found')
+
+    columns = _parse_columns_from_header_line(lines[last_header_idx])
+    data = np.genfromtxt(path, comments='#')
+    if data.ndim == 1:
+        data = data.reshape(1, -1)
+
+    if data.shape[1] != len(columns):
+        # Some files have variables labeled with extra '*' or unusual chars;
+        # fall back to generic col_N names if mismatch
+        columns = [f'col_{i}' for i in range(data.shape[1])]
+
+    return pd.DataFrame(data, columns=columns)
+
+
+def convert_path(path):
+    if os.path.isdir(path):
+        for dat in sorted(glob.glob(os.path.join(path, '*.dat'))):
+            convert_path(dat)
+        return
+    if not path.lower().endswith('.dat'):
+        return
+    try:
+        df = read_commented_dat(path)
+    except Exception as exc:
+        print(f'  FAILED {path}: {exc}')
+        return
+    csv_path = path[:-4] + '.csv'
+    df.to_csv(csv_path, index=False)
+    print(f'  {os.path.basename(path)} -> {os.path.basename(csv_path)}'
+          f'  ({len(df)} rows, {len(df.columns)} cols)')
+
+
+if __name__ == '__main__':
+    if len(sys.argv) < 2:
+        print(__doc__)
+        sys.exit(1)
+    for arg in sys.argv[1:]:
+        print(f'\n[{arg}]')
+        convert_path(arg)

data/dat_to_csv.py

@@ -0,0 +1,109 @@
+"""Convert NASA Tecplot-zone .dat files to flat CSV.
+
+Each .dat file in a given directory is read via the same parser used in
+the original NASA challenge submission (readNasaZoneFile), then flattened
+to a single CSV with one row per (zone, sample) and a `zone` column to
+preserve the multi-zone structure.
+
+Usage:
+    python dat_to_csv.py <dir1> [<dir2> ...]
+"""
+
+import sys
+import os
+import glob
+import numpy as np
+import pandas as pd
+
+
+def _text_in_line(line):
+    if line == '':
+        return False
+    return max(
+        [(ord(c) > 96) & (ord(c) < 101) | (ord(c) > 101) & (ord(c) < 123)
+         for c in line.lower()]
+    )
+
+
+def read_nasa_zone_file(path):
+    """Parse a NASA Tecplot-zone .dat file into a dict {zone: {var: array}}."""
+    with open(path) as f:
+        data = f.read()
+
+    data_lower = data.lower()
+
+    var_start = data_lower.find('variables')
+    var_end = var_start + data_lower[var_start:].find('\n')
+    var_line = data[var_start:var_end]
+    variables = var_line.split('"')[1::2]
+
+    zones = []
+    zone_inds = []
+    data_start_inds = []
+    find_data_start = False
+
+    if 'zone' not in data_lower:
+        zones.append('zone')
+        zone_inds.append(0)
+        find_data_start = True
+
+    lines = data.split('\n')
+    lower_lines = data_lower.split('\n')
+    for i, (line, lower) in enumerate(zip(lines, lower_lines)):
+        if 'zone t=' in lower or 'zone, t=' in lower:
+            zones.append(line.split('"')[1])
+            zone_inds.append(i)
+            find_data_start = True
+        if find_data_start and not _text_in_line(line):
+            data_start_inds.append(i)
+            find_data_start = False
+
+    zone_inds.append(i + 1)
+
+    out = {}
+    for i, zone in enumerate(zones):
+        buff = np.genfromtxt(
+            path,
+            skip_header=data_start_inds[i],
+            max_rows=zone_inds[i + 1] - data_start_inds[i],
+        )
+        if buff.ndim == 1:
+            buff = buff.reshape(1, -1)
+        out[zone] = {variables[j]: buff[:, j] for j in range(len(variables))}
+    return out
+
+
+def dat_to_dataframe(path):
+    zones = read_nasa_zone_file(path)
+    frames = []
+    for zone_name, var_dict in zones.items():
+        df = pd.DataFrame(var_dict)
+        df.insert(0, 'zone', zone_name)
+        frames.append(df)
+    return pd.concat(frames, ignore_index=True)
+
+
+def convert_directory(directory):
+    dat_files = sorted(glob.glob(os.path.join(directory, '*.dat')))
+    if not dat_files:
+        print(f'  (no .dat files in {directory})')
+        return
+    for dat_path in dat_files:
+        try:
+            df = dat_to_dataframe(dat_path)
+        except Exception as exc:
+            print(f'  FAILED {dat_path}: {exc}')
+            continue
+        csv_path = dat_path[:-4] + '.csv'
+        df.to_csv(csv_path, index=False)
+        print(f'  {os.path.basename(dat_path)} -> {os.path.basename(csv_path)}'
+              f'  ({len(df)} rows, {len(df.columns)} cols)')
+
+
+if __name__ == '__main__':
+    if len(sys.argv) < 2:
+        print(__doc__)
+        sys.exit(1)
+    for d in sys.argv[1:]:
+        print(f'\n[{d}]')
+        convert_directory(d)

data/extract_baseline_from_vtk.py

@@ -0,0 +1,317 @@
+"""Extract baseline RANS at experimental locations using foamToVTK + Python+vtk.
+
+Usage (per-case): the per-case shell script `run_baseline_extraction.sh` invokes
+this module after producing a VTK/<case>_<time>.vtk file via foamToVTK.
+
+Approach: the VTK volume is a vtkUnstructuredGrid containing U, k, omega, p, nut.
+For each experimental measurement location, we use vtkProbeFilter with a
+vtkPolyData of the experiment points to interpolate the volume fields onto
+those exact (x,y,z). Output: one CSV per highfidelity .csv with the same
+(x, y, z) coords replaced by sampled (U, V, W, k, omega, p, nut).
+
+Reynolds stresses are computed from Boussinesq:
+    R_ij = (2/3) k delta_ij  -  nut * (dU_i/dx_j + dU_j/dx_i)
+gradU is computed via vtkGradientFilter on the volume.
+"""
+
+import os
+import sys
+import glob
+import numpy as np
+import pandas as pd
+import vtk
+from vtk.util import numpy_support as ns
+
+
+def load_volume(vtk_path):
+    """Load a foamToVTK output (legacy .vtk or .vtu/.pvtu) -> vtkUnstructuredGrid."""
+    if vtk_path.endswith('.vtk'):
+        reader = vtk.vtkUnstructuredGridReader()
+    elif vtk_path.endswith('.vtu'):
+        reader = vtk.vtkXMLUnstructuredGridReader()
+    elif vtk_path.endswith('.pvtu'):
+        reader = vtk.vtkXMLPUnstructuredGridReader()
+    else:
+        raise ValueError(f'Unknown VTK format: {vtk_path}')
+    reader.SetFileName(vtk_path)
+    reader.Update()
+    return reader.GetOutput()
+
+
+def add_grad_U(grid):
+    """Compute gradU via vtkGradientFilter and attach as point data."""
+    grad = vtk.vtkGradientFilter()
+    grad.SetInputData(grid)
+    grad.SetInputScalars(grid.FIELD_ASSOCIATION_POINTS, 'U')
+    grad.SetResultArrayName('gradU')
+    grad.Update()
+    return grad.GetOutput()
+
+
+def probe_at_points(volume, points_xyz):
+    """Interpolate volume fields onto given (N,3) point cloud.
+    Points that fall outside the volume mesh are marked NaN (not 0) so plots
+    can mask missing data instead of treating zeros as real values."""
+    pts = vtk.vtkPoints()
+    pts.SetData(ns.numpy_to_vtk(np.ascontiguousarray(points_xyz, dtype=np.float64)))
+    poly = vtk.vtkPolyData()
+    poly.SetPoints(pts)
+
+    probe = vtk.vtkProbeFilter()
+    probe.SetSourceData(volume)
+    probe.SetInputData(poly)
+    probe.SetValidPointMaskArrayName('vtkValidPointMask')
+    probe.Update()
+    out = probe.GetOutput()
+
+    pdata = out.GetPointData()
+    valid_arr = pdata.GetArray('vtkValidPointMask')
+    valid = ns.vtk_to_numpy(valid_arr).astype(bool) if valid_arr else np.ones(len(points_xyz), bool)
+    n_invalid = int((~valid).sum())
+    if n_invalid:
+        print(f'    [probe] {n_invalid}/{len(valid)} query points outside mesh -> NaN')
+
+    fields = {}
+    for i in range(pdata.GetNumberOfArrays()):
+        name = pdata.GetArrayName(i)
+        if name == 'vtkValidPointMask':
+            continue
+        arr = ns.vtk_to_numpy(pdata.GetArray(i)).astype(np.float64)
+        if arr.ndim == 1:
+            arr[~valid] = np.nan
+        else:
+            arr[~valid, :] = np.nan
+        fields[name] = arr
+    return fields
+
+
+def reynolds_from_boussinesq(U, gradU_flat, k, nut):
+    """gradU_flat shape (N, 9): [du/dx du/dy du/dz dv/dx ... dw/dz]
+    Returns dict with R_xx, R_yy, R_zz, R_xy, R_xz, R_yz."""
+    g = gradU_flat.reshape(-1, 3, 3)
+    S = 0.5 * (g + g.transpose(0, 2, 1))
+    R = np.zeros_like(S)
+    for i in range(3):
+        R[:, i, i] = (2.0 / 3.0) * k
+    R = R - 2.0 * nut[:, None, None] * S
+    return {
+        'R_xx': R[:, 0, 0], 'R_yy': R[:, 1, 1], 'R_zz': R[:, 2, 2],
+        'R_xy': R[:, 0, 1], 'R_xz': R[:, 0, 2], 'R_yz': R[:, 1, 2],
+    }
+
+
+def main():
+    if len(sys.argv) < 4:
+        print("Usage: extract_baseline_from_vtk.py <vtk_volume> <highfidelity_dir> <output_dir>")
+        sys.exit(1)
+    vtk_path, hf_dir, out_dir = sys.argv[1:4]
+
+    print(f'[load] {vtk_path}')
+    grid = load_volume(vtk_path)
+    print(f'[grad] computing gradU')
+    grid = add_grad_U(grid)
+
+    os.makedirs(out_dir, exist_ok=True)
+
+    import re
+
+    # Per-case length scale: divide experiment coords by H_NORM to map into
+    # a non-dimensional OF mesh. Set via env var FH_H_NORM (default 1.0 = no rescale).
+    H_NORM = float(os.environ.get('H_NORM', '1.0'))
+    if H_NORM != 1.0:
+        print(f'[H_NORM={H_NORM} m -> dividing experiment coords by this length]')
+
+    for csv_in in sorted(glob.glob(os.path.join(hf_dir, '*.csv'))):
+        df = pd.read_csv(csv_in)
+        bn = os.path.basename(csv_in)
+
+        # Special-case Faith Hill PIV centerline: 2D plane data (x_mm, y_mm),
+        # implicit z=0 (centerline). Coord remap: (x_mm, y_mm)/h_mm -> OF (x, y), z=0.
+        if 'PIV_centerline' in bn:
+            x_mm = df['x_mm'].values
+            y_mm = df['y_mm'].values
+            # convert mm -> m -> divide by H_NORM
+            xyz = np.column_stack([x_mm * 1e-3 / H_NORM,
+                                    y_mm * 1e-3 / H_NORM,
+                                    np.zeros(len(df))])
+            print(f'  [Faith Hill PIV] {bn}')
+            fields = probe_at_points(grid, xyz)
+            out = pd.DataFrame({'x_mm': x_mm, 'y_mm': y_mm})
+            if 'U' in fields:
+                U = fields['U'].reshape(-1, 3)
+                out['U_mean'] = U[:, 0]; out['V_mean'] = U[:, 1]; out['W_mean'] = U[:, 2]
+            for f in ['k', 'omega', 'p', 'nut']:
+                if f in fields:
+                    out[f] = fields[f]
+            if all(f in fields for f in ['U', 'k', 'nut', 'gradU']):
+                stresses = reynolds_from_boussinesq(
+                    fields['U'].reshape(-1, 3), fields['gradU'],
+                    fields['k'], fields['nut'])
+                for k, v in stresses.items():
+                    out[k] = v
+            out.to_csv(os.path.join(out_dir, bn), index=False)
+            print(f'  {bn:40s} -> {bn} ({len(out)} rows)')
+            continue
+
+        # Special-case Faith Hill PSP centerline: 1D, x_in only. z=0 (sym).
+        # The wall follows a cosine bump h(r)=3*cos(pi*r/9)+3 [in] for |r|<=9 in.
+        # Probe just above the wall surface (y_wall + epsilon).
+        if 'PSP_centerline' in bn:
+            x_in = df['x_in'].values
+            # bump height in inches at each x (centerline so r=|x|)
+            r = np.abs(x_in)
+            y_in_wall = np.where(r <= 9.0, 3.0 * np.cos(np.pi * r / 9.0) + 3.0, 0.0)
+            # convert wall coord to OF mesh frame, add small offset
+            y_offset_OF = 0.005  # ~0.5% of hill in non-dim units
+            xyz = np.column_stack([
+                x_in * 0.0254 / H_NORM,
+                y_in_wall * 0.0254 / H_NORM + y_offset_OF,
+                np.zeros(len(df))
+            ])
+            print(f'  [Faith Hill PSP, bump-aware] {bn}')
+            fields = probe_at_points(grid, xyz)
+            out = pd.DataFrame({'x_in': x_in})
+            if 'p' in fields:
+                out['p'] = fields['p']
+                # Cp = (p - p_inf) / (0.5 * U_inf^2). For non-dim case U_inf=1 -> Cp = 2*p (since rho=1).
+                out['Cp'] = 2.0 * fields['p']
+            out.to_csv(os.path.join(out_dir, bn), index=False)
+            print(f'  {bn:40s} -> {bn} ({len(out)} rows)')
+            continue
+
+        # Special-case Faith Hill FISF surface: (X, Y, Z) where Y=spanwise -> OF z, Z=wallnormal -> OF y.
+        if 'FISF' in bn:
+            X = df['X'].values
+            Yspan = df['Y'].values
+            Znorm = df['Z'].values
+            xyz = np.column_stack([X * 0.0254 / H_NORM,
+                                    Znorm * 0.0254 / H_NORM,  # FISF Z -> OF y
+                                    Yspan * 0.0254 / H_NORM])  # FISF Y -> OF z
+            print(f'  [Faith Hill FISF (Y/Z swap)] {bn}')
+            fields = probe_at_points(grid, xyz)
+            out = pd.DataFrame({'X': X, 'Y': Yspan, 'Z': Znorm})
+            if 'U' in fields:
+                U = fields['U'].reshape(-1, 3)
+                out['U'] = U[:, 0]; out['V'] = U[:, 1]; out['W'] = U[:, 2]
+            for f in ['k', 'omega', 'p', 'nut']:
+                if f in fields:
+                    out[f] = fields[f]
+            out.to_csv(os.path.join(out_dir, bn), index=False)
+            print(f'  {bn:40s} -> {bn} ({len(out)} rows)')
+            continue
+
+        # Special-case WingBody profile_midplane files: x station encoded in filename,
+        # z=0 (symmetry plane), y varies. Columns: y, u, v, Re_xx, ..., k.
+        prof_match = re.match(r'profile_midplane_([-+]?\d*\.?\d+)\.csv$',
+                              os.path.basename(csv_in))
+        if prof_match:
+            T = 0.0717  # WingBody DNS thickness scale
+            x_over_T = float(prof_match.group(1))
+            xyz = np.column_stack([
+                np.full(len(df), x_over_T * T),
+                df['y'].values * T,
+                np.zeros(len(df)),
+            ])
+            print(f'  [profile_midplane x/T={x_over_T}] {os.path.basename(csv_in)}')
+            fields = probe_at_points(grid, xyz)
+            out = pd.DataFrame({'y': df['y']})
+            if 'U' in fields:
+                U = fields['U'].reshape(-1, 3)
+                out['u'] = U[:, 0] / 27.0  # u_ref = 27 m/s
+                out['v'] = U[:, 1] / 27.0
+                out['w'] = U[:, 2] / 27.0
+            # WingBody DNS normalises by u_ref = 27 m/s
+            U_REF = 27.0
+            if 'k' in fields:
+                out['k'] = fields['k'] / U_REF**2
+            if 'omega' in fields:
+                out['omega'] = fields['omega']
+            if 'p' in fields:
+                out['p'] = fields['p']
+            if 'nut' in fields:
+                out['nut'] = fields['nut']
+            if all(f in fields for f in ['U', 'k', 'nut', 'gradU']):
+                stresses = reynolds_from_boussinesq(
+                    fields['U'].reshape(-1, 3), fields['gradU'],
+                    fields['k'], fields['nut'])
+                for kk, v in stresses.items():
+                    out[kk] = v / U_REF**2
+            out.to_csv(os.path.join(out_dir, os.path.basename(csv_in)), index=False)
+            print(f'  {os.path.basename(csv_in):40s} -> {os.path.basename(csv_in)} '
+                  f'({len(out)} rows)')
+            continue
+
+        cols = {c.lower(): c for c in df.columns}
+
+        # Resolve x / y / z column names (case-insensitive, allow common suffixes)
+        def _find(prefixes):
+            for p in prefixes:
+                if p in cols:
+                    return cols[p]
+            return None
+
+        xname = _find(['x', 'x_mm', 'x_in', 'x_over_t'])
+        yname = _find(['y', 'y_mm', 'y_in', 'y_over_t'])
+        zname = _find(['z', 'z_mm', 'z_in', 'z_over_t'])
+        # If z missing (2D plane data), assume z=0
+        z_implicit = zname is None
+        if not (xname and yname):
+            print(f'  skip {os.path.basename(csv_in)} - no x/y columns')
+            continue
+
+        # Detect coord scaling from magnitude + column-name hint.
+        x_vals = df[xname].abs().values
+        max_abs = x_vals.max() if len(x_vals) else 0
+        if 'mm' in xname.lower():
+            scale = 1e-3
+        elif 'in' in xname.lower():
+            scale = 0.0254
+        elif 'over_t' in xname.lower():
+            scale = 0.0717  # WingBody DNS reference thickness T = 71.7 mm
+        elif max_abs > 100:
+            scale = 1e-3   # likely mm
+        elif max_abs > 1.5:
+            scale = 0.0254 # likely inches
+        else:
+            scale = 1.0    # assume meters
+
+        if z_implicit:
+            xyz = np.column_stack([df[xname].values * scale,
+                                    df[yname].values * scale,
+                                    np.zeros(len(df))])
+        else:
+            xyz = df[[xname, yname, zname]].values * scale
+        # detect Wing-body surface CSVs (have x_over_T columns) and compute Cp from OF p
+        is_wbj_surface = ('over_t' in xname.lower())
+        print(f'  [scale={scale:g}, z_implicit={z_implicit}, wbj={is_wbj_surface}] {os.path.basename(csv_in)}')
+
+        fields = probe_at_points(grid, xyz)
+        cols_keep = {xname: df[xname], yname: df[yname]}
+        if not z_implicit:
+            cols_keep[zname] = df[zname]
+        out = pd.DataFrame(cols_keep)
+        if is_wbj_surface and 'p' in fields:
+            U_REF = 27.0
+            out['Cp'] = 2.0 * fields['p'] / U_REF**2
+        if 'U' in fields:
+            U = fields['U'].reshape(-1, 3)
+            out['U'] = U[:, 0]; out['V'] = U[:, 1]; out['W'] = U[:, 2]
+        for f in ['k', 'omega', 'p', 'nut']:
+            if f in fields:
+                out[f] = fields[f]
+        if all(f in fields for f in ['U', 'k', 'nut', 'gradU']):
+            stresses = reynolds_from_boussinesq(
+                fields['U'].reshape(-1, 3),
+                fields['gradU'],
+                fields['k'],
+                fields['nut'])
+            for k, v in stresses.items():
+                out[k] = v
+
+        out_csv = os.path.join(out_dir, os.path.basename(csv_in))
+        out.to_csv(out_csv, index=False)
+        print(f'  {os.path.basename(csv_in):40s} -> {out_csv} ({len(out)} rows, {len(out.columns)} cols)')
+
+
+if __name__ == '__main__':
+    main()

data/extract_wbj_surface_lines.py

@@ -0,0 +1,102 @@
+"""Extract centerline pressure lines from WingBody-junction surface .pvtu files.
+
+DNS 1-6 coordinate convention (per kbwiki):
+    x = streamwise (origin at airfoil root leading edge)
+    y = normalwise (wall-normal; bottom wall at y=0)
+    z = spanwise (symmetry at z=0; lateral boundaries at z/T = +-4)
+    T = airfoil thickness = 71.7 mm (reference length)
+
+Outputs (CSV with x/T, Cp = averaged_pressure / (rho_ref u_ref^2 / 2)):
+    bottom_wall_centerline.csv  : z = 0 strip on the bottom wall
+    wing_root_chord.csv         : y/T ~= 0.05 strip on the wing surface (near root)
+
+The averaged_pressure stored in the .vtu is dimensionless: p / p_ref. We map to a
+"reduced Cp" via:  Cp = (p/p_ref - 1) * (gamma * Ma^2)^{-1}  using gamma=1.4, Ma=0.078.
+
+Usage: python extract_wbj_surface_lines.py
+"""
+
+import os
+import pathlib
+import sys
+import numpy as np
+import pandas as pd
+import vtk
+from vtk.util import numpy_support as ns
+
+T = 1.0  # work in normalised x/T (data is already normalised in the DNS, so keep T=1)
+Z_TOL = 0.01  # strip half-width in z/T
+Y_TARGET = 0.05  # wing extraction height (near root)
+Y_TOL = 0.01
+
+GAMMA = 1.4
+MACH = 0.078
+
+DST = os.environ.get('WBJ_HIGHFIDELITY_DIR',
+                     str(pathlib.Path(__file__).parent / 'ERCOFTAC_WingBodyJunction' / 'highfidelity'))
+RAW = os.path.join(DST, 'raw_surface')
+
+
+def load_pvtu(path):
+    reader = vtk.vtkXMLPUnstructuredGridReader()
+    reader.SetFileName(path)
+    reader.Update()
+    grid = reader.GetOutput()
+    pts = ns.vtk_to_numpy(grid.GetPoints().GetData())  # shape (N, 3)
+    pdata = grid.GetPointData()
+    arr_names = [pdata.GetArrayName(i) for i in range(pdata.GetNumberOfArrays())]
+    if 'averaged_pressure' not in arr_names:
+        raise RuntimeError(f'No averaged_pressure in {path}: have {arr_names}')
+    p = ns.vtk_to_numpy(pdata.GetArray('averaged_pressure'))
+    return pts, p
+
+
+def p_to_cp(p_over_pref):
+    """Convert dimensionless p/p_ref to a Cp-like coefficient.
+    For low Mach, Cp = (p - p_ref) / (0.5 rho_ref u_ref^2). Using p = (rho_ref/gamma) * (p/p_ref) * gamma:
+    Equivalently, (p/p_ref - 1) / (0.5 gamma Ma^2).  At Ma=0.078, denom ~ 0.00426.
+    """
+    return (p_over_pref - 1.0) / (0.5 * GAMMA * MACH**2)
+
+
+def extract_strip(pts, p, axis_to_filter, target, tol):
+    mask = np.abs(pts[:, axis_to_filter] - target) < tol
+    return pts[mask], p[mask]
+
+
+def main():
+    # --- bottom wall: z=0 strip ---
+    pts, p = load_pvtu(os.path.join(RAW, 'bottom_wall_averaged_pressure.pvtu'))
+    sub_pts, sub_p = extract_strip(pts, p, axis_to_filter=2, target=0.0, tol=Z_TOL)
+    cp = p_to_cp(sub_p)
+    df = pd.DataFrame({
+        'x_over_T': sub_pts[:, 0] / T,
+        'y_over_T': sub_pts[:, 1] / T,
+        'z_over_T': sub_pts[:, 2] / T,
+        'p_over_pref': sub_p,
+        'Cp': cp,
+    }).sort_values('x_over_T').reset_index(drop=True)
+    out = os.path.join(DST, 'bottom_wall_centerline.csv')
+    df.to_csv(out, index=False)
+    print(f'  bottom_wall  -> {os.path.basename(out)} '
+          f'({len(df)} rows; x range [{df.x_over_T.min():.2f}, {df.x_over_T.max():.2f}])')
+
+    # --- wing: y/T ~= 0.05 strip (root chord) ---
+    pts, p = load_pvtu(os.path.join(RAW, 'wing_averaged_pressure.pvtu'))
+    sub_pts, sub_p = extract_strip(pts, p, axis_to_filter=1, target=Y_TARGET, tol=Y_TOL)
+    cp = p_to_cp(sub_p)
+    df = pd.DataFrame({
+        'x_over_T': sub_pts[:, 0] / T,
+        'y_over_T': sub_pts[:, 1] / T,
+        'z_over_T': sub_pts[:, 2] / T,
+        'p_over_pref': sub_p,
+        'Cp': cp,
+    }).sort_values('x_over_T').reset_index(drop=True)
+    out = os.path.join(DST, 'wing_root_chord.csv')
+    df.to_csv(out, index=False)
+    print(f'  wing_root    -> {os.path.basename(out)} '
+          f'({len(df)} rows; x range [{df.x_over_T.min():.2f}, {df.x_over_T.max():.2f}])')
+
+
+if __name__ == '__main__':
+    main()

data/faith_hill_to_csv.py

@@ -0,0 +1,161 @@
+"""Convert Faith Hill PIV / PSP / FISF data to flat CSV.
+
+Faith Hill source layout:
+- PIV: one folder per dataset (1kHz_3940samp / 2Hz_4000samps). Each folder has 14 .dat
+  files in Tecplot POINT format, each file containing (x, y, single_scalar). Merge them
+  on the (x, y) grid into one CSV per dataset.
+- PSP: single Tecplot-style file with "VARIABLES =" line and one zone -> 2-col CSV.
+- FISF: single Tecplot-style file with "Variables =" line, no zone -> N-col CSV.
+
+Coords in mm (PIV) or inches (PSP/FISF) per source. Hill height h = 152.4 mm = 6 in.
+
+Usage:
+    python faith_hill_to_csv.py <piv-data-folder|psp.dat|fisf.dat> <output_csv>
+"""
+
+import os
+import re
+import sys
+import glob
+import numpy as np
+import pandas as pd
+
+
+_SCALAR_FROM_NAME = {
+    'U_mean': 'U_mean',
+    'V_mean': 'V_mean',
+    'W_mean': 'W_mean',
+    'U_rms': 'U_rms',
+    'V_rms': 'V_rms',
+    'W_rms': 'W_rms',
+    'Re_stress_UU': 'UU',
+    'Re_stress_UV': 'UV',
+    'Re_stress_UW': 'UW',
+    'Re_stress_VV': 'VV',
+    'Re_stress_VW': 'VW',
+    'Re_stress_WW': 'WW',
+    'Ek_Ave': 'Ek_Ave',
+    'Ek_turb': 'Ek_turb',
+}
+
+
+_NUMERIC_RE = re.compile(r'^\s*[-+]?\d')
+
+
+def _parse_tecplot_point(path):
+    """Parse a Tecplot POINT-format .dat file -> (x, y, value) arrays.
+
+    Robust to multi-line headers: skips every line until the first one whose
+    first non-whitespace character is a digit or sign.
+    """
+    with open(path) as f:
+        lines = f.readlines()
+
+    data_start = 0
+    for i, line in enumerate(lines):
+        if _NUMERIC_RE.match(line):
+            data_start = i
+            break
+    else:
+        raise RuntimeError(f'No numeric data found in {path}')
+
+    arr = np.genfromtxt(lines[data_start:], dtype=float)
+    if arr.ndim == 1:
+        arr = arr.reshape(1, -1)
+    if arr.shape[1] < 3:
+        raise RuntimeError(f'{path}: expected >=3 columns, got {arr.shape[1]}')
+    return arr[:, 0], arr[:, 1], arr[:, 2]
+
+
+def merge_piv_dataset(folder, out_csv):
+    """Merge 14 Tecplot-POINT files in `folder` into one CSV by (x, y) grid."""
+    dat_files = [p for p in sorted(glob.glob(os.path.join(folder, '*.dat')))
+                 if not os.path.basename(p).startswith('._')]
+    if not dat_files:
+        raise RuntimeError(f'No .dat in {folder}')
+
+    df = None
+    for path in dat_files:
+        base = os.path.basename(path).replace('.dat', '').replace('_axis00', '')
+        col = _SCALAR_FROM_NAME.get(base, base)
+        x, y, v = _parse_tecplot_point(path)
+        cur = pd.DataFrame({'x_mm': x, 'y_mm': y, col: v})
+        if df is None:
+            df = cur
+        else:
+            df = pd.merge(df, cur, on=['x_mm', 'y_mm'], how='outer')
+
+    # add k = 0.5 * (UU + VV + WW)
+    if all(c in df.columns for c in ['UU', 'VV', 'WW']):
+        df['k'] = 0.5 * (df['UU'] + df['VV'] + df['WW'])
+
+    df = df.sort_values(['y_mm', 'x_mm']).reset_index(drop=True)
+    df.to_csv(out_csv, index=False)
+    print(f'  PIV: {os.path.basename(folder)} -> {os.path.basename(out_csv)} '
+          f'({len(df)} rows, {len(df.columns)} cols)')
+
+
+def convert_psp(path, out_csv):
+    """Parse PSP centerline .dat (Tecplot single-zone, 2 columns)."""
+    with open(path) as f:
+        content = f.read()
+    var_match = re.search(r'VARIABLES\s*=\s*([^\n]+)', content, re.IGNORECASE)
+    cols = []
+    if var_match:
+        cols = re.findall(r'"([^"]+)"', var_match.group(1))
+    arr = np.genfromtxt(path, comments=None,
+                        skip_header=sum(1 for _ in re.findall(
+                            r'^(?:VARIABLES|TITLE|ZONE|zone|#)[^\n]*\n', content, re.MULTILINE)))
+    # safer: parse line-by-line
+    lines = content.split('\n')
+    data_start = 0
+    for i, line in enumerate(lines):
+        s = line.strip().lower()
+        if s.startswith('zone') or s.startswith('#'):
+            data_start = i + 1
+        elif s.startswith('variables') or s.startswith('title'):
+            data_start = i + 1
+    arr = np.genfromtxt(lines[data_start:], dtype=float)
+    if arr.ndim == 1:
+        arr = arr.reshape(1, -1)
+    if not cols or len(cols) != arr.shape[1]:
+        cols = [f'col_{i}' for i in range(arr.shape[1])]
+    # rename common columns
+    rename = {'X': 'x_in', 'F1V1': 'Cp'}
+    cols = [rename.get(c, c) for c in cols]
+    df = pd.DataFrame(arr, columns=cols)
+    df.to_csv(out_csv, index=False)
+    print(f'  PSP: {os.path.basename(path)} -> {os.path.basename(out_csv)} '
+          f'({len(df)} rows, {len(df.columns)} cols)')
+
+
+def convert_fisf(path, out_csv):
+    """Parse FISF surface data ("Variables =..." header, N-col data)."""
+    with open(path) as f:
+        first_line = f.readline()
+    cols = re.findall(r'"([^"]+)"', first_line)
+    arr = np.genfromtxt(path, skip_header=1, dtype=float)
+    if arr.ndim == 1:
+        arr = arr.reshape(1, -1)
+    if not cols or len(cols) != arr.shape[1]:
+        cols = [f'col_{i}' for i in range(arr.shape[1])]
+    df = pd.DataFrame(arr, columns=cols)
+    df.to_csv(out_csv, index=False)
+    print(f'  FISF: {os.path.basename(path)} -> {os.path.basename(out_csv)} '
+          f'({len(df)} rows, {len(df.columns)} cols)')
+
+
+if __name__ == '__main__':
+    if len(sys.argv) != 3:
+        print(__doc__)
+        sys.exit(1)
+    src, dst = sys.argv[1], sys.argv[2]
+    if os.path.isdir(src):
+        merge_piv_dataset(src, dst)
+    elif 'centerline_p150' in src.lower() or 'psp' in src.lower():
+        convert_psp(src, dst)
+    elif 'fisf' in src.lower():
+        convert_fisf(src, dst)
+    else:
+        print(f'Unknown source type: {src}')
+        sys.exit(1)