Add files using upload-large-folder tool

.gitattributes

@@ -57,3 +57,47 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1220_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1230_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1240_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1250_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1260_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1270_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1280_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1290_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1300_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1300_ms_Angle_05_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1300_ms_Angle_10_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1300_ms_Angle_15_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1300_ms_Angle_20_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1300_ms_Angle_25_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1300_ms_Angle_30_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1300_ms_Angle_35_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1300_ms_Angle_40_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1300_ms_Angle_45_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1300_ms_Angle_50_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1300_ms_Angle_55_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1300_ms_Angle_60_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1310_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1320_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1330_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1340_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1350_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1360_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1370_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1380_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1390_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1400_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1400_ms_Angle_05_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1400_ms_Angle_10_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1400_ms_Angle_15_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1400_ms_Angle_20_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1400_ms_Angle_25_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1400_ms_Angle_30_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1400_ms_Angle_35_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1400_ms_Angle_40_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1400_ms_Angle_45_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1400_ms_Angle_50_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1400_ms_Angle_55_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1400_ms_Angle_60_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text
+Planes/Horizontal/Forward_1410_ms_Angle_00_HORZPLN_ALL filter=lfs diff=lfs merge=lfs -text

Examples/Python/README.md

@@ -0,0 +1,99 @@
+# WAKESET: A Large-Scale, High-Reynolds Number Flow Dataset
+
+**WAKESET** is a comprehensive Computational Fluid Dynamics (CFD) dataset designed for Machine Learning applications in fluid mechanics. It captures the complex hydrodynamic interactions of an Extra Large Uncrewed Underwater Vehicle (XLUUV).
+
+The dataset comprises **1,091 high-fidelity RANS simulations** (augmented to 4,364 instances via the provided `WAKESET_pytorch.py`), covering Reynolds numbers up to $1.09 \times 10^8$ and turning angles up to 60 degrees.
+
+## Directory Structure
+
+```text
+WAKESET/
+|-- Volumes/           # 3D interpolated grids (128x128x128)
+|   |-- Forward_0100_ms_Angle_00_CUBE_128/
+|   |-- Forward_0100_ms_Angle_05_CUBE_128/
+|   |-- ...
+|-- Planes/            # 2D slices (Vertical and Horizontal)
+|   |-- Vertical/
+|   |   |-- Forward_0100_ms_Angle_00_VERTPLN_ALL/
+|   |   |-- Forward_0100_ms_Angle_05_VERTPLN_ALL/
+|   |   |-- ...
+|   |-- Horizontal/
+|   |   |-- Forward_0100_ms_Angle_00_HORZPLN_ALL/
+|   |   |-- Forward_0100_ms_Angle_05_HORZPLN_ALL/
+|   |   |-- ...
+|-- Examples/          # Python Toolkit
+|   |-- Python/
+|       |-- requirements.txt
+|       |-- WAKESET_pytorch.py     # ML Dataloader with on-the-fly augmentation
+|       |-- load_planes.py         # Utilities for 2D data
+|       |-- load_volumes.py        # Utilities for 3D data
+|       |-- load_visualizations.py # Plotting tools
+```
+
+# Quick Start
+
+## 1. Installation
+The dataset includes a Python toolkit to streamline loading, parsing, and augmentation.
+
+```bash
+cd Examples/Python
+pip install -r requirements.txt
+```
+
+## 2. Loading 3D Volumes (CFD Data)
+The `load_volumes.py` script handles the parsing of sparse CFD exports and reshapes them into structured grids.
+
+```python
+import sys
+sys.path.append("Examples/Python")
+from load_volumes import load_volume
+
+# Load a specific volume
+vol_data = load_volume(
+    velocity=1.0, 
+    angle=0, 
+    variable="velocity_magnitude", 
+    data_dir="../../Volumes"
+)
+
+print(f"Loaded Volume Shape: {vol_data.values.shape}") # (128, 128, 128)
+```
+
+## 3. Machine Learning (PyTorch)
+Use the `WAKESET_pytorch.py` wrapper to plug the dataset directly into an ML pipeline. This loader handles on-the-fly augmentation (rotation and flipping) to expand the effective dataset size to 4,364 instances without using extra disk space.
+
+```python
+from torch.utils.data import DataLoader
+from WAKESET_pytorch import WakesetVolumeDataset
+
+# Initialize Dataset
+dataset = WakesetVolumeDataset(
+    root_dir="../../", 
+    subset='train', 
+    augment=True  # Enables physics-informed rotation/flipping
+)
+
+loader = DataLoader(dataset, batch_size=4, shuffle=True)
+
+# Training Loop
+for flow_field, kinematics in loader:
+    # flow_field: [Batch, 1, 128, 128, 128]
+    # kinematics: [Batch, 2] (Speed, Angle)
+    print(flow_field.shape, kinematics.shape)
+    break
+```
+
+## 4. Visualization
+Visualise the data using `load_visualizations.py`.
+
+```python
+from load_visualizations import visualize_volume_slices
+
+# Visualize the center slices of the previously loaded volume
+visualize_volume_slices(vol_data, variable="velocity_magnitude")
+```
+
+# Citation
+If you use WAKESET in your research, please cite:
+
+Cooper-Baldock, Z., Santos, P. E., Brinkworth, R. S. A., & Sammut, K. (2026). WAKESET: A Large-Scale, High-Reynolds Number Flow Dataset for Machine Learning of Turbulent Wake Dynamics.

Examples/Python/WAKESET_pytorch.py

@@ -0,0 +1,73 @@
+import torch
+from torch.utils.data import Dataset
+import numpy as np
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+# Import your existing loaders
+from load_volumes import process_fluent_export_sparse, VolumeSpec
+from load_planes import process_plane_export, PlaneSpec
+
+class WAKESETDataset(Dataset):
+    def __init__(self, root_dir: str, subset: str = 'train', augment: bool = False):
+        """
+        Args:
+            root_dir: Path to WAKESET folder.
+            subset: 'train', 'val', or 'test'.
+            augment: If True, applies the rotation/flipping described in the paper.
+        """
+        self.root = Path(root_dir) / "Volumes"
+        self.files = sorted(list(self.root.glob("Forward_*_CUBE_128.csv")))
+        self.augment = augment
+        
+        # Simple split logic (matches paper Section 6.1)
+        # In reality, you might load a specific split file here
+        n = len(self.files)
+        if subset == 'train': self.files = self.files[:int(0.8*n)]
+        elif subset == 'val': self.files = self.files[int(0.8*n):int(0.9*n)]
+        else: self.files = self.files[int(0.9*n):]
+
+    def __len__(self):
+        # If augmenting, we implicitly have 4x data (handled via index modulo)
+        return len(self.files) * 4 if self.augment else len(self.files)
+
+    def __getitem__(self, idx):
+        # Handle Augmentation Indexing
+        if self.augment:
+            file_idx = idx // 4
+            aug_mode = idx % 4  # 0: None, 1: Flip, 2: Rot+, 3: Rot-
+        else:
+            file_idx = idx
+            aug_mode = 0
+
+        # Load Raw Data (Cached .npz preferred)
+        path = self.files[file_idx]
+        npz_path = path.with_suffix('.npz')
+        
+        if npz_path.exists():
+            data = np.load(npz_path)
+            vol = data['velocity_magnitude'] # Shape (128, 128, 128)
+        else:
+            # Fallback to robust loader
+            raw = process_fluent_export_sparse(path, fill_value=0.0)
+            vol = raw['velocity_magnitude']
+
+        # Convert to Tensor
+        tensor = torch.from_numpy(vol).float().unsqueeze(0) # (C, D, H, W)
+
+        # Apply Physics-Consistent Augmentation (Paper Section 5.3)
+        if aug_mode == 1: 
+            # Flip across vertical mid-plane (assumes symmetry at 0-deg)
+            tensor = torch.flip(tensor, dims=[2]) # Flip Y-axis
+        # Note: True rotation requires rotating vector components (u,v,w) 
+        # not just the scalar magnitude grid. 
+        
+        # Extract Kinematics from filename for Conditioning
+        # "Forward_0100_ms..."
+        spec = VolumeSpec.from_filename(path)
+        speed = float(spec.velocity) / 1000.0
+        angle = float(spec.angle)
+        
+        kinematics = torch.tensor([speed, angle], dtype=torch.float32)
+
+        return tensor, kinematics

Examples/Python/load_planes.py

@@ -0,0 +1,168 @@
+"""
+Utilities for loading WAKESET plane slices (unstructured CFD data) 
+and interpolating them onto regular 2D grids.
+"""
+
+from __future__ import annotations
+import re
+import numpy as np
+import pandas as pd
+from pathlib import Path
+from scipy.interpolate import LinearNDInterpolator, NearestNDInterpolator
+
+# --- Configuration ---
+DEFAULT_GRID_RES: int = 512
+
+# Aliases to map CSV headers to standard names
+_COL_ALIASES = {
+    "cellnumber": "cell", 
+    "x_coordinate": "x", "y_coordinate": "y", "z_coordinate": "z",
+    "velocity_magnitude": "velocity_magnitude", 
+    "z_velocity": "vz", "y_velocity": "vy", "x_velocity": "vx",
+    "total_pressure": "total_pressure",
+    "static_pressure": "static_pressure"
+}
+
+def process_plane_export(
+    filepath: str,
+    resolution: int = DEFAULT_GRID_RES,
+    fill_value: float = np.nan,
+    precision_round: int = 4
+):
+    """
+    Parses unstructured CFD plane exports and interpolates them onto a 
+    regular 2D grid (Image format).
+    """
+    filepath = Path(filepath)
+    print(f"Processing Plane: {filepath.name}...")
+
+    # 1. CSV Loading (Handles variable whitespace)
+    try:
+        df = pd.read_csv(
+            filepath, 
+            sep=',',                # Comma separator
+            skipinitialspace=True,  # Handle " , 1.0"
+            engine='c', 
+            on_bad_lines='warn'
+        )
+    except Exception as e:
+        print(f"Read failed: {e}")
+        return None
+
+    # Normalize columns
+    df.columns = [_normalize_col(c) for c in df.columns]
+    
+    # Ensure coordinates exist
+    if not {'x', 'y', 'z'}.issubset(df.columns):
+        print(f"Error: Missing coordinate columns. Found: {list(df.columns)}")
+        return None
+
+    # 2. Auto-Detect Plane Orientation
+    # Look for the axis with the least variance (the flat axis)
+    coords = df[['x', 'y', 'z']].values.astype(np.float32)
+    spreads = np.ptp(coords, axis=0) # Peak-to-peak (max - min)
+    flat_axis_idx = np.argmin(spreads)
+    
+    axis_names = ['x', 'y', 'z']
+    flat_axis_name = axis_names[flat_axis_idx]
+    
+    # Safety Check: Is it actually a plane?
+    if spreads[flat_axis_idx] > 1e-3:
+        print(f"Warning: Data does not look planar. Spread in {flat_axis_name} is {spreads[flat_axis_idx]}")
+
+    # 3. Define 2D Projection (U, V)
+    # If Plane is X-constant, we map Y->U, Z->V, etc.
+    if flat_axis_name == 'x':
+        u_col, v_col = 'y', 'z'
+    elif flat_axis_name == 'y':
+        u_col, v_col = 'x', 'z'
+    else: # z
+        u_col, v_col = 'x', 'y'
+        
+    print(f"  -> Orientation: {flat_axis_name}-plane. Projecting {u_col}/{v_col} -> Grid.")
+
+    # 4. Generate Target Grid (Regular Image)
+    u_raw = df[u_col].values
+    v_raw = df[v_col].values
+    
+    u_min, u_max = u_raw.min(), u_raw.max()
+    v_min, v_max = v_raw.min(), v_raw.max()
+    
+    # Create the meshgrid
+    grid_u_Lin = np.linspace(u_min, u_max, resolution)
+    grid_v_Lin = np.linspace(v_min, v_max, resolution)
+    grid_u, grid_v = np.meshgrid(grid_u_Lin, grid_v_Lin)
+    
+    # Flatten targets for interpolation logic
+    target_points = np.column_stack((grid_u.ravel(), grid_v.ravel()))
+    source_points = np.column_stack((u_raw, v_raw))
+
+    # 5. Vectorized Interpolation
+    # We grab all relevant data channels
+    channels = [c for c in df.columns if c not in ['x', 'y', 'z', 'cell']]
+    source_values = df[channels].values
+    
+    # LinearNDInterpolator builds a Delaunay triangulation once
+    # and interpolates ALL channels simultaneously.
+    print(f"  -> Interpolating {len(source_points)} points to {resolution}x{resolution} grid...")
+    
+    interp = LinearNDInterpolator(source_points, source_values, fill_value=fill_value)
+    interpolated_flat = interp(target_points)
+    
+    # 6. Fallback for Convex Hull Gaps (Optional)
+    # LinearND returns NaN for points slightly outside the triangulation (edges).
+    # We fill these with Nearest Neighbor to avoid jagged edges.
+    if np.isnan(interpolated_flat).any():
+        nan_mask = np.isnan(interpolated_flat[:, 0]) # Check first channel
+        if np.any(nan_mask):
+            # Only train nearest neighbor on valid points
+            nn = NearestNDInterpolator(source_points, source_values)
+            interpolated_flat[nan_mask] = nn(target_points[nan_mask])
+
+    # 7. Reshape and Store
+    plane_data = {
+        "meta": {
+            "plane_axis": flat_axis_name,
+            "plane_value": float(np.median(coords[:, flat_axis_idx])),
+            "u_axis": u_col,
+            "v_axis": v_col,
+            "bounds": [u_min, u_max, v_min, v_max]
+        }
+    }
+    
+    for i, col_name in enumerate(channels):
+        # Reshape (N*N, ) -> (N, N)
+        # Note: We flip ud (up/down) usually to match image coordinates if needed,
+        # but here we keep mathematical coordinates.
+        plane_data[col_name] = interpolated_flat[:, i].reshape(resolution, resolution)
+
+    return plane_data
+
+def _normalize_col(name: str) -> str:
+    clean = re.sub(r"[^a-z0-9]+", "_", name.lower()).strip("_")
+    return _COL_ALIASES.get(clean, clean)
+
+if __name__ == "__main__":
+    # --- Test ---
+    # Update path to a Plane file (VERTPLN or HORZPLN)
+    test_file = Path("C:/Users/zacco/Desktop/Files/WAKESET/Test Files/Forward_0100_ms_Angle_00_VERTPLN_ALL")
+    
+    if not test_file.exists() and test_file.with_suffix(".csv").exists():
+        test_file = test_file.with_suffix(".csv")
+
+    if test_file.exists():
+        data = process_plane_export(test_file, resolution=512)
+        
+        if data:
+            print("Success!")
+            # Access a variable
+            grid = data['velocity_magnitude']
+            print(f"Output Grid Shape: {grid.shape}")
+            print(f"Axis detected: {data['meta']['plane_axis']}")
+            
+            # Save
+            out_path = test_file.with_name(test_file.name + ".npz")
+            np.savez_compressed(out_path, **data)
+            print(f"Saved to: {out_path}")
+    else:
+        print(f"File not found: {test_file}")

Examples/Python/load_visualizations.py

@@ -0,0 +1,182 @@
+"""
+Utilities for visualizing WAKESET data.
+Handles both 2D planar interpolations and 3D volumetric slices.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import matplotlib.pyplot as plt
+from pathlib import Path
+from typing import Dict, Union, Optional, Tuple
+
+# Configuration
+DEFAULT_CMAP = 'jet'  # Classic CFD look. Options: 'viridis', 'plasma', 'turbo'
+FIG_SIZE_PLANE = (8, 6)
+FIG_SIZE_VOL = (15, 5)
+
+def load_visualization_plane(
+    data: Union[str, Path, Dict],
+    variable: str = "velocity_magnitude",
+    title: Optional[str] = None,
+    save_path: Optional[Union[str, Path]] = None
+):
+    """
+    Visualizes a 2D interpolated plane.
+    """
+    # 1. Load Data if path provided
+    data_dict = _ensure_dict(data)
+    
+    if variable not in data_dict:
+        raise KeyError(f"Variable '{variable}' not found in data. Available: {list(data_dict.keys())}")
+
+    grid = data_dict[variable]
+    
+    # 2. Extract Metadata for Axes (if available)
+    # The load_planes.py script saves a 'meta' dictionary
+    meta = data_dict.get('meta', {})
+    if isinstance(meta, np.ndarray): meta = meta.item() # Handle wrapped npz dicts
+    
+    u_label = meta.get('u_axis', 'U-Axis')
+    v_label = meta.get('v_axis', 'V-Axis')
+    plane_axis = meta.get('plane_axis', 'Plane')
+    plane_val = meta.get('plane_value', 0.0)
+    bounds = meta.get('bounds', None) # [min_u, max_u, min_v, max_v]
+
+    # 3. Plot
+    fig, ax = plt.subplots(figsize=FIG_SIZE_PLANE)
+    
+    # Use 'extent' to map array pixels to physical coordinates
+    im = ax.imshow(
+        grid, 
+        origin='lower', 
+        cmap=DEFAULT_CMAP, 
+        aspect='auto',
+        extent=bounds if bounds is not None else None
+    )
+    
+    # Decoration
+    cbar = plt.colorbar(im, ax=ax)
+    cbar.set_label(variable.replace('_', ' ').title())
+    
+    ax.set_xlabel(f"{u_label} (m)")
+    ax.set_ylabel(f"{v_label} (m)")
+    
+    safe_title = title or f"{variable} on {plane_axis}-Plane ({plane_val:.2f} m)"
+    ax.set_title(safe_title)
+    
+    plt.tight_layout()
+    
+    if save_path:
+        plt.savefig(save_path, dpi=150)
+        print(f"Saved plot to {save_path}")
+        plt.close()
+    else:
+        plt.show()
+
+
+def load_visualization_volume(
+    data: Union[str, Path, Dict],
+    variable: str = "velocity_magnitude",
+    slice_indices: Optional[Tuple[int, int, int]] = None,
+    save_path: Optional[Union[str, Path]] = None
+):
+    """
+    Visualizes 3 orthogonal slices (X, Y, Z) of a 3D volume.
+    Defaults to the center (64th index for 128 grids).
+    """
+    # 1. Load Data
+    data_dict = _ensure_dict(data)
+    
+    if variable not in data_dict:
+        raise KeyError(f"Variable '{variable}' not found. Available: {list(data_dict.keys())}")
+        
+    vol = data_dict[variable]
+    nx, ny, nz = vol.shape
+    
+    # Default to center slices if not provided
+    if slice_indices is None:
+        idx_x, idx_y, idx_z = nx // 2, ny // 2, nz // 2
+    else:
+        idx_x, idx_y, idx_z = slice_indices
+
+    # 2. Setup Plot
+    fig, axes = plt.subplots(1, 3, figsize=FIG_SIZE_VOL)
+    
+    # Calculate global min/max for consistent coloring across slices
+    # We ignore 0.0 or NaN if they represent masked geometry
+    valid_mask = (vol != 0) & (~np.isnan(vol))
+    if np.any(valid_mask):
+        vmin, vmax = np.percentile(vol[valid_mask], [1, 99])
+    else:
+        vmin, vmax = vol.min(), vol.max()
+
+    # 3. Slice and Plot
+    
+    # --- Slice X (Side View) ---
+    # Fix X, show Y vs Z
+    slice_x = vol[idx_x, :, :]
+    im1 = axes[0].imshow(slice_x.T, origin='lower', cmap=DEFAULT_CMAP, vmin=vmin, vmax=vmax, aspect='equal')
+    axes[0].set_title(f"X-Slice (idx={idx_x})")
+    axes[0].set_xlabel("Y Axis")
+    axes[0].set_ylabel("Z Axis")
+
+    # --- Slice Y (Top/Bottom View) ---
+    # Fix Y, show X vs Z
+    slice_y = vol[:, idx_y, :]
+    im2 = axes[1].imshow(slice_y.T, origin='lower', cmap=DEFAULT_CMAP, vmin=vmin, vmax=vmax, aspect='equal')
+    axes[1].set_title(f"Y-Slice (idx={idx_y})")
+    axes[1].set_xlabel("X Axis")
+    axes[1].set_ylabel("Z Axis")
+
+    # --- Slice Z (Front/Back View) ---
+    # Fix Z, show X vs Y
+    slice_z = vol[:, :, idx_z]
+    im3 = axes[2].imshow(slice_z.T, origin='lower', cmap=DEFAULT_CMAP, vmin=vmin, vmax=vmax, aspect='equal')
+    axes[2].set_title(f"Z-Slice (idx={idx_z})")
+    axes[2].set_xlabel("X Axis")
+    axes[2].set_ylabel("Y Axis")
+
+    # 4. Decoration
+    # Add a single colorbar for the whole figure
+    cbar = fig.colorbar(im3, ax=axes.ravel().tolist(), shrink=0.8)
+    cbar.set_label(variable.replace('_', ' ').title())
+    
+    plt.suptitle(f"Volumetric Slices: {variable}", fontsize=14)
+    # plt.tight_layout() # Sometimes interferes with global colorbar
+    
+    if save_path:
+        plt.savefig(save_path, dpi=150)
+        print(f"Saved plot to {save_path}")
+        plt.close()
+    else:
+        plt.show()
+
+def _ensure_dict(data: Union[str, Path, Dict]) -> Dict:
+    """Helper to load npz file or pass through dictionary."""
+    if isinstance(data, (str, Path)):
+        p = Path(data)
+        if not p.exists():
+            raise FileNotFoundError(f"File not found: {p}")
+        # Allow loading .npz files directly
+        return np.load(p, allow_pickle=True)
+    return data
+
+if __name__ == "__main__":
+    # --- Example Usage ---
+    
+    # 1. Try to find a Plane file (.npz)
+    plane_file = Path("Forward_0100_ms_Angle_00_VERTPLN_ALL.npz")
+    if plane_file.exists():
+        print("Visualizing Plane...")
+        load_visualization_plane(plane_file, variable="velocity_magnitude")
+    else:
+        print("No plane file found for demo. (Run load_planes.py first)")
+
+    # 2. Try to find a Volume file (.npz)
+    vol_file = Path("Forward_0100_ms_Angle_00_CUBE_128.npz")
+    if vol_file.exists():
+        print("Visualizing Volume Slices...")
+        load_visualization_volume(vol_file, variable="velocity_magnitude", slice_indices=(65, 65, 65))
+    else:
+        print("No volume file found for demo. (Run load_volumes.py first)")

Examples/Python/load_volumes.py

@@ -0,0 +1,112 @@
+"""
+Utilities for loading WAKESET volume extractions (unstructured CFD data) 
+and interpolating them onto regular 3D grids.
+"""
+
+import pandas as pd
+import numpy as np
+from pathlib import Path
+
+def process_fluent_export_sparse(
+    filepath: str, 
+    grid_dim: int = 128, # Sizes larger than 128 will require interpolation
+    precision_round: int = 3,
+    fill_value: float = 0.0  # Use 0.0 or np.nan for solid object (XLUUV)
+):
+    """
+    Parses CFD exports where solid geometry cells are missing.
+    Maps physical coordinates to a fixed tensor grid.
+    """
+    filepath = Path(filepath)
+    print(f"Processing: {filepath.name}...")
+
+    # 1. Load Data
+    try:
+        df = pd.read_csv(
+            filepath, sep=',', skipinitialspace=True, 
+            engine='c', on_bad_lines='warn'
+        )
+    except Exception as e:
+        print(f"Read failed: {e}")
+        return None
+    
+    # Normalize columns
+    df.columns = [c.strip().lower().replace('-', '_') for c in df.columns]
+
+    # 2. Extract and Round Coordinates
+    # Rounding is critical to group points into grid lines
+    x_raw = df['x_coordinate'].values.round(precision_round)
+    y_raw = df['y_coordinate'].values.round(precision_round)
+    z_raw = df['z_coordinate'].values.round(precision_round)
+
+    # 3. Detect Grid Ticks (The "Ruler")
+    # We find the unique values for each axis to define the grid
+    x_unique = np.unique(x_raw)
+    y_unique = np.unique(y_raw)
+    z_unique = np.unique(z_raw)
+
+    # Validation: Do we have roughly 128 ticks per axis?
+    # (Allowing slight variance if entire slices are missing, though rare)
+    if len(x_unique) > grid_dim or len(y_unique) > grid_dim or len(z_unique) > grid_dim:
+        print(f"Error: Found too many grid ticks (X:{len(x_unique)}, Y:{len(y_unique)}, Z:{len(z_unique)}).")
+        print("Try reducing 'precision_round' (e.g., to 3) if floating point jitter is high.")
+        return None
+
+    # 4. Map Physical Coords to Integer Indices (0 to 127)
+    # np.searchsorted finds the index of each raw point in the unique array
+    # This effectively "snaps" the float coordinates to integer grid positions
+    idx_x = np.searchsorted(x_unique, x_raw)
+    idx_y = np.searchsorted(y_unique, y_raw)
+    idx_z = np.searchsorted(z_unique, z_raw)
+
+    # 5. Create the Blank Canvas (The Full Cube)
+    # Initialize with fill_value (0.0 represents "no flow" inside the object)
+    volume_shape = (grid_dim, grid_dim, grid_dim)
+    
+    channels = [
+        'velocity_magnitude', 'x_velocity', 'y_velocity', 'z_velocity', 
+        'total_pressure', 'absolute_pressure'
+    ]
+    
+    volume_data = {}
+
+    for col in channels:
+        if col in df.columns:
+            # Create empty grid
+            grid = np.full(volume_shape, fill_value, dtype=np.float32)
+            
+            # 6. Fill the known data
+            # We use the integer indices to slot data into the correct place.
+            # Missing indices (the solid object) remain as 'fill_value'.
+            # Note: We assume standard (x, y, z) layout. 
+            # If your ML model expects (z, y, x), swap the indices here.
+            grid[idx_x, idx_y, idx_z] = df[col].values
+            
+            volume_data[col] = grid
+
+    # 7. Verification
+    filled_count = np.count_nonzero(volume_data['velocity_magnitude'] != fill_value)
+    print(f"  -> Grid filled. Solid cells (missing data): {grid_dim**3 - filled_count}")
+    
+    return volume_data
+
+if __name__ == "__main__":
+    # --- Test ---
+    fpath = "C:/Users/zacco/Desktop/Files/WAKESET/Test Files/Forward_0100_ms_Angle_00_CUBE_128" # Update path
+    
+    # Check current directory or provided path
+    p = Path(fpath)
+    if not p.exists() and p.with_suffix(".csv").exists(): p = p.with_suffix(".csv")
+    
+    if p.exists():
+        # Using fill_value=0.0 is common for "inside wall" (zero velocity)
+        # Using fill_value=np.nan is better if you want to mask the loss function later
+        volumes = process_fluent_export_sparse(p, fill_value=0.0)
+        
+        if volumes:
+            print("Success.")
+            # Verify the shape
+            print(f"Shape: {volumes['velocity_magnitude'].shape}")
+            
+            # Save
+            np.savez_compressed(p.name + ".npz", **volumes)

Examples/Python/requirements.txt

@@ -0,0 +1,6 @@
+numpy>=1.21.0
+pandas>=1.3.0
+scipy>=1.7.0
+matplotlib>=3.4.0
+torch>=1.10.0  
+xarray>=0.20.0 

Planes/Horizontal/Forward_1220_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1e3b0d90fbeaf06d4755a0ca301df8d1733ee0f7905d820f849d6c59b18772de
+size 29815590

Planes/Horizontal/Forward_1230_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:10816aef1b9cf871c084651a3c87dd7473bfecde7777b26b7a0af468ecc8dd29
+size 29815590

Planes/Horizontal/Forward_1240_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3e483d701a3ce5b85f772d2b64eb73e9d3fdc8e88bd1b48052b4b306d5f1d08c
+size 29815590

Planes/Horizontal/Forward_1250_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f434488fbfefe05582dd711adcd922cee31c301fb878dfefd7798586f1fc3ee
+size 29815590

Planes/Horizontal/Forward_1260_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02824eb8d4d88cd904082ad8bd8eafae8b8a9042cd99b7ea2690bb3c313f2605
+size 29815590

Planes/Horizontal/Forward_1270_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f3ae165b04cd32741ce73e345352ffedf6a4c1026eb5b29c3126aed270935058
+size 29815590

Planes/Horizontal/Forward_1280_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:134da237df08bde1f4a1961f05f135bda95a4752eeeccf985cb2a373f40bf658
+size 29815590

Planes/Horizontal/Forward_1290_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fc2c8e79bf4a20b9991533f8dd50f5af35ff3d3dcf4b7afc46290ae448bc770
+size 29815590

Planes/Horizontal/Forward_1300_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e74ae995d265a3156db06da1a532f15a521027896363bc2716932d73de1562e7
+size 29815590

Planes/Horizontal/Forward_1300_ms_Angle_05_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:963fbab2f36a16948bf873a430273a02a0ec5beb0675ba6f123bd001e972a349
+size 29815590

Planes/Horizontal/Forward_1300_ms_Angle_10_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e4468e86fb798997d0e88dea96de9655bda6b7a23d72aa422526dbdcdc8a213
+size 29815590

Planes/Horizontal/Forward_1300_ms_Angle_15_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c916c0463e83c07d432e38cbfa7814468d64e2ce25f5bdab6d28389a1b859842
+size 29815590

Planes/Horizontal/Forward_1300_ms_Angle_20_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fa6d6010fffd1cf1234ced672b1d410c2e4bfb0431a27e140e6e6ec279ee3c7a
+size 29815590

Planes/Horizontal/Forward_1300_ms_Angle_25_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87d5161717ea39a8335f7739f2fd0234767d5f255fbd98b19971f58c6e6944de
+size 29815590

Planes/Horizontal/Forward_1300_ms_Angle_30_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0cb3251beb54761649fb791c591da23ca70d00e3a2bd854e64ef0e13c84f278d
+size 29815590

Planes/Horizontal/Forward_1300_ms_Angle_35_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53e3264bbb9b83a96a1da0d0a038902a28eb7940e7e30629271409cdf6f04919
+size 29815590

Planes/Horizontal/Forward_1300_ms_Angle_40_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:09191c3ab6430da250736697a9a652578b470969ca787fcb34db90ee5908ed64
+size 29815590

Planes/Horizontal/Forward_1300_ms_Angle_45_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac6396f2b82a2736bb2a688e79b04bee12c7270662e068844f53a64f26ea1227
+size 29815590

Planes/Horizontal/Forward_1300_ms_Angle_50_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e3e04ca14cd96593408bdad3132215f5083c9eb0b9478c27b8de15ef454964f2
+size 29815590

Planes/Horizontal/Forward_1300_ms_Angle_55_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a91253be72f9134ee0a4677db0601c3773ec305ee0337f205cff3795cfe5c6d
+size 29815590

Planes/Horizontal/Forward_1300_ms_Angle_60_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4420f447cc72edfe8635937d7012929980a90d0878970017c97a92f94dad4536
+size 29815590

Planes/Horizontal/Forward_1310_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac333eae14135349846991dd4fb0e6814f3d079f4c6dc463ba0578e215bc60b8
+size 29815590

Planes/Horizontal/Forward_1320_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:57df93f08f3c96674fb23312cdc993198db4dee089e68a48df7653e48e90b05d
+size 29815590

Planes/Horizontal/Forward_1330_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b50d17a3e23f7041a5fe580fac49b51f466d8ac9dd32d646f42380df16b853b
+size 29815590

Planes/Horizontal/Forward_1340_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cdc2cf26235c6a2dada6f9eb15e84c1827c7d5d83a25f9388e6721d7f2ab2bdc
+size 29815590

Planes/Horizontal/Forward_1350_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5aaf1f8b4545fab40570d09fcba124528d766fdf9e32d75419fc518de8fa0360
+size 29815590

Planes/Horizontal/Forward_1360_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:327b2fbf453314b0516a7d792523f4ebe9166597e1ff516eef0b9848d8394065
+size 29815590

Planes/Horizontal/Forward_1370_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:643404af8b505bf5d602cdfd55e638dce9679ea24f9b416e67411a2a3218ba44
+size 29815590

Planes/Horizontal/Forward_1380_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b45dc13899f116a6dd16fde858e135f92b6c9031f84777767fc2591a384fe91a
+size 29815590

Planes/Horizontal/Forward_1390_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:886a701af9a39f62a3928f8b0d6eb85cb8723bf2ec70c0e58b61f11bdb211b2c
+size 29815590

Planes/Horizontal/Forward_1400_ms_Angle_00_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b1a028d407a5531052e1932fbb8b3b92dfec8a49b0d6520816a4cb8a71ffe9f
+size 29815590

Planes/Horizontal/Forward_1400_ms_Angle_05_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:436b05f09ad6ef3bbdb0b5d545f8b24d78d43dd0fa5cd483844a71792238077d
+size 29815590

Planes/Horizontal/Forward_1400_ms_Angle_10_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:824bb06fb45ec79bd1e9984be6ef9396a373bd129d2f2469a3ff5b3065e81227
+size 29815590

Planes/Horizontal/Forward_1400_ms_Angle_15_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d0bc2d82ed2f709b743b17528540f5d9b857012906dbe21c1855169cd99d3cc
+size 29815590

Planes/Horizontal/Forward_1400_ms_Angle_20_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec53892977a94dd1bd43a94a9faee5b8441b49d17558aa62f6225270fa8a9c44
+size 29815590

Planes/Horizontal/Forward_1400_ms_Angle_25_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0cd8a21e339d5338a298c544d4d1575647045e4ca43c3b57f1a0f356422da518
+size 29815590

Planes/Horizontal/Forward_1400_ms_Angle_30_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05dd922276cce1aa252a4c6014d1fa38d02b0f38535bb4713be9aad70acfb551
+size 29815590

Planes/Horizontal/Forward_1400_ms_Angle_35_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d3596c76201383e02881de1a563dc5b89d82e51a71ccf648d452f9b6536a6d6b
+size 29815590

Planes/Horizontal/Forward_1400_ms_Angle_40_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3dffc6b875a29c51d4edc58371de44ce0ea790c96a39c10d215a8fea4d3934e6
+size 29815590

Planes/Horizontal/Forward_1400_ms_Angle_45_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:80884f8256b4944475ffbf7b2ac5d67e1f7f2087daa6e3d6038adf561058c6a9
+size 29815590

Planes/Horizontal/Forward_1400_ms_Angle_50_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:caeccf34db43ff3421aee2cf33f83aa7267472031da45d95c2d7df51aa757caa
+size 29815590

Planes/Horizontal/Forward_1400_ms_Angle_55_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f98d553e3d273acc4bb7a0d93a64a1563092be4510f7e4e54fb6d5102fb7b91
+size 29815590

Planes/Horizontal/Forward_1400_ms_Angle_60_HORZPLN_ALL

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2a03010b76dde873a053a16ef9b80d6f6c60c506bc83bdebd39a6f5f6d7bc1df
+size 29815590