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

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,
+    )

rock_physics_open/t_matrix_models/t_matrix_vector/calc_t.py

@@ -0,0 +1,71 @@
+import numpy as np
+
+
+def calc_t_vec(td, theta, x, z, omega, gamma, tau, k_fluid):
+    """
+    Returns the t-matrices (6x6x(numbers of connected pores)) of the
+    connected pores.
+
+    Parameters
+    ----------
+    td : np.ndarray
+        Dry t-matrix tensors, (nx6x6x(numbers of empty cavities) matrix).
+    theta : np.ndarray
+        Theta-tensor (nx6x6 matrix).
+    x : np.ndarray
+        X-tensor (nx6x6x(numbers of empty cavities) matrix).
+    z : np.ndarray
+        Z-tensor (nx6x6x(numbers of empty cavities) matrix).
+    omega : np.ndarray
+        Frequency (2*pi*f).
+    gamma : np.ndarray
+        Gamma factor of all the inclusions (nx(numbers of empty cavities) vector).
+    tau : np.ndarray
+        Relaxation time constant (1x(numbers of empty cavities) vector).
+    k_fluid : np.ndarray
+        Bulk modulus of the fluid.
+
+    Returns
+    -------
+    np.ndarray
+        t-matrices.
+    """
+    if not (
+        td.ndim == 4
+        and x.ndim == 4
+        and z.ndim == 4
+        and gamma.ndim == 2
+        and k_fluid.ndim == 1
+        and theta.ndim == 1
+        and np.all(np.array([td.shape[1:2], x.shape[1:2], z.shape[1:2]]) == td.shape[1])
+        and np.all(
+            np.array(
+                [
+                    x.shape[0],
+                    z.shape[0],
+                    gamma.shape[0],
+                    theta.shape[0],
+                    k_fluid.shape[0],
+                ]
+            )
+            == td.shape[0]
+        )
+        and np.all(
+            np.array([x.shape[3], z.shape[3], tau.shape[0], gamma.shape[1]])
+            == td.shape[3]
+        )
+    ):
+        raise ValueError(f"{__name__}: mismatch in inputs dimension/shape")
+
+    log_len = k_fluid.shape[0]
+    alpha_len = td.shape[3]
+
+    # Reshape to enable broadcast
+    k_fluid = k_fluid.reshape((log_len, 1, 1, 1))
+    gamma = gamma.reshape((log_len, 1, 1, alpha_len))
+    tau = tau.reshape((1, 1, 1, alpha_len))
+    theta = theta.reshape((log_len, 1, 1, 1))
+
+    return td + (theta * z + 1j * omega * tau * k_fluid * x) / (
+        1 + 1j * omega * gamma * tau
+    )

rock_physics_open/t_matrix_models/t_matrix_vector/calc_td.py

@@ -0,0 +1,42 @@
+import numpy as np
+
+from .array_functions import array_inverse, array_matrix_mult
+from .g_tensor import g_tensor_vec
+
+
+def calc_td_vec(c0, i4, s_0, kd, alpha):
+    """Returns the dry t-matrix tensors (nx6x6x(numbers of empty cavities) matrix).
+
+    Parameters
+    ----------
+    c0 : np.ndarray
+        Stiffness tensor of the host material (nx6x6 matrix).
+    i4 : np.ndarray
+        An n x Identity matrix.
+    s_0 : np.ndarray
+        Inverse of stiffness tensor.
+    kd : np.ndarray
+        Dry K tensor of all the empty cavities (nx6x6x(numbers of empty cavities) matrix) see Agersborg et al.
+        2009 for explanation.
+    alpha : np.ndarray
+        Aspect ratios of all the empty cavities (1x(numbers of empty cavities) vector).
+
+    Returns
+    -------
+    np.ndarray
+        Dry t-matrix tensors.
+    """
+    log_len = c0.shape[0]
+    if alpha.ndim == 1 and alpha.shape[0] != c0.shape[0]:
+        alpha = np.tile(alpha.reshape(1, alpha.shape[0]), (log_len, 1))
+    alpha_len = alpha.shape[1]
+
+    td = np.array(np.zeros((log_len, 6, 6, alpha_len)))
+
+    for nc in range(alpha_len):
+        g = g_tensor_vec(c0, s_0, alpha[:, nc])
+        td[:, :, :, nc] = array_matrix_mult(
+            array_inverse(g), array_matrix_mult(kd[:, :, :, nc], c0) - i4
+        )
+
+    return td

rock_physics_open/t_matrix_models/t_matrix_vector/calc_theta.py

@@ -0,0 +1,43 @@
+import numpy as np
+
+
+def calc_theta_vec(v, omega, gamma, tau, kd_uuvv, dr, k, kappa, kappa_f):
+    """Returns the theta tensor (6x6 matrix) for more explanation see e.g.
+    Agersborg et al. 2009 or "The effects of drained and undrained loading in
+    visco-elsatic waves in rock-like composites" M. Jakobsen and T.A. Johansen.
+    (2005). Int. J. Solids and Structures (42). p. 1597-1611.
+
+    Parameters
+    ----------
+    v  : np.ndarray
+        Concentration of all the empty cavities (1x(numbers of empty cavities) vector).
+    omega : np.ndarray
+        Frequency (2*pi*f).
+    gamma : np.ndarray
+        Gamma factor of all the inclusions (1x(numbers of empty cavities) vector).
+    tau : np.ndarray
+        Relaxation time constant (1x(numbers of empty cavities) vector).
+    kd_uuvv : np.ndarray
+        Tensor sum of the dry K tensor for all the cavities (1x(numbers of empty cavities) vector).
+    dr : np.ndarray
+        Permeability/viscosity.
+    k : np.ndarray
+        Wave number vector.
+    kappa : np.ndarray
+        Bulk modulus of the host material.
+    kappa_f : np.ndarray
+        Bulk modulus of the fluid.
+
+    Returns
+    -------
+    np.ndarray
+        Theta tensor.
+    """
+    sigma_a = np.sum((v / (1 + 1j * omega * gamma * tau)), axis=1)
+    sigma_b = np.sum((v / (1 + 1j * omega * gamma * tau)) * kd_uuvv, axis=1)
+
+    return kappa_f / (
+        (1 - kappa_f / kappa) * sigma_a
+        + kappa_f * sigma_b
+        - (1j * k * k / omega) * dr * kappa_f
+    )

rock_physics_open/t_matrix_models/t_matrix_vector/calc_x.py

@@ -0,0 +1,33 @@
+import numpy as np
+
+from .array_functions import array_matrix_mult
+from .check_and_tile import check_and_tile
+
+
+def calc_x_vec(s_0, td):
+    """Returns the x-tensor (6x6x(numbers of empty cavities) matrix) for more explanation see e.g.
+    Agersborg et al. 2009 or "The effects of drained and undrained loading in
+    visco-elsatic waves in rock-like composites" M. Jakobsen and T.A. Johansen.
+    (2005). Int. J. Solids and Structures (42). p. 1597-1611
+
+    Parameters
+    ----------
+    s_0: np.ndarray
+        Inverse of stiffness tensor of the host material (nx6x6 matrix).
+    td :  np.ndarray
+        Dry t-matrix tensors (nx6x6x(numbers of empty cavities) matrix).
+
+    Returns
+    -------
+    np.ndarray
+        x-tensor.
+    """
+    i2_i2, log_length, alpha_length = check_and_tile(s_0, td)
+
+    x = np.zeros((log_length, 6, 6, alpha_length))
+    for j in range(alpha_length):
+        x[:, :, :, j] = array_matrix_mult(
+            td[:, :, :, j], s_0, i2_i2, s_0, td[:, :, :, j]
+        )
+
+    return x

rock_physics_open/t_matrix_models/t_matrix_vector/calc_z.py

@@ -0,0 +1,50 @@
+import numpy as np
+
+from .array_functions import array_matrix_mult
+from .check_and_tile import check_and_tile
+
+
+def calc_z_vec(s0, td, td_bar, omega, gamma, v, tau):
+    """Returns the z tensor (6x6x(numbers of empty cavities) matrix) for more explanation see e.g.
+    Agersborg et al. 2009 or "The effects of drained and undrained loading in
+    visco-elsatic waves in rock-like composites" M. Jakobsen and T.A. Johansen.
+    (2005). Int. J. Solids and Structures (42). p. 1597-1611.
+
+    Parameters
+    ----------
+    s0  : np.ndarray
+        Stiffness tensor of the host material (6x6 matrix).
+    td  : np.ndarray
+        Dry t-matrix tensors, (6x6x(numbers of empty cavities) matrix).
+    td_bar  : np.ndarray
+        Dry t-matrix tensors, (6x6x(numbers of empty cavities) matrix).
+    omega : np.ndarray
+        Frequency (2*pi*f).
+    gamma : np.ndarray
+        Gamma factor of all the inclusions (1x(numbers of empty cavities) vector).
+    v  :  np.ndarray
+        Concentration of all the empty cavities (1x(numbers of empty cavities) vector).
+    tau  :  np.ndarray
+        Relaxation time constant (1x(numbers of empty cavities) vector).
+
+    Returns
+    -------
+    tuple
+        z, z_bar : (np.ndarray, np.ndarray).
+    """
+    i2_i2, log_length, alpha_length = check_and_tile(s0, td)
+
+    sum_z = 0.0
+    z = np.zeros((log_length, 6, 6, alpha_length), dtype="complex128")
+    z_bar = np.zeros((log_length, 6, 6, alpha_length), dtype="complex128")
+
+    for j in range(alpha_length):
+        sum_z = sum_z + (td[:, :, :, j] + td_bar[:, :, :, j]) * (
+            v[:, j] / (1 + 1j * omega * gamma[:, j] * tau[j])
+        ).reshape(log_length, 1, 1)
+
+    for j in range(alpha_length):
+        z[:, :, :, j] = array_matrix_mult(td[:, :, :, j], s0, i2_i2, s0, sum_z)
+        z_bar[:, :, :, j] = array_matrix_mult(td_bar[:, :, :, j], s0, i2_i2, s0, sum_z)
+
+    return z, z_bar

rock_physics_open/t_matrix_models/t_matrix_vector/check_and_tile.py

@@ -0,0 +1,43 @@
+import numpy as np
+
+
+def check_and_tile(s, t):
+    """Utility  - code that was repeated in the T-Matrix functions.
+
+    Parameters
+    ----------
+    s : np.ndarray
+        s parameter.
+    t : np.ndarray
+        t parameter.
+
+    Returns
+    -------
+    tuple
+        i2_i2, log_length, alpha_length : (np.ndarray, int, int).
+        i2_i2: array with upper left matrices set to 1, log_length: array dimension, alpha_length: number of inclusions.
+    """
+    if not (
+        s.ndim == 3
+        and t.ndim == 4
+        and np.all(np.array([s.shape[1], s.shape[2], t.shape[1]]) == t.shape[2])
+        and s.shape[0] == t.shape[0]
+    ):
+        raise ValueError(f"{__name__}: mismatch in inputs variables dimension/shape")
+
+    log_length = t.shape[0]
+    alpha_length = t.shape[3]
+
+    tmp = np.array(
+        [
+            [1, 1, 1, 0, 0, 0],
+            [1, 1, 1, 0, 0, 0],
+            [1, 1, 1, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0],
+        ]
+    )
+    i2_i2 = np.tile(tmp.reshape((1, 6, 6)), (log_length, 1, 1))
+
+    return i2_i2, log_length, alpha_length