ps-eor 1.0__tar.gz → 1.2__tar.gz

{ps_eor-1.0 → ps_eor-1.2}/CHANGELOG.md

@@ -1,6 +1,45 @@
 # ChangeLog
 
-## Unreleased
+## 1.2 - 2026-10-26
+
+- [Changed] `SkaLow.get_sefd` now interpolates the AAVS2-based SKAO station-sensitivity lookup
+  (zenith, cold-sky LST 0-8h) instead of the pre-hardware SKA1-LFAA design-target specification.
+  Effective XX and YY SEFD values are stored separately, interpolated with independent cubic
+  splines, then combined using the SKAO Stokes-I convention. Values shift, especially above
+  220 MHz where the old table was flat-extrapolated instead of following the lookup roll-off.
+  `tsys_sky` is no longer a parameter because the lookup already fixes the sky condition
+
+## 1.1 - 2026-09-11
+
+- [Fixed] Fix a thermal-noise normalization regression introduced in 1.0 and limited to the
+  convenience default `SimuGridded.get_noise_std_cube(sefd=None)`. That path passed the effective
+  Stokes-I SEFD into equations that already include the two-polarization average, applying the
+  sensitivity gain twice. It also affected `simu_noise_ps_zrange`, which relied on this default.
+  Corrected results from these two paths have sqrt(2) higher visibility-noise amplitude and twice
+  the noise power. Existing low-level `datacube` calculations supplied with `get_sefd`, ML-GPR,
+  `simu_noise_img`, `simu_noise_ps`, and the power-spectrum estimators retain their previous
+  numerical normalization. The polarization average is now explicit through `n_pol_averaged`;
+  the deprecated `get_i_sefd` helper is no longer used internally
+- [Fixed] `DEx` declared a primary beam name that resolved to nothing, so `SimuGridded.get_ps_gen`
+  raised for it. `pstool simu_noise_ps`, `pstool simu_noise_ps_zrange` and `--fov pb_fwhm` were
+  unusable with that telescope, including the example in `obssimu`'s module docstring. Its beam now
+  follows the configured antenna separation, the same aperture its SEFD already uses
+- [Fixed] `pstool simu_noise_ps_zrange` built its redshift grid with
+  `arange(z_min, z_max + delta_z, delta_z)`, which steps one past `z_max` unless the span is an
+  exact multiple of `delta_z`. That slice selects no channel and the run died on an empty reduction
+- [New] `get_samples` and every `SimuMultiGPCube` draw method take an `rng` argument -- a seed, a
+  `Generator`, or None -- so simulated cubes are reproducible. This was the one path the 1.0 move to
+  `numpy.random.Generator` missed. A seed is resolved once per call, so the draws within it advance
+  rather than repeat
+- [Changed] Run the CI pipeline on tags
+- [Changed] `test_independent_epochs_uncorrelated` asserted on one epoch pair's correlation, which
+  has std 0.09 under independence and reaches 0.31, so it failed about one run in forty. It now
+  averages the 28 pairs of an 8-epoch seeded draw, where the same statistic stays under 0.061 and a
+  20% shared variance fraction reads 0.197
+- [Changed] Assert the sampler convergence warnings the test suite provokes rather than leaving them
+  unread in the run summary
+- [Changed] Cover `pstool` and the VAE, and add numerical regressions for the power-spectrum
+  estimators, taking the package from 64% to 70%
 
 ## 1.0 - 2026-08-03
 

{ps_eor-1.0 → ps_eor-1.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: ps_eor
-Version: 1.0
+Version: 1.2
 Summary: Power Spectra generation for 21-cm experiments and Foreground modeling/removal
 Project-URL: Homepage, https://gitlab.com/flomertens/ps_eor
 Project-URL: Documentation, https://ps-eor.readthedocs.io

ps_eor-1.2/ps_eor/data/instruments/ska_low_aavs2_sefd.csv

@@ -0,0 +1,36 @@
+frequency_mhz,sefd_xx_jy,sefd_yy_jy
+49.92,12691.708008,12706.784180
+58.88,6430.699219,6456.514648
+69.12,4400.614258,4429.739258
+79.36,3287.111084,3280.634033
+88.32,2657.459473,2628.958252
+89.60,2591.589600,2559.727051
+99.84,2175.688477,2124.371094
+108.80,1984.341553,1935.180176
+119.04,1879.441406,1837.543213
+129.28,1817.179443,1761.833984
+139.52,1726.300049,1702.780762
+149.76,1720.707642,1640.811279
+154.88,1770.666016,1661.329468
+160.00,1881.431885,1749.433594
+168.96,1985.992188,1876.033081
+179.20,2034.554932,1939.044189
+185.60,2016.972046,1949.946777
+189.44,1996.074097,1918.264404
+199.68,1980.122925,1835.012085
+209.92,1960.942261,1874.337402
+216.32,2126.444092,1988.125122
+218.88,2162.237061,2007.597900
+229.12,2321.589111,2117.384033
+239.36,2255.394531,2111.037354
+249.60,2109.016846,2050.640625
+259.84,2191.391846,2023.246094
+268.80,2117.823975,1980.030396
+279.04,2129.421387,2049.493408
+289.28,2223.825195,2104.812500
+299.52,2374.633545,2311.893066
+309.76,2340.869141,2267.793945
+320.00,2227.362793,2119.056885
+328.96,2285.774170,2193.820068
+339.20,2279.281982,2268.093018
+349.44,2503.468262,2453.347900

{ps_eor-1.0 → ps_eor-1.2}/ps_eor/datacube.py

@@ -66,6 +66,14 @@ def _fmhz(freqs, precision=3):
     return np.round(freqs * 1e-6, precision)
 
 
+def _validate_n_pol_averaged(n_pol_averaged):
+    """Validate the effective number of independent polarization products."""
+    if (not np.isscalar(n_pol_averaged)
+            or not np.isfinite(n_pol_averaged)
+            or n_pol_averaged <= 0):
+        raise ValueError('n_pol_averaged must be a finite, strictly positive scalar')
+
+
 def get_common_idx(cube1, cube2):
     """Return frequency and spatial-mode masks shared by two cubes."""
     freqs = np.intersect1d(_fmhz(cube1.freqs), _fmhz(cube2.freqs))
@@ -1499,40 +1507,62 @@ class CartDataCube(DataCube):
 
         return cube
 
-    def estimate_sefd(self, sefd_jansky=True):
-        """Overall system-equivalent flux density from this cube and its weights.
+    def estimate_sefd(self, sefd_jansky=True, n_pol_averaged=2):
+        """Overall single-polarization SEFD from this cube and its weights.
+
+        Args:
+            sefd_jansky (bool): return Jy (else Kelvin).
+            n_pol_averaged: number of independent polarization products averaged
+                into the visibility cube (one for XX/YY, two for Stokes I).
 
         Returns:
             float: the SEFD, in Jy (``sefd_jansky=True``) or Kelvin.
         """
         assert self.weights is not None
 
-        return self.weights.estimate_sefd(self, sefd_jansky=sefd_jansky)
+        return self.weights.estimate_sefd(
+            self, sefd_jansky=sefd_jansky,
+            n_pol_averaged=n_pol_averaged,
+        )
 
-    def estimate_uv_sefd(self, sefd_jansky=True):
+    def estimate_uv_sefd(self, sefd_jansky=True, n_pol_averaged=2):
         """SEFD per uv sample (see :meth:`estimate_sefd` for units).
 
+        Args:
+            sefd_jansky (bool): return Jy (else Kelvin).
+            n_pol_averaged: number of independent polarization products averaged
+                into the visibility cube.
+
         Returns:
             CartDataCube: the per-mode SEFD.
         """
         assert self.weights is not None
 
-        return self.weights.estimate_uv_sefd(self, sefd_jansky=sefd_jansky)
+        return self.weights.estimate_uv_sefd(
+            self, sefd_jansky=sefd_jansky,
+            n_pol_averaged=n_pol_averaged,
+        )
 
-    def estimate_freqs_sefd(self, sefd_jansky=True, sefd_poly_fit_deg=0):
+    def estimate_freqs_sefd(self, sefd_jansky=True, sefd_poly_fit_deg=0,
+                            n_pol_averaged=2):
         """SEFD per frequency channel (see :meth:`estimate_sefd` for units).
 
         Args:
             sefd_jansky (bool): return Jy (else Kelvin).
             sefd_poly_fit_deg (int): if > 0, smooth the SEFD with a polynomial
                 of this degree in log-log space.
+            n_pol_averaged: number of independent polarization products averaged
+                into the visibility cube.
 
         Returns:
             ndarray: the SEFD per channel, shape ``(n_freqs,)``.
         """
         assert self.weights is not None
 
-        sefd = self.weights.estimate_freqs_sefd(self, sefd_jansky=sefd_jansky)
+        sefd = self.weights.estimate_freqs_sefd(
+            self, sefd_jansky=sefd_jansky,
+            n_pol_averaged=n_pol_averaged,
+        )
 
         if sefd_poly_fit_deg > 0:
             sefd_fct = np.poly1d(np.polyfit(np.log(self.freqs), np.log(sefd), sefd_poly_fit_deg))
@@ -1712,14 +1742,22 @@ class CartDataCube(DataCube):
                     print(f'Filtering {n_filt} modes ({n_filt / n_tot * 100:.2f} %)')
                 self.filter_uv_from_index(idx_uv)
 
-    def filter_sefd_uv(self, max_sefd, min_sefd=0):
+    def filter_sefd_uv(self, max_sefd, min_sefd=0, n_pol_averaged=2):
         """Keep, in place, only uv modes whose mean estimated SEFD is within
         ``[min_sefd, max_sefd]``.
 
+        Args:
+            max_sefd: maximum retained single-polarization SEFD.
+            min_sefd: minimum retained single-polarization SEFD.
+            n_pol_averaged: number of independent polarization products averaged
+                into the visibility cube.
+
         Returns:
             ndarray: boolean mask of the kept modes.
         """
-        sefd = self.estimate_uv_sefd().data.mean(axis=0)
+        sefd = self.estimate_uv_sefd(
+            n_pol_averaged=n_pol_averaged,
+        ).data.mean(axis=0)
         idx_uv = (sefd >= min_sefd) & (sefd <= max_sefd)
         n_filt = np.sum(~idx_uv)
         n_tot = float(len(self.uu))
@@ -2390,24 +2428,28 @@ class CartWeightCube(CartDataCube):
         return CartWeightCube(1 / noise_scale ** 2, noise_cube.uu, noise_cube.vv,
                               noise_cube.freqs, meta)
 
-    def estimate_sefd(self, noise_cube, sefd_jansky=True, axis=None):
-        """SEFD estimated from a noise realization and these weights.
+    def estimate_sefd(self, noise_cube, sefd_jansky=True, axis=None,
+                      n_pol_averaged=2):
+        """Single-polarization SEFD estimated from a noise realization.
 
         Args:
             noise_cube: a noise :class:`CartDataCube` on the same geometry.
             sefd_jansky (bool): return Jy (else Kelvin).
             axis: reduce over this axis (0 -> per uv mode, 1 -> per channel,
                 None -> a single overall value).
+            n_pol_averaged: number of independent polarization products averaged
+                into ``noise_cube`` (one for XX/YY, two for Stokes I).
 
         Returns:
             The SEFD (MAD-averaged over ``axis``); scalar or array per ``axis``.
         """
+        _validate_n_pol_averaged(n_pol_averaged)
         df = self.meta.chan_width
         int_time = self.meta.int_time
 
         w = abs(self.get_slice(noise_cube.freqs[0], noise_cube.freqs[-1]).data)
         w[w == 0] = np.nan
-        sefd = noise_cube.data * (2 * df * int_time * 1) ** 0.5 * w ** 0.5
+        sefd = noise_cube.data * (n_pol_averaged * df * int_time) ** 0.5 * w ** 0.5
 
         # Kelvin noise is normalized to the image field of view.
         if sefd_jansky:
@@ -2421,27 +2463,45 @@ class CartWeightCube(CartDataCube):
 
         return psutil.mad(sefd, axis=axis)
 
-    def estimate_uv_sefd(self, noise_cube, sefd_jansky=True):
+    def estimate_uv_sefd(self, noise_cube, sefd_jansky=True, n_pol_averaged=2):
         """SEFD per uv sample (see :meth:`estimate_sefd`).
 
+        Args:
+            noise_cube: a noise :class:`CartDataCube` on the same geometry.
+            sefd_jansky (bool): return Jy (else Kelvin).
+            n_pol_averaged: number of independent polarization products averaged
+                into ``noise_cube``.
+
         Returns:
             CartDataCube: the per-mode SEFD (single averaged channel).
         """
-        sefd = self.estimate_sefd(noise_cube, sefd_jansky=sefd_jansky, axis=0)
+        sefd = self.estimate_sefd(
+            noise_cube, sefd_jansky=sefd_jansky, axis=0,
+            n_pol_averaged=n_pol_averaged,
+        )
 
         return CartDataCube(sefd[None, :], self.uu, self.vv, np.array([self.freqs.mean()]),
                             self.meta.copy())
 
-    def estimate_freqs_sefd(self, noise_cube, sefd_jansky=True):
+    def estimate_freqs_sefd(self, noise_cube, sefd_jansky=True, n_pol_averaged=2):
         """SEFD per frequency channel (see :meth:`estimate_sefd`).
 
+        Args:
+            noise_cube: a noise :class:`CartDataCube` on the same geometry.
+            sefd_jansky (bool): return Jy (else Kelvin).
+            n_pol_averaged: number of independent polarization products averaged
+                into ``noise_cube``.
+
         Returns:
             ndarray: the SEFD per channel, shape ``(n_freqs,)``.
         """
-        return self.estimate_sefd(noise_cube, sefd_jansky=sefd_jansky, axis=1)
+        return self.estimate_sefd(
+            noise_cube, sefd_jansky=sefd_jansky, axis=1,
+            n_pol_averaged=n_pol_averaged,
+        )
 
     def scale_with_noise_cube(self, noise_cube, sefd_poly_fit_deg=0, sefd_filter_n_bins=0,
-                              expected_sefd=None, scale_freqs=False):
+                              expected_sefd=None, scale_freqs=False, n_pol_averaged=2):
         """Set ``uv_scale`` (in place) so the weights reflect the SEFD measured
         from ``noise_cube`` -- down-weighting noisier uv modes.
 
@@ -2454,8 +2514,12 @@ class CartWeightCube(CartDataCube):
             expected_sefd: reference SEFD the scale normalises to (default: the
                 median measured SEFD).
             scale_freqs (bool): also apply a per-channel SEFD scaling.
+            n_pol_averaged: number of independent polarization products averaged
+                into ``noise_cube``.
         """
-        sefd_uv = self.estimate_uv_sefd(noise_cube).data
+        sefd_uv = self.estimate_uv_sefd(
+            noise_cube, n_pol_averaged=n_pol_averaged,
+        ).data
         if expected_sefd is None:
             expected_sefd = np.nanmedian(sefd_uv)
 
@@ -2476,7 +2540,9 @@ class CartWeightCube(CartDataCube):
                         fill_value='extrapolate')(self.ru)
 
         if scale_freqs:
-            sefd_freqs = self.estimate_freqs_sefd(noise_cube)
+            sefd_freqs = self.estimate_freqs_sefd(
+                noise_cube, n_pol_averaged=n_pol_averaged,
+            )
             self.uv_scale = self.uv_scale * (np.nanmedian(sefd_freqs) / sefd_freqs)[:, None] ** 2
 
         self.uv_scale[~np.isfinite(self.uv_scale)] = 1
@@ -2499,43 +2565,63 @@ class CartWeightCube(CartDataCube):
         """Reset ``uv_scale`` to one."""
         self.uv_scale = np.ones((1, len(self.uu)))
 
+    def _noise_complex_std_per_unit_weight(self, sefd, time, n_pol_averaged=2,
+                                           sefd_jansky=True, fake_apply_win_fct=False):
+        """Return the full complex RMS before division by UV-cell weights."""
+        _validate_n_pol_averaged(n_pol_averaged)
+
+        df = self.meta.chan_width
+        int_time = self.meta.int_time
+        total_time = self.meta.total_time
+        f = time / total_time
+
+        noise_complex_std = np.atleast_1d(
+            sefd / (n_pol_averaged * df * int_time * f) ** 0.5,
+        )[:, None]
+
+        if fake_apply_win_fct:
+            # Scale as if a spatial tapering had been applied.
+            noise_complex_std = noise_complex_std * self.meta.win_fct_power ** .5
+
+        if sefd_jansky:
+            lamb = const.c.value / self.freqs
+            fov = (self.meta.shape[0] * self.meta.res) ** 2
+            jy2k = ((1e-26 * lamb ** 2) / (2 * const.k_B.value)) / fov
+            noise_complex_std = jy2k[:, None] * noise_complex_std
+
+        return noise_complex_std
+
     def simulate_noise(self, sefd, time, hermitian=True, weights_uncertainity_ratio=None,
-                       sefd_jansky=True, fake_apply_win_fct=False, rng=None):
+                       sefd_jansky=True, fake_apply_win_fct=False, rng=None,
+                       n_pol_averaged=2):
         """Draw a thermal-noise visibility cube for a given SEFD and integration.
 
         Noise per mode follows the radiometer equation, scaled by these weights.
 
         Args:
-            sefd: system-equivalent flux density (Jy if ``sefd_jansky``, else K).
+            sefd: single-polarization station SEFD (Jy if ``sefd_jansky``,
+                else K).
             time: total integration time, in seconds.
             hermitian (bool): make the realization Hermitian (real image).
             weights_uncertainity_ratio: if set, also perturb the weights randomly
                 by up to this ratio (see :meth:`random_scale`).
             sefd_jansky (bool): interpret ``sefd`` in Jy (else Kelvin).
             fake_apply_win_fct (bool): scale as if a spatial taper were applied.
+            n_pol_averaged: number of independent polarization products averaged
+                into the simulated visibilities (one for XX/YY, two for Stokes I).
 
         Returns:
             CartDataCube: the simulated noise cube.
         """
-        df = self.meta.chan_width
-        int_time = self.meta.int_time
         total_time = self.meta.total_time
         f = time / total_time
 
-        noise_rms = np.atleast_1d(sefd / (2 * df * int_time * f) ** 0.5)[:, None]
-
-        # Split full complex variance equally between real and imaginary parts.
-        noise_rms = np.sqrt(0.5) * noise_rms
-
-        if fake_apply_win_fct:
-            # Scale noise_rms as if a spatial tapering had been applied.
-            noise_rms = noise_rms * self.meta.win_fct_power ** .5
-
-        if sefd_jansky:
-            lamb = const.c.value / self.freqs
-            fov = (self.meta.shape[0] * self.meta.res) ** 2
-            jy2k = ((1e-26 * lamb ** 2) / (2 * const.k_B.value)) / fov
-            noise_rms = jy2k[:, None] * noise_rms
+        noise_complex_std = self._noise_complex_std_per_unit_weight(
+            sefd, time, n_pol_averaged=n_pol_averaged,
+            sefd_jansky=sefd_jansky,
+            fake_apply_win_fct=fake_apply_win_fct,
+        )
+        component_std = noise_complex_std / np.sqrt(2)
 
         rng = np.random.default_rng(rng)
         w = self.get() ** 0.5
@@ -2554,11 +2640,13 @@ class CartWeightCube(CartDataCube):
 
             hs = (self.data.shape[0], len(idx1))
             noise_data = np.zeros_like(self.data, dtype=np.complex128)
-            noise_data[:, idx1] = noise_rms / w[:, idx1] * \
+            noise_data[:, idx1] = component_std / w[:, idx1] * \
                 (rng.standard_normal(hs) + 1j * rng.standard_normal(hs))
             noise_data[:, idx2] = np.conj(noise_data[:, idx1])
         else:
-            noise_data = noise_rms / w * (rng.standard_normal(s) + 1j * rng.standard_normal(s))
+            noise_data = component_std / w * (
+                rng.standard_normal(s) + 1j * rng.standard_normal(s)
+            )
 
         weights = self.new_with_data(self.data * f)
 
@@ -2570,37 +2658,31 @@ class CartWeightCube(CartDataCube):
 
         return noise_cube
 
-    def get_noise_std_cube(self, sefd, time, fake_apply_win_fct=False):
+    def get_noise_std_cube(self, sefd, time, fake_apply_win_fct=False,
+                           n_pol_averaged=2):
         """The *expected* per-mode thermal-noise standard deviation (not a
         realization -- see :meth:`simulate_noise` for that).
 
         Args:
-            sefd: system-equivalent flux density, in Jy.
+            sefd: single-polarization station SEFD, in Jy.
             time: total integration time, in seconds.
             fake_apply_win_fct (bool): scale as if a spatial taper were applied.
+            n_pol_averaged: number of independent polarization products averaged
+                into the visibility cube (one for XX/YY, two for Stokes I).
 
         Returns:
             NoiseStdCube: the per-mode noise standard deviation.
         """
-        df = self.meta.chan_width
-        int_time = self.meta.int_time
         total_time = self.meta.total_time
         f = time / total_time
 
-        noise_rms = np.atleast_1d(sefd / (2 * df * int_time * f) ** 0.5)
-
-        lamb = const.c.value / self.freqs
-        fov = (self.meta.shape[0] * self.meta.res) ** 2
-        jy2k = ((1e-26 * lamb ** 2) / (2 * const.k_B.value)) / fov
-        noise_rms = (jy2k * noise_rms)[:, None]
-
+        noise_rms = self._noise_complex_std_per_unit_weight(
+            sefd, time, n_pol_averaged=n_pol_averaged,
+            fake_apply_win_fct=fake_apply_win_fct,
+        )
         w = self.get() ** 0.5
         noise_rms = noise_rms / w
 
-        if fake_apply_win_fct:
-            # Scale noise_rms as if a spatial tapering had been applied.
-            noise_rms = noise_rms * self.meta.win_fct_power ** .5
-
         weights = self.new_with_data(self.data * f)
 
         noise_cube = NoiseStdCube(noise_rms, self.uu, self.vv, self.freqs.copy(),

{ps_eor-1.0 → ps_eor-1.2}/ps_eor/ml_gpr/covariance.py

@@ -234,11 +234,12 @@ def nearest_positive_definite(A, maxtries=10):
 nearest_postive_definite = nearest_positive_definite
 
 
-def get_samples(X, n, K, complex_type=True, nearest_pd=True, method='eigh'):
+def get_samples(X, n, K, complex_type=True, nearest_pd=True, method='eigh', rng=None):
     """Draw ``n`` Gaussian realizations with covariance ``K``.
 
     ``X`` supplies the mean-vector length. The result has shape
-    ``(len(X), n)`` and is complex unless ``complex_type=False``. Raises
+    ``(len(X), n)`` and is complex unless ``complex_type=False``. ``rng`` is a
+    seed, a :class:`numpy.random.Generator`, or None for a fresh draw. Raises
     :class:`numpy.linalg.LinAlgError` if K is not finite; with
     ``nearest_pd=True``, a non-positive-definite matrix is repaired first.
     """
@@ -246,7 +247,7 @@ def get_samples(X, n, K, complex_type=True, nearest_pd=True, method='eigh'):
         raise np.linalg.LinAlgError('covariance contains non-finite values')
     if nearest_pd and not is_positive_definite(K):
         K = nearest_positive_definite(K)
-    rg = np.random.default_rng()
+    rg = np.random.default_rng(rng)
     n_draws = 2 * n if complex_type else n
     draws = rg.multivariate_normal(
         np.zeros_like(X).squeeze(), K, n_draws, method=method).T

{ps_eor-1.0 → ps_eor-1.2}/ps_eor/ml_gpr/fitter.py

@@ -55,10 +55,12 @@ class MLGPRForegroundFitter(fgfit.AbstractForegroundFitter):
 
         if self.config.kern.noise.use_simulated_noise_cube:
             if self.config.kern.noise.use_sefd_freqs_estimate:
-                sefd = noise_cube.estimate_freqs_sefd(sefd_poly_fit_deg=1)
+                sefd = noise_cube.estimate_freqs_sefd(
+                    sefd_poly_fit_deg=1, n_pol_averaged=2,
+                )
                 print(f'Using simulated noise with mean SEFD={sefd.mean():.1f} Jy')
             else:
-                sefd = noise_cube.estimate_sefd()
+                sefd = noise_cube.estimate_sefd(n_pol_averaged=2)
                 print(f'Using simulated noise with SEFD={sefd:.1f} Jy')
 
             w = noise_cube.weights.copy()
@@ -67,12 +69,16 @@ class MLGPRForegroundFitter(fgfit.AbstractForegroundFitter):
                                         sefd_filter_n_bins=sefd_filter_n_bins)
 
             if self.config.kern.noise.use_noise_std:
-                noise_cube = w.get_noise_std_cube(sefd, noise_cube.meta.total_time,
-                                                  fake_apply_win_fct=True)
+                noise_cube = w.get_noise_std_cube(
+                    sefd, noise_cube.meta.total_time,
+                    fake_apply_win_fct=True, n_pol_averaged=2,
+                )
                 noise_cube.weights = w
             else:
-                noise_cube = w.simulate_noise(sefd, noise_cube.meta.total_time,
-                                              fake_apply_win_fct=True)
+                noise_cube = w.simulate_noise(
+                    sefd, noise_cube.meta.total_time,
+                    fake_apply_win_fct=True, n_pol_averaged=2,
+                )
 
         return noise_cube
 

{ps_eor-1.0 → ps_eor-1.2}/ps_eor/obssimu.py

@@ -16,7 +16,7 @@ Sensitivity models can be used independently of a UV simulation::
 
     freqs = np.arange(50, 80, .2) * 1e6
     telescope = obssimu.Telescope.from_name('nenufar')
-    stokes_i_sefd = telescope.get_i_sefd(freqs)
+    single_pol_sefd = telescope.get_sefd(freqs)
 
 For an array with an available station layout, configure the declination, hour
 angle range, and time resolution before choosing a gridding strategy::
@@ -34,7 +34,10 @@ angle range, and time resolution before choosing a gridding strategy::
         fov_deg=telescope.fov,
         min_weight=1,
     )
-    noise_std = coverage.get_noise_std_cube(total_time_sec=100 * 3600)
+    noise_std = coverage.get_noise_std_cube(
+        total_time_sec=100 * 3600,
+        n_pol_averaged=2,
+    )
 
 The same :class:`SimuGridded` object provides a power-spectrum estimator whose
 frequency range, UV limits, primary beam, and default weights match the
@@ -67,6 +70,7 @@ wavelengths, angles in degrees unless a parameter explicitly ends in
 
 import itertools
 import os
+import warnings
 from enum import Enum, auto
 from importlib.resources import files as resource_files
 from typing import ClassVar
@@ -231,7 +235,7 @@ class Telescope:
         """
 
     def get_i_sefd(self, freq):
-        """Return the Stokes-I SEFD in Jy.
+        """Return the effective Stokes-I SEFD in Jy (deprecated).
 
         Args:
             freq (np.ndarray or float): Frequency in Hz.
@@ -239,6 +243,12 @@ class Telescope:
         Returns:
             ndarray or float: Stokes-I SEFD in Jy.
         """
+        warnings.warn(
+            'get_i_sefd() is deprecated; use get_sefd() and specify '
+            'n_pol_averaged instead.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
 
         return 1 / np.sqrt(2) * self.get_sefd(freq)
 
@@ -317,7 +327,6 @@ class DEx(Telescope):
     fov = 120
     du = 1
     only_drift_mode = True
-    pb_name = name
     coord_type = CoordinateType.ENU
     location = EarthLocation(lon=116.67081524 * units.deg, lat=-26.70122102627586 * units.deg,
                              height=0.0 * units.m)
@@ -333,6 +342,19 @@ class DEx(Telescope):
         self.sep_antenna = sep_antenna
         self.n_antenna_side = n_antenna_side
 
+    @property
+    def pb_name(self):
+        """Dipole beam name, following the configured antenna separation.
+
+        :meth:`get_sefd` models one element as an aperture of diameter
+        ``sep_antenna`` (see :meth:`Telescope.get_dipole_aeff`), so the beam
+        uses the same aperture. The tapering matches the other dipole arrays
+        here (``a12_lba``, ``ovro_lwa``). Unlike every other telescope the
+        element geometry is a constructor argument, so this cannot be a fixed
+        class attribute.
+        """
+        return f'ant_{self.sep_antenna}_1.1_gaussian'
+
     def get_stat_pos(self):
         """Generate ENU antenna positions for the square layout.
 
@@ -373,17 +395,31 @@ class SkaLow(Telescope):
         """Return the packaged SKA-Low AA4 ENU station layout."""
         return os.path.join(INSTRU_DIR, 'ska1_low_enu_statpos.data')
 
-    def get_sefd(self, freq, tsys_sky=60):
-        """The interpolated single-polarization SKA-Low SEFD in Jy."""
-        # SKA LFAA station specification, arXiv:2003.12744, p. 22.
-        freqs_spec = np.array([50, 80, 110, 140, 160, 220]) * 1e6
-        a_eff_over_tsys_spec = 1 * np.array([0.14, 0.46, 1.04, 1.15, 1.2, 1.2])
-        def t_sky_fct(freqs): return tsys_sky * (3e8 / freqs) ** 2.55
-        a_eff_fct = scipy.interpolate.interp1d(
-                freqs_spec, a_eff_over_tsys_spec * t_sky_fct(freqs_spec), kind='slinear',
-                bounds_error=False, fill_value='extrapolate')
+    # AAVS2-based SKAO station-sensitivity lookup at zenith, effectively
+    # averaged over cold-sky LST 0-8 h. XX and YY are averaged over time
+    # independently following ska-ost-senscalc, then stored in a packaged CSV.
+    _sefd_table = np.genfromtxt(
+        os.path.join(INSTRU_DIR, 'ska_low_aavs2_sefd.csv'),
+        delimiter=',',
+        names=True,
+    )
+    _sefd_freqs = _sefd_table['frequency_mhz'] * 1e6
+    _sefd_xx_interpolator = scipy.interpolate.UnivariateSpline(
+        _sefd_freqs, _sefd_table['sefd_xx_jy'], s=0,
+    )
+    _sefd_yy_interpolator = scipy.interpolate.UnivariateSpline(
+        _sefd_freqs, _sefd_table['sefd_yy_jy'], s=0,
+    )
+
+    def get_sefd(self, freq):
+        """The interpolated single-polarization-equivalent SKA-Low SEFD in Jy."""
+        sefd_xx = self._sefd_xx_interpolator(freq)
+        sefd_yy = self._sefd_yy_interpolator(freq)
 
-        return 2 * const.k_B.value * 1e26 * t_sky_fct(freq) / a_eff_fct(freq)
+        # ska-ost-senscalc defines SEFD_I = hypot(SEFD_XX, SEFD_YY) / 2.
+        # Returning the equivalent single-polarization value keeps
+        # get_noise_std_cube(..., n_pol_averaged=2) consistent with SEFD_I.
+        return np.hypot(sefd_xx, sefd_yy) / np.sqrt(2)
 
 
 class SkaLowAAstar(SkaLow):
@@ -1083,11 +1119,17 @@ class SimuGridded:
         return np.atleast_1d(self.telescope_simu.telescop.get_sefd(self.weights.freqs))
 
     def get_i_sefd(self):
-        """The Stokes-I SEFD across the simulated frequencies.
+        """The effective Stokes-I SEFD across frequencies (deprecated).
 
         Returns:
             ndarray: Stokes-I SEFD in Jy.
         """
+        warnings.warn(
+            'get_i_sefd() is deprecated; use get_sefd() and specify '
+            'n_pol_averaged instead.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
 
         return 1 / np.sqrt(2) * self.get_sefd()
 
@@ -1135,7 +1177,8 @@ class SimuGridded:
 
         return pspec.PowerSpectraCart(eor, ps_conf, pb)
 
-    def get_noise_std_cube(self, total_time_sec, sefd=None, min_weight=1):
+    def get_noise_std_cube(self, total_time_sec, sefd=None, min_weight=1,
+                           n_pol_averaged=2):
         """Estimate the thermal-noise standard deviation in every UV cell.
 
         A window recorded during gridding is included through its equivalent
@@ -1146,21 +1189,26 @@ class SimuGridded:
 
         Args:
             total_time_sec: Target total integration time in seconds.
-            sefd: Optional Stokes-I SEFD in Jy, scalar or one value per
-                frequency. By default use the telescope model.
+            sefd: Optional single-polarization station SEFD in Jy, scalar or
+                one value per frequency. By default use the telescope model.
             min_weight: Remove cells whose weight is below this value.
+            n_pol_averaged: number of independent polarization products averaged
+                into the visibility cube (one for XX/YY, two for Stokes I).
 
         Returns:
             ps_eor.datacube.NoiseStdCube: Real standard deviation per frequency
             and UV cell.
         """
         if sefd is None:
-            sefd = self.get_i_sefd()
+            sefd = self.get_sefd()
 
         fake_apply_win_fct = 'PEWINFCT' in self.weights.meta
 
-        noise_std = self.weights.get_noise_std_cube(sefd, total_time_sec,
-                                                    fake_apply_win_fct=fake_apply_win_fct)
+        noise_std = self.weights.get_noise_std_cube(
+            sefd, total_time_sec,
+            fake_apply_win_fct=fake_apply_win_fct,
+            n_pol_averaged=n_pol_averaged,
+        )
         noise_std.filter_min_weight(min_weight)
 
         return noise_std

{ps_eor-1.0 → ps_eor-1.2}/ps_eor/simu.py

@@ -37,9 +37,10 @@ def _bind_signal_kern(kern, uv_bins, mean_fmhz):
                          'expected UVScaledKernel, VAEKernTorch, or a sum of those')
 
 
-def get_multi_samples(X, ns, Ks):
+def get_multi_samples(X, ns, Ks, rng=None):
     """Draw ns[i] realizations from each per-uv-bin covariance Ks[i]."""
-    return [get_samples(X, n, K) for n, K in zip(ns, Ks, strict=False)]
+    rng = np.random.default_rng(rng)
+    return [get_samples(X, n, K, rng=rng) for n, K in zip(ns, Ks, strict=False)]
 
 
 def _contains_product(kern):
@@ -95,28 +96,28 @@ class SimuMultiGPCube:
         simulated data can be compared with, or added to, that cube."""
         return SimuMultiGPCube(cube, **kwargs)
 
-    def get_from_kern(self, kern):
+    def get_from_kern(self, kern, rng=None):
         """Cube drawn from a kernel's covariance.
 
         Takes a UVScaledKernel, VAEKernTorch, or a sum of those; binding it to
         this geometry is done here, so it may be passed unbound.
         """
         fmhz = self.template.freqs * 1e-6
-        return self._draw(self._K_from_kern(kern, fmhz))
+        return self._draw(self._K_from_kern(kern, fmhz), rng=rng)
 
-    def get_from_K(self, K):
+    def get_from_K(self, K, rng=None):
         """Cube drawn from an explicit (n_bins, n_freq, n_freq) covariance."""
-        return self._draw(K)
+        return self._draw(K, rng=rng)
 
-    def get_from_ps3d(self, k_mean, ps3d):
+    def get_from_ps3d(self, k_mean, ps3d, rng=None):
         """Cube drawn from a spherically averaged 21-cm power spectrum.
 
         ps3d is delta(k) on the k_mean grid. Requires a simulator built with
         :meth:`new`, since the normalization needs res and n_pix.
         """
-        return self._draw(self._K_from_ps(k_mean, ps3d, self.template.freqs))
+        return self._draw(self._K_from_ps(k_mean, ps3d, self.template.freqs), rng=rng)
 
-    def get_noise(self, variance):
+    def get_noise(self, variance, rng=None):
         """White-noise cube of constant variance.
 
         Use this to make the noise cube a fit needs;
@@ -125,9 +126,9 @@ class SimuMultiGPCube:
         """
         n_freq = len(self.template.freqs)
         K = variance * np.array([np.eye(n_freq)] * len(self.uv_bins))
-        return self.get_from_K(K)
+        return self.get_from_K(K, rng=rng)
 
-    def get_epochs_from_kern(self, kern, epoch_times):
+    def get_epochs_from_kern(self, kern, epoch_times, rng=None):
         """One cube per epoch, with the cross-epoch coherence a TimeKron implies.
 
         Takes a TimeKron expression and epoch times in days. Sums are drawn
@@ -135,7 +136,10 @@ class SimuMultiGPCube:
         coherent epochs. Expressions containing a product are drawn from their
         full joint epoch-frequency covariance, since a product of sums is not
         separable component by component.
+
+        ``rng`` is a seed, a :class:`numpy.random.Generator`, or None.
         """
+        rng = np.random.default_rng(rng)
         comps = list(_iter_leaf_kernels(kern))
         if not all(isinstance(c, TimeKron) for c in comps):
             raise TypeError('get_epochs_from_kern expects a TimeKron or a sum of TimeKrons')
@@ -151,7 +155,7 @@ class SimuMultiGPCube:
             K_joint, joint_x = self._K_from_time_kern(kern, fmhz, times)
             n_f = len(fmhz)
             for K_i, idx in zip(K_joint, idxs, strict=False):
-                draw = get_samples(joint_x, int(np.sum(idx)), K_i)
+                draw = get_samples(joint_x, int(np.sum(idx)), K_i, rng=rng)
                 for t, cube in enumerate(cubes):
                     cube.data[:, idx] = draw[t * n_f:(t + 1) * n_f]
             return cubes
@@ -182,7 +186,8 @@ class SimuMultiGPCube:
 
             for K_i, idx in zip(K_f, idxs, strict=False):
                 n = int(np.sum(idx))
-                Z = {r: get_samples(fmhz, n, K_i) for r in active}  # independent (n_f, n) draws
+                Z = {r: get_samples(fmhz, n, K_i, rng=rng)
+                     for r in active}  # independent (n_f, n) draws
                 for t in range(n_t):
                     for r in active:
                         if abs(L_t[t, r]) > 1e-12:
@@ -205,12 +210,13 @@ class SimuMultiGPCube:
         with torch.no_grad():
             return kern(x, x).to_dense().numpy(), joint_x
 
-    def _draw(self, K):
+    def _draw(self, K, rng=None):
+        rng = np.random.default_rng(rng)
         c = self.template.new_with_data(np.zeros_like(self.template.data))
         fmhz = c.freqs * 1e-6
         idxs = get_uv_bin_masks(c.ru, self.uv_bins)
         for idx, Ki in zip(idxs, K, strict=False):
-            c.data[:, idx] = get_samples(fmhz, np.sum(idx), Ki)
+            c.data[:, idx] = get_samples(fmhz, np.sum(idx), Ki, rng=rng)
         return c
 
     def _K_from_kern(self, kern, fmhz):

{ps_eor-1.0 → ps_eor-1.2}/ps_eor/tools/pstool.py

@@ -1194,8 +1194,10 @@ def simu_noise_img(uv_simu_h5, total_time_hour, out_filename, min_weight):
     print(f'Simulating thermal noise with mean SEFD = {uv_simu.get_sefd().mean()} Jy ...')
     print(f'{len(freqs)} frequency channels between {freqs.min() * 1e-6:.1f} and '
           f'{freqs.max() * 1e-6:.1f} MHz')
-    noise_cube = uv_simu.weights.simulate_noise(uv_simu.get_sefd(), total_time_hour * 3600,
-                                                hermitian=False)
+    noise_cube = uv_simu.weights.simulate_noise(
+        uv_simu.get_sefd(), total_time_hour * 3600,
+        hermitian=False, n_pol_averaged=2,
+    )
     noise_cube.filter_min_weight(min_weight, replace=True)
     noise_img = noise_cube.image()
     print(f'RMS noise @ mid frequency {noise_img.data[len(freqs) // 2].std()} Kelvin')
@@ -1219,7 +1221,7 @@ def simu_noise_img(uv_simu_h5, total_time_hour, out_filename, min_weight):
 @click.option('--filter_kpar_min', help='Filter mode below kpar_min', default=None, type=float)
 @click.option('--filter_wedge_theta', help='Filter mode below the wedge line', default=0,
               type=float)
-@click.option('--sefd', help='System Equivalent Flux Density (Jy)', default=None, type=float)
+@click.option('--sefd', help='Single-polarization station SEFD (Jy)', default=None, type=float)
 @click.option('--n_incoherent_avg', help='Number of incoherent averaging', default=1, type=int)
 @click.option('--min_weight', help='Minimum number of visibilities in a uv-cell', default=10,
               type=int, show_default=True)
@@ -1254,7 +1256,10 @@ def simu_noise_ps(uv_simu_h5, total_time_hour, out_filename, kmin, kmax, nks,
 
     print(f'{len(freqs)} frequency channels between {freqs.min() * 1e-6:.1f} and '
           f'{freqs.max() * 1e-6:.1f} MHz')
-    noise_std = uv_simu.get_noise_std_cube(total_time_hour * 3600, sefd=sefd, min_weight=min_weight)
+    noise_std = uv_simu.get_noise_std_cube(
+        total_time_hour * 3600, sefd=sefd,
+        min_weight=min_weight, n_pol_averaged=2,
+    )
     pss = {}
     pss['ps'] = ps_gen.get_ps(noise_std)
     pss['ps2d'] = ps_gen.get_ps2d(noise_std)
@@ -1316,7 +1321,12 @@ def simu_noise_ps_zrange(uv_simu_h5, total_time_hour, k, out_filename, bandwidth
     simu_gridded = obssimu.SimuGridded.load(uv_simu_h5)
     z_max = np.round(psutil.freq_to_z(simu_gridded.weights.freqs.min() + bandwidth / 2 * 1e6), 1)
     z_min = np.round(psutil.freq_to_z(simu_gridded.weights.freqs.max() - bandwidth / 2 * 1e6), 1)
+    # arange's stop is exclusive, so the + delta_z is there to keep z_max. It
+    # also admits one step past it whenever (z_max - z_min) is not a multiple of
+    # delta_z, and that slice lands outside the coverage: an empty frequency
+    # selection, and no delay modes to take a minimum over.
     zs = np.arange(z_min, z_max + delta_z, delta_z)
+    zs = zs[zs <= z_max + 1e-9]
 
     k_bin = [(1 - dk_over_k / 2) * k, (1 + dk_over_k / 2) * k]
 
@@ -1334,11 +1344,15 @@ def simu_noise_ps_zrange(uv_simu_h5, total_time_hour, k, out_filename, bandwidth
         ps_gen = uv_simu_z.get_ps_gen(filter_kpar_min, filter_wedge_theta)
 
         print(f'Redshift z = {z}')
-        print(f'Simulating thermal noise with mean SEFD = {uv_simu_z.get_sefd().mean():.1f} Jy ...')
+        sefd = uv_simu_z.get_sefd()
+        print(f'Simulating thermal noise with mean SEFD = {sefd.mean():.1f} Jy ...')
         print(f'{len(freqs)} frequency channels between {freqs.min() * 1e-6:.1f} and '
               f'{freqs.max() * 1e-6:.1f} MHz')
 
-        noise_std = uv_simu_z.get_noise_std_cube(total_time_hour * 3600, min_weight=min_weight)
+        noise_std = uv_simu_z.get_noise_std_cube(
+            total_time_hour * 3600, sefd=sefd,
+            min_weight=min_weight, n_pol_averaged=2,
+        )
 
         ps3d = ps_gen.get_ps3d(k_bin, noise_std)
         if n_incoherent_avg > 1:

{ps_eor-1.0 → ps_eor-1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ps_eor"
-version = "1.0"
+version = "1.2"
 description = "Power Spectra generation for 21-cm experiments and Foreground modeling/removal"
 readme = "README.md"
 license = "GPL-3.0-or-later"