Datasets:

andreacenzato
/

Ground-Wing

"""Surface-field screenshots of the benchmark predictions on one reference test run.
Renders the surface fields seen from below, looking towards +Z.
One PNG per model per quantity; the panels are composed side by side in the
paper's LaTeX rather than montaged here.
Outputs, under ``outputs/fields/``:
    cp_truth.png              CFD ground-truth surface C_p
    cp_pred_<model>.png       predicted C_p, one per model
    cp_err_<model>.png        signed error (prediction - truth), one per model
    ws_truth.png              CFD ground-truth |w_s|
    ws_pred_<model>.png       predicted |w_s|, one per model
Run surface_metrics.py first: the panels are ordered by each model's mean $C_l$ error.
"""

from __future__ import annotations

import sys
from pathlib import Path

import numpy as np
import pyvista as pv

sys.path.insert(0, str(Path(__file__).resolve().parent))

from inference_io import (  # noqa: E402
    field_keys,
    here,
    model_labels,
    load_coefficients,
    mesh_files,
    read_field,
    relative_error,
    reported_models,
)

pv.OFF_SCREEN = True

reference_run = "0169_7575"
reference_split = "stratified"

output_dir = here / "outputs" / "fields"
output_dir.mkdir(parents=True, exist_ok=True)

cp_field = "MeanPressureCoefficient"
ws_field = "MeanWallShearStress"
assert set(field_keys) == {cp_field, ws_field}, field_keys

colormap = "turbo"

window_size = (1700, 780)

# (colour limits, colourbar title) per rendered quantity
specs = {
    "cp": ((-2.0, 1.0), r"$C_p$"),
    "cp_err": ((-0.3, 0.3), r"$\Delta C_p$"),
    "ws": ((0.0, 25.0), r"$w_s$"),
}


def ranked_models() -> list[str]:
    """Model keys ordered by mean relative Cl error on the stratified split, best first."""
    err = {
        model: relative_error(load_coefficients("stratified", model), "Cl").mean()
        for model in reported_models()
    }
    return sorted(err, key=err.get)


def attach(mesh, values, name="field"):
    """Attach `values` to the mesh, choosing cell or point association by length."""
    if len(values) == mesh.n_cells:
        mesh.cell_data[name] = values
    elif len(values) == mesh.n_points:
        mesh.point_data[name] = values
    else:
        raise ValueError(
            f"{len(values)} values match neither n_cells={mesh.n_cells} "
            f"nor n_points={mesh.n_points}"
        )
    return name


def field_values(mesh, field: str, kind: str) -> np.ndarray:
    """Ground truth, prediction or signed error (prediction - truth) of one field.
    The wall shear stress is a vector, and the paper reports its magnitude.
    """
    truth = read_field(mesh, field)
    pred = read_field(mesh, f"{field}Pred")
    if truth.ndim == 2:
        truth = np.linalg.norm(truth, axis=1)
        pred = np.linalg.norm(pred, axis=1)
    return {"truth": truth, "pred": pred, "error": pred - truth}[kind]


def render(mesh, name: str, clim, title: str, path: Path) -> Path:
    """Bottom view of one field: camera below the wing, looking towards +Z."""
    plotter = pv.Plotter(off_screen=True, window_size=window_size)
    plotter.set_background("white")
    plotter.add_mesh(
        mesh, scalars=name, cmap=colormap, clim=clim, lighting=False, show_scalar_bar=False
    )
    plotter.add_scalar_bar(
        title=title,
        vertical=False,
        position_x=0.20,
        position_y=0.10,
        width=0.60,
        height=0.055,
        title_font_size=34,
        label_font_size=28,
        color="black",
        n_labels=5,
        fmt="%.1f",
    )

    # +X (chord) points up in the frame, so the span runs horizontally. Parallel projection
    # with an explicit scale keeps the framing pixel-identical across every panel.
    plotter.view_xy(negative=True)
    plotter.camera.up = (1.0, 0.0, 0.0)
    plotter.enable_parallel_projection()

    bounds = mesh.bounds
    scale = ((bounds.y_max - bounds.y_min) / 2) / (window_size[0] / window_size[1]) / 0.96
    mid_x = (bounds.x_min + bounds.x_max) / 2
    mid_y = (bounds.y_min + bounds.y_max) / 2
    mid_z = (bounds.z_min + bounds.z_max) / 2
    lift = 0.34 * scale  # frees the bottom band of the frame for the colourbar
    plotter.camera.parallel_scale = scale
    plotter.camera.focal_point = (mid_x - lift, mid_y, mid_z)
    plotter.camera.position = (mid_x - lift, mid_y, bounds.z_min - 5.0)

    plotter.add_axes(
        color="black",
        xlabel="x",
        ylabel="y",
        zlabel="z",
        viewport=(0.005, 0.02, 0.095, 0.27),
        label_size=(0.20, 0.13),
    )
    plotter.screenshot(str(path))
    plotter.close()
    return path


def emit(mesh, field: str, kind: str, spec: str, path: Path) -> Path:
    """Render one panel."""
    values = field_values(mesh, field, kind)
    clim, title = specs[spec]
    render(mesh, attach(mesh, values), clim, title, path)
    return path


def main() -> None:
    order = ranked_models()
    print("reference run :", reference_run, f"({reference_split} split)")
    print("model order   :", ", ".join(model_labels[m] for m in order))

    # Surface C_p: ground truth, the six predictions, and the six signed error fields. The
    # ground truth is the same CFD field on the same mesh for every model, so it is rendered
    # once, from the best-ranked model's copy.
    truth_mesh = pv.read(mesh_files(reference_split, order[0])[reference_run])
    emit(truth_mesh, cp_field, "truth", "cp", output_dir / "cp_truth.png")
    print("rendered C_p ground truth")

    for model in order:
        mesh = pv.read(mesh_files(reference_split, model)[reference_run])
        emit(mesh, cp_field, "pred", "cp", output_dir / f"cp_pred_{model}.png")
        emit(mesh, cp_field, "error", "cp_err", output_dir / f"cp_err_{model}.png")
        print(f"rendered C_p {model_labels[model]}")

    # Surface wall-shear-stress magnitude: ground truth and the six predictions.
    truth_mesh = pv.read(mesh_files(reference_split, order[0])[reference_run])
    emit(truth_mesh, ws_field, "truth", "ws", output_dir / "ws_truth.png")
    print("rendered |w_s| ground truth")

    for model in order:
        mesh = pv.read(mesh_files(reference_split, model)[reference_run])
        emit(mesh, ws_field, "pred", "ws", output_dir / f"ws_pred_{model}.png")
        print(f"rendered |w_s| {model_labels[model]}")

    print(f"\nwrote 20 panels to {output_dir}")


if __name__ == "__main__":
    main()

	"""Surface-field screenshots of the benchmark predictions on one reference test run.

	Renders the surface fields seen from below, looking towards +Z.
	One PNG per model per quantity; the panels are composed side by side in the
	paper's LaTeX rather than montaged here.

	Outputs, under ``outputs/fields/``:

	cp_truth.png CFD ground-truth surface C_p
	cp_pred_<model>.png predicted C_p, one per model
	cp_err_<model>.png signed error (prediction - truth), one per model
	ws_truth.png CFD ground-truth \|w_s\|
	ws_pred_<model>.png predicted \|w_s\|, one per model

	Run surface_metrics.py first: the panels are ordered by each model's mean $C_l$ error.
	"""

	from __future__ import annotations

	import sys
	from pathlib import Path

	import numpy as np
	import pyvista as pv

	sys.path.insert(0, str(Path(__file__).resolve().parent))

	from inference_io import ( # noqa: E402
	field_keys,
	here,
	model_labels,
	load_coefficients,
	mesh_files,
	read_field,
	relative_error,
	reported_models,
	)

	pv.OFF_SCREEN = True

	reference_run = "0169_7575"
	reference_split = "stratified"

	output_dir = here / "outputs" / "fields"
	output_dir.mkdir(parents=True, exist_ok=True)

	cp_field = "MeanPressureCoefficient"
	ws_field = "MeanWallShearStress"
	assert set(field_keys) == {cp_field, ws_field}, field_keys

	colormap = "turbo"

	window_size = (1700, 780)

	# (colour limits, colourbar title) per rendered quantity
	specs = {
	"cp": ((-2.0, 1.0), r"$C_p$"),
	"cp_err": ((-0.3, 0.3), r"$\Delta C_p$"),
	"ws": ((0.0, 25.0), r"$w_s$"),
	}


	def ranked_models() -> list[str]:
	"""Model keys ordered by mean relative Cl error on the stratified split, best first."""
	err = {
	model: relative_error(load_coefficients("stratified", model), "Cl").mean()
	for model in reported_models()
	}
	return sorted(err, key=err.get)


	def attach(mesh, values, name="field"):
	"""Attach `values` to the mesh, choosing cell or point association by length."""
	if len(values) == mesh.n_cells:
	mesh.cell_data[name] = values
	elif len(values) == mesh.n_points:
	mesh.point_data[name] = values
	else:
	raise ValueError(
	f"{len(values)} values match neither n_cells={mesh.n_cells} "
	f"nor n_points={mesh.n_points}"
	)
	return name


	def field_values(mesh, field: str, kind: str) -> np.ndarray:
	"""Ground truth, prediction or signed error (prediction - truth) of one field.

	The wall shear stress is a vector, and the paper reports its magnitude.
	"""
	truth = read_field(mesh, field)
	pred = read_field(mesh, f"{field}Pred")
	if truth.ndim == 2:
	truth = np.linalg.norm(truth, axis=1)
	pred = np.linalg.norm(pred, axis=1)
	return {"truth": truth, "pred": pred, "error": pred - truth}[kind]


	def render(mesh, name: str, clim, title: str, path: Path) -> Path:
	"""Bottom view of one field: camera below the wing, looking towards +Z."""
	plotter = pv.Plotter(off_screen=True, window_size=window_size)
	plotter.set_background("white")
	plotter.add_mesh(
	mesh, scalars=name, cmap=colormap, clim=clim, lighting=False, show_scalar_bar=False
	)
	plotter.add_scalar_bar(
	title=title,
	vertical=False,
	position_x=0.20,
	position_y=0.10,
	width=0.60,
	height=0.055,
	title_font_size=34,
	label_font_size=28,
	color="black",
	n_labels=5,
	fmt="%.1f",
	)

	# +X (chord) points up in the frame, so the span runs horizontally. Parallel projection
	# with an explicit scale keeps the framing pixel-identical across every panel.
	plotter.view_xy(negative=True)
	plotter.camera.up = (1.0, 0.0, 0.0)
	plotter.enable_parallel_projection()

	bounds = mesh.bounds
	scale = ((bounds.y_max - bounds.y_min) / 2) / (window_size[0] / window_size[1]) / 0.96
	mid_x = (bounds.x_min + bounds.x_max) / 2
	mid_y = (bounds.y_min + bounds.y_max) / 2
	mid_z = (bounds.z_min + bounds.z_max) / 2
	lift = 0.34 * scale # frees the bottom band of the frame for the colourbar
	plotter.camera.parallel_scale = scale
	plotter.camera.focal_point = (mid_x - lift, mid_y, mid_z)
	plotter.camera.position = (mid_x - lift, mid_y, bounds.z_min - 5.0)

	plotter.add_axes(
	color="black",
	xlabel="x",
	ylabel="y",
	zlabel="z",
	viewport=(0.005, 0.02, 0.095, 0.27),
	label_size=(0.20, 0.13),
	)
	plotter.screenshot(str(path))
	plotter.close()
	return path


	def emit(mesh, field: str, kind: str, spec: str, path: Path) -> Path:
	"""Render one panel."""
	values = field_values(mesh, field, kind)
	clim, title = specs[spec]
	render(mesh, attach(mesh, values), clim, title, path)
	return path


	def main() -> None:
	order = ranked_models()
	print("reference run :", reference_run, f"({reference_split} split)")
	print("model order :", ", ".join(model_labels[m] for m in order))

	# Surface C_p: ground truth, the six predictions, and the six signed error fields. The
	# ground truth is the same CFD field on the same mesh for every model, so it is rendered
	# once, from the best-ranked model's copy.
	truth_mesh = pv.read(mesh_files(reference_split, order[0])[reference_run])
	emit(truth_mesh, cp_field, "truth", "cp", output_dir / "cp_truth.png")
	print("rendered C_p ground truth")

	for model in order:
	mesh = pv.read(mesh_files(reference_split, model)[reference_run])
	emit(mesh, cp_field, "pred", "cp", output_dir / f"cp_pred_{model}.png")
	emit(mesh, cp_field, "error", "cp_err", output_dir / f"cp_err_{model}.png")
	print(f"rendered C_p {model_labels[model]}")

	# Surface wall-shear-stress magnitude: ground truth and the six predictions.
	truth_mesh = pv.read(mesh_files(reference_split, order[0])[reference_run])
	emit(truth_mesh, ws_field, "truth", "ws", output_dir / "ws_truth.png")
	print("rendered \|w_s\| ground truth")

	for model in order:
	mesh = pv.read(mesh_files(reference_split, model)[reference_run])
	emit(mesh, ws_field, "pred", "ws", output_dir / f"ws_pred_{model}.png")
	print(f"rendered \|w_s\| {model_labels[model]}")

	print(f"\nwrote 20 panels to {output_dir}")


	if __name__ == "__main__":
	main()