v0.4.2: SB roots /pi, no-lmax loaders, SOC CG rows, multiplicity fix

- Remove lmax parameter: load_cg/load_jd/load_sb_roots return all entries
- compute_sb_roots divides roots by pi (matches DeepH-pack convention)
- CG SOC rows (l1=1, l2=8..14) in cg.npz via --cg-include-soc CLI flag
- CLI: _load_existing_cg preserves H5-sourced data on incremental rebuild
- CLI status: standard lmax separated from SOC=True indicator
- Fix spherical_harmonics multiplicity (both Legendre/CG paths)
- Irrep/MulIrrep/Irreps registered as JAX pytree leaves
- 177 tests passing, H5 byte-identical verified

Author: kYangLi

irrepx/_constants/_compute.py

@@ -221,10 +221,11 @@ def jd_seed(l: int) -> np.ndarray:  # noqa: E741
 
 
 def compute_sb_roots(lmax: int, num_roots: int = 1000) -> list[np.ndarray]:
-    r"""Compute spherical Bessel roots :math:`j_l(x) = 0`.
+    r"""Compute spherical Bessel roots :math:`j_l(x) = 0`, divided by :math:`\pi`.
 
     Uses scipy's Newton solver with a guaranteed-convergence initial guess
-    (:math:`\ell + \pi`).
+    (:math:`\ell + \pi`).  Roots returned as ``root / \pi`` to match the
+    DeepH-pack convention.
 
     Args:
         lmax: maximum :math:`\ell`.
@@ -244,7 +245,7 @@ def compute_sb_roots(lmax: int, num_roots: int = 1000) -> list[np.ndarray]:
         guess = ell + np.pi
         for _ in range(num_roots):
             r = newton(lambda x: spherical_jn(ell, x), guess, tol=1e-12, maxiter=100)
-            roots.append(float(r))
+            roots.append(float(r) / np.pi)
             guess = r + np.pi
         out.append(np.array(roots, dtype=np.float64))
     return out

pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "irrepx"
-version = "0.4.1"
+version = "0.4.2"
 authors = [
     {name = "DeepH team", email = "deeph-pack@outlook.com"},
 ]

tests/test_bessel.py

@@ -12,8 +12,8 @@ def test_bessel_roots_accuracy():
     roots = compute_sb_roots(_LMAX)
     for _ell in range(_LMAX):
         for r in roots[_ell][:5]:
-            val = spherical_jn(_ell, r)
-            assert abs(val) < 1e-8, f"j_{_ell}({r}) = {val}"
+            val = spherical_jn(_ell, r * np.pi)
+            assert abs(val) < 1e-8, f"j_{_ell}({r}π) = {val}"
 
 
 def test_bessel_roots_monotonic():
@@ -32,7 +32,7 @@ def test_bessel_roots_count():
 def test_bessel_roots_l_zero():
     roots = compute_sb_roots(0, num_roots=256)
     for i, r in enumerate(roots[0][:5]):
-        expected = (i + 1) * np.pi
+        expected = float(i + 1)
         assert abs(r - expected) < 1e-10, f"j_0 root {i}: {r} != {expected}"
 
 

tests/test_wigner.py

@@ -68,7 +68,7 @@ def test_roots_accuracy(self):
         roots = compute_sb_roots(8)
         for ell in range(8):
             for r in roots[ell][:5]:
-                assert abs(spherical_jn(ell, r)) < 1e-8
+                assert abs(spherical_jn(ell, r * np.pi)) < 1e-8
 
     def test_roots_monotonic(self):
         roots = compute_sb_roots(8)
@@ -82,6 +82,6 @@ def test_roots_count(self):
             assert len(roots[ell]) == 256
 
     def test_roots_l_zero_exact(self):
-        roots = compute_sb_roots(0)
+        roots = compute_sb_roots(0, num_roots=256)
         for i, r in enumerate(roots[0][:5]):
-            assert abs(r - (i + 1) * np.pi) < 1e-10
+            assert abs(r - float(i + 1)) < 1e-10