flipcosmo 1.0.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

flip/covariance/{lai22 → analytical/lai22}/generator.py

@@ -9,35 +9,64 @@ from scipy.interpolate import interp1d
 from scipy.special import factorial, spherical_jn
 
 from flip.covariance import cov_utils
-from flip.covariance.lai22 import h_terms
 
 
-def compute_correlation_coefficient_simple_integration(p, q, l, r, k, pk):
-    """ " Here the sigma_u is added to pk later.
-    The (2*np.pi**2) is added here in the Lai et al. formalism."""
+def compute_correlation_coefficient_simple_integration(p, q, ell, r, k, pk):
+    """Compute correlation coefficient via direct integration.
+
+    Implements Lai et al. formalism with the ``(2π^2)`` factor inside the
+    integrand. The small-scale velocity dispersion (``sigma_u``) should be
+    applied to ``pk`` upstream when required.
+
+    Args:
+        p: Power of k from derivative order on point 1.
+        q: Power of k from derivative order on point 2.
+        ell: Spherical Bessel order.
+        r: Separation values at which to evaluate.
+        k: Wavenumbers.
+        pk: Power spectrum values at ``k``.
+
+    Returns:
+        Array of correlation coefficient values at separations ``r``.
+    """
     kr = np.outer(k, r)
-    integrand = spherical_jn(l, kr).T * k**2 * k ** (2 * (p + q)) * pk / (2 * np.pi**2)
+    integrand = (
+        spherical_jn(ell, kr).T * k**2 * k ** (2 * (p + q)) * pk / (2 * np.pi**2)
+    )
     return integrate.simpson(integrand, x=k)
 
 
 def compute_correlation_coefficient_hankel(
-    p, q, l, r, k, pk, hankel_overhead_coefficient=2
+    p, q, ell, r, k, pk, hankel_overhead_coefficient=2
 ):
-    """Highly decrease time and memory consumption.
-    Cosmoprimo prefactor is removed here
-    When r is too small for the hankel range, standard integration is used.
-    To avoid edge effects when using hankel, the mask have an overhead
+    """Compute correlation coefficient using FFTLog Hankel transform.
+
+    Uses cosmoprimo's ``PowerToCorrelation`` to accelerate the computation.
+    Falls back to direct integration for small ``r`` values where the Hankel
+    result may be unreliable, controlled by ``hankel_overhead_coefficient``.
+
+    Args:
+        p: Power of k from derivative order on point 1.
+        q: Power of k from derivative order on point 2.
+        ell: Spherical Bessel order.
+        r: Separation values.
+        k: Wavenumbers.
+        pk: Power spectrum values.
+        hankel_overhead_coefficient: Safety margin for the small-``r`` mask.
+
+    Returns:
+        Array of correlation coefficient values at separations ``r``.
     """
     integrand = k ** (2 * (p + q)) * pk
-    Hankel = cosmoprimo.fftlog.PowerToCorrelation(k, ell=l, q=0, complex=False)
+    Hankel = cosmoprimo.fftlog.PowerToCorrelation(k, ell=ell, q=0, complex=False)
     Hankel.set_fft_engine("numpy")
     r_hankel, xi_hankel = Hankel(integrand)
     mask = r < np.min(r_hankel) * hankel_overhead_coefficient
     output = np.empty_like(r)
     output[mask] = compute_correlation_coefficient_simple_integration(
-        p, q, l, r[mask], k, pk
+        p, q, ell, r[mask], k, pk
     )
-    output[~mask] = (-1) ** (l // 2) * interp1d(r_hankel, xi_hankel)(r[~mask])
+    output[~mask] = (-1) ** (ell // 2) * interp1d(r_hankel, xi_hankel)(r[~mask])
     return output
 
 
@@ -53,6 +82,23 @@ def compute_cov_vv(
     hankel=True,
     los_definition="bisector",
 ):
+    """Compute velocity-velocity covariance in Lai22 wide-angle formalism.
+
+    Args:
+        ra: Right ascensions of objects (radians).
+        dec: Declinations of objects (radians).
+        comoving_distance: Comoving distances of objects.
+        wavenumber_tt: Wavenumbers for velocity-velocity spectrum.
+        power_spectrum_tt: P_tt values at ``wavenumber_tt``.
+        grid_window_v_tt: Optional window function applied to ``P_tt``.
+        size_batch: Batch size for pair processing.
+        number_worker: Number of parallel workers (1 for serial).
+        hankel: If True, use Hankel transform acceleration where applicable.
+        los_definition: Line-of-sight definition ("bisector").
+
+    Returns:
+        Flattened covariance vector with the diagonal term at index 0 followed by upper-triangle terms.
+    """
     if grid_window_v_tt is not None:
         power_spectrum_tt = power_spectrum_tt * grid_window_v_tt**2
 
@@ -92,18 +138,29 @@ def compute_cov_vv(
 
 
 def coefficient_vv(wavenumber, power_spectrum_tt, coord, hankel=True):
+    """Coefficient contributing to vv covariance for a given separation.
+
+    Args:
+        wavenumber: Wavenumbers array.
+        power_spectrum_tt: Velocity-velocity power spectrum at ``wavenumber``.
+        coord: Tuple/list ``(r, theta, phi)`` separation coordinates.
+        hankel: If True, use Hankel transform; else use direct integration.
+
+    Returns:
+        Scalar covariance contribution at the provided separation.
+    """
     result = 0
-    for l in [0, 2]:
+    for ell in [0, 2]:
         if hankel:
             correlation = compute_correlation_coefficient_hankel(
-                -0.5, -0.5, l, coord[0], wavenumber, power_spectrum_tt
+                -0.5, -0.5, ell, coord[0], wavenumber, power_spectrum_tt
             )
         else:
             correlation = compute_correlation_coefficient_simple_integration(
-                -0.5, -0.5, l, coord[0], wavenumber, power_spectrum_tt
+                -0.5, -0.5, ell, coord[0], wavenumber, power_spectrum_tt
             )
-        h_function = eval(f"h_terms.H_vv_l{l}")(coord[1], coord[2])
-        result = result + np.real(1j ** (l)) * correlation * h_function
+        h_function = eval(f"h_terms.H_vv_l{ell}")(coord[1], coord[2])
+        result = result + np.real(1j ** (ell)) * correlation * h_function
     return result
 
 
@@ -129,6 +186,36 @@ def compute_cov_gg(
     hankel=True,
     los_definition="bisector",
 ):
+    """Compute density-density covariance terms for Lai22 wide-angle.
+
+    Builds per-``m`` contributions for b², f² and bf components using sums over
+    ``p,q,ℓ`` multipoles with optional damping on the matter-matter spectrum.
+
+    Args:
+        pmax: Maximum p index.
+        qmax: Maximum q index.
+        ra: Right ascensions (radians).
+        dec: Declinations (radians).
+        comoving_distance: Comoving distances.
+        wavenumber_mm: Wavenumbers for matter-matter spectrum.
+        wavenumber_mt: Wavenumbers for matter-velocity spectrum.
+        wavenumber_tt: Wavenumbers for velocity-velocity spectrum.
+        power_spectrum_mm: P_mm at ``wavenumber_mm``.
+        power_spectrum_mt: P_mv at ``wavenumber_mt``.
+        power_spectrum_tt: P_vv at ``wavenumber_tt``.
+        grid_window_m_mm: Optional window for P_mm.
+        grid_window_m_mt: Optional window for P_mv.
+        grid_window_v_mt: Optional velocity window multiplying P_mv.
+        grid_window_v_tt: Optional window for P_vv.
+        size_batch: Batch size for pair processing.
+        number_worker: Number of workers (1 for serial).
+        sig_damp_mm_gg_m: Damping scale for P_mm high-k suppression in gg b² terms.
+        hankel: Use Hankel transform acceleration when True.
+        los_definition: Line-of-sight definition ("bisector").
+
+    Returns:
+        Tuple ``(m_index, cov_gg_b2, cov_gg_f2, cov_gg_bf)`` with lists of flattened per-m covariance vectors (variance inserted at index 0).
+    """
     if grid_window_m_mm is not None:
         power_spectrum_mm = power_spectrum_mm * grid_window_m_mm**2
 
@@ -298,6 +385,26 @@ def compute_cov_gg_add(
     hankel=True,
     los_definition="bisector",
 ):
+    """Compute additional gg b² terms only (e.g. for additive components).
+
+    Args:
+        pmax: Maximum p index.
+        qmax: Maximum q index.
+        ra: Right ascensions (radians).
+        dec: Declinations (radians).
+        comoving_distance: Comoving distances.
+        wavenumber_mm: Wavenumbers for matter-matter spectrum.
+        power_spectrum_mm: P_mm values.
+        grid_window_m_mm: Optional window for P_mm.
+        size_batch: Batch size for pair processing.
+        number_worker: Number of workers.
+        sig_damp_mm_gg_m: Damping scale for P_mm high-k suppression.
+        hankel: Use Hankel transform acceleration when True.
+        los_definition: Line-of-sight definition.
+
+    Returns:
+        Tuple ``(m_index, cov_gg_b2_add)`` with flattened covariance vectors including variance at index 0.
+    """
     if grid_window_m_mm is not None:
         power_spectrum_mm = power_spectrum_mm * grid_window_m_mm**2
 
@@ -383,6 +490,21 @@ def coefficient_gg_b2_m(
     coord,
     hankel=True,
 ):
+    """b² coefficient for gg block at fixed m.
+
+    Args:
+        wavenumber_mm: Wavenumbers for P_mm.
+        power_spectrum_mm: P_mm values (with optional damping applied inside).
+        iter_pq: Array of all (p, q) combinations.
+        sum_iter_pq: Array of ``2*(p+q)`` per (p, q) used for m filtering.
+        m_value: Even m index for basis term.
+        sig_damp_mm_gg_m: Damping scale for P_mm when ``m_value != 0``.
+        coord: Separation coordinates ``(r, theta, phi)``.
+        hankel: Use Hankel transform acceleration when True.
+
+    Returns:
+        Scalar contribution for the given separation.
+    """
     if (sig_damp_mm_gg_m is not None) and (m_value != 0):
         power_spectrum_mm = power_spectrum_mm * np.exp(
             -((wavenumber_mm * sig_damp_mm_gg_m) ** 4) / 2
@@ -392,18 +514,18 @@ def coefficient_gg_b2_m(
     for pq in pq_index:
         p, q = pq[0], pq[1]
         lmax = 2 * (p + q + 1)
-        for l in range(0, lmax + 1, 2):
+        for ell in range(0, lmax + 1, 2):
             if hankel:
                 correlation = compute_correlation_coefficient_hankel(
-                    p, q, l, coord[0], wavenumber_mm, power_spectrum_mm
+                    p, q, ell, coord[0], wavenumber_mm, power_spectrum_mm
                 )
             else:
                 correlation = compute_correlation_coefficient_simple_integration(
-                    p, q, l, coord[0], wavenumber_mm, power_spectrum_mm
+                    p, q, ell, coord[0], wavenumber_mm, power_spectrum_mm
                 )
-            h_function = eval(f"h_terms.H_gg_l{l}_p{p}_q{q}")(coord[1], coord[2])
+            h_function = eval(f"h_terms.H_gg_l{ell}_p{p}_q{q}")(coord[1], coord[2])
             coeff = (
-                np.real(1j ** (l))
+                np.real(1j ** (ell))
                 * ((-1) ** (p + q))
                 / (2 ** (p + q) * factorial(p) * factorial(q))
             )
@@ -420,23 +542,30 @@ def coefficient_gg_f2_m(
     coord,
     hankel=True,
 ):
+    """f² coefficient for gg block at fixed m.
+
+    Args mirror those of ``coefficient_gg_b2_m`` but using P_tt and h-terms shifted by +1.
+
+    Returns:
+        Scalar contribution for the given separation.
+    """
     result = 0
     pq_index = iter_pq[sum_iter_pq == m_value]
     for pq in pq_index:
         p, q = pq[0], pq[1]
         lmax = 2 * (p + q + 1)
-        for l in range(0, lmax + 1, 2):
+        for ell in range(0, lmax + 1, 2):
             if hankel:
                 correlation = compute_correlation_coefficient_hankel(
-                    p, q, l, coord[0], wavenumber_tt, power_spectrum_tt
+                    p, q, ell, coord[0], wavenumber_tt, power_spectrum_tt
                 )
             else:
                 correlation = compute_correlation_coefficient_simple_integration(
-                    p, q, l, coord[0], wavenumber_tt, power_spectrum_tt
+                    p, q, ell, coord[0], wavenumber_tt, power_spectrum_tt
                 )
-            h_function = eval(f"h_terms.H_gg_l{l}_p{p+1}_q{q+1}")(coord[1], coord[2])
+            h_function = eval(f"h_terms.H_gg_l{ell}_p{p+1}_q{q+1}")(coord[1], coord[2])
             coeff = (
-                np.real(1j ** (l))
+                np.real(1j ** (ell))
                 * ((-1) ** (p + q))
                 / (2 ** (p + q) * factorial(p) * factorial(q))
             )
@@ -453,25 +582,34 @@ def coefficient_gg_bf_m(
     coord,
     hankel=True,
 ):
+    """bf cross coefficient for gg block at fixed m.
+
+    Combines the two h-terms with indices (p+1,q) and (p,q+1).
+
+    Args mirror those of ``coefficient_gg_b2_m`` but using P_mt.
+
+    Returns:
+        Scalar contribution for the given separation.
+    """
     result = 0
     pq_index = iter_pq[sum_iter_pq == m_value]
     for pq in pq_index:
         p, q = pq[0], pq[1]
         lmax = 2 * (p + q + 1)
-        for l in range(0, lmax + 1, 2):
+        for ell in range(0, lmax + 1, 2):
             if hankel:
                 correlation = compute_correlation_coefficient_hankel(
-                    p, q, l, coord[0], wavenumber_mt, power_spectrum_mt
+                    p, q, ell, coord[0], wavenumber_mt, power_spectrum_mt
                 )
             else:
                 correlation = compute_correlation_coefficient_simple_integration(
-                    p, q, l, coord[0], wavenumber_mt, power_spectrum_mt
+                    p, q, ell, coord[0], wavenumber_mt, power_spectrum_mt
                 )
-            h_function = eval(f"h_terms.H_gg_l{l}_p{p+1}_q{q}")(
+            h_function = eval(f"h_terms.H_gg_l{ell}_p{p+1}_q{q}")(
                 coord[1], coord[2]
-            ) + eval(f"h_terms.H_gg_l{l}_p{p}_q{q+1}")(coord[1], coord[2])
+            ) + eval(f"h_terms.H_gg_l{ell}_p{p}_q{q+1}")(coord[1], coord[2])
             coeff = (
-                np.real(1j ** (l))
+                np.real(1j ** (ell))
                 * ((-1) ** (p + q))
                 / (2 ** (p + q) * factorial(p) * factorial(q))
             )
@@ -499,6 +637,23 @@ def compute_cov_gv(
     hankel=True,
     los_definition="bisector",
 ):
+    """Compute density-velocity covariance terms for Lai22 wide-angle.
+
+    Args:
+        pmax: Maximum p index.
+        ra_g, dec_g, comoving_distance_g: Galaxy coordinates and distances.
+        ra_v, dec_v, comoving_distance_v: Velocity coordinates and distances.
+        wavenumber_mt, wavenumber_tt: Wavenumbers for cross and velocity spectra.
+        power_spectrum_mt, power_spectrum_tt: Corresponding spectra values.
+        grid_window_m_mt, grid_window_v_mt, grid_window_v_tt: Optional windows.
+        size_batch: Batch size.
+        number_worker: Number of workers.
+        hankel: Use Hankel acceleration when True.
+        los_definition: Line-of-sight definition.
+
+    Returns:
+        Tuple ``(m_index, cov_gv_f2, cov_gv_bf)`` with lists of flattened covariance vectors.
+    """
     if grid_window_m_mt is not None:
         power_spectrum_mt = power_spectrum_mt * grid_window_m_mt
 
@@ -597,19 +752,31 @@ def coefficient_gv_f2_p(
     coord,
     hankel=True,
 ):
+    """f² coefficient for gv block at fixed p.
+
+    Args:
+        wavenumber_tt: Wavenumbers for P_tt.
+        power_spectrum_tt: P_tt values.
+        p: p index.
+        coord: Separation coordinates ``(r, theta, phi)``.
+        hankel: Use Hankel acceleration when True.
+
+    Returns:
+        Scalar contribution for the given separation.
+    """
     result = 0
     lmax = 2 * (p + 1)
-    for l in range(1, lmax + 1, 2):
+    for ell in range(1, lmax + 1, 2):
         if hankel:
             correlation = compute_correlation_coefficient_hankel(
-                p, -0.5, l, coord[0], wavenumber_tt, power_spectrum_tt
+                p, -0.5, ell, coord[0], wavenumber_tt, power_spectrum_tt
             )
         else:
             correlation = compute_correlation_coefficient_simple_integration(
-                p, -0.5, l, coord[0], wavenumber_tt, power_spectrum_tt
+                p, -0.5, ell, coord[0], wavenumber_tt, power_spectrum_tt
             )
-        h_function = eval(f"h_terms.H_gv_l{l}_p{p+1}")(coord[1], coord[2])
-        coeff = np.real(1j ** (l + 1)) * ((-1) ** p) / (2**p * factorial(p))
+        h_function = eval(f"h_terms.H_gv_l{ell}_p{p+1}")(coord[1], coord[2])
+        coeff = np.real(1j ** (ell + 1)) * ((-1) ** p) / (2**p * factorial(p))
         result = result + coeff * correlation * h_function
     return result
 
@@ -621,24 +788,39 @@ def coefficient_gv_bf_p(
     coord,
     hankel=True,
 ):
+    """bf cross coefficient for gv block at fixed p.
+
+    Args mirror those of ``coefficient_gv_f2_p`` but using P_mt and different h-term.
+
+    Returns:
+        Scalar contribution for the given separation.
+    """
     result = 0
     lmax = 2 * (p + 1)
-    for l in range(1, lmax + 1, 2):
+    for ell in range(1, lmax + 1, 2):
         if hankel:
             correlation = compute_correlation_coefficient_hankel(
-                p, -0.5, l, coord[0], wavenumber_mt, power_spectrum_mt
+                p, -0.5, ell, coord[0], wavenumber_mt, power_spectrum_mt
             )
         else:
             correlation = compute_correlation_coefficient_simple_integration(
-                p, -0.5, l, coord[0], wavenumber_mt, power_spectrum_mt
+                p, -0.5, ell, coord[0], wavenumber_mt, power_spectrum_mt
             )
-        h_function = eval(f"h_terms.H_gv_l{l}_p{p}")(coord[1], coord[2])
-        coeff = np.real(1j ** (l + 1)) * ((-1) ** p) / (2**p * factorial(p))
+        h_function = eval(f"h_terms.H_gv_l{ell}_p{p}")(coord[1], coord[2])
+        coeff = np.real(1j ** (ell + 1)) * ((-1) ** p) / (2**p * factorial(p))
         result = result + coeff * correlation * h_function
     return result
 
 
 def return_matrix_covariance(cov):
+    """Convert flattened covariance vector (variance + upper triangle) to matrix.
+
+    Args:
+        cov: 1D array with diagonal at index 0 and upper-triangle entries following.
+
+    Returns:
+        Square covariance matrix reconstructed from the flattened representation.
+    """
     variance_val = cov[0]
 
     non_diagonal_cov = np.delete(cov, 0)
@@ -656,6 +838,14 @@ def return_matrix_covariance(cov):
 
 
 def return_correlation_matrix(cov):
+    """Compute correlation matrix from covariance matrix.
+
+    Args:
+        cov: Square covariance matrix.
+
+    Returns:
+        Correlation matrix with unit diagonal.
+    """
     sigma = np.sqrt(np.diag(cov))
     corr_matrix = cov / np.outer(sigma, sigma)
     return corr_matrix
@@ -687,6 +877,24 @@ def compute_all_matrices(
     number_worker=1,
     hankel=True,
 ):
+    """Compute all Lai22 covariance blocks and assemble matrices.
+
+    Args:
+        ra_density, dec_density, rcom_density: Galaxy coordinates and distances.
+        ra_vel, dec_vel, rcom_vel: Velocity coordinates and distances.
+        wavenumber_mm, wavenumber_mt, wavenumber_tt: Wavenumber grids.
+        power_spectrum_gg_mm, power_spectrum_gg_mt, power_spectrum_gg_tt: Spectra for gg terms.
+        power_spectrum_gv_mt, power_spectrum_gv_tt: Spectra for gv terms.
+        power_spectrum_vv_tt: Spectrum for vv term.
+        grid_window_*: Optional window functions.
+        pmax, qmax: Max indices for expansions.
+        size_batch: Batch size.
+        number_worker: Parallel workers.
+        hankel: Use Hankel acceleration when True.
+
+    Returns:
+        Tuple of matrices and indices: ``(cov_gg_b2_m, cov_gg_bf_m, cov_gg_f2_m, m_index_gg, cov_gv_bf_m, cov_gv_f2_m, m_index_gv, cov_vv)``.
+    """
     m_index_gg, cov_gg_b2, cov_gg_f2, cov_gg_bf = compute_cov_gg(
         pmax,
         qmax,
@@ -780,22 +988,21 @@ def generate_covariance(
     qmax=3,
     **kwargs,
 ):
-    """
-    The generate_covariance function generates the covariance matrix for a given model type.
+    """Generate Lai22 covariance blocks for requested model kind.
+
+    Wide-angle definition follows the bisector as in Lai et al. (2022).
 
     Args:
-        model_kind: Determine which covariance matrices are computed
-        power_spectrum_dict: Pass the power spectrum of the density and velocity fields
-        coordinates_velocity: Pass the coordinates of the velocity field
-        coordinates_density: Define the coordinates of the density field
-        pmax: Set the maximum order of legendre polynomials used to compute the covariance matrix
-        qmax: Set the maximum order of legendre polynomials used in the expansion
-        Wide angle defined in Lai et al. 2022 by the bisector.
-        **kwargs: Pass keyword arguments to the function
-        : Define the model type
+        model_kind: One of ``"density"``, ``"velocity"``, ``"full"``, ``"density_velocity"`` indicating which blocks to compute.
+        power_spectrum_dict: Dict containing required spectra for gg/gv/vv blocks.
+        coordinates_velocity: Tuple ``(ra, dec, rcom)`` for velocity tracers.
+        coordinates_density: Tuple ``(ra, dec, rcom)`` for density tracers.
+        pmax: Maximum p index.
+        qmax: Maximum q index.
+        **kwargs: Extra options forwarded to lower-level functions (e.g., windowing, batching, hankel).
 
     Returns:
-        A dictionary of covariance matrices, the number of density points and the number of velocity points
+        Tuple ``(covariance_dict, number_densities, number_velocities, los_definition)``.
     """
 
     los_definition = "bisector"
@@ -858,11 +1065,9 @@ def generate_covariance(
             **kwargs,
         )
 
-    redshift_dict = None
     return (
         covariance_dict,
         number_densities,
         number_velocities,
         los_definition,
-        redshift_dict,
     )

flip/covariance/{lai22 → analytical/lai22}/symbolic.py

@@ -8,9 +8,17 @@ from sympy.simplify.fu import TR8
 
 
 def simplify_h(H, max_simplification=20):
-    """simplification tests with https://docs.sympy.org/latest/tutorials/intro-tutorial/simplification.html
-    https://docs.sympy.org/latest/modules/simplify/simplify.html#ratsimpmodprime
-    https://docs.sympy.org/dev/modules/simplify/fu.html#sympy.simplify.fu
+    """Iteratively simplify a symbolic expression for H terms.
+
+    Applies ``TR8`` and factoring repeatedly up to ``max_simplification`` times
+    or until convergence. See SymPy docs on simplification strategies.
+
+    Args:
+        H: SymPy expression representing an H term.
+        max_simplification: Maximum number of iterations to apply.
+
+    Returns:
+        Simplified SymPy expression.
     """
     H_simplified = sy.factor(TR8(H))
     i = 0
@@ -20,7 +28,20 @@ def simplify_h(H, max_simplification=20):
     return H_simplified
 
 
-def generate_h_term(l, p, q):
+def generate_h_term(ell, p, q):
+    """Generate the H term for Lai22 wide-angle coefficients.
+
+    Constructs the angular function ``H_{ℓ}^{p,q}(θ,ϕ)`` using Gaunt integrals
+    and Legendre polynomials, then simplifies the symbolic result.
+
+    Args:
+        ell: Multipole order ℓ (integer).
+        p: Half-integer or integer index for point 1 (interpreted as rational).
+        q: Half-integer or integer index for point 2 (interpreted as rational).
+
+    Returns:
+        SymPy expression of ``H(θ, ϕ)``.
+    """
     theta, phi = sy.symbols("theta phi")
     mu = sy.symbols("mu")
     l1max = int(2 * p + 1)
@@ -50,12 +71,12 @@ def generate_h_term(l, p, q):
 
             h_sum = 0
 
-            for m in range(-l, l + 1):
+            for m in range(-ell, ell + 1):
                 for m1 in range(-l1, l1 + 1):
                     for m2 in range(-l2, l2 + 1):
-                        sum_term = wigner.gaunt(l, l1, l2, m, m1, m2)
+                        sum_term = wigner.gaunt(ell, l1, l2, m, m1, m2)
                         sum_term *= (
-                            sy.Ynm(l, m, sy.pi - phi, 0)
+                            sy.Ynm(ell, m, sy.pi - phi, 0)
                             * sy.Ynm(l1, m1, theta / 2, 0)
                             * sy.Ynm(l2, m2, theta / 2, sy.pi)
                         )
@@ -68,12 +89,27 @@ def generate_h_term(l, p, q):
 
 
 def write_h_terms(pmax, qmax, filename="./h_terms.py", number_worker=1):
+    """Generate and write H-term Python functions to a file.
+
+    Produces three sets of functions: gg with even ℓ up to ``2(p+q+1)``, gv with
+    odd ℓ up to ``2(p+1)``, and vv with even ℓ up to 2. The functions are
+    emitted as NumPy-evaluable code via ``pycode``.
+
+    Args:
+        pmax: Maximum p index.
+        qmax: Maximum q index.
+        filename: Output Python file path for the generated H-term functions.
+        number_worker: Number of workers for parallel generation.
+
+    Returns:
+        None. Writes functions to ``filename``.
+    """
     params_pool = []
     for p in range(pmax + 1):
         for q in range(qmax + 1):
             lmax = 2 * (p + q + 1)
-            for l in range(0, lmax + 1, 2):
-                params_pool.append([l, p, q])
+            for ell in range(0, lmax + 1, 2):
+                params_pool.append([ell, p, q])
 
     if number_worker == 1:
         output_H_gg = [generate_h_term(*param) for param in params_pool]
@@ -84,8 +120,8 @@ def write_h_terms(pmax, qmax, filename="./h_terms.py", number_worker=1):
     params_pool = []
     for p in range(pmax + 1):
         lmax = 2 * (p + 1)
-        for l in range(1, lmax + 1, 2):
-            params_pool.append([l, p, 1 / 2])
+        for ell in range(1, lmax + 1, 2):
+            params_pool.append([ell, p, 1 / 2])
 
     if number_worker == 1:
         output_H_gv = [generate_h_term(*param) for param in params_pool]
@@ -95,8 +131,8 @@ def write_h_terms(pmax, qmax, filename="./h_terms.py", number_worker=1):
 
     params_pool = []
     lmax = 2
-    for l in range(0, lmax + 1, 2):
-        params_pool.append([l, 1 / 2, 1 / 2])
+    for ell in range(0, lmax + 1, 2):
+        params_pool.append([ell, 1 / 2, 1 / 2])
 
     if number_worker == 1:
         output_H_vv = [generate_h_term(*param) for param in params_pool]
@@ -114,10 +150,10 @@ def write_h_terms(pmax, qmax, filename="./h_terms.py", number_worker=1):
     for p in range(pmax + 1):
         for q in range(qmax + 1):
             lmax = 2 * (p + q + 1)
-            for l in range(0, lmax + 1, 2):
+            for ell in range(0, lmax + 1, 2):
                 H_txt = pycode(output_H_gg[i]).replace("math.", "np.")
                 i = i + 1
-                f.write(f"def H_gg_l{l}_p{p}_q{q}(theta,phi):\n")
+                f.write(f"def H_gg_l{ell}_p{p}_q{q}(theta,phi):\n")
                 f.write(f"    return({H_txt})\n")
                 f.write("\n")
 
@@ -126,10 +162,10 @@ def write_h_terms(pmax, qmax, filename="./h_terms.py", number_worker=1):
     i = 0
     for p in range(pmax + 1):
         lmax = 2 * (p + 1)
-        for l in range(1, lmax + 1, 2):
+        for ell in range(1, lmax + 1, 2):
             H_txt = pycode(output_H_gv[i]).replace("math.", "np.")
             i = i + 1
-            f.write(f"def H_gv_l{l}_p{p}(theta,phi):\n")
+            f.write(f"def H_gv_l{ell}_p{p}(theta,phi):\n")
             f.write(f"    return({H_txt})\n")
             f.write("\n")
 
@@ -137,10 +173,10 @@ def write_h_terms(pmax, qmax, filename="./h_terms.py", number_worker=1):
     f.write("# Velocity-Velocity \n")
     lmax = 2
     i = 0
-    for l in range(0, lmax + 1, 2):
+    for ell in range(0, lmax + 1, 2):
         H_txt = pycode(output_H_vv[i]).replace("math.", "np.")
         i = i + 1
-        f.write(f"def H_vv_l{l}(theta,phi):\n")
+        f.write(f"def H_vv_l{ell}(theta,phi):\n")
         f.write(f"    return({H_txt})\n")
         f.write("\n")
 

flip/covariance/{ravouxcarreres → analytical/ravouxcarreres}/coefficients.py

@@ -2,7 +2,7 @@ def get_coefficients(
     parameter_values_dict,
     model_kind,
     variant=None,
-    redshift_dict=None,
+    covariance_prefactor_dict=None,
 ):
     coefficients_dict = {}
     if model_kind in ["density", "full", "density_velocity"]:

flip/covariance/{ravouxcarreres → analytical/ravouxcarreres}/fisher_terms.py

@@ -5,7 +5,7 @@ def get_partial_derivative_coefficients(
     model_kind,
     parameter_values_dict,
     variant=None,
-    redshift_dict=None,
+    covariance_prefactor_dict=None,
 ):
     if model_kind == "density":
         return get_partial_derivative_coefficients_density(