prepostcov 0.1.0__tar.gz

prepostcov-0.1.0/LICENSE

@@ -0,0 +1,29 @@
+Creative Commons Attribution-NonCommercial 4.0 International License
+
+Copyright (c) 2026 Maus, Baleato Lizancos and White
+
+This work is licensed under the Creative Commons Attribution-NonCommercial 4.0 
+International License. To view a copy of this license, visit 
+http://creativecommons.org/licenses/by-nc/4.0/ or send a letter to 
+Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
+
+You are free to:
+- Share — copy and redistribute the material in any medium or format
+- Adapt — remix, transform, and build upon the material
+
+Under the following terms:
+- Attribution — You must give appropriate credit, provide a link to the license, 
+  and indicate if changes were made. You may do so in any reasonable manner, but 
+  not in any way that suggests the licensor endorses you or your use.
+- NonCommercial — You may not use the material for commercial purposes.
+- No additional restrictions — You may not apply legal terms or technological 
+  measures that legally restrict others from doing anything the license permits.
+
+Notices:
+You do not have to comply with the license for elements of the material in the 
+public domain or where your use is permitted by an applicable exception or 
+limitation.
+
+No warranties are given. The license may not give you all of the permissions 
+necessary for your intended use. For example, other rights such as publicity, 
+privacy, or moral rights may limit how you use the material.

prepostcov-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: prepostcov
+Version: 0.1.0
+Summary: Covariance and multipole tools for power spectrum and correlation function analysis.
+Home-page: https://github.com/abaleato/PrePostCov/tree/main
+Author: A. Baleato Lizancos & M. Maus
+Author-email: a.baleatolizancos@berkeley.edu
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy

prepostcov-0.1.0/README.md

@@ -0,0 +1,83 @@
+
+# PrePostCov
+
+PrePostCov is a Python package to compute analytical covariances between multipoles of the pre-reconstruction galaxy power spectrum and the post-reconstruction two-point correlation function.
+
+## Installation
+
+You can install the package locally (from the root directory) with:
+
+```bash
+pip install .
+```
+
+Or install dependencies for development:
+
+```bash
+pip install -e .[dev]
+```
+---
+
+
+## $P_{\ell}(k)^{\rm{pre-recon}}$ - $\xi_{\ell}(r)^{\rm{post-recon}}$ cross-covariance
+The main novelty presented in this repo is an analytic calculation of the cross-covariance between $P_{\ell}(k)^{\rm{pre-recon}}$ and $\xi_{\ell}(r)^{\rm{post-recon}}$. The required functionality lives in `covariances_pk_xi.py`. Running this requires only very basic dependencies like `numpy` and `scipy`.
+
+### Basic usage
+
+For the basic cross-covariance calculation, see the worked example in [preprost_covariance.ipynb](preprost_covariance.ipynb). In brief:
+
+```python
+# After installation, you can import the main classes and functions as
+from prepostcov import PkXiCovariance, LegendreMultipoleExtractor
+
+# Initialize the covariance builder
+cov_builder = PkXiCovariance(k=k_array, r=r_array, V=survey_volume, 
+                             poles_Pk=[0, 2], poles_Xi=[0, 2])
+
+# Provide the fiducial P_cross(k, mu) (see paper for details)
+cov_builder.set_Pcross_from_callable(P_cross_of_mu, ells=[0, 2, 4])
+
+# Compute the Pk-Xi block of the covariance matrix
+cov_PkXi = cov_builder.compute_covariance()  # shape (n_poles_Pk, n_poles_Xi, nk, nr)
+```
+
+## Full $P_{\ell}(k)^{\rm{pre-recon}}$ - $\xi_{\ell}(r)^{\rm{post-recon}}$ covariance
+
+Additionally, we include code to calculate the remaining blocks of the covariance matrix involving $P_{\ell}(k)^{\rm{pre-recon}}$ and $\xi_{\ell}(r)^{\rm{post-recon}}$. To do this, we use [TheCov](https://github.com/cosmodesi/thecov) for the $P_{\ell}(k)^{\rm{pre-recon}}$ auto piece, [RascalC](https://github.com/mikhailov/rascalc) for $\xi_{\ell}(r)^{\rm{post-recon}}$.
+
+Overall steps are:
+1. Compute P(k),Xi(s) from catalogs
+2. Compute P(k) window matrices
+3. Obtain fiducial spectra for covariances
+(Can skip steps 1-3 if you already have fiducial spectra)
+4. Compute gaussian, t0, and ssc pieces of P(k) covariance
+5. Compute Xi(s) covariance
+6. Compute PkxXi covariance and combine everyting
+
+These are all subroutines in the `full_covariance()` class in [Covariances_full.py](Covariances_full.py). The front end script is [do_everything.py](do_everything.py) to which you add arguments related to the desired task:
+
+1. **Measure P(k):**
+   ```bash
+   srun -n 64 python do_everything.py --task measure_pk \
+       --tracer LRG --zrange 0.4 0.6 --zeff 0.51 --DR 2 --version v2 \
+       --region GCcomb --outpath ./data/pk_measured/Pk_LRG_z0.4-0.6_DR2_GCcomb
+   ```
+
+2. **Compute window:**
+   ```bash
+   srun -n 64 python do_everything.py --task compute_window \
+       --pk_poles_path ./data/pk_measured/Pk_LRG_z0.4-0.6_DR2_GCcomb.npy \
+       --tracer LRG --zrange 0.4 0.6 --zeff 0.51 --DR 2 --version v2 \
+       --region GCcomb --outpath ./data/pk_window/wmat_LRG_z0.4-0.6_DR2_GCcomb
+   ```
+
+## Citation
+
+If you use this code in your research, please cite:
+
+[**Maus, Baleato Lizancos, White, de Mattia & Chen (2026)**](https://arxiv.org/abs/2602.12343)
+
+## License
+
+This project is licensed under the [Creative Commons Attribution-NonCommercial 4.0 International License](LICENSE) (CC BY-NC 4.0). You are free to use, share, and adapt this code for non-commercial purposes with appropriate attribution.
+

prepostcov-0.1.0/prepostcov/__init__.py

@@ -0,0 +1,3 @@
+from .multipoles import *
+from .covariances_pk_xi import *
+# Optionally, import from Covariances_full if needed

prepostcov-0.1.0/prepostcov/__main__.py

@@ -0,0 +1,5 @@
+from .multipoles import *
+from .covariances_pk_xi import *
+# Optionally, add CLI or main entry point logic here
+if __name__ == "__main__":
+	print("Welcome to the PrePostCov package! This module is not meant to be run directly.")

prepostcov-0.1.0/prepostcov/covariances_pk_xi.py

@@ -0,0 +1,150 @@
+import numpy as np
+from typing import Dict, Iterable, List, Optional
+from scipy.special import spherical_jn
+
+from .multipoles import LegendreMultipoleExtractor, integrate_legendre_product_4
+
+
+class PkXiCovariance:
+    """
+    Compute disconnected covariance between P_ell(k) and xi_ell(r) using a P_cross(k, mu).
+
+    The covariance block for given (ell1, ell2) is
+        Cov[ P_{ell1}(k), xi_{ell2}(r) ] = ((2*ell1+1)*(2*ell2+1) / V) * jbar_{ell2}(k, r) *
+                                            sum_{L1,L2 in poles} i^{ell2} I_{ell1,ell2,L1,L2} * P_{L1}(k) * P_{L2}(k)
+    where I is the integral of four Legendre polynomials over mu in [-1, 1] and
+    jbar_{ell2}(k, r) is the r-bin-averaged spherical Bessel j_{ell2}(k r).
+
+    Parameters
+    - k: 1D np.ndarray of k values (nk,)
+    - r: 1D np.ndarray of r-bin centers (nr,)
+    - V: survey volume
+    - poles_Pk: list of P multipoles to include (even ells), e.g., [0, 2, 4]
+    - poles_Xi: list of xi multipoles to include (even ells), e.g., [0, 2, 4]
+    - ngauss_leg_product: Gauss-Legendre order (half-range) for 4-Legendre integral; 2*ngauss used total
+    - r_avg_nsamp: samples for r averaging per bin
+    """
+
+    def __init__(
+        self,
+        k: np.ndarray,
+        r: np.ndarray,
+        V: float,
+        poles_Pk: Iterable[int] = (0, 2, 4),
+        poles_Xi: Iterable[int] = (0, 2, 4),
+        ngauss_leg_product: int = 32,
+        r_avg_nsamp: int = 100,
+    ) -> None:
+        self.k = np.asarray(k)
+        self.r = np.asarray(r)
+        self.V = float(V)
+        self.poles_Pk = list(poles_Pk)
+        self.poles_Xi = list(poles_Xi)
+        self.ngauss_leg_product = int(ngauss_leg_product)
+        self.r_avg_nsamp = int(r_avg_nsamp)
+
+        # Storage for P_cross multipoles: dict ell -> array(nk,)
+        self.Pcross_ells: Optional[Dict[int, np.ndarray]] = None
+
+        # Precompute 4-Legendre integrals for all combinations
+        self._I4 = self._precompute_I4()
+
+        # Precompute r-averaging grids per bin
+        self._rr_grid = self._build_r_window_grid()
+
+    # ----- Public API -----
+    def set_Pcross_from_callable(self, P_of_mu, ells: Iterable[int] = (0, 2, 4), ngauss_eval: int = 8) -> None:
+        """Compute and store P_cross multipoles from a callable P(k, mu)."""
+        ext = LegendreMultipoleExtractor(ngauss=ngauss_eval)
+        self.Pcross_ells = ext.project(P_of_mu, ells=tuple(ells))
+
+    def set_Pcross_from_dict(self, Pcross_ells: Dict[int, np.ndarray]) -> None:
+        """Provide precomputed P_cross multipoles as a dict ell -> P_ell(k)."""
+        # Basic validation
+        nk = self.k.shape[0]
+        for ell, arr in Pcross_ells.items():
+            arr = np.asarray(arr)
+            if arr.shape[0] != nk:
+                raise ValueError(f"P_cross ell={ell} has length {arr.shape[0]} != nk={nk}")
+        self.Pcross_ells = {int(k): np.asarray(v) for k, v in Pcross_ells.items()}
+
+    def compute_covariance(self) -> np.ndarray:
+        """
+        Return cov_Pkell_Xiell with shape (len(poles_Pk), len(poles_Xi), nk, nr).
+        Requires Pcross_ells to be set.
+        """
+        if self.Pcross_ells is None:
+            raise RuntimeError("Pcross_ells not set. Call set_Pcross_from_callable or set_Pcross_from_dict first.")
+
+        nk = self.k.shape[0]
+        nr = self.r.shape[0]
+        cov = np.zeros((len(self.poles_Pk), len(self.poles_Xi), nk, nr))
+
+        # Precompute P_ell arrays for all Pk poles
+        P_arrays = {ell: np.asarray(self.Pcross_ells[ell]) for ell in self.poles_Pk}
+
+        # Precompute jmean_kr for each xi multipole (returns (nr,))
+        jmean_cache: Dict[int, np.ndarray] = {}
+        for ell2 in self.poles_Xi:
+            jmean_cache[ell2] = self._jmean_kr(ell2)  # (nr,)
+
+        # Loop over desired covariance blocks
+        for i, ell1 in enumerate(self.poles_Pk):
+            for j, ell2 in enumerate(self.poles_Xi):
+                # Sum over L1, L2
+                S_k = np.zeros(nk)
+                for L1 in self.poles_Pk:
+                    P1 = P_arrays[L1]
+                    for L2 in self.poles_Pk:
+                        P2 = P_arrays[L2]
+                        I = self._I4[(ell1, ell2, L1, L2)]  # scalar
+                        S_k += I * (P1 * P2)
+                # Prefactor depends on r only (via jmean), and on ells, V
+                pref = 1.j**ell2 * ((2 * ell1 + 1) * (2 * ell2 + 1) / self.V) * jmean_cache[ell2]  # (nr,)
+                cov[i, j, :, :] = S_k[:, None] * pref[None, :]
+
+        return cov
+
+    # ----- Internal helpers -----
+    def _precompute_I4(self) -> Dict[tuple, float]:
+        I4: Dict[tuple, float] = {}
+        for ell1 in self.poles_Pk:
+            for ell2 in self.poles_Xi:
+                for L1 in self.poles_Pk:
+                    for L2 in self.poles_Pk:
+                        I = integrate_legendre_product_4((ell1, ell2, L1, L2), ngauss=self.ngauss_leg_product)
+                        I4[(ell1, ell2, L1, L2)] = I
+        return I4
+
+    def _build_r_window_grid(self) -> np.ndarray:
+        """Build an r-grid for averaging around each r-bin center, shape (ns, nr)."""
+        r = self.r  # (nr,)
+        nr = r.shape[0]
+        ns = self.r_avg_nsamp
+        if nr > 1:
+            r_step = float(np.mean(np.diff(r)))
+        else:
+            r_step = 0.0
+        # Uniform samples in [r_j - r_step, r_j + r_step] for each r_j
+        t = np.linspace(-1.0, 1.0, ns)[:, None]  # (ns,1)
+        rr = r[None, :] + t * r_step  # (ns, nr)
+        return rr
+
+    def _jmean_kr(self, ell: int) -> np.ndarray:
+        """Compute ⟨ j_ell(k r) ⟩_r over the r-window; returns array (nk, nr)."""
+        k = self.k  # (nk,)
+        rr = self._rr_grid  # (ns, nr)
+        ns, nr = rr.shape
+
+        # Denominator per r-bin: ∫ rr^2 drr over the window
+        den = np.trapz(rr ** 2, x=rr, axis=0)  # (nr,)
+
+        # Numerator per r-bin and k-bin
+        num = np.zeros((k.shape[0], nr))
+        for j in range(nr):
+            r_col = rr[:, j]  # (ns,)
+            y = spherical_jn(ell, k[:, None] * r_col[None, :]) * (r_col[None, :] ** 2)  # (nk, ns)
+            num[:, j] = np.trapz(y, x=r_col, axis=1)  # (nk,)
+
+        jmean = num / den[None, :]
+        return jmean  # (nk, nr)

prepostcov-0.1.0/prepostcov/multipoles.py

@@ -0,0 +1,143 @@
+import numpy as np
+from typing import Dict, Iterable, Optional
+
+
+class LegendreMultipoleExtractor:
+    """
+    Helper to project an anisotropic P(k, mu) onto Legendre multipoles P_ell(k).
+
+    Usage patterns:
+    - Preferred (accurate): pass a callable P(mu) -> Pk (1D array over k). The class will
+      evaluate it at Gauss-Legendre nodes and use quadrature to integrate over mu in [-1, 1].
+    - Fallback (data grid): pass a 2D array Pkmu with a corresponding mu_array. The class will
+      integrate using the trapezoidal rule (assuming P is even in mu if mu_array in [0, 1]).
+
+    Normalization: P_ell(k) = (2*ell+1)/2 * int_{-1}^{1} dmu P(k, mu) L_ell(mu)
+    """
+
+    def __init__(
+        self,
+        ngauss: int = 8,
+    ) -> None:
+        """
+        Parameters
+        - ngauss: number of positive-side Gauss-Legendre nodes to use (total nodes = 2*ngauss)
+        """
+        assert ngauss >= 2, "ngauss should be >= 2"
+        self.ngauss = ngauss
+        # Full-range Gauss-Legendre nodes/weights on [-1, 1]
+        self.mu_full, self.w_full = np.polynomial.legendre.leggauss(2 * ngauss)
+        # Positive half [0, 1] subset of nodes (ascending)
+        self.mu_pos = self.mu_full[ngauss:]
+
+    @staticmethod
+    def _legendre_L(ell: int, mu):
+        return np.polynomial.legendre.Legendre.basis(ell)(mu)
+
+    def project(
+        self,
+        Pkmu,
+        ells: Iterable[int] = (0, 2, 4),
+        mu_array: Optional[np.ndarray] = None,
+    ) -> Dict[int, np.ndarray]:
+        """
+        Project P(k, mu) onto Legendre multipoles.
+
+        Parameters
+        - Pkmu: either a callable f(mu) -> Pk (shape (nk,)) or a 2D array with shape (nmu, nk)
+        - ells: iterable of even multipoles to compute, e.g., (0, 2, 4)
+        - mu_array: if Pkmu is an array, the corresponding mu grid. If None and Pkmu is callable,
+                    Gauss-Legendre nodes are used automatically.
+
+        Returns
+        - dict mapping ell -> P_ell(k) as a 1D array of length nk
+        """
+        ells = list(ells)
+        if any(ell < 0 or int(ell) != ell for ell in ells):
+            raise ValueError("Multipoles must be non-negative integers")
+
+        # Case 1: callable -> use Gauss-Legendre quadrature for best accuracy
+        if callable(Pkmu):
+            # Evaluate P at positive mu nodes (assumes evenness in mu)
+            P_pos = np.atleast_2d(np.array([Pkmu(mu) for mu in self.mu_pos]))  # (nmu_pos, nk)
+            if P_pos.ndim != 2:
+                raise ValueError("Callable must return a 1D array over k for each mu")
+            # Build full-range values using evenness: P(-mu) = P(+mu)
+            P_full = np.vstack((P_pos[::-1], P_pos))  # (2*ngauss, nk), order matches mu_full
+
+            results: Dict[int, np.ndarray] = {}
+            for ell in ells:
+                L_full = self._legendre_L(ell, self.mu_full)[:, None]  # (2*ngauss, 1)
+                pref = (2 * ell + 1) / 2.0
+                P_ell = pref * np.sum(self.w_full[:, None] * L_full * P_full, axis=0)
+                results[ell] = P_ell
+            return results
+
+        # Case 2: grid data -> use provided mu grid and trapz integration
+        if mu_array is None:
+            raise ValueError("mu_array must be provided when Pkmu is an array")
+
+        mu_array = np.asarray(mu_array)
+        P_arr = np.asarray(Pkmu)
+        if P_arr.ndim != 2:
+            raise ValueError("Pkmu array must be 2D with shape (nmu, nk)")
+        if P_arr.shape[0] != mu_array.shape[0]:
+            raise ValueError("First dimension of Pkmu must match length of mu_array")
+
+        # Determine if mu_array spans [0,1] (half-range) or [-1,1] (full-range)
+        half_range = (mu_array.min() >= 0) and (mu_array.max() <= 1)
+        full_range = (mu_array.min() >= -1) and (mu_array.max() <= 1) and not half_range
+        if not (half_range or full_range):
+            raise ValueError("mu_array must lie within [0,1] or [-1,1]")
+
+        results: Dict[int, np.ndarray] = {}
+        for ell in ells:
+            L_vals = self._legendre_L(ell, mu_array)[:, None]  # (nmu, 1)
+            if half_range:
+                # Assume even P(k, mu) and integrate over [0,1] with factor 2
+                pref = (2 * ell + 1) / 2.0
+                P_ell = 2 * pref * np.trapz(P_arr * L_vals, x=mu_array, axis=0)
+            else:
+                # Full-range integration over [-1,1]
+                pref = (2 * ell + 1) / 2.0
+                P_ell = pref * np.trapz(P_arr * L_vals, x=mu_array, axis=0)
+            results[ell] = P_ell
+        return results
+
+
+def integrate_legendre_product_4(ells, ngauss: int = 16) -> float:
+    """
+    Compute I = ∫_{-1}^{1} dμ ∏_{i=1}^4 L_{ℓ_i}(μ), where L_ℓ is the Legendre polynomial.
+
+    Uses Gauss–Legendre quadrature (accurate for smooth polynomials) and
+    cheaply enforces obvious parity selection: if sum(ells) is odd, the integral is 0.
+
+    Parameters
+    - ells: iterable of 4 non-negative integers (ℓ1, ℓ2, ℓ3, ℓ4)
+    - ngauss: number of Gauss nodes per half-range (uses 2*ngauss total)
+
+    Returns
+    - float integral value
+
+    Notes
+    - An exact analytic expression exists in terms of Wigner symbols via product expansions,
+      but high-order closed forms are cumbersome. For EFT use-cases, Gauss rules are exact for
+      polynomials up to degree 4*max(ells) with sufficiently large order; 2*ngauss nodes exactly
+      integrate polynomials up to order 4*ngauss-1. Choose ngauss >= max(ells)+1 for exactness.
+    """
+    ells = list(ells)
+    if len(ells) != 4:
+        raise ValueError("ells must contain exactly four integers")
+    if any((not isinstance(L, int)) or L < 0 for L in ells):
+        raise ValueError("All ell must be non-negative integers")
+
+    # Parity selection: product of four Legendre polynomials is even if sum(ell) is even.
+    if (sum(ells) % 2) == 1:
+        return 0.0
+
+    # Quadrature
+    mu, w = np.polynomial.legendre.leggauss(2 * ngauss)
+    prod = np.ones_like(mu)
+    for L in ells:
+        prod *= np.polynomial.legendre.Legendre.basis(L)(mu)
+    return float(np.sum(w * prod))

prepostcov-0.1.0/prepostcov.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: prepostcov
+Version: 0.1.0
+Summary: Covariance and multipole tools for power spectrum and correlation function analysis.
+Home-page: https://github.com/abaleato/PrePostCov/tree/main
+Author: A. Baleato Lizancos & M. Maus
+Author-email: a.baleatolizancos@berkeley.edu
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy

prepostcov-0.1.0/prepostcov.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+setup.py
+prepostcov/__init__.py
+prepostcov/__main__.py
+prepostcov/covariances_pk_xi.py
+prepostcov/multipoles.py
+prepostcov.egg-info/PKG-INFO
+prepostcov.egg-info/SOURCES.txt
+prepostcov.egg-info/dependency_links.txt
+prepostcov.egg-info/entry_points.txt
+prepostcov.egg-info/requires.txt
+prepostcov.egg-info/top_level.txt

prepostcov-0.1.0/prepostcov.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

prepostcov-0.1.0/prepostcov.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+prepostcov = prepostcov.__main__:main

prepostcov-0.1.0/prepostcov.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy
+scipy

prepostcov-0.1.0/prepostcov.egg-info/top_level.txt

@@ -0,0 +1 @@
+prepostcov

prepostcov-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

prepostcov-0.1.0/setup.py

@@ -0,0 +1,28 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="prepostcov",
+    version="0.1.0",
+    description="Covariance and multipole tools for power spectrum and correlation function analysis.",
+    author="A. Baleato Lizancos & M. Maus",
+    author_email="a.baleatolizancos@berkeley.edu",
+    url="https://github.com/abaleato/PrePostCov/tree/main",
+    packages=find_packages(),
+    install_requires=[
+        "numpy",
+        "scipy",
+        # Add other dependencies as needed
+    ],
+    entry_points={
+        "console_scripts": [
+            "prepostcov=prepostcov.__main__:main"
+        ]
+    },
+    python_requires=">=3.7",
+    license="MIT",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+)