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

rock_physics_open/equinor_utilities/various_utilities/vp_vs_rho_set_statistics.py

@@ -0,0 +1,170 @@
+import os
+from typing import Literal, cast
+
+import numpy as np
+import numpy.typing as npt
+import pandas as pd
+from sklearn.metrics import r2_score
+
+from .display_result_statistics import disp_result_stats
+
+
+def vp_vs_rho_stats(
+    vp_observed: npt.NDArray[np.float64] | list[npt.NDArray[np.float64]],
+    vs_observed: npt.NDArray[np.float64] | list[npt.NDArray[np.float64]],
+    rho_observed: npt.NDArray[np.float64] | list[npt.NDArray[np.float64]],
+    vp_estimated: npt.NDArray[np.float64] | list[npt.NDArray[np.float64]],
+    vs_estimated: npt.NDArray[np.float64] | list[npt.NDArray[np.float64]],
+    rho_estimated: npt.NDArray[np.float64] | list[npt.NDArray[np.float64]],
+    fname: str,
+    estimated_set_names: str | list[str],
+    well_names: str | list[str],
+    file_mode: Literal["a", "w"] = "a",
+    disp_results: bool = True,
+) -> None:
+    """
+    Utility to estimate statistics between vp-vs-rho sets - observed and estimated values. The results are displayed
+    on screen (optional) and saved to a .csv file. If the file exists, the results will be appended.
+    The statistics consists of RAE (relative absolute error) [fraction], RRMSE (relative root mean squared error)
+    [fraction] and R^2 (coefficient of determination) [fraction].
+
+
+    Parameters
+    ----------
+    vp_observed : np.ndarray or list
+        Observed vp [m/s].
+    vs_observed : np.ndarray or list
+        Observed vs [m/s].
+    rho_observed : np.ndarray or list
+        Observed density [kg/m^3].
+    vp_estimated : np.ndarray or list
+        Estimated vp [m/s].
+    vs_estimated : np.ndarray or list
+        Estimated vs [m/s].
+    rho_estimated : np.ndarray or list
+        Estimated density [kg/m^3].
+    fname : str
+        File name for saved results.
+    estimated_set_names : str or list
+        Name of the estimated vp-vs-rho set(s).
+    well_names : str or list
+        Well name of the vp-vs-rho set(s).
+    file_mode : str
+        File open mode, default append.
+    disp_results : bool
+        Display results on screen.
+    """
+    if isinstance(estimated_set_names, str):
+        estimated_set_names = [estimated_set_names]
+    if isinstance(well_names, str):
+        well_names = [well_names]
+
+    _verify(
+        vp_observed,
+        vs_observed,
+        rho_observed,
+        vp_estimated,
+        vs_estimated,
+        rho_estimated,
+        set_names=estimated_set_names,
+        well_names=well_names,
+        file_mode=file_mode,
+    )
+
+    est_frame_columns = [
+        "Well",
+        "Vp RMAE",
+        "Vp RRMSE",
+        "Vp R2",
+        "Vs RMAE",
+        "Vs RRMSE",
+        "Vs R2",
+        "Rho RMAE",
+        "Rho RRMSE",
+        "Rho R2",
+    ]
+    est_frame = pd.DataFrame(columns=est_frame_columns, index=estimated_set_names)
+    est_frame.index.name = "Estimated set name"
+    est_frame.iloc[:, 0] = well_names  # pyright: ignore[reportArgumentType]
+
+    # If inputs are found to satisfy expectations in _verify, and they are numpy arrays, cast to lists, and run through
+    if isinstance(vp_observed, np.ndarray):
+        vp_observed = [vp_observed]
+    if isinstance(vs_observed, np.ndarray):
+        vs_observed = [vs_observed]
+    if isinstance(rho_observed, np.ndarray):
+        rho_observed = [rho_observed]
+    if isinstance(vp_estimated, np.ndarray):
+        vp_estimated = [vp_estimated]
+    if isinstance(vs_estimated, np.ndarray):
+        vs_estimated = [vs_estimated]
+    if isinstance(rho_estimated, np.ndarray):
+        rho_estimated = [rho_estimated]
+
+    for i in range(len(vp_observed)):
+        res: list[float] = []
+        for obs, est in zip(
+            [vp_observed[i], vs_observed[i], rho_observed[i]],
+            [vp_estimated[i], vs_estimated[i], rho_estimated[i]],
+        ):
+            rmae = float(
+                np.mean(np.abs((est.flatten() - obs.flatten()) / obs.flatten()))
+            )
+            rrmse: float = np.sqrt(
+                np.mean(np.square((est.flatten() - obs.flatten()) / obs.flatten()))
+            )
+            r2 = cast(float, r2_score(obs.flatten(), est.flatten()))
+
+            res.append(rmae)
+            res.append(rrmse)
+            res.append(r2)
+
+        res_dict = dict(zip(est_frame_columns[1:], res))
+        est_frame.iloc[i, 1:] = res_dict  # pyright: ignore[reportArgumentType]
+        if disp_results:
+            disp_result_stats(
+                estimated_set_names[i], res, est_frame_columns[1:], values_only=True
+            )
+    # Test if the file already exists. If so, and the file_mode is set to 'a', drop the column headers when writing
+    # the file
+    if os.path.exists(fname) and file_mode == "a":
+        est_frame.to_csv(fname, mode=file_mode, header=False)
+    else:
+        est_frame.to_csv(fname, mode=file_mode)
+
+
+def _verify(
+    *args: npt.NDArray[np.float64] | list[npt.NDArray[np.float64]],
+    set_names: list[str],
+    well_names: list[str],
+    file_mode: Literal["a", "w"],
+):
+    """Verify that arguments are either numpy arrays or lists of numpy arrays.
+    Raises
+    ------
+    ValueError
+        If not np.ndarray or list of such.
+    ValueError
+        If an entry contains NaNs.
+    ValueError
+        If an entry contains Infs.
+    ValueError
+        If mismatch in argument lengths.
+    ValueError
+        If file mode not 'a' or 'w'.
+    """
+    # Verify that args are either numpy arrays or list of arrays
+    for arg in args:
+        if isinstance(arg, np.ndarray):
+            arg = [arg]
+        for this_arg in arg:
+            if not isinstance(this_arg, np.ndarray):  # pyright: ignore[reportUnnecessaryIsInstance] | For backward compatibility
+                raise ValueError(f"{__file__}: input not numpy array: {type(arg)}")
+            if np.any(np.isnan(this_arg)):
+                raise ValueError(f"{__file__}: input contains NaNs")
+            if np.any(np.isinf(this_arg)):
+                raise ValueError(f"{__file__}: input contains Infs")
+        if not len(arg) == len(set_names) == len(well_names):
+            raise ValueError(f"{__file__}: mismatch in argument lengths")
+    if not (file_mode == "a" or file_mode == "w"):
+        raise ValueError(f'{__file__}: file_mode must be one of ["a", "w"]')  # pyright: ignore[reportUnreachable] | For backward compatibility

rock_physics_open/equinor_utilities/various_utilities/vrh_3_min.py

@@ -0,0 +1,83 @@
+import numpy as np
+import numpy.typing as npt
+
+from rock_physics_open.equinor_utilities import std_functions
+
+
+def min_3_voigt_reuss_hill(
+    vp1: npt.NDArray[np.float64],
+    vs1: npt.NDArray[np.float64],
+    rhob1: npt.NDArray[np.float64],
+    f1: npt.NDArray[np.float64],
+    vp2: npt.NDArray[np.float64],
+    vs2: npt.NDArray[np.float64],
+    rhob2: npt.NDArray[np.float64],
+    f2: npt.NDArray[np.float64],
+    vp3: npt.NDArray[np.float64],
+    vs3: npt.NDArray[np.float64],
+    rhob3: npt.NDArray[np.float64],
+    f3: 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],
+]:
+    """
+    Mix of three phases by Voigt-Reuss-Hill model. The fractions should add up to 1 with input of vp, vs and rho.
+
+    Parameters
+    ----------
+    vp1 : np.ndarray
+        Pressure wave velocity of phase 1 [m/s].
+    vs1 : np.ndarray
+        Shear wave velocity of phase 1 [m/s].
+    rhob1 : np.ndarray
+        Bulk density of phase 1 [kg/m^3].
+    f1 : np.ndarray
+        Fraction of phase 1 [fraction].
+    vp2 : np.ndarray
+        Pressure wave velocity of phase 2 [m/s].
+    vs2 : np.ndarray
+        Shear wave velocity of phase 2 [m/s].
+    rhob2 : np.ndarray
+        Bulk density of phase 2 [kg/m^3].
+    f2 : np.ndarray
+        Fraction of phase 2 [fraction].
+    vp3 : np.ndarray
+        Pressure wave velocity of phase 3 [m/s].
+    vs3 : np.ndarray
+        Shear wave velocity of phase 3 [m/s].
+    rhob3 : np.ndarray
+        Bulk density of phase 3 [kg/m^3].
+    f3 : np.ndarray
+        Fraction of phase 3 [fraction].
+
+    Returns
+    -------
+    tuple
+        vp, vs, rhob, ai, vp_vs, k, mu : np.ndarray.
+        vp: pressure wave velocity [m/s], vs: shear wave velocity [m/s], rhob: bulk density [kg/m^3],
+        ai: acoustic impedance [m/s x kg/m^3], vp_vs: velocity ratio [ratio],
+        k: effective bulk modulus [Pa], mu: effective shear modulus [Pa].
+    """
+    k1, mu1 = std_functions.moduli(vp1, vs1, rhob1)
+    k2, mu2 = std_functions.moduli(vp2, vs2, rhob2)
+    k3, mu3 = std_functions.moduli(vp3, vs3, rhob3)
+
+    # Normalise the fractions to make sure they sum to one
+    tot = f1 + f2 + f3
+    f1 = f1 / tot
+    f2 = f2 / tot
+    f3 = f3 / tot
+
+    k, mu = std_functions.multi_voigt_reuss_hill(k1, mu1, f1, k2, mu2, f2, k3, mu3, f3)
+
+    rhob = rhob1 * f1 + rhob2 * f2 + rhob3 * f3
+
+    vp, vs, ai, vp_vs = std_functions.velocity(k, mu, rhob)
+
+    return vp, vs, rhob, ai, vp_vs, k, mu

rock_physics_open/fluid_models/__init__.py

@@ -0,0 +1,9 @@
+from .brine_model import brine_properties
+from .gas_model import gas_properties
+from .oil_model import oil_properties
+
+__all__ = [
+    "brine_properties",
+    "gas_properties",
+    "oil_properties",
+]

rock_physics_open/fluid_models/brine_model/__init__.py

@@ -0,0 +1,5 @@
+from .brine_properties import brine_properties
+
+__all__ = [
+    "brine_properties",
+]

rock_physics_open/fluid_models/brine_model/brine_properties.py

@@ -0,0 +1,178 @@
+import warnings
+
+import numpy as np
+from numpy import sqrt
+from numpy.polynomial.polynomial import polyval2d, polyval3d
+
+
+def brine_properties(
+    temperature: np.ndarray | float,
+    pressure: np.ndarray | float,
+    salinity: np.ndarray | float,
+    p_nacl: np.ndarray | float | None = None,
+    p_kcl: np.ndarray | float | None = None,
+    p_cacl: np.ndarray | float | None = None,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    :param salinity: Salinity of solution as [ppm] of NaCl.
+    :param pressure: Pressure [Pa]
+    :param temperature: Temperature [°C]
+    :param p_nacl: NaCl percentage, for future use
+    :param p_kcl: KCl percentage, for future use
+    :param p_cacl: CaCl percentage, for future use
+    :return: Brine velocity vel_b [m/s], brine density den_b [kg/m^3], brine bulk modulus k_b [Pa]
+    """
+    vel_b = brine_primary_velocity(temperature, pressure, salinity)
+    den_b = brine_density(temperature, pressure, salinity)
+    k_b = vel_b**2 * den_b
+    return vel_b, den_b, k_b
+
+
+def brine_density(
+    temperature: np.ndarray | float,
+    pressure: np.ndarray | float,
+    salinity: np.ndarray | float,
+) -> np.ndarray | float:
+    """
+    density of sodium chloride solutions, equation 27 in Batzle & Wang [1].
+    :param salinity: Salinity of solution in ppm
+    :param pressure: Pressure [Pa]
+    :param temperature: Temperature [°C]
+    :return: density of solution in [kg/m^3].
+    """
+    # Change unit of pressure to MPa
+    pressure_mpa = pressure / 1.0e6
+    # Change unit of salinity to fraction
+    salinity_frac = salinity / 1.0e6
+
+    coefficients = [
+        [[0.668, 3e-4], [8e-5, -13e-6], [3e-6, 0.0]],
+        [[0.44, -24e-4], [-33e-4, 47e-6], [0.0, 0.0]],
+    ]
+    water_den = water_density(temperature, pressure)
+    brine_correction = (
+        salinity_frac
+        * polyval3d(salinity_frac, temperature, pressure_mpa, coefficients)
+        * 1000.0
+    )
+    return water_den + brine_correction
+
+
+def brine_primary_velocity(
+    temperature: np.ndarray | float,
+    pressure: np.ndarray | float,
+    salinity: np.ndarray | float,
+) -> np.ndarray | float:
+    """
+    Primary wave velocity of sodium chloride solutions, equation 29 in Batzle & Wang [1]
+
+    :param salinity: Salinity of solution as [ppm] of sodium chloride
+    :param pressure: Pressure [Pa]
+    :param temperature: Temperature [°C]
+    :return: velocity of solution in m/s.
+    """
+    # Change unit for salinity from ppm to fraction
+    salinity_frac = salinity / 1.0e6
+    # Change the unit for pressure from Pa to MPa
+    pressure_mpa = pressure / 1.0e6
+
+    coefficients = np.zeros((3, 4, 3))
+    coefficients[0, 0, 0] = 1170
+    coefficients[0, 1, 0] = -9.6
+    coefficients[0, 2, 0] = 0.055
+    coefficients[0, 3, 0] = -8.5e-5
+    coefficients[0, 0, 1] = 2.6
+    coefficients[0, 1, 1] = -29e-4
+    coefficients[0, 0, 2] = -0.0476
+    coefficients[1, 0, 0] = 780
+    coefficients[1, 0, 1] = -10
+    coefficients[1, 0, 2] = 0.16
+    coefficients[2, 0, 0] = -820
+
+    return water_primary_velocity(temperature, pressure) + salinity_frac * polyval3d(
+        sqrt(salinity_frac), temperature, pressure_mpa, coefficients
+    )
+
+
+def water_density(
+    temperature: np.ndarray | float,
+    pressure: np.ndarray | float,
+) -> np.ndarray | float:
+    """
+    Density of water,, equation 27a in Batzle & Wang [1].
+    :param pressure: Pressure [Pa]
+    :param temperature: Temperature [°C]
+    :return: Density of water in [kg/m^3].
+    """
+    # Change unit of pressure from Pa to MPa
+    pressure_mpa = pressure / 1.0e6
+
+    coefficients = [
+        [1.0, 489e-6, -333e-9],
+        [-8e-5, -2e-6, -2e-09],
+        [-33e-7, 16e-9, 0.0],
+        [1.75e-9, -13e-12, 0.0],
+    ]
+    return polyval2d(temperature, pressure_mpa, coefficients) * 1000.0
+
+
+def water_primary_velocity(
+    temperature: np.ndarray | float,
+    pressure: np.ndarray | float,
+) -> np.ndarray | float:
+    """
+    Primary wave velocity of water, table 1 and equation 28 in Batzle & Wang [1].
+    :param pressure: Pressure [Pa]
+    :param temperature: Temperature [°C]
+    :return: primary wave velocity of water in m/s.
+    """
+    # Change unit of pressure from Pa to MPa
+    pressure_mpa = pressure / 1.0e6
+
+    if np.any(pressure_mpa > 100):
+        warnings.warn(
+            "Calculations for water velocity is not precise for\n"
+            + "pressure outside [0,100]MPa"
+            + f"pressure given: {pressure}MPa",
+            stacklevel=1,
+        )
+    coefficients = [
+        [1402.85, 1.524, 3.437e-3, -1.197e-5],
+        [4.871, -1.11e-2, 1.739e-4, -1.628e-6],
+        [-4.783e-2, 2.747e-4, -2.135e-6, 1.237e-8],
+        [1.487e-4, -6.503e-7, -1.455e-8, 1.327e-10],
+        [-2.197e-7, 7.987e-10, 5.23e-11, -4.614e-13],
+    ]
+    return polyval2d(temperature, pressure_mpa, coefficients)
+
+
+def water(
+    temperature: np.ndarray | float, pressure: np.ndarray | float
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    :param pressure: Pressure [Pa]
+    :param temperature: Temperature [°C]
+    :return: water_velocity [m/s], water_density [kg/m^3], water_bulk_modulus [Pa]
+    """
+    water_den = water_density(temperature, pressure)
+    water_vel = water_primary_velocity(temperature, pressure)
+    water_k = water_vel**2 * water_den
+    return water_vel, water_den, water_k
+
+
+def brine_viscosity(
+    temperature: np.ndarray | float,
+    salinity: np.ndarray | float,
+) -> np.ndarray | float:
+    """
+    Brine viscosity according to Batzle & Wang [1].
+
+    Based on equation 32.
+    """
+    salinity_frac = salinity / 1.0e6
+    return (
+        0.1
+        + 0.333 * salinity_frac
+        + (1.65 + 91.9 * salinity_frac**3)
+        * np.exp(-(0.42 * (salinity_frac**0.8 - 0.17) ** 2 + 0.045) * temperature**0.8)
+    )

rock_physics_open/fluid_models/gas_model/__init__.py

@@ -0,0 +1,5 @@
+from .gas_properties import gas_properties
+
+__all__ = [
+    "gas_properties",
+]