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

rock_physics_open/equinor_utilities/various_utilities/__init__.py

@@ -0,0 +1,24 @@
+from .display_result_statistics import disp_result_stats
+from .gassmann_dry_mod import gassmann_dry_model
+from .gassmann_mod import gassmann_model
+from .gassmann_sub_mod import gassmann_sub_model
+from .hs_average import hs_average
+from .pressure import pressure
+from .reflectivity import reflectivity
+from .timeshift import time_shift_pp, time_shift_ps
+from .vp_vs_rho_set_statistics import vp_vs_rho_stats
+from .vrh_3_min import min_3_voigt_reuss_hill
+
+__all__ = [
+    "disp_result_stats",
+    "gassmann_dry_model",
+    "gassmann_model",
+    "gassmann_sub_model",
+    "hs_average",
+    "pressure",
+    "reflectivity",
+    "time_shift_pp",
+    "time_shift_ps",
+    "vp_vs_rho_stats",
+    "min_3_voigt_reuss_hill",
+]

rock_physics_open/equinor_utilities/various_utilities/display_result_statistics.py

@@ -0,0 +1,83 @@
+import os
+import sys
+
+import numpy as np
+
+
+def disp_result_stats(title: str, arr: list | tuple, names_arr: list, **kwargs):
+    """
+    Display results utilizing tkinter.
+
+    Parameters
+    ----------
+    title : Title.
+    arr : items to display
+    names_arr : array of names.
+    """
+    from tkinter import END, Entry, PhotoImage, Tk
+
+    class Table:
+        def __init__(self, tk_root, no_rows, no_cols, info):
+            # code for creating table
+            str_len = np.vectorize(len)
+            text_justify = ["center", "left"]
+            text_weight = ["bold", "normal"]
+            for i in range(no_rows):
+                weigh = text_weight[np.sign(i)]
+                for j in range(no_cols):
+                    just = text_justify[np.sign(i)]
+                    max_len = np.max(str_len(info[:, j]))
+                    self.e = Entry(
+                        tk_root,
+                        width=max_len + 2,
+                        fg="black",
+                        font=("Consolas", 12, weigh),
+                        justify=just,
+                    )
+                    self.e.grid(row=i, column=j)
+                    self.e.insert(END, info[i][j])
+
+    values_only = kwargs.pop("values_only", False)
+    root = Tk(**kwargs)
+    root.title(title)
+    if values_only:
+        info_array = np.zeros((len(arr) + 1, 2)).astype(str)
+        info_array[0, :] = ["Property", "Value"]
+        for k in range(len(arr)):
+            info_array[k + 1, 0] = f"{names_arr[k]}"
+            info_array[k + 1, 1] = f"{arr[k]:.3g}"
+    else:
+        info_array = np.zeros((len(arr) + 1, 6)).astype(str)
+        info_array[0, :] = ["Var", "Min", "Mean", "Max", "No. NaN", "No. of Inf"]
+        for k in range(len(arr)):
+            info_array[k + 1, 0] = f"{names_arr[k]}"
+            info_array[k + 1, 1] = f"{np.nanmin(np.asarray(arr[k])):.3g}"
+            info_array[k + 1, 2] = f"{np.nanmean(np.asarray(arr[k])):.3g}"
+            info_array[k + 1, 3] = f"{np.nanmax(np.asarray(arr[k])):.3g}"
+            info_array[k + 1, 4] = f"{np.sum(np.isnan(np.asarray(arr[k])))}"
+            info_array[k + 1, 5] = f"{np.sum(np.isinf(np.asarray(arr[k])))}"
+
+    Table(root, info_array.shape[0], info_array.shape[1], info_array)
+
+    root.update_idletasks()
+    window_height = root.winfo_height()
+    window_width = root.winfo_width()
+    screen_width = root.winfo_screenwidth()
+    screen_height = root.winfo_screenheight()
+
+    x_coordinate = int((screen_width / 2) - (window_width / 2))
+    y_coordinate = int((screen_height / 2) - (window_height / 2))
+
+    root.geometry(
+        "{}x{}+{}+{}".format(window_width, window_height, x_coordinate, y_coordinate)
+    )
+
+    if sys.platform.startswith("win"):
+        root.iconbitmap(os.path.join(os.path.dirname(__file__), "Equinor_logo.ico"))
+    else:
+        logo = PhotoImage(
+            file=os.path.join(os.path.dirname(__file__), "Equinor_logo.gif")
+        )
+        root.call("wm", "iconphoto", root._w, logo)
+
+    root.mainloop()

rock_physics_open/equinor_utilities/various_utilities/gassmann_dry_mod.py

@@ -0,0 +1,37 @@
+from rock_physics_open.equinor_utilities import std_functions
+
+
+def gassmann_dry_model(k_min, k_fl, rho_fl, k_sat, mu, rho_sat, por):
+    """
+    Gassmann model to go from saturated rock to dry state.
+
+    Parameters
+    ----------
+    k_min : np.ndarray
+        Mineral bulk modulus [Pa].
+    k_fl : np.ndarray
+        Fluid  bulk modulus [Pa].
+    rho_fl : np.ndarray
+        Fluid density [lg/m^3].
+    k_sat : np.ndarray
+        Saturated rock bulk modulus [Pa].
+    mu : np.ndarray
+        Saturated rock shear modulus [Pa].
+    rho_sat : np.ndarray
+        Saturated rock density [kg/m^3].
+    por : np.ndarray
+        Porosity [fraction].
+
+    Returns
+    -------
+    tuple
+        vp_dry, vs_dry, rho_dry, ai_dry, vpvs_dry, k_dry, mu : (np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray).
+        vp_dry, vs_dry:  dry velocities [m/s], rho_dry: dry density [kg/m^3], ai_dry: dry acoustic impedance
+        [kg/m^3 x m/s], vpvs_dry: dry velocity ratio [unitless], k_dry, mu: dry bulk modulus and shear modulus (the
+        latter unchanged from saturated state) [Pa].
+    """
+    rho_dry = rho_sat - por * rho_fl
+    k_dry = std_functions.gassmann_dry(k_sat, por, k_fl, k_min)
+    vp_dry, vs_dry, ai_dry, vpvs_dry = std_functions.velocity(k_dry, mu, rho_dry)
+
+    return vp_dry, vs_dry, rho_dry, ai_dry, vpvs_dry, k_dry, mu

rock_physics_open/equinor_utilities/various_utilities/gassmann_mod.py

@@ -0,0 +1,37 @@
+from rock_physics_open.equinor_utilities import std_functions
+
+
+def gassmann_model(k_min, k_fl, rho_fl, k_dry, mu, rho_dry, por):
+    """
+    Gassmann model to go from dry rock to saturated state.
+
+    Parameters
+    ----------
+    k_min : np.ndarray
+        Mineral bulk modulus [Pa].
+    k_fl : np.ndarray
+        Fluid  bulk modulus [Pa].
+    rho_fl : np.ndarray
+        Fluid density [lg/m^3].
+    k_dry : np.ndarray
+        Dry rock bulk modulus [Pa].
+    mu : np.ndarray
+        Dry rock shear modulus [Pa].
+    rho_dry : np.ndarray
+        Dry rock density [kg/m^3].
+    por : np.ndarray
+        Porosity [fraction].
+
+    Returns
+    -------
+    tuple
+        vp_sat, vs_sat, rho_sat, ai_sat, vpvs_sat, k_sat, mu : (np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray).
+        vp_sat, vs_sat:  saturated velocities [m/s], rho_sat: saturated density [kg/m^3], ai_sat: saturated acoustic
+        impedance [kg/m^3 x m/s], vpvs_sat: saturated velocity ratio [unitless], k_sat, mu: saturated bulk modulus and
+        shear modulus (the latter unchanged from dry state) [Pa].
+    """
+    rho_sat = rho_dry + por * rho_fl
+    k_sat = std_functions.gassmann(k_dry, por, k_fl, k_min)
+    vp_sat, vs_sat, ai_sat, vpvs_sat = std_functions.velocity(k_sat, mu, rho_sat)
+
+    return vp_sat, vs_sat, rho_sat, ai_sat, vpvs_sat, k_sat, mu

rock_physics_open/equinor_utilities/various_utilities/gassmann_sub_mod.py

@@ -0,0 +1,53 @@
+from rock_physics_open.equinor_utilities import std_functions
+
+
+def gassmann_sub_model(
+    k_min,
+    k_fl_orig,
+    rho_fl_orig,
+    k_fl_sub,
+    rho_fl_sub,
+    k_sat_orig,
+    mu,
+    rho_sat_orig,
+    por,
+):
+    """
+    Gassmann model to go from one saturated state to another.
+
+    Parameters
+    ----------
+    k_min : np.ndarray
+        Mineral bulk modulus [Pa].
+    k_fl_orig : np.ndarray
+        Original fluid  bulk modulus [Pa].
+    rho_fl_orig : np.ndarray
+        Original fluid density [lg/m^3].
+    k_fl_sub : np.ndarray
+        Sunstituted fluid  bulk modulus [Pa].
+    rho_fl_sub : np.ndarray
+        Substituted fluid density [lg/m^3].
+    k_sat_orig : np.ndarray
+        Saturated rock bulk modulus with original fluid  [Pa].
+    mu : np.ndarray
+        Rock shear modulus [Pa].
+    rho_sat_orig : np.ndarray
+        Saturated rock density with original fluid [kg/m^3].
+    por : np.ndarray
+        Porosity [fraction].
+
+    Returns
+    -------
+    tuple
+        vp_sat, vs_sat, rho_sat, ai_sat, vpvs_sat, k_sat, mu : (np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray).
+        vp_sat, vs_sat:  saturated velocities [m/s], rho_sat: saturated density [kg/m^3], ai_sat: saturated acoustic
+        impedance [kg/m^3 x m/s], vpvs_sat: saturated velocity ratio [unitless], k_sat, mu: saturated bulk modulus and
+        shear modulus (the latter unchanged from dry state) [Pa].
+    """
+    rho_sat_sub = rho_sat_orig + por * (rho_fl_sub - rho_fl_orig)
+    k_sat_sub = std_functions.gassmann2(k_sat_orig, k_fl_orig, k_fl_sub, por, k_min)
+    vp_sat_sub, vs_sat_sub, ai_sat_sub, vpvs_sat_sub = std_functions.velocity(
+        k_sat_sub, mu, rho_sat_sub
+    )
+
+    return vp_sat_sub, vs_sat_sub, rho_sat_sub, ai_sat_sub, vpvs_sat_sub, k_sat_sub, mu

rock_physics_open/equinor_utilities/various_utilities/hs_average.py

@@ -0,0 +1,40 @@
+from rock_physics_open.equinor_utilities import std_functions
+
+
+def hs_average(k1, mu1, rhob1, k2, mu2, rhob2, f):
+    """
+    BMix of two phases by Hashin-Shtrikman model. Derived properties are also returned.
+
+    Parameters
+    ----------
+    k1 : np.ndarray
+        k1 array.
+    mu1 : np.ndarray
+        mu1 array.
+    rhob1 : np.ndarray
+        rhob1 array.
+    k2 : np.ndarray
+        k2 array.
+    mu2 : np.ndarray
+        mu2 array.
+    rhob2 : np.ndarray
+        rhob2 array.
+    f : float or np.ndarray
+        f value or array.
+
+    Returns
+    -------
+    tuple
+        vp, vs, rhob, ai, vp_vs, k, mu : np.ndarray
+        vp: compressional wave velocity [m/s], vs: shear wave velocity [m/s], ai: acoustic impedance [m/s x kg/m^3],
+        vp_vs: velocity ratio [ratio], k: bulk modulus [Pa], mu: shear modulus [Pa]
+
+    """
+
+    k, mu = std_functions.hashin_shtrikman_average(k1, mu1, k2, mu2, f)
+
+    rhob = rhob1 * f + rhob2 * (1 - f)
+
+    vp, vs, ai, vp_vs = std_functions.velocity(k, mu, rhob)
+
+    return vp, vs, rhob, ai, vp_vs, k, mu

rock_physics_open/equinor_utilities/various_utilities/pressure.py

@@ -0,0 +1,88 @@
+import numpy as np
+
+
+def pressure(rho, tvd_msl, water_depth, p_form, tvd_p_form, n):
+    """
+    Function to estimate overburden pressure and vertical effective stress (lithostatic pressure)
+    based on density.
+
+    Parameters
+    ----------
+    rho : np.ndarray
+        Density log [kg/m3].
+    tvd_msl : np.ndarray
+        Vertical depth log [m].
+    water_depth : float
+        Down to this point the difference between formation pressure and overburden pressure shall be zero [m].
+    p_form : float
+        Formation pressure [Pa].
+    tvd_p_form : float
+        Depth of formation pressure point [m].
+    n: float
+        Biot coefficient [unitless].
+
+    Returns
+    -------
+    tuple
+        p_eff, p_lith : np.ndarray.
+        p_eff [Pa] - effective pressure,
+        p_lith [Pa] - overburden pressure.
+    """
+
+    # Standard brine density with salinity 40000 ppm, 2 MPa and 4 deg. C
+    rho_brine = 1.03e3
+    # Gravity constant
+    g = 9.80665
+    # Input log length
+    log_length = len(rho)
+
+    # Allocate output logs
+    p_eff = np.ones(log_length) * np.nan
+    p_lith = np.ones(log_length) * np.nan
+
+    # Does the depth log start at, above or below the sea bottom? We want it to
+    # start at sea bottom, so we get rid of values above this point.
+    # Also, as the tvd log normally is calculated by calling application, there can be
+    # undefined values, flagged as negative or NaN
+    idx = np.ones_like(rho, dtype=bool)
+    idx_inf_nan = np.any(
+        [np.isnan(rho), np.isinf(rho), np.isnan(tvd_msl), np.isinf(tvd_msl)], axis=0
+    )
+    idx[idx_inf_nan] = False
+    idx[~idx_inf_nan] = np.logical_and(
+        tvd_msl[~idx_inf_nan] >= water_depth, rho[~idx_inf_nan] > 0
+    )
+
+    # We need a starting point for pressure at water bottom - use a standard
+    # density value
+    p_wb = g * rho_brine * water_depth
+
+    # p_form is a single value. No functionality is added at present to handle p_form in log version
+    # Find which depth in the log that matches the calibration point best
+    calib_point = np.argmin(abs(tvd_msl[idx] - tvd_p_form))
+
+    # Overburden pressure
+    dz = np.diff(tvd_msl[idx])
+    # Append one sample to match the density log length
+    dz = np.append(dz, dz[-1])
+
+    # Find a starting point for the litho pressure at the start of the depth log
+    # Density at water bottom is assumed to be for a sand with 40% porosity. Take the average
+    # of this and the first observation of density log
+    ave_dens = 0.5 * ((2650 * 0.6 + rho_brine * 0.4) + rho[0])
+    p_lith_start = ave_dens * g * (tvd_msl[0] - water_depth)
+
+    # Estimate the overburden pressure as the gravity of the cumulative bulk
+    # density plus the calculated starting point and the fluid pressure at sea bottom
+    p_lith[idx] = np.cumsum(g * dz * rho[idx]) + p_lith_start + p_wb
+
+    # Find the effective/differential pressure at the calibration point
+    p_eff_calib = p_lith[idx][calib_point] - n * p_form
+    # In the absence of any better alternative - make a linear interpolation
+    # from zero at water bottom to the calculated effective pressure at the
+    # calibration point
+    p_eff[idx] = np.interp(tvd_msl[idx], [water_depth, tvd_p_form], [0, p_eff_calib])
+
+    p_lith[idx] = np.interp(tvd_msl[idx], tvd_msl[idx], p_lith[idx])
+
+    return p_eff, p_lith

rock_physics_open/equinor_utilities/various_utilities/reflectivity.py

@@ -0,0 +1,85 @@
+import numpy as np
+
+from rock_physics_open.equinor_utilities import gen_utilities, std_functions
+
+
+def reflectivity(vp_inp, vs_inp, rho_inp, theta=0.0, k=2.0, model="AkiRichards"):
+    """
+    Reflectivity model according to Aki and Richards or Smith and Gidlow for weak contrasts
+    and angles less than critical angle.
+
+    In this function it is not allowed to have any missing values in the input logs.
+    Instead of interpolating here without the user knowing, raise an input value
+    exception and leave it to the user to provide complete logs.
+
+    Parameters
+    ----------
+    vp_inp : np.ndarray
+        Compressional wave velocity [m/s].
+    vs_inp : np.ndarray
+        Shear wave velocity [m/s].
+    rho_inp : np.ndarray
+        Bulk density [kg/m^3].
+    theta : float
+        Incidence angle [radians] (default value 0).
+    k : float
+        Background Vp/Vs ratio [ratio] (default value 2.0).
+    model : str
+        One of 'AkiRichards' (default) or 'SmithGidlow'.
+
+    Returns
+    -------
+    tuple
+        refl_coef, idx_inp : np.ndarray.
+        refl_coef: reflection coefficient [ratio],
+        idx_inp: index to accepted part of the input arrays [bool].
+    """
+
+    vp, vs, rho, theta, k = gen_utilities.dim_check_vector(
+        (vp_inp, vs_inp, rho_inp, theta, k)
+    )
+
+    idx_inp, (vp, vs, rho, theta, k) = gen_utilities.filter_input_log(
+        [vp, vs, rho, theta, k], positive=True
+    )
+
+    if np.any(~idx_inp):
+        # Only NaNs at the start or end? Find the first and last valid sample and check
+        # if there are any invalid samples in between
+        first_samp = np.where(idx_inp)[0][0]
+        last_samp = np.where(idx_inp)[0][-1]
+        if np.any(~idx_inp[first_samp : last_samp + 1]):
+            # Find the culprit(s)
+            idx_vp = gen_utilities.filter_input_log(
+                [vp_inp[first_samp : last_samp + 1]], positive=True
+            )[0]
+            idx_vs = gen_utilities.filter_input_log(
+                [vs_inp[first_samp : last_samp + 1]], positive=True
+            )[0]
+            idx_rho = gen_utilities.filter_input_log(
+                [rho_inp[first_samp : last_samp + 1]], positive=True
+            )[0]
+            log_str = (
+                int(np.any(~idx_vp)) * "Vp, "
+                + int(np.any(~idx_vs)) * "Vs, "
+                + int(np.any(~idx_rho)) * "Rho, "
+            )
+            pl_str = (
+                (int(np.any(~idx_vp)) + int(np.any(~idx_vs)) + int(np.any(~idx_rho)))
+                > 1
+            ) * "s"
+            raise ValueError(
+                "{0:} reflectivity: Missing or illegal values in input log{1:}: {2:}interpolation of input log{1:} "
+                "is needed\n".format(model, log_str, pl_str)
+            )
+
+    if model == "AkiRichards":
+        refl_coef = std_functions.aki_richards(vp, vs, rho, theta, k)
+    elif model == "SmithGidlow":
+        refl_coef = std_functions.smith_gidlow(vp, vs, rho, theta, k)
+    else:
+        raise ValueError(
+            f'{__file__}: unknown model: {model}, should be one of "AkiRichards", "SmithGidlow"'
+        )
+
+    return refl_coef, idx_inp

rock_physics_open/equinor_utilities/various_utilities/timeshift.py

@@ -0,0 +1,91 @@
+import numpy as np
+
+
+def time_shift_pp(tvd, vp_base, vp_mon, multiplier):
+    """
+    Cumulative time shift calculation for 4D case. According to Equinor standard
+    the time shift is negative for an increase in velocity from base to monitor
+    survey.
+
+    Parameters
+    ----------
+    tvd : np.ndarray
+        True vertical depth along wellbore [m].
+    vp_base : np.ndarray
+        Initial Vp [m/s].
+    vp_mon : np.ndarray
+        vp at time of monitor survey [m/s].
+    multiplier : int
+        Time shift multiplier.
+
+    Returns
+    -------
+    tuple
+        owt_pp_shift, twt_pp_shift : np.ndarray.
+        owt_pp_shift: one way time shift [ms],
+        twt_pp_shift: two way time shift [ms].
+
+    Notes
+    -----
+    Original function by Sascha Bussat, Equinor
+    Ported to Python by Harald Flesche, Equinor 2016.
+
+    """
+    dx = np.diff(tvd)
+    dx = np.append(dx, dx[-1])
+
+    time_base = np.cumsum(dx / vp_base)
+    time_monitor = np.cumsum(dx / vp_mon)
+
+    owt_pp_shift = (time_monitor - time_base) * 1000 * multiplier
+    twt_pp_shift = 2 * owt_pp_shift
+
+    return owt_pp_shift, twt_pp_shift
+
+
+def time_shift_ps(tvd, vp_base, vp_mon, vs_base, vs_mon, multiplier):
+    """
+    Cumulative time shift calculation for 4D case. According to Equinor standard
+    the time shift is negative for an increase in velocity from base to monitor
+    survey.
+
+    Parameters
+    ----------
+    tvd : np.ndarray
+        True vertical depth along wellbore [m].
+    vp_base : np.ndarray
+        Initial vp [m/s].
+    vp_mon : np.ndarray
+        vs at time of monitor survey [m/s].
+    vs_base : np.ndarray
+        Initial vp [m/s].
+    vs_mon : np.ndarray
+        vs at time of monitor survey [m/s].
+    multiplier : int
+        Time shift multiplier.
+
+    Returns
+    -------
+    np.ndarray
+        twt_ps_shift: two way time shift [ms]
+
+    Notes
+    -----
+    Original function by Sascha Bussat, Equinor
+    Ported to Python by Harald Flesche, Equinor 2016.
+
+    """
+    dx = np.diff(tvd)
+    dx = np.append(dx, dx[-1])
+
+    time_base_vp = np.cumsum(dx / vp_base)
+    time_monitor_vp = np.cumsum(dx / vp_mon)
+
+    time_base_vs = np.cumsum(dx / vs_base)
+    time_monitor_vs = np.cumsum(dx / vs_mon)
+
+    return (
+        ((time_monitor_vp - time_base_vp) + (time_monitor_vs - time_base_vs))
+        * 1000
+        * multiplier
+    )