Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /als-apg_osprey /tests /simulation /test_artifact.py
| """Tests for the canonical ``.mat`` build artifact of the shared ALS-U AR ring. | |
| Covers a full serialize/reload round-trip (`build_ring` -> `save_canonical_mat` | |
| -> `at.load_mat`) and a regeneration-equality check that guards against a stale | |
| committed artifact by comparing a freshly built+reloaded ring against the | |
| committed one. | |
| """ | |
| from __future__ import annotations | |
| import re | |
| import at | |
| import numpy as np | |
| from osprey.simulation.lattice import ( | |
| build_ring, | |
| load_canonical_ring, | |
| save_canonical_mat, | |
| ) | |
| # Flat-naming family prefixes (``{fam}{id:02d}``) whose ``PolynomB`` we assert | |
| # preserved. DIPOLE is excluded here — dipoles are ``at.Dipole`` and already | |
| # checked separately by ``_dipoles``. | |
| _AR_MAGNET_TYPES = frozenset({"QF", "QD", "QFA", "SF", "SD", "SHF", "SHD"}) | |
| _MAGNET_FAM_RE = re.compile(r"^([A-Z]+)\d{2,}$") | |
| def _fam_names(ring): | |
| return [e.FamName for e in ring] | |
| def _pass_methods(ring): | |
| return [e.PassMethod for e in ring] | |
| def _monitors(ring): | |
| return [e for e in ring if isinstance(e, at.Monitor)] | |
| def _correctors(ring): | |
| return [e for e in ring if isinstance(e, at.Corrector)] | |
| def _dipoles(ring): | |
| return [e for e in ring if isinstance(e, at.Dipole)] | |
| def _is_ar_magnet(e): | |
| if not hasattr(e, "PolynomB"): | |
| return False | |
| match = _MAGNET_FAM_RE.match(e.FamName) | |
| return match is not None and match.group(1) in _AR_MAGNET_TYPES | |
| def _ar_magnets(ring): | |
| return [e for e in ring if _is_ar_magnet(e)] | |
| def _assert_rings_equal(a, b): | |
| """Assert two rings match on the canonical structural + physics fields.""" | |
| # Order-preserving family names and pass methods. | |
| assert _fam_names(a) == _fam_names(b) | |
| assert _pass_methods(a) == _pass_methods(b) | |
| # Monitors. | |
| a_mon, b_mon = _monitors(a), _monitors(b) | |
| assert [e.FamName for e in a_mon] == [e.FamName for e in b_mon] | |
| # Correctors: length-2 KickAngle vectors. | |
| a_cor, b_cor = _correctors(a), _correctors(b) | |
| assert len(a_cor) == len(b_cor) | |
| for ea, eb in zip(a_cor, b_cor, strict=True): | |
| assert np.allclose(np.asarray(ea.KickAngle).ravel(), np.asarray(eb.KickAngle).ravel()) | |
| # Dipoles: entrance/exit edge angles. | |
| a_dip, b_dip = _dipoles(a), _dipoles(b) | |
| assert len(a_dip) == len(b_dip) | |
| for ea, eb in zip(a_dip, b_dip, strict=True): | |
| assert np.allclose(ea.EntranceAngle, eb.EntranceAngle) | |
| assert np.allclose(ea.ExitAngle, eb.ExitAngle) | |
| # AR magnet PolynomB. | |
| a_mag, b_mag = _ar_magnets(a), _ar_magnets(b) | |
| assert len(a_mag) == len(b_mag) | |
| for ea, eb in zip(a_mag, b_mag, strict=True): | |
| assert np.allclose(np.asarray(ea.PolynomB).ravel(), np.asarray(eb.PolynomB).ravel()) | |
| def test_canonical_mat_roundtrip(tmp_path): | |
| """build_ring -> save_canonical_mat -> at.load_mat preserves all fields.""" | |
| ring = build_ring() | |
| dest = tmp_path / "rt.mat" | |
| written = save_canonical_mat(ring, dest) | |
| assert written == dest | |
| reloaded = at.load_mat(str(dest), use="RING") | |
| # Field-by-field round-trip fidelity. | |
| assert _fam_names(reloaded) == _fam_names(ring) | |
| assert _pass_methods(reloaded) == _pass_methods(ring) | |
| ring_mon, reloaded_mon = _monitors(ring), _monitors(reloaded) | |
| assert [e.FamName for e in reloaded_mon] == [e.FamName for e in ring_mon] | |
| assert len(reloaded_mon) == 72 | |
| ring_cor, reloaded_cor = _correctors(ring), _correctors(reloaded) | |
| assert len(reloaded_cor) == 144 | |
| assert len(ring_cor) == 144 | |
| for ea, eb in zip(ring_cor, reloaded_cor, strict=True): | |
| assert np.allclose(np.asarray(ea.KickAngle).ravel(), np.asarray(eb.KickAngle).ravel()) | |
| ring_dip, reloaded_dip = _dipoles(ring), _dipoles(reloaded) | |
| assert len(reloaded_dip) == 36 | |
| assert len(ring_dip) == 36 | |
| for ea, eb in zip(ring_dip, reloaded_dip, strict=True): | |
| assert np.allclose(ea.EntranceAngle, eb.EntranceAngle) | |
| assert np.allclose(ea.ExitAngle, eb.ExitAngle) | |
| ring_mag, reloaded_mag = _ar_magnets(ring), _ar_magnets(reloaded) | |
| assert len(reloaded_mag) == len(ring_mag) | |
| assert ring_mag # non-empty guard | |
| for ea, eb in zip(ring_mag, reloaded_mag, strict=True): | |
| assert np.allclose(np.asarray(ea.PolynomB).ravel(), np.asarray(eb.PolynomB).ravel()) | |
| def test_committed_artifact_matches_fresh_build(tmp_path): | |
| """Guard against a stale committed .mat: fresh build must equal committed.""" | |
| committed = load_canonical_ring() | |
| fresh = build_ring() | |
| dest = tmp_path / "fresh.mat" | |
| save_canonical_mat(fresh, dest) | |
| reloaded_fresh = at.load_mat(str(dest), use="RING") | |
| _assert_rings_equal(reloaded_fresh, committed) | |
| assert len(committed) == 802 | |
| assert np.isclose(committed.circumference, 182.1219508800, atol=1e-6) | |
Xet Storage Details
- Size:
- 4.74 kB
- Xet hash:
- 96c2bf8304db5648d9d49b6c416e9899715ec3de9cb184b53d8890e88b67a216
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.