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

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

rock_physics_open/t_matrix_models/t_matrix_vector/t_matrix_vec.py

@@ -0,0 +1,278 @@
+import warnings
+
+import numpy as np
+
+from rock_physics_open.equinor_utilities import gen_utilities
+
+from .array_functions import array_inverse, array_matrix_mult
+from .calc_c_eff import calc_c_eff_visco_vec
+from .calc_isolated import calc_isolated_part_vec
+from .calc_kd import calc_kd_vec
+from .calc_kd_uuv import calc_kd_uuvv_vec
+from .calc_pressure import calc_pressure_vec
+from .calc_td import calc_td_vec
+from .calc_x import calc_x_vec
+from .iso_av import iso_av_vec
+from .pressure_input import pressure_input_utility
+from .velocity_vti_angles import velocity_vti_angles_vec
+
+
+def t_matrix_porosity_vectorised(
+    k_min,
+    mu_min,
+    rho_min,
+    k_fl,
+    rho_fl,
+    phi,
+    perm,
+    visco,
+    alpha,
+    v,
+    tau,
+    frequency,
+    angle,
+    frac_inc_con,
+    frac_inc_ani,
+    pressure=None,
+):
+    """Vectorised version of T-Matrix, pure Python version - mainly intended for cases where it is wished to follow
+    the entire process through and study intermediate results. The C++ implementation is significantly faster.
+
+    Description of inputs:
+    Mineral propeties (effective properties, assumed mixed).
+    Fluid properties (effective properties, assume mixed).
+
+    Parameters
+    ----------
+    k_min : np.ndarray
+        N length array, bulk modulus of matrix/mineral [Pa].
+    mu_min : np.ndarray
+        N length array, shear modulus of matrix/mineral [Pa].
+    rho_min : np.ndarray
+        N length array, density of matrix/mineral [kg/m^3].
+    k_fl : np.ndarray
+        N length array, bulk modulus of fluid [Pa].
+    rho_fl : np.ndarray
+        N length array, density of fluid [kg/m^3].
+    phi : np.ndarray
+        N length array, porosity [fraction].
+    perm : np.ndarray
+        Single float or N length array, permeability [mD].
+    visco : np.ndarray
+        Single float or N length array, fluid viscosity [cP].
+    alpha : np.ndarray
+        M length vector, aspect ratio for inclusion sets [ratio].
+    v : np.ndarray
+        M length vector, fraction of porosity belonging to each inclusion set [fraction].
+    tau : np.ndarray
+        M length vector, relaxation time constant [s].
+    frequency : float
+        Single float, measurement frequency (seismic, sonic, ultrasonic range) [Hz].
+    angle : float
+        Single float, angle of symmetry plane (0 = HTI, 90 = VTI medium).
+    frac_inc_con : float or np.ndarray
+        Single float or N length array, fraction of inclusions that are connected.
+    frac_inc_ani : float or np.ndaray
+        Single float or N length array, fraction of inclusions that are anisotropic.
+    pressure : np.ndarray, optional
+        L length array (normally 2), by default None.
+
+    Returns
+    -------
+    tuple
+        Of type (np.ndarray, np.ndarray, np.ndarray, np.ndarray). Vertical P-wave velocity [m/s], Vsv: Vertical polarity S-wave velocity [m/s],
+        Vsh: Horizontal polarity S-wave velocity [m/s], rho_b: bulk density [kg/m^3].
+    """
+    log_length = len(phi)
+    # Check that the inputs that should have the same length actually do
+    (
+        k_min,
+        mu_min,
+        rho_min,
+        k_fl,
+        rho_fl,
+        phi,
+        perm,
+        visco,
+    ) = gen_utilities.dim_check_vector(
+        (k_min, mu_min, rho_min, k_fl, rho_fl, phi, perm, visco)
+    )
+
+    # Conversion to SI units
+    perm = perm * 0.986923e-15
+    visco = visco * 1.0e-2
+
+    # Alpha, v and tau should be of the same length
+    (alpha, v, tau) = gen_utilities.dim_check_vector((alpha, v, tau))
+    shape_len = alpha.shape[0]
+
+    # Shape parameters go into a dict, duplicate here, can be changed with pressure effect
+    shape_params = {
+        "alpha_con": alpha,
+        "alpha_iso": alpha,
+        "v_con": v * frac_inc_con,
+        "v_iso": v * (1 - frac_inc_con),
+        "tau_con": tau,
+        "tau_iso": tau,
+    }
+    # Create case based on amount of anisotropic inclusions
+    if frac_inc_ani == 0:
+        case = {"iso": 0}  # All isotropic
+        angle = 0
+    elif frac_inc_ani == 1:
+        case = {"iso": 2}  # All anisotropic
+    else:
+        case = {"iso": 1}  # Mixed case
+
+    # Create case based on amount of connected inclusions
+    if frac_inc_con == 0:
+        case["con"] = 0
+    elif frac_inc_con == 1:
+        # All connected
+        case["con"] = 2
+    else:
+        # Mixed case
+        case["con"] = 1
+
+    pressure_steps = 1
+    delta_pres = 0.0
+    if pressure is not None:
+        try:
+            # Pressure should be an object with __len__ attribute, cast to np.array
+            pressure = np.array(pressure)
+            pressure_steps = len(pressure)
+        except TypeError:
+            w_str = "pressure input must be a vector of length > 1 with increasing effective pressures"
+            warnings.warn(w_str)
+        else:
+            delta_pres = np.diff(pressure)
+
+    # Predefine output vectors
+    vp = np.zeros((log_length, pressure_steps))
+    vs_v = np.zeros((log_length, pressure_steps))
+    vs_h = np.zeros((log_length, pressure_steps))
+    rho_b_est = np.zeros((log_length, pressure_steps))
+
+    # Matrix properties needed
+    c0, s0, gd = pressure_input_utility(k_min, mu_min, log_length)
+
+    i4 = np.tile(np.eye(6).reshape(1, 6, 6), (log_length, 1, 1))
+
+    # Vectorise v and alpha
+    v_con = None
+    alpha_con = None
+    v_iso = None
+    alpha_iso = None
+    if case["con"] != 0:
+        v_con = phi.reshape(log_length, 1) * shape_params["v_con"].reshape(1, shape_len)
+        alpha_con = np.ones(v_con.shape) * shape_params["alpha_con"].reshape(
+            1, shape_len
+        )
+
+    if case["con"] != 2:
+        v_iso = phi.reshape(log_length, 1) * shape_params["v_iso"].reshape(1, shape_len)
+        alpha_iso = np.ones(v_iso.shape) * shape_params["alpha_iso"].reshape(
+            1, shape_len
+        )
+
+    for i in range(pressure_steps):
+        # Check if v(j) > alpha(j)for maximum porosity. If true, set v(j) = alpha(j)/2 to make sure
+        # the numbers of inclusions in the system is not violating the
+        # approximations for effective medium theories.
+        phi_con = 0.0
+        phi_iso = 0.0
+        if case["con"] != 0:
+            idx_v_con = v_con * phi.reshape(log_length, 1) > alpha_con
+            if np.any(idx_v_con):
+                v_con[idx_v_con] = alpha_con[idx_v_con] / 2
+            phi_con = np.sum(v_con, axis=1)
+        if case["con"] != 2:
+            idx_v_iso = v_iso * phi.reshape(log_length, 1) > alpha_iso
+            if np.any(idx_v_iso):
+                v_iso[idx_v_iso] = alpha_iso[idx_v_iso] / 2
+            phi_iso = np.sum(v_iso, axis=1)
+        # May seem unnecessary, but V-vectors can change with changing pressure
+        phi_out = phi_con + phi_iso
+
+        # Creating reference matrix
+        vs_min = np.sqrt(mu_min / rho_min)
+
+        if case["con"] == 0:
+            # All isolated
+            # Isolated part: calculated c1 tensor (sum over all the isolated t-matrices and concentrations
+            c1 = calc_isolated_part_vec(
+                c0, s0, k_fl, alpha_iso, v_iso, case["iso"], frac_inc_ani
+            )
+            c_eff = c0 + array_matrix_mult(
+                c1, array_inverse(i4 + array_matrix_mult(gd, c1))
+            )
+            gamma = np.zeros_like(tau)
+        else:
+            kd = calc_kd_vec(c0, i4, s0, alpha_con)
+            kd_uuvv = calc_kd_uuvv_vec(kd)
+            gamma = (1 - k_fl / k_min).reshape(log_length, 1) + k_fl.reshape(
+                log_length, 1
+            ) * kd_uuvv
+            if case["con"] == 1:
+                # Mix
+                # Isolated part: calculated c1 tensor (sum over all the isolated t-matrices and concentrations
+                c1 = calc_isolated_part_vec(
+                    c0, s0, k_fl, alpha_iso, v_iso, case["iso"], frac_inc_ani
+                )
+            else:  # case['con'] == 2
+                # All connected - only c1 differs from the most general case
+                c1 = np.zeros((log_length, 6, 6))
+            # Connected part Calculate dry properties:
+            td = calc_td_vec(c0, i4, s0, kd, alpha_con)
+            # iso averaging the isotropic porosity
+            td_bar = iso_av_vec(td)
+            # Calculate the fluid effect
+            x = calc_x_vec(s0, td)
+            # iso averaging the isotropic porosity
+            x_bar = iso_av_vec(x)
+            # Frequency dependent stiffness
+            c_eff = calc_c_eff_visco_vec(
+                vs_min,
+                perm,
+                visco,
+                v_con,
+                gamma,
+                tau,
+                kd_uuvv,
+                k_min,
+                k_fl,
+                c0,
+                s0,
+                c1,
+                td,
+                td_bar,
+                x,
+                x_bar,
+                gd,
+                frequency,
+                frac_inc_ani,
+            )
+        # Effective density
+        rho_b_est[:, i] = phi_out * rho_fl + (1 - phi_out) * rho_min
+        vp[:, i], vs_v[:, i], vs_h[:, i] = velocity_vti_angles_vec(
+            c_eff, rho_b_est[:, i], angle
+        )
+
+        if i != pressure_steps - 1:
+            alpha_con, v_con, alpha_iso, v_iso, tau, gamma = calc_pressure_vec(
+                alpha_con,
+                alpha_iso,
+                v_con,
+                v_iso,
+                c0,
+                s0,
+                gd,
+                delta_pres[i],
+                tau,
+                gamma,
+                k_fl,
+                case["con"],
+                frac_inc_ani,
+            )
+
+    return vp, vs_v, vs_h, rho_b_est

rock_physics_open/t_matrix_models/t_matrix_vector/velocity_vti_angles.py

@@ -0,0 +1,81 @@
+import numpy as np
+
+
+def velocity_vti_angles_vec(c_eff, rho_eff, angle):
+    """Returns the P-velocity and  S-velocities.
+
+    Parameters
+    ----------
+    c_eff : np.ndarray
+        Effective stiffness tensor (nx6x6 matrix).
+    rho_eff : np.ndarray
+        Effective density.
+    angle : np.ndarray or float
+        The angle between the wave vector and the axis of symmetry.
+
+    Returns
+    -------
+    tuple
+        vp_out, vsv_out, vsh_out : (np.ndarray, np.ndarray, np.ndarray).
+        vp_out, vsv_out, vsh_out : p-velocity, vertical polarisation s-velocity, horizontal polarisation s-velocity.
+    """
+    if not (
+        c_eff.ndim == 3
+        and rho_eff.ndim == 1
+        and isinstance(angle, (float, int))
+        and (c_eff.shape[0] == rho_eff.shape[0] and c_eff.shape[1] == c_eff.shape[2])
+    ):
+        raise ValueError("velocity_vti_angles: inconsistencies in input shapes")
+
+    # vp45
+    m45 = (
+        (c_eff[:, 0, 0] - c_eff[:, 3, 3] / 2.0) * 0.5
+        - (c_eff[:, 2, 2] - c_eff[:, 3, 3] / 2.0) * 0.5
+    ) ** 2 + (c_eff[:, 0, 0] - c_eff[:, 3, 3] / 2.0) ** 2
+    m45 = np.sqrt(m45)
+    v2p = ((c_eff[:, 0, 0] + c_eff[:, 2, 2] + c_eff[:, 3, 3]) / 2.0 + m45) / (
+        2.0 * rho_eff
+    )
+    sp = np.real(1.0 / (np.sqrt(v2p)))
+    vp45 = 1.0 / sp
+
+    # c11 = rho_eff * Vp90 ** 2
+    c11 = np.real(c_eff[:, 0, 0])
+    # c33 = rho_eff * Vp0 ** 2
+    c33 = np.real(c_eff[:, 2, 2])
+    # c44 = rho_eff * Vs0 ** 2
+    c44 = np.real(c_eff[:, 3, 3] / 2.0)
+    # c66 = rho_eff * Vs90 ** 2
+    c66 = np.real(c_eff[:, 5, 5] / 2.0)
+
+    c13 = -c44 + np.sqrt(
+        4 * (rho_eff**2) * (vp45**4)
+        - 2.0 * rho_eff * (vp45**2) * (c11 + c33 + 2.0 * c44)
+        + (c11 + c44) * (c33 + c44)
+    )
+
+    rad_angle = (angle * np.pi) / 180.0
+
+    m_real = (
+        (c11 - c44) * (np.sin(rad_angle) ** 2) - (c33 - c44) * (np.cos(rad_angle) ** 2)
+    ) ** 2 + ((c13 + c44) ** 2) * (np.sin(2.0 * rad_angle) ** 2)
+
+    vp_out = np.sqrt(
+        c11 * (np.sin(rad_angle) ** 2)
+        + c33 * (np.cos(rad_angle) ** 2)
+        + c44
+        + np.sqrt(m_real)
+    ) * np.sqrt(1.0 / (2.0 * rho_eff))
+
+    vsv_out = np.sqrt(
+        c11 * (np.sin(rad_angle) ** 2)
+        + c33 * (np.cos(rad_angle) ** 2)
+        + c44
+        - np.sqrt(m_real)
+    ) * np.sqrt(1.0 / (2.0 * rho_eff))
+
+    vsh_out = np.sqrt(
+        (c66 * (np.sin(rad_angle) ** 2) + c44 * (np.cos(rad_angle) ** 2)) / rho_eff
+    )
+
+    return vp_out, vsv_out, vsh_out

rock_physics_open/ternary_plots/__init__.py

@@ -0,0 +1,3 @@
+from .unconventionals_ternary import run_ternary
+
+__all__ = ["run_ternary"]