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

flip/power_spectra/generator.py

@@ -1,9 +1,8 @@
+import importlib
 import os
 
 import numpy as np
 
-from flip.power_spectra import class_engine, cosmoprimo_engine, models, pyccl_engine
-
 _available_engines = ["class_engine", "cosmoprimo_engine", "pyccl_engine"]
 _available_power_spectrum_model = ["linearbel", "nonlinearbel", "linear"]
 _available_power_spectrum_normalizaton = [
@@ -20,6 +19,11 @@ def get_power_spectrum_suffix(
     number_points,
     log_space,
 ):
+    """Build a filename suffix encoding spectrum sampling settings.
+
+    Returns:
+        str: Suffix including z, kmin, kmax, N, and log/lin tag.
+    """
     return f"z{redshift}_kmin{minimal_wavenumber:.4f}_kmax{maximal_wavenumber:.4f}_N{number_points}{'_log' if log_space else '_lin'}"
 
 
@@ -28,6 +32,16 @@ def get_power_spectrum_name(
     power_spectrum_type,
     suffix,
 ):
+    """Construct a power spectrum filename for saving.
+
+    Args:
+        power_spectrum_model (str): Model name, e.g., `linearbel`.
+        power_spectrum_type (str): One of `mm`, `mt`, `tt`.
+        suffix (str): Sampling suffix from `get_power_spectrum_suffix`.
+
+    Returns:
+        str: Filename `power_spectrum_<model>_<type>_<suffix>.txt`.
+    """
     return f"power_spectrum_{power_spectrum_model}_{power_spectrum_type}_{suffix}.txt"
 
 
@@ -40,6 +54,17 @@ def save_power_spectrum(
     header,
     path,
 ):
+    """Save a power spectrum to disk as a two-row text file.
+
+    Args:
+        wavenumber (ndarray): $k$ samples.
+        power_spectrum (ndarray): Spectrum values.
+        power_spectrum_model (str): Model name.
+        power_spectrum_type (str): `mm`, `mt`, or `tt`.
+        suffix (str): Sampling suffix.
+        header (str): Header string with metadata.
+        path (str): Directory where to save.
+    """
     power_spectrum_name = get_power_spectrum_name(
         power_spectrum_model,
         power_spectrum_type,
@@ -66,29 +91,26 @@ def compute_power_spectra(
     power_spectrum_model="linearbel",
     save_path=None,
 ):
-    """Compute the power spectrum.
+    """Compute and optionally save MM/MT/TT power spectra.
 
     Args:
-        power_spectrum_engine (str): engine to use to compute the power spectrum, see _available_engines.
-        power_spectrum_settings (dic or cosmo): configuration for the engine.
-        redshift (float): the redshift at which compute the power spectrum.
-        minimal_wavenumber (float): minimum k in h/Mpc.
-        maximal_wavenumber (float): maximum k in h/Mpc.
-        number_points (int): Sampling of the power spectrum.
-        logspace (bool, optional): Sample the power spectrum in logspace or linspace. Defaults to True.
-        normalization_power_spectrum (str, optional): which normalisation to use. Defaults to "no_normalization".
-            Available options are: "no_normalization", "growth_rate" or "growth_amplitude".
-        power_spectrum_non_linear_model (str, optional): Non-linear model to compute. Defaults to None.
-        power_spectrum_model (str, optional): Non-linear model to apply to the computed power spectrum, see _available_power_spectrum_model. Defaults to "linearbel".
-        save_path (str, optional): Path to save the computed power spectrum. Defaults to None.
-
-    Raises:
-        ValueError: power_spectrum_engine is not available
-        ValueError: power_spectrum_model is not available
-        ValueError: _description_
+        power_spectrum_engine (str): Engine module, one of `_available_engines`.
+        power_spectrum_settings (dict|object): Engine configuration.
+        redshift (float): Target redshift.
+        minimal_wavenumber (float): Minimum $k$ in h/Mpc.
+        maximal_wavenumber (float): Maximum $k$ in h/Mpc.
+        number_points (int): Number of $k$ samples.
+        logspace (bool): Sample $k$ in log-space if True.
+        normalization_power_spectrum (str): One of `_available_power_spectrum_normalizaton`.
+        power_spectrum_non_linear_model (str|None): Non-linear engine flag for CLASS.
+        power_spectrum_model (str): One of `_available_power_spectrum_model`.
+        save_path (str|None): Directory to save spectra.
 
     Returns:
-        _type_: _description_
+        tuple: `(k, P_mm, P_mt, P_tt, fiducial_dict)`.
+
+    Raises:
+        ValueError: If engine or model name is unsupported.
     """
     if power_spectrum_engine not in _available_engines:
         raise ValueError(
@@ -101,7 +123,7 @@ def compute_power_spectra(
             f"PLease choose between {_available_power_spectrum_model}"
         )
 
-    engine = eval(power_spectrum_engine)
+    engine = importlib.import_module(f"flip.power_spectra.{power_spectrum_engine}")
 
     (
         wavenumber,
@@ -117,10 +139,10 @@ def compute_power_spectra(
         logspace=logspace,
         non_linear_model=power_spectrum_non_linear_model,
     )
+    module = importlib.import_module("flip.power_spectra.models")
+    model_function = getattr(module, f"get_{power_spectrum_model}_model")
 
-    power_spectrum_mm, power_spectrum_mt, power_spectrum_tt = eval(
-        f"models.get_{power_spectrum_model}_model"
-    )(
+    power_spectrum_mm, power_spectrum_mt, power_spectrum_tt = model_function(
         wavenumber,
         power_spectrum_linear,
         power_spectrum_non_linear=power_spectrum_non_linear,

flip/power_spectra/models.py

@@ -2,17 +2,16 @@ import numpy as np
 
 
 def bel_coefficients(sigma_8):
-    """
-    The bel_coefficients function takes in a value for sigma_8 and returns the values of the coefficients
-    a_i, i = 1, 2, 3 and invkdelta as well as b. These are used to calculate the non-linear power spectrum using
-    the fitting formula from Bel et al. (2007). The function is called by Class when calculating P(k)
+    """Compute BEL model coefficients as a function of $\sigma_8$.
+
+    Uses the parameterization from Bel et al. to construct coefficients
+    for the non-linear damping terms.
 
     Args:
-        sigma_8: Calculate the coefficients of the bessel function
+        sigma_8 (float): Amplitude of matter fluctuations in 8 Mpc/h spheres.
 
     Returns:
-        The coefficients a_i, i = 1,
-
+        tuple: `(a1, a2, a3, invkdelta, b)` coefficients.
     """
     a1 = -0.817 + 3.198 * sigma_8
     a2 = 0.877 - 4.191 * sigma_8
@@ -27,19 +26,15 @@ def get_bel_model(
     power_spectrum_linear,
     **kwargs,
 ):
-    """
-    The get_bel_model function takes in the linear power spectrum, wavenumber, and sigma_8 value.
-    It then calculates the nonlinear matter-matter power spectrum using a fitting function from Bel et al. (2014).
-    The function also returns the nonlinear matter-matter cross correlation coefficient.
+    """Apply BEL damping to linear spectrum to get TT and MT forms.
 
     Args:
-        wavenumber: Calculate the power spectrum
-        power_spectrum_linear: Calculate the nonlinear power spectrum
-        **kwargs: Pass a variable number of keyword arguments to a function
-        : Calculate the nonlinear power spectrum
+        wavenumber (ndarray): $k$ values in h/Mpc.
+        power_spectrum_linear (ndarray): Linear matter power spectrum $P_{mm}^{lin}(k)$.
+        **kwargs: Must include `sigma_8`.
 
     Returns:
-        The nonlinear matter power spectrum and the nonlinear galaxy clustering power spectrum
+        tuple: `(P_mt(k), P_tt(k))` BEL-damped spectra.
     """
     if "sigma_8" not in kwargs.keys():
         raise ValueError("Fiducial sigma_8 value is needed for nonlinearbel model")
@@ -62,18 +57,15 @@ def get_nonlinearbel_model(
     power_spectrum_linear,
     **kwargs,
 ):
-    """
-    The get_nonlinearbel_model function returns the nonlinear power spectra for a given linear power spectrum.
+    """Return BEL-damped spectra using an external non-linear $P_{mm}$.
 
     Args:
-        wavenumber: Get the wavenumber of the power spectrum
-        power_spectrum_linear: Calculate the power_spectrum_mt and power_spectrum_tt
-        **kwargs: Pass a variable number of keyword arguments to a function
-        : Get the nonlinear power spectrum
+        wavenumber (ndarray): $k$ values in h/Mpc.
+        power_spectrum_linear (ndarray): Linear $P_{mm}^{lin}(k)$.
+        **kwargs: Must include `power_spectrum_non_linear` and `sigma_8`.
 
     Returns:
-        The nonlinear power spectrum of matter, the cross power spectrum of matter and tracers and the auto-power spectrum of tracers
-
+        tuple: `(P_mm(k), P_mt(k), P_tt(k))` with $P_mm$ taken from engine.
     """
     if "power_spectrum_non_linear" not in kwargs.keys():
         raise ValueError("Non linear power spectrum is needed for nonlinearbel model")
@@ -95,17 +87,15 @@ def get_linearbel_model(
     power_spectrum_linear,
     **kwargs,
 ):
-    """
-    The get_linearbel_model function returns the linear BEL model for a given power spectrum.
+    """Return linear spectra with BEL damping applied to MT and TT.
 
     Args:
-        wavenumber: Calculate the wavenumber in h/mpc
-        power_spectrum_linear: Calculate the power spectrum of the matter field
-        **kwargs: Pass a variable number of keyword arguments to the function
-        : Set the value of the power spectrum
+        wavenumber (ndarray): $k$ values in h/Mpc.
+        power_spectrum_linear (ndarray): Linear $P_{mm}^{lin}(k)$.
+        **kwargs: Must include `sigma_8`.
 
     Returns:
-        The linear power spectrum and the
+        tuple: `(P_mm, P_mt, P_tt)` with `P_mm = P_lin`.
     """
     power_spectrum_mt, power_spectrum_tt = get_bel_model(
         wavenumber, power_spectrum_linear, **kwargs
@@ -120,5 +110,14 @@ def get_linear_model(
     power_spectrum_linear,
     **kwargs,
 ):
+    """Return purely linear spectra for MM, MT, and TT.
+
+    Args:
+        wavenumber (ndarray): $k$ values (unused).
+        power_spectrum_linear (ndarray): Linear $P_{mm}^{lin}(k)$.
+
+    Returns:
+        tuple: `(P_mm, P_mt, P_tt)` all equal to `P_lin`.
+    """
 
     return power_spectrum_linear, power_spectrum_linear, power_spectrum_linear

flip/power_spectra/pyccl_engine.py

@@ -6,7 +6,7 @@ log = create_log()
 
 try:
     import pyccl as ccl
-except:
+except ImportError:
     log.add(
         "Install CCL https://github.com/LSSTDESC/CCL to use pyccl_engine.py module",
         level="warning",
@@ -19,10 +19,28 @@ _pyccl_setting_default = {}
 
 
 def get_fiducial_fs8(model, redshift):
+    """Return fiducial $f\sigma_8$ using PyCCL at redshift.
+
+    Args:
+        model (ccl.Cosmology): PyCCL cosmology.
+        redshift (float): Target redshift.
+
+    Returns:
+        float: $f(z)\,\sigma_8(z)$ (using PyCCL conventions).
+    """
     return model.growth_rate(1 / (1 + redshift))
 
 
 def get_fiducial_s8(model, redshift):
+    """Return fiducial $\sigma_8$ using PyCCL at redshift.
+
+    Args:
+        model (ccl.Cosmology): PyCCL cosmology.
+        redshift (float): Target redshift.
+
+    Returns:
+        float: $\sigma_8(z)$.
+    """
     return model.sigmaR(8 / model.to_dict()["h"], 1 / (1 + redshift))
 
 
@@ -35,6 +53,23 @@ def compute_power_spectrum(
     non_linear_model=None,
     logspace=True,
 ):
+    """Compute linear/non-linear $P(k)$ using PyCCL.
+
+    Args:
+        power_spectrum_settings (dict): PyCCL settings (cosmology + flags).
+        redshift (float): Redshift for $P(k)$.
+        minimal_wavenumber (float): Minimum $k$ in h/Mpc.
+        maximal_wavenumber (float): Maximum $k$ in h/Mpc.
+        number_points (int): Number of $k$ samples.
+        non_linear_model (str|None): PyCCL matter power spectrum model key.
+        logspace (bool): Sample $k$ in log-space when True.
+
+    Returns:
+        tuple: `(k, P_lin, P_nl_or_None, fiducial_dict)`.
+
+    Raises:
+        Exception: Propagates PyCCL errors with a helpful message.
+    """
     if logspace:
         wavenumber = np.logspace(
             np.log10(minimal_wavenumber),

flip/utils.py

@@ -2,29 +2,35 @@ import logging
 import time
 
 import astropy.constants as acst
+import matplotlib.pyplot as plt
 import numpy as np
 
 _C_LIGHT_KMS_ = acst.c.to("km/s").value
 
 
 def Du(k, sigmau):
+    """Damping function Du(k, sigma_u) = sin(k sigma_u) / (k sigma_u).
+
+    Args:
+        k (array-like): Wavenumber values.
+        sigmau (float): Velocity dispersion parameter.
+
+    Returns:
+        numpy.ndarray: Damping values for each `k`.
+    """
     return np.sin(k * sigmau) / (k * sigmau)
 
 
 def radec2cart(rcom, ra, dec):
-    """
-    The radec2cart function takes in the comoving distance to a galaxy,
-        its right ascension and declination, and returns the x, y, z coordinates
-        of that galaxy.
+    """Convert spherical (r, ra, dec) to Cartesian (x, y, z).
 
     Args:
-        rcom: Convert the ra and dec to cartesian coordinates
-        ra: Calculate the x-coordinate of a point in space
-        dec: Calculate the z coordinate
+        rcom (array-like): Comoving distances.
+        ra (array-like): Right ascension in radians.
+        dec (array-like): Declination in radians.
 
     Returns:
-        The x, y and z coordinates of each galaxy
-
+        tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]: x, y, z coordinates.
     """
     x = rcom * np.cos(ra) * np.cos(dec)
     y = rcom * np.sin(ra) * np.cos(dec)
@@ -33,18 +39,15 @@ def radec2cart(rcom, ra, dec):
 
 
 def cart2radec(x, y, z):
-    """
-    The cart2radec function converts cartesian coordinates to spherical
-    coordinates.  The input is a set of x, y, and z values.  The output is the
-    radius (rcom), right ascension (ra), and declination (dec).
+    """Convert Cartesian (x, y, z) to spherical (r, ra, dec).
 
     Args:
-        x: Represent the x-coordinate of a point in space
-        y: Calculate the right ascension
-        z: Calculate the declination
+        x (array-like): X coordinates.
+        y (array-like): Y coordinates.
+        z (array-like): Z coordinates.
 
     Returns:
-        The radius, right ascension and declination of a point in cartesian coordinates
+        tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]: rcom, ra, dec.
     """
     rcom = np.sqrt(x**2 + y**2 + z**2)
     ra = np.arctan2(y, x)
@@ -55,34 +58,49 @@ def cart2radec(x, y, z):
 
 
 def return_key(dictionary, string, default_value):
-    """
-    The return_key function takes a dictionary, a string, and a default value.
-    It returns the value of the key in the dictionary that matches the string if it exists.
-    If not, it returns the default_value.
+    """Return value for `string` in `dictionary`, or a default.
 
     Args:
-        dictionary: Pass in a dictionary to the function
-        string: Specify the key to look up in the dictionary
-        default_value: Return a default value if the key is not in the dictionary
+        dictionary (dict): Input mapping.
+        string (str): Key to retrieve.
+        default_value (Any): Fallback if key is absent.
 
     Returns:
-        A value from a dictionary
+        Any: `dictionary[string]` if present, else `default_value`.
     """
     return dictionary[string] if string in dictionary.keys() else default_value
 
 
-def create_log(log_level="info"):
+def __secret_logo__(first_album=False):
+    """Show the hidden flip WEBP logo.
+
+    Args:
+        first_album (bool): Show the first album variant.
     """
-    The create_log function creates a logger object that can be used to log messages.
-    The function takes one argument, the log_level, which is set to "info" by default.
-    The function returns a Logger object with the specified logging level.
+    from PIL import Image
+
+    from flip import __flip_dir_path__
+
+    if first_album:
+        img = Image.open(f"{__flip_dir_path__}/data/.htmp/flip_first_album.webp")
+    else:
+        # Load the WEBP image
+        img = Image.open(f"{__flip_dir_path__}/data/.htmp/flip_heavy.webp")
+
+    # Display it with matplotlib
+    plt.imshow(img)
+    plt.axis("off")
+    plt.show()
+
+
+def create_log(log_level="info"):
+    """Create and configure a global logger.
 
     Args:
-        log_level: Set the logging level
+        log_level (str): One of `info`, `debug`, `warning`.
 
     Returns:
-        A logger object
-
+        Logger: Configured logger wrapper.
     """
     log = Logger(log_level=log_level)
     log.setup_logging()
@@ -94,33 +112,17 @@ _logging_handler = None
 
 class Logger(object):
     def __init__(self, name="Python_Report", log_level="info"):
-        """
-        The __init__ function is called when the class is instantiated.
-        It sets up the logger and defines a few variables that will be used later.
+        """Initialize Logger wrapper.
 
         Args:
-            self: Represent the instance of the class
-            name: Set the name of the report
-            log_level: Set the log level
-
-        Returns:
-            Nothing
-
+            name (str): Report filename for file logging.
+            log_level (str): Logging level name.
         """
         self.name = name
         self.log_level = log_level
 
     def setup_logging(self):
-        """
-        The setup_logging function is used to set up the logging module.
-
-        Args:
-            self: Refer to the current instance of a class
-
-        Returns:
-            Nothing
-
-        """
+        """Configure stream logging with formatted timestamps."""
         levels = {
             "info": logging.INFO,
             "debug": logging.DEBUG,
@@ -149,16 +151,7 @@ class Logger(object):
         logger.setLevel(levels[self.log_level])
 
     def setup_report_logging(self):
-        """
-        The setup_report_logging function is used to set up the logging for a report.
-
-        Args:
-            self: Represent the instance of the class
-
-        Returns:
-            None
-
-        """
+        """Configure file logging for reports using basicConfig."""
         levels = {
             "info": logging.INFO,
             "debug": logging.DEBUG,
@@ -173,19 +166,11 @@ class Logger(object):
 
     @staticmethod
     def add(line, level="info"):
-        """
-        The add function takes a line of text and adds it to the log file.
-        It also takes an optional level argument, which can be set to "info", "warning" or "debug".
-        If no level is specified, the default value is used ("info").
-
+        """Log a message at the given level.
 
         Args:
-            line: Pass the line of text to be logged
-            level: Determine the type of log message
-
-        Returns:
-            None
-
+            line (str): Message to log.
+            level (str): One of `info`, `warning`, `debug`.
         """
         if level == "info":
             logging.info(line)
@@ -196,16 +181,11 @@ class Logger(object):
 
     @staticmethod
     def add_array_statistics(arr, char):
-        """
-        The add_array_statistics function takes in an array and a character, and prints out the min, max, mean, and standard deviation of that array.
+        """Log min, max, mean, and std of an array with a label.
 
         Args:
-            arr: Store the array that is passed to the function
-            char: Specify which array is being used
-
-        Returns:
-            The minimum, maximum, mean and standard deviation of the array
-
+            arr (array-like): Input array.
+            char (str): Label to include in messages.
         """
         if arr is not None:
             Logger.add(f"Min of {char}: {arr.min()}")
@@ -215,14 +195,5 @@ class Logger(object):
 
     @staticmethod
     def close():
-        """
-        The close function shuts down the logging module.
-
-
-        Args:
-
-        Returns:
-            The return value of the logging
-
-        """
+        """Shut down the logging module cleanly."""
         logging.shutdown()

flipcosmo-1.2.1.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: flipcosmo
+Version: 1.2.1
+Summary:  Field Level Inference Package
+Author-email: Corentin Ravoux <corentin.ravoux.research@gmail.com>, Bastien Carreres <bastien.carreres@duke.edu>
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: scipy>=1.12
+Requires-Dist: matplotlib
+Requires-Dist: importlib-metadata
+Requires-Dist: emcee
+Requires-Dist: iminuit
+Requires-Dist: astropy
+Requires-Dist: mpmath
+Provides-Extra: docs
+Requires-Dist: markdown; extra == "docs"
+Requires-Dist: sphinx>=5.2.3; extra == "docs"
+Requires-Dist: sphinx-markdown-tables>=0.0.15; extra == "docs"
+Requires-Dist: numpydoc; extra == "docs"
+Requires-Dist: sphinx_book_theme; extra == "docs"
+Requires-Dist: myst-parser; extra == "docs"
+Requires-Dist: sphinx-copybutton; extra == "docs"
+Requires-Dist: sphinx-design; extra == "docs"
+Requires-Dist: sphinx-inline-tabs; extra == "docs"
+Requires-Dist: sphinx-tabs; extra == "docs"
+Requires-Dist: sphinx-autoapi; extra == "docs"
+Dynamic: license-file
+
+<img src="docs/_static/flip_logo.webp" width=350>
+
+# flip: Field Level Inference Package
+
+flip is a Python package that uses the maximum likelihood method to fit the growth rate based on the velocity and density fields. The first part of the software is the computation of a covariance matrix from a model power spectrum and the considered coordinates. This part is generalized to work for any linear power spectrum models, both for velocities, densities, and cross-terms, and it is optimized with Hankel transform for any model. In the second part, the covariance is used to create a likelihood by multiplying it by velocities or densities. Finally, this package includes some integrated fitters such as Minuit and MCMC (with emcee) to fit the growth rate of structures.
+
+
+[![Documentation Status](https://readthedocs.org/projects/flip/badge/?version=latest)](https://flip.readthedocs.io/en/latest/?badge=latest)
+
+## Quick install
+```bash
+git clone https://github.com/corentinravoux/flip.git
+cd flip
+pip install .
+```
+For now, the package requires you to install manually cosmoprimo: pip install git+https://github.com/cosmodesi/cosmoprimo
+
+
+## Required packages
+
+Mandatory: numpy, scipy, matplotlib, [cosmoprimo](https://github.com/adematti/cosmoprimo), iminuit, emcee, sympy
+
+Optional: classy, pyccl, pypower, GPy, tensorflow 
+
+## Examples
+
+For an example with velocity fit check out: <a target="_blank" href="https://colab.research.google.com/github/corentinravoux/flip/blob/main/notebook/fit_velocity.ipynb">
+  <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>
+</a>
+
+For density only: <a target="_blank" href="https://colab.research.google.com/github/corentinravoux/flip/blob/main/notebook/fit_density.ipynb">
+  <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>
+</a>
+
+For a joint fit: <a target="_blank" href="https://colab.research.google.com/github/corentinravoux/flip/blob/main/notebook/fit_joint.ipynb">
+  <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>
+</a>
+
+## Need help?
+Documentation available on [ReadTheDoc](https://flip.readthedocs.io/) 
+
+## How to cite
+
+The full description of the core concepts of this package is given [here](https://arxiv.org/abs/2501.16852).
+This package was started on the previous work of [@bastiencarreres](https://github.com/bastiencarreres), detail in [this article](https://arxiv.org/abs/2303.01198).
+Please cite both paper when using the package.