BUG: fix ROQ likelihood incompatibility with numpy 2.4 (#1106)

* BUG: fix roq_params shape when using HDF5 format

* TST: add tests for roq_params

* ENH: improve roq_params validation

* TST: add test for missing roq param fields

Author: mj-will

bilby/gw/likelihood/roq.py

@@ -84,6 +84,31 @@ class ROQGravitationalWaveTransient(GravitationalWaveTransient):
         - e.g., "H1": sample in the time of arrival at H1
 
     """
+    @property
+    def roq_params(self):
+        return self._roq_params
+
+    @roq_params.setter
+    def roq_params(self, roq_params):
+        if roq_params is not None:
+            if not isinstance(roq_params, np.ndarray) or roq_params.dtype.names is None:
+                raise TypeError(
+                    "roq_params must be None or a scalar structured numpy array"
+                )
+            if roq_params.ndim != 0:
+                raise ValueError(
+                    "roq_params must be a scalar structured array; "
+                    f"received shape {roq_params.shape}"
+                )
+            required_fields = {"flow", "fhigh", "seglen"}
+            missing_fields = required_fields.difference(roq_params.dtype.names)
+            if missing_fields:
+                raise ValueError(
+                    "roq_params is missing required fields: "
+                    + ", ".join(sorted(missing_fields))
+                )
+        self._roq_params = roq_params
+
     def __init__(
             self, interferometers, waveform_generator, priors,
             weights=None, linear_matrix=None, quadratic_matrix=None,
@@ -96,6 +121,7 @@ def __init__(
 
     ):
         self._delta_tc = delta_tc
+        self._roq_params = None
         super(ROQGravitationalWaveTransient, self).__init__(
             interferometers=interferometers,
             waveform_generator=waveform_generator, priors=priors,
@@ -130,17 +156,17 @@ def __init__(
             if self.roq_params is None:
                 if is_hdf5_linear:
                     self.roq_params = np.array(
-                        [(linear_matrix['minimum_frequency_hz'][()],
-                          linear_matrix['maximum_frequency_hz'][()],
-                          linear_matrix['duration_s'][()])],
+                        (linear_matrix['minimum_frequency_hz'][()],
+                         linear_matrix['maximum_frequency_hz'][()],
+                         linear_matrix['duration_s'][()]),
                         dtype=[('flow', float), ('fhigh', float), ('seglen', float)]
                     )
                 if is_hdf5_quadratic:
                     if self.roq_params is None:
                         self.roq_params = np.array(
-                            [(quadratic_matrix['minimum_frequency_hz'][()],
-                              quadratic_matrix['maximum_frequency_hz'][()],
-                              quadratic_matrix['duration_s'][()])],
+                            (quadratic_matrix['minimum_frequency_hz'][()],
+                             quadratic_matrix['maximum_frequency_hz'][()],
+                             quadratic_matrix['duration_s'][()]),
                             dtype=[('flow', float), ('fhigh', float), ('seglen', float)]
                         )
                     else:

test/gw/likelihood_test.py

@@ -3,6 +3,7 @@
 import tempfile
 from functools import cached_property
 from itertools import product
+from unittest import mock
 from parameterized import parameterized
 import pytest
 from copy import deepcopy
@@ -1032,13 +1033,36 @@ def test_from_hdf5(self, basis_linear, basis_quadratic):
             )
         )
 
-        bilby.gw.likelihood.ROQGravitationalWaveTransient(
+        likelihood = bilby.gw.likelihood.ROQGravitationalWaveTransient(
             interferometers=interferometers,
             priors=priors,
             waveform_generator=search_waveform_generator,
             linear_matrix=f"{self.roq_dir}/{basis_linear}",
             quadratic_matrix=f"{self.roq_dir}/{basis_quadratic}"
         )
+        assert np.asarray(likelihood.roq_params).shape == ()
+
+    def test_roq_params_requires_scalar_structured_array(self):
+        likelihood = mock.Mock()
+        with self.assertRaisesRegex(ValueError, "scalar structured array"):
+            bilby.gw.likelihood.ROQGravitationalWaveTransient.roq_params.fset(
+                likelihood,
+                np.array(
+                    [(20.0, 1024.0, 16.0)],
+                    dtype=[("flow", float), ("fhigh", float), ("seglen", float)],
+                ),
+            )
+
+    def test_roq_params_requires_expected_fields(self):
+        likelihood = mock.Mock()
+        with self.assertRaisesRegex(ValueError, "missing required fields: seglen"):
+            bilby.gw.likelihood.ROQGravitationalWaveTransient.roq_params.fset(
+                likelihood,
+                np.array(
+                    (20.0, 1024.0),
+                    dtype=[("flow", float), ("fhigh", float)],
+                ),
+            )
 
     @parameterized.expand([(False, ), (True, )])
     def test_from_npy(self, from_array):