tests: add direct coverage for biot_savart_3d, sim3d, moments, fieldline_classify

- test_biot_savart_3d.py: 16 tests for Coil3D/Grid3D/BField3D + compute_bfield_3d
  (linearity, zero-current, shape, mirror_ratio, on_axis)
- test_sim3d.py: 9 tests for Sim3DConfig, Sim3DResult, _make_grid_params, run_3d_simulation
- test_moments.py: 8 tests for MomentData dataclass + numpy bin-index logic + error path
- test_fieldline_classify.py: 8 tests for ParticleClassification, _navigate_openpmd, error path
- test_scan.py: +1 test for ScanResult.plot_pareto() (spec §6.2)

Total: 1300 tests (was 1258). All non-Streamlit source modules now have direct imports in tests.

Author: Lulzx

docs_src/changelog.md

@@ -42,7 +42,12 @@
   `helicon.Metrics`, `helicon.DetachmentMetrics`)
 - Added `tests/unit/test_mission_cli.py`: 14 tests for throttle-map + mission + regression CLI
 - Added `tests/unit/test_diagnostics.py`: 9 tests for `DiagnosticSchedule` / `resolve_schedule`
-- Total: 1258 tests (was 1198)
+- Added `tests/unit/test_moments.py`: 8 tests for `MomentData` dataclass + bin-index logic
+- Added `tests/unit/test_fieldline_classify.py`: 8 tests for `ParticleClassification`, `_navigate_openpmd`
+- Added `tests/unit/test_biot_savart_3d.py`: 16 tests for 3D Biot-Savart solver (`Coil3D`, `Grid3D`, `BField3D`, `compute_bfield_3d`)
+- Added `tests/unit/test_sim3d.py`: 9 tests for `Sim3DConfig`, `Sim3DResult`, `_make_grid_params`, `run_3d_simulation`
+- Added `ScanResult.plot_pareto()` test in `test_scan.py` (spec §6.2)
+- Total: 1300 tests (was 1258)
 
 ---
 

tests/unit/test_biot_savart_3d.py

@@ -0,0 +1,116 @@
+"""Tests for helicon.fields.biot_savart_3d — 3D Biot-Savart solver."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from helicon.fields.biot_savart_3d import BField3D, Coil3D, Grid3D, compute_bfield_3d
+
+
+def _small_grid() -> Grid3D:
+    """A small 8×8×16 grid suitable for fast unit tests."""
+    return Grid3D(
+        x_min=-0.2, x_max=0.2,
+        y_min=-0.2, y_max=0.2,
+        z_min=-0.3, z_max=1.5,
+        nx=8, ny=8, nz=16,
+    )
+
+
+def _single_coil(z: float = 0.0, r: float = 0.1, I: float = 10000.0) -> Coil3D:
+    return Coil3D(z=z, r=r, I=I)
+
+
+class TestCoil3DDataclass:
+    def test_frozen(self):
+        coil = _single_coil()
+        with pytest.raises(AttributeError):
+            coil.I = 999  # type: ignore[misc]
+
+    def test_fields(self):
+        coil = Coil3D(z=0.5, r=0.15, I=5000.0)
+        assert coil.z == 0.5
+        assert coil.r == 0.15
+        assert coil.I == 5000.0
+
+
+class TestGrid3DDataclass:
+    def test_fields(self):
+        g = _small_grid()
+        assert g.nx == 8
+        assert g.ny == 8
+        assert g.nz == 16
+
+    def test_frozen(self):
+        g = _small_grid()
+        with pytest.raises(AttributeError):
+            g.nx = 32  # type: ignore[misc]
+
+
+class TestComputeBfield3D:
+    def test_returns_bfield3d(self):
+        bfield = compute_bfield_3d([_single_coil()], _small_grid(), backend="numpy")
+        assert isinstance(bfield, BField3D)
+
+    def test_output_shape(self):
+        grid = _small_grid()
+        bfield = compute_bfield_3d([_single_coil()], grid, backend="numpy")
+        assert bfield.Bx.shape == (grid.nx, grid.ny, grid.nz)
+        assert bfield.By.shape == (grid.nx, grid.ny, grid.nz)
+        assert bfield.Bz.shape == (grid.nx, grid.ny, grid.nz)
+
+    def test_coordinate_arrays(self):
+        grid = _small_grid()
+        bfield = compute_bfield_3d([_single_coil()], grid, backend="numpy")
+        assert bfield.x.shape == (grid.nx,)
+        assert bfield.y.shape == (grid.ny,)
+        assert bfield.z.shape == (grid.nz,)
+
+    def test_field_nonzero(self):
+        bfield = compute_bfield_3d([_single_coil()], _small_grid(), backend="numpy")
+        assert np.any(bfield.Bz != 0.0)
+
+    def test_zero_current_gives_zero_field(self):
+        coil = Coil3D(z=0.0, r=0.1, I=0.0)
+        bfield = compute_bfield_3d([coil], _small_grid(), backend="numpy")
+        assert np.allclose(bfield.Bx, 0.0)
+        assert np.allclose(bfield.By, 0.0)
+        assert np.allclose(bfield.Bz, 0.0)
+
+    def test_backend_stored(self):
+        bfield = compute_bfield_3d([_single_coil()], _small_grid(), backend="numpy")
+        assert bfield.backend == "numpy"
+
+    def test_coils_stored(self):
+        coil = _single_coil()
+        bfield = compute_bfield_3d([coil], _small_grid(), backend="numpy")
+        assert len(bfield.coils) == 1
+        assert bfield.coils[0] is coil
+
+    def test_linearity_two_coils(self):
+        """Field from 2 identical coils should be ~2× field from 1 coil."""
+        grid = _small_grid()
+        coil = _single_coil(I=1000.0)
+        b1 = compute_bfield_3d([coil], grid, backend="numpy")
+        b2 = compute_bfield_3d([coil, coil], grid, backend="numpy")
+        np.testing.assert_allclose(b2.Bz, 2.0 * b1.Bz, rtol=1e-10)
+
+
+class TestBField3DProperties:
+    def test_bmag_shape(self):
+        bfield = compute_bfield_3d([_single_coil()], _small_grid(), backend="numpy")
+        assert bfield.Bmag.shape == bfield.Bx.shape
+
+    def test_bmag_nonnegative(self):
+        bfield = compute_bfield_3d([_single_coil()], _small_grid(), backend="numpy")
+        assert np.all(bfield.Bmag >= 0.0)
+
+    def test_on_axis_shape(self):
+        grid = _small_grid()
+        bfield = compute_bfield_3d([_single_coil()], grid, backend="numpy")
+        assert bfield.on_axis().shape == (grid.nz,)
+
+    def test_mirror_ratio_positive(self):
+        bfield = compute_bfield_3d([_single_coil()], _small_grid(), backend="numpy")
+        assert bfield.mirror_ratio() >= 1.0

tests/unit/test_fieldline_classify.py

@@ -0,0 +1,92 @@
+"""Tests for helicon.postprocess.fieldline_classify — particle topology classification."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from helicon.postprocess.fieldline_classify import ParticleClassification, _navigate_openpmd
+
+
+class TestParticleClassificationDataclass:
+    def test_fields_accessible(self):
+        n = 100
+        rng = np.random.default_rng(7)
+        labels = rng.integers(0, 3, size=n).astype(np.int32)
+        pc = ParticleClassification(
+            species="D_plus",
+            n_open=int(np.sum(labels == 0)),
+            n_closed=int(np.sum(labels == 1)),
+            n_separatrix=int(np.sum(labels == 2)),
+            n_total=n,
+            labels=labels,
+            positions_r=rng.uniform(0, 0.1, n),
+            positions_z=rng.uniform(-0.3, 1.0, n),
+        )
+        assert pc.n_total == n
+        assert pc.n_open + pc.n_closed + pc.n_separatrix == n
+        assert pc.labels.dtype == np.int32
+        assert pc.positions_r.shape == (n,)
+        assert pc.positions_z.shape == (n,)
+
+    def test_all_open(self):
+        n = 50
+        pc = ParticleClassification(
+            species="He_2plus",
+            n_open=50,
+            n_closed=0,
+            n_separatrix=0,
+            n_total=50,
+            labels=np.zeros(n, dtype=np.int32),
+            positions_r=np.ones(n) * 0.05,
+            positions_z=np.linspace(0, 1, n),
+        )
+        assert pc.n_open == n
+        assert np.all(pc.labels == 0)
+
+    def test_species_name_preserved(self):
+        pc = ParticleClassification(
+            species="alpha",
+            n_open=10, n_closed=5, n_separatrix=1, n_total=16,
+            labels=np.zeros(16, dtype=np.int32),
+            positions_r=np.zeros(16),
+            positions_z=np.zeros(16),
+        )
+        assert pc.species == "alpha"
+
+
+class TestNavigateOpenPMD:
+    def test_flat_dict_returned_as_is(self):
+        """If no 'data' key, return the dict unchanged."""
+        d = {"particles": "mock"}
+        result = _navigate_openpmd(d)
+        assert result is d
+
+    def test_navigates_data_key(self):
+        """With 'data' key, returns the last iteration's subtree."""
+        d = {"data": {"100": {"particles": "step100"}, "200": {"particles": "step200"}}}
+        result = _navigate_openpmd(d)
+        assert result == {"particles": "step200"}
+
+    def test_navigates_single_iteration(self):
+        d = {"data": {"0": {"particles": "step0"}}}
+        result = _navigate_openpmd(d)
+        assert result == {"particles": "step0"}
+
+    def test_sorts_iterations_numerically(self):
+        """Iterations must be sorted as integers, not lexicographically."""
+        d = {"data": {"9": {"step": 9}, "10": {"step": 10}, "2": {"step": 2}}}
+        result = _navigate_openpmd(d)
+        assert result == {"step": 10}
+
+
+class TestClassifyParticlesErrors:
+    def test_raises_on_missing_h5_files(self, tmp_path):
+        """classify_particles raises FileNotFoundError if no HDF5 files present."""
+        import helicon
+        from helicon.postprocess.fieldline_classify import classify_particles
+
+        config = helicon.Config.from_preset("sunbird")
+        bfield = helicon.fields.compute(config.nozzle)
+        with pytest.raises(FileNotFoundError, match="No HDF5 files"):
+            classify_particles(tmp_path, bfield)

tests/unit/test_moments.py

@@ -0,0 +1,97 @@
+"""Tests for helicon.postprocess.moments — moment computation from particle data."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from helicon.postprocess.moments import MomentData
+
+
+class TestMomentDataclass:
+    def test_fields_accessible(self):
+        nr, nz = 8, 16
+        m = MomentData(
+            species="D_plus",
+            density=np.zeros((nr, nz)),
+            vr_mean=np.zeros((nr, nz)),
+            vz_mean=np.zeros((nr, nz)),
+            pressure_rr=np.zeros((nr, nz)),
+            pressure_zz=np.zeros((nr, nz)),
+            r_grid=np.linspace(0, 0.1, nr),
+            z_grid=np.linspace(-0.3, 1.0, nz),
+        )
+        assert m.species == "D_plus"
+        assert m.density.shape == (nr, nz)
+        assert m.vr_mean.shape == (nr, nz)
+        assert m.vz_mean.shape == (nr, nz)
+        assert m.pressure_rr.shape == (nr, nz)
+        assert m.pressure_zz.shape == (nr, nz)
+        assert m.r_grid.shape == (nr,)
+        assert m.z_grid.shape == (nz,)
+
+    def test_with_nonzero_values(self):
+        nr, nz = 4, 8
+        density = np.random.default_rng(42).random((nr, nz)) * 1e18
+        m = MomentData(
+            species="He_2plus",
+            density=density,
+            vr_mean=np.zeros((nr, nz)),
+            vz_mean=np.ones((nr, nz)) * 50000.0,
+            pressure_rr=np.zeros((nr, nz)),
+            pressure_zz=np.zeros((nr, nz)),
+            r_grid=np.linspace(0, 0.2, nr),
+            z_grid=np.linspace(0.0, 2.0, nz),
+        )
+        assert np.all(m.density >= 0)
+        assert np.allclose(m.vz_mean, 50000.0)
+
+
+class TestBinIndexNumpyPath:
+    """Test the numpy bin-index logic that underpins moment binning."""
+
+    def _bin_indices(self, pos, edges, n_bins):
+        """Replicate the numpy path from compute_moments."""
+        return np.clip(np.searchsorted(edges, pos) - 1, 0, n_bins - 1)
+
+    def test_center_of_first_bin(self):
+        edges = np.linspace(0.0, 1.0, 11)  # 10 bins
+        pos = np.array([0.05])  # midpoint of first bin
+        idx = self._bin_indices(pos, edges, 10)
+        assert idx[0] == 0
+
+    def test_center_of_last_bin(self):
+        edges = np.linspace(0.0, 1.0, 11)
+        pos = np.array([0.95])  # midpoint of last bin
+        idx = self._bin_indices(pos, edges, 10)
+        assert idx[0] == 9
+
+    def test_below_minimum_clips_to_zero(self):
+        edges = np.linspace(0.0, 1.0, 11)
+        pos = np.array([-0.5])
+        idx = self._bin_indices(pos, edges, 10)
+        assert idx[0] == 0
+
+    def test_above_maximum_clips_to_last(self):
+        edges = np.linspace(0.0, 1.0, 11)
+        pos = np.array([2.0])
+        idx = self._bin_indices(pos, edges, 10)
+        assert idx[0] == 9
+
+    def test_all_particles_binned_in_range(self):
+        rng = np.random.default_rng(0)
+        n = 1000
+        edges = np.linspace(0.0, 5.0, 101)  # 100 bins
+        pos = rng.uniform(0.0, 5.0, size=n)
+        idx = self._bin_indices(pos, edges, 100)
+        assert np.all(idx >= 0)
+        assert np.all(idx < 100)
+
+
+class TestComputeMomentsErrors:
+    def test_raises_on_missing_h5_files(self, tmp_path):
+        """compute_moments raises FileNotFoundError if no HDF5 files present."""
+        from helicon.postprocess.moments import compute_moments
+
+        with pytest.raises(FileNotFoundError, match="No HDF5 files"):
+            compute_moments(tmp_path)

tests/unit/test_scan.py

@@ -337,3 +337,10 @@ def test_to_json_summary_each_result_has_params(self, base_config, tmp_path):
             assert "params" in entry
             assert "coils.0.I" in entry["params"]
             assert "screened_out" in entry
+
+    def test_plot_pareto_returns_tuple(self, base_config):
+        """plot_pareto() returns (fig, ax) or (None, None) without crashing."""
+        result = self._make_result(base_config)
+        out = result.plot_pareto()
+        assert isinstance(out, tuple)
+        assert len(out) == 2