test: report scheme spatial order (rate-1) in cell-shift mode

In cell-shift mode T = K*h scales with h, so accumulated truncation error
T*h^p = h^(p+1) gives raw measured rate p+1 — one greater than the scheme's
spatial order. The +1 is an artifact of scaling T with h, not an extra order
of accuracy in the scheme. Subtract 1 from the displayed value so the runner
reports the scheme's canonical spatial order p in both modes; the spec's
expected_order field always means p directly.

Output now self-documents:
  cell-shift: 'Fitted spatial order: 5.00 (need >= 4.7)'
  period:     'Fitted rate: 6.97 (need >= 6.5)'

Author: sbryngelson

toolchain/mfc/test/cases.py

@@ -12,26 +12,28 @@
 # the filter handle (`./mfc.sh test --only Convergence`); convergence cases
 # are skipped by default.
 
-# Advection convergence cases use cell-shift mode by default: T = K*h per
-# resolution, compare q(T) to np.roll(q(0), -K) per dim. Spatial error scales
-# as T*h^p = h^(p+1), so measured rate = p+1 (p = scheme order). Wins ~10-100x
-# vs running a full period since Nt = K*c/CFL is independent of N.
-# WENO7/TENO7 stay in period mode: at typical N their cell-shift error hits
-# machine precision (h^8 < 1e-15 at N=64) before any rate signal develops.
+# Advection convergence cases. Cell-shift mode: T = K*h per resolution, compare
+# q(T) to np.roll(q(0), +K) per dim. Cost is O(1) in N (Nt = K*c/CFL independent
+# of resolution) — wins ~10-100x vs period mode (full advection period).
+# WENO7/TENO7 stay in period mode: at typical N their cell-shift signal sinks
+# below machine precision (h^8 < 1e-15 at N=64) before any rate develops.
+#
+# expected_order is always the scheme's spatial order p. The runner subtracts
+# 1 from the displayed rate in cell-shift mode (where raw rate = p+1) so the
+# reported "spatial order" matches expected_order in both modes.
 _CONS_VARS_1D = [("density", 1), ("x-momentum", 2), ("energy", 3)]
 _CONS_VARS_2D = [("density", 1), ("energy", 4)]
 _CONS_VARS_3D = [("density", 1), ("energy", 5)]
 
 # (label, extra_args, expected_order, tol, resolutions)
-# expected_order = scheme order p + 1 in cell-shift mode (T scales with h).
-# WENO3-JS reduces to 2 at smooth extrema → cell-shift expected = 3.
-# MUSCL2 unlimited central → effective order 2 → cell-shift expected = 3.
+# WENO3-JS at smooth extrema empirically achieves ~1.5 in MFC (Henrick mapping
+# enabled). MUSCL2 unlimited central → effective spatial order 2.
 _CONVERGENCE_1D_SCHEMES = [
-    ("WENO5", ["--order", "5", "--cfl", "0.02"], 6, 0.3, [32, 64, 128]),
-    ("WENO3", ["--order", "3", "--cfl", "0.02"], 2.5, 0.3, [64, 128, 256]),
-    ("WENO1", ["--order", "1", "--cfl", "0.02"], 2, 0.2, [64, 128, 256]),
-    ("MUSCL2", ["--muscl", "--muscl-lim", "0", "--cfl", "0.02"], 3, 0.3, [64, 128, 256]),
-    ("TENO5", ["--order", "5", "--teno", "--teno-ct", "1e-6", "--cfl", "0.02"], 6, 0.3, [32, 64, 128]),
+    ("WENO5", ["--order", "5", "--cfl", "0.02"], 5, 0.3, [32, 64, 128]),
+    ("WENO3", ["--order", "3", "--cfl", "0.02"], 1.5, 0.3, [64, 128, 256]),
+    ("WENO1", ["--order", "1", "--cfl", "0.02"], 1, 0.2, [64, 128, 256]),
+    ("MUSCL2", ["--muscl", "--muscl-lim", "0", "--cfl", "0.02"], 2, 0.3, [64, 128, 256]),
+    ("TENO5", ["--order", "5", "--teno", "--teno-ct", "1e-6", "--cfl", "0.02"], 5, 0.3, [32, 64, 128]),
 ]
 # WENO7/TENO7 in 1D: period mode (full period T=1.0, see 1D case.py).
 _CONVERGENCE_1D_PERIOD_SCHEMES = [
@@ -40,11 +42,11 @@
 ]
 
 _CONVERGENCE_2D_SCHEMES = [
-    ("WENO5", ["--order", "5", "--cfl", "0.02"], 6, 0.3, [32, 64, 96]),
-    ("WENO3", ["--order", "3", "--cfl", "0.02"], 2.5, 0.3, [32, 64, 128]),
-    ("WENO1", ["--order", "1", "--cfl", "0.02"], 2, 0.2, [32, 64, 128]),
-    ("MUSCL2", ["--muscl", "--muscl-lim", "0", "--cfl", "0.02"], 3, 0.3, [32, 64, 128]),
-    ("TENO5", ["--order", "5", "--teno", "--teno-ct", "1e-6", "--cfl", "0.02"], 6, 0.3, [32, 64, 96]),
+    ("WENO5", ["--order", "5", "--cfl", "0.02"], 5, 0.3, [32, 64, 96]),
+    ("WENO3", ["--order", "3", "--cfl", "0.02"], 1.5, 0.3, [32, 64, 128]),
+    ("WENO1", ["--order", "1", "--cfl", "0.02"], 1, 0.2, [32, 64, 128]),
+    ("MUSCL2", ["--muscl", "--muscl-lim", "0", "--cfl", "0.02"], 2, 0.3, [32, 64, 128]),
+    ("TENO5", ["--order", "5", "--teno", "--teno-ct", "1e-6", "--cfl", "0.02"], 5, 0.3, [32, 64, 96]),
 ]
 _CONVERGENCE_2D_PERIOD_SCHEMES = [
     ("WENO7", ["--order", "7", "--cfl", "0.005"], 7, 0.5, [80, 96]),
@@ -55,11 +57,11 @@
 # would dominate CI even at N=64). WENO7/TENO7 skipped — at N=64 with K=1
 # the spatial error signal is below machine precision.
 _CONVERGENCE_3D_SCHEMES = [
-    ("WENO5", ["--order", "5", "--cfl", "0.02"], 6, 0.3, [32, 64]),
-    ("WENO3", ["--order", "3", "--cfl", "0.02"], 2.5, 0.3, [32, 64]),
-    ("WENO1", ["--order", "1", "--cfl", "0.02"], 2, 0.2, [32, 64]),
-    ("MUSCL2", ["--muscl", "--muscl-lim", "0", "--cfl", "0.02"], 3, 0.3, [32, 64]),
-    ("TENO5", ["--order", "5", "--teno", "--teno-ct", "1e-6", "--cfl", "0.02"], 6, 0.3, [32, 64]),
+    ("WENO5", ["--order", "5", "--cfl", "0.02"], 5, 0.3, [32, 64]),
+    ("WENO3", ["--order", "3", "--cfl", "0.02"], 1.5, 0.3, [32, 64]),
+    ("WENO1", ["--order", "1", "--cfl", "0.02"], 1, 0.2, [32, 64]),
+    ("MUSCL2", ["--muscl", "--muscl-lim", "0", "--cfl", "0.02"], 2, 0.3, [32, 64]),
+    ("TENO5", ["--order", "5", "--teno", "--teno-ct", "1e-6", "--cfl", "0.02"], 5, 0.3, [32, 64]),
 ]
 
 # Sod L1 self-convergence: any conservative monotone scheme converges at L1

toolchain/mfc/test/convergence.py

@@ -120,15 +120,16 @@ def _print_conservation_check(all_cons_errs, var_list, tol=CONS_TOL):
 def _run_resolution_sweep(spec):
     """1D/2D/3D resolution sweep on a smooth diagonal-advection problem.
 
+    `expected_order` in the spec always names the scheme's spatial order p.
     Two time modes:
       - 'period' (default): T = one full advection period; compare q(T) vs q(0).
-        Spatial truncation accumulates over a full period, so error ~ h^p and
-        the measured rate equals the scheme order p.
-      - 'cell_shift':       T = cell_shift * h / v; compare q(T) vs np.roll of q(0)
+        Truncation accumulates over fixed T, so error ~ h^p and measured rate = p.
+      - 'cell_shift': T = cell_shift * h / v; compare q(T) vs np.roll of q(0)
         by cell_shift cells (analytical solution for periodic linear advection
-        with v=1 in unit domain). Cost is O(1) in N (Nt = c/CFL independent
-        of resolution). Error scales as T*h^p = h^(p+1) so the measured rate
-        is p+1. Forces num_ranks=1 for unambiguous Fortran-order data layout.
+        with v=1). Cost is O(1) in N (Nt = K*c/CFL independent of resolution).
+        Error scales as T*h^p = h^(p+1), giving raw measured rate = p+1; the
+        runner subtracts 1 for display so the reported "spatial order" still
+        equals p. Forces num_ranks=1 for unambiguous Fortran-order data layout.
     """
     case_path = spec["case_path"]
     extra_args = list(spec.get("extra_args", []))
@@ -146,15 +147,20 @@ def _run_resolution_sweep(spec):
     if time_mode == "cell_shift":
         # Single-rank only: multi-rank concat order doesn't match (N,)*ndim reshape.
         num_ranks = 1
+        # Cell-shift mode: T = K*h, so raw rate is p+1; subtract 1 for display.
+        rate_offset = 1
+        order_label = "spatial order"
     else:
         num_ranks = spec.get("num_ranks", 1)
+        rate_offset = 0
+        order_label = "rate"
 
     if "min_N" in spec and spec["min_N"] is not None:
         resolutions = [N for N in resolutions if N >= spec["min_N"]]
     if "max_N" in spec and spec["max_N"] is not None:
         resolutions = [N for N in resolutions if N <= spec["max_N"]]
 
-    print(f"  (need rate >= {expected_order - tol:.1f})")
+    print(f"  (need {order_label} >= {expected_order - tol:.1f})")
 
     errors = []
     nts = []
@@ -185,16 +191,18 @@ def _run_resolution_sweep(spec):
     dxs = [domain_len / N for N in resolutions]
     rates = _pairwise_rates(errors, dxs)
 
-    print(f"\n  {'N':>6}  {'Nt':>6}  {'dx':>10}  {'L2 error':>14}  {'rate':>8}")
-    print(f"  {'-' * 6}  {'-' * 6}  {'-' * 10}  {'-' * 14}  {'-' * 8}")
+    col_label = order_label.replace(" ", "_")
+    print(f"\n  {'N':>6}  {'Nt':>6}  {'dx':>10}  {'L2 error':>14}  {col_label:>13}")
+    print(f"  {'-' * 6}  {'-' * 6}  {'-' * 10}  {'-' * 14}  {'-' * 13}")
     for i, N in enumerate(resolutions):
-        r_str = f"{rates[i]:>8.2f}" if rates[i] is not None else f"{'---':>8}"
+        r_str = f"{rates[i] - rate_offset:>13.2f}" if rates[i] is not None else f"{'---':>13}"
         print(f"  {N:>6}  {nts[i]:>6}  {dxs[i]:>10.6f}  {errors[i]:>14.6e}  {r_str}")
 
     if len(resolutions) > 1:
         overall = _fit_rate(errors, dxs)
-        print(f"\n  Fitted rate: {overall:.2f}  (need >= {expected_order - tol:.1f})")
-        rate_passed = overall >= expected_order - tol
+        displayed = overall - rate_offset
+        print(f"\n  Fitted {order_label}: {displayed:.2f}  (need >= {expected_order - tol:.1f})")
+        rate_passed = displayed >= expected_order - tol
     else:
         rate_passed = True