isgri 0.2.0__tar.gz → 0.3.0__tar.gz

isgri-0.3.0/.python-version

@@ -0,0 +1 @@
+3.10

{isgri-0.2.0 → isgri-0.3.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: isgri
-Version: 0.2.0
+Version: 0.3.0
 Summary: Python package for INTEGRAL IBIS/ISGRI lightcurve analysis
 Author: Dominik Patryk Pacholski
 License: MIT
 License-File: LICENSE
 Requires-Python: >=3.10
-Requires-Dist: astropy>=7.2.0
-Requires-Dist: numpy>=2.3.5
+Requires-Dist: astropy
+Requires-Dist: numpy
 Description-Content-Type: text/markdown
 
 # isgri

{isgri-0.2.0 → isgri-0.3.0}/demo/lightcurve_walkthrough.ipynb

@@ -243,7 +243,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 3,
    "id": "69106f8b",
    "metadata": {},
    "outputs": [
@@ -251,11 +251,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Raw chisq reduced: 8.11\n",
-      "Clipped chisq reduced: 0.82\n",
-      "GTI chisq reduced: 8.05\n",
-      "Module variability: [ 1.7798905  1.9385959  9.868956  10.112125  10.713058  11.080585\n",
-      "  9.421991   9.954155 ]\n"
+      "Raw chisq reduced: 10.04\n",
+      "Clipped chisq reduced: 1.00\n",
+      "GTI chisq reduced: 10.03\n",
+      "Module variability: (array([ 6359.549,  6926.603, 35261.777, 36130.625, 38277.758, 39590.93 ,\n",
+      "       33664.773, 35566.195], dtype=float32), array([2942, 3025, 3567, 3568, 3568, 3568, 3568, 3567]), array([ 6185.0806,  6649.9795, 91052.58  , 93023.62  , 97074.28  ,\n",
+      "       96712.97  , 91139.47  , 85202.89  ], dtype=float32))\n"
      ]
     }
    ],
@@ -389,7 +390,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.3"
+   "version": "3.10.19"
   }
  },
  "nbformat": 4,

{isgri-0.2.0 → isgri-0.3.0}/pyproject.toml

@@ -4,15 +4,15 @@ build-backend = "hatchling.build"
 
 [project]
 name = "isgri"
-version = "0.2.0"
+version = "0.3.0"
 authors = [{name = "Dominik Patryk Pacholski"}]
 license = {text = "MIT"}
 description = "Python package for INTEGRAL IBIS/ISGRI lightcurve analysis"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "numpy>=2.3.5",
-    "astropy>=7.2.0",
+    "numpy",
+    "astropy",
 ]
 
 [tool.setuptools.packages.find]

{isgri-0.2.0 → isgri-0.3.0}/src/isgri/utils/quality.py

@@ -62,7 +62,7 @@ class QualityMetrics:
         time, counts = self.lightcurve.rebin_by_modules(
             binsize=self.binsize, emin=self.emin, emax=self.emax, local_time=self.local_time
         )
-        module_data = {"time": time, "counts": counts}
+        module_data = {"time": time, "counts": np.asarray(counts)}
         self.module_data = module_data
         return module_data
 
@@ -71,20 +71,36 @@ class QualityMetrics:
         Compute reduced chi-squared for count data.
 
         Args:
-            counts (ndarray): Count array(s) to analyze.
-            return_all (bool, optional): If True, returns chi-squared for each array. If False, returns mean. Defaults to False.
+            counts (ndarray): Count array(s) to analyze. Shape: (n_modules, n_bins) or (n_bins,)
+            return_all (bool, optional): If True, returns detailed results. If False, returns weighted mean. Defaults to False.
 
         Returns:
-            float or ndarray: Reduced chi-squared value(s).
+            If return_all=False:
+                float: Weighted mean chi-squared (weighted by total counts per module)
+            If return_all=True:
+                tuple: (chi_squared, dof, no_counts) where:
+                    - chi_squared: Raw chi-squared values per module
+                    - dof: Degrees of freedom per module (n_bins - 1 excluding NaN)
+                    - no_counts: Total counts per module
         """
         counts = np.asarray(counts)
         counts = np.where(counts == 0, np.nan, counts)
         mean_counts = np.nanmean(counts, axis=-1, keepdims=True)
         chi_squared = np.nansum((counts - mean_counts) ** 2 / mean_counts, axis=-1)
-        dof = counts.shape[-1] - 1
+
+        # DOF = number of non-empty bins minus 1
+        nan_mask = ~np.isnan(counts)
+        dof = np.sum(nan_mask, axis=-1) - 1
+        no_counts = np.nansum(counts, axis=-1)
+
         if return_all:
-            return chi_squared / dof
-        return np.nanmean(chi_squared / dof)
+            return chi_squared, dof, no_counts
+
+        if np.sum(no_counts) == 0 or np.all(dof <= 0):
+            return np.nan
+        
+        # Weight by total counts per module
+        return np.average(chi_squared / dof, weights=no_counts)
 
     def raw_chi_squared(self, counts=None, return_all=False):
         """

{isgri-0.2.0 → isgri-0.3.0}/tests/utils/test_lightcurve.py

@@ -219,3 +219,70 @@ def test_lightcurve_rebin_with_custom_mask(mock_events_file):
     time_full, counts_full = lc.rebin(binsize=1.0, emin=30, emax=300)
 
     assert np.sum(counts_masked) < np.sum(counts_full)
+
+
+def test_lightcurve_module_assignment():
+    """Test that events are correctly assigned to detector modules."""
+    # Create synthetic events with DIFFERENT counts per module to verify assignment
+    module_counts_expected = [10, 25, 50, 75, 100, 125, 150, 200]  # Different for each module
+    n_events = sum(module_counts_expected)
+
+    events = np.zeros(
+        n_events,
+        dtype=[
+            ("TIME", "f8"),
+            ("ISGRI_ENERGY", "f4"),
+            ("DETY", "i2"),
+            ("DETZ", "i2"),
+            ("SELECT_FLAG", "i2"),
+        ],
+    )
+
+    # Module layout: 0 1
+    #                2 3
+    #                4 5
+    #                6 7
+    module_positions = [
+        (16, 32),  # Module 0: DETZ [0-32),   DETY [0-64)
+        (16, 96),  # Module 1: DETZ [0-32),   DETY [64-130)
+        (48, 32),  # Module 2: DETZ [32-66),  DETY [0-64)
+        (48, 96),  # Module 3: DETZ [32-66),  DETY [64-130)
+        (80, 32),  # Module 4: DETZ [66-100), DETY [0-64)
+        (80, 96),  # Module 5: DETZ [66-100), DETY [64-130)
+        (116, 32),  # Module 6: DETZ [100-134), DETY [0-64)
+        (116, 96),  # Module 7: DETZ [100-134), DETY [64-130)
+    ]
+
+    idx = 0
+    for module_no, (detz, dety) in enumerate(module_positions):
+        n_events_module = module_counts_expected[module_no]
+
+        events["DETZ"][idx : idx + n_events_module] = detz
+        events["DETY"][idx : idx + n_events_module] = dety
+        events["TIME"][idx : idx + n_events_module] = np.linspace(0, 10 / 86400, n_events_module)
+        events["ISGRI_ENERGY"][idx : idx + n_events_module] = 100  # All same energy
+        events["SELECT_FLAG"][idx : idx + n_events_module] = 0
+
+        idx += n_events_module
+
+    # Create LightCurve
+    time = events["TIME"]
+    energies = events["ISGRI_ENERGY"]
+    dety = events["DETY"]
+    detz = events["DETZ"]
+    gtis = np.array([[time[0], time[-1]]])
+    weights = np.ones(n_events)
+    metadata = {}
+
+    lc = LightCurve(time, energies, gtis, dety, detz, weights, metadata)
+
+    # Rebin by modules (1 bin covering all time)
+    times, counts = lc.rebin_by_modules(binsize=20.0, emin=50, emax=200, local_time=True)
+
+    # Verify each module has the expected count
+    for module_no, expected_count in enumerate(module_counts_expected):
+        actual_count = counts[module_no][0]
+        assert actual_count == expected_count, (
+            f"Module {module_no} at position {module_positions[module_no]}: "
+            f"expected {expected_count} counts, got {actual_count}"
+        )

isgri-0.3.0/tests/utils/test_quality.py

@@ -0,0 +1,268 @@
+import pytest
+import numpy as np
+from isgri.utils.quality import QualityMetrics
+from isgri.utils.lightcurve import LightCurve
+
+
+@pytest.fixture
+def mock_lightcurve():
+    """Create a simple mock LightCurve for testing."""
+    n_events = 1000
+    time = np.linspace(0, 100 / 86400, n_events)
+    energies = np.random.uniform(30, 300, n_events)
+    gtis = np.array([[time[0], time[-1]]])
+    dety = np.random.randint(0, 128, n_events)
+    detz = np.random.randint(0, 134, n_events)
+    weights = np.ones(n_events)
+    metadata = {"SWID": "test"}
+
+    return LightCurve(time, energies, gtis, dety, detz, weights, metadata)
+
+
+def test_quality_metrics_init():
+    """Test QualityMetrics initialization."""
+    qm = QualityMetrics(binsize=1.0, emin=30, emax=300)
+
+    assert qm.lightcurve is None
+    assert qm.binsize == 1.0
+    assert qm.emin == 30
+    assert qm.emax == 300
+    assert qm.local_time is False
+    assert qm.module_data is None
+
+
+def test_quality_metrics_init_with_lightcurve(mock_lightcurve):
+    """Test QualityMetrics initialization with LightCurve."""
+    qm = QualityMetrics(mock_lightcurve, binsize=1.0, emin=30, emax=300)
+
+    assert qm.lightcurve is not None
+    assert isinstance(qm.lightcurve, LightCurve)
+
+
+def test_quality_metrics_init_invalid_type():
+    """Test QualityMetrics raises error for invalid lightcurve type."""
+    with pytest.raises(TypeError):
+        QualityMetrics(lightcurve="not_a_lightcurve")
+
+
+def test_compute_counts_without_lightcurve():
+    """Test _compute_counts raises error when lightcurve is None."""
+    qm = QualityMetrics()
+
+    with pytest.raises(ValueError, match="Lightcurve is not set"):
+        qm._compute_counts()
+
+
+def test_compute_counts_caching(mock_lightcurve):
+    """Test that _compute_counts caches results."""
+    qm = QualityMetrics(mock_lightcurve, binsize=1.0, emin=30, emax=300)
+
+    data1 = qm._compute_counts()
+    data2 = qm._compute_counts()
+
+    assert data1 is data2
+    assert "time" in data1
+    assert "counts" in data1
+
+
+def test_chi_squared_constant_lightcurve():
+    """Test chi-squared for constant lightcurve."""
+    counts = np.ones(100) * 10.0
+    qm = QualityMetrics()
+
+    chi = qm.raw_chi_squared(counts=counts)
+
+    assert chi < 0.1
+
+
+def test_chi_squared_poisson_lightcurve():
+    """Test chi-squared for Poisson-distributed data."""
+    np.random.seed(42)
+    counts = np.random.poisson(10, 1000)
+    qm = QualityMetrics()
+
+    chi = qm.raw_chi_squared(counts=counts)
+
+    assert 0.7 < chi < 1.3
+
+
+def test_chi_squared_variable_lightcurve():
+    """Test chi-squared for highly variable lightcurve."""
+    counts = np.concatenate([np.ones(50) * 5, np.ones(50) * 50])
+    qm = QualityMetrics()
+
+    chi = qm.raw_chi_squared(counts=counts)
+
+    assert chi > 2.0
+
+
+def test_chi_squared_1d_vs_2d():
+    """Test chi-squared handles both 1D and 2D arrays."""
+    np.random.seed(42)
+    counts_1d = np.random.poisson(10, 100)
+    counts_2d = np.random.poisson(10, (8, 100))
+
+    qm = QualityMetrics()
+    chi_1d = qm.raw_chi_squared(counts=counts_1d)
+    chi_2d = qm.raw_chi_squared(counts=counts_2d)
+
+    assert isinstance(chi_1d, (float, np.floating))
+    assert isinstance(chi_2d, (float, np.floating))
+
+
+def test_chi_squared_return_all():
+    """Test chi-squared with return_all=True."""
+    np.random.seed(42)
+    counts = np.random.poisson(10, (8, 100))
+    qm = QualityMetrics()
+
+    chi, dof, no_counts = qm.raw_chi_squared(counts=counts, return_all=True)
+
+    assert chi.shape == (8,)
+    assert dof.shape == (8,)
+    assert no_counts.shape == (8,)
+    assert np.all(dof == 99)
+    assert np.all(no_counts > 0)
+
+
+def test_chi_squared_with_zeros():
+    """Test chi-squared handles zero counts."""
+    counts = np.array([10, 10, 0, 10, 10])
+    qm = QualityMetrics()
+
+    chi = qm.raw_chi_squared(counts=counts)
+
+    assert np.isfinite(chi)
+    assert chi < 0.5
+
+
+def test_sigma_clip_removes_outliers():
+    """Test sigma clipping removes outliers."""
+    counts = np.ones(100) * 10.0
+    counts[50] = 100.0
+
+    qm = QualityMetrics()
+    chi_raw = qm.raw_chi_squared(counts=counts)
+    chi_clipped = qm.sigma_clip_chi_squared(counts=counts, sigma=3.0)
+
+    assert chi_clipped < chi_raw
+    assert chi_clipped < 0.5
+
+
+def test_sigma_clip_different_thresholds():
+    """Test different sigma thresholds."""
+    np.random.seed(42)
+    counts = np.random.poisson(10, 100)
+    counts[50] = 100
+
+    qm = QualityMetrics()
+    chi_1sigma = qm.sigma_clip_chi_squared(counts=counts, sigma=1.0)
+    chi_3sigma = qm.sigma_clip_chi_squared(counts=counts, sigma=3.0)
+
+    assert chi_1sigma <= chi_3sigma
+
+
+def test_sigma_clip_2d_arrays():
+    """Test sigma clipping works with 2D arrays."""
+    np.random.seed(42)
+    counts = np.random.poisson(10, (8, 100))
+    counts[:, 50] = 100
+
+    qm = QualityMetrics()
+    chi_raw = qm.raw_chi_squared(counts=counts)
+    chi_clipped = qm.sigma_clip_chi_squared(counts=counts, sigma=3.0)
+
+    assert chi_clipped < chi_raw
+
+
+def test_gti_chi_squared_filters_correctly(mock_lightcurve):
+    """Test GTI filtering applies correctly."""
+    qm = QualityMetrics(mock_lightcurve, binsize=1.0, emin=30, emax=300, local_time=False)
+
+    chi = qm.gti_chi_squared()
+
+    assert np.isfinite(chi)
+    assert chi > 0
+
+
+def test_gti_chi_squared_no_overlap():
+    """Test GTI chi-squared raises error when no overlap."""
+    np.random.seed(42)
+    time = np.linspace(0, 100, 100)
+    counts = np.random.poisson(10, (8, 100))
+    gtis = np.array([[200, 300]])
+
+    qm = QualityMetrics()
+
+    with pytest.raises(ValueError, match="No overlap"):
+        qm.gti_chi_squared(time=time, counts=counts, gtis=gtis)
+
+
+def test_gti_chi_squared_custom_gtis():
+    """Test GTI chi-squared with custom GTI array."""
+    np.random.seed(42)
+    time = np.linspace(0, 100, 100)
+    counts = np.random.poisson(10, (8, 100))
+    gtis = np.array([[0, 50], [75, 100]])
+
+    qm = QualityMetrics()
+    chi = qm.gti_chi_squared(time=time, counts=counts, gtis=gtis)
+
+    assert np.isfinite(chi)
+    assert chi > 0
+
+
+def test_gti_chi_squared_return_all():
+    """Test GTI chi-squared with return_all=True."""
+    np.random.seed(42)
+    time = np.linspace(0, 100, 100)
+    counts = np.random.poisson(10, (8, 100))
+    gtis = np.array([[0, 100]])
+
+    qm = QualityMetrics()
+    chi, dof, no_counts = qm.gti_chi_squared(time=time, counts=counts, gtis=gtis, return_all=True)
+
+    assert chi.shape == (8,)
+    assert dof.shape == (8,)
+    assert no_counts.shape == (8,)
+
+
+def test_chi_squared_weighting():
+    """Test chi-squared weighting by total counts."""
+    counts = np.array(
+        [
+            np.concatenate([np.ones(50) * 5, np.ones(50) * 50]),
+            np.ones(100) * 100,
+        ]
+    )
+
+    qm = QualityMetrics()
+    chi_weighted = qm.raw_chi_squared(counts=counts)
+    chi_1, chi_2 = qm.raw_chi_squared(counts=counts, return_all=True)[0]
+
+    # Weighted average closer to high-count module
+    assert abs(chi_weighted - chi_2) < abs(chi_weighted - chi_1)
+
+
+def test_chi_squared_all_nan():
+    """Test chi-squared handles all-NaN arrays."""
+    counts = np.full(100, np.nan)
+    qm = QualityMetrics()
+
+    chi = qm.raw_chi_squared(counts=counts)
+
+    assert np.isnan(chi)
+
+
+def test_integration_with_real_lightcurve(mock_lightcurve):
+    """Test full workflow with real LightCurve."""
+    qm = QualityMetrics(mock_lightcurve, binsize=1.0, emin=30, emax=300, local_time=False)
+
+    chi_raw = qm.raw_chi_squared()
+    chi_clipped = qm.sigma_clip_chi_squared(sigma=3.0)
+    chi_gti = qm.gti_chi_squared()
+
+    assert np.isfinite(chi_raw)
+    assert np.isfinite(chi_clipped)
+    assert np.isfinite(chi_gti)
+    assert qm.module_data is not None

isgri-0.2.0/tests/utils/test_quality.py

@@ -1,39 +0,0 @@
-import pytest
-import numpy as np
-from isgri.utils.quality import QualityMetrics
-
-
-def test_quality_metrics_init():
-    """Test QualityMetrics initialization."""
-    qm = QualityMetrics(binsize=1.0, emin=30, emax=300)
-    assert qm.lightcurve is None
-    assert qm.binsize == 1.0
-
-def test_chi_squared_raw_constant():
-    """Test chi-squared for constant lightcurve (should be ~0)."""
-    counts = np.ones(100) * 10
-    qm = QualityMetrics()
-    chi = qm.raw_chi_squared(counts=counts)
-    assert chi < 0.1  # Should be very small
-
-
-def test_chi_squared_raw_poisson():
-    """Test chi-squared for Poisson-like data."""
-    np.random.seed(42)
-    counts = np.random.poisson(10, 100)
-    qm = QualityMetrics()
-    chi = qm.raw_chi_squared(counts=counts)
-    assert 0.5 < chi < 2.0  # Should be ~1 for Poisson
-
-
-def test_chi_squared_clipped():
-    """Test sigma-clipped chi-squared removes outliers."""
-    counts = np.ones(100) * 10
-    counts[50] = 100  # Add outlier
-    
-    qm = QualityMetrics()
-    chi_raw = qm.raw_chi_squared(counts=counts)
-    chi_clipped = qm.sigma_clip_chi_squared(counts=counts, sigma=3.0)
-    
-    assert chi_clipped < chi_raw  # Clipped should be smaller
-