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

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

@@ -880,5 +880,4 @@ dictionary_subterms = {
     "vv_0_2": 1,
 }
 multi_index_model = False
-redshift_dependent_model = False
 regularize_M_terms = {"gg": "mpmath", "gv": "mpmath", "vv": None}

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

@@ -7,11 +7,12 @@ def get_coefficients(
     model_kind,
     parameter_values_dict,
     variant=None,
-    redshift_dict=None,
+    covariance_prefactor_dict=None,
 ):
     H0 = parameter_values_dict["H0"]
     Omega_m0 = parameter_values_dict["Omega_m0"]
-    redshift_velocity = redshift_dict["v"]
+
+    redshift_velocity = covariance_prefactor_dict["redshift_velocity"]
 
     D1_z = D1_function(redshift_velocity, Omega_m0)
     D1_0 = D1_function(0, Omega_m0)

flip/covariance/{carreres23 → analytical/ravouxnoanchor25}/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 variant == "growth_index":
         partial_coefficients_dict = {

flip/covariance/{ravouxnoanchor25 → analytical/ravouxnoanchor25}/flip_terms.py

@@ -2,8 +2,6 @@ import mpmath
 import numpy
 import scipy
 
-from flip.covariance.ravouxnoanchor25.coefficients import D1_function
-
 
 def set_backend(module):
     global np, erf
@@ -40,15 +38,8 @@ def N_vv_0_2_0(theta, phi):
     return (9 / 2) * np.cos(2 * phi) + (3 / 2) * np.cos(theta)
 
 
-def Z_vv_0(k, redshift_1, redshift_2, Omega_m0, knl):
-    D1_z1 = D1_function(redshift_1, Omega_m0)
-    D1_z2 = D1_function(redshift_2, Omega_m0)
-    return np.exp(np.outer((D1_z1 - D1_z2) ** 2, -((k / knl) ** 2)))
-
-
 dictionary_terms = {"vv": ["0"]}
 dictionary_lmax = {"vv": [2]}
 dictionary_subterms = {"vv_0_0": 1, "vv_0_1": 0, "vv_0_2": 1}
 multi_index_model = False
-redshift_dependent_model = True
 regularize_M_terms = None

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

@@ -204,10 +204,10 @@ def get_coefficients(
     parameter_values_dict,
     model_kind,
     variant=None,
-    redshift_dict=None,
+    covariance_prefactor_dict=None,
 ):
-    redshift_velocities = redshift_dict["v"]
-    a = 1 / (1 + redshift_velocities)
+    redshift_velocity = covariance_prefactor_dict["redshift_velocity"]
+    a = 1 / (1 + redshift_velocity)
 
     coefficients_dict = {}
     if variant == "growth_index":
@@ -220,9 +220,9 @@ def get_coefficients(
         gamma = parameter_values_dict["gamma"]
 
         coefficient_vector = (
-            aH(1 / (1 + redshift_velocities))
+            aH(1 / (1 + redshift_velocity))
             * f(a, Om0, gamma)
-            * s8_approx(redshift_velocities, Om0, gamma)
+            * s8_approx(redshift_velocity, Om0, gamma)
         )
 
         coefficients_dict["vv"] = [np.outer(coefficient_vector, coefficient_vector)]
@@ -233,7 +233,7 @@ def get_coefficients(
         #      P = (aHfs8)(aHfs8) (P_fid/s8^2_fid)
 
         fs8 = parameter_values_dict["fs8"]
-        coefficient_vector = aH(1 / (1 + redshift_velocities)) * fs8
+        coefficient_vector = aH(1 / (1 + redshift_velocity)) * fs8
 
         coefficients_dict["vv"] = [np.outer(coefficient_vector, coefficient_vector)]
     else:

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

@@ -1,7 +1,5 @@
 import numpy as np
-from astropy.cosmology import FlatLambdaCDM
-
-from flip.covariance.rcrk24.coefficients import (
+from flip.covariance.analytical.rcrk24.coefficients import (
     aH,
     dfdgamma,
     dfdOm0,
@@ -29,11 +27,11 @@ def get_partial_derivative_coefficients(
     model_kind,
     parameter_values_dict,
     variant=None,
-    redshift_dict=None,
+    covariance_prefactor_dict=None,
 ):
     partial_coefficients_dict = None
-    redshift_velocities = redshift_dict["v"]
-    a = 1 / (1 + redshift_velocities)
+    redshift_velocity = covariance_prefactor_dict["redshift_velocity"]
+    a = 1 / (1 + redshift_velocity)
 
     if variant == "growth_index":
         # vv
@@ -46,20 +44,20 @@ def get_partial_derivative_coefficients(
         # The Om0-gamma model f=Omega(Om0)^gamma
         aH_values = aH(a)
         f_values = f(a, Om0, gamma)  # cosmoOm ** parameter_values_dict["gamma"]
-        s8_values = s8(redshift_velocities, Om0, gamma)
+        s8_values = s8(redshift_velocity, Om0, gamma)
         aHfs8 = aH_values * f_values * s8_values
 
         dfdOm0_values = dfdOm0(a, Om0, gamma)
         dfdgamma_values = dfdgamma(a, Om0, gamma)
 
         ds8dO0_values = ds8dO0(
-            redshift_velocities,
+            redshift_velocity,
             Om0,
             gamma,
             s8_values=s8_values,
         )
         ds8dgamma_values = ds8dgamma(
-            redshift_velocities,
+            redshift_velocity,
             Om0,
             gamma,
             s8_values=s8_values,

flip/covariance/{rcrk24 → analytical/rcrk24}/flip_terms.py

@@ -15,9 +15,6 @@ def set_backend(module):
 
 set_backend("numpy")
 
-import scipy.integrate as integrate
-from astropy.cosmology import FlatLambdaCDM
-
 exact = False
 
 
@@ -43,13 +40,8 @@ def N_vv_0_2_0(theta, phi):
     return (9 / 2) * np.cos(2 * phi) + (3 / 2) * np.cos(theta)
 
 
-def Z_vv_0(k, redshift_1, redshift_2):
-    return 1
-
-
 dictionary_terms = {"vv": ["0"]}
 dictionary_lmax = {"vv": [2]}
 dictionary_subterms = {"vv_0_0": 1, "vv_0_1": 0, "vv_0_2": 1}
 multi_index_model = False
-redshift_dependent_model = True
 regularize_M_terms = None

flip/covariance/contraction.py

@@ -2,7 +2,6 @@ import importlib
 
 import numpy as np
 
-from flip.covariance import cov_utils
 from flip.covariance import generator as generator_flip
 from flip.utils import create_log
 
@@ -10,6 +9,13 @@ log = create_log()
 
 
 class Contraction:
+    """Container for contracted covariance components and coordinates.
+
+    Holds precomputed contraction tensors (per block gg/gv/vv) and the
+    corresponding coordinate grids. Provides utilities to build from flip
+    covariance generators and to evaluate weighted sums via model coefficients.
+    """
+
     def __init__(
         self,
         model_name=None,
@@ -17,15 +23,23 @@ class Contraction:
         contraction_dict=None,
         coordinates_dict=None,
         basis_definition=None,
-        redshift_dict=None,
         variant=None,
     ):
+        """Initialize the contraction container.
+
+        Args:
+            model_name (str|None): Covariance model package name.
+            model_kind (str|None): `"density"`, `"velocity"`, `"full"`, or `"density_velocity"`.
+            contraction_dict (dict|None): Arrays per block (e.g., `{"gg": [..], "vv": [..]}`).
+            coordinates_dict (dict|None): Coordinates like `r_perpendicular`, `r_parallel`, etc.
+            basis_definition (str|None): Basis choice, e.g., `"bisector"`, `"mean"`, `"endpoint"`.
+            variant (str|None): Optional model variant.
+        """
         self.model_name = model_name
         self.model_kind = model_kind
         self.contraction_dict = contraction_dict
         self.coordinates_dict = coordinates_dict
         self.basis_definition = basis_definition
-        self.redshift_dict = redshift_dict
         self.variant = variant
 
     @classmethod
@@ -45,10 +59,29 @@ class Contraction:
         variant=None,
         **kwargs,
     ):
+        """Build a `Contraction` from flip covariance generator outputs.
+
+        Args:
+            model_name (str): Covariance model name under `flip.covariance`.
+            model_kind (str): `"density"`, `"velocity"`, `"full"`, or `"density_velocity"`.
+            power_spectrum_dict (dict): Power spectra per block: keys `gg`, `vv`, and optional `gv`.
+            coord_1 (ndarray): First coordinate grid (e.g., `r_perp` or `r`).
+            coord_2 (ndarray): Second coordinate grid (e.g., `r_par` or `mu`).
+            coord_1_reference (float): Reference point first coordinate.
+            coord_2_reference (float): Reference point second coordinate.
+            coordinate_type (str): `"rprt"` or `"rmu"`.
+            additional_parameters_values (dict|None): Extra model parameters.
+            basis_definition (str): Basis choice for angular definitions.
+            redshift (float|None): Optional redshift context.
+            variant (str|None): Model variant.
+            **kwargs: Options forwarded to generator.
+
+        Returns:
+            Contraction: Initialized instance with tensors and coordinates.
+        """
         (
             contraction_dict,
             coordinates_dict,
-            redshift_dict,
         ) = contract_covariance(
             model_name,
             model_kind,
@@ -70,25 +103,15 @@ class Contraction:
             contraction_dict=contraction_dict,
             coordinates_dict=coordinates_dict,
             basis_definition=basis_definition,
-            redshift_dict=redshift_dict,
             variant=variant,
         )
 
     @property
     def type(self):
-        """
-        The type function is used to determine the type of covariance model that will be computed.
-        The options are:
-            - velocity: The covariance model is computed for velocity only.
-            - density: The covariance model is computed for density only.
-            - density_velocity: The covariance model is computed for both velocity and density, without cross-term (i.e., the covariances between velocities and densities are zero). This option should be used when computing a full 3D tomography in which we want to compute a separate 1D tomography along each axis (x, y, z
-
-        Args:
-            self: Represent the instance of the class
+        """Return the model kind and log a short description.
 
         Returns:
-            The type of the model
-
+            str: `model_kind` as provided on initialization.
         """
         if self.model_kind == "velocity":
             log.add("The covariance model is computed for velocity")
@@ -108,27 +131,22 @@ class Contraction:
         self,
         parameter_values_dict,
     ):
-        """
-        The compute_contraction_sum function computes the sum of all the contractions
-            for a given model type and parameter values.
+        """Compute weighted sum of contraction tensors using model coefficients.
 
         Args:
-            self: Make the function a method of the class
-            parameter_values_dict: Get the coefficients for each of the covariances
-            : Get the coefficients of the model
+            parameter_values_dict (dict): Parameters to obtain coefficients.
 
         Returns:
-            A dictionary of contraction_covariance_sum
+            dict: Sum per block, e.g., `{"gg": array, "vv": array, "gv": array}`.
         """
         coefficients = importlib.import_module(
-            f"flip.covariance.{self.model_name}.coefficients"
+            f"flip.covariance.analytical.{self.model_name}.coefficients"
         )
 
         coefficients_dict = coefficients.get_coefficients(
             parameter_values_dict,
             self.model_kind,
             variant=self.variant,
-            redshift_dict=self.redshift_dict,
         )
         contraction_covariance_sum_dict = {}
         if self.model_kind == "density":
@@ -174,7 +192,7 @@ class Contraction:
                 axis=0,
             )
         else:
-            log.add(f"Wrong model type in the loaded covariance.")
+            log.add("Wrong model type in the loaded covariance.")
 
         return contraction_covariance_sum_dict
 
@@ -187,6 +205,23 @@ def compute_contraction_coordinates(
     coordinate_type,
     basis_definition,
 ):
+    """Compute coordinate grids and derived angles for contractions.
+
+    Supports `rmu` and `rprt` input coordinate parameterizations and basis
+    definitions `bisector`, `mean`, and `endpoint`.
+
+    Args:
+        coord_1 (ndarray): First coordinate grid.
+        coord_2 (ndarray): Second coordinate grid.
+        coord_1_reference (float): Reference first coordinate.
+        coord_2_reference (float): Reference second coordinate.
+        coordinate_type (str): `"rmu"` or `"rprt"`.
+        basis_definition (str): `"bisector"`, `"mean"`, or `"endpoint"`.
+
+    Returns:
+        tuple: `(coordinates_dict, coordinates)` where `coordinates_dict` holds
+        2D grids and `coordinates` is a stacked array `[r, theta, phi]` per point.
+    """
     shape_coord_1_coord_2 = len(coord_1) * len(coord_2)
 
     if coordinate_type == "rmu":
@@ -285,6 +320,26 @@ def contract_covariance(
     number_worker=8,
     hankel=True,
 ):
+    """Generate contraction tensors for the specified model and blocks.
+
+    Args:
+        model_name (str): Covariance model name under `flip.covariance`.
+        model_kind (str): `"density"`, `"velocity"`, `"full"`, or `"density_velocity"`.
+        power_spectrum_dict (dict): Power spectra per block.
+        coord_1 (ndarray): First coordinate grid.
+        coord_2 (ndarray): Second coordinate grid.
+        coord_1_reference (float): Reference first coordinate.
+        coord_2_reference (float): Reference second coordinate.
+        coordinate_type (str): Input parameterization, `"rprt"` or `"rmu"`.
+        additional_parameters_values (dict|None): Extra model parameters.
+        basis_definition (str): Basis choice.
+        redshift (float|None): Optional redshift context.
+        number_worker (int): Parallel workers used by generator.
+        hankel (bool): Use FFTLog Hankel transform when True.
+
+    Returns:
+        tuple: `(contraction_dict, coordinates_dict)`.
+    """
     # r_perpendicular : coord_1, r_parallel : coord_2
     coordinates_dict, coordinates = compute_contraction_coordinates(
         coord_1,
@@ -295,19 +350,6 @@ def contract_covariance(
         basis_definition,
     )
 
-    redshift_dependent_model = generator_flip.get_redshift_dependent_model_flag(
-        model_name
-    )
-    if redshift_dependent_model:
-        redshift_dict = cov_utils.generate_redshift_dict(
-            model_name,
-            model_kind,
-            redshift_velocity=redshift,
-            redshift_density=redshift,
-        )
-    else:
-        redshift_dict = None
-
     contraction_dict = {}
     if model_kind in ["density", "full", "density_velocity"]:
         contraction_dict["gg"] = generator_flip.compute_coeficient(
@@ -342,4 +384,4 @@ def contract_covariance(
             hankel=hankel,
         )[:, :].reshape(-1, len(coord_1), len(coord_2))
 
-    return contraction_dict, coordinates_dict, redshift_dict
+    return contraction_dict, coordinates_dict