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

rock_physics_open/equinor_utilities/various_utilities/display_result_statistics.py

@@ -0,0 +1,90 @@
+import os
+import sys
+from collections.abc import Sequence
+from typing import Any, Literal, cast
+
+import numpy as np
+import numpy.typing as npt
+
+
+def disp_result_stats(
+    title: str, arr: Sequence[Any], names_arr: list[str], **kwargs: Any
+) -> None:
+    """
+    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: Tk, no_rows: int, no_cols: int, info: npt.NDArray[Any]
+        ):
+            # code for creating table
+            str_len = np.vectorize(len)
+            text_justify: list[Literal["center", "left"]] = ["center", "left"]
+            text_weight: list[str] = ["bold", "normal"]
+            for i in range(no_rows):
+                weigh = text_weight[cast(int, np.sign(i))]
+                for j in range(no_cols):
+                    just = text_justify[cast(int, np.sign(i))]
+                    max_len = np.max(str_len(info[:, j]))
+                    self.e: Entry = 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.wm_iconphoto(True, logo)
+
+    root.mainloop()

rock_physics_open/equinor_utilities/various_utilities/gassmann_dry_mod.py

@@ -0,0 +1,56 @@
+import numpy as np
+import numpy.typing as npt
+
+from rock_physics_open.equinor_utilities import std_functions
+
+
+def gassmann_dry_model(
+    k_min: npt.NDArray[np.float64],
+    k_fl: npt.NDArray[np.float64],
+    rho_fl: npt.NDArray[np.float64],
+    k_sat: npt.NDArray[np.float64],
+    mu: npt.NDArray[np.float64],
+    rho_sat: npt.NDArray[np.float64],
+    por: npt.NDArray[np.float64],
+) -> tuple[
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+]:
+    """
+    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
+        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,56 @@
+import numpy as np
+import numpy.typing as npt
+
+from rock_physics_open.equinor_utilities import std_functions
+
+
+def gassmann_model(
+    k_min: npt.NDArray[np.float64],
+    k_fl: npt.NDArray[np.float64],
+    rho_fl: npt.NDArray[np.float64],
+    k_dry: npt.NDArray[np.float64],
+    mu: npt.NDArray[np.float64],
+    rho_dry: npt.NDArray[np.float64],
+    por: npt.NDArray[np.float64],
+) -> tuple[
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+]:
+    """
+    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
+        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,64 @@
+import numpy as np
+import numpy.typing as npt
+
+from rock_physics_open.equinor_utilities import std_functions
+
+
+def gassmann_sub_model(
+    k_min: npt.NDArray[np.float64],
+    k_fl_orig: npt.NDArray[np.float64],
+    rho_fl_orig: npt.NDArray[np.float64],
+    k_fl_sub: npt.NDArray[np.float64],
+    rho_fl_sub: npt.NDArray[np.float64],
+    k_sat_orig: npt.NDArray[np.float64],
+    mu: npt.NDArray[np.float64],
+    rho_sat_orig: npt.NDArray[np.float64],
+    por: npt.NDArray[np.float64],
+) -> tuple[
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+]:
+    """
+    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
+        Substituted 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
+        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,59 @@
+import numpy as np
+import numpy.typing as npt
+
+from rock_physics_open.equinor_utilities import std_functions
+
+
+def hs_average(
+    k1: npt.NDArray[np.float64],
+    mu1: npt.NDArray[np.float64],
+    rhob1: npt.NDArray[np.float64],
+    k2: npt.NDArray[np.float64],
+    mu2: npt.NDArray[np.float64],
+    rhob2: npt.NDArray[np.float64],
+    f: npt.NDArray[np.float64],
+) -> tuple[
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+]:
+    """
+    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,96 @@
+import numpy as np
+import numpy.typing as npt
+
+
+def pressure(
+    rho: npt.NDArray[np.float64],
+    tvd_msl: npt.NDArray[np.float64],
+    water_depth: float,
+    p_form: float,
+    tvd_p_form: float,
+    n: float,
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    """
+    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,101 @@
+from typing import Literal, cast
+
+import numpy as np
+import numpy.typing as npt
+
+from rock_physics_open.equinor_utilities import gen_utilities, std_functions
+
+
+def reflectivity(
+    vp_inp: npt.NDArray[np.float64],
+    vs_inp: npt.NDArray[np.float64],
+    rho_inp: npt.NDArray[np.float64],
+    theta: float = 0.0,
+    k: float = 2.0,
+    model: Literal["AkiRichards", "SmithGidlow"] = "AkiRichards",
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.bool_]]:
+    """
+    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_ = cast(
+        list[npt.NDArray[np.float64]],
+        gen_utilities.dim_check_vector((vp_inp, vs_inp, rho_inp, theta, k)),
+    )
+
+    idx_inp, (vp, vs, rho, theta_, k_) = cast(
+        tuple[npt.NDArray[np.bool_], list[npt.NDArray[np.float64]]],
+        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(  # pyright: ignore[reportUnreachable] | Kept for backward compatibility
+            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,104 @@
+import numpy as np
+import numpy.typing as npt
+
+
+def time_shift_pp(
+    tvd: npt.NDArray[np.float64],
+    vp_base: npt.NDArray[np.float64],
+    vp_mon: npt.NDArray[np.float64],
+    multiplier: int,
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    """
+    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: npt.NDArray[np.float64],
+    vp_base: npt.NDArray[np.float64],
+    vp_mon: npt.NDArray[np.float64],
+    vs_base: npt.NDArray[np.float64],
+    vs_mon: npt.NDArray[np.float64],
+    multiplier: int,
+) -> npt.NDArray[np.float64]:
+    """
+    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
+    )