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

rock_physics_open/equinor_utilities/std_functions/hashin_shtrikman.py

@@ -0,0 +1,195 @@
+import numpy as np
+
+from rock_physics_open.equinor_utilities.gen_utilities import dim_check_vector
+
+
+def hashin_shtrikman(k1, mu1, k2, mu2, f):
+    """
+    Hashin-Sktrikman upper or lower according to ordering of phases.
+
+    Parameters
+    ----------
+    k1 : np.ndarray
+        Bulk modulus of phase 1 [Pa].
+    mu1 : 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].
+    f : np.ndarray
+        Fraction of phase 1 [fraction].
+
+    Returns
+    -------
+    tuple
+        k, mu : np.ndarray.
+        k: effective bulk modulus [Pa], mu: effective shear modulus [Pa].
+    """
+    k = k1 + (1 - f) * (k2 - k1) / (1 + (k2 - k1) * f * (k1 + 4 / 3 * mu1) ** -1)
+    mu = mu1 + (1 - f) * (mu2 - mu1) / (
+        1 + 2 * (mu2 - mu1) * f * (k1 + 2 * mu1) / (5 * mu1 * (k1 + 4 / 3 * mu1))
+    )
+
+    return k, mu
+
+
+def hashin_shtrikman_average(k1, mu1, k2, mu2, f):
+    """
+    Average of Hashin-Shtrikman upper and lower bound.
+
+    Parameters
+    ----------
+    k1 : np.ndarray
+        Bulk modulus of phase 1 [Pa].
+    mu1 : 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].
+    f : np.ndarray
+        Fraction of phase 1 [fraction].
+
+    Returns
+    -------
+    tuple
+        k_av, mu_av : np.ndarray.
+        k_av: effective bulk modulus [Pa], mu_av: effective shear modulus [Pa]
+    """
+    k_hs1, mu_hs1 = hashin_shtrikman(k1, mu1, k2, mu2, f)
+    k_hs2, mu_hs2 = hashin_shtrikman(k2, mu2, k1, mu1, 1 - f)
+
+    k_av = (k_hs1 + k_hs2) / 2
+    mu_av = (mu_hs1 + mu_hs2) / 2
+
+    return k_av, mu_av
+
+
+def hashin_shtrikman_walpole(k1, mu1, k2, mu2, f1, bound="lower"):
+    """
+    Hashin-Shtrikman upper bound is obtained when the stiffest material is
+    termed 1 and vice versa for lower bound. Tricky in cases like Quartz -
+    Calcite where the K and Mu have opposed values. HS - Walpole is
+    generalised to regard highest and lowest values in each case. The default
+    is to generate lower bound.
+
+    Parameters
+    ----------
+    k1 : np.ndarray
+        Bulk modulus of phase 1 [Pa].
+    mu1 : 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].
+    f1 : np.ndarray or float
+        Fraction of phase 1 [fraction].
+    bound: str
+        'upper' or 'lower' selection of upper of lower bound of effective medium.
+    Returns
+    -------
+    tuple
+        k, mu : np.ndarray.
+        k: effective bulk modulus [Pa], mu: effective shear modulus [Pa].
+    """
+    k1, mu1, k2, mu2, f1 = dim_check_vector((k1, mu1, k2, mu2, f1))
+    if bound.lower() not in ["lower", "upper"]:
+        raise ValueError(f'{__file__}: bound must be one of "lower" or "upper"')
+
+    idx_k = k1 == k2
+    idx_mu = mu1 == mu2
+    f2 = 1 - f1
+
+    if bound.lower() == "lower":
+        k_m = np.minimum(k1, k2)
+        mu_m = np.minimum(mu1, mu2)
+    else:
+        k_m = np.maximum(k1, k2)
+        mu_m = np.maximum(mu1, mu2)
+
+    k = np.zeros(k1.shape)
+    mu = np.zeros(k1.shape)
+
+    if np.any(idx_k):
+        k[idx_k] = k1[idx_k]
+    if np.any(~idx_k):
+        k[~idx_k] = k1[~idx_k] + f2[~idx_k] / (
+            (k2[~idx_k] - k1[~idx_k]) ** -1
+            + f1[~idx_k] * (k1[~idx_k] + 4 / 3 * mu_m[~idx_k]) ** -1
+        )
+    if np.any(idx_mu):
+        mu[idx_mu] = mu1[idx_mu]
+    if np.any(~idx_mu):
+        mu[~idx_mu] = mu1[~idx_mu] + f2[~idx_mu] / (
+            (mu2[~idx_mu] - mu1[~idx_mu]) ** -1
+            + f1[~idx_mu]
+            * (
+                mu1[~idx_mu]
+                + mu_m[~idx_mu]
+                / 6
+                * (9 * k_m[~idx_mu] + 8 * mu_m[~idx_mu])
+                / (k_m[~idx_mu] + 2 * mu_m[~idx_mu])
+            )
+            ** -1
+        )
+
+    return k, mu
+
+
+def multi_hashin_shtrikman(*coeffs, mode="average"):
+    """
+    Hashin-Shtrikman effective medium calculation for multi-mineral case.
+
+    Parameters
+    ----------
+    coeffs : np.ndarray
+        Triplets of vectors with k (bulk modulus [Pa]), mu (shear modulus [Pa]) and fraction for each mineral.
+    mode : str
+        'average', 'upper' or 'lower'.
+
+    Returns
+    -------
+    tuple
+        k_hs, mu_hs : np.ndarray.
+        k_hs, mu_hs - bulk modulus and shear modulus for effective medium [Pa].
+    """
+    if not len(coeffs) % 3 == 0:
+        raise ValueError(
+            "multi_hashin_shtrikman: inputs not vectors of k, mu and fraction for each mineral"
+        )
+
+    k_arr = np.array(coeffs[::3])
+    mu_arr = np.array(coeffs[1::3])
+    f = np.array(coeffs[2::3])
+
+    if not np.all(np.around(np.sum(f, axis=0), decimals=6) == 1.0):
+        raise ValueError("multi_hashin_shtrikman: all fractions do not add up to 1.0")
+
+    if mode.lower() not in ["average", "upper", "lower"]:
+        raise ValueError(
+            'multi_hashin_shtrikman: mode is not one of "average", "upper" or "lower"'
+        )
+
+    k_min = np.min(k_arr, axis=0)
+    k_max = np.max(k_arr, axis=0)
+    mu_min = np.min(mu_arr, axis=0)
+    mu_max = np.max(mu_arr, axis=0)
+
+    k_hs_upper = np.sum(f / (k_arr + 4 / 3 * mu_max), axis=0) ** -1 - 4 / 3 * mu_max
+    k_hs_lower = np.sum(f / (k_arr + 4 / 3 * mu_min), axis=0) ** -1 - 4 / 3 * mu_min
+
+    zeta_max = mu_max / 6 * (9 * k_max + 8 * mu_max) / (k_max + 2 * mu_max)
+    zeta_min = mu_min / 6 * (9 * k_min + 8 * mu_min) / (k_min + 2 * mu_min)
+
+    mu_hs_upper = np.sum(f / (mu_arr + zeta_max), axis=0) ** -1 - zeta_max
+    mu_hs_lower = np.sum(f / (mu_arr + zeta_min), axis=0) ** -1 - zeta_min
+
+    if mode == "lower":
+        return k_hs_lower, mu_hs_lower
+    if mode == "upper":
+        return k_hs_upper, mu_hs_upper
+    k_hs = 0.5 * (k_hs_upper + k_hs_lower)
+    mu_hs = 0.5 * (mu_hs_upper + mu_hs_lower)
+    return k_hs, mu_hs

rock_physics_open/equinor_utilities/std_functions/hertz_mindlin.py

@@ -0,0 +1,43 @@
+import numpy as np
+
+
+def hertz_mindlin(k, mu, phi_c, p, shear_red, coord=None):
+    """
+    Hertz-Mindlin Pressure-induced moduli increase at critical porosity.
+
+    Parameters
+    ----------
+    k : np.ndarray
+        Bulk modulus of grain mineral [Pa].
+    mu : np.ndarray
+        Shear modulus of grain mineral [Pa].
+    phi_c : np.ndarray
+        Critical porosity [fraction].
+    p : np.ndarray
+        Effective pressure = lithostatic pressure - hydrostatic pressure [Pa].
+    shear_red : float or np.ndarray
+        Reduced shear factor, if set to 1.0, calculation reduces to standard Hertz-Mindlin equation.
+    coord
+        coordination number, i.e. the number of grain contacts per grain. If not provided a porosity based
+        estimate is used.
+
+    Returns
+    -------
+    tuple
+        k_dry, mu_dry : np.ndarray.
+        k_dry:	Bulk modulus [Pa] at effective pressure p,
+        mu_dry:	Shear modulus [Pa] at effective pressure p.
+    """
+    n = 25.98805 * phi_c**2 - 43.7622 * phi_c + 21.6719 if coord is None else coord
+
+    poiss = (3 * k - 2 * mu) / (2 * (3 * k + mu))
+
+    a = ((3 * np.pi * (1 - poiss) * p) / (2 * n * (1 - phi_c) * mu)) ** (1 / 3)
+
+    s_n = (4 * a * mu) / (1 - poiss)
+    s_t = (8 * a * mu) / (2 - poiss)
+
+    k_dry = (n * (1 - phi_c) / (12 * np.pi)) * s_n
+    mu_dry = (n * (1 - phi_c) / (20 * np.pi)) * (s_n + 1.5 * s_t * shear_red)
+
+    return k_dry, mu_dry

rock_physics_open/equinor_utilities/std_functions/moduli_velocity.py

@@ -0,0 +1,51 @@
+def moduli(vp, vs, rhob):
+    """
+    Calculate isotropic moduli from velocity and density.
+
+    Parameters
+    ----------
+    vp : np.ndarray or float
+        Pressure wave velocity [m/s].
+    vs : np.ndarray or float
+        Shear wave velocity [m/s].
+    rhob : np.ndarray or float
+        Bulk density [kg/m^3].
+
+    Returns
+    -------
+    tuple
+        k, mu : (np.ndarray, np.ndarray) or (float, float).
+        k: bulk modulus [Pa], mu: shear modulus [Pa].
+    """
+    mu = vs**2 * rhob
+    k = vp**2 * rhob - 4 / 3 * mu
+
+    return k, mu
+
+
+def velocity(k, mu, rhob):
+    """
+    Calculate velocity, acoustic impedance and vp/vs ratio from elastic moduli and density.
+
+    Parameters
+    ----------
+    k : np.ndarray, float
+        Bulk modulus [Pa].
+    mu : np.ndarray, float
+        Shear modulus [Pa].
+    rhob : np.ndarray, float
+        Bulk density [kg/m^3].
+
+    Returns
+    -------
+    tuple
+        vp, vs, ai, vp_vs : np.ndarray.
+        vp: pressure wave velocity [m/s], vs: shear wave velocity [m/s], ai: acoustic impedance [m/s x kg/m^3],
+        vp_vs: velocity ratio [fraction].
+    """
+    vs = (mu / rhob) ** 0.5
+    vp = ((k + 4 / 3 * mu) / rhob) ** 0.5
+    ai = vp * rhob
+    vp_vs = vp / vs
+
+    return vp, vs, ai, vp_vs

rock_physics_open/equinor_utilities/std_functions/reflection_eq.py

@@ -0,0 +1,98 @@
+import numpy as np
+
+
+def _refl_models(vp, vs, rho, theta, k=2.0, mod="aki_richards"):
+    """Calculate reflect coeff.
+
+    Parameters
+    ----------
+    vp : np.ndarray
+        vp array.
+    vs : np.ndarray
+        vs array.
+    rho : np.ndarray
+        rho array.
+    theta : float, np.ndarray
+        Theta value.
+    k : float, optional
+        By default 2.0.
+    mod : str, optional
+        By default 'aki_richards'.
+
+    Returns
+    -------
+    np.ndarray
+        Reflect coeff.
+    """
+    theta = theta / 180 * np.pi
+    r_vp = (vp[1:] - vp[0:-1]) / (vp[0:-1] + vp[1:])
+    r_vs = (vs[1:] - vs[0:-1]) / (vs[0:-1] + vs[1:])
+    r_rho = (rho[1:] - rho[0:-1]) / (rho[0:-1] + rho[1:])
+    # Need to append one sample to make returned array of the same size - repeat the last value
+    r_vp = np.append(r_vp, r_vp[-1])
+    r_vs = np.append(r_vs, r_vs[-1])
+    r_rho = np.append(r_rho, r_rho[-1])
+
+    if mod == "aki_richards":
+        reflect_coeff = (
+            0.5 * (r_vp + r_rho)
+            + (0.5 * r_vp - 2 * k**-2 * (2 * r_vs + r_rho)) * np.sin(theta) ** 2
+            + 0.5 * r_vp * (np.tan(theta) ** 2 - np.sin(theta) ** 2)
+        )
+    else:
+        reflect_coeff = (
+            5 / 8 - 0.5 * k**-2 * np.sin(theta) ** 2 + 0.5 * np.tan(theta) ** 2
+        ) * r_vp - 4 * k**-2 * np.sin(theta) ** 2 * r_vs
+
+    return reflect_coeff
+
+
+def aki_richards(vp, vs, rho, theta, k=2.0):
+    """
+    Linearised Zoeppritz equation according to Aki and Richards.
+
+    Parameters
+    ----------
+    vp : np.ndarray
+        Pressure wave velocity [m/s].
+    vs : np.ndarray
+        Shear wave velocity [m/s].
+    rho : np.ndarray
+        Density [kg/m^3].
+    theta : np.ndarray
+        Angle of incident ray [radians].
+    k : float
+        Background vp/vs [unitless].
+
+    Returns
+    -------
+    refl_coeff : np.ndarray
+        Reflection coefficient [unitless].
+    """
+    return _refl_models(vp, vs, rho, theta, k, mod="aki_richards")
+
+
+def smith_gidlow(vp, vs, rho, theta, k=2.0):
+    """
+    Linearised Zoeppritz equation according to Smith and Gidlow.
+
+    Parameters
+    ----------
+    vp : np.ndarray
+        Pressure wave velocity [m/s].
+    vs : np.ndarray
+        Shear wave velocity [m/s].
+    rho : np.ndarray
+        Density [kg/m^3].
+    theta : np.ndarray
+        Angle of incident ray [radians].
+    k : float
+        Background vp/vs [unitless].
+
+    Returns
+    -------
+    refl_coeff : np.ndarray
+        Reflection coefficient [unitless].
+    """
+
+    return _refl_models(vp, vs, rho, theta, k, mod="smith_gidlow")

rock_physics_open/equinor_utilities/std_functions/rho.py

@@ -0,0 +1,59 @@
+from warnings import warn
+
+import numpy as np
+
+
+def rho_b(phi, rho_f, rho_mat):
+    """
+    Calculate bulk density from porosity, fluid density and matrix density.
+
+    Parameters
+    ----------
+    phi: np.ndarray
+        Porosity [fraction].
+    rho_f: np.ndarray
+        Fluid bulk density [kg/m^3].
+    rho_mat: np.ndarray
+        Matrix bulk density [kg/m^3].
+
+    Returns
+    -------
+    np.ndarray
+        rhob: bulk density [kg/m^3].
+    """
+    return phi * rho_f + (1 - phi) * rho_mat
+
+
+def rho_m(frac_cem, phi, rho_cem, rho_min):
+    """
+    Calculates matrix density as a combination of cement fraction and minerals
+    fracCem is defined as cement fraction relative to total volume.
+
+    Parameters
+    ----------
+    frac_cem : np.ndarray
+        Cement fraction [fraction].
+    phi : np.ndarray
+        Porosity [fraction].
+    rho_cem : np.ndarray
+         Cement density [kg/m^3].
+    rho_min : np.ndarray
+         Mineral density [kg/m^3].
+
+    Returns
+    -------
+    np.ndarray
+        rho_mat: matrix density [kg/m^3]
+    """
+    idx = np.logical_and(phi >= 0.0, phi < 1.0)
+    if np.sum(idx) != len(phi):
+        warn(
+            f"{__file__}: phi out of range in {len(phi) - np.sum(idx)} sample",
+        )
+
+    rho_mat = np.ones_like(phi) * np.nan
+    f_cem = frac_cem[idx] / (1 - phi[idx])
+
+    rho_mat[idx] = f_cem * rho_cem[idx] + (1 - f_cem) * rho_min[idx]
+
+    return rho_mat

rock_physics_open/equinor_utilities/std_functions/voigt_reuss_hill.py

@@ -0,0 +1,128 @@
+import numpy as np
+
+
+def voigt(k1, mu1, k2, mu2, f1):
+    """
+    Effective media calculation of a mixture of two phases using the Voigt bound.
+
+    Parameters
+    ----------
+    k1 : np.ndarray
+        Bulk modulus of phase 1 [Pa].
+    mu1 : 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].
+    f1 : np.ndarray
+        Fraction of phase 1 [fraction].
+
+    Returns
+    -------
+    tuple
+        k, mu : np.ndarray.
+        k: effective bulk modulus [Pa], mu: effective shear modulus [Pa]
+    """
+    f2 = 1 - f1
+    k_v = f1 * k1 + f2 * k2
+    mu_v = f1 * mu1 + f2 * mu2
+
+    return k_v, mu_v
+
+
+def voigt_reuss_hill(k1, mu1, k2, mu2, f1):
+    """
+    Effective media calculation of a mixture of two phases using the Voigt-Reuss-Hill average.
+
+    Parameters
+    ----------
+    k1 : np.ndarray
+        Bulk modulus of phase 1 [Pa].
+    mu1 : 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].
+    f1 : np.ndarray
+        Fraction of phase 1 [fraction].
+
+    Returns
+    -------
+    tuple
+        k, mu : np.ndarray
+        k: effective bulk modulus [Pa], mu: effective shear modulus [Pa]
+    """
+    k_v, mu_v = voigt(k1, mu1, k2, mu2, f1)
+    k_r, mu_r = reuss(k1, mu1, k2, mu2, f1)
+
+    k_vrh = (k_r + k_v) / 2
+    mu_vrh = (mu_r + mu_v) / 2
+
+    return k_vrh, mu_vrh
+
+
+def multi_voigt_reuss_hill(*varargin):
+    """
+    Voigt-Reuss-Hill with multiple mineral input.
+
+    Call function with [k, mu] = multi_voigt_reuss_hill(k1, mu1, f2, ....kn,
+    mun, fn). Fractions must add up to 1.0. All inputs are assumed to be
+    vectors with the same length.
+
+    Parameters
+    ----------
+    varargin : np.ndarray
+
+    Returns
+    -------
+    tuple
+        k, mu : np.ndarray
+        k: effective bulk modulus [Pa], mu: effective shear modulus [Pa].
+    """
+    k_min = np.array(varargin[::3])
+    mu_min = np.array(varargin[1::3])
+    f = np.array(varargin[2::3])
+
+    k_voigt = np.sum(k_min * f, axis=0)
+    mu_voigt = np.sum(mu_min * f, axis=0)
+
+    k_reuss = 1 / np.sum(f / k_min, axis=0)
+    mu_reuss = 1 / np.sum(f / mu_min, axis=0)
+
+    k = (k_voigt + k_reuss) / 2
+    mu = (mu_voigt + mu_reuss) / 2
+
+    return k, mu
+
+
+def reuss(k1, mu1, k2, mu2, f1):
+    """
+    Effective media calculation of a mixture of two phases using the Reuss bound.
+
+    Parameters
+    ----------
+    k1 : np.ndarray
+        Bulk modulus of phase 1 [Pa].
+    mu1 : 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].
+    f1 : np.ndarray
+        Fraction of phase 1 [fraction].
+
+    Returns
+    -------
+    tuple
+        k, mu : np.ndarray.
+        k: effective bulk modulus [Pa], mu: effective shear modulus [Pa].
+    """
+    f2 = 1 - f1
+
+    k_r = 1 / (f1 / k1 + f2 / k2)
+    mu_r = 1 / (f1 / mu1 + f2 / mu2)
+
+    return k_r, mu_r

rock_physics_open/equinor_utilities/std_functions/walton.py

@@ -0,0 +1,38 @@
+import numpy as np
+
+
+def walton_smooth(k, mu, phi, p_eff, coord=None):
+    """
+    Walton Smooth Pressure-induced moduli increase at critical porosity.
+
+    Parameters
+    ----------
+    k : np.ndarray
+        Bulk modulus of grain mineral [Pa].
+    mu : np.ndarray
+        Shear modulus of grain mineral [Pa].
+    phi : np.ndarray
+        Critical porosity [fraction].
+    p_eff : np.ndarray
+        Effective Pressure = (Lithostatic - Hydrostatic) pressure [Pa].
+    coord : float or np.ndarray
+        Coordination number, i.e. number of grain contract per grain. If not provided a porosity based estimate is
+        used [unitless].
+
+    Returns
+    -------
+    tuple
+        k_dry , mu_dry : np.ndarray.
+        k_dry	Bulk modulus at effective pressure p,
+        mu_dry	Shear modulus at effective pressure p.
+    """
+
+    n = 25.98805 * phi**2 - 43.7622 * phi + 21.6719 if coord is None else coord
+
+    pr_min = (3 * k - 2 * mu) / (2 * (3 * k + mu))
+    k_dry_num = n**2 * (1 - phi) ** 2 * mu**2 * p_eff  # Numerator in walton expression
+    k_dry_denom = 18 * np.pi**2 * (1 - pr_min) ** 2  # Denominator in Walton expression
+    k_dry = (k_dry_num / k_dry_denom) ** (1 / 3)  # Bulk modulus
+    mu_dry = 3 / 5 * k_dry
+
+    return k_dry, mu_dry

rock_physics_open/equinor_utilities/std_functions/wood_brie.py

@@ -0,0 +1,77 @@
+import numpy as np
+
+
+def brie(s_gas, k_gas, s_brine, k_brine, s_oil, k_oil, e):
+    """
+    Brie function for effective bulk modulus of a mix of fluids.
+
+    Parameters
+    ----------
+    s_gas : np.ndarray
+        Gas saturation [ratio].
+    k_gas : np.ndarray
+        Gas bulk modulus [Pa].
+    s_brine : np.ndarray
+        Brine saturation [ratio].
+    k_brine : np.ndarray
+        Brine bulk modulus [Pa].
+    s_oil : np.ndarray
+        Oil saturation [ratio].
+    k_oil : np.ndarray
+        Oil bulk modulus [Pa].
+    e : float or np.ndarray
+        Exponent in Brie function [unitless].
+
+    Returns
+    -------
+    np.ndarray
+        k: effective bulk modulus [Pa].
+    """
+
+    # Reuss average for fluids, catch zero fluid saturations
+    idx = s_brine + s_oil > 0
+    k_liquid = np.zeros(k_brine.shape)
+    k_liquid[idx] = (s_brine[idx] / k_brine[idx] + s_oil[idx] / k_oil[idx]) ** -1
+
+    return (k_liquid - k_gas) * (1 - s_gas) ** e + k_gas
+
+
+def wood(s1, k1, rho1, k2, rho2):
+    """
+    Wood effective fluid properties for a mix of two fluids.
+
+    Parameters
+    ----------
+    s1 : np.ndarray
+        Saturation of phase 1 [ratio].
+    k1 : np.ndarray
+        Bulk modulus of phase 1 [Pa].
+    rho1 : np.ndarray
+        Density of phase 1 [kg/m^3].
+    k2 : np.ndarray
+        Bulk modulus of phase 2 [Pa].
+    rho2 : np.ndarray
+        Density of phase 2 [kg/m^3].
+
+    Returns
+    -------
+    tuple
+        k, rho : np.ndarray.
+        k: effective fluid bulk modulus [Pa], rho: effective fluid density [kg/m^3].
+    """
+    s2 = 1 - s1
+
+    k = 1 / (s1 / k1 + s2 / k2)
+    rho = s1 * rho1 + s2 * rho2
+
+    return k, rho
+
+
+def multi_wood(fractions, bulk_moduli):
+    assert len(fractions) == len(bulk_moduli)
+    sum_fractions = sum(fractions)
+    ratio_sum = sum(
+        saturation / bulk_modulus
+        for (saturation, bulk_modulus) in zip(fractions, bulk_moduli)
+    )
+    return sum_fractions / ratio_sum