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

rock_physics_open/equinor_utilities/std_functions/hertz_mindlin.py

@@ -0,0 +1,51 @@
+import numpy as np
+import numpy.typing as npt
+
+
+def hertz_mindlin(
+    k: npt.NDArray[np.float64],
+    mu: npt.NDArray[np.float64],
+    phi_c: npt.NDArray[np.float64],
+    p: npt.NDArray[np.float64],
+    shear_red: npt.NDArray[np.float64] | float,
+    coord: npt.NDArray[np.float64] | None = None,
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    """
+    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,67 @@
+from typing import TypeVar, cast
+
+import numpy as np
+import numpy.typing as npt
+
+_T = TypeVar("_T", npt.NDArray[np.float64], float)
+
+
+def moduli(
+    vp: _T,
+    vs: _T,
+    rhob: _T,
+) -> tuple[_T, _T]:
+    """
+    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: _T,
+    mu: _T,
+    rhob: _T,
+) -> tuple[_T, _T, _T, _T]:
+    """
+    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 = cast(_T, (mu / rhob) ** 0.5)
+    vp = cast(_T, ((k + 4 / 3 * mu) / rhob) ** 0.5)
+    ai = cast(_T, vp * rhob)
+    vp_vs = cast(_T, vp / vs)
+
+    return vp, vs, ai, vp_vs

rock_physics_open/equinor_utilities/std_functions/reflection_eq.py

@@ -0,0 +1,120 @@
+from typing import Literal
+
+import numpy as np
+import numpy.typing as npt
+
+
+def _refl_models(
+    vp: npt.NDArray[np.float64],
+    vs: npt.NDArray[np.float64],
+    rho: npt.NDArray[np.float64],
+    theta: npt.NDArray[np.float64],
+    k: npt.NDArray[np.float64] | float = 2.0,
+    mod: Literal["aki_richards", "smith_gidlow"] = "aki_richards",
+) -> npt.NDArray[np.float64]:
+    """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, np.ndarray, 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: npt.NDArray[np.float64],
+    vs: npt.NDArray[np.float64],
+    rho: npt.NDArray[np.float64],
+    theta: npt.NDArray[np.float64],
+    k: npt.NDArray[np.float64] | float = 2.0,
+) -> npt.NDArray[np.float64]:
+    """
+    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, np.ndarray
+        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: npt.NDArray[np.float64],
+    vs: npt.NDArray[np.float64],
+    rho: npt.NDArray[np.float64],
+    theta: npt.NDArray[np.float64],
+    k: npt.NDArray[np.float64] | float = 2.0,
+) -> npt.NDArray[np.float64]:
+    """
+    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, np.ndarray
+        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,69 @@
+from warnings import warn
+
+import numpy as np
+import numpy.typing as npt
+
+
+def rho_b(
+    phi: npt.NDArray[np.float64],
+    rho_f: npt.NDArray[np.float64],
+    rho_mat: npt.NDArray[np.float64],
+) -> npt.NDArray[np.float64]:
+    """
+    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: npt.NDArray[np.float64],
+    phi: npt.NDArray[np.float64],
+    rho_cem: npt.NDArray[np.float64],
+    rho_min: npt.NDArray[np.float64],
+) -> npt.NDArray[np.float64]:
+    """
+    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,149 @@
+import numpy as np
+import numpy.typing as npt
+
+
+def voigt(
+    k1: npt.NDArray[np.float64],
+    mu1: npt.NDArray[np.float64],
+    k2: npt.NDArray[np.float64],
+    mu2: npt.NDArray[np.float64],
+    f1: npt.NDArray[np.float64],
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    """
+    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: npt.NDArray[np.float64],
+    mu1: npt.NDArray[np.float64],
+    k2: npt.NDArray[np.float64],
+    mu2: npt.NDArray[np.float64],
+    f1: npt.NDArray[np.float64],
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    """
+    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: npt.NDArray[np.float64],
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    """
+    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: npt.NDArray[np.float64],
+    mu1: npt.NDArray[np.float64],
+    k2: npt.NDArray[np.float64],
+    mu2: npt.NDArray[np.float64],
+    f1: npt.NDArray[np.float64],
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    """
+    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,45 @@
+import numpy as np
+import numpy.typing as npt
+
+
+def walton_smooth(
+    k: npt.NDArray[np.float64],
+    mu: npt.NDArray[np.float64],
+    phi: npt.NDArray[np.float64],
+    p_eff: npt.NDArray[np.float64],
+    coord: float | npt.NDArray[np.float64] | None = None,
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    """
+    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,94 @@
+from collections.abc import Sequence
+
+import numpy as np
+import numpy.typing as npt
+
+
+def brie(
+    s_gas: npt.NDArray[np.float64],
+    k_gas: npt.NDArray[np.float64],
+    s_brine: npt.NDArray[np.float64],
+    k_brine: npt.NDArray[np.float64],
+    s_oil: npt.NDArray[np.float64],
+    k_oil: npt.NDArray[np.float64],
+    e: float | npt.NDArray[np.float64],
+) -> npt.NDArray[np.float64]:
+    """
+    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: npt.NDArray[np.float64],
+    k1: npt.NDArray[np.float64],
+    rho1: npt.NDArray[np.float64],
+    k2: npt.NDArray[np.float64],
+    rho2: npt.NDArray[np.float64],
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    """
+    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: Sequence[float], bulk_moduli: Sequence[float]) -> float:
+    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

rock_physics_open/equinor_utilities/various_utilities/__init__.py

@@ -0,0 +1,24 @@
+from .display_result_statistics import disp_result_stats
+from .gassmann_dry_mod import gassmann_dry_model
+from .gassmann_mod import gassmann_model
+from .gassmann_sub_mod import gassmann_sub_model
+from .hs_average import hs_average
+from .pressure import pressure
+from .reflectivity import reflectivity
+from .timeshift import time_shift_pp, time_shift_ps
+from .vp_vs_rho_set_statistics import vp_vs_rho_stats
+from .vrh_3_min import min_3_voigt_reuss_hill
+
+__all__ = [
+    "disp_result_stats",
+    "gassmann_dry_model",
+    "gassmann_model",
+    "gassmann_sub_model",
+    "hs_average",
+    "pressure",
+    "reflectivity",
+    "time_shift_pp",
+    "time_shift_ps",
+    "vp_vs_rho_stats",
+    "min_3_voigt_reuss_hill",
+]