Repository navigation
feat: vlasov1d broadband laser driver + 1D super-Gaussian width normalization (vlasov1d & pic1d) - #337
feat: vlasov1d broadband laser driver + 1D super-Gaussian width normalization (vlasov1d & pic1d)#337ManharGupta25 wants to merge 24 commits into
Conversation
…sov-broadband # Conflicts: # adept/_vlasov1d/simulation.py
ManharGupta25
changed the title
joglekara
left a comment
joglekara
left a comment
There was a problem hiding this comment.
Nice work — the core of this is sound and the physics checks out. I checked the branch out, ran the suites, and exercised the broadband path directly. Two things need fixing before merge: one is an unrelated regression, one invalidates the headline validation claim. Everything else is cleanup or docs.
Blocking
1. FokkerPlanckConfig.m was deleted — collateral from a merge
adept/_vlasov1d/datamodel.py drops m: float = Field(default=2.0, ge=1.0), which c2e79e4 (#313, the super-Gaussian FP operator) added. It isn't mentioned in the PR description and disappeared in one of the three Merge branch 'main' commits, so I'm reading it as accidental.
It's silent rather than fatal — fokker_planck.py:329 reads the raw cfg dict, not the validated model, so type: super_gaussian runs still pick up m. But the ge=1.0 bound is gone (an m: 0.5 deck now validates), and the schema no longer documents the option. Should be a pure restore.
2. num_colors: 1 puts the line at -delta_omega * w0, not at w0
jnp.linspace(-Δ, Δ, 1) returns [-Δ], not [0]. Measured on this branch:
N=1: dw0/w0 = [-0.0025]
N=2: dw0/w0 = [-0.0025, 0.0025]
N=3: dw0/w0 = [-0.0025, 0.0, 0.0025]
So the N=1 reduction test isn't testing what the description claims. The amplitude half is genuinely bit-identical — I reproduced a0 = 0.06783401532993676 on both paths with x64 on, as _base_.py enforces — but the single line is red-shifted 0.25%, so this isn't the monochromatic driver.
That matters because the N=1 equivalence is the main evidence that the driver units and F0 scaling are right. Either special-case N == 1 to dw = 0, or re-run the comparison at delta_omega: 0 and restate the claim.
Should fix before merge
3. No config documentation
CLAUDE.md requires docs/source/solvers/vlasov1d/config.md updates for new config options. num_colors, delta_omega, intensities.{init,seed,range,base_intensity} and phases.{init,seed,range,base_phase} are all undocumented — the only doc change here is the m row.
4. delta_omega is a half-width but reads like a bandwidth
linspace(-Δ, +Δ, N) means the full width is 2Δ, and plot_driver_spectra labels 2Δ as "full width Δω/ω0". Someone writing delta_omega: 0.0025 for a "0.25% bandwidth" run gets 0.5%. The kinetic-srs notes already carry a translation table for exactly this (0.25% -> 0.00125), which is a good sign it's a real trip hazard. Worth stating explicitly in the docs, or renaming to half_width / switching the config to full width.
5. intensities: dict and phases: dict are unvalidated
Everything else in datamodel.py is a typed pydantic model. Here init: random without a seed raises a bare KeyError: 'seed' from inside the constructor, and base_intensity is required but undeclared. Two small BaseModels would turn both into proper validation errors.
6. scale_intensities / get_partition_spec / __call__ are unreachable, and two of them raise
I gather these are intended for the optimization follow-up, so this is about wiring rather than deletion. As written they can't be called from a built simulation: BroadbandDriver is a local inside EMDriver.from_config, only broadband_driver.driver_list escapes, and EMDriverSet stores list[EMDriver]. Nothing retains the instance — I checked kinetic-srs too (including mg/vlasov-broadband-and-sup-gauss); no Python there references these, and the campaign decks set only init/seed/base_intensity.
All three also fail if you do reach them. Calling them directly on a BroadbandDriver:
__call__->TypeError: unsupported operand type(s) for |: 'dict' and 'SpaceTimeEnvelopeFunction'(self.envelopeis a module, not a dict)get_partition_spec->KeyError: 'learned'scale_intensities->KeyError: 'activation'
__call__ also re-applies jnp.tanh(phases) * jnp.pi to phases already drawn on (0, 2π), which contradicts what's baked into driver_list.
So whichever way you want to go: either keep a reference to the BroadbandDriver on EMDriverSet and fix the three methods now, or leave the methods with an explicit raise NotImplementedError until the backward-pass PR wires them. Right now they read as working API that silently isn't.
7. self.intensities holds amplitudes, not intensities
It's a0 * sqrt(w_j / Σw), and __call__ publishes it under the key "intensities". Worth renaming to amplitudes (keeping the raw weights separate if the optimizer wants them) before the optimization PR builds on the name.
8. No test and no example config
tests/test_vlasov1d/ gets only the EMDriver signature fix. Three cheap ones that would have caught #2:
- uniform N-line comb ->
Σ a_j² == a_mono²(this is exact today, I verified) - seeded reproducibility across two builds (also holds today)
- N=1 comb sits at
dw0 == 0
An example deck under configs/vlasov-1d/ would help too, since the kinetic-srs configs are gitignored and the YAML shape currently exists only in that repo's NOTES.md.
Minor
# %%cell markers left atdatamodel.py:124and:163gamma_5_over_min_vlasov1d/helpers.pyis now unused (pic1d switched imports; vfp1d has its own)match cfg.paramshas nocase _:— a future params type would silently returnNonerather than raiseplot_driver_spectrahardcodes driver key"0"when readingbase_intensity; a driver keyed'1'just loses the absolute axis scale (guarded, so cosmetic)
Physics — this part holds up
The alpha change is correct and I'd take it on its own. With α = sqrt(Γ(1/m)/Γ(3/m)) the variance is v_th² · (Γ(1/m)/Γ(3/m)) · (Γ(3/m)/Γ(1/m)) = T0/mass for every m. And SuperGaussianDougherty's D = β^(-2/m) Γ(3/m)/Γ(1/m) equals exactly that variance — so the initializer is now the operator's fixed point at the labeled temperature, which it wasn't before. vfp1d correctly keeps its own 3D-isotropic sqrt(3Γ(3/m)/(2Γ(5/m))), so configs/vfp-1d/epp-short.yaml (m: 3.4) is untouched. Config-regression and super-Gaussian FP suites pass, and the docs row is updated.
Three notes on it:
-
It silently changes results for every
m != 2vlasov1d/pic1d run. No in-tree vlasov1d config usesm != 2, so nothing breaks here — but saved runs and in-flight m-scans are now on a different convention with no version marker. Same class of silent drift as #311. Worth a line in the PR description and wherever the m-scan results are recorded. -
All comb lines share
k0. The source is-factor * ω_j² * a_j * sin(k0*x - ω_j*t + φ_j), so an off-center line isn't launched on its own dispersion branch. That's fine as used — the campaign decks drive through awidth: 1.0umpoint source, where the phase error across the antenna is negligible. It stops being fine for a source extended across the box, whereδk*L ~ 10 radat 0.25% over 200 µm. Worth a docstring sentence noting the comb assumes a localized antenna. -
"Same power" is time-averaged, not peak.
Σ a_j² = a0²exactly (verified), but a phase-locked comb reachesa0*√Nat recurrence — consistent with the 0.408 ps recurrence you measured, and correct physics for a coherent sum. Just worth confirming the threshold campaign's "same intensity" control means the same thing on both sides of the comparison.
Blocking items are only #1 and #2, both small. Happy to look again as soon as those land.
|
Broadband driver injestion was changed from breaking it into separate EMDrivers in simulation.py to having the injestion being directly vectorized and array-based within field.py such that when complete optimization loop with loss calculation and training wrappers is added, gradient will be traceable back to the amplitudes and phases in transverse wave sources (or any other parameter of those sources which will require some specific plumbing for the given parameter). More importantly, the BroadbandDriver object now persists throughout the simulation as it is directly made part of EMDriverSet, and its the entire EMDriverSet that is stored in 'args'. Along with that, other concerns mentioned in the above PR comment were addressed as well, apart from Claude's detailed comment: Points addressed —
|
![ergodic-ludwig[bot]](https://avatars.githubusercontent.com/u/74554135?s=60&v=4){kind=small}
There was a problem hiding this comment.
The previous blockers on FokkerPlanckConfig.m and the N=1 frequency offset are fixed, and the added documentation/tests cover the main broadband behavior well. I reviewed the complete current diff at eb9447a80806eed8479191c33b41947ea356598d, ran the focused broadband/config suite locally (26 passed), and checked the current GitHub runs (vlasov1d, pic1d, pre-commit, and install all pass).
Two remaining validated-input paths produce runtime-invalid simulations, so I am requesting changes; see the inline comments:
intensities.rangecan generate invalid weights and silently introduce NaNs into amplitudes.- The schema accepts a broadband driver under
drivers.ex, but the longitudinal evaluator crashes on that object.
Both should be rejected during config validation (unless broadband Ex is intentionally implemented).
There was a problem hiding this comment.
Reviewed the complete diff at 95a55159af281094bad498c1617b94d34cc20bfe. Two high-confidence blockers previously identified are still present in this head:
BroadbandIntensitiesConfig.rangeaccepts negative and all-zero ranges.BroadbandDriverthen evaluatessqrt(weight / sum(weights)), so validated decks can construct NaN amplitudes and silently contaminate a solve. Reject invalid bounds/realized weights and cover mixed-sign and all-zero cases.- The shared schema still accepts
BroadbandConfigunderdrivers.ex, andEMDriverSet.from_configstores thatBroadbandDriverinex; the longitudinal evaluator expects scalarEMDriverattributes such asdw0, so this validated configuration fails at runtime. Reject broadband Ex during validation or implement longitudinal broadband evaluation.
The latest merge does not address either path, so both should be fixed before merge.
There was a problem hiding this comment.
The broadband implementation has one blocking normalization defect: preserving sum(a_j²) does not preserve the configured physical laser intensity when line frequencies differ, because physical field intensity scales with (w_j a_j)². Details and a concrete regression criterion are inline.
There was a problem hiding this comment.
One blocking test-suite regression remains at d18d244d166ef13f01724aed0149a776e6a4f89f: the updated absorbing-wave test references eqx without importing it, causing collection to fail. The previously reported broadband validation and physical-power issues are addressed in this head.
There was a problem hiding this comment.
Re-review of ba9dea961a06cee2119137fea430abd81b0fdb37
Verdict: changes requested for two remaining P2 input-contract issues. The earlier blockers are fixed; these are separate cases found during this pass, not a reopening of the resolved findings.
Fix before merge
- Zero-bandwidth multi-line comb: the schema accepts N > 1 with
delta_omega: 0. Coincident-frequency lines sum coherently, so diagonal line-power normalization does not preserve total intensity. The four-line, equal-phase case gives 2x the source amplitude / 4x its squared amplitude at the samebase_intensity. Reject that combination or handle the coherent normalization explicitly. - Scalar Ex phase is ignored:
phaseis now an accepted and stored driver parameter, but the longitudinal evaluator never uses it. A validated phase change from 0 to pi/2 produces identical Ex. Implement the phase or reject nonzero Ex phase.
Both have independently executed failing reviewer-authored regressions on this exact head; details and fixes are inline. Neither finding invalidates the normal finite-bandwidth Ey campaign configuration.
Verified good
- Previous fixes:
FokkerPlanckConfig.m, N=1 centered frequency, invalid intensity ranges, broadband-Ex rejection, frequency-weighted physical line powers, and absorbing-wave test collection/execution. - 65 repository tests passed locally, using the frozen
uv.lock, CPU JAX and x64: broadband, absorbing wave, super-Gaussian FP, PIC1D, config validation, units, multispecies/quasineutral initialization, and architecture solver-builder tests. One slow case was deselected by the repository's default marker.git diff --checkis clean. - Independent per-line source sums agree with both point and extended evaluators; phase gradients agree with finite differences.
- Direct production-initializer moment checks at m = 2, 2.5, 3, 4, 5 confirm the Vlasov variance is T0/mass on a sufficiently wide/resolved grid. Both PIC loading paths agree within deterministic quadrature / sampling error. The super-Gaussian width correction is sound. These checks exercise the changed initializers, rather than relying only on the FP suite's separately constructed reference distributions.
- A reduced four-color deck completed the production BaseVlasov1D initialization-and-solve lifecycle: 101 steps, all 24 saved arrays finite, including the partial-args route.
- Current GitHub Vlasov1D and PIC1D checks are successful. I did not rerun the full production SRS campaign or validate its recorded fluence metrics.
Nonblocking cleanup
- The spectrum diagnostic pools multiple drivers but scales them to only the first driver's intensity; it also counts driver objects rather than spectral lines. Reproduced separately; details inline.
- Refresh the PR description's old amplitude formula/object-expansion wording. In the new docs/docstrings, use different symbols for intensity weights and line frequencies instead of
w_jfor both. Backward-pass/optimization support remains explicitly outside this review's acceptance scope.
| """ | ||
|
|
||
| num_colors: int = Field(ge=1) | ||
| delta_omega: float = Field(ge=0.0, lt=1.0) # half-width, fraction of w0; < 1 keeps every line frequency positive |
There was a problem hiding this comment.
P2 — Reject zero-width multi-line combs, or normalize their coherent sum. delta_omega: 0 is accepted with num_colors > 1, so all lines have exactly the same frequency. The new frequency-weighted normalization correctly fixes distinct-line powers, but sum_j (omega_j a_j)^2 is not the total power when frequencies coincide: cross terms never average away. On this head I built num_colors: 4, delta_omega: 0, uniform intensity weights, and phases: {init: uniform, base_phase: 0}. At identical base_intensity, the evaluated point source is exactly 2 times the monochromatic source, with squared amplitude 4 times the control; this persists in time, rather than being a finite-bandwidth recurrence peak. Thus a zero-bandwidth control silently changes pump strength. The smallest fix is a model-level check rejecting num_colors > 1 and delta_omega == 0 and directing users to num_colors: 1. Alternatively combine/normalize equal-frequency complex amplitudes, with an explicit policy for cancellation. Add a regression using the evaluated coherent source, not only the diagonal per-line power sum.
| k0: float | None = None | ||
| w0: float | None = None | ||
| dw0: float | ||
| phase: float = 0.0 |
There was a problem hiding this comment.
P2 — Honor the newly accepted scalar phase for Ex, or reject it there. AKWDriverConfig now explicitly accepts phase, the same schema is used under drivers.ex, and EMDriver.from_config retains it. However LongitudinalElectricFieldDriver._single_driver_field (solvers/pushers/field.py:22–27) still evaluates sin(k0*x - (w0 + dw0)*t) without driver.phase. I reproduced this through EMDriverSetConfig and EMDriverSet.from_config: changing a valid Ex deck from phase: 0 to phase: pi/2 produces exactly identical fields, rather than the requested phase shift. This can silently invalidate relative-phase forcing experiments. Please include + driver.phase in the longitudinal evaluator, or reject nonzero Ex phase if the new option is deliberately Ey-only; add a test against the analytic phase-shifted source. The same issue affects the new phase field in IntensityWavelengthDriverConfig.
| ints = ((dcfg or {}).get("params", {}) or {}).get("intensities") | ||
| if isinstance(ints, dict) and ints.get("base_intensity") is not None: | ||
| base = ints["base_intensity"] | ||
| break |
There was a problem hiding this comment.
Nonblocking diagnostic follow-up — don't pool multiple drivers under the first intensity. All lines from the field are concatenated and normalized together, but their absolute scale is taken from only the first broadband entry. I exercised two four-line combs at the same carrier with disjoint frequency sets (delta_omega 0.0025 and 0.00125), each at 2.378e14 W/cm^2: matplotlib received eight intensities summing to 2.378e14, rather than 4.756e14 W/cm^2. The title also says 2 lines because it uses len(dlist) instead of the flattened line count. Plot each configured driver separately or retain per-driver normalization while combining; if carriers differ, retain actual omega_j too, since (1 + dw/w0)^2 * a^2 drops different factors of w0^2. This does not affect the single-comb forward solve.
|
Re-review complete at
|
There was a problem hiding this comment.
Reviewed the complete diff at f43e172ca5128e065f11b1b9d02c8f4fb589d62f. Changes are still required:
- P2 — New import-boundary regression: importing the explicit Vlasov1D builder now loads plotting and patches MLflow process-wide. See the new inline comment.
- P2 — Zero-width multi-line combs remain accepted:
BroadbandConfigallowsnum_colors > 1withdelta_omega == 0, whileBroadbandDrivernormalizes separate line powers and the pusher sums coincident lines coherently. A zero-bandwidth control therefore need not preservebase_intensity. Reject this combination or normalize the coherent sum (existing finding). - P2 — Scalar Ex phase remains ignored: the schema and
EMDriver.from_configretainphase, butLongitudinalElectricFieldDriver._single_driver_fieldnever uses it, silently invalidating relative-phase forcing. Implement it or reject nonzero Ex phase (existing finding).
Postprocessing: the single-comb workflow has a reachable line-spectrum plot and existing field/moment/distribution plots, mean_e2, netCDF output, and MLflow artifact export. The explicit analyzer provides datasets without plotting. Existing diagnostics also cover the changed Vlasov/PIC distribution widths. The previously noted multi-driver spectrum scaling issue remains nonblocking.
Static code/test inspection only; I did not execute tests, postprocessing, or campaign validation.
| from adept.normalization import UREG, PlasmaNormalization, normalize | ||
|
|
||
| from .. import patched_mlflow as mlflow | ||
|
|
There was a problem hiding this comment.
P2 — Keep tracking and plotting imports out of shared preparation. adept._vlasov1d.builder imports preparation, which imports this module for _initialize_total_distribution_. The new module-level patched_mlflow import therefore loads MLflow and immediately rewrites its REST endpoint mappings (adept/patched_mlflow.py), even when a caller only resolves/prepares the logging-free solver and never requests tracking. The new module-level matplotlib.pyplot import likewise loads plotting on that path. This breaks the established boundary checked by tests/test_vlasov1d/test_builder.py::test_builder_import_does_not_load_tracking_or_plotting_facades, and can change an embedding application's MLflow behavior without opting in. Remove the unused global MLflow import (the existing local import in post_process is sufficient) and import pyplot locally inside plot_driver_spectra, as post_process already does. This is a code-path finding; I have not run the test.
There was a problem hiding this comment.
Reviewed the complete diff at 193b7ac645bc5d60cf18795bb1e63a696457d245. The tracking/plotting import-boundary finding is addressed: pyplot and patched MLflow are now imported only inside diagnostic functions.
Two existing P2 blockers remain; linking their inline discussions rather than duplicating them:
- Zero-width multi-line combs:
BroadbandConfigstill acceptsnum_colors > 1withdelta_omega == 0.BroadbandDrivernormalizes separate line powers, butTransverseCurrentSourceDriversums these coincident-frequency sources coherently. Their interference does not average away, so a zero-bandwidth control can silently change pump intensity despite unchangedbase_intensity. Reject this combination and direct users to one line, or normalize the coherent sum (inline finding). - Ignored scalar Ex phase: both scalar parameter schemas accept
phase, andEMDriver.from_configstores it, butLongitudinalElectricFieldDriver._single_driver_fieldstill omits it from the sinusoid. Relative-phase forcing therefore runs with the wrong field without reporting an error. Apply the phase in the longitudinal evaluator or reject nonzero Ex phase (inline finding).
Postprocessing: the single-comb workflow has a reachable spectrum plot, field/wave-decomposition and distribution/moment diagnostics, mean_e2, netCDF persistence, and MLflow artifact export. Existing moment/distribution diagnostics also cover the Vlasov/PIC width change. The explicit analyzer provides datasets without plotting. The previously reported multi-driver spectrum scaling issue remains nonblocking.
Static code and test inspection only; I did not execute tests, postprocessing, or the reported campaign validation.
There was a problem hiding this comment.
Reviewed the complete diff and relevant call sites/tests at cd588718275481564b61ce91ae7e0974dd090cc2. Two existing P2 blockers remain; linking their inline discussions rather than duplicating them:
- Zero-width multi-line combs:
BroadbandConfigstill acceptsnum_colors > 1withdelta_omega == 0.BroadbandDrivernormalizes separate line powers, whileTransverseCurrentSourceDriversums the coincident-frequency sources coherently. Their interference does not average away, so a zero-bandwidth control can silently change pump intensity despite unchangedbase_intensity. Reject this combination and direct users to one line, or normalize the coherent sum; cover the evaluated source in a regression (existing inline finding). - Ignored scalar Ex phase:
AKWDriverConfigandIntensityWavelengthDriverConfigacceptphase, andEMDriver.from_configstores it, butLongitudinalElectricFieldDriver._single_driver_fieldomits it from the sinusoid. Relative-phase forcing therefore runs with the wrong field without reporting an error. Apply the phase in the longitudinal evaluator or reject nonzero Ex phase, with an analytic-source regression (existing inline finding).
Postprocessing: the configured single-comb workflow has a reachable spectrum plot, field/wave-decomposition and distribution/moment diagnostics, mean_e2, netCDF persistence, and MLflow artifact export. Existing moment/distribution diagnostics also cover the Vlasov/PIC width change. The explicit program can run without plotting/artifact writes and exposes a callable dataset analyzer. The previously reported multi-driver spectrum scaling issue remains nonblocking.
Static code and test inspection only; I did not execute tests, postprocessing, or the reported campaign validation.
Introducing the broadband changes and the alpha_1D fix for super-gaussian experiments in 1d solvers, mainly vlasov1d. broadband-driver lines plot for amplitude, log(amplitude) and phase are here as well. The additions for mean_e2 metrics and params will be in the existing kinetic-srs PR (https://github.com/ergodicio/kinetic-srs/pull/14)
Claude's detailed comment:
What this PR does
1. Broadband laser driver for vlasov1d (forward pass)
BroadbandConfig/BroadbandDriver: the pump is a comb ofnum_colorsdiscrete lines atdw_j = linspace(-delta_omega, +delta_omega, N) * w0, each anEMDriverwith its own frequency offset and phase.A_j = a0 * sqrt(I_j / sum_k I_k), so total power equalsbase_intensityregardless of N — and an N=1 broadband driver reduces exactly to the monochromatic driver.intensities/phasesblocks supportinit: uniform | randomwith a seeded RNG and an optionalrange(defaults:(0, 2)for intensity weights,(0, 2*pi)for phases, the Follett 2019 convention).EMDrivergainsphase/dw0;IntensityWavelengthDriverConfigandAKWDriverConfiggaindw0/phasewith0.0defaults, so existing monochromatic configs are unchanged.casepatterns (pydantic v2 defines no__match_args__),num_colorsasint, driver params passed as amodel_dump()dict so the driver stays grad-safe for a later backward pass.2. 1D super-Gaussian width normalization
alpha = sqrt(Gamma(1/m) / Gamma(3/m))in_initialize_supergaussian_distribution_: the realized variance equalsT0/massfor every m, so a species labeled T0 is at temperature T0 for any order (temperature inflation F(m), the init-vs-operator convention split, and the Debye-length consequences).sqrt(2)): all Maxwellian configs, fixtures and tests unaffected.T0/mass) andSuperGaussianDougherty's temperature relation.x0 = lambda_Dat all m, sok*lambda_Dread from code coordinates is exact across an m-scan._pic1dparticle loader (both the inverse-CDF and rejection-sampling sites) gets the same one-line fix — no-op at m=2, so Maxwellian PIC runs are unchanged.docs config.mdm-row updated; verified<v^2>/T0 = 1.000000for m in {2, 2.5, 3, 4, 5} in both the vlasov1d initializer and the pic1d pdf form.3. Driver line-spectrum diagnostic in post_process
plots/drivers/{ex,ey}-lines.png: per-line intensity (linear + log10) and phase vsdw_j/w0, read from the liveEMDriverobjects rather than re-derived from config — so optimized line sets from a future backward pass plot with no extra wiring. Skips single-line drivers; wrapped in a guard so a plotting failure can never cost a completed solve its output.4. Misc
solvers/pushers/field.py.Validation
probe_pump_fluence_at_left = 75.85687287627245on both paths) — driver units, F0 scale and envelope handling confirmed clean.sum_j I_j = base_intensityby construction; CPU seed test: per-seed fluence within 0.88% of the monochromatic control, 3-seed mean within 0.21%.x0(4 keV) = 4.942252 nm,x0(3 keV) = 4.280116 nm,v0 = sqrt(T0/m_e)— fix: Vlasov1d vth conventions #311 conventions intact; monochromatic configs load withdw0 = 0.0,phase = 0.0. The alpha change composes cleanly with the fix: Vlasov1d vth conventions #311 scheme: fix: Vlasov1d vth conventions #311 removed the globalsqrt(2)from the unit definition, this removes the m-dependent F(m) from the initializer — togetherT_phys = T_labelfor all m.<v^2>/T0 = 1.000000for m in {2, 2.5, 3, 4, 5} with correct T0 scaling;test_super_gaussian_fp.pyalready builds its references with the 1D convention, so the operator tests double as corroboration.Not in this PR
BroadbandDriver(planned follow-up; the params-as-dict plumbing anticipates it).