drbx 2.0.0.dev0__py3-none-any.whl

drbx/validation/stellarator_neutral_physics_campaign.py

@@ -0,0 +1,255 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from matplotlib import pyplot as plt
+import numpy as np
+
+from ..geometry import build_synthetic_stellarator_geometry
+from ..native.fci_neutral import compute_fci_neutral_reaction_diffusion
+
+
+@dataclass(frozen=True)
+class StellaratorNeutralPhysicsCampaignArtifacts:
+    report_json_path: Path
+    arrays_npz_path: Path
+    plot_png_path: Path
+
+
+def create_stellarator_neutral_physics_campaign_package(
+    *,
+    output_root: str | Path,
+    case_label: str = "stellarator_neutral_physics_campaign",
+    nx: int = 34,
+    ny: int = 30,
+    nz: int = 60,
+) -> StellaratorNeutralPhysicsCampaignArtifacts:
+    root = Path(output_root)
+    data_dir = root / "data"
+    images_dir = root / "images"
+    data_dir.mkdir(parents=True, exist_ok=True)
+    images_dir.mkdir(parents=True, exist_ok=True)
+    report, arrays = build_stellarator_neutral_physics_campaign(nx=nx, ny=ny, nz=nz)
+    report_json_path = data_dir / f"{case_label}.json"
+    report_json_path.write_text(json.dumps(report, indent=2, sort_keys=True), encoding="utf-8")
+    arrays_npz_path = data_dir / f"{case_label}.npz"
+    np.savez_compressed(arrays_npz_path, **arrays)
+    plot_png_path = images_dir / f"{case_label}.png"
+    save_stellarator_neutral_physics_plot(report, arrays, plot_png_path)
+    return StellaratorNeutralPhysicsCampaignArtifacts(
+        report_json_path=report_json_path,
+        arrays_npz_path=arrays_npz_path,
+        plot_png_path=plot_png_path,
+    )
+
+
+def build_stellarator_neutral_physics_campaign(
+    *,
+    nx: int = 34,
+    ny: int = 30,
+    nz: int = 60,
+) -> tuple[dict[str, Any], dict[str, np.ndarray]]:
+    geometry = build_synthetic_stellarator_geometry(nx=nx, ny=ny, nz=nz)
+    radial = np.asarray(geometry.radial, dtype=np.float64)
+    theta = np.asarray(geometry.poloidal_angle, dtype=np.float64)
+    phi = np.asarray(geometry.toroidal_angle, dtype=np.float64)
+
+    neutral_density = 0.12 + 0.62 * np.exp(-((radial - 0.93) / 0.08) ** 2) * (
+        1.0 + 0.18 * np.cos(2.0 * theta - 5.0 * phi)
+    )
+    ion_density = 0.35 + 1.0 * np.exp(-((radial - 0.68) / 0.20) ** 2)
+    electron_density = ion_density * (1.0 + 0.015 * np.cos(theta - 5.0 * phi))
+    neutral_temperature = 0.035 + 0.020 * radial
+    ion_temperature = 0.075 + 0.12 * (1.0 - radial)
+    electron_temperature = 0.095 + 0.16 * (1.0 - radial)
+    neutral_pressure = neutral_density * neutral_temperature
+    ion_pressure = ion_density * ion_temperature
+    electron_pressure = electron_density * electron_temperature
+    neutral_velocity = 0.025 * np.sin(theta - 5.0 * phi)
+    ion_velocity = 0.040 * np.cos(2.0 * theta - 5.0 * phi)
+    neutral_momentum = neutral_density * neutral_velocity
+    ion_momentum = ion_density * ion_velocity
+
+    result = compute_fci_neutral_reaction_diffusion(
+        neutral_density=neutral_density,
+        neutral_pressure=neutral_pressure,
+        neutral_momentum=neutral_momentum,
+        ion_density=ion_density,
+        ion_pressure=ion_pressure,
+        ion_momentum=ion_momentum,
+        electron_density=electron_density,
+        electron_pressure=electron_pressure,
+        maps=geometry.maps,
+        metric=geometry.metric,
+    )
+
+    ionisation = np.asarray(result.ionisation_rate, dtype=np.float64)
+    recombination = np.asarray(result.recombination_rate, dtype=np.float64)
+    charge_exchange = np.asarray(result.charge_exchange_rate, dtype=np.float64)
+    neutral_diffusion = np.asarray(result.neutral_diffusion_source, dtype=np.float64)
+    neutral_source = np.asarray(result.neutral_density_source, dtype=np.float64)
+    ion_source = np.asarray(result.ion_density_source, dtype=np.float64)
+    momentum_pair = np.asarray(result.neutral_momentum_source + result.ion_momentum_source, dtype=np.float64)
+
+    total_ionisation = float(np.sum(ionisation))
+    total_recombination = float(np.sum(recombination))
+    total_charge_exchange = float(np.sum(charge_exchange))
+    particle_residual = float(np.asarray(result.total_particle_residual))
+    momentum_residual = float(np.asarray(result.total_momentum_residual))
+    particle_relative_error = abs(particle_residual) / max(total_ionisation + total_recombination, 1.0e-30)
+    momentum_relative_error = abs(momentum_residual) / max(float(np.sum(np.abs(momentum_pair))) + 1.0e-30, 1.0e-30)
+    jacobian = np.asarray(geometry.metric.J, dtype=np.float64)
+    diffusion_integral = float(np.sum(jacobian * neutral_diffusion))
+    diffusion_relative_integral = abs(diffusion_integral) / max(float(np.sum(np.abs(jacobian * neutral_diffusion))), 1.0e-30)
+    cx_to_ionisation_ratio = total_charge_exchange / max(total_ionisation, 1.0e-30)
+
+    report: dict[str, Any] = {
+        "case": "non_axisymmetric_neutral_diffusion_reaction_gate",
+        "geometry": geometry.metadata,
+        "total_ionisation": total_ionisation,
+        "total_recombination": total_recombination,
+        "total_charge_exchange": total_charge_exchange,
+        "cx_to_ionisation_ratio": cx_to_ionisation_ratio,
+        "particle_reaction_residual": particle_residual,
+        "particle_reaction_relative_error": particle_relative_error,
+        "momentum_reaction_residual": momentum_residual,
+        "momentum_reaction_relative_error": momentum_relative_error,
+        "neutral_diffusion_integral": diffusion_integral,
+        "neutral_diffusion_relative_integral": diffusion_relative_integral,
+        "max_ionisation_rate": float(np.max(ionisation)),
+        "max_charge_exchange_rate": float(np.max(charge_exchange)),
+    }
+    report["passed"] = (
+        total_ionisation > 0.0
+        and total_recombination > 0.0
+        and total_charge_exchange > 0.0
+        and particle_relative_error < 1.0e-12
+        and momentum_relative_error < 1.0e-12
+        and diffusion_relative_integral < 2.0e-2
+        and cx_to_ionisation_ratio > 0.05
+    )
+    arrays = {
+        "ionisation_toroidal": np.sum(ionisation, axis=0).astype(np.float32),
+        "recombination_toroidal": np.sum(recombination, axis=0).astype(np.float32),
+        "charge_exchange_toroidal": np.sum(charge_exchange, axis=0).astype(np.float32),
+        "neutral_source_toroidal": np.sum(neutral_source, axis=0).astype(np.float32),
+        "ion_source_toroidal": np.sum(ion_source, axis=0).astype(np.float32),
+        "neutral_density_slice": neutral_density[:, 0, :].astype(np.float32),
+        "radial_grid": np.mean(radial, axis=(1, 2)).astype(np.float32),
+        "radial_rates": np.stack(
+            [
+                np.mean(neutral_density, axis=(1, 2)),
+                np.sum(ionisation, axis=(1, 2)),
+                np.sum(recombination, axis=(1, 2)),
+                np.sum(charge_exchange, axis=(1, 2)),
+            ],
+            axis=1,
+        ).astype(np.float32),
+        "summary": np.asarray(
+            [
+                total_ionisation,
+                total_recombination,
+                total_charge_exchange,
+                abs(particle_residual),
+                abs(momentum_residual),
+            ],
+            dtype=np.float32,
+        ),
+    }
+    return report, arrays
+
+
+def save_stellarator_neutral_physics_plot(
+    report: dict[str, Any],
+    arrays: dict[str, np.ndarray],
+    path: str | Path,
+) -> Path:
+    resolved = Path(path)
+    resolved.parent.mkdir(parents=True, exist_ok=True)
+    fig, axes = plt.subplots(2, 3, figsize=(15.6, 8.8), constrained_layout=True)
+    extent = [0.0, 2.0 * np.pi, 0.0, 2.0 * np.pi]
+
+    image0 = axes[0, 0].imshow(arrays["ionisation_toroidal"].T, origin="lower", aspect="auto", extent=extent, cmap="inferno")
+    axes[0, 0].set_title("ionisation source")
+    axes[0, 0].set_xlabel("toroidal angle")
+    axes[0, 0].set_ylabel("poloidal angle")
+    fig.colorbar(image0, ax=axes[0, 0])
+
+    image1 = axes[0, 1].imshow(
+        arrays["charge_exchange_toroidal"].T,
+        origin="lower",
+        aspect="auto",
+        extent=extent,
+        cmap="magma",
+    )
+    axes[0, 1].set_title("charge-exchange rate")
+    axes[0, 1].set_xlabel("toroidal angle")
+    axes[0, 1].set_ylabel("poloidal angle")
+    fig.colorbar(image1, ax=axes[0, 1])
+
+    signed = arrays["ion_source_toroidal"].T + arrays["neutral_source_toroidal"].T
+    vmax = float(np.max(np.abs(signed)))
+    image2 = axes[0, 2].imshow(
+        signed,
+        origin="lower",
+        aspect="auto",
+        extent=extent,
+        cmap="coolwarm",
+        vmin=-vmax,
+        vmax=vmax,
+    )
+    axes[0, 2].set_title("local plasma + neutral source")
+    axes[0, 2].set_xlabel("toroidal angle")
+    axes[0, 2].set_ylabel("poloidal angle")
+    fig.colorbar(image2, ax=axes[0, 2])
+
+    radial_grid = arrays["radial_grid"]
+    radial_rates = arrays["radial_rates"]
+    axes[1, 0].plot(radial_grid, radial_rates[:, 0] / np.max(radial_rates[:, 0]), lw=2.0, label="neutral density")
+    axes[1, 0].plot(radial_grid, radial_rates[:, 1] / np.max(radial_rates[:, 1]), lw=2.0, label="ionisation")
+    axes[1, 0].plot(radial_grid, radial_rates[:, 2] / np.max(radial_rates[:, 2]), lw=2.0, label="recombination")
+    axes[1, 0].plot(radial_grid, radial_rates[:, 3] / np.max(radial_rates[:, 3]), lw=2.0, label="charge exchange")
+    axes[1, 0].set_title("normalized radial reaction profiles")
+    axes[1, 0].set_xlabel("normalized radius")
+    axes[1, 0].grid(alpha=0.25)
+    axes[1, 0].legend(frameon=False, fontsize=8)
+
+    image3 = axes[1, 1].imshow(arrays["neutral_density_slice"], origin="lower", aspect="auto", cmap="viridis")
+    axes[1, 1].set_title("neutral density at one toroidal plane")
+    axes[1, 1].set_xlabel("poloidal index")
+    axes[1, 1].set_ylabel("radial index")
+    fig.colorbar(image3, ax=axes[1, 1])
+
+    summary = arrays["summary"]
+    labels = ["ion", "rec", "CX", "particle err", "mom err"]
+    axes[1, 2].bar(np.arange(summary.size), summary, color=["#9b2226", "#005f73", "#ee9b00", "#94d2bd", "#0a9396"])
+    axes[1, 2].set_xticks(np.arange(summary.size), labels, rotation=18, ha="right")
+    axes[1, 2].set_yscale("log")
+    axes[1, 2].grid(axis="y", alpha=0.25)
+    axes[1, 2].set_title("integrated reaction balance")
+    axes[1, 2].text(
+        0.03,
+        0.96,
+        "\n".join(
+            [
+                f"particle rel. err = {report['particle_reaction_relative_error']:.1e}",
+                f"momentum rel. err = {report['momentum_reaction_relative_error']:.1e}",
+                f"CX / ionisation = {report['cx_to_ionisation_ratio']:.2f}",
+            ]
+        ),
+        transform=axes[1, 2].transAxes,
+        va="top",
+        ha="left",
+        fontsize=8,
+        bbox={"facecolor": "white", "alpha": 0.82, "edgecolor": "0.8"},
+    )
+    fig.suptitle(
+        "Non-axisymmetric neutral gate: diffusion plus ionisation, recombination, and charge exchange",
+        fontsize=14,
+    )
+    fig.savefig(resolved, dpi=190)
+    plt.close(fig)
+    return resolved

drbx/validation/stellarator_sheath_recycling_campaign.py

@@ -0,0 +1,331 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from matplotlib import pyplot as plt
+import numpy as np
+
+from ..geometry import build_synthetic_stellarator_geometry
+from ..native.fci_sheath_recycling import compute_fci_sheath_recycling
+
+
+@dataclass(frozen=True)
+class StellaratorSheathRecyclingCampaignArtifacts:
+    report_json_path: Path
+    arrays_npz_path: Path
+    plot_png_path: Path
+
+
+def create_stellarator_sheath_recycling_campaign_package(
+    *,
+    output_root: str | Path,
+    case_label: str = "stellarator_sheath_recycling_campaign",
+    nx: int = 36,
+    ny: int = 32,
+    nz: int = 64,
+) -> StellaratorSheathRecyclingCampaignArtifacts:
+    root = Path(output_root)
+    data_dir = root / "data"
+    images_dir = root / "images"
+    data_dir.mkdir(parents=True, exist_ok=True)
+    images_dir.mkdir(parents=True, exist_ok=True)
+
+    report, arrays = build_stellarator_sheath_recycling_campaign(nx=nx, ny=ny, nz=nz)
+    report_json_path = data_dir / f"{case_label}.json"
+    report_json_path.write_text(json.dumps(report, indent=2, sort_keys=True), encoding="utf-8")
+    arrays_npz_path = data_dir / f"{case_label}.npz"
+    np.savez_compressed(arrays_npz_path, **arrays)
+    plot_png_path = images_dir / f"{case_label}.png"
+    save_stellarator_sheath_recycling_plot(report, arrays, plot_png_path)
+    return StellaratorSheathRecyclingCampaignArtifacts(
+        report_json_path=report_json_path,
+        arrays_npz_path=arrays_npz_path,
+        plot_png_path=plot_png_path,
+    )
+
+
+def build_stellarator_sheath_recycling_campaign(
+    *,
+    nx: int = 36,
+    ny: int = 32,
+    nz: int = 64,
+) -> tuple[dict[str, Any], dict[str, np.ndarray]]:
+    geometry = build_synthetic_stellarator_geometry(nx=nx, ny=ny, nz=nz)
+    radial = np.asarray(geometry.radial, dtype=np.float64)
+    theta = np.asarray(geometry.poloidal_angle, dtype=np.float64)
+    phi = np.asarray(geometry.toroidal_angle, dtype=np.float64)
+    connection = np.asarray(geometry.connection_length, dtype=np.float64)
+
+    density = (
+        0.28
+        + 1.10 * np.exp(-((radial - 0.70) / 0.19) ** 2)
+        + 0.15 * np.exp(-((radial - 0.91) / 0.06) ** 2) * (1.0 + np.cos(2.0 * theta - 5.0 * phi))
+    )
+    electron_temperature = (
+        0.055
+        + 0.18 * (1.0 - radial) ** 1.25
+        + 0.018 * np.cos(theta - 5.0 * phi)
+        + 0.010 * np.sin(3.0 * theta + 4.0 * phi)
+    )
+    ion_temperature = (
+        0.050
+        + 0.13 * (1.0 - radial) ** 1.10
+        + 0.015 * np.sin(2.0 * theta - 5.0 * phi + 0.35)
+    )
+    density = np.maximum(density, 1.0e-4)
+    electron_temperature = np.maximum(electron_temperature, 5.0e-3)
+    ion_temperature = np.maximum(ion_temperature, 5.0e-3)
+
+    result = compute_fci_sheath_recycling(
+        density,
+        electron_temperature,
+        ion_temperature,
+        geometry.maps,
+        recycling_fraction=0.97,
+        electron_sheath_transmission=5.0,
+        ion_sheath_transmission=3.5,
+        recycled_neutral_energy=0.025,
+    )
+
+    target_mask = np.asarray(result.masks.active, dtype=bool)
+    endpoint_count = np.asarray(result.masks.endpoint_count, dtype=np.float64)
+    heat_load = np.asarray(result.target_heat_load, dtype=np.float64)
+    particle_loss = np.asarray(result.ion_particle_loss, dtype=np.float64)
+    recycled_source = np.asarray(result.recycled_particle_source, dtype=np.float64)
+    neutral_energy = np.asarray(result.recycled_neutral_energy_source, dtype=np.float64)
+    current_residual = np.asarray(result.current_residual, dtype=np.float64)
+
+    total_particle_loss = float(np.asarray(result.total_ion_particle_loss))
+    total_recycled_particle_source = float(np.asarray(result.total_recycled_particle_source))
+    total_heat_load = float(np.asarray(result.total_target_heat_load))
+    total_recycled_neutral_energy = float(np.asarray(result.total_recycled_neutral_energy))
+    particle_recycling_relative_error = float(
+        abs(np.asarray(result.particle_recycling_residual)) / max(total_recycled_particle_source, 1.0e-30)
+    )
+    neutral_energy_relative_error = float(
+        abs(np.asarray(result.neutral_energy_recycling_residual)) / max(total_recycled_neutral_energy, 1.0e-30)
+    )
+    current_balance_relative_error = float(
+        abs(np.asarray(result.current_balance_residual)) / max(total_particle_loss, 1.0e-30)
+    )
+    target_fraction = float(np.mean(target_mask))
+    positive_heat = heat_load[heat_load > 0.0]
+    heat_load_contrast = float(np.percentile(positive_heat, 99.0) / max(np.percentile(positive_heat, 50.0), 1.0e-30))
+    short_connection_mask = connection <= np.percentile(connection, 35.0)
+    short_connection_heat_fraction = float(
+        np.sum(heat_load[short_connection_mask]) / max(np.sum(heat_load), 1.0e-30)
+    )
+    heat_connection_correlation = _finite_corrcoef(
+        np.ravel(heat_load[target_mask]),
+        np.ravel(1.0 / np.maximum(connection[target_mask], 1.0e-12)),
+    )
+    endpoint_heat_fraction = float(np.sum(heat_load[target_mask]) / max(np.sum(heat_load), 1.0e-30))
+    max_current_residual = float(np.max(np.abs(current_residual)))
+
+    report: dict[str, Any] = {
+        "case": "non_axisymmetric_fci_sheath_recycling",
+        "geometry": geometry.metadata,
+        "model": {
+            "recycling_fraction": 0.97,
+            "electron_sheath_transmission": 5.0,
+            "ion_sheath_transmission": 3.5,
+            "recycled_neutral_energy": 0.025,
+            "sound_speed": "sqrt((Te + Ti) / mi)",
+            "ion_particle_loss": "endpoint_count * n * sound_speed",
+            "electron_particle_loss": "ion_particle_loss by zero-current reconstruction",
+            "electron_heat_loss": "gamma_e * ion_particle_loss * Te",
+            "ion_heat_loss": "gamma_i * ion_particle_loss * Ti",
+            "recycled_particle_source": "recycling_fraction * ion_particle_loss",
+        },
+        "target_fraction": target_fraction,
+        "total_particle_loss": total_particle_loss,
+        "total_recycled_particle_source": total_recycled_particle_source,
+        "total_heat_load": total_heat_load,
+        "total_recycled_neutral_energy": total_recycled_neutral_energy,
+        "particle_recycling_relative_error": particle_recycling_relative_error,
+        "neutral_energy_relative_error": neutral_energy_relative_error,
+        "current_balance_relative_error": current_balance_relative_error,
+        "max_current_residual": max_current_residual,
+        "heat_load_contrast": heat_load_contrast,
+        "short_connection_heat_fraction": short_connection_heat_fraction,
+        "heat_inverse_connection_correlation": heat_connection_correlation,
+        "endpoint_heat_fraction": endpoint_heat_fraction,
+    }
+    report["passed"] = (
+        0.002 < target_fraction < 0.35
+        and total_particle_loss > 0.0
+        and total_heat_load > 0.0
+        and particle_recycling_relative_error < 1.0e-12
+        and neutral_energy_relative_error < 1.0e-12
+        and current_balance_relative_error < 1.0e-12
+        and max_current_residual < 1.0e-12
+        and heat_load_contrast > 1.05
+        and short_connection_heat_fraction > 0.05
+        and endpoint_heat_fraction > 0.999999
+    )
+
+    heat_toroidal = np.sum(heat_load, axis=0)
+    loss_toroidal = np.sum(particle_loss, axis=0)
+    source_toroidal = np.sum(recycled_source, axis=0)
+    mask_toroidal = np.sum(endpoint_count, axis=0)
+    connection_heat_weighted = np.sum(connection * heat_load, axis=0) / np.maximum(np.sum(heat_load, axis=0), 1.0e-30)
+    radial_profile = np.stack(
+        [
+            np.mean(density, axis=(1, 2)),
+            np.sum(particle_loss, axis=(1, 2)),
+            np.sum(heat_load, axis=(1, 2)),
+            np.sum(recycled_source, axis=(1, 2)),
+        ],
+        axis=1,
+    )
+    toroidal_profile = np.stack(
+        [
+            np.sum(particle_loss, axis=(0, 2)),
+            np.sum(heat_load, axis=(0, 2)),
+            np.sum(recycled_source, axis=(0, 2)),
+        ],
+        axis=1,
+    )
+    summary_bars = np.asarray(
+        [
+            total_particle_loss,
+            total_recycled_particle_source,
+            total_heat_load,
+            total_recycled_neutral_energy,
+        ],
+        dtype=np.float64,
+    )
+    arrays = {
+        "target_mask_toroidal": mask_toroidal.astype(np.float32),
+        "particle_loss_toroidal": loss_toroidal.astype(np.float32),
+        "heat_load_toroidal": heat_toroidal.astype(np.float32),
+        "recycled_source_toroidal": source_toroidal.astype(np.float32),
+        "connection_toroidal_heat_weighted": connection_heat_weighted.astype(np.float32),
+        "radial_grid": np.mean(radial, axis=(1, 2)).astype(np.float32),
+        "radial_profile": radial_profile.astype(np.float32),
+        "toroidal_angle": np.mean(phi, axis=(0, 2)).astype(np.float32),
+        "toroidal_profile": toroidal_profile.astype(np.float32),
+        "summary_bars": summary_bars.astype(np.float32),
+    }
+    return report, arrays
+
+
+def save_stellarator_sheath_recycling_plot(
+    report: dict[str, Any],
+    arrays: dict[str, np.ndarray],
+    path: str | Path,
+) -> Path:
+    resolved = Path(path)
+    resolved.parent.mkdir(parents=True, exist_ok=True)
+
+    fig, axes = plt.subplots(2, 3, figsize=(15.8, 9.2), constrained_layout=True)
+    extent = [0.0, 2.0 * np.pi, 0.0, 2.0 * np.pi]
+
+    loss_image = axes[0, 0].imshow(
+        arrays["particle_loss_toroidal"].T,
+        origin="lower",
+        aspect="auto",
+        extent=extent,
+        cmap="viridis",
+    )
+    axes[0, 0].set_title("integrated Bohm particle loss")
+    axes[0, 0].set_xlabel("toroidal angle")
+    axes[0, 0].set_ylabel("poloidal angle")
+    fig.colorbar(loss_image, ax=axes[0, 0], label="normalized particle flux")
+
+    connection_image = axes[0, 1].imshow(
+        arrays["connection_toroidal_heat_weighted"].T,
+        origin="lower",
+        aspect="auto",
+        extent=extent,
+        cmap="magma",
+    )
+    axes[0, 1].set_title("heat-weighted connection-length proxy")
+    axes[0, 1].set_xlabel("toroidal angle")
+    axes[0, 1].set_ylabel("poloidal angle")
+    fig.colorbar(connection_image, ax=axes[0, 1], label="length proxy")
+
+    heat_image = axes[0, 2].imshow(
+        arrays["heat_load_toroidal"].T,
+        origin="lower",
+        aspect="auto",
+        extent=extent,
+        cmap="inferno",
+    )
+    axes[0, 2].set_title("integrated target heat load")
+    axes[0, 2].set_xlabel("toroidal angle")
+    axes[0, 2].set_ylabel("poloidal angle")
+    fig.colorbar(heat_image, ax=axes[0, 2], label="normalized heat load")
+
+    radial_grid = arrays["radial_grid"]
+    radial_profile = arrays["radial_profile"]
+    normalized_density = radial_profile[:, 0] / max(float(np.max(radial_profile[:, 0])), 1.0e-30)
+    normalized_loss = radial_profile[:, 1] / max(float(np.max(radial_profile[:, 1])), 1.0e-30)
+    normalized_heat = radial_profile[:, 2] / max(float(np.max(radial_profile[:, 2])), 1.0e-30)
+    normalized_source = radial_profile[:, 3] / max(float(np.max(radial_profile[:, 3])), 1.0e-30)
+    axes[1, 0].plot(radial_grid, normalized_density, color="#005f73", lw=2.2, label="mean density")
+    axes[1, 0].plot(radial_grid, normalized_loss, color="#9b2226", lw=2.2, label="particle loss")
+    axes[1, 0].plot(radial_grid, normalized_heat, color="#ee9b00", lw=2.2, label="heat load")
+    axes[1, 0].plot(radial_grid, normalized_source, color="#0a9396", lw=2.2, label="recycled source")
+    axes[1, 0].set_title("normalized radial profiles")
+    axes[1, 0].set_xlabel("normalized radius")
+    axes[1, 0].set_ylim(-0.05, 1.08)
+    axes[1, 0].grid(alpha=0.25)
+    axes[1, 0].legend(frameon=False, fontsize=8)
+
+    toroidal_angle = arrays["toroidal_angle"]
+    toroidal_profile = arrays["toroidal_profile"]
+    axes[1, 1].plot(toroidal_angle, toroidal_profile[:, 0], color="#9b2226", lw=2.0, label="particle loss")
+    axes[1, 1].plot(toroidal_angle, toroidal_profile[:, 1], color="#ee9b00", lw=2.0, label="heat load")
+    axes[1, 1].plot(toroidal_angle, toroidal_profile[:, 2], color="#0a9396", lw=2.0, label="recycled source")
+    axes[1, 1].set_title("toroidal modulation of target response")
+    axes[1, 1].set_xlabel("toroidal angle")
+    axes[1, 1].grid(alpha=0.25)
+    axes[1, 1].legend(frameon=False, fontsize=8)
+
+    summary = arrays["summary_bars"]
+    labels = ["ion loss", "neutral source", "heat load", "neutral energy"]
+    axes[1, 2].bar(np.arange(summary.size), summary, color=["#9b2226", "#0a9396", "#ee9b00", "#005f73"])
+    axes[1, 2].set_xticks(np.arange(summary.size), labels, rotation=18, ha="right")
+    axes[1, 2].set_yscale("log")
+    axes[1, 2].set_title("integrated balance diagnostics")
+    axes[1, 2].grid(axis="y", alpha=0.25)
+    axes[1, 2].text(
+        0.03,
+        0.96,
+        "\n".join(
+            [
+                f"particle balance error = {report['particle_recycling_relative_error']:.1e}",
+                f"current balance error = {report['current_balance_relative_error']:.1e}",
+                f"short-L heat fraction = {report['short_connection_heat_fraction']:.2f}",
+            ]
+        ),
+        transform=axes[1, 2].transAxes,
+        va="top",
+        ha="left",
+        fontsize=8,
+        bbox={"facecolor": "white", "alpha": 0.82, "edgecolor": "0.8"},
+    )
+
+    fig.suptitle(
+        "Non-axisymmetric FCI sheath/recycling gate: "
+        "Bohm loss, zero-current closure, and exact recycled-source accounting",
+        fontsize=14,
+    )
+    fig.savefig(resolved, dpi=190)
+    plt.close(fig)
+    return resolved
+
+
+def _finite_corrcoef(left: np.ndarray, right: np.ndarray) -> float:
+    mask = np.isfinite(left) & np.isfinite(right)
+    if int(np.sum(mask)) < 3:
+        return 0.0
+    left_valid = left[mask]
+    right_valid = right[mask]
+    if float(np.std(left_valid)) <= 0.0 or float(np.std(right_valid)) <= 0.0:
+        return 0.0
+    return float(np.corrcoef(left_valid, right_valid)[0, 1])