drbx 2.0.0.dev0__py3-none-any.whl

drbx/validation/stellarator_fci_suite_campaign.py

@@ -0,0 +1,264 @@
+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 .stellarator_fci_geometry_campaign import build_stellarator_fci_geometry_report
+
+
+@dataclass(frozen=True)
+class StellaratorFciSuiteCampaignArtifacts:
+    report_json_path: Path
+    arrays_npz_path: Path
+    plot_png_path: Path
+
+
+def create_stellarator_fci_suite_campaign_package(
+    *,
+    output_root: str | Path,
+    case_label: str = "stellarator_fci_suite_campaign",
+    nx: int = 30,
+    ny: int = 28,
+    nz: int = 56,
+) -> StellaratorFciSuiteCampaignArtifacts:
+    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_fci_suite_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_fci_suite_plot(report, arrays, plot_png_path)
+    return StellaratorFciSuiteCampaignArtifacts(
+        report_json_path=report_json_path,
+        arrays_npz_path=arrays_npz_path,
+        plot_png_path=plot_png_path,
+    )
+
+
+def build_stellarator_fci_suite_campaign(
+    *,
+    nx: int = 30,
+    ny: int = 28,
+    nz: int = 56,
+) -> tuple[dict[str, Any], dict[str, np.ndarray]]:
+    configs = _suite_configs()
+    reports: list[dict[str, Any]] = []
+    row_labels: list[str] = []
+    cross_r: list[np.ndarray] = []
+    cross_z: list[np.ndarray] = []
+    bmag_slices: list[np.ndarray] = []
+    connection_slices: list[np.ndarray] = []
+    curvature_map_slices: list[np.ndarray] = []
+    summary_rows: list[list[float]] = []
+    for config in configs:
+        geometry = build_synthetic_stellarator_geometry(nx=nx, ny=ny, nz=nz, **config["parameters"])
+        report = build_stellarator_fci_geometry_report(geometry)
+        reports.append(report)
+        row_labels.append(str(config["label"]))
+        x = np.asarray(geometry.coordinates_x)
+        y = np.asarray(geometry.coordinates_y)
+        z = np.asarray(geometry.coordinates_z)
+        r_major = np.sqrt(x * x + y * y)
+        toroidal_index = max(1, ny // 6)
+        cross_r.append(r_major[:, toroidal_index, :].astype(np.float32))
+        cross_z.append(z[:, toroidal_index, :].astype(np.float32))
+        bmag_slices.append(np.asarray(geometry.metric.Bxy[:, 0, :], dtype=np.float32))
+        connection_slices.append(np.asarray(geometry.connection_length[:, 0, :], dtype=np.float32))
+        radial_shift = np.asarray(geometry.maps.forward_x) - np.arange(
+            geometry.maps.shape[0],
+            dtype=np.float64,
+        )[:, None, None]
+        curvature_map_slices.append(np.asarray(geometry.curvature[:, 0, :] * radial_shift[:, 0, :], dtype=np.float32))
+        map_report = report["map_diagnostics"]
+        summary_rows.append(
+            [
+                float(report["magnetic_field"]["mirror_ratio"]),
+                float(report["connection_length"]["mean"]),
+                float(report["connection_length"]["std"]),
+                float(report["curvature"]["std"]),
+                float(map_report["radial_shift_linf_cells"]),
+                float(map_report["forward_boundary_fraction"] + map_report["backward_boundary_fraction"]),
+            ]
+        )
+    summary = np.asarray(summary_rows, dtype=np.float64)
+    report = {
+        "case": "stellarator_fci_multi_configuration_suite",
+        "configuration_labels": row_labels,
+        "configurations": reports,
+        "summary_columns": [
+            "mirror_ratio",
+            "connection_length_mean",
+            "connection_length_std",
+            "curvature_std",
+            "radial_shift_linf_cells",
+            "two_sided_boundary_fraction",
+        ],
+        "summary": summary_rows,
+        "passed": all(bool(item["passed"]) for item in reports)
+        and float(np.min(summary[:, 1])) > 0.0
+        and float(np.max(summary[:, 4])) > 0.0
+        and float(np.max(summary[:, 5])) < 0.20,
+    }
+    arrays = {
+        "labels": np.asarray(row_labels),
+        "cross_r": np.asarray(cross_r, dtype=np.float32),
+        "cross_z": np.asarray(cross_z, dtype=np.float32),
+        "bmag_slices": np.asarray(bmag_slices, dtype=np.float32),
+        "connection_slices": np.asarray(connection_slices, dtype=np.float32),
+        "curvature_map_slices": np.asarray(curvature_map_slices, dtype=np.float32),
+        "summary": summary.astype(np.float32),
+    }
+    return report, arrays
+
+
+def save_stellarator_fci_suite_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)
+    labels = [str(label) for label in arrays["labels"]]
+    nrows = len(labels)
+    fig, axes = plt.subplots(
+        nrows + 1,
+        4,
+        figsize=(15.5, 11.2),
+        constrained_layout=True,
+        gridspec_kw={"height_ratios": [1.0, 1.0, 1.0, 0.72]},
+    )
+    bmag_vmin = float(np.min(arrays["bmag_slices"]))
+    bmag_vmax = float(np.max(arrays["bmag_slices"]))
+    connection_vmin = float(np.min(arrays["connection_slices"]))
+    connection_vmax = float(np.max(arrays["connection_slices"]))
+    curvature_vmax = float(np.max(np.abs(arrays["curvature_map_slices"])))
+    for row, label in enumerate(labels):
+        cross_r = arrays["cross_r"][row]
+        cross_z = arrays["cross_z"][row]
+        for surface in (max(1, cross_r.shape[0] // 4), max(2, cross_r.shape[0] // 2), cross_r.shape[0] - 2):
+            axes[row, 0].plot(cross_r[surface], cross_z[surface], linewidth=1.2)
+        if row == 0:
+            axes[row, 0].set_title("sampled cross-sections")
+        axes[row, 0].set_xlabel("major radius" if row == nrows - 1 else "")
+        axes[row, 0].set_ylabel(f"{label}\nvertical")
+        axes[row, 0].set_aspect("equal", adjustable="box")
+
+        image0 = axes[row, 1].imshow(
+            arrays["bmag_slices"][row],
+            origin="lower",
+            aspect="auto",
+            cmap="viridis",
+            vmin=bmag_vmin,
+            vmax=bmag_vmax,
+        )
+        if row == 0:
+            axes[row, 1].set_title("magnetic-field strength")
+        axes[row, 1].set_xlabel("poloidal index" if row == nrows - 1 else "")
+        axes[row, 1].set_ylabel("radial index")
+
+        image1 = axes[row, 2].imshow(
+            arrays["connection_slices"][row],
+            origin="lower",
+            aspect="auto",
+            cmap="magma",
+            vmin=connection_vmin,
+            vmax=connection_vmax,
+        )
+        if row == 0:
+            axes[row, 2].set_title("connection-length proxy")
+        axes[row, 2].set_xlabel("poloidal index" if row == nrows - 1 else "")
+        axes[row, 2].set_ylabel("radial index")
+
+        image2 = axes[row, 3].imshow(
+            arrays["curvature_map_slices"][row],
+            origin="lower",
+            aspect="auto",
+            cmap="coolwarm",
+            vmin=-curvature_vmax,
+            vmax=curvature_vmax,
+        )
+        if row == 0:
+            axes[row, 3].set_title("curvature x radial map shift")
+        axes[row, 3].set_xlabel("poloidal index" if row == nrows - 1 else "")
+        axes[row, 3].set_ylabel("radial index")
+
+    fig.colorbar(image0, ax=axes[:nrows, 1], label="normalized |B|", shrink=0.72)
+    fig.colorbar(image1, ax=axes[:nrows, 2], label="length proxy", shrink=0.72)
+    fig.colorbar(image2, ax=axes[:nrows, 3], label="signed proxy", shrink=0.72)
+
+    summary = arrays["summary"]
+    x_locations = np.arange(nrows)
+    bar_axes = axes[nrows]
+    for axis in bar_axes:
+        axis.set_xticks(x_locations, labels, rotation=18, ha="right", fontsize=8)
+    bar_axes[0].bar(x_locations, summary[:, 0], color="#005f73")
+    bar_axes[0].set_title("mirror ratio")
+    bar_axes[1].bar(x_locations, summary[:, 1], color="#9b2226")
+    bar_axes[1].set_title("mean connection length")
+    bar_axes[2].bar(x_locations, summary[:, 3], color="#ca6702")
+    bar_axes[2].set_title("curvature RMS")
+    bar_axes[3].bar(x_locations, summary[:, 4], color="#0a9396")
+    bar_axes[3].set_title("max radial map shift")
+    for axis in bar_axes:
+        axis.grid(axis="y", alpha=0.25)
+    fig.suptitle(
+        "Multi-configuration 3D stellarator field-line-map geometry suite: "
+        f"{len(labels)} passing metric/map gates",
+        fontsize=14,
+    )
+    fig.savefig(resolved, dpi=180)
+    plt.close(fig)
+    return resolved
+
+
+def _suite_configs() -> list[dict[str, Any]]:
+    return [
+        {
+            "label": "baseline island SOL",
+            "parameters": {
+                "elongation": 1.45,
+                "field_periods": 5,
+                "island_mode": 2,
+                "island_amplitude": 0.030,
+                "mirror_amplitude": 0.16,
+                "iota_axis": 0.38,
+                "iota_edge": 0.58,
+            },
+        },
+        {
+            "label": "strong island map",
+            "parameters": {
+                "elongation": 1.35,
+                "field_periods": 5,
+                "island_mode": 2,
+                "island_amplitude": 0.055,
+                "mirror_amplitude": 0.18,
+                "iota_axis": 0.34,
+                "iota_edge": 0.64,
+            },
+        },
+        {
+            "label": "high mirror shear",
+            "parameters": {
+                "elongation": 1.65,
+                "field_periods": 4,
+                "island_mode": 3,
+                "island_amplitude": 0.026,
+                "mirror_amplitude": 0.24,
+                "iota_axis": 0.30,
+                "iota_edge": 0.70,
+            },
+        },
+    ]

drbx/validation/stellarator_metric_mms_campaign.py

@@ -0,0 +1,289 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+import jax.numpy as jnp
+from matplotlib import pyplot as plt
+import numpy as np
+
+from ..geometry import MetricTensor3D, build_synthetic_stellarator_geometry
+from ..native.fci import metric_weighted_scalar_laplacian_3d
+
+
+@dataclass(frozen=True)
+class StellaratorMetricMmsCampaignArtifacts:
+    report_json_path: Path
+    arrays_npz_path: Path
+    plot_png_path: Path
+
+
+def create_stellarator_metric_mms_campaign_package(
+    *,
+    output_root: str | Path,
+    case_label: str = "stellarator_metric_mms_campaign",
+    resolutions: tuple[int, ...] = (16, 24, 32, 48),
+) -> StellaratorMetricMmsCampaignArtifacts:
+    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_metric_mms_campaign(resolutions=resolutions)
+    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_metric_mms_plot(report, arrays, plot_png_path)
+    return StellaratorMetricMmsCampaignArtifacts(
+        report_json_path=report_json_path,
+        arrays_npz_path=arrays_npz_path,
+        plot_png_path=plot_png_path,
+    )
+
+
+def build_stellarator_metric_mms_campaign(
+    *,
+    resolutions: tuple[int, ...] = (16, 24, 32, 48),
+) -> tuple[dict[str, object], dict[str, np.ndarray]]:
+    rms_errors = []
+    max_errors = []
+    final_numeric = np.empty((1, 1), dtype=np.float64)
+    final_exact = np.empty((1, 1), dtype=np.float64)
+    final_error = np.empty((1, 1), dtype=np.float64)
+    for resolution in resolutions:
+        result = _identity_metric_mms_result(resolution)
+        rms_errors.append(result["rms_error"])
+        max_errors.append(result["max_error"])
+        final_numeric = result["numeric_slice"]
+        final_exact = result["exact_slice"]
+        final_error = result["error_slice"]
+
+    resolution_array = np.asarray(resolutions, dtype=np.int64)
+    mesh_spacing = 1.0 / resolution_array.astype(np.float64)
+    observed_order = _fit_convergence_slope(mesh_spacing, np.asarray(rms_errors, dtype=np.float64))
+
+    synthetic_report, synthetic_arrays = _run_synthetic_metric_probe()
+    report: dict[str, object] = {
+        "case": "stellarator_metric_weighted_scalar_laplacian_mms",
+        "operator": "J^-1 partial_i(J K g^ij partial_j f)",
+        "resolutions": resolution_array.tolist(),
+        "identity_mms_rms_error": rms_errors,
+        "identity_mms_max_error": max_errors,
+        "identity_mms_observed_order": float(observed_order),
+        **synthetic_report,
+    }
+    report["passed"] = (
+        float(report["identity_mms_observed_order"]) > 1.75
+        and float(report["synthetic_constant_residual_linf"]) < 1.0e-12
+        and float(report["synthetic_energy_rate"]) < 0.0
+        and float(report["synthetic_energy_monotone_fraction"]) > 0.95
+        and float(report["synthetic_cross_term_fraction"]) > 1.0e-3
+    )
+    arrays: dict[str, np.ndarray] = {
+        "resolution": resolution_array,
+        "mesh_spacing": mesh_spacing,
+        "identity_mms_rms_error": np.asarray(rms_errors, dtype=np.float64),
+        "identity_mms_max_error": np.asarray(max_errors, dtype=np.float64),
+        "identity_numeric_slice": final_numeric.astype(np.float32),
+        "identity_exact_slice": final_exact.astype(np.float32),
+        "identity_error_slice": final_error.astype(np.float32),
+        **synthetic_arrays,
+    }
+    return report, arrays
+
+
+def save_stellarator_metric_mms_plot(
+    report: dict[str, object],
+    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, 8.6), constrained_layout=True)
+
+    axes[0, 0].loglog(
+        arrays["mesh_spacing"],
+        arrays["identity_mms_rms_error"],
+        "o-",
+        color="#005f73",
+        linewidth=2.0,
+        label="RMS error",
+    )
+    reference = arrays["identity_mms_rms_error"][-1] * (arrays["mesh_spacing"] / arrays["mesh_spacing"][-1]) ** 2
+    axes[0, 0].loglog(arrays["mesh_spacing"], reference, "--", color="#6c757d", linewidth=1.6, label="$h^2$")
+    axes[0, 0].invert_xaxis()
+    axes[0, 0].set_xlabel("logical mesh spacing")
+    axes[0, 0].set_ylabel("error")
+    axes[0, 0].set_title("Manufactured solution: full metric scalar operator")
+    axes[0, 0].legend(frameon=False)
+
+    image0 = axes[0, 1].imshow(arrays["identity_exact_slice"], origin="lower", aspect="auto", cmap="viridis")
+    axes[0, 1].set_title("Exact $\\nabla^2 f$ slice")
+    axes[0, 1].set_xlabel("toroidal index")
+    axes[0, 1].set_ylabel("radial index")
+    fig.colorbar(image0, ax=axes[0, 1])
+
+    image1 = axes[0, 2].imshow(arrays["identity_error_slice"], origin="lower", aspect="auto", cmap="coolwarm")
+    axes[0, 2].set_title("MMS error slice")
+    axes[0, 2].set_xlabel("toroidal index")
+    axes[0, 2].set_ylabel("radial index")
+    fig.colorbar(image1, ax=axes[0, 2])
+
+    image2 = axes[1, 0].imshow(arrays["synthetic_jacobian_slice"], origin="lower", aspect="auto", cmap="magma")
+    axes[1, 0].set_title("Synthetic non-axisymmetric Jacobian")
+    axes[1, 0].set_xlabel("poloidal index")
+    axes[1, 0].set_ylabel("radial index")
+    fig.colorbar(image2, ax=axes[1, 0])
+
+    image3 = axes[1, 1].imshow(arrays["synthetic_cross_term_slice"], origin="lower", aspect="auto", cmap="coolwarm")
+    axes[1, 1].set_title("Full minus diagonal metric operator")
+    axes[1, 1].set_xlabel("poloidal index")
+    axes[1, 1].set_ylabel("radial index")
+    fig.colorbar(image3, ax=axes[1, 1])
+
+    normalized_energy = arrays["synthetic_energy_history"] / arrays["synthetic_energy_history"][0]
+    axes[1, 2].plot(1.0 - normalized_energy, color="#0a9396", linewidth=2.0)
+    axes[1, 2].set_xlabel("explicit metric-diffusion step")
+    axes[1, 2].set_ylabel("fractional energy dissipated")
+    axes[1, 2].set_title("Dissipation on synthetic stellarator metric")
+
+    fig.suptitle(
+        "Full 3D metric operator gate: "
+        f"MMS order {float(report['identity_mms_observed_order']):.2f}, "
+        f"cross-term fraction {100.0 * float(report['synthetic_cross_term_fraction']):.1f}%",
+        fontsize=12,
+    )
+    fig.savefig(resolved, dpi=180)
+    plt.close(fig)
+    return resolved
+
+
+def _identity_metric_mms_result(resolution: int) -> dict[str, object]:
+    nx = int(resolution)
+    ny = int(resolution)
+    nz = 2 * int(resolution)
+    metric = _identity_metric(nx=nx, ny=ny, nz=nz)
+    x = jnp.arange(nx, dtype=jnp.float64) / float(nx)
+    y = 2.0 * jnp.pi * jnp.arange(ny, dtype=jnp.float64) / float(ny)
+    z = 2.0 * jnp.pi * jnp.arange(nz, dtype=jnp.float64) / float(nz)
+    X, Y, Z = jnp.meshgrid(x, y, z, indexing="ij")
+    field = jnp.sin(2.0 * jnp.pi * X) * jnp.cos(3.0 * Y) * jnp.sin(2.0 * Z)
+    exact = -((2.0 * jnp.pi) ** 2 + 3.0**2 + 2.0**2) * field
+    numeric = metric_weighted_scalar_laplacian_3d(
+        field,
+        metric,
+        coefficient=1.0,
+        periodic_axes=(True, True, True),
+    )
+    error = numeric - exact
+    slice_index = max(1, ny // 6)
+    return {
+        "rms_error": float(jnp.sqrt(jnp.mean(jnp.square(error)))),
+        "max_error": float(jnp.max(jnp.abs(error))),
+        "numeric_slice": np.asarray(numeric[:, slice_index, :], dtype=np.float64),
+        "exact_slice": np.asarray(exact[:, slice_index, :], dtype=np.float64),
+        "error_slice": np.asarray(error[:, slice_index, :], dtype=np.float64),
+    }
+
+
+def _run_synthetic_metric_probe() -> tuple[dict[str, object], dict[str, np.ndarray]]:
+    geometry = build_synthetic_stellarator_geometry(nx=22, ny=18, nz=36)
+    field = (
+        jnp.sin(jnp.pi * geometry.radial) * jnp.cos(2.0 * geometry.poloidal_angle - 5.0 * geometry.toroidal_angle)
+        + 0.18 * jnp.sin(3.0 * geometry.poloidal_angle + 2.0 * geometry.toroidal_angle)
+    )
+    coefficient = 8.0e-4 * (1.0 + 0.25 * geometry.radial)
+    constant = jnp.ones_like(field, dtype=jnp.float64)
+    rhs = metric_weighted_scalar_laplacian_3d(field, geometry.metric, coefficient)
+    diagonal_rhs = metric_weighted_scalar_laplacian_3d(field, _diagonal_metric(geometry.metric), coefficient)
+    cross_term = rhs - diagonal_rhs
+    constant_residual = metric_weighted_scalar_laplacian_3d(constant, geometry.metric, coefficient)
+    energy_rate = jnp.mean(geometry.metric.J * field * rhs)
+
+    dt = 1.0e-3
+    energy_history = []
+    evolved = field
+    for _ in range(60):
+        energy_history.append(float(jnp.mean(geometry.metric.J * jnp.square(evolved))))
+        evolved = evolved + dt * metric_weighted_scalar_laplacian_3d(evolved, geometry.metric, coefficient)
+    energy_history.append(float(jnp.mean(geometry.metric.J * jnp.square(evolved))))
+    energy_history_array = np.asarray(energy_history, dtype=np.float64)
+    cross_fraction = float(
+        jnp.sqrt(jnp.mean(jnp.square(cross_term))) / jnp.maximum(jnp.sqrt(jnp.mean(jnp.square(rhs))), 1.0e-30)
+    )
+    report = {
+        "synthetic_shape": list(geometry.shape),
+        "synthetic_constant_residual_linf": float(jnp.max(jnp.abs(constant_residual))),
+        "synthetic_energy_rate": float(energy_rate),
+        "synthetic_energy_initial": float(energy_history_array[0]),
+        "synthetic_energy_final": float(energy_history_array[-1]),
+        "synthetic_energy_monotone_fraction": float(np.mean(np.diff(energy_history_array) <= 1.0e-14)),
+        "synthetic_energy_drop_fraction": float(1.0 - energy_history_array[-1] / energy_history_array[0]),
+        "synthetic_cross_term_fraction": cross_fraction,
+    }
+    arrays = {
+        "synthetic_energy_history": energy_history_array,
+        "synthetic_jacobian_slice": np.asarray(geometry.metric.J[:, 0, :], dtype=np.float32),
+        "synthetic_rhs_slice": np.asarray(rhs[:, 0, :], dtype=np.float32),
+        "synthetic_cross_term_slice": np.asarray(cross_term[:, 0, :], dtype=np.float32),
+        "synthetic_constant_residual_slice": np.asarray(constant_residual[:, 0, :], dtype=np.float32),
+    }
+    return report, arrays
+
+
+def _identity_metric(*, nx: int, ny: int, nz: int) -> MetricTensor3D:
+    shape = (nx, ny, nz)
+    ones = jnp.ones(shape, dtype=jnp.float64)
+    zeros = jnp.zeros(shape, dtype=jnp.float64)
+    return MetricTensor3D(
+        dx=ones * (1.0 / float(nx)),
+        dy=ones * (2.0 * np.pi / float(ny)),
+        dz=ones * (2.0 * np.pi / float(nz)),
+        J=ones,
+        Bxy=ones,
+        g11=ones,
+        g22=ones,
+        g33=ones,
+        g12=zeros,
+        g13=zeros,
+        g23=zeros,
+        g_11=ones,
+        g_22=ones,
+        g_33=ones,
+        g_12=zeros,
+        g_13=zeros,
+        g_23=zeros,
+    )
+
+
+def _diagonal_metric(metric: MetricTensor3D) -> MetricTensor3D:
+    zeros = jnp.zeros_like(metric.J, dtype=jnp.float64)
+    return MetricTensor3D(
+        dx=metric.dx,
+        dy=metric.dy,
+        dz=metric.dz,
+        J=metric.J,
+        Bxy=metric.Bxy,
+        g11=metric.g11,
+        g22=metric.g22,
+        g33=metric.g33,
+        g12=zeros,
+        g13=zeros,
+        g23=zeros,
+        g_11=metric.g_11,
+        g_22=metric.g_22,
+        g_33=metric.g_33,
+        g_12=zeros,
+        g_13=zeros,
+        g_23=zeros,
+    )
+
+
+def _fit_convergence_slope(h: np.ndarray, error: np.ndarray) -> float:
+    safe = np.maximum(error, 1.0e-16)
+    slope, _ = np.polyfit(np.log(h), np.log(safe), 1)
+    return float(slope)