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

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

rock_physics_open/t_matrix_models/t_matrix_vector/g_tensor.py

@@ -0,0 +1,140 @@
+import numpy as np
+
+from .array_functions import array_matrix_mult
+
+
+def g_tensor_vec(c0, s_0, alpha):
+    """Returns the Eshelby green's tensor (nx6x6 array).
+
+    Parameters
+    ----------
+    c0 : np.ndarray
+        n stiffness tensors of the host material (nx6x6 array).
+    s_0 : np.ndarray
+        Inverse of stiffness tensor.
+    alpha : float
+        Aspect ratio for single inclusion.
+
+    Returns
+    -------
+    np.ndarray
+        g-tensor.
+
+    Raises
+    ------
+    ValueError
+        If mismatch in input dimension/shape.
+    """
+    if not (
+        c0.ndim == 3
+        and c0.shape[1] == c0.shape[2]
+        and s_0.ndim == 3
+        and s_0.shape[1] == s_0.shape[2]
+    ):
+        raise ValueError(f"{__name__}: mismatch in inputs variables dimension/shape")
+
+    log_len = c0.shape[0]
+    mu = c0[:, 3, 3] / 2
+    kappa = c0[:, 0, 0] - (4 / 3) * mu
+    pois_ratio = (3 * kappa - 2 * mu) / (2 * (3 * kappa + mu))
+
+    s_r = np.zeros(c0.shape)
+
+    s_11 = np.zeros(log_len)
+    s_12 = np.zeros(log_len)
+    s_13 = np.zeros(log_len)
+    s_21 = np.zeros(log_len)
+    s_22 = np.zeros(log_len)
+    s_23 = np.zeros(log_len)
+    s_31 = np.zeros(log_len)
+    s_32 = np.zeros(log_len)
+    s_33 = np.zeros(log_len)
+    s_44 = np.zeros(log_len)
+    s_55 = np.zeros(log_len)
+    s_66 = np.zeros(log_len)
+
+    if isinstance(alpha, float):
+        alpha = np.ones(log_len) * alpha
+    # Check for valid range of alpha - those outside are returned with zero matrices
+    idx_in = (alpha >= 0) & (alpha < 1)
+    idx_one = alpha == 1
+    alpha_in = alpha[idx_in]
+    pois_ratio_in = pois_ratio[idx_in]
+    pois_ratio_one = pois_ratio[idx_one]
+
+    if np.any(idx_in):
+        q = (alpha_in / (1 - alpha_in**2) ** (3 / 2)) * (
+            np.arccos(alpha_in) - alpha_in * (1 - alpha_in**2) ** (1 / 2)
+        )
+        s_11[idx_in] = (3 / (8 * (1 - pois_ratio_in))) * (
+            alpha_in**2 / (alpha_in**2 - 1)
+        ) + (1 / (4 * (1 - pois_ratio_in))) * (
+            1 - 2 * pois_ratio_in - 9 / (4 * (alpha_in**2 - 1))
+        ) * q
+        s_33[idx_in] = (1 / (2 * (1 - pois_ratio_in))) * (
+            1
+            - 2 * pois_ratio_in
+            + (3 * alpha_in**2 - 1) / (alpha_in**2 - 1)
+            - (1 - 2 * pois_ratio_in + 3 * alpha_in**2 / (alpha_in**2 - 1)) * q
+        )
+        s_12[idx_in] = (1 / (4 * (1 - pois_ratio_in))) * (
+            alpha_in**2 / (2 * (alpha_in**2 - 1))
+            - (1 - 2 * pois_ratio_in + 3 / (4 * (alpha_in**2 - 1))) * q
+        )
+        s_13[idx_in] = (1 / (2 * (1 - pois_ratio_in))) * (
+            -(alpha_in**2) / (alpha_in**2 - 1)
+            + 0.5 * (3 * alpha_in**2 / (alpha_in**2 - 1) - (1 - 2 * pois_ratio_in)) * q
+        )
+        s_31[idx_in] = (1 / (2 * (1 - pois_ratio_in))) * (
+            2 * pois_ratio_in
+            - 1
+            - 1 / (alpha_in**2 - 1)
+            + (1 - 2 * pois_ratio_in + 3 / (2 * (alpha_in**2 - 1))) * q
+        )
+        s_66[idx_in] = (1 / (4 * (1 - pois_ratio_in))) * (
+            alpha_in**2 / (2 * (alpha_in**2 - 1))
+            + (1 - 2 * pois_ratio_in - 3 / (4 * (alpha_in**2 - 1))) * q
+        )
+        s_44[idx_in] = (1 / (4 * (1 - pois_ratio_in))) * (
+            1
+            - 2 * pois_ratio_in
+            - (alpha_in**2 + 1) / (alpha_in**2 - 1)
+            - 0.5
+            * (1 - 2 * pois_ratio_in - (3 * (alpha_in**2 + 1)) / (alpha_in**2 - 1))
+            * q
+        )
+        s_22[idx_in] = s_11[idx_in]
+        s_21[idx_in] = s_12[idx_in]
+        s_23[idx_in] = s_13[idx_in]
+        s_32[idx_in] = s_31[idx_in]
+        s_55[idx_in] = s_44[idx_in]
+    if np.any(idx_one):
+        s_11[idx_one] = (5 * pois_ratio_one - 1) / (15 * (1 - pois_ratio_one)) + (
+            2 * (4 - 5 * pois_ratio_one)
+        ) / (15 * (1 - pois_ratio_one))
+        s_12[idx_one] = (5 * pois_ratio_one - 1) / (15 * (1 - pois_ratio_one))
+        s_13[idx_one] = (5 * pois_ratio_one - 1) / (15 * (1 - pois_ratio_one))
+        s_31[idx_one] = (5 * pois_ratio_one - 1) / (15 * (1 - pois_ratio_one))
+        s_44[idx_one] = (4 - 5 * pois_ratio_one) / (15 * (1 - pois_ratio_one))
+        s_22[idx_one] = s_11[idx_one]
+        s_33[idx_one] = s_11[idx_one]
+        s_21[idx_one] = s_12[idx_one]
+        s_32[idx_one] = s_31[idx_one]
+        s_23[idx_one] = s_13[idx_one]
+        s_55[idx_one] = s_44[idx_one]
+        s_66[idx_one] = s_44[idx_one]
+
+    s_r[:, 0, 0] = s_11
+    s_r[:, 1, 1] = s_22
+    s_r[:, 2, 2] = s_33
+    s_r[:, 3, 3] = 2 * s_44
+    s_r[:, 4, 4] = 2 * s_55
+    s_r[:, 5, 5] = 2 * s_66
+    s_r[:, 0, 1] = s_12
+    s_r[:, 0, 2] = s_13
+    s_r[:, 1, 0] = s_21
+    s_r[:, 1, 2] = s_23
+    s_r[:, 2, 0] = s_31
+    s_r[:, 2, 1] = s_32
+
+    return array_matrix_mult(-s_r, s_0)

rock_physics_open/t_matrix_models/t_matrix_vector/iso_av.py

@@ -0,0 +1,60 @@
+import numpy as np
+
+
+def iso_av_vec(t):
+    """Returns a (nx6x6) matrix t_bar averaged over all the orientations (isotropy).
+
+
+    t_bar = np.array([
+
+        [c11, c12, c12, 0, 0, 0],
+
+        [c12, c11, c12, 0, 0, 0],
+
+        [c12, c12, c11, 0, 0, 0],
+
+        [0, 0, 0, 2 * c44, 0, 0],
+
+        [0, 0, 0, 0, 2 * c44, 0],
+
+        [0, 0, 0, 0, 0, 2 * c44]
+
+    ])
+
+
+    Parameters
+    ----------
+    t : np.ndarray
+        An nx6x6 matrix which has a HTI symmetry.
+
+
+    Returns
+    -------
+    np.ndarray
+        Averaged value.
+    """
+    t_bar = np.zeros(t.shape)
+
+    lambda_var = (
+        t[:, 0, 0] + t[:, 2, 2] + 5 * t[:, 0, 1] + 8 * t[:, 0, 2] - 2 * t[:, 3, 3]
+    ) / 15
+    mu = (
+        7 * t[:, 0, 0]
+        + 2 * t[:, 2, 2]
+        - 5 * t[:, 0, 1]
+        - 4 * t[:, 0, 2]
+        + 6 * t[:, 3, 3]
+    ) / 30
+    c11 = lambda_var + 2 * mu
+    c12 = lambda_var
+    c44 = mu
+
+    for i in range(3):
+        t_bar[:, i, i] = c11
+        t_bar[:, i + 3, i + 3] = 2 * c44
+    for i in range(2):
+        t_bar[:, 0, i + 1] = c12
+        t_bar[:, 1, 2 * i] = c12
+        t_bar[:, 2, i] = c12
+
+    return t_bar

rock_physics_open/t_matrix_models/t_matrix_vector/iso_ave_all.py

@@ -0,0 +1,55 @@
+import numpy as np
+
+from .iso_av import iso_av_vec
+
+
+def iso_av_all_vec(x, case_iso):
+    """Returns an multi dimensional matrix with isotropic elements. (nx6x6x(numbers of inclusions) matrix).
+    Not used in the present implementation - direct call to iso_av_vec from main function instead
+
+
+    Parameters
+    ----------
+    x : np.ndarray
+        An nx6x6x(numbers of inclusions) matrix.
+    case_iso : int
+        Control parameter.
+
+    Returns
+    -------
+    np.ndarray,
+        Isotropic values.
+
+    Examples
+    --------
+    caseIso : control parameter
+    if caseIso = 0 then all the pore types are isotropic,
+    if caseIso = 1 then there is a mix of isotropic and anisotropic pores,
+    if caseIso = 2 then all the pore types are anisotropic.
+
+    Notes
+    -----
+    HFLE 01.11.2020: Anisotropic inclusions are set to have the same aspect ratio as the isotropic ones.
+    """
+    if not (x.ndim == 4 and x.shape[1] == x.shape[2]):
+        raise ValueError(f"{__name__}: mismatch in inputs variables dimension/shape")
+
+    no_inclusions = x.shape[3]
+    x_iso = np.zeros(x.shape)
+
+    # if caseIso = 0 then all the pore types are isotropic
+    if case_iso == 0:
+        for j in range(no_inclusions):
+            x_iso[:, :, j] = iso_av_vec(x[:, :, j])
+    # if caseIso = 1 then all the pore types are isotropic
+    elif case_iso == 1:
+        for j in range(no_inclusions):
+            x_iso[:, :, j] = iso_av_vec(x[:, :, j])
+
+        x_iso[:, :, (no_inclusions // 2) : no_inclusions] = x[
+            :, :, (no_inclusions // 2) : no_inclusions
+        ]
+    elif case_iso == 2:
+        x_iso = x
+
+    return x_iso

rock_physics_open/t_matrix_models/t_matrix_vector/pressure_input.py

@@ -0,0 +1,44 @@
+import numpy as np
+
+from .array_functions import array_inverse, array_matrix_mult
+from .g_tensor import g_tensor_vec
+
+
+def pressure_input_utility(k_min, mu_min, log_length):
+    """Utility that calculates some of the elastic properties needed for T-Matrix pressure estimation.
+
+    Parameters
+    ----------
+    k_min : np.ndarray
+        Effective mineral bulk modulus [Pa].
+    mu_min : np.ndarray
+        Effective mineral shear modulus [Pa].
+    log_length : int
+        Number of samples in logs.
+
+    Returns
+    -------
+    tuple
+        c0 (background stiffness), s0 (inverse of background stiffness), gd (G tensor for inclusions with aspect
+        ratio 1.0).
+    """
+    # Calculate elastic parameters
+    c11 = k_min + 4 / 3 * mu_min
+    c44 = mu_min
+    c12 = c11 - 2 * c44
+
+    i4 = np.tile(np.eye(6).reshape(1, 6, 6), (log_length, 1, 1))
+    c0 = np.zeros((log_length, 6, 6))
+
+    for i in range(3):
+        c0[:, i, i] = c11
+        c0[:, i + 3, i + 3] = 2 * c44
+    for i in range(2):
+        c0[:, 0, i + 1] = c12
+        c0[:, 1, 2 * i] = c12
+        c0[:, 2, i] = c12
+
+    s0 = array_matrix_mult(i4, array_inverse(c0))
+    gd = g_tensor_vec(c0, s0, 1.0)
+
+    return c0, s0, gd