Update unit tests

Author: prayush

tests/test_blend.py

@@ -3,6 +3,7 @@
 
 from esigmapy.blend import (
     align_in_phase,
+    blend_modes,
     blend_series,
     compute_amplitude,
     compute_frequency,
@@ -363,3 +364,55 @@ def test_align_inspiral_to_merger_order(self):
         # Merger-ringdown is unchanged; inspiral is shifted
         assert np.allclose(mr_out, mr)
         assert not np.allclose(insp_out, wave)
+
+
+# ---------------------------------------------------------------------------
+# blend_modes — input validation guards (pure Python, no LAL required)
+# ---------------------------------------------------------------------------
+
+class TestBlendModesValidation:
+    @staticmethod
+    def _modes(n=500, freq_hz=50.0, dt=1.0 / 4096):
+        t = np.arange(n) * dt
+        mode = np.exp(-2j * np.pi * freq_hz * t)
+        return {(2, 2): mode, (2, -2): np.conj(mode)}
+
+    def test_negative_frq_width_raises(self):
+        modes = self._modes()
+        with pytest.raises(IOError, match="negative"):
+            blend_modes(modes, modes, np.ones(500), 50.0, frq_width=-5.0)
+
+    def test_zero_frq_width_raises(self):
+        modes = self._modes()
+        with pytest.raises(IOError):
+            blend_modes(modes, modes, np.ones(500), 50.0, frq_width=0.0)
+
+    def test_mismatched_orbital_freq_length_raises(self):
+        modes = self._modes(n=500)
+        with pytest.raises(IOError):
+            blend_modes(
+                modes, modes,
+                inspiral_orbital_frequency=np.ones(100),  # wrong length
+                frq_attach=50.0, frq_width=5.0,
+                blend_using_avg_orbital_frequency=True,
+            )
+
+    def test_mode_missing_from_inspiral_raises(self):
+        insp = {(2, 2): np.ones(500, dtype=complex)}
+        mr = {(2, 2): np.ones(500, dtype=complex), (3, 3): np.ones(500, dtype=complex)}
+        with pytest.raises(IOError):
+            blend_modes(
+                insp, mr, np.ones(500), 50.0, frq_width=5.0,
+                modes_to_blend=[(2, 2), (3, 3)],
+                include_conjugate_modes=False,
+            )
+
+    def test_mode_missing_from_mr_raises(self):
+        insp = {(2, 2): np.ones(500, dtype=complex), (3, 3): np.ones(500, dtype=complex)}
+        mr = {(2, 2): np.ones(500, dtype=complex)}
+        with pytest.raises(IOError):
+            blend_modes(
+                insp, mr, np.ones(500), 50.0, frq_width=5.0,
+                modes_to_blend=[(2, 2), (3, 3)],
+                include_conjugate_modes=False,
+            )

tests/test_generator.py

@@ -0,0 +1,173 @@
+import numpy as np
+import pytest
+from scipy import integrate
+
+from esigmapy.generator import (
+    _get_window_start,
+    _get_transition_frequency_window,
+    get_imr_esigma_modes,
+)
+
+
+# ---------------------------------------------------------------------------
+# _get_window_start
+# ---------------------------------------------------------------------------
+
+class TestGetWindowStart:
+    """Tests for the private helper that integrates a frequency series and
+    returns the first index where the cumulative phase exceeds a threshold."""
+
+    _DT = 1.0 / 4096
+    _F0 = 100.0  # Hz — constant frequency used in several tests
+
+    def test_forward_meets_threshold(self):
+        freq = np.ones(500) * self._F0
+        idx = _get_window_start(freq, self._DT, 1.0, direction="forward")
+        assert idx is not None
+        assert abs(integrate.trapezoid(freq[: idx + 1], dx=self._DT)) >= 1.0
+
+    def test_forward_is_first_crossing(self):
+        # The index immediately before should NOT yet meet the threshold
+        freq = np.ones(500) * self._F0
+        idx = _get_window_start(freq, self._DT, 1.0, direction="forward")
+        assert abs(integrate.trapezoid(freq[:idx], dx=self._DT)) < 1.0
+
+    def test_forward_returns_none_when_unreachable(self):
+        # Total integral of [1 Hz × 5 samples × dt] is far below 1000 rad
+        freq = np.ones(5) * 1.0
+        assert _get_window_start(freq, 0.001, 1000.0, direction="forward") is None
+
+    def test_backward_meets_threshold(self):
+        freq = np.ones(500) * self._F0
+        idx = _get_window_start(freq, self._DT, 1.0, direction="backward")
+        assert idx is not None
+        assert abs(integrate.trapezoid(freq[idx:], dx=self._DT)) >= 1.0
+
+    def test_backward_is_last_crossing(self):
+        # The index one step to the right should NOT meet the threshold alone
+        freq = np.ones(500) * self._F0
+        idx = _get_window_start(freq, self._DT, 1.0, direction="backward")
+        assert abs(integrate.trapezoid(freq[idx + 1 :], dx=self._DT)) < 1.0
+
+    def test_backward_returns_none_when_unreachable(self):
+        freq = np.ones(5) * 1.0
+        assert _get_window_start(freq, 0.001, 1000.0, direction="backward") is None
+
+    def test_forward_index_in_valid_range(self):
+        freq = np.linspace(10.0, 200.0, 500)
+        idx = _get_window_start(freq, self._DT, 1.0, direction="forward")
+        assert idx is not None
+        assert 0 < idx < len(freq)
+
+
+# ---------------------------------------------------------------------------
+# _get_transition_frequency_window
+# ---------------------------------------------------------------------------
+
+class TestGetTransitionFrequencyWindow:
+    """Tests for the private helper that converts num_hyb_orbits into a
+    hybridization frequency window width."""
+
+    @staticmethod
+    def _setup(n=2000, dt=1.0 / 4096, f_start=10.0, f_end=200.0):
+        freq = np.linspace(f_start, f_end, n)
+        phase = np.cumsum(freq) * dt  # monotonically increasing
+        return freq, phase, dt
+
+    def test_end_mode_returns_positive_width(self):
+        freq, phase, dt = self._setup()
+        result = _get_transition_frequency_window(
+            phase, freq, dt,
+            f_mr_transition=freq[1000],
+            num_hyb_orbits=0.1,
+            keep_f_mr_transition_at_center=False,
+            blend_using_avg_orbital_frequency=False,
+            failsafe=True,
+        )
+        assert result > 0
+
+    def test_center_mode_returns_positive_width(self):
+        freq, phase, dt = self._setup()
+        result = _get_transition_frequency_window(
+            phase, freq, dt,
+            f_mr_transition=freq[1000],
+            num_hyb_orbits=0.1,
+            keep_f_mr_transition_at_center=True,
+            blend_using_avg_orbital_frequency=False,
+            failsafe=True,
+        )
+        assert result > 0
+
+    def test_avg_orbital_frequency_mode_returns_positive_width(self):
+        freq, phase, dt = self._setup()
+        result = _get_transition_frequency_window(
+            phase, freq, dt,
+            f_mr_transition=freq[1000],
+            num_hyb_orbits=0.1,
+            keep_f_mr_transition_at_center=False,
+            blend_using_avg_orbital_frequency=True,
+            failsafe=True,
+        )
+        assert result > 0
+
+    def test_more_orbits_wider_or_equal_window(self):
+        freq, phase, dt = self._setup()
+        f_tr = freq[1000]
+        w_narrow = _get_transition_frequency_window(
+            phase, freq, dt, f_tr,
+            num_hyb_orbits=0.1,
+            keep_f_mr_transition_at_center=False,
+            blend_using_avg_orbital_frequency=False,
+            failsafe=True,
+        )
+        w_wide = _get_transition_frequency_window(
+            phase, freq, dt, f_tr,
+            num_hyb_orbits=0.5,
+            keep_f_mr_transition_at_center=False,
+            blend_using_avg_orbital_frequency=False,
+            failsafe=True,
+        )
+        assert w_wide >= w_narrow
+
+
+# ---------------------------------------------------------------------------
+# get_imr_esigma_modes — input validation guards (fire before any LAL call)
+# ---------------------------------------------------------------------------
+
+class TestGetImrEsigmaModesValidation:
+    _BASE = dict(
+        mass1=20.0,
+        mass2=20.0,
+        f_lower=20.0,
+        delta_t=1.0 / 2048,
+        merger_ringdown_approximant="NRSur7dq4",
+    )
+
+    def test_invalid_approximant_raises_before_lal(self):
+        kwargs = {**self._BASE, "merger_ringdown_approximant": "IMRPhenomD"}
+        with pytest.raises(IOError):
+            get_imr_esigma_modes(**kwargs, mean_anomaly=0.0)
+
+    def test_both_phase_angles_none_raises(self):
+        with pytest.raises(IOError):
+            get_imr_esigma_modes(**self._BASE, mean_anomaly=None, coa_phase=None)
+
+    def test_align_merger_without_mean_anomaly_raises(self):
+        # blend_aligning_merger_to_inspiral=True (default) requires mean_anomaly
+        with pytest.raises(IOError):
+            get_imr_esigma_modes(
+                **self._BASE,
+                blend_aligning_merger_to_inspiral=True,
+                mean_anomaly=None,
+                coa_phase=0.0,
+            )
+
+    def test_align_inspiral_without_coa_phase_raises(self):
+        # blend_aligning_merger_to_inspiral=False requires coa_phase
+        with pytest.raises(IOError):
+            get_imr_esigma_modes(
+                **self._BASE,
+                blend_aligning_merger_to_inspiral=False,
+                mean_anomaly=0.0,
+                coa_phase=None,
+            )

tests/test_mr_generator.py

@@ -0,0 +1,46 @@
+import pytest
+
+from esigmapy.mr_generator import (
+    check_available_mr_approximants,
+    LALSIM_APPROXIMANTS,
+    PYSEOBNR_APPROXIMANTS,
+    SUPPORTED_MR_APPROXIMANTS,
+)
+
+
+class TestCheckAvailableMrApproximants:
+    def test_lalsim_approximants_valid(self):
+        for approx in LALSIM_APPROXIMANTS:
+            check_available_mr_approximants(approx)  # must not raise
+
+    def test_pyseobnr_approximants_valid(self):
+        for approx in PYSEOBNR_APPROXIMANTS:
+            check_available_mr_approximants(approx)  # must not raise
+
+    def test_unsupported_approximant_raises(self):
+        with pytest.raises(IOError, match="cannot generate"):
+            check_available_mr_approximants("IMRPhenomD")
+
+    def test_empty_string_raises(self):
+        with pytest.raises(IOError):
+            check_available_mr_approximants("")
+
+    def test_case_sensitive(self):
+        with pytest.raises(IOError):
+            check_available_mr_approximants("nrsur7dq4")
+
+
+class TestApproximantConstants:
+    def test_supported_is_union_of_lalsim_and_pyseobnr(self):
+        assert set(SUPPORTED_MR_APPROXIMANTS) == set(LALSIM_APPROXIMANTS) | set(
+            PYSEOBNR_APPROXIMANTS
+        )
+
+    def test_lalsim_and_pyseobnr_disjoint(self):
+        assert not set(LALSIM_APPROXIMANTS) & set(PYSEOBNR_APPROXIMANTS)
+
+    def test_lalsim_contains_nrsur7dq4(self):
+        assert "NRSur7dq4" in LALSIM_APPROXIMANTS
+
+    def test_lalsim_contains_seobnrv4phm(self):
+        assert "SEOBNRv4PHM" in LALSIM_APPROXIMANTS