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

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

rock_physics_open/shale_models/sca.py

@@ -0,0 +1,90 @@
+import numpy as np
+
+from .pq import p_q_fcn
+
+
+def self_consistent_approximation_model(
+    k1, mu1, rho1, k2, mu2, rho2, frac1, asp1, asp2, tol
+):
+    """
+    SCA - Effective elastic moduli using Berryman's Self-Consistent
+    (Coherent Potential) Approximation method.
+
+    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].
+    frac1 : np.ndarray
+        Fraction of inclusions [fraction].
+    asp1 : np.ndarray
+        Aspect ratio of inclusions [ratio].
+    asp2 : np.ndarray
+        Aspect ratio of inclusions [ratio].
+    tol: float
+        Desired accuracy in the SCA iterations.
+
+    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
+    --------
+    Based on function by T. Mukerji, SRB, Stanford University, 1994.
+    Ported to Python by Harald Flesche, Equinor 2015.
+    """
+
+    # Calculate fn and theta - independent of iteration
+    f1 = frac1
+    f2 = 1 - frac1
+
+    k_sc = f1 * k1 + f2 * k2
+    mu_sc = f1 * mu1 + f2 * mu2
+    rhob = f1 * rho1 + f2 * rho2
+
+    idx = np.logical_and(np.not_equal(f1, 0.0), np.not_equal(f1, 1.0))
+    n_iter = 0
+    k_new = np.zeros(np.sum(idx))
+    delta = np.absolute(k_sc[idx] - k_new)
+    # Express tolerance in terms of k1
+    tol = tol * k1[idx]
+
+    while np.any(delta > tol) and (n_iter < 3000):
+        p1, q1 = p_q_fcn(k_sc[idx], mu_sc[idx], k1[idx], mu1[idx], asp1[idx])
+        p2, q2 = p_q_fcn(k_sc[idx], mu_sc[idx], k2[idx], mu2[idx], asp2[idx])
+
+        k_new = (f1[idx] * k1[idx] * p1 + f2[idx] * k2[idx] * p2) / (
+            f1[idx] * p1 + f2[idx] * p2
+        )
+        mu_new = (f1[idx] * mu1[idx] * q1 + f2[idx] * mu2[idx] * q2) / (
+            f1[idx] * q1 + f2[idx] * q2
+        )
+
+        delta = np.absolute(k_sc[idx] - k_new)
+        k_sc[idx] = k_new
+        mu_sc[idx] = mu_new
+
+        n_iter = n_iter + 1
+
+    # If all inclusions or all matrix - substitute with inclusion mineral properties
+    idx = frac1 == 1.0
+    if np.any(idx):
+        k_sc[idx] = k1[idx]
+        mu_sc[idx] = mu1[idx]
+    idx = frac1 == 0.0
+    if np.any(idx):
+        k_sc[idx] = k2[idx]
+        mu_sc[idx] = mu2[idx]
+
+    return k_sc, mu_sc, rhob

rock_physics_open/shale_models/shale4_mineral.py

@@ -0,0 +1,147 @@
+import numpy as np
+
+from rock_physics_open.equinor_utilities import std_functions
+from rock_physics_open.equinor_utilities.gen_utilities import dim_check_vector
+
+from .dem import dem_model
+from .multi_sca import multi_sca
+
+
+def shale_model_4_mineral_dem(
+    k1,
+    mu1,
+    rho1,
+    k2,
+    mu2,
+    rho2,
+    k3,
+    mu3,
+    rho3,
+    k4,
+    mu4,
+    rho4,
+    k_fl,
+    rho_fl,
+    phi,
+    f1,
+    f2,
+    f3,
+    rhob_inp,
+    asp1,
+    asp2,
+    asp3,
+    asp4,
+    asp,
+    mod_type="SCA",
+):
+    """
+    Simple shale model with mixture of matrix minerals in self-consistent approximation
+    or Voigt-Reuss-Hill average. In the latter case the aspect ratios are ignored.
+    Fluid filled porosity is included through a DEM inclusion model.
+
+    All k, mu inputs have unit [Pa], all rho inputs have unit [kg/m^3], phi and all f and asp have unit [fraction].
+
+    Parameters
+    ----------
+    k1, mu1, rho1 : np.ndarray
+        Mineral 1 properties [Quartz and feldspar].
+    k2, mu2, rho2 : np.ndarray
+        Mineral 2 properties [Kerogen].
+    k3, mu3, rho3 : np.ndarray
+        Mineral 3 properties [Clay].
+    k4, mu4, rho4 : np.ndarray
+        Mineral 4 properties [Carbonates].
+    k_fl, rho_fl : np.ndarray
+        Fluid properties.
+    phi : np.ndarray
+        Phi parmeter.
+    f1 : np.ndarray
+        Fraction of mineral 1.
+    f2 : np.ndarray
+        Fraction of mineral 2.
+    f3 : np.ndarray
+        Fraction of mineral 3.
+    rhob_inp : np.ndarray
+        Observed density [kg/m^3].
+    asp1 : np.ndarray
+        Aspect ratio mineral 1 inclusions.
+    asp2 : np.ndarray
+        Aspect ratio mineral 2 inclusions.
+    asp3 : np.ndarray
+        Aspect ratio mineral 3 inclusions.
+    asp4 : np.ndarray
+        Aspect ratio mineral 4 inclusions.
+    asp : np.ndarray
+        Porosity aspect ratio.
+    mod_type : str
+        One of 'SCA' or 'VRH'.
+
+    Returns
+    -------
+    tuple
+        k, mu, rhob, vp, vs, rho_factor : (np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray).
+        k - effektive bulk modulus [Pa], mu - effective shear modulus [Pa], rhob - effective density [kg/m^3],
+        vp - p-wave velocity [m/s], vs - shear wave velocity [m/s], rho_factor - ratio between modelled and observed
+        density [ratio].
+    """
+
+    #   tol: DEM model calculation tolerance <= Set as a hardcoded value, not
+    #   found to influence the results
+    tol = 1.0e-6
+
+    # Calculate effective mineral properties
+
+    # Too harsh to raise exceptions - do a quiet normalisation instead,
+    tot = f1 + f2 + f3
+    idx = tot > 1.0
+    f1[idx] /= tot[idx]
+    f2[idx] /= tot[idx]
+    f3[idx] /= tot[idx]
+    f4 = 1.0 - f1 - f2 - f3
+
+    if mod_type == "SCA":
+        k_mat, mu_mat, rho_mat = multi_sca(
+            k1,
+            mu1,
+            rho1,
+            f1,
+            asp1,
+            k2,
+            mu2,
+            rho2,
+            f2,
+            asp2,
+            k3,
+            mu3,
+            rho3,
+            f3,
+            asp3,
+            k4,
+            mu4,
+            rho4,
+            f4,
+            asp4,
+            tol=tol,
+        )
+    elif mod_type == "VRH":
+        k_mat, mu_mat = std_functions.multi_voigt_reuss_hill(
+            k1, mu1, f1, k2, mu2, f2, k3, mu3, f3, k4, mu4, f4
+        )
+        rho_mat = f1 * rho1 + f2 * rho2 + f3 * rho3 + f4 * rho4
+    else:
+        raise ValueError(
+            f'{__file__}: unknown type: {mod_type}, should be one of "SCA", "VRH"'
+        )
+
+    k_mat, mu_mat, rho_mat, k_fl, rho_fl, phi, asp = dim_check_vector(
+        (k_mat, mu_mat, rho_mat, k_fl, rho_fl, phi, asp)
+    )
+    k, mu, rhob = dem_model(
+        k_mat, mu_mat, rho_mat, k_fl, np.zeros(len(k_fl)), rho_fl, phi, asp, tol
+    )
+
+    rho_factor = rhob / rhob_inp
+
+    vp, vs = std_functions.velocity(k, mu, rhob)[0:2]
+
+    return k, mu, rhob, vp, vs, rho_factor

rock_physics_open/shale_models/shale4_mineral_dem_overlay.py

@@ -0,0 +1,92 @@
+import numpy as np
+
+from rock_physics_open.equinor_utilities import std_functions
+from rock_physics_open.equinor_utilities.gen_utilities import dim_check_vector
+
+from .dem import dem_model
+
+
+def shale_4_min_dem_overlay(
+    k1,
+    mu1,
+    rho1,
+    k2,
+    mu2,
+    rho2,
+    k3,
+    mu3,
+    rho3,
+    k4,
+    mu4,
+    rho4,
+    k_fl,
+    rho_fl,
+    phi,
+    f1,
+    f2,
+    prop_clay,
+    asp,
+):
+    """
+    Simple shale model with mixture of matrix minerals in Voigt-Reuss-Hill
+    and DEM inclusion model for fluid filled porosity. The model is aimed at
+    overlays in cross-plots where two input fractions are given, and the two
+    remaining are given as a proportion.
+    Fraction of carbonate and clay is implicit 1 - f1 - f2. f1 and f2 can be set to zero
+    All k, mu values in [Pa], rho in [kg/m^3], f, phi, prop_clay, asp in [fraction].
+
+    Parameters
+    ----------
+    k1, mu1, rho1 : np.ndarray
+        Mineral 1 properties [Quartz and feldspar].
+    f1 : np.ndarray
+        Fraction of mineral 1.
+    k2, mu2, rho2 : np.ndarray
+        Mineral 2 properties [Kerogen].
+    f2 : np.ndarray
+        Fraction of mineral 2.
+    k3, mu3, rho3 : np.ndarray
+        Mineral 3 properties [Clay].
+    k4, mu4, rho4 : np.ndarray
+        Mineral 4 properties [Carbonates].
+    prop_clay : float
+        Range 0 - 1 of the fraction that is clay and carbonate.
+    k_fl, rho_fl : np.ndarray
+        Fluid properties.
+    phi : np.ndarray
+        Porosity.
+    asp:
+        Porosity aspect ratio.
+
+    Returns
+    -------
+    tuple
+        k, mu, rhob : (np.ndarray, np.ndarray, np.ndarray).
+        k - effektive bulk modulus [Pa], mu - effective shear modulus [Pa], rhob - effective density [kg/m^3].
+    """
+
+    #   tol: DEM model calculation tolerance <= Set as a hardcoded value, not
+    #   found to influence the results
+    tol = 1e-6
+
+    # Calculate effective mineral properties
+    if np.any((f1 + f2) > 1.0):
+        raise ValueError(f"{__file__}: fixed mineral fractions exceed 1.0")
+    if np.any(np.logical_or(f1 < 0, f2 < 0)):
+        raise ValueError(f"{__file__}: negative mineral fractions")
+
+    f3 = prop_clay * (1.0 - f1 - f2)
+    f4 = (1.0 - prop_clay) * (1.0 - f1 - f2)
+    k_mat, mu_mat = std_functions.multi_voigt_reuss_hill(
+        k1, mu1, f1, k2, mu2, f2, k3, mu3, f3, k4, mu4, f4
+    )
+    rho_mat = rho1 * f1 + rho2 * f2 + rho3 * f3 + rho4 * f4
+
+    k_mat, mu_mat, rho_mat, k_fl, rho_fl, phi, asp = dim_check_vector(
+        (k_mat, mu_mat, rho_mat, k_fl, rho_fl, phi, asp)
+    )
+    k, mu, rhob = dem_model(
+        k_mat, mu_mat, rho_mat, k_fl, np.zeros(len(k_fl)), rho_fl, phi, asp, tol
+    )
+
+    return k, mu, rhob

rock_physics_open/span_wagner/__init__.py

@@ -0,0 +1,5 @@
+from .co2_properties import co2_properties
+
+__all__ = [
+    "co2_properties",
+]