sigima 0.0.1.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

sigima/tests/signal/pulse/__init__.py

@@ -0,0 +1,112 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit tests for pulse analysis functions.
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+import numpy as np
+
+from sigima.tools.signal import pulse
+
+
+def view_baseline_plateau_and_curve(
+    x: np.ndarray,
+    y: np.ndarray,
+    title: str,
+    signal_type: Literal["step", "square"],
+    start_range: tuple[float, float],
+    end_range: tuple[float, float],
+    plateau_range: tuple[float, float] | None = None,
+    vcursors: dict[str, float] | None = None,
+    other_items: list | None = None,
+) -> None:
+    """Helper function to visualize signal with baselines and plateau.
+
+    Args:
+        x: X data.
+        y: Y data.
+        title: Title for the plot.
+        signal_type: Signal shape type
+        start_range: Start baseline range.
+        end_range: End baseline range.
+        plateau_range: Plateau range for square signals (optional).
+        vcursors: Dictionary of vertical cursors to display (optional).
+        other_items: Additional items to display (optional).
+    """
+    # pylint: disable=import-outside-toplevel
+    from plotpy.builder import make
+
+    from sigima.tests import vistools
+
+    ys = pulse.get_range_mean_y(x, y, start_range)
+    ye = pulse.get_range_mean_y(x, y, end_range)
+    xs0, xs1 = start_range
+    xe0, xe1 = end_range
+    items = [
+        make.mcurve(x, y, label="Noisy signal"),
+        vistools.create_signal_segment(xs0, ys, xs1, ys, "Start baseline"),
+        vistools.create_signal_segment(xe0, ye, xe1, ye, "End baseline"),
+    ]
+    if signal_type == "square":
+        if plateau_range is None:
+            polarity = pulse.detect_polarity(x, y, start_range, end_range)
+            plateau_range = pulse.get_plateau_range(x, y, polarity)
+        xp0, xp1 = plateau_range
+        yp = pulse.get_range_mean_y(x, y, plateau_range)
+        items.append(vistools.create_signal_segment(xp0, yp, xp1, yp, "Plateau"))
+    if vcursors is not None:
+        for label, xt in vcursors.items():
+            items.append(vistools.create_cursor("v", xt, label))
+    if other_items is not None:
+        items.extend(other_items)
+
+    vistools.view_curve_items(items, title=title)
+
+
+def view_pulse_features(
+    x: np.ndarray,
+    y: np.ndarray,
+    title: str,
+    signal_type: Literal["step", "square"],
+    features: pulse.PulseFeatures,
+) -> None:
+    """Helper function to visualize pulse features.
+
+    Args:
+        x: X data.
+        y: Y data.
+        title: Title for the plot.
+        signal_type: Signal shape type
+        features: Extracted pulse features.
+    """
+    # pylint: disable=import-outside-toplevel
+    from sigima.tests import vistools
+
+    params_text = "<br>".join(
+        [
+            f"<b>Extracted {signal_type} parameters:</b>",
+            f"Polarity: {features.polarity}",
+            f"Amplitude: {features.amplitude}",
+            f"Rise time: {features.rise_time}",
+            f"Fall time: {features.fall_time}",
+            f"FWHM: {features.fwhm}",
+            f"Offset: {features.offset}",
+            f"T50: {features.x50}",
+            f"X100: {features.x100}",
+            f"Foot duration: {features.foot_duration}",
+        ]
+    )
+    view_baseline_plateau_and_curve(
+        x,
+        y,
+        title,
+        signal_type,
+        [features.xstartmin, features.xstartmax],
+        [features.xendmin, features.xendmax],
+        plateau_range=None,
+        other_items=[vistools.create_label(params_text)],
+    )

sigima/tests/signal/pulse/crossing_times_unit_test.py

@@ -0,0 +1,123 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit tests for crossing time detection (x0, x50, x100) with real square pulse data.
+
+This test suite validates that the crossing time detection algorithm correctly
+identifies the x0 (0%), x50 (50%), and x100 (100%) crossing points in real-world
+square pulse signals.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from sigima.tests import guiutils
+from sigima.tests.data import get_test_signal
+from sigima.tests.helpers import check_scalar_result
+from sigima.tests.signal.pulse import view_baseline_plateau_and_curve
+from sigima.tools.signal import pulse
+
+# Test data configuration: (basename, (x0, x50, x100), (rtol0, rtol50, rtol100))
+# Note: x0 values have known issues (detecting crossings too early in the signal)
+# so we use very high tolerances. x50 is generally reliable, x100 varies by signal.
+CROSSING_TEST_DATA = [
+    ("boxcar.npy", (-1e-9, 2.5e-10, 2e-9), (20.0, 0.15, 0.5)),
+    ("square2.npy", (-3e-6, 6.5e-6, 1.65e-5), (20.0, 0.1, 5.0)),
+]
+
+
+@pytest.mark.parametrize("basename,expected_values,tolerances", CROSSING_TEST_DATA)
+def test_crossing_times(
+    basename: str,
+    expected_values: tuple[float, float, float],
+    tolerances: tuple[float, float, float],
+) -> None:
+    """Parametric test for crossing time detection on real square pulse data.
+
+    Args:
+        basename: Name of the test data file
+        expected_values: Expected (x0, x50, x100) crossing times
+        tolerances: Relative tolerances (rtol0, rtol50, rtol100) for each crossing
+
+    This test ensures that the crossing time detection algorithm correctly identifies
+    the 0%, 50%, and 100% crossing points within acceptable tolerances.
+    The test includes optional visualization when run with GUI enabled.
+
+    Note:
+        x0 detection has known issues and uses very high tolerances. This test
+        primarily validates that the algorithm doesn't crash and returns values
+        in the ballpark of expected results.
+    """
+    # Load real data
+    obj = get_test_signal(basename)
+    x, y = obj.x, obj.y
+
+    # Auto-detect ranges and polarity
+    start_range = pulse.get_start_range(x)
+    end_range = pulse.get_end_range(x)
+    polarity = pulse.detect_polarity(x, y, start_range, end_range)
+    plateau_range = pulse.get_plateau_range(x, y, polarity)
+
+    # Find crossing times
+    x0 = pulse.find_crossing_at_ratio(x, y, 0.0, start_range, end_range)
+    x50 = pulse.find_crossing_at_ratio(x, y, 0.5, start_range, end_range)
+    x100 = pulse.find_crossing_at_ratio(x, y, 1.0, start_range, end_range)
+
+    exp_x0, exp_x50, exp_x100 = expected_values
+    rtol0, rtol50, rtol100 = tolerances
+
+    with guiutils.lazy_qt_app_context() as qt_app:
+        title = (
+            f"{basename} - Crossing Times Test\n"
+            f"x0={x0:.3e} (exp: {exp_x0:.3e}), "
+            f"x50={x50:.3e} (exp: {exp_x50:.3e}), "
+            f"x100={x100:.3e} (exp: {exp_x100:.3e})"
+        )
+        if qt_app is not None:
+            # pylint: disable=import-outside-toplevel
+            from sigima.tests import vistools
+
+            # Create vertical markers for crossing times
+            items = []
+            items.append(vistools.create_cursor("v", x0, "x0 (detected)"))
+            items.append(vistools.create_cursor("v", exp_x0, "x0 (expected)"))
+            items.append(vistools.create_cursor("v", x50, "x50 (detected)"))
+            items.append(vistools.create_cursor("v", exp_x50, "x50 (expected)"))
+            items.append(vistools.create_cursor("v", x100, "x100 (detected)"))
+            items.append(vistools.create_cursor("v", exp_x100, "x100 (expected)"))
+
+            view_baseline_plateau_and_curve(
+                x,
+                y,
+                title,
+                "square",
+                start_range,
+                end_range,
+                plateau_range,
+                other_items=items,
+            )
+
+    # Validate crossing times with appropriate tolerances
+    # Note: We use very high tolerances for x0 due to known detection issues
+    assert x0 is not None, f"{basename}: x0 crossing not found"
+    assert x50 is not None, f"{basename}: x50 crossing not found"
+    assert x100 is not None, f"{basename}: x100 crossing not found"
+
+    # Check results
+    check_scalar_result("x0", x0, exp_x0, rtol0)
+    check_scalar_result("x50", x50, exp_x50, rtol50)
+    check_scalar_result("x100", x100, exp_x100, rtol100)
+
+
+def all_tests() -> None:
+    """Run all crossing time tests."""
+    for basename, expected_values, tolerances in CROSSING_TEST_DATA:
+        print(f"Testing {basename}...")
+        test_crossing_times(basename, expected_values, tolerances)
+        print(f"✓ {basename} passed\n")
+
+
+if __name__ == "__main__":
+    guiutils.enable_gui()
+    all_tests()

sigima/tests/signal/pulse/plateau_detection_unit_test.py

@@ -0,0 +1,102 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit tests for plateau detection algorithm with real square pulse data.
+
+This test suite validates that the plateau detection algorithm correctly identifies
+the plateau region in real-world square pulse signals.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from sigima.tests import guiutils
+from sigima.tests.data import get_test_signal
+from sigima.tests.signal.pulse import view_baseline_plateau_and_curve
+from sigima.tools.signal import pulse
+
+# Test data configuration: (basename, expected_interval)
+PLATEAU_TEST_DATA = [
+    ("boxcar.npy", (0.0, 1.4e-7)),  # Slightly wider to accommodate full plateau
+    ("square2.npy", (0.0, 2.4e-4)),  # Slightly wider to accommodate full plateau
+]
+
+
+@pytest.mark.parametrize("basename,expected_interval", PLATEAU_TEST_DATA)
+def test_plateau_detection(
+    basename: str, expected_interval: tuple[float, float]
+) -> None:
+    """Parametric test for plateau detection on real square pulse data.
+
+    Args:
+        basename: Name of the test data file
+        expected_interval: Expected (min, max) interval containing the plateau
+
+    This test ensures that the plateau detection algorithm correctly identifies
+    the plateau region within the expected interval for various real signals.
+    The test also includes optional visualization when run with GUI enabled.
+    """
+    # Load real data
+    obj = get_test_signal(basename)
+    x, y = obj.x, obj.y
+
+    # Auto-detect polarity and plateau
+    start_range = pulse.get_start_range(x)
+    end_range = pulse.get_end_range(x)
+    polarity = pulse.detect_polarity(x, y, start_range, end_range)
+    plateau_min, plateau_max = pulse.get_plateau_range(x, y, polarity)
+
+    expected_min, expected_max = expected_interval
+
+    with guiutils.lazy_qt_app_context() as qt_app:
+        title = (
+            f"{basename} - Plateau Detection Test\n"
+            f"Detected: [{plateau_min:.3e}, {plateau_max:.3e}]"
+        )
+        if qt_app is not None:
+            # pylint: disable=import-outside-toplevel
+            from sigima.tests import vistools
+
+            item = vistools.create_range(
+                "h",
+                expected_min,
+                expected_max,
+                "Expected plateau interval",
+            )
+            view_baseline_plateau_and_curve(
+                x,
+                y,
+                title,
+                "square",
+                start_range or pulse.get_start_range(x),
+                end_range or pulse.get_end_range(x),
+                (plateau_min, plateau_max),
+                other_items=[item],
+            )
+
+    # Validate plateau is within expected interval
+    assert plateau_min >= expected_min, (
+        f"{basename}: Plateau start {plateau_min:.3e} is before expected "
+        f"interval [{expected_min:.3e}, {expected_max:.3e}]"
+    )
+    assert plateau_max <= expected_max, (
+        f"{basename}: Plateau end {plateau_max:.3e} is after expected "
+        f"interval [{expected_min:.3e}, {expected_max:.3e}]"
+    )
+    assert plateau_min < plateau_max, (
+        f"{basename}: Invalid plateau range [{plateau_min:.3e}, {plateau_max:.3e}]"
+    )
+
+
+def all_tests() -> None:
+    """Run all plateau detection tests."""
+    for basename, expected_interval in PLATEAU_TEST_DATA:
+        print(f"Testing {basename}...")
+        test_plateau_detection(basename, expected_interval)
+        print(f"✓ {basename} passed\n")
+
+
+if __name__ == "__main__":
+    guiutils.enable_gui()
+    all_tests()