[physicistphil]

Summary

HPE's Landau-damping feedback read one box-averaged electron distribution, as LPSE's ElectronTracker does. This adds an optional spatially windowed distribution, terms.hpe.n_windows (adept-only; the default 1 is the existing code path, bit-identical).

Stacked on #378 (lpse2d/lpse-parity-plan2 @ 3b582f6): review only the last commit, e6def50 (git log lpse2d/lpse-parity-plan2..feat/lpse2d-hpe-spatial-fv).

• Windows: n_windows equal-width x windows with cos² tapers forming a partition of unity (each x in at most two windows; wrapped on periodic boxes, flat to the walls on bounded ones).
• Distributions: every particle deposits into its two windows with its weights; each window keeps its own EMA histogram (binned exactly as jnp.histogram) and its own rate gamma_j(k) = C(k) Op[f_j](k) with the shared per-k calibration.
• Damping: the EPW step applies the rates on psi = |k| phi as psi <- sum_j sqrt(w_j) IFFT[exp(-gamma_j dt) FFT(sqrt(w_j) psi)] (SpectralEPWSolver.windowed_landau_damping). It never raises the EPW energy for gamma_j >= 0 and is the per-mode multiply for one shared k-independent rate.
• State / diagnostics: gamma_L_windows (applied), gamma_L = volume-weighted mean; series hpe_hist_windows (hpe_hist = volume-weighted mean), windowed epw_dissipation, plots/hpe_distribution_windows.png.
• terms.hpe.hist_smooth: binomial [1,2,1]/4 passes along v before the slope is read, with the calibration through the same filter (ported from the lpse2d/srs 2-D HPE work) — reduces the per-window shot noise without bias.
• Refused with terms.epw.solver: combined and with energy_conservation (not implemented).

Tests

Criteria and tolerances fixed before the tests were run (research-vault note 2026-10-08-182046-claude-lpse2d-hpe-spatial-fv-b47179bd, including the recorded corrections):

• default parity: a 20-step SRS + HPE run (quasi-1D and 2-D) is bit-identical to 3b582f6 in all 23 state arrays;
• tests/test_lpse2d/test_hpe_windows.py (19): partition of unity, per-window histograms summing to the global one, uniform-rate exactness, local-multiplier exactness for k-independent rates, energy contraction, a plateau on half the particles reaching the window rates in proportion to the windows' weight shares, calibration under smoothing, validation, and a 0.2 ps SRS smoke run with 4 windows (slow);
• full tests/test_lpse2d on macOS: 473 passed, 2 skipped; the 4 failures are the known laptop-only ones (test_lpse_deck time steps for test_019/test_030 need run inputs that are not in git; test_three_component_fields combined bit-identity, failing at 044784f on this machine too).

Status

Draft. Measured on the blackbox (research-vault study hpe-windows-validation):

• Cost (RTX 3090, float64, quasi-1D scan2 boxes): 4e6 particles cost 80.2 / 88.3 ms per EPW step with n_windows 1 / 9 at Ln200 and 81.6 / 89.1 at Ln1000 (about 32-35 min per 23.29 ps); the 9 windows add ~10 %. float32: 48.7 ms/step.
• Validation (7 scan2 points, newest LPSE defaults, flat noise recalibrated to the OSIRIS floors): the default path is unchanged; with n_windows: 9 R stays within 0.014 of the box-averaged HPE at 5 points and is lower at Ln400um-Te10keV-x2 (0.031 vs 0.293, reproduced across three particle seeds). With every window held at the analytic rate (feedback: false) the windowed operator reproduces the fluid result there (0.269 vs 0.271), so the difference comes from the per-window rates; why is not established yet.

🤖 Generated with Claude Code

[ergodic-reviewer]

Requesting changes for two [P2] correctness issues:

• The separate solver consumes the previous step's prescribed pump after the step-order change (inline comment).
• Windowed dissipation omits the energy lost when damped window fields are recombined, leaving the derived energy budget incomplete (inline comment).

Postprocessing: windowed HPE distributions have NetCDF persistence in binary/series.xr, optional separate histogram cadence, and distribution plots. BaseLPSE2D.post_process() is callable independently of the numerical solve. The energy-accounting defect above still needs correction.

The previously reported FD combined negative-rate branch is corrected in this head. Static review only: no tests, benchmarks, or postprocessing were executed, and no generated artifacts were opened. Oversized tool responses prevented exhaustive inspection of some large files; findings are grounded in retrieved source, per-commit patches, and tests.

[ergodic-reviewer]

[P2] Refresh the prescribed pump before the IAW/EPW updates

Moving light_split_step() after self.epw.advance() also moves the only evaluation of the prescribed pump after its consumers. With pump_depletion: false and drivers.E0 present, light_split_step() stores E0_fn(t) in y["E0"]; consequently the next call's EPW update reads the previous step's pump, not the pump at its current t. BaseLPSE2D.init_state_and_args() initializes E0 to zero, so the first step also omits the prescribed pump entirely. SpectralEPWSolver.advance() reads that array directly for both TPD and SRS, while the Raman update evaluates its callable at the current substep times.

This delays pulse envelopes/KAP phase changes and makes the two sides of the SRS coupling use different pump times; an active IAW likewise receives the stale prescribed-pump drive. Refresh the prescribed field at the current time before the IAW/EPW consumers, without advancing the evolved light early. Add a regression with an actual time-dependent drivers.E0 and nonzero initial EPW/Raman field: the current step-order test uses args = {"drivers": {}}, so it does not exercise this branch.

[physicistphil]

Fixed on plan2 in 5119513, where 914a0d7 introduced the step order; merged here in 2239faa. With pump_depletion: false and drivers.E0, SplitStep.__call__ now writes the prescribed pump at the step's start t into the state first (SplitStep.prescribed_pump), before the IAW and the EPW, or the combined field, read it. The evolved light is not advanced early.

For the record, this departs from LPSE, which has the lag you describe:

• ZakharovSolver::evolve runs IAW, then LW, then laser->computeFields(theCurrentTime, …), and LightSolver::computeStaticE0_* evaluates the pump at that start time (exp(I (phase - dOmega time)), applyPulseShapeStatic(time)). Its LW therefore reads the previous step's pump.
• LPSE never evaluates the static field at setup, so the first step has no pump.

This is now listed in the overview's "Departures from LPSE" table (30493b4).

Regression: test_step_order.py::test_prescribed_pump_is_refreshed_before_the_iaw_and_epw[separate, combined]. One step inside the pump's rise, with an IAW and a nonzero EPW / E1, starts from states whose E0 is zero, the pump at t − dt, or the pump at t; the outputs are identical (exact). Before the fix, the separate EPW differed in every mode, and on the combined path the IAW drive differed.

[ergodic-reviewer]

[P2] Account for recombination loss in the windowed energy budget

The windowed get_default_save_func() branch sums each chunk's independent damping loss, but SpectralEPWSolver.windowed_landau_damping() subsequently multiplies the damped chunks by sqrt(w_j) and sums the fields before measuring their energy. The per-window sum does not include the additional loss from that recombination. This already occurs for non-negative, k-independent rates that differ between overlapping windows: the solver averages amplitude attenuation factors, whereas this diagnostic averages their squared attenuation factors. Thus the reported loss is not the energy removed by the implemented damping step, even on a uniform periodic box with no other physics.

diagnostics.series_metrics() integrates this value into electron_energy_final and the EPW absorbed-fraction metrics, leaving part of the windowed solver's energy removal unaccounted for. Derive the budget from the actual before/after damping operator, or expose the recombination loss as a separate numerical-loss channel rather than silently omitting it. advance() already measures the actual damping change for its energy ledger. Please compare the diagnostic/budget against that change for unequal overlapping-window rates; test_windowed_dissipation_is_signed_with_allow_growth currently checks the independent-chunk formula, not the energy change of the reconstructed field.

[physicistphil]

Fixed in f0a35b2. The windowed branch now applies the solver's own operator to the current state and takes the energy density before minus after, (|psi|^2 − |psi'|^2) / dt. The operator recombines the damped windows as fields, drops the recombined k = 0 part as windowed_landau_damping does, and applies the collisions to the whole field. The box integral is therefore the energy the damping step removes, and it is signed with growth rates. This replaces 359f9cd's L⁺/L⁻ split for the windowed branch.

Regression: test_hpe_windows.py::test_windowed_dissipation_is_the_energy_the_damping_step_removes, which replaces the old test of the per-window formula. The series equals the energy change of SpectralEPWSolver.windowed_landau_damping, then the collisions, at rtol 1e-12 in two cases:

• unequal k-independent positive rates (5 / 40 / 120 /ps in 3 overlapping windows), where the old per-window sum is 4.2 % below the energy removed, as you describe;
• mixed-sign rates.

Non-negative rates stay bitwise identical with and without allow_growth. Docs: the n_windows row.

One assertion was corrected after the first run. The inequality "the energy removed exceeds the per-window sum" first compared the series values directly. The total-to-electric factor is negative on this box, so those values carry the opposite sign; the check now compares the energy removed (both divided by the same prefactor). The rtol 1e-12 equalities were fixed in advance and are unchanged.

[ergodic-reviewer]

Requesting changes at e7977c32f6ca067692a129bd55cd9c46287946aa. These two [P2] defects remain; linking the existing inline threads rather than duplicating them:

• Prescribed pump is refreshed after its consumers (thread). On the separate, undepleted-pump path, SplitStep.__call__() advances the IAW/EPW before light_split_step() writes E0_fn(t). The EPW therefore uses the previous step's pump (initially zero), while Raman evolution evaluates the current prescription. Refresh the prescribed pump before those consumers, without advancing evolved light early. test_step_order.py uses empty driver arguments and does not cover this case.
• Windowed energy accounting omits recombination loss (thread). get_default_save_func() sums independently damped chunk losses, whereas windowed_landau_damping() recombines the attenuated fields before their energy is measured. Unequal rates in overlapping windows consequently remove additional energy that is absent from epw_dissipation and the derived absorption/electron-energy budget. Account for the actual operator's loss, or expose the extra numerical loss separately. The current signed-dissipation test checks the chunk formula, not the reconstructed field's energy change.

Postprocessing: windowed histograms have NetCDF persistence in binary/series.xr, optional separate histogram cadence, and distribution plots. BaseLPSE2D.post_process() is callable separately from the numerical solve; normal ergoExo execution logs the artifacts. The windowed energy-budget defect above still needs correction.

Static review only: no tests, benchmarks, or postprocessing were executed, and no generated artifacts were opened. Oversized tool responses prevented exhaustive full-diff inspection; these findings are supported by retrieved source, relevant per-commit patches, and test code.

[ergodic-reviewer]

Requesting changes at cddb6dc26ead67967d4e1391538c0cdf08b51529. Two previously reported [P2] correctness defects remain; linking the existing inline threads rather than duplicating them:

• Refresh the prescribed pump before its consumers (thread). On the separate, undepleted-pump path, SplitStep.__call__() still advances the IAW/EPW before light_split_step() writes E0_fn(t). The EPW consumes the previous step's pump (initially zero), while Raman evolution evaluates the current prescription. This delays time-dependent forcing and makes the coupled updates use inconsistent pump times. Refresh the prescription before those consumers without advancing evolved light early. The step-order test still uses empty driver arguments, so it does not exercise this case.
• Account for window recombination loss (thread). get_default_save_func() sums independent chunk losses, but SpectralEPWSolver.windowed_landau_damping() recombines attenuated fields before measuring their energy. Unequal rates in overlapping windows remove additional energy absent from epw_dissipation and the derived electron-energy/absorption budget. Measure the actual operator's loss or expose the additional numerical loss separately; compare against the reconstructed field's energy change, not only the independent-chunk formula used by the current signed-dissipation test.

Postprocessing: windowed histograms have NetCDF persistence in binary/series.xr, optional separate histogram cadence/coordinates, and distribution plots. BaseLPSE2D.post_process() remains callable separately from the numerical solve. The energy-accounting defect above still needs correction.

Static review only: no tests, benchmarks, or postprocessing were executed, and no generated artifacts were opened. Oversized tool responses prevented exhaustive full-diff inspection; the findings above are supported by retrieved source, relevant per-commit patches, and tests.

[ergodic-reviewer]

Requesting changes at 8ed34919fc192e0c8a1abc7b7519bcd7f267f0da. Two [P2] correctness defects remain; reusing the existing inline threads rather than duplicating comments:

• Refresh the prescribed pump before its consumers (thread). On the separate, undepleted-pump path, SplitStep.__call__() advances the IAW/EPW before light_split_step() writes E0_fn(t). The EPW consumes the previous step's pump (initially zero), while Raman evolution evaluates the current prescription. Time-dependent forcing is therefore delayed and the coupled updates use inconsistent pump times. Refresh the prescription before those consumers without advancing evolved light early. test_step_order.py uses empty driver arguments and does not cover this case.
• Reconcile default windowed dissipation with recombination loss (thread). get_default_save_func() sums independent window-chunk losses, whereas windowed_landau_damping() recombines the attenuated fields. Unequal overlapping-window rates introduce additional energy loss not represented by that sum. diagnostics.series_metrics() still derives electron-energy/absorption metrics from epw_dissipation, so those results do not account for the full applied loss. The optional operator energy ledger records actual damping deltas, but does not reconcile these default metrics. Incorporate the actual loss or expose the recombination contribution separately in the budget, with a comparison against the reconstructed field's energy change rather than only the chunk formula.

Postprocessing: windowed histogram series and distribution plots are implemented, with optional separate histogram cadence. BaseLPSE2D.post_process() remains callable outside the numerical solve; the parity harness also persists returned datasets for subsequent analysis. The default energy-accounting limitation above remains.

Static review only: no tests, benchmarks, or postprocessing were executed, and no generated artifacts were opened. Oversized tool responses prevented exhaustive inspection of some large diffs/files; these findings are grounded in retrieved source, relevant per-commit patches, and tests.

[ergodic-reviewer]

The prescribed-pump timing issue is corrected, and windowed dissipation now includes recombination and collision losses, with focused regression tests. No new high-confidence blocking defect identified in the inspected code. Non-blocking feedback: extend the windowed energy-accounting regression to a density ramp.

Postprocessing: windowed HPE distributions have saved histogram series, optional separate histogram cadence, and distribution plots. BaseLPSE2D.post_process() remains callable separately from the numerical solve; the parity harness persists returned datasets for subsequent analysis.

Static review only: no tests, benchmarks, or postprocessing were executed, and no generated artifacts were opened. Oversized tool responses prevented exhaustive inspection of some large files, notably helpers.py and lpse_deck.py; this is not a full-diff sign-off.

[ergodic-reviewer]

Non-blocking: cover spatial weighting in the windowed-loss regression. test_windowed_dissipation_is_the_energy_the_damping_step_removes() explicitly asserts np.ptp(factor) == 0.0, so its before/after comparison only covers a uniform density. Windowed HPE also supports density ramps, where energy_total_factor varies with position. A ramp case comparing epw_dissipation against before/after energy using the same spatial weighting as the saved energy diagnostics would exercise that part of the scientific output, in addition to recombination. This is a validation gap, not a demonstrated failing run.