qdiffusivity 0.1.0__py3-none-any.whl

qdiffusivity/example_api.py

@@ -0,0 +1,3 @@
+def example_function(number: float) -> float:
+    """Return `2*number`. This is and example for tests."""
+    return 2 * number

qdiffusivity/tests/conftest.py

@@ -0,0 +1,82 @@
+"""Shared pytest fixtures for the qdiffusivity test suite."""
+
+import MDAnalysis as mda
+import numpy as np
+import pytest
+from MDAnalysis.coordinates.memory import MemoryReader
+
+
+def _make_universe(n_atoms, n_res, n_frames, Lx, Ly, Lz, pos, seed):
+    """Build a Universe with masses, types, residues, and a trajectory."""
+    u = mda.Universe.empty(
+        n_atoms=n_atoms,
+        n_residues=n_res,
+        atom_resindex=np.arange(n_atoms) % n_res,
+        trajectory=True,
+    )
+    u.add_TopologyAttr("masses", values=np.ones(n_atoms))
+    u.add_TopologyAttr("types", values=["X"] * n_atoms)
+    u.add_TopologyAttr("resids", values=np.arange(1, n_res + 1))
+    u.add_TopologyAttr("resnames", values=["RES"] * n_res)
+    dims = np.tile([Lx, Ly, Lz, 90.0, 90.0, 90.0], (n_frames, 1))
+    u.trajectory = MemoryReader(pos, dimensions=dims)
+    return u
+
+
+@pytest.fixture
+def diff_universe():
+    """Universe whose atoms perform independent Brownian walks.
+
+    Atoms diffuse with prescribed D_perp (along z) and D_para (along
+    x/y) with dt=1.  z is wrapped to [0, Lz]; x/y are wrapped for the
+    topology (NoJump unwraps them during analysis).
+    """
+
+    def _build(
+        n_atoms=100,
+        n_frames=20,
+        Lx=30.0,
+        Ly=30.0,
+        Lz=80.0,
+        D_perp=0.05,
+        D_para=0.1,
+        seed=0,
+    ):
+        rng = np.random.default_rng(seed)
+        pos = np.empty((n_frames, n_atoms, 3), dtype=np.float64)
+        z = rng.uniform(0.0, Lz, size=n_atoms)
+        x = rng.uniform(0.0, Lx, size=n_atoms)
+        y = rng.uniform(0.0, Ly, size=n_atoms)
+        sp = np.sqrt(2.0 * D_perp)
+        sq = np.sqrt(2.0 * D_para)
+        for f in range(n_frames):
+            x = (x + rng.normal(0.0, sq, size=n_atoms)) % Lx
+            y = (y + rng.normal(0.0, sq, size=n_atoms)) % Ly
+            z = (z + rng.normal(0.0, sp, size=n_atoms)) % Lz
+            pos[f, :, 0] = x
+            pos[f, :, 1] = y
+            pos[f, :, 2] = z
+        return _make_universe(n_atoms, n_atoms, n_frames, Lx, Ly, Lz, pos, seed)
+
+    return _build
+
+
+@pytest.fixture
+def density_universe():
+    """Universe with atoms random-walking in z (no drift, uniform density)."""
+
+    def _build(
+        n_atoms=200, n_res=10, n_frames=5,
+        Lx=20.0, Ly=20.0, Lz=100.0, seed=0,
+    ):
+        rng = np.random.default_rng(seed)
+        pos = np.empty((n_frames, n_atoms, 3), dtype=np.float64)
+        base = rng.uniform(0.0, Lz, size=n_atoms)
+        for f in range(n_frames):
+            pos[f, :, 0] = rng.uniform(0.0, Lx, size=n_atoms)
+            pos[f, :, 1] = rng.uniform(0.0, Ly, size=n_atoms)
+            base = (base + rng.normal(0.0, 1.0, size=n_atoms)) % Lz
+            pos[f, :, 2] = base
+        return _make_universe(n_atoms, n_res, n_frames, Lx, Ly, Lz, pos, seed)
+
+    return _build

qdiffusivity/tests/test_binned.py

@@ -0,0 +1,163 @@
+"""Tests for the binned density/diffusivity module."""
+
+import numpy as np
+import pytest
+
+from qdiffusivity.binned import (
+    LocalDiffusivityQBinned,
+    TransverseDensityQBinned,
+    cic_assign,
+    resolve_bins,
+)
+
+
+def test_resolve_bins():
+    """int, 'quantile', explicit edges (padded/full), and invalid specs."""
+    n, edges, cic = resolve_bins(20)
+    assert n == 20 and edges.shape == (21,) and cic is True
+    n, _, cic = resolve_bins("quantile")
+    assert n == 30 and cic is True
+    assert resolve_bins("quantile", n_default=15)[0] == 15
+    n, edges, cic = resolve_bins(np.array([0.1, 0.3, 0.7, 0.9]))
+    assert n == 5 and edges[0] == 0.0 and edges[-1] == 1.0 and cic is False
+    n, edges, cic = resolve_bins(np.array([0, 0.25, 0.5, 0.75, 1.0]))
+    assert n == 4 and cic is False
+    for bad in [
+        "bogus",
+        0,
+        np.array([0, 0.5, 0.3, 1.0]),
+        np.array([-0.1, 0.5, 1.0]),
+        np.array([0, 0.5, 1.1]),
+    ]:
+        with pytest.raises(ValueError):
+            resolve_bins(bad)
+
+
+def test_cic_assign():
+    """Weights sum to 1, center -> single bin, edge -> 50/50, mirror,
+    total population preserved."""
+    rng = np.random.default_rng(40)
+    u = rng.uniform(0.0, 1.0, size=5_000)
+    k0, k1, w0, w1 = cic_assign(u, 20)
+    assert np.allclose(w0 + w1, 1.0)
+    assert np.all(k0 >= 0) and np.all(k0 < 20)
+    # Center of bin 10: u = 10.5/20 = 0.525.
+    _, _, w0c, w1c = cic_assign(np.array([0.525]), 20)
+    assert w0c[0] == pytest.approx(1.0) and w1c[0] == pytest.approx(0.0)
+    # Edge: u = 0.5 -> 50/50.
+    _, _, w0e, w1e = cic_assign(np.array([0.5]), 20)
+    assert w0e[0] == pytest.approx(0.5) and w1e[0] == pytest.approx(0.5)
+    # Mirror: u = 0.01 -> q = -0.3 -> reflected to 0.3 -> w0 = 0.7.
+    k0m, _, w0m, _ = cic_assign(np.array([0.01]), 20)
+    assert k0m[0] == 0 and w0m[0] == pytest.approx(0.7)
+    # Total population preserved.
+    pop = np.zeros(20)
+    np.add.at(pop, k0, w0)
+    np.add.at(pop, k1, w1)
+    assert pop.sum() == pytest.approx(5_000.0)
+
+
+@pytest.mark.parametrize(
+    "bins,expected_n",
+    [(20, 20), ("quantile", 30), (np.array([0, 0.25, 0.5, 0.75, 1.0]), 4)],
+)
+@pytest.mark.parametrize("grouping", ["atoms", "residues"])
+def test_density_binned(density_universe, bins, expected_n, grouping):
+    """Run, attributes, density positive, all bin specs, grouping."""
+    u = density_universe(n_atoms=200, n_res=20, n_frames=5, Lz=100.0, seed=50)
+    binned = TransverseDensityQBinned(
+        u.select_atoms("all"),
+        dim=2,
+        z_bot=0.0,
+        z_top=100.0,
+        bins=bins,
+        grouping=grouping,
+    )
+    binned.run()
+    assert binned.density.shape == (expected_n,)
+    assert binned.z_centers.shape == (expected_n,)
+    assert np.all(binned.density >= 0.0)
+    assert binned.n_frames_used == 5
+
+
+@pytest.mark.parametrize(
+    "bins,expected_n",
+    [(20, 20), ("quantile", 30),
+     (np.array([0.1, 0.3, 0.7, 0.9]), 5)]
+)
+def test_diffusivity_binned(diff_universe, bins, expected_n):
+    """Run, attributes, known-D recovery, all bin specs."""
+    D_perp_true, D_para_true = 0.05, 0.1
+    u = diff_universe(
+        n_atoms=400,
+        n_frames=40,
+        Lz=60.0,
+        D_perp=D_perp_true,
+        D_para=D_para_true,
+        seed=61,
+    )
+    binned = LocalDiffusivityQBinned(u.select_atoms("all"), dim=2, bins=bins)
+    binned.run()
+    assert binned.D_perp.shape == (expected_n,)
+    assert binned.n_increments == 400 * 39
+    assert binned.dt == pytest.approx(1.0)
+    bulk = (binned.z_centers > 20) & (binned.z_centers < 40)
+    valid = binned.n_eff_perp > 5
+    assert np.median(binned.D_perp[bulk & valid]) == pytest.approx(
+        D_perp_true, rel=0.3
+    )
+    assert np.median(binned.D_para[bulk & valid]) == pytest.approx(
+        D_para_true, rel=0.3
+    )
+
+
+@pytest.mark.parametrize(
+    "cls,kwargs",
+    [
+        (TransverseDensityQBinned, {"dim": 5}),
+        (TransverseDensityQBinned, {"grouping": "molecules"}),
+        (LocalDiffusivityQBinned, {"dim": 5}),
+    ],
+)
+def test_binned_validation(density_universe, diff_universe, cls, kwargs):
+    if cls is TransverseDensityQBinned:
+        u = density_universe(n_atoms=10, n_res=2, n_frames=1, Lz=10.0)
+    else:
+        u = diff_universe(n_atoms=10, n_frames=3, Lz=10.0)
+    with pytest.raises(ValueError):
+        cls(u.select_atoms("all"), **kwargs)
+
+
+def test_diffusivity_binned_single_frame_raises(diff_universe):
+    u = diff_universe(n_atoms=10, n_frames=1, Lz=10.0)
+    binned = LocalDiffusivityQBinned(u.select_atoms("all"), bins=10)
+    with pytest.raises(ValueError):
+        binned.run()
+
+
+def test_diffusivity_binned_explicit_dt(diff_universe):
+    u = diff_universe(n_atoms=50, n_frames=5, Lz=40.0, seed=68)
+    binned = LocalDiffusivityQBinned(
+        u.select_atoms("all"), dim=2, bins=10, dt=2.0
+    )
+    binned.run()
+    assert binned.dt == pytest.approx(2.0)
+
+
+@pytest.mark.parametrize("ito", [False, True])
+def test_diffusivity_binned_ito(diff_universe, ito):
+    """Default-off (None), on (finite non-neg), reduces D_perp, no effect
+    on D_para."""
+    u = diff_universe(n_atoms=200, n_frames=20, Lz=60.0, seed=66)
+    ag = u.select_atoms("all")
+    binned = LocalDiffusivityQBinned(ag, dim=2, bins=15, ito_correction=ito)
+    binned.run()
+    if not ito:
+        assert binned.ito_bias is None
+        return
+    assert binned.ito_bias is not None
+    assert np.all(binned.ito_bias >= 0)
+    b_unc = LocalDiffusivityQBinned(ag, dim=2, bins=15)
+    b_unc.run()
+    assert np.all(binned.D_perp <= b_unc.D_perp + 1e-12)
+    assert np.allclose(binned.D_para, b_unc.D_para)

qdiffusivity/tests/test_density.py

@@ -0,0 +1,123 @@
+"""Tests for the density QKDE module."""
+
+import numpy as np
+import pytest
+
+from qdiffusivity.density import (
+    TransverseDensityQKDE,
+    epanechnikov_kernel,
+    kde_1d,
+    select_bandwidth,
+    silverman_bw,
+)
+
+
+def test_epanechnikov_kernel():
+    """Normalised, compact support, non-negative, peak at zero."""
+    x = np.linspace(-3.0, 3.0, 200_001)
+    assert np.trapezoid(
+        epanechnikov_kernel(x, 1.0), x
+    ) == pytest.approx(1.0, abs=1e-4)
+    assert epanechnikov_kernel(np.array([1.6]), 1.5)[0] == 0.0
+    assert epanechnikov_kernel(
+        np.array([0.0]), 1.5
+    )[0] == pytest.approx(0.75 / 1.5)
+    assert np.all(epanechnikov_kernel(x, 2.0) >= 0.0)
+
+
+def test_bandwidth_selection():
+    """Silverman, Sheather-Jones, select_bandwidth, and edge cases."""
+    rng = np.random.default_rng(0)
+    z = rng.normal(0.0, 1.0, size=10_000)
+    assert silverman_bw(z) == pytest.approx(1.06 * 10_000 ** (-0.2), rel=0.3)
+    assert silverman_bw(np.array([1.0])) == 0.1
+    from qdiffusivity.density import sheather_jones_bw
+
+    z_bimodal = np.concatenate(
+        [rng.normal(-3.0, 0.5, 2000), rng.normal(3.0, 0.5, 2000)]
+    )
+    assert 0 < sheather_jones_bw(z_bimodal, -10, 10) <= silverman_bw(z_bimodal)
+    assert select_bandwidth(z, -5, 5, method=0.42) == pytest.approx(0.42)
+    with pytest.raises(ValueError):
+        select_bandwidth(z, -5, 5, method="bogus")
+
+
+def test_kde_1d():
+    """Integration to 1, bandwidth validation, ESS bounds, empty data."""
+    rng = np.random.default_rng(1)
+    z = rng.normal(50.0, 5.0, size=20_000)
+    z_eval = np.linspace(20.0, 80.0, 2001)
+    rho, n_eff = kde_1d(z, z_eval, 0.5, 0.0, 100.0)
+    assert np.trapezoid(rho, z_eval) == pytest.approx(1.0, abs=0.02)
+    # ESS is positive in the well-sampled interior and bounded by N.
+    interior = (z_eval > 40) & (z_eval < 60)
+    assert np.all(n_eff[interior] > 0)
+    assert np.all(n_eff <= z.size)
+    with pytest.raises(ValueError):
+        kde_1d(z, z_eval, 0.0, 0.0, 100.0)
+    rho_e, n_eff_e = kde_1d(np.array([]), np.linspace(0, 10, 11), 0.5, 0, 10)
+    assert np.all(rho_e == 0.0) and np.all(n_eff_e == 0.0)
+
+
+@pytest.mark.parametrize("grouping", ["atoms", "residues"])
+def test_density_qkde(density_universe, grouping):
+    """Run, attributes, normalisation, auto bandwidth, auto boundaries."""
+    n_atoms, n_res, n_frames = 200, 10, 5
+    u = density_universe(
+        n_atoms=n_atoms, n_res=n_res,
+        n_frames=n_frames, Lz=100.0,
+    )
+    ag = u.select_atoms("all")
+    kde = TransverseDensityQKDE(
+        ag,
+        dim=2,
+        z_bot=0.0,
+        z_top=100.0,
+        n_points=80,
+        bandwidth="auto",
+        grouping=grouping,
+    )
+    kde.run()
+    assert kde.rho.shape == (80,)
+    assert np.all(kde.rho >= 0.0)
+    assert np.trapezoid(kde.rho, kde.z_eval) == pytest.approx(1.0, abs=0.05)
+    assert kde.n_frames_used == n_frames
+    if grouping == "residues":
+        expected_n = n_res * n_frames
+    else:
+        expected_n = n_atoms * n_frames
+    assert kde.n_total == expected_n
+    assert np.isfinite(kde.bandwidth) and kde.bandwidth > 0
+
+
+def test_density_qkde_auto_boundaries(density_universe):
+    u = density_universe(n_atoms=100, n_frames=2, Lz=40.0)
+    kde = TransverseDensityQKDE(
+        u.select_atoms("all"), dim=2, n_points=40, bandwidth=0.3
+    )
+    kde.run()
+    assert kde.z_eval[0] > 0.0
+    assert kde.z_eval[-1] < 40.0
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"dim": 5},
+        {"grouping": "molecules"},
+        {"bandwidth": "bogus"},
+    ],
+)
+def test_density_qkde_validation(density_universe, kwargs):
+    u = density_universe(n_atoms=10, n_res=2, n_frames=1, Lz=10.0)
+    with pytest.raises(ValueError):
+        TransverseDensityQKDE(u.select_atoms("all"), **kwargs)
+
+
+def test_density_qkde_inverted_boundaries(density_universe):
+    u = density_universe(n_atoms=10, n_res=2, n_frames=1, Lz=10.0)
+    kde = TransverseDensityQKDE(
+        u.select_atoms("all"), dim=2, z_bot=10.0, z_top=0.0, bandwidth=0.5
+    )
+    with pytest.raises(ValueError):
+        kde.run()

qdiffusivity/tests/test_diffusivity.py

@@ -0,0 +1,227 @@
+"""Tests for the diffusivity QKDE module."""
+
+import numpy as np
+import pytest
+
+import qdiffusivity
+from qdiffusivity.diffusivity import (
+    LocalDiffusivityQKDE,
+    build_cdf,
+    gaussian_kernel,
+    kde_estimate,
+    select_diff_bandwidth,
+)
+
+
+def test_gaussian_kernel():
+    """Normalised, symmetric, peak at zero."""
+    x = np.linspace(-10.0, 10.0, 200_001)
+    assert np.trapezoid(
+        gaussian_kernel(x, 1.0), x
+    ) == pytest.approx(1.0, abs=1e-4)
+    k = gaussian_kernel(np.array([-3, -1, 0, 1, 3.0]), 1.5)
+    assert k[0] == pytest.approx(k[-1])
+    assert k[2] > k[1] > k[0]
+    assert k[2] == pytest.approx(1.0 / (1.5 * np.sqrt(2 * np.pi)))
+
+
+def test_bandwidth_selection():
+    """Silverman, SJ for both kernels, select_diff_bandwidth, invalid."""
+    rng = np.random.default_rng(10)
+    u = rng.uniform(0.0, 1.0, size=5_000)
+    from qdiffusivity.diffusivity import sheather_jones_bw, silverman_bw
+
+    assert silverman_bw(u) > 0
+    for kernel in ("gaussian", "epanechnikov"):
+        h = sheather_jones_bw(u, kernel=kernel)
+        assert np.isfinite(h) and h > 0
+    h_unif = sheather_jones_bw(np.linspace(0, 1, 5000), kernel="gaussian")
+    assert h_unif <= silverman_bw(np.linspace(0, 1, 5000))
+    assert select_diff_bandwidth(u, method=0.42) == pytest.approx(0.42)
+    with pytest.raises(ValueError):
+        select_diff_bandwidth(u, method="bogus", kernel="gaussian")
+
+
+def test_build_cdf():
+    """Monotonic, in-bounds, inverse roundtrip, rho integrates to 1,
+    rho_prime sign at mode, empty raises."""
+    rng = np.random.default_rng(13)
+    z = rng.normal(50.0, 5.0, size=20_000)
+    P, P_inv, rho, rho_prime, _, _ = build_cdf(z)
+    z_grid = np.linspace(40, 60, 101)
+    u_grid = P(z_grid)
+    assert np.all(np.diff(u_grid) >= -1e-12)
+    assert np.all(u_grid >= 0) and np.all(u_grid <= 1)
+    z_back = P_inv(P(z_grid))
+    assert np.allclose(z_back, z_grid, atol=0.1)
+    rho_vals = rho(z_grid)
+    assert np.all(rho_vals >= 0)
+    assert np.trapezoid(rho_vals, z_grid) == pytest.approx(1.0, abs=0.1)
+    rho_p = rho_prime(np.array([45.0, 50.0, 55.0]))
+    assert rho_p[0] > 0 and rho_p[2] < 0
+    assert rho_p[1] == pytest.approx(0.0, abs=2e-3)
+    with pytest.raises(ValueError):
+        build_cdf(np.array([]))
+
+
+def test_kde_estimate():
+    """Constant estimator, weighted mean, bandwidth validation, empty,
+    ESS bound, kernels agree at wide bandwidth."""
+    rng = np.random.default_rng(16)
+    u = rng.uniform(0.0, 1.0, size=5_000)
+    D, D_std, n_eff = kde_estimate(
+        u, np.full(5000, 0.3), np.array([0.25, 0.5, 0.75]), h=0.05
+    )
+    assert np.allclose(D, 0.3, atol=1e-10)
+    assert np.all(n_eff > 0)
+    # Two clusters.
+    u2 = np.concatenate([np.full(2000, 0.2), np.full(2000, 0.8)])
+    d2 = np.concatenate([np.full(2000, 1.0), np.full(2000, 2.0)])
+    D2, _, _ = kde_estimate(u2, d2, np.array([0.2, 0.8]), h=0.05)
+    assert D2[0] == pytest.approx(1.0, abs=0.05)
+    assert D2[1] == pytest.approx(2.0, abs=0.05)
+    with pytest.raises(ValueError):
+        kde_estimate(u, np.ones(5000), np.array([0.5]), h=0.0)
+    De, _, ne = kde_estimate(
+        np.array([]), np.array([]), np.linspace(0.1, 0.9, 5), h=0.1
+    )
+    assert np.all(De == 0) and np.all(ne == 0)
+    # Kernels agree at wide bandwidth.
+    d3 = rng.normal(1.0, 0.2, size=2000)
+    Dg, _, _ = kde_estimate(
+        u2[:2000], d3, np.array([0.5]), h=2.0,
+        kernel="gaussian",
+    )
+    Dep, _, _ = kde_estimate(
+        u2[:2000], d3, np.array([0.5]), h=2.0, kernel="epanechnikov"
+    )
+    assert Dg[0] == pytest.approx(np.mean(d3), abs=0.05)
+    assert Dep[0] == pytest.approx(np.mean(d3), abs=0.05)
+
+
+@pytest.mark.parametrize("kernel", ["gaussian", "epanechnikov"])
+def test_diffusivity_qkde(diff_universe, kernel):
+    """Run, attributes, known-D recovery, auto bandwidth."""
+    D_perp_true, D_para_true = 0.05, 0.1
+    u = diff_universe(
+        n_atoms=400,
+        n_frames=40,
+        Lz=60.0,
+        D_perp=D_perp_true,
+        D_para=D_para_true,
+        seed=21,
+    )
+    ag = u.select_atoms("all")
+    kde = LocalDiffusivityQKDE(
+        ag,
+        dim=2,
+        n_points=60,
+        bandwidth="auto",
+        kernel=kernel,
+    )
+    kde.run()
+    assert kde.D_perp.shape == (60,)
+    assert kde.D_para.shape == (60,)
+    assert kde.n_increments == 400 * 39
+    assert kde.dt == pytest.approx(1.0)
+    assert np.all(kde.D_perp >= 0)
+    bulk = (kde.z_eval > 20) & (kde.z_eval < 40)
+    valid = kde.n_eff_perp > 5
+    assert np.median(kde.D_perp[bulk & valid]) == pytest.approx(
+        D_perp_true, rel=0.3
+    )
+    assert np.median(kde.D_para[bulk & valid]) == pytest.approx(
+        D_para_true, rel=0.3
+    )
+
+
+@pytest.mark.parametrize(
+    "kwargs", [{"dim": 5}, {"bandwidth": "bogus"}, {"kernel": "tri"}]
+)
+def test_diffusivity_qkde_validation(diff_universe, kwargs):
+    u = diff_universe(n_atoms=10, n_frames=3, Lz=10.0)
+    with pytest.raises(ValueError):
+        LocalDiffusivityQKDE(u.select_atoms("all"), **kwargs)
+
+
+def test_diffusivity_qkde_single_frame_raises(diff_universe):
+    u = diff_universe(n_atoms=10, n_frames=1, Lz=10.0)
+    kde = LocalDiffusivityQKDE(
+        u.select_atoms("all"), n_points=10, bandwidth=0.1
+    )
+    with pytest.raises(ValueError):
+        kde.run()
+
+
+def test_diffusivity_qkde_explicit_dt(diff_universe):
+    u = diff_universe(n_atoms=50, n_frames=5, Lz=40.0, seed=24)
+    kde = LocalDiffusivityQKDE(
+        u.select_atoms("all"), n_points=20, bandwidth=0.1, dt=2.0
+    )
+    kde.run()
+    assert kde.dt == pytest.approx(2.0)
+
+
+@pytest.mark.parametrize("ito", [False, True])
+def test_ito_correction(diff_universe, ito):
+    """Default-off (None), on (finite non-neg array), reduces D_perp,
+    no effect on D_para, recovers known D, zero bias for uniform density."""
+    u = diff_universe(n_atoms=200, n_frames=20, Lz=60.0, seed=32)
+    ag = u.select_atoms("all")
+    kde = LocalDiffusivityQKDE(
+        ag,
+        dim=2,
+        n_points=40,
+        bandwidth=0.08,
+        ito_correction=ito,
+    )
+    kde.run()
+    if not ito:
+        assert kde.ito_bias is None
+        return
+    assert kde.ito_bias is not None
+    assert np.all(kde.ito_bias >= 0)
+    # Compare with uncorrected.
+    kde_unc = LocalDiffusivityQKDE(ag, dim=2, n_points=40, bandwidth=0.08)
+    kde_unc.run()
+    assert np.all(kde.D_perp <= kde_unc.D_perp + 1e-12)
+    assert np.allclose(kde.D_para, kde_unc.D_para)
+    # Bulk bias should be tiny (uniform density -> rho' ~ 0).
+    bulk = (kde.z_eval > 20) & (kde.z_eval < 40)
+    assert np.all(kde.ito_bias[bulk] < 1e-3)
+    # Still recovers known D in bulk.
+    u2 = diff_universe(n_atoms=400, n_frames=40, Lz=60.0, D_perp=0.05, seed=35)
+    kde2 = LocalDiffusivityQKDE(
+        u2.select_atoms("all"),
+        n_points=60,
+        bandwidth=0.08,
+        ito_correction=True,
+    )
+    kde2.run()
+    bulk2 = (kde2.z_eval > 20) & (kde2.z_eval < 40)
+    valid2 = kde2.n_eff_perp > 5
+    assert np.median(kde2.D_perp[bulk2 & valid2]) == pytest.approx(
+        0.05, rel=0.3
+    )
+
+
+def test_package_exports():
+    """All public names are importable from qdiffusivity."""
+    for name in (
+        "TransverseDensityQKDE",
+        "TransverseDensityQBinned",
+        "LocalDiffusivityQKDE",
+        "LocalDiffusivityQBinned",
+        "build_cdf",
+        "cic_assign",
+        "epanechnikov_kernel",
+        "gaussian_kernel",
+        "kde_1d",
+        "kde_estimate",
+        "resolve_bins",
+        "select_bandwidth",
+        "select_diff_bandwidth",
+        "sheather_jones_bw",
+        "silverman_bw",
+    ):
+        assert hasattr(qdiffusivity, name)

qdiffusivity/tests/test_qdiffusivity.py

@@ -0,0 +1,8 @@
+"""Smoke test: the package imports and exposes its version."""
+
+import qdiffusivity
+
+
+def test_version():
+    assert isinstance(qdiffusivity.__version__, str)
+    assert len(qdiffusivity.__version__) > 0

qdiffusivity/tests/utils.py

@@ -0,0 +1,77 @@
+from typing import Tuple
+
+import MDAnalysis as mda
+import numpy as np
+from MDAnalysis.coordinates.memory import MemoryReader
+
+
+def make_Universe(
+    extras: Tuple[str] = tuple(),
+    size: Tuple[int, int, int] = (125, 25, 5),
+    n_frames: int = 0,
+    velocities: bool = False,
+    forces: bool = False
+) -> mda.Universe:
+    """Make a dummy reference Universe
+
+    Allows the construction of arbitrary-sized Universes. Suitable for
+    the generation of structures for output.
+
+    Preferable for testing core components because:
+      * minimises dependencies within the package
+      * very fast compared to a "real" Universe
+
+    Parameters
+    ----------
+    extras : tuple of strings, optional
+      extra attributes to add to Universe:
+      u = make_Universe(('masses', 'charges'))
+      Creates a lightweight Universe with only masses and charges.
+    size : tuple of int, optional
+      number of elements of the Universe (n_atoms, n_residues, n_segments)
+    n_frames : int
+      If positive, create a fake Reader object attached to Universe
+    velocities : bool, optional
+      if the fake Reader provides velocities
+    force : bool, optional
+      if the fake Reader provides forces
+
+    Returns
+    -------
+    MDAnalysis.core.universe.Universe object
+
+    """
+
+    n_atoms, n_residues, n_segments = size
+    trajectory = n_frames > 0
+    u = mda.Universe.empty(
+        # topology things
+        n_atoms=n_atoms,
+        n_residues=n_residues,
+        n_segments=n_segments,
+        atom_resindex=np.repeat(
+            np.arange(n_residues), n_atoms // n_residues),
+        residue_segindex=np.repeat(
+            np.arange(n_segments), n_residues // n_segments),
+        # trajectory things
+        trajectory=trajectory,
+        velocities=velocities,
+        forces=forces,
+    )
+    if extras is None:
+        extras = []
+    for ex in extras:
+        u.add_TopologyAttr(ex)
+
+    if trajectory:
+        pos = np.arange(3 * n_atoms * n_frames).reshape(n_frames, n_atoms, 3)
+        vel = pos + 100 if velocities else None
+        fcs = pos + 10000 if forces else None
+        reader = MemoryReader(
+            pos,
+            velocities=vel,
+            forces=fcs,
+        )
+        u.trajectory = reader
+
+    return u