flipcosmo 1.0.0__tar.gz

flipcosmo-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 corentinravoux
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

flipcosmo-1.0.0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: flipcosmo
+Version: 1.0.0
+Summary: Field Level Inference Package
+Home-page: https://github.com/corentinravoux/flip
+Author: Corentin Ravoux
+License: MIT
+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
+
+file : README.md

flipcosmo-1.0.0/README.md

@@ -0,0 +1,46 @@
+<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.

flipcosmo-1.0.0/flip/__init__.py

@@ -0,0 +1,27 @@
+"""Init file of the flip package."""
+
+import os
+
+from flip.utils import create_log
+
+log = create_log()
+from . import (
+    covariance,
+    data_vector,
+    fisher,
+    fitter,
+    gridding,
+    likelihood,
+    power_spectra,
+    utils,
+)
+
+try:
+    import jax
+
+    jax.config.update("jax_enable_x64", True)
+except:
+    log.add("Jax is not available, loading numpy and scipy instead")
+
+__version__ = "1.0.0"
+__flip_dir_path__ = os.path.dirname(__file__)

flipcosmo-1.0.0/flip/config.py

@@ -0,0 +1 @@
+__use_jax__ = True

flipcosmo-1.0.0/flip/covariance/__init__.py

@@ -0,0 +1,15 @@
+"""Init file of the flip.covariance package."""
+
+from . import (
+    adamsblake17,
+    adamsblake17plane,
+    adamsblake20,
+    carreres23,
+    cov_utils,
+    emulators,
+    lai22,
+    ravouxcarreres,
+    ravouxnoanchor25,
+    rcrk24,
+)
+from .covariance import CovMatrix

flipcosmo-1.0.0/flip/covariance/adamsblake17/__init__.py

@@ -0,0 +1,5 @@
+_variant = [None]
+
+_free_par = {"fs8": "velocity@all", "bs8": "density@all", "sigv": "velocity@all"}
+
+_coordinate_keys = ["ra", "dec", "rcom_zobs"]

flipcosmo-1.0.0/flip/covariance/adamsblake17/coefficients.py

@@ -0,0 +1,27 @@
+def get_coefficients(
+    parameter_values_dict,
+    model_kind,
+    variant=None,
+    redshift_dict=None,
+):
+    coefficients_dict = {}
+    if model_kind in ["density", "full", "density_velocity"]:
+        coefficients_dict["gg"] = [
+            parameter_values_dict["bs8"] ** 2,
+        ]
+    if model_kind in ["full"]:
+        coefficients_dict["gv"] = [
+            parameter_values_dict["bs8"] * parameter_values_dict["fs8"],
+        ]
+    if model_kind in ["velocity", "full", "density_velocity"]:
+        coefficients_dict["vv"] = [parameter_values_dict["fs8"] ** 2]
+    return coefficients_dict
+
+
+def get_diagonal_coefficients(parameter_values_dict, model_kind):
+    coefficients_dict = {}
+    if model_kind in ["density", "full", "density_velocity"]:
+        coefficients_dict["gg"] = 0.0
+    if model_kind in ["velocity", "full", "density_velocity"]:
+        coefficients_dict["vv"] = parameter_values_dict["sigv"] ** 2
+    return coefficients_dict

flipcosmo-1.0.0/flip/covariance/adamsblake17/fisher_terms.py

@@ -0,0 +1,300 @@
+import numpy as np
+
+
+def get_partial_derivative_coefficients(
+    model_kind,
+    parameter_values_dict,
+    variant=None,
+    redshift_dict=None,
+):
+    if model_kind == "density":
+        return get_partial_derivative_coefficients_density(
+            parameter_values_dict,
+            variant=variant,
+        )
+    elif model_kind == "velocity":
+        return get_partial_derivative_coefficients_velocity(
+            parameter_values_dict,
+            variant=variant,
+        )
+    elif model_kind == "density_velocity":
+        return get_partial_derivative_coefficients_density_velocity(
+            parameter_values_dict,
+            variant=variant,
+        )
+    elif model_kind == "full":
+        return get_partial_derivative_coefficients_full(
+            parameter_values_dict,
+            variant=variant,
+        )
+
+
+def get_partial_derivative_coefficients_velocity(
+    parameter_values_dict,
+    variant=None,
+):
+    if variant == "growth_index":
+        partial_coefficients_dict = {
+            "Omegam": {
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    / parameter_values_dict["Omegam"],
+                ],
+            },
+            "gamma": {
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                ],
+            },
+            "s8": {
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+            },
+            "bs8": {
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    else:
+        partial_coefficients_dict = {
+            "fs8": {
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    return partial_coefficients_dict
+
+
+def get_partial_derivative_coefficients_density(
+    parameter_values_dict,
+    variant=None,
+):
+    if variant == "growth_index":
+        partial_coefficients_dict = {
+            "Omegam": {
+                "gg": [
+                    0,
+                ],
+            },
+            "gamma": {
+                "gg": [
+                    0,
+                ],
+            },
+            "s8": {
+                "gg": [
+                    0,
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                ],
+            },
+        }
+    else:
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                ],
+            },
+        }
+    return partial_coefficients_dict
+
+
+def get_partial_derivative_coefficients_density_velocity(
+    parameter_values_dict,
+    variant=None,
+):
+    if variant == "growth_index":
+        partial_coefficients_dict = {
+            "Omegam": {
+                "gg": [
+                    0,
+                ],
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    / parameter_values_dict["Omegam"],
+                ],
+            },
+            "gamma": {
+                "gg": [
+                    0,
+                ],
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                ],
+            },
+            "s8": {
+                "gg": [
+                    0,
+                ],
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    else:
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                ],
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    return partial_coefficients_dict
+
+
+def get_partial_derivative_coefficients_full(
+    parameter_values_dict,
+    variant=None,
+):
+    if variant == "growth_index":
+        partial_coefficients_dict = {
+            "Omegam": {
+                "gg": [
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    / parameter_values_dict["Omegam"],
+                ],
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    / parameter_values_dict["Omegam"],
+                ],
+            },
+            "gamma": {
+                "gg": [
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * np.log(parameter_values_dict["Omegam"]),
+                ],
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                ],
+            },
+            "s8": {
+                "gg": [
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"],
+                ],
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"],
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    else:
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["bs8"],
+                ],
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                ],
+                "gv": [
+                    parameter_values_dict["fs8"],
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    return partial_coefficients_dict

flipcosmo-1.0.0/flip/covariance/adamsblake17/flip_terms.py

@@ -0,0 +1,78 @@
+import mpmath
+import numpy
+import scipy
+
+
+def set_backend(module):
+    global np, erf
+    if module == "numpy":
+        np = numpy
+        erf = scipy.special.erf
+    elif module == "mpmath":
+        np = mpmath.mp
+        erf = mpmath.erf
+
+
+set_backend("numpy")
+
+
+def M_gg_0_0_0():
+    def func(k):
+        return 1
+
+    return func
+
+
+def N_gg_0_0_0(theta, phi):
+    return 1
+
+
+def M_gv_0_1_0():
+    def func(k):
+        return (100 / 3) / k
+
+    return func
+
+
+def N_gv_0_1_0(theta, phi):
+    return -3 * np.cos(phi + (1 / 2) * theta)
+
+
+def M_vv_0_0_0():
+    def func(k):
+        return (10000 / 9) / k**2
+
+    return func
+
+
+def N_vv_0_0_0(theta, phi):
+    return 3 * np.cos(theta)
+
+
+def M_vv_0_2_0():
+    def func(k):
+        return (10000 / 9) / k**2
+
+    return func
+
+
+def N_vv_0_2_0(theta, phi):
+    return (9 / 2) * np.cos(2 * phi) + (3 / 2) * np.cos(theta)
+
+
+dictionary_terms = {"gg": ["0"], "gv": ["0"], "vv": ["0"]}
+dictionary_lmax = {"gg": [2], "gv": [2], "vv": [2]}
+dictionary_subterms = {
+    "gg_0_0": 1,
+    "gg_0_1": 0,
+    "gg_0_2": 0,
+    "gv_0_0": 0,
+    "gv_0_1": 1,
+    "gv_0_2": 0,
+    "vv_0_0": 1,
+    "vv_0_1": 0,
+    "vv_0_2": 1,
+}
+multi_index_model = False
+redshift_dependent_model = False
+regularize_M_terms = None

flipcosmo-1.0.0/flip/covariance/adamsblake17plane/__init__.py

@@ -0,0 +1,5 @@
+_variant = [None]
+
+_free_par = {"fs8": "velocity@all", "bs8": "density@all", "sigv": "velocity@all"}
+
+_coordinate_keys = ["ra", "dec", "rcom_zobs"]

flipcosmo-1.0.0/flip/covariance/adamsblake17plane/coefficients.py

@@ -0,0 +1,27 @@
+def get_coefficients(
+    parameter_values_dict,
+    model_kind,
+    variant=None,
+    redshift_dict=None,
+):
+    coefficients_dict = {}
+    if model_kind in ["density", "full", "density_velocity"]:
+        coefficients_dict["gg"] = [
+            parameter_values_dict["bs8"] ** 2,
+        ]
+    if model_kind in ["full"]:
+        coefficients_dict["gv"] = [
+            parameter_values_dict["bs8"] * parameter_values_dict["fs8"],
+        ]
+    if model_kind in ["velocity", "full", "density_velocity"]:
+        coefficients_dict["vv"] = [parameter_values_dict["fs8"] ** 2]
+    return coefficients_dict
+
+
+def get_diagonal_coefficients(parameter_values_dict, model_kind):
+    coefficients_dict = {}
+    if model_kind in ["density", "full", "density_velocity"]:
+        coefficients_dict["gg"] = 0.0
+    if model_kind in ["velocity", "full", "density_velocity"]:
+        coefficients_dict["vv"] = parameter_values_dict["sigv"] ** 2
+    return coefficients_dict