From 51c3eefee37940185f0be55b24252db1b3281d82 Mon Sep 17 00:00:00 2001
From: corentinravoux <corentin.ravoux.research@gmail.com>
Date: Thu, 2 May 2024 11:55:24 +0200
Subject: [PATCH 01/11] Skeleton for fisher matrix calculation

---
 flip/fisher/__init__.py      |  3 ++
 flip/fisher/fisher_matrix.py | 94 ++++++++++++++++++++++++++++++++++++
 2 files changed, 97 insertions(+)
 create mode 100644 flip/fisher/__init__.py
 create mode 100644 flip/fisher/fisher_matrix.py

diff --git a/flip/fisher/__init__.py b/flip/fisher/__init__.py
new file mode 100644
index 0000000..cfd3904
--- /dev/null
+++ b/flip/fisher/__init__.py
@@ -0,0 +1,3 @@
+"""Init file of the flip.covariance package."""
+
+from . import fisher_matrix
diff --git a/flip/fisher/fisher_matrix.py b/flip/fisher/fisher_matrix.py
new file mode 100644
index 0000000..d1fd7ad
--- /dev/null
+++ b/flip/fisher/fisher_matrix.py
@@ -0,0 +1,94 @@
+import importlib
+import time
+
+import numpy as np
+
+from flip.utils import create_log
+
+log = create_log()
+
+
+class FisherMatrix:
+    def __init__(
+        self,
+        covariance=None,
+        fisher_matrix=None,
+    ):
+        self.covariance = covariance
+        self.fisher_matrix = fisher_matrix
+
+    @classmethod
+    def init_from_covariance(
+        cls,
+        covariance,
+        parameter_values_dict,
+        **kwargs,
+    ):
+
+        # CR - Fisher matrix from https://arxiv.org/pdf/astro-ph/9603021 to implement
+
+        vector_error = load_error_vector(
+            covariance.model_type,
+            parameter_values_dict,
+        )
+
+        covariance_sum = covariance.compute_covariance_sum(
+            parameter_values_dict, vector_error
+        )
+        covariance_coefficients, covariance_derivatives = (
+            cls.compute_covariance_derivatives(
+                covariance,
+                parameter_values_dict,
+            )
+        )
+
+        A_matrices = []
+        for derivative in enumerate(covariance_derivatives):
+            A_matrices.append(np.linalg.inv(covariance_sum) * derivative)
+
+        fisher_matrix = np.zeros((len(A_matrices), len(A_matrices)))
+        for i in range(len(A_matrices)):
+            for j in range(len(A_matrices)):
+                fisher_matrix[i][j] = 0.5 * np.trace(
+                    np.dot(A_matrices[i], A_matrices[j])
+                )
+
+        return cls(
+            covariance=covariance,
+            fisher_matrix=fisher_matrix,
+        )
+
+    @classmethod
+    def compute_covariance_derivatives(
+        cls,
+        covariance,
+        parameter_values_dict,
+    ):
+        coefficients = importlib.import_module(
+            f"flip.covariance.{covariance.model_name}.coefficients"
+        )
+
+        coefficients_dict = coefficients.get_coefficients(
+            covariance.model_type,
+            parameter_values_dict,
+            variant=covariance.variant,
+        )
+        if covariance.model_type == "density":
+            return [coefficients_dict["gg"]], [covariance.covariance_dict["gg"]]
+        elif covariance.model_type == "velocity":
+            return [coefficients_dict["vv"]], [covariance.covariance_dict["vv"]]
+        elif covariance.model_type == "density_velocity":
+            return [coefficients_dict["gg"], coefficients_dict["vv"]], [
+                covariance.covariance_dict["gg"],
+                covariance.covariance_dict["vv"],
+            ]
+        elif covariance.model_type == "full":
+            return [
+                coefficients_dict["gg"],
+                coefficients_dict["gv"],
+                coefficients_dict["vv"],
+            ], [
+                covariance.covariance_dict["gg"],
+                covariance.covariance_dict["gv"],
+                covariance.covariance_dict["vv"],
+            ]

From 47e9a4bd22c384e2634430b5385534933e544ed6 Mon Sep 17 00:00:00 2001
From: corentinravoux <corentin.ravoux.research@gmail.com>
Date: Thu, 16 May 2024 11:40:51 +0200
Subject: [PATCH 02/11] moving and improvement of fisher class

---
 flip/__init__.py                            |  3 +-
 flip/{fisher/fisher_matrix.py => fisher.py} | 41 ++++++++++++++++++---
 flip/fisher/__init__.py                     |  3 --
 flip/likelihood.py                          |  4 +-
 4 files changed, 40 insertions(+), 11 deletions(-)
 rename flip/{fisher/fisher_matrix.py => fisher.py} (70%)
 delete mode 100644 flip/fisher/__init__.py

diff --git a/flip/__init__.py b/flip/__init__.py
index 51cf0fc..297ba15 100644
--- a/flip/__init__.py
+++ b/flip/__init__.py
@@ -1,7 +1,8 @@
 """Init file of the flip package."""
+
 import os
 
-from . import covariance, fitter, gridding, likelihood, utils, power_spectra
+from . import covariance, fisher, fitter, gridding, likelihood, power_spectra, utils
 
 __version__ = "1.0.0"
 __flip_dir_path__ = os.path.dirname(__file__)
diff --git a/flip/fisher/fisher_matrix.py b/flip/fisher.py
similarity index 70%
rename from flip/fisher/fisher_matrix.py
rename to flip/fisher.py
index d1fd7ad..b313a6f 100644
--- a/flip/fisher/fisher_matrix.py
+++ b/flip/fisher.py
@@ -3,6 +3,7 @@
 
 import numpy as np
 
+from flip import vectors
 from flip.utils import create_log
 
 log = create_log()
@@ -12,6 +13,7 @@ class FisherMatrix:
     def __init__(
         self,
         covariance=None,
+        data=None,
         fisher_matrix=None,
     ):
         self.covariance = covariance
@@ -21,20 +23,23 @@ def __init__(
     def init_from_covariance(
         cls,
         covariance,
+        data,
         parameter_values_dict,
+        fisher_properties,
         **kwargs,
     ):
 
-        # CR - Fisher matrix from https://arxiv.org/pdf/astro-ph/9603021 to implement
-
-        vector_error = load_error_vector(
+        vector_error = cls.load_error_vector(
             covariance.model_type,
+            data,
             parameter_values_dict,
+            fisher_properties,
         )
 
         covariance_sum = covariance.compute_covariance_sum(
             parameter_values_dict, vector_error
         )
+
         covariance_coefficients, covariance_derivatives = (
             cls.compute_covariance_derivatives(
                 covariance,
@@ -58,9 +63,7 @@ def init_from_covariance(
             fisher_matrix=fisher_matrix,
         )
 
-    @classmethod
     def compute_covariance_derivatives(
-        cls,
         covariance,
         parameter_values_dict,
     ):
@@ -92,3 +95,31 @@ def compute_covariance_derivatives(
                 covariance.covariance_dict["gv"],
                 covariance.covariance_dict["vv"],
             ]
+
+    @classmethod
+    def load_error_vector(
+        cls,
+        model_type,
+        data,
+        parameter_values_dict,
+        fisher_properties,
+    ):
+        if model_type in ["velocity", "density_velocity", "full"]:
+            velocity_error = vectors.load_velocity_error(
+                data,
+                parameter_values_dict,
+                velocity_type=fisher_properties["velocity_type"],
+                velocity_estimator=fisher_properties["velocity_estimator"],
+            )
+
+        if model_type in ["density", "density_velocity", "full"]:
+            density_error = vectors.load_density_error(data)
+
+        if model_type == "density":
+            return density_error
+        elif model_type == "velocity":
+            return velocity_error
+        elif model_type in ["density_velocity", "full"]:
+            return np.concatenate([density_error, velocity_error], axis=0)
+        else:
+            log.add(f"Wrong model type in the loaded covariance.")
diff --git a/flip/fisher/__init__.py b/flip/fisher/__init__.py
deleted file mode 100644
index cfd3904..0000000
--- a/flip/fisher/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-"""Init file of the flip.covariance package."""
-
-from . import fisher_matrix
diff --git a/flip/likelihood.py b/flip/likelihood.py
index 5fdc2fa..20cf5c8 100644
--- a/flip/likelihood.py
+++ b/flip/likelihood.py
@@ -91,7 +91,7 @@ def load_data_vector(
         parameter_values_dict,
     ):
         if model_type in ["velocity", "density_velocity", "full"]:
-            velocity, velocity_error = vectors.load_velocity_vector(
+            velocity, velocity_error = vectors.load_velocity_vectors(
                 self.data,
                 parameter_values_dict,
                 velocity_type=self.likelihood_properties["velocity_type"],
@@ -99,7 +99,7 @@ def load_data_vector(
             )
 
         if model_type in ["density", "density_velocity", "full"]:
-            density, density_error = vectors.load_density_vector(self.data)
+            density, density_error = vectors.load_density_vectors(self.data)
 
         if model_type == "density":
             return density, density_error

From 087f334c71d47221ab1bcb7977640959ea894bab Mon Sep 17 00:00:00 2001
From: corentinravoux <corentin.ravoux.research@gmail.com>
Date: Thu, 16 May 2024 11:41:25 +0200
Subject: [PATCH 03/11] large modification of vector loading for fisher,
 include scatter mode

---
 flip/vectors.py | 225 +++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 183 insertions(+), 42 deletions(-)

diff --git a/flip/vectors.py b/flip/vectors.py
index 23ef53e..dc2a012 100644
--- a/flip/vectors.py
+++ b/flip/vectors.py
@@ -5,45 +5,112 @@
 
 log = create_log()
 
-_avail_velocity_type = ["direct", "saltfit"]
+_avail_velocity_type = ["direct", "scatter", "saltfit"]
 _avail_velocity_estimator = ["watkins", "lowz", "hubblehighorder", "full"]
 
 
-def load_density_vector(data):
-    density, density_error = None, None
+def load_density_error(data):
+    if "density_error" in data.keys():
+        density_error = data["density_error"]
+    else:
+        log.add("""No density error in data, loading a null density error""")
+        density_error = np.zeros_like(data["density"])
+    return density_error
+
+
+def load_density_vectors(data):
     if "density" in data.keys():
         density = data["density"]
-        if "density_error" in data.keys():
-            density_error = data["density_error"]
-        else:
-            log.add("""No density error in data, loading a null density error""")
-            density_error = np.zeros_like(data["density"])
+        density_error = load_density_error(data)
     else:
         raise ValueError("""The data does not contains a density field""")
     return density, density_error
 
 
-def load_velocity_vector(
+def load_velocity_error(
+    data,
+    parameter_values_dict,
+    velocity_type="direct",
+    velocity_estimator="full",
+):
+    if velocity_type == "direct":
+        velocity_error = get_velocity_error_directly(data)
+
+    elif velocity_type == "scatter":
+
+        if "zobs" in data.keys():
+            velocity_error = get_velocity_error_from_scatter(
+                data,
+                parameter_values_dict,
+                velocity_estimator,
+            )
+        else:
+            raise ValueError(
+                """The data does not contains a "zobs" field."""
+                f"""Add it or choose a different velocity_type among: {_avail_velocity_type}"""
+            )
+
+    elif velocity_type == "saltfit":
+        key_to_verify = (
+            "e_mb",
+            "e_x1",
+            "e_c",
+            "cov_mb_x1",
+            "cov_mb_c",
+            "cov_x1_c",
+            "zobs",
+        )
+        if all(k in data for k in key_to_verify):
+            velocity_error = get_velocity_error_from_salt_fit(
+                data,
+                parameter_values_dict,
+                velocity_estimator,
+            )
+        else:
+            raise ValueError(
+                """The data does not contains parameters for saltfit velocity error estimate."""
+                f"""Add all the following values: {key_to_verify}"""
+                f"""Or choose a different velocity_type among {_avail_velocity_type}"""
+            )
+    else:
+        raise ValueError(
+            f"""Please choose a velocity_type among {_avail_velocity_type}"""
+        )
+
+    return velocity_error
+
+
+def load_velocity_vectors(
     data,
     parameter_values_dict,
     velocity_type="direct",
     velocity_estimator="full",
-    **kwargs,
 ):
-    velocity, velocity_error = None, None
     if velocity_type == "direct":
         if "velocity" in data.keys():
-            velocity = data["velocity"]
-            if "velocity_error" in data.keys():
-                velocity_error = data["velocity_error"]
-            else:
-                log.add("""No velocity error in data, loading a null velocity error""")
-                velocity_error = np.zeros_like(data["velocity"])
+            velocity, velocity_error = get_velocity_directly(data)
         else:
             raise ValueError(
                 """The data does not contains a "velocity" field."""
                 f"""Add it or choose a different velocity_type among: {_avail_velocity_type}"""
             )
+    elif velocity_type == "scatter":
+        key_to_verify = (
+            "velocity",
+            "zobs",
+        )
+        if all(k in data for k in key_to_verify):
+            velocity, velocity_error = get_velocity_from_scatter(
+                data,
+                parameter_values_dict,
+                velocity_estimator,
+            )
+        else:
+            raise ValueError(
+                """The data does not contains parameters for scatter velocity estimate."""
+                f"""Add all the following values: {key_to_verify}"""
+                f"""Or choose a different velocity_type among {_avail_velocity_type}"""
+            )
 
     elif velocity_type == "saltfit":
         key_to_verify = (
@@ -64,11 +131,10 @@ def load_velocity_vector(
                 data,
                 parameter_values_dict,
                 velocity_estimator,
-                **kwargs,
             )
         else:
             raise ValueError(
-                f"""The data does not contains parameters for saltfit velocity estimate."""
+                """The data does not contains parameters for saltfit velocity estimate."""
                 f"""Add all the following values: {key_to_verify}"""
                 f"""Or choose a different velocity_type among {_avail_velocity_type}"""
             )
@@ -83,39 +149,101 @@ def load_velocity_vector(
     return velocity, velocity_error
 
 
-def get_velocity_from_salt_fit(
+def get_velocity_error_directly(data):
+    if "velocity_error" in data.keys():
+        velocity_error = data["velocity_error"]
+    else:
+        log.add("""No velocity error in data, loading a null velocity error""")
+        velocity_error = np.zeros_like(data["velocity"])
+    return velocity_error
+
+
+def get_velocity_directly(data):
+    velocity = data["velocity"]
+    velocity_error = get_velocity_error_directly(data)
+    return velocity, velocity_error
+
+
+def get_velocity_error_from_scatter(
     data,
     parameter_values_dict,
     velocity_estimator,
-    q_0=None,
-    j_0=None,
 ):
-    alpha = parameter_values_dict["alpha"]
-    beta = parameter_values_dict["beta"]
-    M_0 = parameter_values_dict["M_0"]
     sigma_M = parameter_values_dict["sigma_M"]
 
-    mu, variance_mu = compute_observed_distance_modulus(
+    redshift_dependence = redshift_dependence_velocity(
         data,
-        alpha,
-        beta,
-        M_0,
+        parameter_values_dict,
+        velocity_estimator,
     )
-    variance_mu += sigma_M**2
 
-    muth = 5 * np.log10((1 + data["zobs"]) * data["rcom_zobs"]) + 25
-    dmu = mu - muth
+    velocity_error = redshift_dependence * sigma_M
+    return velocity_error
+
+
+def get_velocity_from_scatter(
+    data,
+    parameter_values_dict,
+    velocity_estimator,
+):
+    velocity = data["velocity"]
+
+    velocity_error = get_velocity_error_from_scatter(
+        data,
+        parameter_values_dict,
+        velocity_estimator,
+    )
+
+    return velocity, velocity_error
+
+
+def get_velocity_error_from_salt_fit(
+    data,
+    parameter_values_dict,
+    velocity_estimator,
+):
+
+    variance_mu = compute_observed_distance_modulus_error(
+        data,
+        parameter_values_dict["alpha"],
+        parameter_values_dict["beta"],
+    )
+    variance_mu += parameter_values_dict["sigma_M"] ** 2
 
     redshift_dependence = redshift_dependence_velocity(
         data,
+        parameter_values_dict,
         velocity_estimator,
-        q_0=q_0,
-        j_0=j_0,
     )
 
-    velocity = -redshift_dependence * dmu
     velocity_error = redshift_dependence * np.sqrt(variance_mu)
 
+    return velocity_error, redshift_dependence
+
+
+def get_velocity_from_salt_fit(
+    data,
+    parameter_values_dict,
+    velocity_estimator,
+):
+
+    velocity_error, redshift_dependence = get_velocity_error_from_salt_fit(
+        data,
+        parameter_values_dict,
+        velocity_estimator,
+    )
+
+    mu = compute_observed_distance_modulus(
+        data,
+        parameter_values_dict["alpha"],
+        parameter_values_dict["beta"],
+        parameter_values_dict["M_0"],
+    )
+    muth = 5 * np.log10((1 + data["zobs"]) * data["rcom_zobs"]) + 25
+    dmu = mu - muth
+
+    velocity = -redshift_dependence * dmu
+
     return velocity, velocity_error
 
 
@@ -127,6 +255,14 @@ def compute_observed_distance_modulus(
 ):
     mu = data["mb"] + alpha * data["x1"] - beta * data["c"] - M0
 
+    return mu
+
+
+def compute_observed_distance_modulus_error(
+    data,
+    alpha,
+    beta,
+):
     variance_mu = (
         data["e_mb"] ** 2 + alpha**2 * data["e_x1"] ** 2 + beta**2 * data["e_c"] ** 2
     )
@@ -135,14 +271,13 @@ def compute_observed_distance_modulus(
         - 2 * beta * data["cov_mb_c"]
         - 2 * alpha * beta * data["cov_x1_c"]
     )
-    return mu, variance_mu
+    return variance_mu
 
 
 def redshift_dependence_velocity(
     data,
+    parameter_values_dict,
     velocity_estimator,
-    q_0=None,
-    j_0=None,
 ):
     prefactor = utils._C_LIGHT_KMS_ * np.log(10) / 5
     redshift_obs = data["zobs"]
@@ -152,6 +287,13 @@ def redshift_dependence_velocity(
     elif velocity_estimator == "lowz":
         redshift_dependence = prefactor / ((1 + redshift_obs) / redshift_obs - 1.0)
     elif velocity_estimator == "hubblehighorder":
+        if ("q_0" not in parameter_values_dict) & ("j_0" not in parameter_values_dict):
+            raise ValueError(
+                """ The "q_0" and "j_0" parameters are not present in the parameter_values_dict"""
+                f""" Please add it or choose a different velocity_estimator among {_avail_velocity_estimator}"""
+            )
+        q_0 = parameter_values_dict["q_0"]
+        j_0 = parameter_values_dict["j_0"]
         redshift_mod = redshift_obs * (
             1
             + (1 / 2) * (1 - q_0) * redshift_obs
@@ -160,11 +302,10 @@ def redshift_dependence_velocity(
         redshift_dependence = prefactor * redshift_mod / (1 + redshift_obs)
 
     elif velocity_estimator == "full":
-        # hubble_norm = H(z)/h = 100 E(z) with h = H0/100
-        if "hubble_norm" not in data:
+        if ("hubble_norm" not in data) | ("rcom_zobs" not in data):
             raise ValueError(
-                """ The "hubble_norm" field is not present in the data"""
-                """ Please add it or choose a different velocity_estimator from salt fit among {_avail_velocity_estimator}"""
+                """ The "hubble_norm" (H(z)/h = 100 E(z)) or "rcom_zobs" (Dm(z)) fields are not present in the data"""
+                f""" Please add it or choose a different velocity_estimator among {_avail_velocity_estimator}"""
             )
 
         redshift_dependence = prefactor / (

From 7c8174dd16e29f3883f67fa6b20e0ea6e36c1e5b Mon Sep 17 00:00:00 2001
From: corentinravoux <corentin.ravoux.research@gmail.com>
Date: Thu, 16 May 2024 16:27:49 +0200
Subject: [PATCH 04/11] working implementation of fisher matrix calculation

---
 flip/covariance/carreres23/coefficients.py |  43 +++++
 flip/fisher.py                             | 199 +++++++++++++++------
 2 files changed, 186 insertions(+), 56 deletions(-)

diff --git a/flip/covariance/carreres23/coefficients.py b/flip/covariance/carreres23/coefficients.py
index b7f4d76..02d522b 100644
--- a/flip/covariance/carreres23/coefficients.py
+++ b/flip/covariance/carreres23/coefficients.py
@@ -1,3 +1,6 @@
+import numpy as np
+
+
 def get_coefficients(
     model_type,
     parameter_values_dict,
@@ -12,3 +15,43 @@ def get_diagonal_coefficients(model_type, parameter_values_dict):
     coefficients_dict = {}
     coefficients_dict["vv"] = parameter_values_dict["sigv"] ** 2
     return coefficients_dict
+
+
+def get_partial_derivative_coefficients(
+    model_type,
+    parameter_values_dict,
+    variant=None,
+):
+    partial_coefficients_dict = {}
+    if variant == "growth_index":
+        partial_coefficients_dict = {
+            "Omegam": {
+                "vv": [
+                    2
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"] - 1)
+                    * parameter_values_dict["s8"] ** 2
+                ]
+            },
+            "gamma": {
+                "vv": [
+                    2
+                    * np.log(parameter_values_dict["Omegam"])
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                ]
+            },
+            "s8": {
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ]
+            },
+        }
+    else:
+        partial_coefficients_dict = {"fs8": {"vv": [2 * parameter_values_dict["fs8"]]}}
+    return partial_coefficients_dict
diff --git a/flip/fisher.py b/flip/fisher.py
index b313a6f..c174aba 100644
--- a/flip/fisher.py
+++ b/flip/fisher.py
@@ -9,15 +9,27 @@
 log = create_log()
 
 
+def inverse_covariance_inverse(covariance):
+    return np.linalg.inv(covariance)
+
+
 class FisherMatrix:
+
+    _default_fisher_properties = {
+        "inversion_method": "inverse",
+        "velocity_type": "direct",
+        "velocity_estimator": "full",
+        "negative_log_likelihood": True,
+    }
+
     def __init__(
         self,
         covariance=None,
-        data=None,
-        fisher_matrix=None,
+        inverse_covariance_sum=None,
     ):
+
         self.covariance = covariance
-        self.fisher_matrix = fisher_matrix
+        self.inverse_covariance_sum = inverse_covariance_sum
 
     @classmethod
     def init_from_covariance(
@@ -25,9 +37,15 @@ def init_from_covariance(
         covariance,
         data,
         parameter_values_dict,
-        fisher_properties,
-        **kwargs,
+        fisher_properties={},
     ):
+        if covariance.full_matrix is False:
+            covariance.compute_full_matrix()
+
+        fisher_properties = {
+            **cls._default_fisher_properties,
+            **fisher_properties,
+        }
 
         vector_error = cls.load_error_vector(
             covariance.model_type,
@@ -40,62 +58,15 @@ def init_from_covariance(
             parameter_values_dict, vector_error
         )
 
-        covariance_coefficients, covariance_derivatives = (
-            cls.compute_covariance_derivatives(
-                covariance,
-                parameter_values_dict,
-            )
-        )
-
-        A_matrices = []
-        for derivative in enumerate(covariance_derivatives):
-            A_matrices.append(np.linalg.inv(covariance_sum) * derivative)
-
-        fisher_matrix = np.zeros((len(A_matrices), len(A_matrices)))
-        for i in range(len(A_matrices)):
-            for j in range(len(A_matrices)):
-                fisher_matrix[i][j] = 0.5 * np.trace(
-                    np.dot(A_matrices[i], A_matrices[j])
-                )
+        inverse_covariance_sum = eval(
+            f"inverse_covariance_{fisher_properties['inversion_method']}"
+        )(covariance_sum)
 
         return cls(
             covariance=covariance,
-            fisher_matrix=fisher_matrix,
-        )
-
-    def compute_covariance_derivatives(
-        covariance,
-        parameter_values_dict,
-    ):
-        coefficients = importlib.import_module(
-            f"flip.covariance.{covariance.model_name}.coefficients"
+            inverse_covariance_sum=inverse_covariance_sum,
         )
 
-        coefficients_dict = coefficients.get_coefficients(
-            covariance.model_type,
-            parameter_values_dict,
-            variant=covariance.variant,
-        )
-        if covariance.model_type == "density":
-            return [coefficients_dict["gg"]], [covariance.covariance_dict["gg"]]
-        elif covariance.model_type == "velocity":
-            return [coefficients_dict["vv"]], [covariance.covariance_dict["vv"]]
-        elif covariance.model_type == "density_velocity":
-            return [coefficients_dict["gg"], coefficients_dict["vv"]], [
-                covariance.covariance_dict["gg"],
-                covariance.covariance_dict["vv"],
-            ]
-        elif covariance.model_type == "full":
-            return [
-                coefficients_dict["gg"],
-                coefficients_dict["gv"],
-                coefficients_dict["vv"],
-            ], [
-                covariance.covariance_dict["gg"],
-                covariance.covariance_dict["gv"],
-                covariance.covariance_dict["vv"],
-            ]
-
     @classmethod
     def load_error_vector(
         cls,
@@ -123,3 +94,119 @@ def load_error_vector(
             return np.concatenate([density_error, velocity_error], axis=0)
         else:
             log.add(f"Wrong model type in the loaded covariance.")
+
+    def compute_covariance_derivative(
+        self,
+        partial_coefficients_dict_param,
+    ):
+
+        if self.covariance.model_type == "density":
+            covariance_derivative_sum = np.sum(
+                [
+                    partial_coefficients_dict_param["gg"][i] * cov
+                    for i, cov in enumerate(self.covariance.covariance_dict["gg"])
+                ],
+                axis=0,
+            )
+
+        elif self.covariance.model_type == "velocity":
+            covariance_derivative_sum = np.sum(
+                [
+                    partial_coefficients_dict_param["vv"][i] * cov
+                    for i, cov in enumerate(self.covariance.covariance_dict["vv"])
+                ],
+                axis=0,
+            )
+
+        elif self.covariance.model_type in ["density_velocity", "full"]:
+            number_densities = self.covariance.number_densities
+            number_velocities = self.covariance.number_velocities
+
+            if self.covariance.model_type == "density_velocity":
+                covariance_derivative_sum_gv = np.zeros(
+                    (number_densities, number_velocities)
+                )
+            elif self.covariance.model_type == "full":
+                covariance_derivative_sum_gv = np.sum(
+                    [
+                        partial_coefficients_dict_param["gv"][i] * cov
+                        for i, cov in enumerate(self.covariance.covariance_dict["gv"])
+                    ],
+                    axis=0,
+                )
+            covariance_derivative_sum_gg = np.sum(
+                [
+                    partial_coefficients_dict_param["gg"][i] * cov
+                    for i, cov in enumerate(self.covariance.covariance_dict["gg"])
+                ],
+                axis=0,
+            )
+
+            covariance_derivative_sum_vv = np.sum(
+                [
+                    partial_coefficients_dict_param["vv"][i] * cov
+                    for i, cov in enumerate(self.covariance.covariance_dict["vv"])
+                ],
+                axis=0,
+            )
+            covariance_derivative_sum_vg = -covariance_derivative_sum_gv.T
+
+            covariance_derivative_sum = np.block(
+                [
+                    [covariance_derivative_sum_gg, covariance_derivative_sum_gv],
+                    [covariance_derivative_sum_vg, covariance_derivative_sum_vv],
+                ]
+            )
+        else:
+            log.add(f"Wrong model type in the loaded covariance.")
+
+        return covariance_derivative_sum
+
+    def compute_fisher_matrix(
+        self,
+        parameter_values_dict,
+        variant=None,
+    ):
+
+        coefficients = importlib.import_module(
+            f"flip.covariance.{self.covariance.model_name}.coefficients"
+        )
+        partial_coefficients_dict = coefficients.get_partial_derivative_coefficients(
+            self.covariance.model_type,
+            parameter_values_dict,
+            variant=variant,
+        )
+        parameter_name_list = []
+        covariance_derivative_sum_list = []
+
+        for (
+            parameter_name,
+            partial_coefficients_dict_param,
+        ) in partial_coefficients_dict.items():
+            parameter_name_list.append(parameter_name)
+            covariance_derivative_sum_list.append(
+                self.inverse_covariance_sum
+                * self.compute_covariance_derivative(
+                    partial_coefficients_dict_param,
+                )
+            )
+
+        fisher_matrix = np.zeros(
+            (
+                len(partial_coefficients_dict.keys()),
+                len(partial_coefficients_dict.keys()),
+            )
+        )
+        for i in range(len(fisher_matrix)):
+            for j in range(i, len(fisher_matrix)):
+                fisher_matrix[i][j] = 0.5 * np.trace(
+                    np.dot(
+                        covariance_derivative_sum_list[i],
+                        covariance_derivative_sum_list[j],
+                    )
+                )
+        for i in range(len(fisher_matrix)):
+            for j in range(i):
+                fisher_matrix[i][j] = fisher_matrix[j][i]
+
+        return parameter_name_list, fisher_matrix

From f86e967992b8a4678b4803927b5496b7bf77d010 Mon Sep 17 00:00:00 2001
From: corentinravoux <corentin.ravoux.research@gmail.com>
Date: Thu, 16 May 2024 16:27:57 +0200
Subject: [PATCH 05/11] add a script

---
 scripts/flip_fisher_forecast_velocity.py | 74 ++++++++++++++++++++++++
 1 file changed, 74 insertions(+)
 create mode 100644 scripts/flip_fisher_forecast_velocity.py

diff --git a/scripts/flip_fisher_forecast_velocity.py b/scripts/flip_fisher_forecast_velocity.py
new file mode 100644
index 0000000..3e3991d
--- /dev/null
+++ b/scripts/flip_fisher_forecast_velocity.py
@@ -0,0 +1,74 @@
+import os
+
+import numpy as np
+import pandas as pd
+from pkg_resources import resource_filename
+
+from flip import fisher, utils
+from flip.covariance import covariance
+
+flip_base = resource_filename("flip", ".")
+data_path = os.path.join(flip_base, "data")
+
+### Load data
+sn_data = pd.read_parquet(os.path.join(data_path, "velocity_data.parquet"))
+
+sn_data = sn_data[np.array(sn_data["status"]) != False]
+sn_data = sn_data[np.array(sn_data["status"]) != None]
+
+coordinates_velocity = np.array([sn_data["ra"], sn_data["dec"], sn_data["rcom_zobs"]])
+
+data_velocity = sn_data.to_dict("list")
+for key in data_velocity.keys():
+    data_velocity[key] = np.array(data_velocity[key])
+data_velocity["velocity"] = data_velocity.pop("vpec")
+data_velocity["velocity_error"] = np.zeros_like(data_velocity["velocity"])
+
+
+ktt, ptt = np.loadtxt(os.path.join(data_path, "power_spectrum_tt.txt"))
+kmt, pmt = np.loadtxt(os.path.join(data_path, "power_spectrum_mt.txt"))
+kmm, pmm = np.loadtxt(os.path.join(data_path, "power_spectrum_mm.txt"))
+
+sigmau_fiducial = 15
+
+power_spectrum_dict = {"vv": [[ktt, ptt * utils.Du(ktt, sigmau_fiducial) ** 2]]}
+
+### Compute covariance
+size_batch = 10_000
+number_worker = 16
+
+covariance_fit = covariance.CovMatrix.init_from_flip(
+    "carreres23",
+    "velocity",
+    power_spectrum_dict,
+    coordinates_velocity=coordinates_velocity,
+    size_batch=size_batch,
+    number_worker=number_worker,
+)
+
+
+### Load fitter
+
+fisher_properties = {
+    "inversion_method": "inverse",
+    "velocity_type": "scatter",
+}
+
+variant = None  # can be replaced by growth_index
+
+parameter_dict = {
+    "fs8": 0.4,
+    "sigv": 200,
+    "sigma_M": 0.12,
+}
+
+Fisher = fisher.FisherMatrix.init_from_covariance(
+    covariance_fit,
+    data_velocity,
+    parameter_dict,
+    fisher_properties=fisher_properties,
+)
+
+parameter_name_list, fisher_matrix = Fisher.compute_fisher_matrix(
+    parameter_dict, variant=None
+)

From f53dc00f367dff632f9b035c94cfdb465fc76004 Mon Sep 17 00:00:00 2001
From: corentinravoux <corentin.ravoux.research@gmail.com>
Date: Fri, 17 May 2024 11:58:40 +0200
Subject: [PATCH 06/11] adding symbolic generation of fisher terms

---
 flip/covariance/symbolic.py | 461 ++++++++++++++++++++++++++++++++++++
 1 file changed, 461 insertions(+)

diff --git a/flip/covariance/symbolic.py b/flip/covariance/symbolic.py
index 3f5b165..74daada 100644
--- a/flip/covariance/symbolic.py
+++ b/flip/covariance/symbolic.py
@@ -637,6 +637,454 @@ def generate_generalized_ravouxcarreres_functions(
     )
 
 
+def compute_partial_derivative_dictionnary(
+    name_models,
+    components,
+    parameter_models,
+    all_parameters,
+    coefficient_models,
+):
+    """
+    The compute_partial_derivatiove_dictionnary function computes the partial derivatives of each component of the model with respect to each parameter.
+    The output is a list containing dictionnaries, one for each model. Each dictionnary contains as keys all parameters and as values another dictionnary which contains as keys all components and as values lists containing the partial derivatives.
+
+    Args:
+        name_models: Name the models
+        parameter_models: Get the parameters of each model
+        components: Create the keys of the dictionnaries in compute_partial_derivatiove_dictionnary
+        coefficient_models: Compute the partial derivatives of each component with respect to each parameter
+        : Create the keys of the dictionnaries in compute_partial_derivatiove_dictionnary
+
+    Returns:
+        A list containing dictionnaries, one for each model
+
+    Doc Author:
+        Trelent
+    """
+
+    for param in all_parameters:
+        locals()[param] = sy.symbols(
+            f'parameter_values_dict["{param}"]', positive=True, finite=True, real=True
+        )
+
+    partial_derivative_dictionnary_list = []
+    for i in range(len(name_models)):
+        partial_derivative_dictionnary = {}
+        for parameter in parameter_models[i]:
+            partial_derivative_dictionnary[parameter] = {}
+            for component in components:
+                derivative = "["
+                model = eval(coefficient_models[i][component])
+                for j in range(len(model)):
+                    derivative = (
+                        derivative + pycode(sy.diff(model[j], eval(parameter))) + ","
+                    )
+                derivative = derivative + "]"
+                partial_derivative_dictionnary[parameter][component] = derivative
+        partial_derivative_dictionnary_list.append(partial_derivative_dictionnary)
+
+    return partial_derivative_dictionnary_list
+
+
+def write_partial_derivatives(
+    filename,
+    name_models,
+    components,
+    parameter_models,
+    all_parameters,
+    coefficient_models,
+):
+
+    f = open(filename, "w")
+    f.write("import numpy as np\n")
+    f.write("\n")
+    f.write("\n")
+    if len(components) == 1:
+
+        partial_derivative_dictionnary_list = compute_partial_derivative_dictionnary(
+            name_models,
+            components,
+            parameter_models,
+            all_parameters,
+            coefficient_models,
+        )
+
+        f.write(
+            "def get_partial_derivative_coefficients(model_type,parameter_values_dict,variant=None,):\n"
+        )
+        write_one_function(
+            f,
+            name_models,
+            components,
+            parameter_models,
+            partial_derivative_dictionnary_list,
+        )
+    else:
+        f.write(
+            "def get_partial_derivative_coefficients(model_type,parameter_values_dict,variant=None,):\n"
+        )
+        f.write("    if model_type == 'density':\n")
+        f.write(
+            "        return get_partial_derivative_coefficients_density(parameter_values_dict,variant=variant,)\n"
+        )
+        f.write("    elif model_type == 'velocity':\n")
+        f.write(
+            "        return get_partial_derivative_coefficients_velocity(parameter_values_dict,variant=variant,)\n"
+        )
+        f.write("    elif model_type == 'density_velocity':\n")
+        f.write(
+            "        return get_partial_derivative_coefficients_density_velocity(parameter_values_dict,variant=variant,)\n"
+        )
+        f.write("    elif model_type == 'full':\n")
+        f.write(
+            "        return get_partial_derivative_coefficients_full(parameter_values_dict,variant=variant,)\n"
+        )
+        f.write("\n")
+
+        components_to_treat = [["vv"], ["gg"], ["gg", "vv"], ["gg", "gv", "vv"]]
+        component_names = ["velocity", "density", "density_velocity", "full"]
+        for i in range(len(components_to_treat)):
+            partial_derivative_dictionnary_list = (
+                compute_partial_derivative_dictionnary(
+                    name_models,
+                    components_to_treat[i],
+                    parameter_models,
+                    all_parameters,
+                    coefficient_models,
+                )
+            )
+
+            f.write(
+                f"def get_partial_derivative_coefficients_{component_names[i]}(parameter_values_dict,variant=None,):\n"
+            )
+            write_one_function(
+                f,
+                name_models,
+                components_to_treat[i],
+                parameter_models,
+                partial_derivative_dictionnary_list,
+            )
+
+    f.write("\n")
+    f.close()
+
+
+def write_one_function(
+    f,
+    name_models,
+    components,
+    parameter_models,
+    partial_derivative_dictionnary_list,
+):
+    if len(name_models) == 1:
+        f.write("    partial_coefficients_dict = {\n")
+        for parameter in parameter_models:
+            f.write("'" + parameter + "': {\n")
+            for component in components:
+                f.write(
+                    "'"
+                    + component
+                    + "':"
+                    + partial_derivative_dictionnary_list[0][parameter][
+                        component
+                    ].replace("math.", "np.")
+                    + ",\n"
+                )
+            f.write("},\n")
+        f.write("}\n")
+    else:
+        for i_model, name in enumerate(name_models):
+            if name is None:
+                f.write(f"    else:\n")
+            elif i_model > 0:
+                f.write(f"    elif variant == '{name}':\n")
+            else:
+                f.write(f"    if variant == '{name}':\n")
+            f.write("        partial_coefficients_dict = {\n")
+            for parameter in parameter_models[i_model]:
+                f.write("'" + parameter + "': {\n")
+                for component in components:
+                    f.write(
+                        "'"
+                        + component
+                        + "':"
+                        + partial_derivative_dictionnary_list[i_model][parameter][
+                            component
+                        ].replace("math.", "np.")
+                        + ",\n"
+                    )
+                f.write("},\n")
+            f.write("}\n")
+    f.write("    return partial_coefficients_dict")
+    f.write("\n")
+
+
+def generate_fisher_coefficients_dictionnary_carreres23(
+    filename="./carreres23/fisher_terms.py",
+):
+
+    name_models = ["growth_index", None]
+    components = ["vv"]
+    parameter_models = [["Omegam", "gamma", "s8"], ["fs8"]]
+    all_parameters = ["Omegam", "gamma", "s8", "fs8"]
+    coefficient_models = [{"vv": "[(Omegam**gamma * s8)**2]"}, {"vv": "[fs8**2]"}]
+
+    write_partial_derivatives(
+        filename,
+        name_models,
+        components,
+        parameter_models,
+        all_parameters,
+        coefficient_models,
+    )
+
+
+def generate_fisher_coefficients_dictionnary_adamsblake17plane(
+    filename="./adamsblake17plane/fisher_terms.py",
+):
+
+    name_models = ["growth_index", None]
+    components = ["gg", "gv", "vv"]
+    parameter_models = [
+        ["Omegam", "gamma", "s8", "bs8"],
+        ["fs8", "bs8"],
+    ]
+    all_parameters = ["Omegam", "gamma", "s8", "fs8", "bs8"]
+    coefficient_models = [
+        {
+            "gg": "[bs8**2]",
+            "gv": "[bs8*Omegam**gamma*s8]",
+            "vv": "[(Omegam**gamma*s8)**2]",
+        },
+        {
+            "gg": "[bs8**2]",
+            "gv": "[bs8*fs8]",
+            "vv": "[fs8**2]",
+        },
+    ]
+
+    write_partial_derivatives(
+        filename,
+        name_models,
+        components,
+        parameter_models,
+        all_parameters,
+        coefficient_models,
+    )
+
+
+def generate_fisher_coefficients_dictionnary_full_nosigmag(
+    filename,
+):
+
+    name_models = ["growth_index", "growth_index_nobeta", "nobeta", None]
+    components = ["gg", "gv", "vv"]
+    parameter_models = [
+        ["Omegam", "gamma", "s8", "bs8", "beta_f"],
+        ["Omegam", "gamma", "s8", "bs8"],
+        ["fs8", "bs8"],
+        ["fs8", "bs8", "beta_f"],
+    ]
+    all_parameters = ["Omegam", "gamma", "s8", "fs8", "bs8", "beta_f"]
+    coefficient_models = [
+        {
+            "gg": "[bs8**2, bs8**2*beta_f, bs8**2*beta_f**2]",
+            "gv": "[bs8*Omegam**gamma*s8, bs8*Omegam**gamma*s8*beta_f]",
+            "vv": "[(Omegam**gamma*s8)**2]",
+        },
+        {
+            "gg": "[bs8**2, bs8*Omegam**gamma*s8, (Omegam**gamma*s8)**2]",
+            "gv": "[bs8*Omegam**gamma*s8, (Omegam**gamma*s8)**2]",
+            "vv": "[(Omegam**gamma*s8)**2]",
+        },
+        {
+            "gg": "[bs8**2, bs8*fs8, fs8**2]",
+            "gv": "[bs8*fs8, fs8**2]",
+            "vv": "[fs8**2]",
+        },
+        {
+            "gg": "[bs8**2, bs8**2*beta_f, bs8**2*beta_f**2]",
+            "gv": "[bs8*fs8, bs8*fs8*beta_f]",
+            "vv": "[fs8**2]",
+        },
+    ]
+
+    write_partial_derivatives(
+        filename,
+        name_models,
+        components,
+        parameter_models,
+        all_parameters,
+        coefficient_models,
+    )
+
+
+def generate_fisher_coefficients_dictionnary_lai22(
+    filename="./lai22/fisher_terms.py",
+):
+    from flip.covariance.lai22.flip_terms import dictionary_terms
+
+    name_models = ["growth_index", "growth_index_nobeta", "nobeta", None]
+    components = ["gg", "gv", "vv"]
+    parameter_models = [
+        ["Omegam", "gamma", "s8", "bs8", "beta_f", "sigg"],
+        ["Omegam", "gamma", "s8", "bs8", "sigg"],
+        ["fs8", "bs8", "sigg"],
+        ["fs8", "bs8", "beta_f", "sigg"],
+    ]
+    all_parameters = ["Omegam", "gamma", "s8", "fs8", "bs8", "beta_f", "sigg"]
+
+    gg_terms = dictionary_terms["gg"]
+    gv_terms = dictionary_terms["gv"]
+
+    coefficient_models = []
+
+    coefficient_model_gg = "["
+    for gg_term in gg_terms:
+        term_index, m_index = np.array(gg_term.split("_")).astype(int)
+        if term_index == 0:
+            coefficient_model_gg = coefficient_model_gg + f"bs8**2*sigg**({2*m_index}),"
+        elif term_index == 1:
+            coefficient_model_gg = (
+                coefficient_model_gg + f"bs8**2*beta_f*sigg**({2*m_index}),"
+            )
+        elif term_index == 2:
+            coefficient_model_gg = (
+                coefficient_model_gg + f"bs8**2*beta_f**2*sigg**({2*m_index}),"
+            )
+    coefficient_model_gg = coefficient_model_gg + "]"
+
+    coefficient_model_gv = "["
+    for gv_term in gv_terms:
+        term_index, m_index = np.array(gv_term.split("_")).astype(int)
+        if term_index == 0:
+            coefficient_model_gv = (
+                coefficient_model_gv + f"bs8*(Omegam**gamma*s8)*sigg**({2*m_index}),"
+            )
+        elif term_index == 1:
+            coefficient_model_gv = (
+                coefficient_model_gv + f"bs8**2*beta_f**2*sigg**({2*m_index}),"
+            )
+    coefficient_model_gv = coefficient_model_gv + "]"
+    coefficient_models.append(
+        {
+            "gg": coefficient_model_gg,
+            "gv": coefficient_model_gv,
+            "vv": "[(Omegam**gamma*s8)**2]",
+        }
+    )
+
+    coefficient_model_gg = "["
+    for gg_term in gg_terms:
+        term_index, m_index = np.array(gg_term.split("_")).astype(int)
+        if term_index == 0:
+            coefficient_model_gg = coefficient_model_gg + f"bs8**2*sigg**({2*m_index}),"
+        elif term_index == 1:
+            coefficient_model_gg = (
+                coefficient_model_gg + f"bs8*(Omegam**gamma*s8)*sigg**({2*m_index}),"
+            )
+        elif term_index == 2:
+            coefficient_model_gg = (
+                coefficient_model_gg + f"(Omegam**gamma*s8)**2*sigg**({2*m_index}),"
+            )
+    coefficient_model_gg = coefficient_model_gg + "]"
+
+    coefficient_model_gv = "["
+    for gv_term in gv_terms:
+        term_index, m_index = np.array(gv_term.split("_")).astype(int)
+        if term_index == 0:
+            coefficient_model_gv = (
+                coefficient_model_gv + f"bs8*(Omegam**gamma*s8)*sigg**({2*m_index}),"
+            )
+        elif term_index == 1:
+            coefficient_model_gv = (
+                coefficient_model_gv + f"(Omegam**gamma*s8)**2*sigg**({2*m_index}),"
+            )
+    coefficient_model_gv = coefficient_model_gv + "]"
+    coefficient_models.append(
+        {
+            "gg": coefficient_model_gg,
+            "gv": coefficient_model_gv,
+            "vv": "[(Omegam**gamma*s8)**2]",
+        }
+    )
+
+    coefficient_model_gg = "["
+    for gg_term in gg_terms:
+        term_index, m_index = np.array(gg_term.split("_")).astype(int)
+        if term_index == 0:
+            coefficient_model_gg = coefficient_model_gg + f"bs8**2*sigg**({2*m_index}),"
+        elif term_index == 1:
+            coefficient_model_gg = (
+                coefficient_model_gg + f"bs8*fs8*sigg**({2*m_index}),"
+            )
+        elif term_index == 2:
+            coefficient_model_gg = coefficient_model_gg + f"fs8**2*sigg**({2*m_index}),"
+    coefficient_model_gg = coefficient_model_gg + "]"
+
+    coefficient_model_gv = "["
+    for gv_term in gv_terms:
+        term_index, m_index = np.array(gv_term.split("_")).astype(int)
+        if term_index == 0:
+            coefficient_model_gv = (
+                coefficient_model_gv + f"bs8*fs8*sigg**({2*m_index}),"
+            )
+        elif term_index == 1:
+            coefficient_model_gv = coefficient_model_gv + f"fs8**2*sigg**({2*m_index}),"
+    coefficient_model_gv = coefficient_model_gv + "]"
+    coefficient_models.append(
+        {
+            "gg": coefficient_model_gg,
+            "gv": coefficient_model_gv,
+            "vv": "[fs8**2]",
+        }
+    )
+
+    coefficient_model_gg = "["
+    for gg_term in gg_terms:
+        term_index, m_index = np.array(gg_term.split("_")).astype(int)
+        if term_index == 0:
+            coefficient_model_gg = coefficient_model_gg + f"bs8**2*sigg**({2*m_index}),"
+        elif term_index == 1:
+            coefficient_model_gg = (
+                coefficient_model_gg + f"bs8**2*beta_f*sigg**({2*m_index}),"
+            )
+        elif term_index == 2:
+            coefficient_model_gg = (
+                coefficient_model_gg + f"bs8**2*beta_f**2*sigg**({2*m_index}),"
+            )
+    coefficient_model_gg = coefficient_model_gg + "]"
+
+    coefficient_model_gv = "["
+    for gv_term in gv_terms:
+        term_index, m_index = np.array(gv_term.split("_")).astype(int)
+        if term_index == 0:
+            coefficient_model_gv = (
+                coefficient_model_gv + f"bs8*fs8*sigg**({2*m_index}),"
+            )
+        elif term_index == 1:
+            coefficient_model_gv = (
+                coefficient_model_gv + f"bs8**2*beta_f**2*sigg**({2*m_index}),"
+            )
+    coefficient_model_gv = coefficient_model_gv + "]"
+    coefficient_models.append(
+        {
+            "gg": coefficient_model_gg,
+            "gv": coefficient_model_gv,
+            "vv": "[fs8**2]",
+        }
+    )
+
+    write_partial_derivatives(
+        filename,
+        name_models,
+        components,
+        parameter_models,
+        all_parameters,
+        coefficient_models,
+    )
+
+
 def generate_files():
     """
     The generate_files function generates the following files:
@@ -652,6 +1100,19 @@ def generate_files():
 
     """
     generate_generalized_carreres23_functions()
+    generate_generalized_adamsblake17plane_functions()
     generate_generalized_adamsblake20_functions()
     generate_generalized_lai22_functions()
     generate_generalized_ravouxcarreres_functions()
+
+
+def generate_fisher_files():
+    generate_fisher_coefficients_dictionnary_carreres23()
+    generate_fisher_coefficients_dictionnary_adamsblake17plane()
+    generate_fisher_coefficients_dictionnary_full_nosigmag(
+        "./adamsblake20/fisher_terms.py"
+    )
+    generate_fisher_coefficients_dictionnary_full_nosigmag(
+        "./ravouxcarreres/fisher_terms.py"
+    )
+    generate_fisher_coefficients_dictionnary_lai22()

From 8cdb2eacc0cb00b26ce33590efd6ff07d4f93d0d Mon Sep 17 00:00:00 2001
From: corentinravoux <corentin.ravoux.research@gmail.com>
Date: Fri, 17 May 2024 11:59:09 +0200
Subject: [PATCH 07/11] Creation of fisher terms for all models

---
 .../adamsblake17plane/fisher_terms.py         |  299 ++
 flip/covariance/adamsblake20/fisher_terms.py  |  812 ++++
 flip/covariance/carreres23/coefficients.py    |   40 -
 flip/covariance/carreres23/fisher_terms.py    |   47 +
 flip/covariance/lai22/fisher_terms.py         | 3910 +++++++++++++++++
 .../covariance/ravouxcarreres/fisher_terms.py |  812 ++++
 flip/fisher.py                                |    2 +-
 7 files changed, 5881 insertions(+), 41 deletions(-)
 create mode 100644 flip/covariance/adamsblake17plane/fisher_terms.py
 create mode 100644 flip/covariance/adamsblake20/fisher_terms.py
 create mode 100644 flip/covariance/carreres23/fisher_terms.py
 create mode 100644 flip/covariance/lai22/fisher_terms.py
 create mode 100644 flip/covariance/ravouxcarreres/fisher_terms.py

diff --git a/flip/covariance/adamsblake17plane/fisher_terms.py b/flip/covariance/adamsblake17plane/fisher_terms.py
new file mode 100644
index 0000000..2265c14
--- /dev/null
+++ b/flip/covariance/adamsblake17plane/fisher_terms.py
@@ -0,0 +1,299 @@
+import numpy as np
+
+
+def get_partial_derivative_coefficients(
+    model_type,
+    parameter_values_dict,
+    variant=None,
+):
+    if model_type == "density":
+        return get_partial_derivative_coefficients_density(
+            parameter_values_dict,
+            variant=variant,
+        )
+    elif model_type == "velocity":
+        return get_partial_derivative_coefficients_velocity(
+            parameter_values_dict,
+            variant=variant,
+        )
+    elif model_type == "density_velocity":
+        return get_partial_derivative_coefficients_density_velocity(
+            parameter_values_dict,
+            variant=variant,
+        )
+    elif model_type == "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
diff --git a/flip/covariance/adamsblake20/fisher_terms.py b/flip/covariance/adamsblake20/fisher_terms.py
new file mode 100644
index 0000000..b185a0b
--- /dev/null
+++ b/flip/covariance/adamsblake20/fisher_terms.py
@@ -0,0 +1,812 @@
+import numpy as np
+
+
+def get_partial_derivative_coefficients(
+    model_type,
+    parameter_values_dict,
+    variant=None,
+):
+    if model_type == "density":
+        return get_partial_derivative_coefficients_density(
+            parameter_values_dict,
+            variant=variant,
+        )
+    elif model_type == "velocity":
+        return get_partial_derivative_coefficients_velocity(
+            parameter_values_dict,
+            variant=variant,
+        )
+    elif model_type == "density_velocity":
+        return get_partial_derivative_coefficients_density_velocity(
+            parameter_values_dict,
+            variant=variant,
+        )
+    elif model_type == "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,
+                ],
+            },
+            "beta_f": {
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    elif variant == "growth_index_nobeta":
+        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,
+                ],
+            },
+        }
+    elif variant == "nobeta":
+        partial_coefficients_dict = {
+            "fs8": {
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    else:
+        partial_coefficients_dict = {
+            "fs8": {
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "vv": [
+                    0,
+                ],
+            },
+            "beta_f": {
+                "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,
+                    0,
+                    0,
+                ],
+            },
+            "gamma": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                ],
+            },
+            "s8": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                ],
+            },
+        }
+    elif variant == "growth_index_nobeta":
+        partial_coefficients_dict = {
+            "Omegam": {
+                "gg": [
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    / parameter_values_dict["Omegam"],
+                    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,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                ],
+            },
+            "s8": {
+                "gg": [
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"],
+                    0,
+                ],
+            },
+        }
+    elif variant == "nobeta":
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    parameter_values_dict["fs8"],
+                    0,
+                ],
+            },
+        }
+    else:
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                ],
+            },
+        }
+    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,
+                    0,
+                    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,
+                    0,
+                    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,
+                    0,
+                    0,
+                ],
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    elif variant == "growth_index_nobeta":
+        partial_coefficients_dict = {
+            "Omegam": {
+                "gg": [
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    / 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,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * 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,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"],
+                    0,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    elif variant == "nobeta":
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["fs8"],
+                ],
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    parameter_values_dict["fs8"],
+                    0,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    else:
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                ],
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                ],
+                "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,
+                    0,
+                    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"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["beta_f"]
+                    * 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,
+                    0,
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["beta_f"]
+                    * 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,
+                    0,
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["beta_f"]
+                    * 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"],
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["s8"],
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                ],
+                "gv": [
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"],
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    elif variant == "growth_index_nobeta":
+        partial_coefficients_dict = {
+            "Omegam": {
+                "gg": [
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    / parameter_values_dict["Omegam"],
+                ],
+                "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"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    / 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,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * 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,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"],
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"],
+                    0,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    elif variant == "nobeta":
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["fs8"],
+                ],
+                "gv": [
+                    parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["fs8"],
+                ],
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    parameter_values_dict["fs8"],
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["fs8"],
+                    0,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    else:
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["bs8"],
+                    parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                ],
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                ],
+                "gv": [
+                    parameter_values_dict["fs8"],
+                    parameter_values_dict["beta_f"] * parameter_values_dict["fs8"],
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                ],
+                "gv": [
+                    0,
+                    parameter_values_dict["bs8"] * parameter_values_dict["fs8"],
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    return partial_coefficients_dict
diff --git a/flip/covariance/carreres23/coefficients.py b/flip/covariance/carreres23/coefficients.py
index 02d522b..7436fab 100644
--- a/flip/covariance/carreres23/coefficients.py
+++ b/flip/covariance/carreres23/coefficients.py
@@ -15,43 +15,3 @@ def get_diagonal_coefficients(model_type, parameter_values_dict):
     coefficients_dict = {}
     coefficients_dict["vv"] = parameter_values_dict["sigv"] ** 2
     return coefficients_dict
-
-
-def get_partial_derivative_coefficients(
-    model_type,
-    parameter_values_dict,
-    variant=None,
-):
-    partial_coefficients_dict = {}
-    if variant == "growth_index":
-        partial_coefficients_dict = {
-            "Omegam": {
-                "vv": [
-                    2
-                    * parameter_values_dict["gamma"]
-                    * parameter_values_dict["Omegam"]
-                    ** (2 * parameter_values_dict["gamma"] - 1)
-                    * parameter_values_dict["s8"] ** 2
-                ]
-            },
-            "gamma": {
-                "vv": [
-                    2
-                    * np.log(parameter_values_dict["Omegam"])
-                    * parameter_values_dict["Omegam"]
-                    ** (2 * parameter_values_dict["gamma"])
-                    * parameter_values_dict["s8"] ** 2
-                ]
-            },
-            "s8": {
-                "vv": [
-                    2
-                    * parameter_values_dict["Omegam"]
-                    ** (2 * parameter_values_dict["gamma"])
-                    * parameter_values_dict["s8"],
-                ]
-            },
-        }
-    else:
-        partial_coefficients_dict = {"fs8": {"vv": [2 * parameter_values_dict["fs8"]]}}
-    return partial_coefficients_dict
diff --git a/flip/covariance/carreres23/fisher_terms.py b/flip/covariance/carreres23/fisher_terms.py
new file mode 100644
index 0000000..ed2e119
--- /dev/null
+++ b/flip/covariance/carreres23/fisher_terms.py
@@ -0,0 +1,47 @@
+import numpy as np
+
+
+def get_partial_derivative_coefficients(
+    model_type,
+    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"],
+                ],
+            },
+        }
+    else:
+        partial_coefficients_dict = {
+            "fs8": {
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+        }
+    return partial_coefficients_dict
diff --git a/flip/covariance/lai22/fisher_terms.py b/flip/covariance/lai22/fisher_terms.py
new file mode 100644
index 0000000..b57b975
--- /dev/null
+++ b/flip/covariance/lai22/fisher_terms.py
@@ -0,0 +1,3910 @@
+import numpy as np
+
+
+def get_partial_derivative_coefficients(
+    model_type,
+    parameter_values_dict,
+    variant=None,
+):
+    if model_type == "density":
+        return get_partial_derivative_coefficients_density(
+            parameter_values_dict,
+            variant=variant,
+        )
+    elif model_type == "velocity":
+        return get_partial_derivative_coefficients_velocity(
+            parameter_values_dict,
+            variant=variant,
+        )
+    elif model_type == "density_velocity":
+        return get_partial_derivative_coefficients_density_velocity(
+            parameter_values_dict,
+            variant=variant,
+        )
+    elif model_type == "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,
+                ],
+            },
+            "beta_f": {
+                "vv": [
+                    0,
+                ],
+            },
+            "sigg": {
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    elif variant == "growth_index_nobeta":
+        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,
+                ],
+            },
+            "sigg": {
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    elif variant == "nobeta":
+        partial_coefficients_dict = {
+            "fs8": {
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "vv": [
+                    0,
+                ],
+            },
+            "sigg": {
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    else:
+        partial_coefficients_dict = {
+            "fs8": {
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "vv": [
+                    0,
+                ],
+            },
+            "beta_f": {
+                "vv": [
+                    0,
+                ],
+            },
+            "sigg": {
+                "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,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+            },
+            "gamma": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+            },
+            "s8": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+            },
+            "sigg": {
+                "gg": [
+                    0,
+                    2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                ],
+            },
+        }
+    elif variant == "growth_index_nobeta":
+        partial_coefficients_dict = {
+            "Omegam": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 8
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 10
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 12
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12
+                    / parameter_values_dict["Omegam"],
+                ],
+            },
+            "gamma": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 8
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 10
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 12
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12
+                    * np.log(parameter_values_dict["Omegam"]),
+                ],
+            },
+            "s8": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+            },
+            "sigg": {
+                "gg": [
+                    0,
+                    2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                ],
+            },
+        }
+    elif variant == "nobeta":
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["bs8"],
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 12,
+                    2 * parameter_values_dict["fs8"],
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    parameter_values_dict["fs8"],
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 12,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+            },
+            "sigg": {
+                "gg": [
+                    0,
+                    2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                ],
+            },
+        }
+    else:
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+            },
+            "sigg": {
+                "gg": [
+                    0,
+                    2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                ],
+            },
+        }
+    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,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    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,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    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,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "sigg": {
+                "gg": [
+                    0,
+                    2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    elif variant == "growth_index_nobeta":
+        partial_coefficients_dict = {
+            "Omegam": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 8
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 10
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 12
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12
+                    / 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,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 8
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 10
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 12
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12
+                    * 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,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "sigg": {
+                "gg": [
+                    0,
+                    2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    elif variant == "nobeta":
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["bs8"],
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 12,
+                    2 * parameter_values_dict["fs8"],
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    parameter_values_dict["fs8"],
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 12,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "sigg": {
+                "gg": [
+                    0,
+                    2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    else:
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "sigg": {
+                "gg": [
+                    0,
+                    2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                ],
+                "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,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    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"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6
+                    / parameter_values_dict["Omegam"],
+                    0,
+                    0,
+                    0,
+                    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,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6
+                    * np.log(parameter_values_dict["Omegam"]),
+                    0,
+                    0,
+                    0,
+                    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,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+                "gv": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "sigg": {
+                "gg": [
+                    0,
+                    2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                ],
+                "gv": [
+                    0,
+                    2
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 5,
+                    0,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    elif variant == "growth_index_nobeta":
+        partial_coefficients_dict = {
+            "Omegam": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 8
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 10
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 12
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12
+                    / parameter_values_dict["Omegam"],
+                ],
+                "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"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4
+                    / parameter_values_dict["Omegam"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6
+                    / 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,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 8
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 10
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 12
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12
+                    * np.log(parameter_values_dict["Omegam"]),
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6
+                    * 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,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                ],
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "sigg": {
+                "gg": [
+                    0,
+                    2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                ],
+                "gv": [
+                    0,
+                    2
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * parameter_values_dict["sigg"] ** 5,
+                    0,
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    elif variant == "nobeta":
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["bs8"],
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 12,
+                    2 * parameter_values_dict["fs8"],
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+                "gv": [
+                    parameter_values_dict["bs8"],
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 6,
+                    2 * parameter_values_dict["fs8"],
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                ],
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    parameter_values_dict["fs8"],
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 12,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["fs8"],
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 6,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "sigg": {
+                "gg": [
+                    0,
+                    2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                ],
+                "gv": [
+                    0,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 5,
+                    0,
+                    2
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["fs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    else:
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["bs8"],
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["bs8"] * parameter_values_dict["sigg"] ** 6,
+                    0,
+                    0,
+                    0,
+                    0,
+                ],
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+                "gv": [
+                    parameter_values_dict["fs8"],
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["fs8"] * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["sigg"] ** 6,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10,
+                    parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 8,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 10,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 12,
+                ],
+                "gv": [
+                    0,
+                    0,
+                    0,
+                    0,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 4,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 6,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "sigg": {
+                "gg": [
+                    0,
+                    2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                    0,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                    8
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 7,
+                    10
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 9,
+                    12
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 11,
+                ],
+                "gv": [
+                    0,
+                    2
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["fs8"]
+                    * parameter_values_dict["sigg"] ** 5,
+                    0,
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"],
+                    4
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 3,
+                    6
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"] ** 2
+                    * parameter_values_dict["sigg"] ** 5,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    return partial_coefficients_dict
diff --git a/flip/covariance/ravouxcarreres/fisher_terms.py b/flip/covariance/ravouxcarreres/fisher_terms.py
new file mode 100644
index 0000000..b185a0b
--- /dev/null
+++ b/flip/covariance/ravouxcarreres/fisher_terms.py
@@ -0,0 +1,812 @@
+import numpy as np
+
+
+def get_partial_derivative_coefficients(
+    model_type,
+    parameter_values_dict,
+    variant=None,
+):
+    if model_type == "density":
+        return get_partial_derivative_coefficients_density(
+            parameter_values_dict,
+            variant=variant,
+        )
+    elif model_type == "velocity":
+        return get_partial_derivative_coefficients_velocity(
+            parameter_values_dict,
+            variant=variant,
+        )
+    elif model_type == "density_velocity":
+        return get_partial_derivative_coefficients_density_velocity(
+            parameter_values_dict,
+            variant=variant,
+        )
+    elif model_type == "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,
+                ],
+            },
+            "beta_f": {
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    elif variant == "growth_index_nobeta":
+        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,
+                ],
+            },
+        }
+    elif variant == "nobeta":
+        partial_coefficients_dict = {
+            "fs8": {
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    else:
+        partial_coefficients_dict = {
+            "fs8": {
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "vv": [
+                    0,
+                ],
+            },
+            "beta_f": {
+                "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,
+                    0,
+                    0,
+                ],
+            },
+            "gamma": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                ],
+            },
+            "s8": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                ],
+            },
+        }
+    elif variant == "growth_index_nobeta":
+        partial_coefficients_dict = {
+            "Omegam": {
+                "gg": [
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    / parameter_values_dict["Omegam"],
+                    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,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                ],
+            },
+            "s8": {
+                "gg": [
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"],
+                    0,
+                ],
+            },
+        }
+    elif variant == "nobeta":
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    parameter_values_dict["fs8"],
+                    0,
+                ],
+            },
+        }
+    else:
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                ],
+            },
+        }
+    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,
+                    0,
+                    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,
+                    0,
+                    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,
+                    0,
+                    0,
+                ],
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    elif variant == "growth_index_nobeta":
+        partial_coefficients_dict = {
+            "Omegam": {
+                "gg": [
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    / 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,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * 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,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"],
+                    0,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    elif variant == "nobeta":
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["fs8"],
+                ],
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    parameter_values_dict["fs8"],
+                    0,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    else:
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                ],
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                ],
+                "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,
+                    0,
+                    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"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["beta_f"]
+                    * 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,
+                    0,
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * np.log(parameter_values_dict["Omegam"]),
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["beta_f"]
+                    * 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,
+                    0,
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["beta_f"]
+                    * 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"],
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["s8"],
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                ],
+                "gv": [
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"],
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    elif variant == "growth_index_nobeta":
+        partial_coefficients_dict = {
+            "Omegam": {
+                "gg": [
+                    0,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"]
+                    / parameter_values_dict["Omegam"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    / parameter_values_dict["Omegam"],
+                ],
+                "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"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"] ** 2
+                    / 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,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * np.log(parameter_values_dict["Omegam"]),
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"]
+                    * parameter_values_dict["s8"]
+                    * np.log(parameter_values_dict["Omegam"]),
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"] ** 2
+                    * 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,
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+                "vv": [
+                    2
+                    * parameter_values_dict["Omegam"]
+                    ** (2 * parameter_values_dict["gamma"])
+                    * parameter_values_dict["s8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"],
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["Omegam"] ** parameter_values_dict["gamma"]
+                    * parameter_values_dict["s8"],
+                    0,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    elif variant == "nobeta":
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["fs8"],
+                ],
+                "gv": [
+                    parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["fs8"],
+                ],
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    parameter_values_dict["fs8"],
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["fs8"],
+                    0,
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    else:
+        partial_coefficients_dict = {
+            "fs8": {
+                "gg": [
+                    0,
+                    0,
+                    0,
+                ],
+                "gv": [
+                    parameter_values_dict["bs8"],
+                    parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                ],
+                "vv": [
+                    2 * parameter_values_dict["fs8"],
+                ],
+            },
+            "bs8": {
+                "gg": [
+                    2 * parameter_values_dict["bs8"],
+                    2 * parameter_values_dict["beta_f"] * parameter_values_dict["bs8"],
+                    2
+                    * parameter_values_dict["beta_f"] ** 2
+                    * parameter_values_dict["bs8"],
+                ],
+                "gv": [
+                    parameter_values_dict["fs8"],
+                    parameter_values_dict["beta_f"] * parameter_values_dict["fs8"],
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+            "beta_f": {
+                "gg": [
+                    0,
+                    parameter_values_dict["bs8"] ** 2,
+                    2
+                    * parameter_values_dict["beta_f"]
+                    * parameter_values_dict["bs8"] ** 2,
+                ],
+                "gv": [
+                    0,
+                    parameter_values_dict["bs8"] * parameter_values_dict["fs8"],
+                ],
+                "vv": [
+                    0,
+                ],
+            },
+        }
+    return partial_coefficients_dict
diff --git a/flip/fisher.py b/flip/fisher.py
index c174aba..4c1bbd7 100644
--- a/flip/fisher.py
+++ b/flip/fisher.py
@@ -169,7 +169,7 @@ def compute_fisher_matrix(
     ):
 
         coefficients = importlib.import_module(
-            f"flip.covariance.{self.covariance.model_name}.coefficients"
+            f"flip.covariance.{self.covariance.model_name}.fisher_terms"
         )
         partial_coefficients_dict = coefficients.get_partial_derivative_coefficients(
             self.covariance.model_type,

From 0705a0cd1048cbae243509d514d043a98a41a8d4 Mon Sep 17 00:00:00 2001
From: DamianoRosselli <rosselli@cppm.in2p3.fr>
Date: Mon, 10 Jun 2024 17:57:39 +0200
Subject: [PATCH 08/11] correct bug in velocity error from saltfit

---
 flip/vectors.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/flip/vectors.py b/flip/vectors.py
index dc2a012..664d411 100644
--- a/flip/vectors.py
+++ b/flip/vectors.py
@@ -218,7 +218,7 @@ def get_velocity_error_from_salt_fit(
 
     velocity_error = redshift_dependence * np.sqrt(variance_mu)
 
-    return velocity_error, redshift_dependence
+    return velocity_error
 
 
 def get_velocity_from_salt_fit(

From a5f6d92013e82d925810f4c81def3173e02b81f9 Mon Sep 17 00:00:00 2001
From: corentinravoux <corentin.ravoux.research@gmail.com>
Date: Tue, 18 Jun 2024 12:04:38 +0200
Subject: [PATCH 09/11] fix on the script

---
 scripts/flip_fisher_forecast_velocity.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/flip_fisher_forecast_velocity.py b/scripts/flip_fisher_forecast_velocity.py
index 3e3991d..56a67c0 100644
--- a/scripts/flip_fisher_forecast_velocity.py
+++ b/scripts/flip_fisher_forecast_velocity.py
@@ -70,5 +70,5 @@
 )
 
 parameter_name_list, fisher_matrix = Fisher.compute_fisher_matrix(
-    parameter_dict, variant=None
+    parameter_dict, variant=variant
 )

From e53779d2220d1f4d03d65e8c04e21319f6d46b17 Mon Sep 17 00:00:00 2001
From: corentinravoux <corentin.ravoux.research@gmail.com>
Date: Tue, 25 Jun 2024 09:28:39 +0200
Subject: [PATCH 10/11] important fix for the fisher forecast

---
 flip/fisher.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/flip/fisher.py b/flip/fisher.py
index 4c1bbd7..115e0fe 100644
--- a/flip/fisher.py
+++ b/flip/fisher.py
@@ -185,9 +185,11 @@ def compute_fisher_matrix(
         ) in partial_coefficients_dict.items():
             parameter_name_list.append(parameter_name)
             covariance_derivative_sum_list.append(
-                self.inverse_covariance_sum
-                * self.compute_covariance_derivative(
-                    partial_coefficients_dict_param,
+                np.dot(
+                    self.inverse_covariance_sum,
+                    self.compute_covariance_derivative(
+                        partial_coefficients_dict_param,
+                    ),
                 )
             )
 

From 5d1a6df3c82d40791b5b795d8b3758d96c611a82 Mon Sep 17 00:00:00 2001
From: corentinravoux <corentin.ravoux.research@gmail.com>
Date: Tue, 25 Jun 2024 09:30:49 +0200
Subject: [PATCH 11/11] return values dictionnary at the end of the minuit run

---
 flip/fitter.py | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/flip/fitter.py b/flip/fitter.py
index 7976fcc..1bdc384 100644
--- a/flip/fitter.py
+++ b/flip/fitter.py
@@ -100,7 +100,7 @@ def get_likelihood(
         )
 
         return likelihood
-    
+
     @staticmethod
     def select_likelihood(likelihood_type):
         """
@@ -194,7 +194,10 @@ def init_from_covariance(
         likelihood = minuit_fitter.get_likelihood(
             parameter_dict,
             likelihood_type=likelihood_type,
-            likelihood_properties={**likelihood_properties, 'negative_log_likelihood': True},
+            likelihood_properties={
+                **likelihood_properties,
+                "negative_log_likelihood": True,
+            },
             **kwargs,
         )
         minuit_fitter.likelihood = likelihood
@@ -247,7 +250,10 @@ def init_from_file(
             data,
             parameter_dict,
             likelihood_type=likelihood_type,
-            likelihood_properties={**likelihood_properties, 'negative_log_likelihood': True},
+            likelihood_properties={
+                **likelihood_properties,
+                "negative_log_likelihood": True,
+            },
         )
 
     def setup_minuit(self, parameter_dict):
@@ -302,6 +308,8 @@ def run(self, migrad=True, hesse=False, minos=False, n_iter=1):
         if minos:
             log.add(self.minuit.minos())
 
+        return self.minuit.values.to_dict()
+
 
 class FitMCMC(BaseFitter):
     """Class to create and run a MCMC sampler with emcee package."""
@@ -396,12 +404,12 @@ def init_from_file(
         """
 
         raise NotImplementedError
-    
+
     def set_sampler(self, likelihood, p0=None, **kwargs):
-        if self.sampler_name == 'emcee':
+        if self.sampler_name == "emcee":
             self.sampler = EMCEESampler(likelihood, p0=p0, **kwargs)
         else:
-            raise ValueError('Only emcee is available now')
+            raise ValueError("Only emcee is available now")
 
 
 class Sampler(abc.ABC):
@@ -481,7 +489,9 @@ def run_chains_untilconv(
                 pool=pool,
                 backend=self.backend,
             )
-            for sample in sampler.sample(self.p0, iterations=maxstep, progress=progress):
+            for sample in sampler.sample(
+                self.p0, iterations=maxstep, progress=progress
+            ):
                 if sampler.iteration % 500 == 0:
                     # Compute tau
                     tau = sampler.get_autocorr_time(tol=0)