PycWB 1.0.0a1__tar.gz → 1.0.0a2__tar.gz

{pycwb-1.0.0a1 → pycwb-1.0.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PycWB
-Version: 1.0.0a1
+Version: 1.0.0a2
 Summary: A Python package for coherent gravitational wave burst analysis
 Author-email: The PycWB team <yumeng.xu@ligo.org>
 License: GPL-3.0-or-later

{pycwb-1.0.0a1 → pycwb-1.0.0a2}/PycWB.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PycWB
-Version: 1.0.0a1
+Version: 1.0.0a2
 Summary: A Python package for coherent gravitational wave burst analysis
 Author-email: The PycWB team <yumeng.xu@ligo.org>
 License: GPL-3.0-or-later

{pycwb-1.0.0a1 → pycwb-1.0.0a2}/PycWB.egg-info/SOURCES.txt

@@ -354,6 +354,7 @@ pycwb/modules/catalog/module.yaml
 pycwb/modules/catalog/tests/__init__.py
 pycwb/modules/catalog/tests/test_remove_stale_triggers.py
 pycwb/modules/catalog/tests/test_triggers_deduplicate.py
+pycwb/modules/catalog/tests/test_write_table_atomic_permissions.py
 pycwb/modules/coherence/__init__.py
 pycwb/modules/coherence/coherence.py
 pycwb/modules/coherence/coherence_lite.py

{pycwb-1.0.0a1 → pycwb-1.0.0a2}/pycwb/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.0a1'
-__version_tuple__ = version_tuple = (1, 0, 0, 'a1')
+__version__ = version = '1.0.0a2'
+__version_tuple__ = version_tuple = (1, 0, 0, 'a2')
 
-__commit_id__ = commit_id = 'g880416389'
+__commit_id__ = commit_id = 'g979003768'

{pycwb-1.0.0a1 → pycwb-1.0.0a2}/pycwb/modules/catalog/catalog.py

@@ -125,6 +125,13 @@ def _write_table_atomic(table: pa.Table, filename: str, compression: str = "snap
     os.makedirs(target_dir, exist_ok=True)
 
     fd, tmp_path = tempfile.mkstemp(prefix=".catalog_tmp_", suffix=".parquet", dir=target_dir)
+    # mkstemp creates files with mode 0o600, bypassing the system umask.
+    # Restore umask-respecting permissions so catalog files are group/world
+    # readable as expected (equivalent to what a normal open(O_CREAT, 0666)
+    # would produce after the umask is applied).
+    _umask = os.umask(0)
+    os.umask(_umask)
+    os.fchmod(fd, 0o666 & ~_umask)
     os.close(fd)
     try:
         pq.write_table(table, tmp_path, compression=compression)

pycwb-1.0.0a2/pycwb/modules/catalog/tests/test_write_table_atomic_permissions.py

@@ -0,0 +1,94 @@
+"""Unit tests for permission handling in ``_write_table_atomic``."""
+import os
+import stat
+import tempfile
+import unittest
+
+import pyarrow as pa
+
+from pycwb.modules.catalog.catalog import _write_table_atomic
+
+
+def _simple_table() -> pa.Table:
+    return pa.table({"x": pa.array([1, 2, 3], type=pa.int32())})
+
+
+class TestWriteTableAtomicPermissions(unittest.TestCase):
+    """_write_table_atomic must respect the process umask, not fix at 0o600."""
+
+    def _file_mode(self, path: str) -> int:
+        return stat.S_IMODE(os.stat(path).st_mode)
+
+    def _call_with_umask(self, umask: int) -> int:
+        """Write a table with a specific umask and return the resulting file mode."""
+        with tempfile.TemporaryDirectory() as d:
+            dest = os.path.join(d, "catalog.parquet")
+            old_umask = os.umask(umask)
+            try:
+                _write_table_atomic(_simple_table(), dest)
+            finally:
+                os.umask(old_umask)
+            return self._file_mode(dest)
+
+    def test_permissions_with_umask_022(self):
+        """File mode should be 0o644 when umask is 0o022."""
+        mode = self._call_with_umask(0o022)
+        expected = 0o666 & ~0o022  # 0o644
+        self.assertEqual(
+            mode, expected,
+            f"Expected 0o{expected:03o} but got 0o{mode:03o} (umask=0o022)",
+        )
+
+    def test_permissions_with_umask_002(self):
+        """File mode should be 0o664 when umask is 0o002."""
+        mode = self._call_with_umask(0o002)
+        expected = 0o666 & ~0o002  # 0o664
+        self.assertEqual(
+            mode, expected,
+            f"Expected 0o{expected:03o} but got 0o{mode:03o} (umask=0o002)",
+        )
+
+    def test_permissions_with_umask_077(self):
+        """File mode should be 0o600 when umask is 0o077."""
+        mode = self._call_with_umask(0o077)
+        expected = 0o666 & ~0o077  # 0o600
+        self.assertEqual(
+            mode, expected,
+            f"Expected 0o{expected:03o} but got 0o{mode:03o} (umask=0o077)",
+        )
+
+    def test_permissions_not_hardcoded_600(self):
+        """File mode must NOT be 0o600 when umask allows more permissions."""
+        mode = self._call_with_umask(0o022)
+        self.assertNotEqual(
+            mode, 0o600,
+            "File mode was 0o600, indicating mkstemp permissions were not corrected.",
+        )
+
+    def test_no_temp_file_left_after_success(self):
+        """No temporary .catalog_tmp_* files should remain after a successful write."""
+        with tempfile.TemporaryDirectory() as d:
+            dest = os.path.join(d, "catalog.parquet")
+            _write_table_atomic(_simple_table(), dest)
+            tmp_files = [
+                f for f in os.listdir(d) if f.startswith(".catalog_tmp_")
+            ]
+            self.assertEqual(tmp_files, [], f"Stale temp files found: {tmp_files}")
+
+    def test_destination_file_created(self):
+        """The destination file must exist after a successful write."""
+        with tempfile.TemporaryDirectory() as d:
+            dest = os.path.join(d, "catalog.parquet")
+            _write_table_atomic(_simple_table(), dest)
+            self.assertTrue(os.path.exists(dest))
+
+    def test_destination_dir_created(self):
+        """Parent directory is created if it does not exist."""
+        with tempfile.TemporaryDirectory() as d:
+            dest = os.path.join(d, "nested", "subdir", "catalog.parquet")
+            _write_table_atomic(_simple_table(), dest)
+            self.assertTrue(os.path.exists(dest))
+
+
+if __name__ == "__main__":
+    unittest.main()

{pycwb-1.0.0a1 → pycwb-1.0.0a2}/pycwb/modules/injection/sky_distribution.py

@@ -125,8 +125,12 @@ def distribute_injections_on_sky(injections, sky_locations, shuffle=True, coords
 
     # shuffle the sky locations
     if shuffle:
-        np.random.shuffle(phi)
-        np.random.shuffle(theta)
+        coords = np.column_stack((phi, theta))
+        np.random.shuffle(coords)
+
+        theta = coords[:, 1]
+        phi = coords[:, 0]
+
 
     if coordsys == 'icrs':
         # If the coordinate system is ICRS, save the sky location directly in ra and dec attributes

{pycwb-1.0.0a1 → pycwb-1.0.0a2}/pycwb/modules/likelihoodWP/dpf.py

@@ -64,7 +64,7 @@ def avx_dpf_ps(Fp0, Fx0, rms):
         ss = si ** 2
         nn = sqrt(cc + ss)  # co/si norm
         fp = (AP + nn) / 2  # |f+|^2
-        cc = co / (nn + 0.0001)  # cos(2p)
+        cc = co / (nn + 1e-9)  # cos(2p)
         ss = 1 if si > 0 else -1  # 1 if sin(2p)>0. or-1 if sin(2p)<0.
         si = sqrt((1 - cc) / 2)  # |sin(p)|
         co = sqrt((1 + cc) / 2)  # |cos(p)|
@@ -75,13 +75,13 @@ def avx_dpf_ps(Fp0, Fx0, rms):
         nn = np.dot(_cc, _cc)
         fF = np.dot(f, F)
 
-        fF = fF / (fp + 0.0001)
+        fF = fF / (fp + 1e-9)
 
         F -= f * fF
         fx = np.dot(F, F)
 
-        ni = nn / (fp ** 2 + 0.0001)  # network index
-        ff = ni + 0.0001  # network index
+        ni = nn / (fp ** 2 + 1e-9)  # network index
+        ff = ni + 1e-9  # network index
         NI += fx / ff  # sum of |fx|^2/2/ni
         NN += 1 if fp > 0 else 0  # pixel count
 
@@ -108,7 +108,7 @@ def dpf_np_loops_local(Fp0, Fx0, rms):
     ni = np.zeros(NPIX, dtype=np.float32)
 
     # Prepare constants
-    _o = np.float32(0.0001)
+    _o = np.float32(1e-9)
     # _0 = np.float32(0)
     # _2 = np.float32(2)
     # _1 = np.float32(1)
@@ -202,7 +202,7 @@ def dpf_np_loops(Fp0, Fx0, rms):
         AP[i] = ff[i] + FF[i]
         nn[i] = sqrt(co[i] * co[i] + si[i] * si[i])
         fp[i] = (AP[i] + nn[i]) / 2
-        cc[i] = co[i] / (nn[i] + 0.0001)
+        cc[i] = co[i] / (nn[i] + 1e-9)
         si[i], co[i] = sqrt((1 - cc[i]) / 2), sqrt((1 + cc[i]) / 2) * (1 if si[i] > 0 else -1)
 
     # Compute f_new, F_new, fF_new, F_new, fx, ni
@@ -210,7 +210,7 @@ def dpf_np_loops(Fp0, Fx0, rms):
         for j in range(NIFO):
             f[i, j], F[i, j] = f[i, j] * co[i] + F[i, j] * si[i], F[i, j] * co[i] - f[i, j] * si[i]
             fF_new[i] += f[i, j] * F[i, j]
-        fF_new[i] /= (fp[i] + 0.0001)
+        fF_new[i] /= (fp[i] + 1e-9)
         for j in range(NIFO):
             F[i, j] -= f[i, j] * fF_new[i]
             fx[i] += F[i, j] * F[i, j]
@@ -220,8 +220,8 @@ def dpf_np_loops(Fp0, Fx0, rms):
     NI = 0
     NN = 0
     for i in range(NPIX):
-        ni[i] /= (fp[i] * fp[i] + 0.0001)
-        NI += fx[i] / (ni[i] + 0.0001)
+        ni[i] /= (fp[i] * fp[i] + 1e-9)
+        NI += fx[i] / (ni[i] + 1e-9)
         NN += 1 if fp[i] > 0 else 0
 
     return sqrt(NI / (NN + 0.01)), fp, fx, si, co, ni
@@ -250,20 +250,20 @@ def dpf_np(Fp0, Fx0, rms):
 
     nn = np.sqrt(co * co + si * si)  # co/si norm
     fp = (AP + nn) / 2  # |f+|^2
-    cc = co / (nn + 0.0001)  # cos(2p)
+    cc = co / (nn + 1e-9)  # cos(2p)
     si, co = np.sqrt((1 - cc) / 2), np.sqrt((1 + cc) / 2) * np.where(si > 0, 1, -1)
 
     f, F = f * co[:, np.newaxis] + F * si[:, np.newaxis], F * co[:, np.newaxis] - f * si[:, np.newaxis]
 
-    fF = (f * F).sum(axis=1) / (fp + 0.0001)
+    fF = (f * F).sum(axis=1) / (fp + 1e-9)
 
     F -= f * fF[:, None]
 
     fx = (F * F).sum(axis=1)
 
-    ni = (f ** 4).sum(axis=1) / (fp * fp + 0.0001)  # network index
+    ni = (f ** 4).sum(axis=1) / (fp * fp + 1e-9)  # network index
 
-    NI = (fx / (ni + 0.0001)).sum()  # sum of |fx|^2/2/ni
+    NI = (fx / (ni + 1e-9)).sum()  # sum of |fx|^2/2/ni
 
     NN = (fp > 0).sum()  # pixel count
 
@@ -277,7 +277,7 @@ def mul_vec(a, b):
 
 @vectorize([float32(float32, float32)])
 def div_vec(a, b):
-    _o = float32(0.0001)
+    _o = float32(1e-9)
     return a / (b + _o)
 
 
@@ -386,7 +386,7 @@ def dpf_np_loops_vec(Fp0, Fx0, rms):
     fx = np.zeros(NPIX, dtype=np.float32)
     ni = np.zeros(NPIX, dtype=np.float32)
 
-    _o = float32(0.0001)
+    _o = float32(1e-9)
 
     # Prepare constants
     # NI = np.float32(0.0)
@@ -414,7 +414,7 @@ def dpf_np_loops_vec(Fp0, Fx0, rms):
         _co = sub_vec(_ff, _FF)          # rotation (cos^2-sin^2)*norm
         _AP = add_vec(_ff, _FF)          # total antenna norm
         _nn = norm_vec(_co, _si)         # co/si norm    np.sqrt(_co * _co + _si * _si)
-        _cc = div_vec(_co, _nn)          # cos(2p)       _co / (_nn + 0.0001)
+        _cc = div_vec(_co, _nn)          # cos(2p)       _co / (_nn + 1e-9)
         fp[i] = avg_vec(_AP, _nn)        # |f+|^2        (_AP + _nn) / 2.
         si[i] = sin_from_cc(_cc)         # |sin(p)|      sqrt((1. - _cc) / 2.)
         co[i] = cos_from_cc(_cc, _si)    # cos(p)        (sqrt((1. + _cc) / 2.) if _si > 0.0 else - sqrt((1. + _cc) / 2.))

{pycwb-1.0.0a1 → pycwb-1.0.0a2}/pycwb/modules/likelihoodWP/likelihood.py

@@ -455,6 +455,15 @@ def likelihood(
     skymap_statistics = SkyMapStatistics.from_tuple(skymap_statistics)
     stage_timings["sky_scan"] = time.perf_counter() - _t0
 
+    if skymap_statistics.sky_stat_max <= 0.0:
+        logger.info("Cluster rejected: non-positive sky_stat_max=%.3f", skymap_statistics.sky_stat_max)
+        stage_timings["total"] = time.perf_counter() - timer_start
+        logger.info("-------------------------------------------------------")
+        logger.info("Total events: %d", 0)
+        logger.info("Total time: %.2f s", stage_timings["total"])
+        logger.info("-------------------------------------------------------")
+        return None, None
+
     # --- Compute normalised sky probability map (softmax over nSkyStat) ---
     _t0 = time.perf_counter()
     _sky_stat_f64 = skymap_statistics.nSkyStat.astype(np.float64)
@@ -479,8 +488,8 @@ def likelihood(
     # calculate sky statistics for the cluster at the optimal sky location l_max,
     # dozens of parameters will be returned in SkyStatistics dataclass
     _t0 = time.perf_counter()
-    sky_statistics: SkyStatistics = calculate_sky_statistics(skymap_statistics.l_max, nIFO, n_pix, 
-                                                             FP, FX, rms, td00, td90, ml, REG, 
+    sky_statistics: SkyStatistics = calculate_sky_statistics(skymap_statistics.l_max, nIFO, n_pix,
+                                                             FP, FX, rms, td00, td90, ml, REG,
                                                              network_energy_threshold,
                                                              cluster_xtalk, cluster_xtalk_lookup,
                                                              xgb_rho_mode=xgb_rho_mode)
@@ -786,7 +795,7 @@ def find_optimal_sky_localization(n_ifo, n_pix, n_sky, FP, FX, rms, td00, td90,
         cc = CH if CH > float(1.0) else 1.0  # noise correction factor in TF domain
         Co = Ec / (Ec + No * cc - Mo * (n_ifo - 1))  # network correlation coefficient in TF
 
-        if Cr < netCC:
+        if not np.isfinite(Cr) or Cr < netCC:
             continue
 
         # --- Sky statistics: likelihood and cross-correlation ---
@@ -823,16 +832,16 @@ def find_optimal_sky_localization(n_ifo, n_pix, n_sky, FP, FX, rms, td00, td90,
     # Mirror C++ tie-breaking: C++ uses `if (AA >= STAT)` in a forward loop,
     # so the LAST pixel with the maximum value wins on ties.
     # Iterate only over valid (unmasked) indices to match C++ behaviour.
-    STAT = np.float32(-1.e12)
+    sky_stat_max = 0
     l_max = int(sky_valid_indices[0])
     for _k in range(n_valid):
         _l = sky_valid_indices[_k]
-        if AA_array[_l] >= STAT:
-            STAT = AA_array[_l]
+        if AA_array[_l] >= sky_stat_max:
+            sky_stat_max = AA_array[_l]
             l_max = _l
 
     return (l_max, nAntenaPrior, nAlignment, nLikelihood, nNullEnergy, nCorrEnergy, \
-              nCorrelation, nSkyStat, nDisbalance, nNetIndex, nEllipticity, nPolarisation)
+              nCorrelation, nSkyStat, nDisbalance, nNetIndex, nEllipticity, nPolarisation, sky_stat_max)
 
 
 def calculate_sky_statistics(
@@ -974,7 +983,11 @@ def calculate_sky_statistics(
     else:  # XGB.rho0
         penalty = ch
         ecor = Ec
-        rho = np.sqrt(ecor / (1 + penalty * (max(float(1), penalty) - 1)))
+        # TODO: The ecor can be negative for certain cases, which causes rho to be NaN. 
+        # And in Python NaN < netRHO is always False, which means the cluster will never be rejected by the rho threshold cut. 
+        # This is fixed in cWB 6.9.6.9. The investigation of the root cause of negative ecor is leave to the future,
+        # for now we clamp it to zero to avoid NaN issues and ensure proper thresholding.
+        rho = np.sqrt(ecor / (1 + penalty * (max(float(1), penalty) - 1))) if ecor > 0 else 0 
         cc = ch if ch > 1 else 1             # noise correction factor (kept for xrho)
         xrho = np.sqrt(Ec * Rc / 2.) if Ec > 0 else 0  # original 2G rho (reference only)
         if DEBUG:
@@ -1496,7 +1509,7 @@ def threshold_cut(
             net_rho_threshold = (netEC_threshold / 2.0) ** 0.5
         condition_1 = Lm <= 0.
         condition_2 = (Eo - Eh) <= 0.
-        condition_3 = rho < net_rho_threshold
+        condition_3 = not np.isfinite(rho) or rho < net_rho_threshold
         condition_4 = N < 1   # C++: N < 1 (pixel count)
         if condition_1 or condition_2 or condition_3 or condition_4:
             rejection_reason = ""

{pycwb-1.0.0a1 → pycwb-1.0.0a2}/pycwb/modules/likelihoodWP/sky_stat.py

@@ -148,7 +148,7 @@ def avx_GW_ps(v00, v90, f, F, fp, fx, ni, et, mask, reg):
     p_updated = np.empty((n_ifo, n_pix), dtype=np.float32)
     q_updated = np.empty((n_ifo, n_pix), dtype=np.float32)
 
-    _o = np.float32(1e-5)
+    _o = np.float32(1e-9)
     _rr = np.float32(reg[0])
     _RR = np.float32(reg[1])
     NN = np.int32(0)
@@ -337,7 +337,7 @@ def avx_stat_ps(v00, v90, s, S, si, co, mask):
     n_ifo = len(v00)  # Number of interferometers
     n_pix = len(v00[0])  # Number of pixels
 
-    _o = np.float32(0.001)
+    _o = np.float32(1.e-9)
     _0 = np.float32(0)
     _1 = np.float32(1)
     _2 = np.float32(2)

{pycwb-1.0.0a1 → pycwb-1.0.0a2}/pycwb/modules/likelihoodWP/typing.py

@@ -89,6 +89,7 @@ class SkyMapStatistics:
     nNetIndex: np.array  # cc
     nEllipticity: np.array  # Cr
     nPolarisation: np.array  # Mp
+    sky_stat_max: float = 0 
     nProbability: np.array = None  # normalized sky probability (softmax of nSkyStat)
     stage_timings: dict = None  # per-stage wall-clock timings (GPU only)
 

{pycwb-1.0.0a1 → pycwb-1.0.0a2}/pycwb/modules/likelihoodWP/utils.py

@@ -383,7 +383,7 @@ def avx_loadNULL_ps(d, D, h, H):
 
 #    static const __m128 _0  = _mm_set1_ps(0);
 #    static const __m128 _1  = _mm_set1_ps(1);
-#    static const __m128 _o  = _mm_set1_ps(1.e-5);
+#    static const __m128 _o  = _mm_set1_ps(1.e-9);
 
 #    __m128 _ss,_cc,_SS,_CC;
 #    float rpol[4],cpol[4],spol[4];
@@ -596,7 +596,7 @@ def avx_pol_ps(p, q, MK, fp, fx, f, F):
     new_p = np.empty((n_ifo, n_pix), dtype=np.float32)
     new_q = np.empty((n_ifo, n_pix), dtype=np.float32)
 
-    _o = float(1.e-5)
+    _o = float(1.e-9)
 
     # Vectorized pixel loop — replaces the interpreted for i in range(n_pix) loop
     p_arr = np.asarray(p, dtype=np.float64)   # (n_ifo, n_pix)
@@ -692,7 +692,7 @@ def avx_packet_ps(v00, v90, mask):
     """
     n_ifo = len(v00)
     n_pix = len(v00[0])
-    _o = float(0.0001)
+    _o = float(1.e-9)
 
     mk = np.empty(n_pix, dtype=np.float32)
     aa = np.zeros(n_ifo, dtype=np.float32)

{pycwb-1.0.0a1 → pycwb-1.0.0a2}/pycwb/types/data_quality_file.py

@@ -98,24 +98,24 @@ class DQFile:
 
         # check if all start > 0
         if np.any(start < 0):
-            error_indexes = np.where(start < 0)
+            error_indexes = np.where(start < 0)[0]
             for i in error_indexes:
-                logger.error(f"Error Ranges : {float(start[i])} {float(stop[i])}")
-            raise Exception("Error Ranges")
+                logger.error(f"Negative start time at index {i}: start={float(start[i])} stop={float(stop[i])}")
+            raise Exception("Error Ranges: negative start times found")
 
         # check if all start < stop
         if np.any(start > stop):
-            error_indexes = np.where(start > stop)
+            error_indexes = np.where(start > stop)[0]
             for i in error_indexes:
-                logger.error(f"Error Ranges : {float(start[i])} {float(stop[i])}")
-            raise Exception("Error Ranges")
+                logger.error(f"Start exceeds stop at index {i}: start={float(start[i])} stop={float(stop[i])}")
+            raise Exception("Error Ranges: start > stop")
 
         # check if all stop < next start
         if np.any(stop[:-1] > start[1:]):
-            error_indexes = np.where(stop[:-1] > start[1:])
+            error_indexes = np.where(stop[:-1] > start[1:])[0]
             for i in error_indexes:
-                logger.error(f"Error Ranges : {float(start[i])} {float(stop[i])}")
-            raise Exception("Error Ranges")
+                logger.error(f"Overlapping segments at index {i}-{i+1}: [{float(start[i])}, {float(stop[i])}] overlaps [{float(start[i+1])}, {float(stop[i+1])}]")
+            raise Exception("Error Ranges: overlapping segments")
 
         if self.invert:
             start, stop = np.append(0, stop), np.append(start, np.inf)