[physicistphil]

Summary

Feature parity of lpse2d (envelope-2d) with the original LPSE C++ code (deck v5.1.2), following the plan in the research vault (Notes/adept/2026-09-14-144422-claude-lpse2d-parity-plan-*). Everything is opt-in and default-preserving unless stated.

Foundations (A)

• adept/_lpse2d/lpse_deck.py: LPSE lpse.parms translator (translate_parms, parse_parms with #include), ZAK unit system, read_metrics / read_frames for LPSE output files, CLI.
• EPW energy ledger (terms.epw.energy_ledger) with per-operation channels and closure.

Term parity (B, B')

• Thermal (fluctuation-dissipation) EPW noise, LPSE TPD source form (tpd_form: lpse), transverse TPD depletion, Landau-damping options (form, threshold, multiplier, relativistic 2-D Bessel rate), LPSE exponential absorbers, max_wavenumber caps, rectangular dealiasing, LPSE density profiles (lpse-<shape>: linear, exp, gaussian, inverse-power, quadratic, qd, gd, file).
• IAW: spectral exact damped-oscillator propagator, Krall-Trivelpiece ion Landau rate, flow Doppler, stride, IAW noise, thermal filamentation (terms.iaw.thermal_filamentation).

Solvers (C)

• Spectral light propagator with L/T projection and smooth injectors (terms.light.solver: spectral), collisional light absorption (NRL), separate light absorber rate (terms.light.boundary_max_rate), transverse projection of the SRS light sources (terms.light.transverse_source), optional SRS source k-filter (terms.epw.source.srs_k_filter).
• Combined TPD+SRS solver (terms.epw.solver: combined).
• Pump injector generalisation: oblique incidence (drivers.E0.angle), beamlets (beams), transverse super-Gaussian, Kubo-Anderson bandwidth, pulse-shape file.

Kinetics, workflow, diagnostics (D)

• HPE controls and instruments (terms.hpe.*): gamma limits, per-direction thermalization probability with LPSE particle-wall semantics, uniform B field, energy-conservation multiplier, wall-flux and cone-power instruments.
• Checkpoint / restart (save.checkpoint, restart.file), bit-exact resume.
• Absolute-threshold bisection driver (adept._lpse2d.threshold).
• Poynting-flux fields (save.fields.poynting) and Thomson probes (save.thomson).

Cross-checks against LPSE reference runs (translated decks)

deck	physics	result
homogeneous SRS control	SRS from noise, periodic	energy growth 25.2/ps vs LPSE 25.3/ps
homogeneous TPD control	TPD from noise, periodic	28.7/ps vs 28.9/ps
test_006	SRS, static pump, gradient	5.96/ps vs 5.80/ps, same growth location (n_c/4)
test_029	TPD + IAW, static pump	12.3/ps vs 13.0/ps, saturation at 1.2 ps in both
test_010	TPD + IAW, oblique evolving pump	same modes and saturation physics; growth 9.5 vs 11.8/ps (open)
test_032	combined TPD+SRS+IAW, 10 ps	same phases, saturation at 3.3 ps; growth 12-16 % below LPSE (open)
test_013	everything, spectral light	half-max at 2.36 vs 2.35 ps, IAW clip in both
test_022	everything, LPSE FD light	half-max at 2.30 vs 2.69 ps, IAW clip in both
test_036	HPE walls, field-free	wall flux per keV bin within 6 % (with v_min: 0.05)
test_037	everything + HPE feedback	linear stage agrees; kinetic feedback over-damps after HPE starts (open, see vault M5 note)

Five adept defects were found and fixed by the cross-checks: the always-on SRS source k-filter removed the resonant Raman mode at densities below the envelope density; the longitudinal part of the SRS light source accumulated in E1 (spurious two-wave instability); the light fields used the EPW absorber (injected pump reflected into a standing wave, 1.45x amplitude) in the separate and in the combined solver; the spectral injectors ran without sub-cycling when the deck gave no light dt. The term coefficients matched LPSE in every homogeneous control.

Tests

tests/test_lpse2d/: test_lpse_parity.py, test_lpse_deck.py, test_spectral_light.py, test_combined.py, test_iaw_spectral.py, test_energy_ledger.py, test_oblique_pump.py, test_lpse_density.py, test_threshold.py, test_restart.py, test_diagnostics_lpse.py, test_thermal_filamentation.py, test_hpe.py (extended). Docs: docs/source/solvers/lpse2d/config.md.

🤖 Generated with Claude Code

[ergodic-reviewer]

Request changes for the source-level defects documented in the review comments: combined-solver noise uses the wrong timestep, its evolved pump ignores supported driver settings, combined Raman-flux maps include the EPW, LPSE density files are transposed twice, quasi-1D periodic particle crossings bypass the new wall handling, and a default test depends on an unavailable developer-local deck.

Postprocessing is implemented and reachable through BaseLPSE2D.post_process and the existing ergoExo artifact lifecycle. The additions connect ledger/HPE/Thomson series, optional flux fields, and checkpoints to that path; the combined-field flux incompatibility needs correction before those maps are scientifically usable.

Validation: reviewed the complete diff, relevant implementations/call sites, tests, and repository guidance at 3c429904ed81e4b75e19e5b02763e22388f3feec. GitHub reports test-lpse2d as failing. I did not execute tests, benchmarks, or postprocessing, and did not access the author's local LPSE reference artifacts.

[ergodic-reviewer]

[P1] Scale the noise kick to the timestep at which it is applied

CombinedSolver.__init__ builds self.noise_kick with noise_kick_spectrum(cfg), which uses grid.dt. However, substep calls add_noise on every light sub-step, while propagation/damping advance by self.dt_l. With light_substeps > 1, this repeatedly injects an outer-step kick against sub-step damping. In particular, thermal noise no longer equilibrates to the configured fluctuation-dissipation spectrum, and changing light subcycling changes the physical seed level. diagnostics.expected_noise_energy still assumes one outer-step kick, so its growth-fit floor also disagrees with the simulation. Build the kick for the actual noise timestep (and keep the diagnostic consistent), or apply the outer-step source only once per outer step. Add a combined-solver thermal-noise/subcycling regression; the current equilibrium test exercises only SpectralEPWSolver.

[physicistphil]

Fixed in 59e01d0. epw.noise_step(cfg) returns the step at which the active solver applies the kick (the light sub-step for the combined solver) and the rate it damps with; CombinedSolver builds its kick from it and diagnostics.expected_noise_energy uses the same values, so the growth-fit floor matches. The flat model's kick is now amplitude * sqrt(dt_EPW * dt) (unchanged for the separate solver), so its seed level does not depend on the sub-step count either. New tests: the combined steady state is independent of light_substeps for thermal and flat noise (8 vs 2 sub-steps gave 3.96x / 3.98x on the old kick), and equals the expected_noise_energy floor (15 %).

[ergodic-reviewer]

[P1] Preserve pump-driver settings on the combined-solver path

CombinedSolver.calc_pump_source only constructs a normal-incidence scalar source, and substep adds it only to E0[..., 1]. It never consumes the derived beam angles/fractions/phases/frequency offsets, transverse profile, KAP bandwidth, or pulse table implemented by SpectralCoupledLight. Setup nevertheless accepts these settings with epw.solver: combined because light.solver is spectral, and SplitStep.combined_step bypasses self.coupled_light. Thus switching an oblique/multi-beam or shaped-pulse run to the solver required for simultaneous TPD/SRS silently changes the pump to a different physical problem. Share the existing spectral injector implementation with the combined solver, or explicitly reject unsupported combinations rather than ignoring them; cover an oblique or multi-beam combined run.

[physicistphil]

Fixed in 1e3cf4a by sharing the implementation: the spectral light solver's injector (beam angles, fractions, phases, frequency offsets, transverse profile, KAP bandwidth, pulse table) moved into SmoothPumpInjector, which SpectralCoupledLight and CombinedSolver both use; the combined step adds the full vector source. Normal incidence is bit-identical to the previous combined source, so the combined parity decks (one normal-incidence beam each) are unaffected. New tests: the combined and spectral sources are identical for two oblique beams with a profile, KAP and a pulse table, and a combined run launches both +-20 deg beams (> 95 % of the power in the two ky rows, balanced to 5 %); both fail on the old solver.

[ergodic-reviewer]

[P2] Remove the EPW component before computing Raman flux maps

For epw.solver: combined, saved state["E1"] is the full longitudinal EPW plus transverse Raman field. This loop treats it all as Raman light and applies the light-flux coefficient, so even a purely longitudinal EPW traveling mode produces a nonzero s1_x/s1_y map despite there being no scattered light. The default-series saver already handles this distinction with combined.transverse_part, but that local conversion does not change the separately saved fields consumed here. Apply the same separation to the field-output path, preferably before spatial downsampling, and test a pure longitudinal combined field. Otherwise the new persisted Raman-flux diagnostics misidentify plasma-wave energy as escaping light.

[physicistphil]

Fixed in f6b1e1a. helpers._raman_light_part(cfg) takes the transverse part of E1 in combined mode; the default series and both field-save paths now use it, before any spatial interpolation, so the saved E1 fields and the s1 maps are the Raman light (the EPW is saved as epw). Test: a pure longitudinal combined field saves E1 = 0 and s1 = 0, and a mixed field's s1 equals its transverse part's.

[ergodic-reviewer]

[P2] Do not transpose LPSE frames a second time

lpse_deck.read_frames already converts the x-fastest file layout to an (Nx, Ny) array with reshape((nz, ny, nx)).transpose(2, 1, 0)[:, :, 0]; its reader test explicitly checks that shape. The .T here reverses it again. Consequently, a rectangular LPSE density file is rejected by the following (nx, ny) shape check, while a square file silently rotates an x-dependent density profile into the y direction. Use the reader's returned orientation directly and add a non-square LPSE-file density round trip; the current density-file test only exercises .npy.

[physicistphil]

Fixed in 27418ef: the loader uses read_frames' orientation directly. Test: a non-square (200 x 8) profile written in LPSE's binary layout round-trips through read_frames and the lpse-file loader; the old loader raised the shape error. The only shipped LPSE deck with a density file (test_018, 1800 x 1800) had not been run in adept.

[ergodic-reviewer]

[P2] Retain periodic crossings in the quasi-1D particle push

This wraps the carried x back into the box on every quasi-1D sub-step. By the time push invokes the new _apply_boundaries, neither out_left nor out_right can detect a periodic crossing. For ny == 1 with periodic x field boundaries, the new wall/cone energy instruments therefore miss outgoing particles, and an explicitly nonzero thermalization_probability[0] is silently ignored. The 2-D implementation now preserves the unwrapped position and wraps only the gather coordinates for exactly this reason. Apply that pattern here as well, with a 1-D particle crossing test that checks both the instrument and thermalization.

[physicistphil]

Fixed in f6c7429 with the 2-D pattern: the quasi-1D _substep wraps only the gather coordinate and carries the unwrapped x to _apply_boundaries; with the default pass-through probability the trajectories are unchanged. Test through push(): 10 keV electrons crossing the right wall of a periodic quasi-1D box are counted at that wall, then wrap (p = 0) or are re-injected inward at x_max (p = 1); the old push recorded no flux.

[ergodic-reviewer]

[P2] Make the beam-direction translation test portable

test_translator_maps_the_test_010_beam_direction unconditionally passes /home/phil/Desktop/Ergodic-projects/original-lpse/examples/testRuns/test_010/lpse.parms to parse_parms, which immediately calls Path.read_text(). That external checkout is not provided by the repository or the test-lpse2d workflow, so this normal, unmarked test raises FileNotFoundError in CI and ordinary contributor checkouts. Use a checked-in/minimal temporary deck for this translation assertion, or guard the external-reference case as the tests in test_lpse_deck.py already do. This is a concrete portability failure, not a request to reproduce the inaccessible reference simulations.

[physicistphil]

Fixed in 278fda7: the test writes test_010's beam lines (laser_include.txt) and the main-deck keys the translator needs to a temporary directory, so parse_parms (including the #include) and translate_parms run without an LPSE checkout.

[ergodic-reviewer]

Request changes for two correctness defects detailed inline: combined thermal-noise setup can be rejected by the unused separate EPW solver, and FD rotation coupling bypasses the new transverse SRS-source projection.

Postprocessing is implemented and reachable through BaseLPSE2D.post_process and the existing ergoExo artifact lifecycle, including field/series datasets, plots, derived metrics, optional flux/Thomson/ledger/HPE diagnostics, and checkpoints. The latest combined-absorption and threshold-bracket fixes are present with regression tests in source.

Validation: source review of the diff, relevant implementations/call sites, tests, and repository guidance at 672418056145997380be2b8c032ce264f7f86002. The last GitHub check read reported test-lpse2d in progress. I did not execute tests, benchmarks, or postprocessing, or inspect the external LPSE reference artifacts.

[ergodic-reviewer]

[P2] Skip separate EPW initialization for combined runs

SplitStep constructs SpectralEPWSolver before selecting the combined solver. With terms.epw.solver: combined, source.noise: true, noise_model: thermal, damping.landau: false, damping.collisions: false, and positive terms.light.absorption, this unused constructor calls noise_kick_spectrum(cfg) without the combined rate. It therefore sees zero damping and raises thermal needs EPW damping before CombinedSolver is reached. The combined solver itself correctly uses noise_step(cfg) and the Raman absorption rate, so this is a valid damped thermal-noise configuration that cannot run through BaseLPSE2D/ergoExo.

Only initialize the separate EPW solver on the separate path (or otherwise avoid its irrelevant noise validation). Add a regression through SplitStep or module setup; constructing CombinedSolver alone does not cover this failure.

[physicistphil]

Fixed in 2577b05. SplitStep determines epw_solver first and builds epw.SpectralEPWSolver(cfg) only on the separate path; in combined mode self.epw is None (nothing else reads it there — the other builds in SplitStep.__init__ are already skipped or used by the combined step).

Test test_combined.py::test_combined_thermal_noise_needs_only_the_raman_absorption: combined, noise_model: thermal, Landau and collisions off, Raman absorption > 0 → SplitStep(cfg) sets up, step.epw is None, noise_step(cfg) returns ν_R, and the combined noise kick is nonzero. Before the fix it raised the quoted "thermal needs EPW damping" error. The docs row for terms.epw.solver now says the separate EPW solver is not built in combined mode.

Merged into plan2 (3a096b8; the plan2 version of the test uses terms.light.raman_absorption) and #387 (5f7b67b). On plan2, test_gradients.py used step.epw.energy as its objective on the combined paths too; 7081182 computes the same measure Σₖ k²|φₖ|² from the grid (tolerances unchanged, 8/8).

[ergodic-reviewer]

[P2] Honor transverse-source projection in the rotation coupling path

The new projection is only applied inside the couple-guarded RHS. For the supported FD evolved-pump configuration coupling: rotation, CoupledLight.__call__ sets couple_in_rhs = False and instead uses couple(), whose pointwise exchange never checks self.transverse_source. Consequently transverse_source: true is silently ignored for both SRS light sources on that path.

In 2-D, even a transverse input pump multiplied by an EPW mode with nonzero transverse wavenumber produces a longitudinal component in the Raman source. The rotation path retains that component, which then enters the EPW SRS feedback instead of evolving the projected light equations. This defeats the longitudinal-source correction implemented here. Make the rotation path compatible with the projection, or explicitly reject the unsupported combination, and cover it with a nonzero-ky regression rather than only the pointwise exchange invariant.

[physicistphil]

Fixed in 55fd66f by refusing the combination rather than adding a projection to the rotation: the exact exchange is a pointwise rotation of (E0, E1), and the k-space projection of its sources has no counterpart in it (the spectral solver keeps the fields themselves transverse instead, which is why it is unaffected).

CoupledLight.__init__ now raises for coupling: rotation + SRS on + transverse_source: true with terms.light.solver: fd, naming the alternatives: coupling: explicit or solver: spectral to keep the projection, or transverse_source: false — which reproduces what fd rotation runs did so far. On this branch transverse_source defaults to true, so an fd rotation deck that leaves it unset is now refused. FDCombinedSolver inherits this __init__, but combined mode already refuses any non-explicit coupling in helpers.

Test test_light_coupling.py::test_fd_rotation_refuses_the_transverse_source_projection_it_cannot_apply (did not raise before). The rotation configs of test_light_coupling.py and the srs+pump_depletion case of test_energy_ledger.py were built with the default and are refused without it; they now set transverse_source: false explicitly, and their behaviour is unchanged. Docs: coupling and transverse_source rows.

On plan2 transverse_source defaults to false (LPSE takeTransversePartOfSourceTerms), so there only an explicit true is refused; 4223609 adapts the message, docs and test, and names transverse_fields: true (applied after the sub-steps under either coupling) as the fd way to keep the light transverse with rotation.

[ergodic-reviewer]

Request changes for two postprocessing correctness defects detailed inline: combined-mode EPW dissipation uses the separate solver's collision model, and HPE inverse-Landau growth produces NaNs in the default energy diagnostics.

Postprocessing is implemented and reachable through BaseLPSE2D.post_process and the ergoExo artifact lifecycle, including field/series datasets, plots, derived metrics, optional flux/Thomson/ledger/HPE diagnostics, and checkpoints. The findings affect the scientific interpretation of the saved heating and energy-budget results. The latest separate-EPW initialization and FD rotation-validation fixes are present with regression tests in source.

Validation: source review of the diff, relevant implementations/call sites, tests, and repository guidance at 55fd66fad6e042749b99888ff7c6ca4b25ad41ad. The last GitHub check read reported test-lpse2d in progress. I did not execute tests, benchmarks, or postprocessing, or inspect the external LPSE reference artifacts.

[ergodic-reviewer]

[P2] Use the combined solver's damping in the dissipation diagnostic

get_default_save_func still builds epw_dissipation from the separate EPW collision rate, but CombinedSolver explicitly ignores nu_coll and damps the longitudinal field with nu_raman * (n_over_env + iaw_density)**2. For a combined run with EPW Landau damping/collisions off and terms.light.absorption > 0 (already a supported case in test_combined.py), this diagnostic reports zero dissipation even while a nonzero longitudinal wave loses energy. Conversely, enabling EPW collisions can report absorption that the combined solver never applies. diagnostics.series_metrics integrates this series into electron_energy_final and uses it for laser_absorbed_frac_epw, so the exported heating/budget results are incorrect. Please select the active solver's damping here, including its density dependence, and cover a longitudinal combined-field absorption case through the save function.

[physicistphil]

Fixed in 9119fd2 (#372); merged into plan2 (d9f0d46, with the plan2 adaptations below) and #387 (1467202).

In combined mode, get_default_save_func now builds epw_dissipation from the damping the combined solver actually applies:

• the Landau rate in k-space (y["gamma_L"] with HPE), with no nu_coll;
• plus the x-space collisional loss (1 − exp(−2 ν_R (n/n_env + δn)² dt))/dt on the EPW energy density.

combined_collision_rate(cfg) is now the single source of ν_R for both CombinedSolver and the diagnostic. On the test box, the pre-fix diagnostic reported 1.67×10⁷ against 2.95×10⁹.

Same class, also fixed:

• The IAW thermal-filamentation lw heating used 2 ν_coll n/n_env in combined mode as well. It now uses the combined damping 2 ν_R (n/n_env)², the raman term's coefficient on the same field, and requires terms.light.absorption.
• On plan2, where the combined field has its own absorbing layer, epw_boundary_loss now uses grid.combined_absorbing_boundaries in combined mode (8bd768f; the EPW layer gave 1.23×10⁹ against 7.10×10⁹).

Plan2 adaptations in the merge:

• ν_R follows raman_absorption.
• δn enters through the Raman class's IAW feedback factor, as plan2's combined solver does.
• thermal_filamentation.lw stays dropped in combined mode (LPSE); the test there checks that the heating does not depend on the EPW collisions.

Tests:

• test_combined.py::test_combined_dissipation_diagnostic_uses_the_combined_damping, through the save function, with Landau off (EPW collisions on) and on. Exact identities against 2(2 − n/n_env)·L_c·epw_energy plus the Parseval Landau term, rtol 1e-12.
• test_thermal_filamentation.py::test_lw_heating_in_combined_mode_uses_the_combined_damping.
• On plan2, test_combined_boundary_loss_diagnostic_uses_the_combined_layer.

All fail before the fix.

[ergodic-reviewer]

[P2] Make the default energy diagnostics support inverse-Landau growth

The new allow_growth path permits negative gamma_L (as test_gamma_limits_and_allow_growth demonstrates), but helpers.get_default_save_func still computes loss_factor = (1 - exp(-2 * (gamma_L + nu_coll) * dt)) / dt followed by the real jnp.sqrt(loss_factor). With collisions off, any negative-rate mode therefore introduces NaNs into the inverse FFTs and epw_dissipation, even when the simulation fields remain finite. Those NaNs propagate to the saved series, electron-energy integral and absorbed-energy metrics. Please handle signed energy transfer in the diagnostic, rather than feeding negative rates into the positive-loss square-root construction, and extend the growth regression through the default save/postprocessing path.

[physicistphil]

This was already fixed when this comment was posted. ca6ced8 on this branch splits the loss factor into L⁺ = max(L, 0) and L⁻ = max(−L, 0); the density is |ifft(√L⁺ Eₖ)|² − |ifft(√L⁻ Eₖ)|², so epw_dissipation is the signed net transfer and its box integral is exactly Σₖ Lₖ|Eₖ|². The windowed branch on #387 got the same treatment in 359f9cd.

Regressions through the default save path: test_hpe.py::test_dissipation_diagnostic_is_signed_with_allow_growth and test_hpe_windows.py::test_windowed_dissipation_is_signed_with_allow_growth. They use mixed-sign rates against the Parseval closed form at rtol 1e-12, and check that non-negative rates are bitwise identical with and without allow_growth. Both were NaN before; see also the #387 thread on the same defect.

[ergodic-reviewer]

Request changes for two correctness issues:

• The previously reported combined-mode dissipation defect remains: get_default_save_func uses the separate EPW collision model instead of the combined field's Raman absorption and density dependence. A longitudinal combined wave can lose energy while epw_dissipation reports zero, corrupting the derived heating/budget metrics. The existing thread retains the requested fix; no duplicate inline comment added.
• HPE energy-conservation rescaling can exceed the configured damping/growth limits before handing gamma_L to the solver; detailed inline.

The signed inverse-Landau dissipation fix and separation of the light/EPW wavenumber caps are present with regression tests in source.

Postprocessing is implemented and reachable through BaseLPSE2D.post_process and the ergoExo artifact lifecycle, including field/series datasets, plots, derived metrics, optional flux/Thomson/ledger/HPE diagnostics and checkpoints. The combined dissipation issue is an output-correctness problem, not an absent analysis path.

Validation: source review at ca6ced826cfedc9815253f6d578d876b55fefc8d. The last GitHub check read reported test-lpse2d in progress. I did not execute tests, benchmarks or postprocessing, or inspect the external LPSE reference artifacts.

[ergodic-reviewer]

[P2] Apply the HPE rate limits after energy-conservation rescaling

These bounds only constrain the rate returned by damping(). In HybridParticleEvolution.__call__, feedback() subsequently multiplies that rate by mult[0] when energy_conservation is enabled, with no final clipping. ld_multiplier() permits values above one (its regression test explicitly exercises this), so a resonant mode already at gamma_limit_damping is written to y["gamma_L"] above that limit; the negative bound can likewise be exceeded with allow_growth. Both EPW solvers consume this state directly in their damping exponential. Thus enabling the energy-conservation control defeats the configured bounds on the applied kinetic damping/growth, changing the wave evolution despite those limits.

Please enforce the configured bounds on the final feedback rate, preserving the intended treatment of non-resonant modes, and cover the combined controls through __call__. The current limit test exercises damping() alone and the multiplier test exercises ld_multiplier() alone, so neither checks the rate actually handed to the solver.

[physicistphil]

Fixed in 971f999 (#372); merged into plan2 (a694ba0, inside plan2's running-average multiplier) and #387 (56e4c86).

After the energy-conservation multiplier, HybridParticleEvolution.limit_resonant clips the resonant modes again to [−gamma_limit_growth, gamma_limit_damping]. The non-resonant modes keep the multiplier times their analytic rate, with no clip. The rate handed to the solver therefore respects the configured limits.

This departs from LPSE, which clips only before its LD_multiplier (ElectronTracker.cu:2792; LwSolver.cpp:823 and LightSolver.cpp:3707 apply LD_multiplier · LDgammaE). Where a limit binds, the energy balance the multiplier enforces no longer holds exactly; the docs rows for both limits say so. Windowed HPE is unaffected: n_windows > 1 with energy_conservation is already refused at setup.

Regression through __call__: test_hpe.py::test_gamma_limits_bound_the_rate_after_the_energy_conservation_multiplier. The multiplier is held at 5 by a 10⁶-step running average started from 5, so the limit binds. The test checks:

• the applied rate is clip(5 × rate) on the resonant modes and 5 × rate elsewhere (rtol 1e-12);
• the limit holds on the resonant modes.

Before the fix 63 of the 160 modes exceeded the limit. A test added earlier in this round pinned LPSE's order instead; it is replaced.

[ergodic-reviewer]

Request changes:

• The previously reported HPE rate-limit defect remains at this head. HybridParticleEvolution.__call__.feedback multiplies the already-clipped rate by the energy-conservation multiplier without enforcing the bounds again. With energy_conservation enabled, the gamma_L consumed by the wave solver can exceed the configured damping/growth limits. Please enforce the limits on the final feedback rate; the existing thread retains the details, without a duplicate inline comment.
• The new required HPE instrument entries also break the existing test_oneil_flattening slow regression: its manually constructed state omits those entries, causing a KeyError before it exercises nonlinear feedback. Details and the caller update are inline.

The combined-mode dissipation and thermal-filamentation coefficient fixes are present, with regression tests in source. Postprocessing is implemented and reachable through BaseLPSE2D.post_process and the ergoExo artifact lifecycle, including field/series datasets, derived metrics, optional flux/Thomson/ledger/HPE diagnostics and checkpoints.

Validation: source review at 9119fd2ab19f077c2aeb0e4d0b7f4ee7a9dd7189. I did not execute tests, benchmarks or postprocessing, or inspect the external LPSE reference plots/artifacts.

[ergodic-reviewer]

[P2] Update the existing trapping regression for the new required state

tests/test_lpse2d/test_hpe.py::test_oneil_flattening still constructs y with only epw, x_e, u_e, epw_hist, and gamma_L, then calls jax.jit(hpe.__call__). These new unconditional lookups therefore raise KeyError('hpe_wall_flux') on its first call, before the test can exercise trapping or check damping reduction. Unlike the other HPE test callers updated for the expanded push results, this caller was not migrated to the expanded state contract.

Initialize that test from the complete load_particles(cfg) state (including hpe_wall_flux, hpe_cone_energy, and hpe_ld_multiplier) so the existing slow nonlinear-feedback regression remains runnable. This conclusion is from tracing the caller and callee; I did not execute the test.

[physicistphil]

Fixed in 86606c8: test_oneil_flattening now starts from the complete load_particles state (wall-flux, cone-energy and multiplier instruments included) with the driven wave. Its O'Neil assertion is unchanged and holds (~19 s).

Running the whole slow set (deselected by the default -m 'not slow', and so by CI) turned up two more:

• test_srs_smoke_with_hpe had failed since 1989b5e, also on ergodicio/main.
  • Its all-finite check rejected the t = 0 sample of hpe_gamma_ratio_kpeak, which is NaN by design while the EPW has no band energy; the check now exempts only that sample (86606c8).
  • Its ratio[-1] > 0.5 check was a coin flip at 20k particles with an unseeded EPW noise source: seeds 1–10 gave 0.0–2.39, with 4/10 passing. Per the repo's rule against picking seeds after seeing results, the criterion stayed > 0.5, and 1M particles plus noise seed 7919 were fixed before validation (df43c9b). On fresh seeds 7919 and 11–16 the final ratio was 0.59–1.33 on this branch and 0.74–1.26 on plan2, 7/7 and 6/6 passing.
• test_linear_closure failed on plan2/feat(lpse2d): spatially windowed electron distribution for HPE (stacked on #378) #387. It measured against the MATLAB landau_damping_rate instead of the configured analytic_landau_rate(cfg), which HPE calibrates to (4d193ad); tolerance unchanged.

The slow set now passes on #372 (3/3), plan2 (3/3) and #387 (5/5).

Recorded, not changed: test_linear_closure's margin is thin. Over HPE seeds 42/1/2/3 the measured/analytic ratio was 0.91/0.83/0.89/1.08 here and 0.87/0.80/0.81/0.96 on plan2. Seed 42 at 4M particles gave 0.866, the same as at 1M (0.868), so the shortfall is not particle shot noise.

[ergodic-reviewer]

Request changes for the remaining HPE test-state regression (P2). At this head, tests/test_lpse2d/test_hpe.py::test_oneil_flattening still builds y without hpe_wall_flux, hpe_cone_energy, or hpe_ld_multiplier, while HybridParticleEvolution.__call__ reads all three unconditionally. Its first jitted call therefore raises KeyError('hpe_wall_flux') before exercising nonlinear trapping/feedback. Initialize the test from the complete load_particles(cfg) state and override epw, as the new feedback regression does. The existing inline thread retains the finding; no duplicate comment added.

The HPE rate-limit fix is present: feedback now calls limit_resonant after energy-conservation rescaling, with a regression through __call__ and documented treatment of non-resonant modes.

Postprocessing is implemented and reachable through BaseLPSE2D.post_process and the existing ergoExo lifecycle: field/series datasets, plots, derived metrics, optional flux/Thomson/ledger/HPE diagnostics, and checkpoint persistence. Combined-field projection, carrier selection, and dissipation handling have implementation and regression coverage in source.

Validation: source review at 971f999d9bae2f349b8f29ce182f8e669398130c; oversized helper changes were inspected through constituent commit patches. I did not execute tests, benchmarks, or postprocessing, or inspect external LPSE reference plots/artifacts.

[ergodic-reviewer]

No remaining blocking findings identified at df43c9bbd23461db466207b9adf9e0dadd743ddc. The previously reported test_oneil_flattening state regression is fixed: it now carries the complete loaded HPE state, including the instrument entries. The related slow tests use the configured analytic Landau rate and a pinned noise seed with a larger particle population, without relaxing the damping-ratio criterion.

Postprocessing is implemented and reachable through BaseLPSE2D.post_process and the existing ergoExo artifact lifecycle: field/series datasets, plots, derived metrics, optional Poynting/Thomson/ledger/HPE diagnostics, and checkpoint persistence. Combined-field projection, carrier selection and dissipation handling have implementation and regression coverage in source.

Validation: source review of the diff, relevant implementations/call sites, tests and repository guidance. The latest GitHub check read reports test-lpse2d in progress. I did not execute tests, benchmarks or postprocessing, or inspect external LPSE reference plots/artifacts; the reported cross-check results are not independently verified.

[ergodic-reviewer]

Request changes for the P2 output failure detailed in the attached comment: an accepted interpolated save grid with one x point crashes Poynting postprocessing after the simulation, before series/checkpoint writing and result-artifact export. Validate that combination at setup or compute flux before resampling.

Postprocessing is implemented and reachable through BaseLPSE2D.post_process and the ergoExo artifact lifecycle: field/series datasets, plots, derived metrics, optional Poynting/Thomson/ledger/HPE diagnostics, and checkpoints. The merged field-save fixes preserve the combined-field projection and ledger exclusion; full-grid and interpolated field regressions are present in source. The finding is a specific output-compatibility failure, not an absent analysis path.

Validation: source review at a85fbd5a77d67675c3fe9f6c82f57046ac65521e, including the diff, relevant implementations/call sites, tests and repository guidance; oversized helper changes were inspected through constituent commit patches. The last GitHub check read reported test-lpse2d in progress. I did not execute tests, benchmarks or postprocessing, or inspect external LPSE reference plots/artifacts.

[ergodic-reviewer]

[P2] Validate singleton x save grids before computing Poynting maps

The new _interpolated_save_axis permits a single saved x point (n_save = max(1, ...)), for example when save.fields.x.dx is the box length. Combining that accepted save configuration with save.fields.poynting: true fails after the solve: make_field_xarrays unconditionally calls np.gradient(e, dxs, axis=1), which requires at least two samples along x. The dxs = 1.0 fallback does not make a singleton axis differentiable. Unlike the y derivative, the x derivative has no size guard.

This exception occurs before post_process writes the series and checkpoint, and before ergoExo uploads the result artifacts, so this output choice prevents a completed run from exporting its results. Please either reject singleton x save grids during setup when Poynting maps are enabled, or compute the flux on the simulation grid before sampling it onto the save grid. Add a regression for this combination; the existing Poynting tests exercise only the full-grid path.

[physicistphil]

Fixed in a62b52c. get_save_quantities now refuses save.fields.poynting: true together with an interpolated save of fewer than two x points, at setup rather than after the solve; two or more points are accepted. Computing the flux before resampling would also work, but the maps would then need their own save path.

Regression: test_diagnostics_lpse.py::test_poynting_refuses_a_single_point_x_save_grid. dx equal to the box length is refused; half the box (2 points) is accepted. Before the fix it did not raise. Docs: the save.fields.poynting text. Merged into plan2 (04b432a) and #387 (2239faa).

[ergodic-reviewer]

No remaining material findings identified at a62b52c93b4a40e7fe9a57346569f207d66e4a7d. The previously reported single-point Poynting-save failure is now rejected during setup in get_save_quantities, before the solve. The regression covers rejection of one saved x point and acceptance of two, and the restriction is documented.

Postprocessing is implemented and reachable through BaseLPSE2D.post_process and the existing ergoExo artifact lifecycle: field/series datasets, plots, derived metrics, optional Poynting/Thomson/ledger/HPE diagnostics, and checkpoint persistence. The interpolated-save path retains the combined-field Raman projection and excludes the series-only energy ledger; full-grid and interpolated field regressions are present in source.

Validation: source review of the diff, relevant implementations/call sites, tests and repository guidance; oversized helper changes were inspected through constituent commit patches. The latest GitHub check read reports test-lpse2d in progress. I did not execute tests, benchmarks or postprocessing, or inspect external LPSE reference plots/artifacts; the reported cross-check results are not independently verified.