Merge branch 'develop' into bugfix/kf-periodic-vpar-spline

Author: logan-nc

.github/workflows/auto-merge.yaml

@@ -124,9 +124,18 @@ jobs:
             }
 
             // Assignee and reviewer need a human decision, so comment rather than block.
+            // A reviewer counts as named whether or not they have acted yet. GitHub drops a
+            // reviewer from requested_reviewers the moment they submit a review, so the
+            // submitted reviews are what remember an assignment that has already been acted
+            // on; without them this nags precisely the pull requests that got reviewed.
+            const { data: reviews } = await github.rest.pulls.listReviews({
+              owner, repo, pull_number: pr.number, per_page: 100,
+            });
+            const reviewedByOther = reviews.some(r => r.user && r.user.login !== pr.user.login);
+
             const missing = [];
             if (!pr.assignees.length) missing.push('an **assignee**');
-            if (!pr.requested_reviewers.length && !pr.requested_teams.length) {
+            if (!pr.requested_reviewers.length && !pr.requested_teams.length && !reviewedByOther) {
               missing.push('a **reviewer**');
             }
 

.github/workflows/pr-conventions.yaml

@@ -41,16 +41,16 @@ function setup_and_run_solovev()
     intr.mpert = intr.mhigh - intr.mlow + 1
     intr.numpert_total = intr.mpert * intr.npert
     metric = FFS.make_metric(equil, intr.mpert)
-    ffit = FFS.make_matrix(equil, intr, metric)
-    odet, _, _, _ = FFS.riccati_eulerlagrange_integration(ctrl, equil, ffit, intr)
-    return ctrl, equil, ffit, intr, odet
+    mats = FFS.build_matrix_splines(equil, intr, metric)
+    odet, _, _, _ = FFS.riccati_eulerlagrange_integration(ctrl, equil, mats, intr)
+    return ctrl, equil, mats, intr, odet
 end
 
 println("\n=== compute_delta_prime_from_ca! consistency check ===")
 println("Verifies the standalone Δ' formula matches the inline Riccati crossing computation.")
 println("Expected error: exactly zero (same formula, same data).\n")
 
-ctrl, equil, ffit, intr, odet = setup_and_run_solovev()
+ctrl, equil, mats, intr, odet = setup_and_run_solovev()
 msing = intr.msing
 
 # Capture Δ' values set inline by riccati_cross_ideal_singular_surf! during integration

benchmarks/benchmark_delta_prime_methods.jl

@@ -42,19 +42,19 @@ function setup_solovev()
     intr.mpert = intr.mhigh - intr.mlow + 1
     intr.numpert_total = intr.mpert * intr.npert
     metric = FFS.make_metric(equil, intr.mpert)
-    ffit = FFS.make_matrix(equil, intr, metric)
-    return ctrl, equil, ffit, intr
+    mats = FFS.build_matrix_splines(equil, intr, metric)
+    return ctrl, equil, mats, intr
 end
 
 # Evaluate the Riccati RHS explicitly from splines: dS = w†·F̄⁻¹·w - S·Ḡ·S
-function riccati_rhs_manual(S, psi, equil, ffit, intr)
+function riccati_rhs_manual(S, psi, equil, mats, intr)
     N = intr.numpert_total
     L = zeros(ComplexF64, N, N)
     Kmat = zeros(ComplexF64, N, N)
     Gmat = zeros(ComplexF64, N, N)
-    ffit.fmats_lower(vec(L), psi; hint=ffit._hint)
-    ffit.kmats(vec(Kmat), psi; hint=ffit._hint)
-    ffit.gmats(vec(Gmat), psi; hint=ffit._hint)
+    mats.ideal.F_spline_lower(vec(L), psi; hint=mats._hint)
+    mats.ideal.K_spline(vec(Kmat), psi; hint=mats._hint)
+    mats.ideal.G_spline(vec(Gmat), psi; hint=mats._hint)
 
     q = equil.profiles.q_spline(psi)
     singfac = vec(1.0 ./ ((intr.mlow:intr.mhigh) .- q .* (intr.nlow:intr.nhigh)'))
@@ -77,7 +77,7 @@ println("\n=== riccati_der! formula verification ===")
 println("Verifies riccati_der! output matches manual evaluation of Glasser 2018 Eq. 19.")
 println("Test state: Hermitian S (physical constraint). Expected error: ~machine epsilon.\n")
 
-ctrl, equil, ffit, intr = setup_solovev()
+ctrl, equil, mats, intr = setup_solovev()
 N = intr.numpert_total
 
 odet = FFS.OdeState(N, ctrl.numsteps_init, ctrl.numunorms_init, intr.msing)
@@ -101,15 +101,15 @@ max_err = let max_err = 0.0
         S = (A + A') / 2   # Hermitian by construction
 
         # Manual RHS
-        dS_manual = riccati_rhs_manual(S, psi, equil, ffit, intr)
+        dS_manual = riccati_rhs_manual(S, psi, equil, mats, intr)
 
         # riccati_der! RHS
         u_ric = zeros(ComplexF64, N, N, 2)
         du_ric = zeros(ComplexF64, N, N, 2)
         u_ric[:, :, 1] .= S
         u_ric[:, :, 2] .= Matrix{ComplexF64}(I, N, N)
         dummy_chunk = FFS.IntegrationChunk(psi, psi, false, 0, 1)
-        params = (ctrl, equil, ffit, intr, odet, dummy_chunk)
+        params = (ctrl, equil, mats, intr, odet, dummy_chunk)
         FFS.riccati_der!(du_ric, u_ric, params, psi)
         dS_ric = du_ric[:, :, 1]
 

benchmarks/benchmark_riccati_der.jl

@@ -30,9 +30,9 @@ function run_ffs(ex; integrator)
     intr.mpert = intr.mhigh - intr.mlow + 1
     intr.numpert_total = intr.mpert * intr.npert
     metric = GeneralizedPerturbedEquilibrium.ForceFreeStates.make_metric(equil, intr.mpert)
-    ffit = GeneralizedPerturbedEquilibrium.ForceFreeStates.make_matrix(equil, intr, metric)
-    odet, _, _, _ = GeneralizedPerturbedEquilibrium.ForceFreeStates.eulerlagrange_integration(ctrl, equil, ffit, intr)
-    vac = GeneralizedPerturbedEquilibrium.ForceFreeStates.free_run(odet, ctrl, equil, ffit, intr)
+    mats = GeneralizedPerturbedEquilibrium.ForceFreeStates.build_matrix_splines(equil, intr, metric)
+    odet, _, _, _ = GeneralizedPerturbedEquilibrium.ForceFreeStates.eulerlagrange_integration(ctrl, equil, mats, intr)
+    vac = GeneralizedPerturbedEquilibrium.ForceFreeStates.free_run(odet, ctrl, equil, mats, intr)
     return real(vac.et[1]), intr.numpert_total
 end
 

benchmarks/benchmark_threads.jl

@@ -57,11 +57,14 @@ Splines are provided by the external `FastInterpolations` package rather than by
    - Solves ideal MHD eigenvalue problem with force-free boundary conditions
    - Identifies singular surfaces where ξ·∇ψ = 0
    - Key files:
-     - `ForceFreeStatesStructs.jl` - Core data structures
+     - `CoreTypes.jl` - Module-wide types (`ForceFreeStatesControl`, `ForceFreeStatesInternal`)
      - `Result.jl` - `ForceFreeStatesResult`, the published solve product every downstream stage reads
-     - `Ode.jl` - ODE solver for Euler-Lagrange equations
-     - `Sing.jl` - Singular point handling and layer analysis
-     - `Fourfit.jl` - Fourier fitting routines
+     - `EulerLagrange.jl` - ODE integration of the Euler-Lagrange equations (`OdeState`, derivative kernel)
+     - `Surfaces/` - Singular-surface finding, Frobenius asymptotics, and GGJ coefficients
+     - `Riccati/` - Chunked fundamental-matrix (STRIDE) driver and Δ' boundary-value problem
+     - `Galerkin/` - RDCON outer-region singular Galerkin Δ' solver
+     - `Matching/` - Outer↔inner resistive matching (`DeltaPrimeData`, `resonant_match_rpec`)
+     - `Fourfit.jl` - Fourier fitting routines (`MatrixSplines`)
      - `FixedBoundaryStability.jl` - Fixed boundary analysis
      - `Free.jl` - Free boundary stability
    - Status: Stable, core DCON functionality implemented

docs/development/architecture.md

@@ -4,14 +4,16 @@ A short list of who to suggest as a reviewer or assignee, and the GitHub handle
 
 **This is a suggestion list, not a roster.** It names lead developers only — many more people contribute, and their absence here means nothing. It exists mainly so an AI agent has somewhere sensible to start; a human opening a pull request can simply pick from GitHub's own dropdown and does not need this file.
 
+**Focus names Areas, including the ones outside `src/`.** Focus values are the Area names from [`naming.md`](naming.md), so they cover repository maintenance as well as physics modules: `CI` is the workflows under `.github/`, and `Repo` is the cross-cutting plumbing — conventions, templates, the changelog, and the regression harness. Those rows exist so a tooling change has somewhere to go; without them a CI fix has no obvious reviewer and lands unassigned.
+
 **Focus is advisory, not ownership.** Nobody is obliged to review a change because they appear in a row, and nobody is barred from one because they do not. There is no `CODEOWNERS` file, so GitHub requests no reviewers automatically — choosing them is the author's job. When it is not obvious who should review, ask rather than guess, and open the pull request as a draft until it has a reviewer and an assignee.
 
 This file is not published to the documentation site; `docs/development/` sits outside the Documenter source tree.
 
 | Name | Handle | Focus |
 |---|---|---|
-| Nikolas Logan | `@logan-nc` | KineticForces, PerturbedEquilibrium, Equilibrium, ForceFreeStates |
-| Matthew Pharr | `@matt-pharr` | ForceFreeStates, InnerLayer |
+| Nikolas Logan | `@logan-nc` | KineticForces, PerturbedEquilibrium, Equilibrium, ForceFreeStates, CI, Repo |
+| Matthew Pharr | `@matt-pharr` | ForceFreeStates, InnerLayer, CI, Repo |
 | Jake Halpern | `@jhalpern30` | Vacuum, ForceFreeStates, Equilibrium |
 | Daniel Burgess | `@d-burg` | Tearing, ForceFreeStates |
 | Jaebeom Cho | `@JaeBeom1019` | Vacuum, Equilibrium, ForceFreeStates |

docs/development/contributors.md

@@ -67,6 +67,7 @@ Mechanism: writers stay table-driven — each writer keeps a `path => (; long_na
 
 - Complex quantities are stored as the native HDF5.jl compound type (readable by h5py as a compound dtype) — **never split into `*_real`/`*_imag` dataset pairs**. Sole sanctioned exception: `Input/RawInputs/ForcingTerms/amplitude_{real,imag}`, which mirrors the external forcing ingest-file format and keeps pre-existing snapshots replayable.
 - `NaN` is the not-computed sentinel in numeric datasets (e.g. auto-derived settings, rootless growth-rate entries).
+- A **zero-extent array** is the not-computed sentinel for whole datasets that a given run never produces (e.g. `SingularSurfaces/ca_left`/`ca_right` on kinetic or galerkin-matched runs, the free-boundary energies when `vac_flag=false`, the on-demand derivative stores). Never write unpopulated (`undef`) memory.
 - Ragged (variable-length) data uses the flat-plus-`offsets` companion pattern (`offsets[k+1] - offsets[k]` = length of row `k`) rather than HDF5 VLEN types, e.g. `KineticForces/<method>/EnergyIntegrals/` and `Tearing/Diagnostics/*`.
 
 ## Back-compatibility policy

docs/development/hdf5-conventions.md

@@ -98,14 +98,12 @@ regress --cases solovev_n1 --ref-range develop~10..develop
 - `--force` — re-run even if cached
 - `--verbose` — print GPEC subprocess output
 - `--no-instantiate` — skip `Pkg.instantiate()` (faster if deps are already resolved)
-<<<<<<< HEAD
-
-GPEC subprocesses run with `-t auto` (all cores) so GPEC's threaded kernels are active; set `GPEC_REGRESS_THREADS=1` to force single-threaded runs. Tracked quantities are thread-count independent, and the count each run actually used is recorded in its environment fingerprint (shown in the report's `env:` lines). Thread count is deliberately not part of the cache key, so `Runtime (s)` rows cached from single-threaded runs are not comparable to threaded ones — re-baseline with `--force` if runtime tracking matters.
-=======
 - `--no-pin-manifest` — let each ref resolve its own package set (see below)
 - `--allow-env-mismatch` — reuse cached results produced in a different environment
 - `--fail-on-change` — exit non-zero when any tracked quantity changed
 
+GPEC subprocesses run with `-t auto` (all cores) so GPEC's threaded kernels are active; set `GPEC_REGRESS_THREADS=1` to force single-threaded runs. Tracked quantities are thread-count independent, and the count each run actually used is recorded in its environment fingerprint (shown in the report's `env:` lines). Thread count is deliberately not part of the cache key, so `Runtime (s)` rows cached from single-threaded runs are not comparable to threaded ones — re-baseline with `--force` if runtime tracking matters.
+
 ## Making source code the only variable
 
 `Manifest.toml` is untracked, so a worktree checked out at an old commit used to resolve whatever
@@ -140,11 +138,9 @@ than leaving you to infer it from the numbers.
 Results cached before environment fingerprinting existed carry no environment and are therefore
 re-run once — those are exactly the entries whose provenance cannot be established.
 
-Thread counts are recorded but **not** forced: the harness does not silently change how your runs
-execute. If the two refs in a comparison ran under different thread counts, the report flags it.
+If the two refs in a comparison ran under different thread counts, the report flags it.
 
 ## Exit status
 
 - `0` — every run completed (and, with `--fail-on-change`, nothing changed)
 - `1` — a run failed, or a quantity changed under `--fail-on-change`
->>>>>>> performance/regression-harness-worktree-reuse

docs/development/regression-harness.md

@@ -36,7 +36,7 @@ The primary reference for the `ForceFreeStates` module. Derives the Euler-Lagran
 > *Physics of Plasmas* **25**, 032507 (2018).
 > DOI: [10.1063/1.5007042](https://doi.org/10.1063/1.5007042)
 
-Reformulates the DCON eigenvalue problem as a Riccati matrix ODE, enabling parallel integration across singular surfaces and faster computation. Implemented in `src/ForceFreeStates/Riccati.jl` and enabled via `integrator = "riccati"` in `[ForceFreeStates]`.
+Reformulates the DCON eigenvalue problem as a Riccati matrix ODE, enabling parallel integration across singular surfaces and faster computation. Implemented in `src/ForceFreeStates/Riccati/` and enabled via `integrator = "riccati"` in `[ForceFreeStates]`.
 
 ---