rock-physics-open 0.0__py3-none-any.whl

rock_physics_open/sandstone_models/unresolved_friable_sandshale_models.py

@@ -0,0 +1,126 @@
+from rock_physics_open import sandstone_models as sm
+from rock_physics_open.equinor_utilities import std_functions
+
+
+def unresolved_friable_sand_shale_model(
+    k_sst,
+    mu_sst,
+    rho_sst,
+    k_mud,
+    mu_mud,
+    rho_mud,
+    k_fl_sst,
+    rho_fl_sst,
+    k_fl_mud,
+    rho_fl_mud,
+    phi_sst,
+    phi_mud,
+    p_eff_sst,
+    p_eff_mud,
+    shale_frac,
+    phi_c_sst,
+    phi_c_mud,
+    coord_num_func_sst,
+    n_sst,
+    coord_num_func_mud,
+    n_mud,
+    shear_red_sst,
+    shear_red_mud,
+):
+    """
+    Model for siliciclastic rocks with alternating layers of friable sand and shale, and in which the layers are not
+    resolved by the investigating signal. Backus average is used to calculate the anisotropic effect of the alternating
+    layers.
+
+    Parameters
+    ----------
+    k_sst : np.ndarray
+        Sandstone bulk modulus [Pa].
+    mu_sst : np.ndarray
+        Sandstone shear modulus [Pa].
+    rho_sst : np.ndarray
+        Sandstone bulk density [kg/m^3].
+    k_mud : np.ndarray
+        Shale bulk modulus [Pa].
+    mu_mud : np.ndarray
+        Shale shear modulus [Pa].
+    rho_mud : np.ndarray
+        Shale bulk density [kg/m^3].
+    k_fl_sst : np.ndarray
+        Fluid bulk modulus for sandstone fluid [Pa].
+    rho_fl_sst : np.ndarray
+        Fluid bulk density for sandstone fluid [kg/m^3].
+    k_fl_mud : np.ndarray
+        Fluid bulk modulus for shale fluid [Pa].
+    rho_fl_mud : np.ndarray
+        Fluid bulk density for shale fluid [kg/m^3].
+    phi_sst : np.ndarray
+        Sandstone porosity [fraction].
+    phi_mud : np.ndarray
+        Shale porosity [fraction].
+    p_eff_sst : np.ndarray
+        Effective pressure in sandstone [Pa].
+    p_eff_mud : np.ndarray
+        Effective pressure in mud [Pa].
+    shale_frac : np.ndarray
+        Shale fraction [fraction].
+    phi_c_sst : float
+        Critical porosity for sandstone [fraction].
+    phi_c_mud : float
+        Critical porosity for mud [fraction].
+    coord_num_func_sst : str
+        Indication if coordination number should be calculated from porosity or kept constant for sandstone.
+    coord_num_func_mud : str
+        Indication if coordination number should be calculated from porosity or kept constant for shale.
+    n_sst : float
+        Coordination number for sandstone [unitless].
+    n_mud : float
+        Coordination number for shale [unitless].
+    shear_red_sst : float
+        Shear reduction factor for sandstone [fraction].
+    shear_red_mud : float
+        Shear reduction factor for mud [fraction].
+
+    Returns
+    -------
+    tuple
+        vpv, vsv, vph, vsh, rho : (np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray).
+        vertical p-wave velocity, vertical shear-wave velocity, horizontal p-wave velocity, horizontal shear-wave
+        velocity (all [m/s]), bulk density [kg/m^3].
+    """
+
+    # Estimate the sand and shale end members through the friable models
+    vp_sst, vs_sst, rho_b_sst = sm.friable_model(
+        k_sst,
+        mu_sst,
+        rho_sst,
+        k_fl_sst,
+        rho_fl_sst,
+        phi_sst,
+        p_eff_sst,
+        phi_c_sst,
+        coord_num_func_sst,
+        n_sst,
+        shear_red_sst,
+    )[0:3]
+
+    vp_mud, vs_mud, rho_b_mud = sm.friable_model(
+        k_mud,
+        mu_mud,
+        rho_mud,
+        k_fl_mud,
+        rho_fl_mud,
+        phi_mud,
+        p_eff_mud,
+        phi_c_mud,
+        coord_num_func_mud,
+        n_mud,
+        shear_red_mud,
+    )[0:3]
+
+    # Calculate Backus average for the effective medium
+    vpv, vsv, vph, vsh, rho = std_functions.backus_average(
+        vp_sst, vs_sst, rho_b_sst, vp_mud, vs_mud, rho_b_mud, 1.0 - shale_frac
+    )
+
+    return vpv, vsv, vph, vsh, rho

rock_physics_open/shale_models/__init__.py

@@ -0,0 +1,19 @@
+from .dem import dem_model
+from .dem_dual_por import dem_model_dual_por
+from .kus_tok import kuster_toksoz_model
+from .multi_sca import multi_sca
+from .pq import p_q_fcn
+from .sca import self_consistent_approximation_model
+from .shale4_mineral import shale_model_4_mineral_dem
+from .shale4_mineral_dem_overlay import shale_4_min_dem_overlay
+
+__all__ = [
+    "dem_model",
+    "dem_model_dual_por",
+    "kuster_toksoz_model",
+    "multi_sca",
+    "p_q_fcn",
+    "self_consistent_approximation_model",
+    "shale_model_4_mineral_dem",
+    "shale_4_min_dem_overlay",
+]

rock_physics_open/shale_models/dem.py

@@ -0,0 +1,174 @@
+import sys
+
+import numpy as np
+from scipy.integrate import odeint
+
+from .pq import p_q_fcn
+
+
+def dem_model(k1, mu1, rho1, k2, mu2, rho2, frac2, asp2, tol):
+    """
+    DEM - Effective elastic moduli using Differential Effective Medium formulation.
+
+    Parameters
+    ----------
+    k1 : np.ndarray
+        Bulk modulus of background matrix [Pa].
+    mu1 : np.ndarray
+        Shear modulus of background matrix [Pa].
+    rho1 : np.ndarray
+        Bulk density of background matrix [kg/m^3].
+    k2 : np.ndarray
+        Bulk modulus of inclusions [Pa].
+    mu2 : np.ndarray
+        Shear modulus of inclusions [Pa].
+    rho2 : np.ndarray
+        Bulk density of inclusions [kg/m^3].
+    frac2 : np.ndarray
+        Fraction of inclusions [fraction].
+    asp2 : np.ndarray
+        Aspect ratio of inclusions [ratio].
+    tol: float
+        Desired accuracy in the ODE solver.
+
+    Returns
+    -------
+    tuple
+        k, mu, rho : (np.ndarray, np.ndarray, np.ndarray).
+        k: effective medium bulk modulus [Pa], mu: effective medium shear modulus [Pa], rho: bulk density [kg/m^3].
+
+    Comments
+    --------
+    Written by T. Mukerji, SRB, Stanford University.
+    Ported to Python by Harald Flesche, Equinor 2015.
+    """
+
+    # Make sure all log inputs are vectors, expand scalars, throw error if uneven
+    # length and not scalars
+    k = np.ones(k1.shape) * np.nan
+    mu = np.ones(k1.shape) * np.nan
+    rhob = rho1 * (1 - frac2) + rho2 * frac2
+
+    # Check for the trivial cases: all inclusions or all matrix
+    idx = np.logical_or(frac2 == 1.0, frac2 == 0.0)
+    if np.any(idx):
+        idx1 = frac2 == 1.0
+        idx2 = frac2 == 0.0
+        if np.any(idx1):
+            k[idx1] = k2[idx1]
+            mu[idx1] = mu2[idx1]
+        if np.any(idx2):
+            k[idx2] = k1[idx2]
+            mu[idx2] = mu1[idx2]
+    if np.all(idx):
+        return k, mu, rhob
+
+    # Need to run the DEM model for cases that are mixed
+    idx1 = ~idx
+    frac2 = frac2[idx1]
+
+    # Only need to run the ODE on different initial conditions
+    uni, idx_restore = np.unique(
+        np.stack((k1[idx1], mu1[idx1], k2[idx1], mu2[idx1]), axis=1),
+        return_inverse=True,
+        axis=0,
+    )
+    k1, mu1, k2, mu2 = np.split(uni, 4, axis=1)
+    # Must flatten arrays to avoid problems with dimensions
+    k1 = k1.flatten()
+    k2 = k2.flatten()
+    mu1 = mu1.flatten()
+    mu2 = mu2.flatten()
+
+    k_vec = np.zeros(len(idx_restore))
+    mu_vec = np.zeros(len(idx_restore))
+
+    tot = k1.shape[0]
+
+    # Must run ODE solver with values in increasing order, and must start at zero value
+    i_x = np.argsort(frac2)
+    frac2 = frac2[i_x]
+    frac2 = np.insert(frac2, 0, 0)
+    # Find reverse order
+    i_y = np.argsort(i_x)
+
+    # Too many data points create memory problems for ODE solver, set limit at lim = 1000
+    lim = 1000
+    runs = 1 if tot <= lim else tot // lim + 1
+    for i in range(runs):
+        start_i = i * lim
+        end_i = min(tot, (i + 1) * lim)
+
+        # Select part to run, cast to array in case it defaults to single value
+        k1_tmp = np.array(k1[start_i:end_i])
+        mu1_tmp = np.array(mu1[start_i:end_i])
+        k2_tmp = np.array(k2[start_i:end_i])
+        mu2_tmp = np.array(mu2[start_i:end_i])
+        asp2_tmp = np.array(asp2[start_i:end_i])
+
+        y0 = np.concatenate((k1_tmp, mu1_tmp))
+
+        try:
+            y_out = odeint(
+                _demy_prime, y0, frac2, args=(k2_tmp, mu2_tmp, asp2_tmp), rtol=tol
+            )
+        except ValueError:
+            raise ValueError(sys.exc_info())
+
+        # Remove inserted zero-value in row 0, split output in k and mu
+        # Pycharm reports wrong object type here, checked and found to be OK
+        k_out, mu_out = np.split(y_out[1:, :], 2, axis=1)
+
+        # Reorder rows back to original sequence of fraction values
+        k_out = k_out[i_y, :]
+        mu_out = mu_out[i_y, :]
+
+        # Select correct column for the row values
+        idx_pres_range = np.logical_and(idx_restore >= start_i, idx_restore < end_i)
+        for j in range(len(idx_restore)):
+            if idx_pres_range[j]:
+                k_vec[j] = k_out[j, idx_restore[j] - start_i]
+                mu_vec[j] = mu_out[j, idx_restore[j] - start_i]
+
+    k[idx1] = k_vec
+    mu[idx1] = mu_vec
+
+    return k, mu, rhob
+
+
+def _demy_prime(y, t, k2, mu2, asp2):
+    """
+    Used by DEM model.
+
+    Parameters
+    ----------
+    y : np.ndarray
+        y array.
+    t : float
+        t float.
+    k2 : np.ndarray
+        Bulk modulus of inclusions [Pa].
+    mu2 : np.ndarray
+        Shear modulus of inclusions [Pa].
+    asp2 : np.ndarray
+        Aspect ratio of inclusions [ratio].
+
+    Returns
+    -------
+    np.ndarray
+        k, mu array.
+
+    Comments
+    --------
+    Written by T. Mukerji, Stanford University.
+    Rewritten in Python by Harald Flesche, Equinor 2015.
+    """
+    # Input value vector consists of both k and mu values
+    k, mu = np.split(y, 2)
+
+    p, q = p_q_fcn(k, mu, k2, mu2, asp2)
+
+    k_r_hs = (k2 - k) * p / (1 - t)
+    mu_r_hs = (mu2 - mu) * q / (1 - t)
+
+    return np.concatenate((k_r_hs, mu_r_hs))

rock_physics_open/shale_models/dem_dual_por.py

@@ -0,0 +1,61 @@
+from .dem import dem_model
+
+
+def dem_model_dual_por(
+    k1, mu1, rho1, k2, mu2, rho2, k3, mu3, rho3, frac_inc, frac_inc_1, asp_1, asp_2, tol
+):
+    """Differential effective media model with two sets of inclusions.
+
+    Parameters
+    ----------
+    k1 : np.ndarray
+        Matrix bulk modulus [Pa].
+    mu1 : np.ndarray
+        Matrix shear modulus [Pa].
+    rho1 : np.ndarray
+        Matrix bulk density [kg/m^3].
+    k2 : np.ndarray
+        Inclusion 1 bulk modulus [Pa].
+    mu2 : np.ndarray
+        Inclusion 1 shear modulus [Pa].
+    rho2 : np.ndarray
+        Inclusion 1 bulk density [kg/m^3]
+    k3 : np.ndarray
+        Inclusion 2 bulk modulus [Pa].
+    mu3 : np.ndarray
+        Inclusion 2 shear modulus [Pa].
+    rho3 : np.ndarray
+        Inclusion 2 bulk density [kg/m^3].
+    frac_inc : np.ndarray
+        Total fraction of inclusions [fraction].
+    frac_inc_1 : np.ndarray
+        Fraction of inclusions belonging to type 1 [fraction].
+    asp_1 : np.ndarray
+        Aspect ratio of inclusion 1 [fraction].
+    asp_2 : np.ndarray
+        Aspect ratio of inclusion 2 [fraction].
+    tol : float
+        Tolerance of accuracy [unitless].
+
+    Returns
+    -------
+    tuple
+        k_dem_dual: bulk modulus [Pa], mu_dem_dual: shear modulus [Pa], rhob_dem_dual: bulk density [kg/m^3].
+    """
+    # Include the Type 1 inclusions into the matrix first, then run again with inclusions Type 2
+    k_dem1, mu_dem1, rhob_dem1 = dem_model(
+        k1, mu1, rho1, k2, mu2, rho2, frac_inc * frac_inc_1, asp_1, tol
+    )
+    k_dem_dual, mu_dem_dual, rhob_dem_dual = dem_model(
+        k_dem1,
+        mu_dem1,
+        rhob_dem1,
+        k3,
+        mu3,
+        rho3,
+        frac_inc * (1.0 - frac_inc_1),
+        asp_2,
+        tol,
+    )
+
+    return k_dem_dual, mu_dem_dual, rhob_dem_dual

rock_physics_open/shale_models/kus_tok.py

@@ -0,0 +1,59 @@
+import warnings
+
+import numpy as np
+
+from .pq import p_q_fcn
+
+
+def kuster_toksoz_model(k1, mu1, rho1, k2, mu2, rho2, frac1, asp2):
+    """Simplified Kuster-Toksoz model for single mineral inclusion with single aspect ratio.
+
+    Parameters
+    ----------
+    k1 : np.ndarray
+        Phase 1 bulk modulus [Pa].
+    mu1 : np.ndarray
+        Phase 1 shear modulus [Pa].
+    rho1 : np.ndarray
+        Phase 1 bulk density [kg/m^3].
+    k2 : np.ndarray
+        Phase 2 bulk modulus [Pa].
+    mu2 : np.ndarray
+        Phase 2 shear modulus [Pa].
+    rho2 : np.ndarray
+        Phase 2 bulk density [kg/m^3].
+    frac1 : np.ndarray
+        Fraction of phase 1 [fraction].
+    asp2 : np.ndarray
+        Aspect ratio for phase 2 inclusions [ratio].
+
+    Returns
+    -------
+    tuple
+        k_kt, mu_kt, rhob : (np.ndarray, np.ndarray, np.ndarray).
+        effective media properties: k_kt: bulk modulus [Pa], mu_kt: shear modulus [Pa], rhob: bulk density [kg/m^3].
+    """
+    frac2 = 1.0 - frac1
+    rhob = rho1 * frac1 + rho2 * frac2
+    p, q = p_q_fcn(k1, mu1, k2, mu2, asp2)
+    zeta = mu1 / 6.0 * (9.0 * k1 + 8.0 * mu1) / (k1 + 2.0 * mu1)
+
+    k_kt = (k1 * (k1 + 4.0 / 3.0 * mu1) + 4.0 / 3.0 * mu1 * frac2 * (k2 - k1) * p) / (
+        k1 + 4.0 / 3.0 * mu1 - frac2 * (k2 - k1) * p
+    )
+    mu_kt = (mu1 * (mu1 + zeta) + zeta * frac2 * (mu2 - mu1) * q) / (
+        mu1 + zeta - frac2 * (mu2 - mu1) * q
+    )
+
+    # Non-physical situations can arise if there is too high volume fraction of inclusions with
+    # low aspect ratio
+    idx_neg = np.logical_or(k_kt < 0.0, mu_kt < 0.0)
+    if np.any(idx_neg):
+        k_kt[idx_neg] = np.nan
+        mu_kt[idx_neg] = np.nan
+        rhob[idx_neg] = np.nan
+        warnings.warn(
+            f"{__file__}: {np.sum(idx_neg)} non-physical solutions to Kuster-Toksöz equation"
+        )
+
+    return k_kt, mu_kt, rhob

rock_physics_open/shale_models/multi_sca.py

@@ -0,0 +1,133 @@
+import numpy as np
+
+from rock_physics_open.equinor_utilities.gen_utilities import dim_check_vector
+
+from .pq import p_q_fcn
+
+
+def multi_sca(*args, tol):
+    """SCA - Effective elastic moduli using Berryman's Self-Consistent
+    (Coherent Potential Approximation) method.
+
+    -----------------------------------------------
+
+    Inputs for each phase:
+
+    k:      mineral bulk modulus [Pa]
+
+    mu:     mineral shear modulus [Pa]
+
+    rho:    mineral density [kg/m^3]
+
+    asp:    aspect ratio for inclusions [ratio]
+
+    frac:   fraction of matrix that is made up of this mineral [fraction]
+
+    Additional inputs:
+
+    tol:    tolerance parameter (scalar) [unitless]
+
+    The sum of all fractions must add to one, and it will be normalised to one if it differs.
+
+    =======================================================
+
+    Based on function by T. Mukerji, SRB, Stanford University, 1994.
+
+    Ported to Python by Harald Flesche, Equinor 2015.
+
+    Parameters
+    ----------
+    args : list or tuple
+        List or tuple containing multiples of elastic properties as explained above, all numpy arrays.
+    tol : float
+        Tolerance for the SCA iterations.
+
+    Returns
+    -------
+    tuple
+        k_sc, mu_sc, rhob : (np.ndarray, np.ndarray, np.ndarray).
+        effective medium properties k_sc: bulk modulus [Pa], mu_sc: shear modulus [Pa], rhob: bulk density [kg/m^3].
+    """
+    if len(args) % 5 != 0:
+        raise ValueError(
+            "Call function with (k_sc,mu_sc,rhob) = multi_sca((k1,mu1,rho1,asp1,frac1, ...,k_n,mu_n,rho_n,asp_n,"
+            "frac_n,tol)). Fractions must add up to 1.0"
+        )
+
+    args = dim_check_vector(args)
+
+    # Proceed without the parameter, all other inputs should be arrays
+
+    n_mins = len(args) // 5
+
+    # Sort inputs
+    k_min = []
+    mu_min = []
+    rho_min = []
+    frac = []
+    asp = []
+
+    for i in range(n_mins):
+        k_min.append(args[5 * i])
+        mu_min.append(args[5 * i + 1])
+        rho_min.append(args[5 * i + 2])
+        asp.append(args[5 * i + 3])
+        frac.append(args[5 * i + 4])
+
+    # Check and normalise frac
+    tot_frac = np.sum(np.vstack(frac[:]), 0)
+    if np.any(tot_frac != 1.0):
+        for i in range(n_mins):
+            frac[i] = frac[i] / tot_frac
+
+    # Initiate k_sc and mu_sc with weighted sum of phases
+    k_sc = np.sum(np.vstack(k_min[:]) * np.vstack(frac[:]), 0)
+    mu_sc = np.sum(np.vstack(mu_min[:]) * np.vstack(frac[:]), 0)
+    rhob = np.sum(np.vstack(rho_min[:]) * np.vstack(frac[:]), 0)
+
+    idx = np.any(np.vstack(frac[:]) == 1.0, 0)
+    if np.any(idx):
+        # If any of the samples contain 100% of one phase - substitute the result
+        # with the mineral properties of that phase
+        for i in range(n_mins):
+            idx1 = frac[i] == 1.0
+            if np.any(idx1):
+                k_sc[idx1] = k_min[i][idx1]
+                mu_sc[idx1] = mu_min[i][idx1]
+            # Continue with the real mixtures
+            k_min[i] = k_min[i][~idx]
+            mu_min[i] = mu_min[i][~idx]
+            asp[i] = asp[i][~idx]
+            frac[i] = frac[i][~idx]
+    if not np.all(idx):
+        niter = 0
+        # Initiate the delta with a value that makes the while-loop run
+        delta = k_sc[~idx]
+        # Express tolerance in terms of k0
+        tol = tol * k_min[0]
+
+        # Iterate until delta is less than the tolerance and the loop has run for
+        # less than 3000 iterations (normally far less)
+        while np.any(np.logical_and(np.greater(delta, tol), np.less(niter, 3000))):
+            p = []
+            q = []
+            for i in range(n_mins):
+                p_tmp, q_tmp = p_q_fcn(
+                    k_sc[~idx], mu_sc[~idx], k_min[i], mu_min[i], asp[i]
+                )
+                p.append(p_tmp)
+                q.append(q_tmp)
+            k_new = np.sum(
+                np.vstack(frac[:]) * np.vstack(k_min[:]) * np.vstack(p[:]), 0
+            ) / np.sum(np.vstack(frac[:]) * np.vstack(p[:]), 0)
+            mu_new = np.sum(
+                np.vstack(frac[:]) * np.vstack(mu_min[:]) * np.vstack(q[:]), 0
+            ) / np.sum(np.vstack(frac[:]) * np.vstack(q[:]), 0)
+
+            delta = np.absolute(k_sc[~idx] - k_new)
+            k_sc[~idx] = k_new
+            mu_sc[~idx] = mu_new
+
+            niter = niter + 1
+
+    return k_sc, mu_sc, rhob

rock_physics_open/shale_models/pq.py

@@ -0,0 +1,102 @@
+import numpy as np
+
+
+def p_q_fcn(k, mu, k2, mu2, asp):
+    """
+    Geometric factors used in inclusion models.
+
+    References
+    ----------
+    The rock physics handbook, Gary Mavko et al.
+
+    Parameters
+    ----------
+    k : np.ndarray
+        Bulk modulus of phase 1 [Pa].
+    mu : np.ndarray
+        Shear modulus of phase 1 [Pa].
+    k2 : np.ndarray
+        Bulk modulus of phase 2 [Pa].
+    mu2 : np.ndarray
+        Shear modulus of phase 2 [Pa].
+    asp : np.ndarray
+        Aspect ratio [ratio].
+
+    Returns
+    -------
+    tuple
+        p, q : (np.ndarray, np.ndarray).
+        geometric factors p and q.
+    """
+
+    # Functions theta and fn defaults to 2/3 and -2/5 for asp == 1.0
+    idx_oblate = np.less(asp, 1.0)
+    idx_prolate = np.greater(asp, 1.0)
+    theta = 2.0 / 3.0 * np.ones(asp.shape)
+    fn = -2.0 / 5.0 * np.ones(asp.shape)
+
+    if np.any(idx_oblate):
+        theta[idx_oblate] = (
+            asp[idx_oblate] / ((1 - asp[idx_oblate] ** 2) ** (3 / 2))
+        ) * (
+            np.arccos(asp[idx_oblate])
+            - asp[idx_oblate] * np.sqrt(1 - asp[idx_oblate] ** 2)
+        )
+        fn[idx_oblate] = (asp[idx_oblate] ** 2 / (1 - asp[idx_oblate] ** 2)) * (
+            3 * theta[idx_oblate] - 2
+        )
+
+    if np.any(idx_prolate):
+        theta[idx_prolate] = (
+            asp[idx_prolate] / ((asp[idx_prolate] ** 2 - 1) ** (3 / 2))
+        ) * (
+            asp[idx_prolate] * np.sqrt(asp[idx_prolate] ** 2 - 1)
+            - np.arccosh(asp[idx_prolate])
+        )
+        fn[idx_prolate] = (asp[idx_prolate] ** 2 / (asp[idx_prolate] ** 2 - 1)) * (
+            2 - 3 * theta[idx_prolate]
+        )
+
+    nu = (3 * k - 2 * mu) / (2 * (3 * k + mu))
+    r = (1 - 2 * nu) / (2 * (1 - nu))
+    a = mu2 / mu - 1
+    b = (1 / 3) * (k2 / k - mu2 / mu)
+
+    f1 = 1 + a * (
+        (3 / 2) * (fn + theta) - r * ((3 / 2) * fn + (5 / 2) * theta - (4 / 3))
+    )
+
+    f2 = (
+        1
+        + a * (1 + (3 / 2) * (fn + theta) - (r / 2) * (3 * fn + 5 * theta))
+        + b * (3 - 4 * r)
+        + (a / 2)
+        * (a + 3 * b)
+        * (3 - 4 * r)
+        * (fn + theta - r * (fn - theta + 2 * theta**2))
+    )
+
+    f3 = 1 + a * (1 - (fn + (3 / 2) * theta) + r * (fn + theta))
+
+    f4 = 1 + (a / 4) * (fn + 3 * theta - r * (fn - theta))
+
+    f5 = a * (-fn + r * (fn + theta - (4 / 3))) + b * theta * (3 - 4 * r)
+
+    f6 = 1 + a * (1 + fn - r * (fn + theta)) + b * (1 - theta) * (3 - 4 * r)
+
+    f7 = (
+        2
+        + (a / 4) * (3 * fn + 9 * theta - r * (3 * fn + 5 * theta))
+        + b * theta * (3 - 4 * r)
+    )
+
+    f8 = a * (1 - 2 * r + (fn / 2) * (r - 1) + (theta / 2) * (5 * r - 3)) + b * (
+        1 - theta
+    ) * (3 - 4 * r)
+
+    f9 = a * ((r - 1) * fn - r * theta) + b * theta * (3 - 4 * r)
+
+    p = f1 / f2
+    q = (1 / 5) * ((2 / f3) + (1 / f4) + ((f4 * f5 + f6 * f7 - f8 * f9) / (f2 * f4)))
+
+    return p, q