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

rock_physics_open/t_matrix_models/t_matrix_vector/array_functions.py

@@ -0,0 +1,75 @@
+import numpy as np
+
+
+def array_inverse(a: np.ndarray) -> np.ndarray:
+    """Inverse of higher order array (3 dim) using linalg inv routine.
+
+    Parameters
+    ----------
+    a : np.ndarray
+        An nxmxm numpy array.
+
+    Returns
+    -------
+    np.ndarray
+        An nxmxm array where [i, :, :] contains the inverse of A[i, :, :].
+
+    Raises
+    ------
+    ValueError
+        If input of wrong shape.
+    """
+    if not (a.ndim == 3 and a.shape[1] == a.shape[2]):
+        raise ValueError(f"{__name__}: mismatch in inputs variables dimension/shape")
+
+    return np.array([np.linalg.inv(x) for x in a])
+
+
+def array_matrix_mult(*args: np.ndarray) -> np.ndarray:
+    """3-dim arrays are matrix multiplied args[j][i, :, :] @ args[j+1][i, :, :].
+    Input args should all be numpy arrays of shape nxmxm.
+
+    Returns
+    -------
+    np.ndarray
+        An nxmxm array with n args[i] @ args[i+1] @ ....
+
+    Raises
+    ------
+    ValueError
+        If input is not a list or tuple.
+    ValueError
+        If mismatch in input shape/dimension.
+    ValueError
+        If mismatch in input shape/dimension.
+    """
+    if not isinstance(args, (list, tuple)):
+        raise ValueError(f"{__name__}: inputs must be list or tuple")
+    if not len(args) > 1:
+        return args[0]
+
+    arg_shape = []
+    arg_type = []
+    for i in range(len(args)):
+        if not (
+            isinstance(args[i], np.ndarray)
+            and args[i].ndim == 3
+            and args[i].shape[1] == args[i].shape[2]
+        ):
+            raise ValueError(
+                f"{__name__}: mismatch in inputs variables dimension/shape"
+            )
+        arg_shape.append(args[i].shape)
+        arg_type.append(args[i].dtype)
+    arg_shape = np.array(arg_shape)
+    arg_type = np.array(arg_type)
+    if not np.all(arg_shape[:, 0] == arg_shape[0, 0]):
+        raise ValueError(f"{__name__}: mismatch in inputs variables dimension/shape")
+    out_type = "complex128" if np.any(arg_type == np.dtype("complex128")) else "float64"
+
+    x = args[0]
+
+    for i in range(1, len(args)):
+        x = np.einsum("...ij,...jk->...ik", x, args[i], dtype=out_type)
+
+    return x

rock_physics_open/t_matrix_models/t_matrix_vector/calc_c_eff.py

@@ -0,0 +1,163 @@
+import numpy as np
+
+from .array_functions import array_inverse, array_matrix_mult
+from .calc_t import calc_t_vec
+from .calc_theta import calc_theta_vec
+from .calc_z import calc_z_vec
+
+
+def calc_c_eff_vec(c0, c1, gd, t, t_bar, v, frac_aniso):
+    """
+    Equation  4 (page 222) Jakobsen et al. 2003 (The acoustic signature of fluid flow in complex
+    porous media).
+    Returns the effective stiffness tensor C* (nx6x6 matrix) calculated from the t-matrices t(r) (Eq. 1).
+
+    Parameters
+    ----------
+    c0 : np.ndarray
+        Stiffness tensor of the host of the inclusion (nx6x6 matrix).
+    c1 : np.ndarray
+        Sum of the concentration and t-matrices (nx6x6 matrix).
+    gd : np.ndarray
+        Correlation function (nx6x6 matrix).
+    t : np.ndarray
+        t-matrices of the different inclusions (nx6x6xr matrix) (anisotropic).
+    t_bar: np.ndarray
+        t-matrices of the different inclusions (nx6x6xr matrix) (isotropic).
+    v : np.ndarray
+        Concentration of the inclusions (nxr vector).
+    frac_aniso: np.ndarray
+        Fraction of anisotropic.
+
+    Returns
+    -------
+    tuple
+        c_eff: np.ndarray.
+        c_eff: effective stiffness tensor C.
+    """
+    if not (
+        c0.ndim == 3
+        and c1.ndim == 3
+        and gd.ndim == 3
+        and t.ndim == 4
+        and t_bar.ndim == 4
+        and v.ndim == 2
+        and np.all(
+            np.array(
+                [
+                    c0.shape[1:2],
+                    c1.shape[1:2],
+                    gd.shape[1:2],
+                    t.shape[1:2],
+                    t_bar.shape[1:2],
+                ]
+            )
+            == c0.shape[1]
+        )
+        and np.all(
+            np.array(
+                [
+                    c0.shape[0],
+                    c1.shape[0],
+                    gd.shape[0],
+                    t.shape[0],
+                    t_bar.shape[0],
+                    v.shape[0],
+                ]
+            )
+            == c0.shape[0]
+        )
+    ):
+        raise ValueError("calc_c_eff_vec: inconsistencies in input shapes")
+
+    log_length = c0.shape[0]
+    alpha_len = v.shape[1]
+    v = v.reshape((log_length, 1, 1, alpha_len))
+    i4 = np.eye(6)
+
+    c1 = c1 + np.sum(frac_aniso * v * t + (1.0 - frac_aniso) * v * t_bar, axis=3)
+
+    return c0 + array_matrix_mult(c1, array_inverse(i4 + array_matrix_mult(gd, c1)))
+
+
+def calc_c_eff_visco_vec(
+    vs,
+    k_r,
+    eta_f,
+    v,
+    gamma,
+    tau,
+    kd_uuvv,
+    kappa,
+    kappa_f,
+    c0,
+    s0,
+    c1,
+    td,
+    td_bar,
+    x,
+    x_bar,
+    gd,
+    frequency,
+    frac_ani,
+):
+    """
+    Returns the effective stiffness tensor C* for a visco-elastic system (6x6xnumber of frequencies).
+
+    Parameters
+    ----------
+    vs : np.ndarray
+        The velocity used to calculate the wave number.
+    k_r : np.ndarray
+        Klinkenberg permability.
+    eta_f : np.ndarray
+        Viscosity (P).
+    v : np.ndarray
+        Concentration of the inclusions which are connected with respect to fluid flow.
+    gamma : np.ndarray
+        Gamma factor for each inclusion (1x(number of connected inclusions) vector).
+    tau : float or np.ndarray
+        Relaxation time constant.
+    kd_uuvv : np.ndarray
+        Kd_uuvv for each connected inclusion (1x(number of connected inclusions) vector.
+    kappa : np.ndarray
+        Bulk modulus of host material.
+    kappa_f : np.ndarray
+        Bulk modulus of the fluid.
+    c0 : np.ndarray
+        The stiffness tensor of host material (6x6 matrix).
+    s0 : np.ndarray
+        Inverse of C0.
+    c1 : np.ndarray
+        First order correction matrix(6x6 matrix). If there are isolated inclusions, C1 is sum of concentration and
+        t-matrices of the isolated part of the porosity.
+    td : np.ndarray
+        t-matrix tensors.
+    td_bar : np.ndarray
+        t-matrices of the connected inclusions(6x6x(numbers of inclusions) matrix).
+    x : np.ndarray
+        X-tensor.
+    x_bar : np.ndarray
+        X-tensor of the connected inclusions (6x6x(numbers of inclusions) matrix).
+    gd : np.ndarray
+        Correlation function (6x6 matrix).
+    frequency : float
+        Frequency under consideration.
+    frac_ani : np.ndarray
+        Fraction of anisotropic inclusions.
+
+    Returns
+    -------
+    np.ndarray
+        Effective stiffness tensor.
+    """
+    dr = k_r / eta_f
+
+    omega = 2 * np.pi * frequency
+    k = omega / vs
+    theta = calc_theta_vec(v, omega, gamma, tau, kd_uuvv, dr, k, kappa, kappa_f)
+    z, z_bar = calc_z_vec(s0, td, td_bar, omega, gamma, v * frac_ani, tau)
+    t = calc_t_vec(td, theta, x, z, omega, gamma, tau, kappa_f)
+    t_bar = calc_t_vec(td_bar, theta, x_bar, z_bar, omega, gamma, tau, kappa_f)
+
+    return calc_c_eff_vec(c0, c1, gd, t, t_bar, v, frac_ani)

rock_physics_open/t_matrix_models/t_matrix_vector/calc_isolated.py

@@ -0,0 +1,95 @@
+import numpy as np
+
+from .array_functions import array_inverse, array_matrix_mult
+from .g_tensor import g_tensor_vec
+from .iso_av import iso_av_vec
+
+
+def calc_isolated_part_vec(c0, s_0, kappa_f, alpha, v, case_iso, frac_ani):
+    """
+    Returns the first order correction tensor: sum of the concentrations and
+    t-matrices of the isolated porosity (6x6 matrix).
+    case_iso = 0 : 100% isotropic,
+    case_iso = 1 : mixed isotropic and anisotropic porosity,
+    case_iso = 2 : 100% anisotropic porosity.
+
+    Parameters
+    ----------
+    c0 : np.ndarray
+        Stiffness tensor of the host material (6x6xn).
+    s_0 :  np.ndarray
+        Inverse of stiffness tensor.
+    kappa_f : np.ndarray
+        Bulk modulus of the fluid (n length vector).
+    alpha : np.ndarray
+        Aspect ratios of all the inclusions (1xnumber of inclusions) vector).
+    v : np.ndarray
+        Concentration of all the inclusions (1xnumber of inclusions) vector).
+    case_iso : int
+        Control parameter.
+    frac_ani : float
+        Fraction of anisotropic inclusions.
+
+    Returns
+    -------
+    np.ndarray
+        c1: correction tensor.
+
+    Notes
+    -----
+    29.10.2020 HFLE: Simplification: alpha for isotropic and anisotropic part are the same. This has been default in
+    Remy's code, but this function had assumption that half of the inclusions could have different aspect ratio
+    13.11.2020 HFLE: In case of zero porosity, this routine returns a zero tensor, whereas the correct should have
+    been to return the host material tensor - corrected.
+
+    """
+    if not (c0.ndim == 3 and s_0.ndim == 3):
+        raise ValueError(f"{__name__}: mismatch in inputs variables dimension/shape")
+
+    log_length = c0.shape[0]
+    if v.ndim != 2:
+        v = np.tile(v.reshape(1, v.shape[0]), (log_length, 1))
+
+    if alpha.ndim == 1 and alpha.shape[0] != c0.shape[0]:
+        alpha = np.tile(alpha.reshape(1, alpha.shape[0]), (log_length, 1))
+    alpha_len = alpha.shape[1]
+
+    cn = np.zeros_like(c0)
+    cn[:, 0:3, 0:3] = np.tile(kappa_f.reshape((log_length, 1, 1)), (1, 3, 3))
+    cn_d = cn - c0
+    i4 = np.tile(np.eye(6).reshape(1, 6, 6), (log_length, 1, 1))
+    c1 = np.zeros_like(c0)
+
+    # Will need G tensor for each alpha
+    g_arr = []
+    for i in range(alpha_len):
+        g_arr.append(g_tensor_vec(c0, s_0, alpha[:, i]))
+
+    if case_iso != 1:
+        # if there is only isotropic or anisotropic inclusions
+        for j in range(alpha_len):
+            t = array_matrix_mult(
+                cn_d, array_inverse(i4 - array_matrix_mult(g_arr[j], cn_d))
+            )
+            if case_iso != 2:
+                t = iso_av_vec(t)
+            c1 = c1 + v[:, j].reshape(log_length, 1, 1) * t
+    else:
+        # Isotropic and anisotropic part
+        for j in range(alpha_len):
+            t = array_matrix_mult(
+                cn_d, array_inverse(i4 - array_matrix_mult(g_arr[j], cn_d))
+            )
+            t = iso_av_vec(t)
+            c1 = c1 + ((1 - frac_ani) * v[:, j]).reshape(log_length, 1, 1) * t
+        for j in range(alpha_len):
+            t = array_matrix_mult(
+                cn_d, array_inverse(i4 - array_matrix_mult(g_arr[j], cn_d))
+            )
+            c1 = c1 + (frac_ani * v[:, j]).reshape(log_length, 1, 1) * t
+
+    idx_zero = np.sum(v, axis=1) == 0.0
+    if np.any(idx_zero):
+        c1[idx_zero] = c0[idx_zero]
+
+    return c1

rock_physics_open/t_matrix_models/t_matrix_vector/calc_kd.py

@@ -0,0 +1,40 @@
+import numpy as np
+
+from .array_functions import array_inverse, array_matrix_mult
+from .g_tensor import g_tensor_vec
+
+
+def calc_kd_vec(c0, i4, s_0, alpha):
+    """
+    kd is a (nx6x6x(number of alphas)) matrix.
+
+    Parameters
+    ----------
+    c0 : np.ndarray
+        Stiffness tensor of the host material (nx6x6 matrix).
+    i4 : np.ndarray
+        Array of 6x6 identity matrices.
+    s_0:  np.ndarray
+        Inverse of stiffness tensor.
+    alpha : np.ndarray
+        Vector of aspect ratios (1x (number of aspect ratios) vector) or nx(number of (number of alphas)).
+
+    Returns
+    -------
+    np.ndarray
+        kd: stiffness tensor.
+    """
+    log_length = c0.shape[0]
+
+    if alpha.ndim == 1 and alpha.shape[0] != c0.shape[0]:
+        alpha = np.tile(alpha.reshape(1, alpha.shape[0]), (log_length, 1))
+    L = alpha.shape[1]
+    kd = np.zeros((log_length, 6, 6, L))
+
+    for nc in range(L):
+        g = g_tensor_vec(c0, s_0, alpha[:, nc])
+        kd[:, :, :, nc] = array_matrix_mult(
+            array_inverse(i4 + array_matrix_mult(g, c0)), s_0
+        )
+
+    return kd

rock_physics_open/t_matrix_models/t_matrix_vector/calc_kd_eff.py

@@ -0,0 +1,116 @@
+import numpy as np
+
+from .array_functions import array_inverse, array_matrix_mult
+from .calc_isolated import calc_isolated_part_vec
+from .g_tensor import g_tensor_vec
+
+
+def calc_kd_eff_vec(
+    c0, s_0, k_fl, alpha_con, alpha_iso, v_con, v_iso, gd, ctrl, frac_ani
+):
+    """Returns the effective dry K-tensor (6x6x(numbers of inclusions) matrix.
+    If there is no connected or no isolated pores, the function returns a NaN for
+    the case which is not considered. E.g. if only isolated pores, the kd_eff_connected = NaN.
+
+    Note: When isolated pores, the pores are considered as filled when
+    calculating the dry effective K-tensor.
+
+    Parameters
+    ----------
+    c0 : np.ndarray
+        Stiffness tensor of the host material (nx6x6 matrix).
+    s_0 : np.ndarray
+        Inverse of the stiffness tensor.
+    k_fl : np.ndarray
+        Bulk modulus of the fluid (n length vector).
+    alpha_con : np.ndarray
+        Aspect ratio of connected inclusions.
+    alpha_iso : np.ndarray
+        Aspect ratio of isolated inclusions.
+    v_con : np.ndarray
+        Concentration of connected pores.
+    v_iso : np.ndarray
+        Concentration of isolated pores.
+    gd : np.ndarray
+        Correlation function (nx6x6 matrix).
+    ctrl : int
+        0 :only isolated pores, 1 :both isolated and connected pores, 2 :only connected pores.
+    frac_ani : float
+        Fraction of anisotropic inclusions.
+
+    Returns
+    -------
+    tuple
+         kd_eff_isolated, kd_eff_connected: (np.ndarray, np.ndarray).
+
+    Notes
+    -----
+    Equations used can be found in:
+    Agersborg (2007), phd thesis:
+    https://bora.uib.no/handle/1956/2422
+
+    09.03.2012
+    Remy Agersborg
+    email: remy@agersborg.com
+
+    Translated to Python and vectorised by Harald Flesche, hfle@equinor.com 2020.
+    """
+    log_len = c0.shape[0]
+    c1dry = np.zeros((log_len, 6, 6))
+    c2dry = np.zeros((log_len, 6, 6))
+
+    kd_eff_isolated = None
+    kd_eff_connected = None
+
+    c1_isolated = None
+    if ctrl != 2:
+        c1_isolated = calc_isolated_part_vec(
+            c0, s_0, k_fl, alpha_iso, v_iso, ctrl, frac_ani
+        )
+        c1dry = c1dry + c1_isolated
+        if alpha_iso.ndim == 1 and alpha_iso.shape[0] != c0.shape[0]:
+            alpha_iso = np.tile(alpha_iso.reshape(1, alpha_iso.shape[0]), (log_len, 1))
+        c2dry = c2dry + array_matrix_mult(c1_isolated, gd, c1_isolated)
+    if ctrl != 0:
+        c1_connected = calc_isolated_part_vec(
+            c0, s_0, np.zeros_like(k_fl), alpha_con, v_con, ctrl, frac_ani
+        )
+        c1dry = c1dry + c1_connected
+        if alpha_con.ndim == 1 and alpha_con.shape[0] != c0.shape[0]:
+            alpha_con = np.tile(alpha_con.reshape(1, alpha_con.shape[0]), (log_len, 1))
+        c2dry = c2dry + array_matrix_mult(c1_connected, gd, c1_connected)
+        if c1_isolated is not None:
+            c2dry = (
+                c2dry
+                + array_matrix_mult(c1_connected, gd, c1_isolated)
+                + array_matrix_mult(c1_isolated, gd, c1_connected)
+            )
+
+    i4 = np.tile(np.eye(6).reshape(1, 6, 6), (log_len, 1, 1))
+    c_eff_dry = c0 + array_matrix_mult(
+        c1dry, array_inverse(i4 + array_matrix_mult(array_inverse(c1dry), c2dry))
+    )
+    temp = array_matrix_mult(
+        i4,
+        array_inverse(i4 + array_matrix_mult(array_inverse(c1dry), c2dry)),
+        array_inverse(c_eff_dry),
+    )
+
+    # if only connected or mixed connected and isolated
+    if ctrl != 0:
+        kd_eff_connected = np.zeros((log_len, 6, 6, alpha_con.shape[1]))
+        for j in range(alpha_con.shape[1]):
+            g = g_tensor_vec(c0, s_0, alpha_con[:, j])
+            kd_eff_connected[:, :, :, j] = array_matrix_mult(
+                array_inverse(i4 + array_matrix_mult(g, c0)), temp
+            )
+
+    if ctrl != 2:
+        kd_eff_isolated = np.zeros((log_len, 6, 6, alpha_iso.shape[1]))
+        for j in range(alpha_iso.shape[1]):
+            g = g_tensor_vec(c0, s_0, alpha_iso[:, j])
+            kd_eff_isolated[:, :, :, j] = array_matrix_mult(
+                array_inverse(i4 + array_matrix_mult(g, c0)), temp
+            )
+
+    return kd_eff_isolated, kd_eff_connected

rock_physics_open/t_matrix_models/t_matrix_vector/calc_kd_uuv.py

@@ -0,0 +1,18 @@
+import numpy as np
+
+
+def calc_kd_uuvv_vec(kd):
+    """Returns the sum of dry k_uuvv.
+
+    Parameters
+    ----------
+    kd : np.ndarray
+        The dry K-tensor (n, 6,6,(numbers of inclusions)) matrix.
+
+    Returns
+    -------
+    np.ndarray
+        Summed elements.
+
+    """
+    return np.sum(kd[:, :3, :3, :], axis=(1, 2))

rock_physics_open/t_matrix_models/t_matrix_vector/calc_pressure.py

@@ -0,0 +1,140 @@
+import numpy as np
+
+from .calc_kd_eff import calc_kd_eff_vec
+
+
+def calc_pressure_vec(
+    alpha_con,
+    alpha_iso,
+    v_con,
+    v_iso,
+    c0,
+    s_0,
+    gd,
+    d_p,
+    tau,
+    gamma,
+    k_fl,
+    ctrl,
+    frac_ani,
+):
+    """Calculate the effect of depletion on aspect ratios.
+
+    Parameters
+    ----------
+    alpha_con : np.ndarray
+        Aspect ratio for connected inclusions (r length vector).
+    alpha_iso : np.ndarray
+        Aspect ratio for connected inclusions (s length vector).
+    v_con : np.ndarray
+        Volume of connected inclusions (r length vector).
+    v_iso : np.ndarray
+        Volume of connected inclusions (s length vector).
+    c0 : np.ndarray
+        Stiffness tensor of host material (nx6x6 array).
+    s_0 : np.ndarray
+        Inverse of stiffness tensor (nx6x6 array).
+    gd : np.ndarray
+        The correlation function (green's tensor nx6x6 matrix).
+    d_p : float
+        Change in effective pressure.
+    tau : np.ndarray
+        Relaxation time constant ((numbers of connected pores) vector).
+    gamma : np.ndarray
+        Gamma factor ((numbers of connected pores) vector).
+    k_fl : np.ndarray
+        Fluid bulk modulus (n length vector).
+    ctrl : int
+        Control parameter.
+    frac_ani : float
+        Fraction of anisotropic inclusions.
+
+    Returns
+    -------
+    tuple
+        alpha_n_connected, v_n_connected, alpha_n_isolated, v_n_isolated, tau_n_out, gamma_n_out -
+        modified alphas, volumes, relaxation times and gamma factors.
+
+    Notes
+    -----
+    Equations used can be found in:
+    Agersborg (2007), phd thesis:
+    https://bora.uib.no/handle/1956/2422
+
+    09.03.2012
+    Remy Agersborg
+    email: remy@agersborg.com
+
+    Translated to Python and vectorised by Harald Flesche, hfle@equinor.com 2020
+    """
+
+    def _new_values(k, sum_k, a, v, d_p, t, g):
+        # Local helper function to avoid code duplication
+        len_alpha = a.shape[1]
+        len_log = k.shape[0]
+
+        v_new = v * (
+            1
+            - (np.sum(k[:, 0:3, 0:3, :], axis=(1, 2)) - sum_k.reshape(len_log, 1)) * d_p
+        )
+        alpha_new = a * (
+            1
+            - (np.sum(k[:, 2, 0:3, :], axis=1) - np.sum(k[:, 0, 0:3, :], axis=1)) * d_p
+        )
+
+        idx_neg = (alpha_new < 0.0) | (v_new < 0.0)
+        idx_high = (alpha_new > 1.0) | (v_new > 1.0)
+        idx_inval = np.logical_or(idx_neg, idx_high)
+
+        for i in range(len_alpha):
+            # Maybe best to set undefined, but for now keep old values
+            # alpha_new[idx_inval] = np.nan
+            # v_new[idx_inval] = np.nan
+            alpha_new[idx_inval[:, i], i] = a[idx_inval[:, i], i]
+            v_new[idx_inval[:, i], i] = v[idx_inval[:, i], i]
+        tau_n = np.array(t)
+        gamma_n = np.array(g)
+
+        return v_new, alpha_new, tau_n, gamma_n
+
+    kd_eff_isolated, kd_eff_connected = calc_kd_eff_vec(
+        c0, s_0, k_fl, alpha_con, alpha_iso, v_con, v_iso, gd, ctrl, frac_ani
+    )
+    # Find the sum in the eq. 21 Jakobsen and Johansen 2005
+    sum_kd = 0.0
+    if ctrl != 2 and kd_eff_isolated is not None:
+        count_isolated = kd_eff_isolated.shape[3]
+        for j in range(count_isolated):
+            sum_kd = sum_kd + v_iso[:, j] * np.sum(
+                kd_eff_isolated[:, 0:3, 0:3, j], axis=(1, 2)
+            )
+    if ctrl != 0 and kd_eff_connected is not None:
+        count_connected = kd_eff_connected.shape[3]
+        for j in range(count_connected):
+            sum_kd = sum_kd + v_con[:, j] * np.sum(
+                kd_eff_connected[:, 0:3, 0:3, j], axis=(1, 2)
+            )
+    # Find the new concentration of inclusion
+    alpha_n_isolated = None
+    alpha_n_connected = None
+    v_n_isolated = None
+    v_n_connected = None
+    gamma_n_out = []
+    tau_n_out = []
+    if ctrl != 2:
+        v_n_isolated, alpha_n_isolated, _, _ = _new_values(
+            kd_eff_isolated, sum_kd, alpha_iso, v_iso, d_p, tau, gamma
+        )
+    if ctrl != 0:
+        v_n_connected, alpha_n_connected, tau_n_out, gamma_n_out = _new_values(
+            kd_eff_connected, sum_kd, alpha_con, v_con, d_p, tau, gamma
+        )
+
+    return (
+        alpha_n_connected,
+        v_n_connected,
+        alpha_n_isolated,
+        v_n_isolated,
+        tau_n_out,
+        gamma_n_out,
+    )