refactor: extract repeated patterns in case_validator and test/cases

case_validator.py:
- Add _check_order_fits_grid(): the 3-line m/n/p dimension check was
  duplicated identically in check_igr, check_weno, check_muscl; now one call
- Add _get_recon_type(): the recon_type read + prohibit was duplicated in
  check_weno, check_muscl, check_weno_simulation, check_muscl_simulation;
  now one call each
- Collapse two named param lists in check_muscl into inline literals

test/cases.py:
- Add make_3d_box_patches(): the 18-line 3-patch 3D box IC setup was
  copy-pasted identically in mpi_consistency_tests, restart_roundtrip_tests,
  and kernel_golden_tests; now one line each

lint_docs.py:
- Add private helpers to skip set (they call prohibit but are not
  check_* methods and should not require PHYSICS_DOCS entries)

Author: sbryngelson

toolchain/mfc/case_validator.py

@@ -250,6 +250,21 @@ def _validate_logical(self, key: str):
         if val is not None and val not in ("T", "F"):
             self.errors.append(f"{key} must be 'T' or 'F', got '{val}'")
 
+    def _check_order_fits_grid(self, order: int, param_name: str) -> None:
+        """Prohibit reconstruction order that exceeds grid cell count in any active dimension."""
+        m = self.get("m", 0)
+        n = self.get("n", 0) or 0
+        p = self.get("p", 0) or 0
+        self.prohibit(m + 1 < order, f"m must be at least {param_name} - 1 (= {order - 1})")
+        self.prohibit(n > 0 and n + 1 < order, f"For 2D: n must be at least {param_name} - 1 (= {order - 1})")
+        self.prohibit(p > 0 and p + 1 < order, f"For 3D: p must be at least {param_name} - 1 (= {order - 1})")
+
+    def _get_recon_type(self) -> int:
+        """Return recon_type after validating it is 1 (WENO) or 2 (MUSCL)."""
+        recon_type = self.get("recon_type", 1)
+        self.prohibit(recon_type not in [1, 2], "recon_type must be 1 (WENO) or 2 (MUSCL)")
+        return recon_type
+
     def check_parameter_types(self):
         """Validate parameter types before other checks.
 
@@ -316,72 +331,44 @@ def check_igr(self):
             return
 
         igr_order = self.get("igr_order")
-        m = self.get("m", 0)
-        n = self.get("n", 0)
-        p = self.get("p", 0)
         self.prohibit(igr_order not in [None, 3, 5], "igr_order must be 3 or 5")
         if igr_order:
-            self.prohibit(m + 1 < igr_order, f"m must be at least igr_order - 1 (= {igr_order - 1})")
-            self.prohibit(n is not None and n > 0 and n + 1 < igr_order, f"n must be at least igr_order - 1 (= {igr_order - 1})")
-            self.prohibit(p is not None and p > 0 and p + 1 < igr_order, f"p must be at least igr_order - 1 (= {igr_order - 1})")
+            self._check_order_fits_grid(igr_order, "igr_order")
 
     def check_weno(self):
         """Checks constraints regarding WENO order"""
-        recon_type = self.get("recon_type", 1)
-        self.prohibit(recon_type not in [1, 2], "recon_type must be 1 (WENO) or 2 (MUSCL)")
-
-        # WENO_TYPE = 1
-        if recon_type != 1:
+        if self._get_recon_type() != 1:
             return
 
         for param in ["muscl_order", "muscl_lim"]:
             self.prohibit(self.is_set(param), f"recon_type = 1 (WENO) is not compatible with {param}")
 
         weno_order = self.get("weno_order")
-        m = self.get("m", 0)
-        n = self.get("n", 0)
-        p = self.get("p", 0)
-
         if weno_order is None:
             return
 
         self.prohibit(weno_order not in [1, 3, 5, 7], "weno_order must be 1, 3, 5, or 7")
-        self.prohibit(m + 1 < weno_order, f"m must be at least weno_order - 1 (= {weno_order - 1})")
-        self.prohibit(n is not None and n > 0 and n + 1 < weno_order, f"For 2D simulation, n must be at least weno_order - 1 (= {weno_order - 1})")
-        self.prohibit(p is not None and p > 0 and p + 1 < weno_order, f"For 3D simulation, p must be at least weno_order - 1 (= {weno_order - 1})")
+        self._check_order_fits_grid(weno_order, "weno_order")
 
     def check_muscl(self):
         """Check constraints regarding MUSCL order"""
-        recon_type = self.get("recon_type", 1)
-        self.prohibit(recon_type not in [1, 2], "recon_type must be 1 (WENO) or 2 (MUSCL)")
-
-        # MUSCL_TYPE = 2
-        if recon_type != 2:
+        if self._get_recon_type() != 2:
             return
 
-        weno_log_params = ["mapped_weno", "wenoz", "teno", "mp_weno", "weno_avg", "null_weights", "weno_Re_flux"]
-        for param in weno_log_params:
+        for param in ["mapped_weno", "wenoz", "teno", "mp_weno", "weno_avg", "null_weights", "weno_Re_flux"]:
             self.prohibit(self.get(param) == "T", f"recon_type = 2 (MUSCL) is not compatible with {param} = T")
-
-        weno_numeric_params = ["wenoz_q", "teno_CT", "weno_eps"]
-        for param in weno_numeric_params:
+        for param in ["wenoz_q", "teno_CT", "weno_eps"]:
             self.prohibit(self.is_set(param), f"recon_type = 2 (MUSCL) is not compatible with {param}")
 
         weno_order = self.get("weno_order")
         self.prohibit(weno_order is not None and weno_order != 0, f"recon_type = 2 (MUSCL) requires weno_order unset or 0, but got {weno_order}")
 
         muscl_order = self.get("muscl_order")
-        m = self.get("m", 0)
-        n = self.get("n", 0)
-        p = self.get("p", 0)
-
         if muscl_order is None:
             return
 
         self.prohibit(muscl_order not in [1, 2], "muscl_order must be 1 or 2")
-        self.prohibit(m + 1 < muscl_order, f"m must be at least muscl_order - 1 (= {muscl_order - 1})")
-        self.prohibit(n is not None and n > 0 and n + 1 < muscl_order, f"For 2D simulation, n must be at least muscl_order - 1 (= {muscl_order - 1})")
-        self.prohibit(p is not None and p > 0 and p + 1 < muscl_order, f"For 3D simulation, p must be at least muscl_order - 1 (= {muscl_order - 1})")
+        self._check_order_fits_grid(muscl_order, "muscl_order")
 
     def check_interface_compression(self):
         """Check constraints regarding interface compression"""
@@ -752,11 +739,7 @@ def check_finite_difference(self):
 
     def check_weno_simulation(self):
         """Checks WENO-specific constraints for simulation"""
-        recon_type = self.get("recon_type", 1)
-        self.prohibit(recon_type not in [1, 2], "recon_type must be 1 (WENO) or 2 (MUSCL)")
-
-        # WENO_TYPE = 1
-        if recon_type != 1:
+        if self._get_recon_type() != 1:
             return
 
         weno_order = self.get("weno_order")
@@ -793,11 +776,7 @@ def check_weno_simulation(self):
 
     def check_muscl_simulation(self):
         """Checks MUSCL-specific constraints for simulation"""
-        recon_type = self.get("recon_type", 1)
-        self.prohibit(recon_type not in [1, 2], "recon_type must be 1 (WENO) or 2 (MUSCL)")
-
-        # MUSCL_TYPE = 2
-        if recon_type != 2:
+        if self._get_recon_type() != 2:
             return
 
         muscl_order = self.get("muscl_order")

toolchain/mfc/lint_docs.py

@@ -407,6 +407,9 @@ def check_physics_docs_coverage(repo_root: Path) -> list[str]:
     # Methods without PHYSICS_DOCS entries. Add a PHYSICS_DOCS entry (with math,
     # references, and explanation) to case_validator.py to remove from this set.
     skip = {
+        # Private helpers — called from check_* methods, not check methods themselves
+        "_check_order_fits_grid",
+        "_get_recon_type",
         # Structural/mechanical checks (no physics meaning)
         "check_parameter_types",  # type validation
         "check_output_format",  # output format selection

toolchain/mfc/test/cases.py

@@ -162,6 +162,26 @@ def _h_sweep(case_path, ndim, cons_vars, extra_args, expected, tol, resolutions,
         )
 
 
+def make_3d_box_patches(
+    z_centroids=(0.05, 0.45, 0.9),
+    z_lengths=(0.1, 0.7, 0.2),
+    geometry=9,
+) -> dict:
+    """3-patch 3D box IC: uniform xy plane (centroid=0.5, length=1), z spacing given."""
+    d = {}
+    for pid in range(1, 4):
+        d[f"patch_icpp({pid})%geometry"] = geometry
+        for vel in (1, 2, 3):
+            d[f"patch_icpp({pid})%vel({vel})"] = 0.0
+        d[f"patch_icpp({pid})%x_centroid"] = 0.5
+        d[f"patch_icpp({pid})%length_x"] = 1
+        d[f"patch_icpp({pid})%y_centroid"] = 0.5
+        d[f"patch_icpp({pid})%length_y"] = 1
+        d[f"patch_icpp({pid})%z_centroid"] = z_centroids[pid - 1]
+        d[f"patch_icpp({pid})%length_z"] = z_lengths[pid - 1]
+    return d
+
+
 def get_bc_mods(bc: int, dimInfo):
     params = {}
     for dimCmp in dimInfo[0]:
@@ -2027,25 +2047,7 @@ def mpi_consistency_tests():
             "bc_z%end": -3,
         }
 
-        for patchID in range(1, 4):
-            base_3d[f"patch_icpp({patchID})%geometry"] = 9
-            base_3d[f"patch_icpp({patchID})%vel(1)"] = 0.0
-            base_3d[f"patch_icpp({patchID})%vel(2)"] = 0.0
-            base_3d[f"patch_icpp({patchID})%vel(3)"] = 0.0
-            base_3d[f"patch_icpp({patchID})%x_centroid"] = 0.5
-            base_3d[f"patch_icpp({patchID})%length_x"] = 1
-            base_3d[f"patch_icpp({patchID})%y_centroid"] = 0.5
-            base_3d[f"patch_icpp({patchID})%length_y"] = 1
-        base_3d.update(
-            {
-                "patch_icpp(1)%z_centroid": 0.05,
-                "patch_icpp(1)%length_z": 0.1,
-                "patch_icpp(2)%z_centroid": 0.45,
-                "patch_icpp(2)%length_z": 0.7,
-                "patch_icpp(3)%z_centroid": 0.9,
-                "patch_icpp(3)%length_z": 0.2,
-            }
-        )
+        base_3d.update(make_3d_box_patches())
 
         # Bubbles with 2 MPI ranks
         stack.push(
@@ -2203,25 +2205,7 @@ def restart_roundtrip_tests():
             "bc_z%beg": -3,
             "bc_z%end": -3,
         }
-        for patchID in range(1, 4):
-            base_3d[f"patch_icpp({patchID})%geometry"] = 9
-            base_3d[f"patch_icpp({patchID})%vel(1)"] = 0.0
-            base_3d[f"patch_icpp({patchID})%vel(2)"] = 0.0
-            base_3d[f"patch_icpp({patchID})%vel(3)"] = 0.0
-            base_3d[f"patch_icpp({patchID})%x_centroid"] = 0.5
-            base_3d[f"patch_icpp({patchID})%length_x"] = 1
-            base_3d[f"patch_icpp({patchID})%y_centroid"] = 0.5
-            base_3d[f"patch_icpp({patchID})%length_y"] = 1
-        base_3d.update(
-            {
-                "patch_icpp(1)%z_centroid": 0.05,
-                "patch_icpp(1)%length_z": 0.1,
-                "patch_icpp(2)%z_centroid": 0.45,
-                "patch_icpp(2)%length_z": 0.7,
-                "patch_icpp(3)%z_centroid": 0.9,
-                "patch_icpp(3)%length_z": 0.2,
-            }
-        )
+        base_3d.update(make_3d_box_patches())
         stack.push("Restart Roundtrip -> 3D", base_3d)
         cases.append(define_case_d(stack, "", {}, restart_check=True))
         stack.pop()
@@ -2259,25 +2243,7 @@ def kernel_golden_tests():
             "bc_z%beg": -3,
             "bc_z%end": -3,
         }
-        for patchID in range(1, 4):
-            base_3d[f"patch_icpp({patchID})%geometry"] = 9
-            base_3d[f"patch_icpp({patchID})%vel(1)"] = 0.0
-            base_3d[f"patch_icpp({patchID})%vel(2)"] = 0.0
-            base_3d[f"patch_icpp({patchID})%vel(3)"] = 0.0
-            base_3d[f"patch_icpp({patchID})%x_centroid"] = 0.5
-            base_3d[f"patch_icpp({patchID})%length_x"] = 1
-            base_3d[f"patch_icpp({patchID})%y_centroid"] = 0.5
-            base_3d[f"patch_icpp({patchID})%length_y"] = 1
-        base_3d.update(
-            {
-                "patch_icpp(1)%z_centroid": 0.05,
-                "patch_icpp(1)%length_z": 0.1,
-                "patch_icpp(2)%z_centroid": 0.45,
-                "patch_icpp(2)%length_z": 0.7,
-                "patch_icpp(3)%z_centroid": 0.9,
-                "patch_icpp(3)%length_z": 0.2,
-            }
-        )
+        base_3d.update(make_3d_box_patches())
 
         # 3D grid stretching in all directions.
         # The cosh-based stretching expands the domain beyond the original