File size: 6,155 Bytes
b5241eb |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 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}") |