rock-physics-open 0.2.3__py3-none-any.whl → 0.3.0__py3-none-any.whl

rock_physics_open/equinor_utilities/machine_learning_utilities/sigmoidal_model.py

@@ -1,188 +1,237 @@
+from __future__ import annotations
+
 import pickle
-from io import BufferedIOBase
-from typing import Union
+from typing import Any
 
 import numpy as np
 
+from .base_pressure_model import BasePressureModel
+
+
+class SigmoidalPressureModel(BasePressureModel):
+    """
+    Sigmoidal pressure sensitivity model for velocity prediction.
+
+    Uses nested sigmoid functions: velocity amplitude varies with porosity,
+    and velocity varies sigmoidally with effective pressure using the amplitude.
+
+    Input format (n,3): [porosity, p_eff_in_situ, p_eff_depleted]
+
+    The model applies two sigmoid transformations:
+    1. Porosity -> velocity amplitude using phi_model parameters
+    2. Effective pressure -> velocity using p_eff_model parameters and amplitude
+    """
 
-class Sigmoid:
     def __init__(
         self,
-        amplitude: float = None,
-        median_point: float = None,
-        x_scaling: float = None,
-        bias: float = None,
-        description="",
+        phi_amplitude: float,
+        phi_median_point: float,
+        phi_x_scaling: float,
+        phi_bias: float,
+        p_eff_median_point: float,
+        p_eff_x_scaling: float,
+        p_eff_bias: float,
+        model_max_pressure: float | None = None,
+        description: str = "",
     ):
-        self._amplitude = amplitude
-        self._median_point = median_point
-        self._x_scaling = x_scaling
-        self._bias = bias
-        self._description = description
-
-    def todict(self):
-        return {
-            "amplitude": self._amplitude,
-            "median_point": self._median_point,
-            "x_scaling": self._x_scaling,
-            "bias": self._bias,
-            "description": self._description,
-        }
+        """
+        Initialize sigmoidal pressure model.
+
+        Parameters
+        ----------
+        phi_amplitude : float
+            Amplitude parameter for porosity sigmoid [m/s].
+        phi_median_point : float
+            Median point for porosity sigmoid [fraction].
+        phi_x_scaling : float
+            X-scaling parameter for porosity sigmoid [unitless].
+        phi_bias : float
+            Bias parameter for porosity sigmoid [m/s].
+        p_eff_median_point : float
+            Median point for pressure sigmoid [Pa].
+        p_eff_x_scaling : float
+            X-scaling parameter for pressure sigmoid [1/Pa].
+        p_eff_bias : float
+            Bias parameter for pressure sigmoid [m/s].
+        model_max_pressure : float | None
+            Maximum pressure for predict_max method [Pa].
+        description : str
+            Model description.
+        """
+        super().__init__(model_max_pressure, description)
+        # Porosity model parameters
+        self._phi_amplitude = phi_amplitude
+        self._phi_median_point = phi_median_point
+        self._phi_x_scaling = phi_x_scaling
+        self._phi_bias = phi_bias
+        # Pressure model parameters
+        self._p_eff_median_point = p_eff_median_point
+        self._p_eff_x_scaling = p_eff_x_scaling
+        self._p_eff_bias = p_eff_bias
 
     @property
-    def amplitude(self):
-        return self._amplitude
+    def phi_amplitude(self) -> float:
+        """Porosity sigmoid amplitude."""
+        return self._phi_amplitude
 
     @property
-    def median_point(self):
-        return self._median_point
+    def phi_median_point(self) -> float:
+        """Porosity sigmoid median point."""
+        return self._phi_median_point
 
     @property
-    def x_scaling(self):
-        return self._x_scaling
+    def phi_x_scaling(self) -> float:
+        """Porosity sigmoid x-scaling."""
+        return self._phi_x_scaling
 
     @property
-    def bias(self):
-        return self._bias
+    def phi_bias(self) -> float:
+        """Porosity sigmoid bias."""
+        return self._phi_bias
 
     @property
-    def description(self):
-        return self._description
-
-    def predict(self, x):
-        if isinstance(x, list):
-            x = np.array(x)
-        if not self._valid():
-            return None
-        return (
-            self._amplitude / (1 + np.exp(-self._x_scaling * (x - self._median_point)))
-            + self._bias
-        )
-
-    def predict_amp(self, x, amp):
-        if isinstance(x, list):
-            x = np.array(x)
-        if isinstance(amp, list):
-            amp = np.array(amp)
-        if not self._valid(variant="amp"):
-            return None
-        return (
-            amp / (1 + np.exp(-self._x_scaling * (x - self._median_point))) + self._bias
-        )
-
-    @classmethod
-    def save(cls, file):
-        with open(file, "wb") as f_out:
-            pickle.dump(cls, f_out)
-
-    @classmethod
-    def load(cls, file):
-        with open(file, "rb") as f_in:
-            return pickle.load(f_in)
-
-    def _valid(self, variant=None):
-        if variant is None and self.amplitude is None:
-            raise ValueError('object field "variant" is not set')
-        if self.median_point is None:
-            raise ValueError('object field "median_point" is not set')
-        if self.x_scaling is None:
-            raise ValueError('object field "x_scaling" is not set')
-        if self.bias is None:
-            raise ValueError('object field "bias" is not set')
-        return True
-
-
-class CarbonateSigmoidalPressure:
-    def __init__(
-        self,
-        phi_model: Union[dict, Sigmoid] = None,
-        p_eff_model: Union[dict, Sigmoid] = None,
-    ):
-        if isinstance(phi_model, Sigmoid):
-            self._phi_model = phi_model
-        elif isinstance(phi_model, dict):
-            self._phi_model = Sigmoid(**phi_model)
-        else:
-            self._phi_model = None
-        if isinstance(p_eff_model, Sigmoid):
-            self._p_eff_model = p_eff_model
-        elif isinstance(p_eff_model, dict):
-            self._p_eff_model = Sigmoid(**p_eff_model)
-        else:
-            self._p_eff_model = None
+    def p_eff_median_point(self) -> float:
+        """Pressure sigmoid median point."""
+        return self._p_eff_median_point
 
     @property
-    def phi_model(self):
-        return self._phi_model
-
-    @phi_model.setter
-    def phi_model(self, phi_mod):
-        if isinstance(phi_mod, Sigmoid):
-            self._phi_model = phi_mod
-        else:
-            raise ValueError(
-                f"{type(self)}: expected input Sigmoid object, received {type(phi_mod)}"
-            )
+    def p_eff_x_scaling(self) -> float:
+        """Pressure sigmoid x-scaling."""
+        return self._p_eff_x_scaling
 
     @property
-    def p_eff_model(self):
-        return self._p_eff_model
-
-    @p_eff_model.setter
-    def p_eff_model(self, p_eff_mod):
-        if isinstance(p_eff_mod, Sigmoid):
-            self._p_eff_model = p_eff_mod
-        else:
+    def p_eff_bias(self) -> float:
+        """Pressure sigmoid bias."""
+        return self._p_eff_bias
+
+    def validate_input(self, inp_arr: np.ndarray) -> np.ndarray:
+        """
+        Validate input for sigmoidal model.
+
+        Parameters
+        ----------
+        inp_arr : np.ndarray
+            Input array to validate.
+
+        Returns
+        -------
+        np.ndarray
+            Validated input array.
+
+        Raises
+        ------
+        ValueError
+            If input format is invalid.
+        """
+        if not isinstance(inp_arr, np.ndarray):
+            raise ValueError("Input must be numpy ndarray.")
+        if inp_arr.ndim != 2 or inp_arr.shape[1] != 3:
             raise ValueError(
-                f"{type(self)}: expected input Sigmoid object, received {type(p_eff_mod)}"
+                "Input must be (n,3): [porosity, p_eff_in_situ, p_eff_depleted]"
             )
-
-    def predict(self, inp_arr: np.ndarray) -> np.ndarray:
-        # Don't save any of the intermediate calculations, only return the difference between the effective pressure
-        # cases. The method name is set to be the same as for other machine learning models
-        self._validate_input(inp_arr)
-        velocity_amp = self._phi_model.predict(inp_arr[:, 0].flatten())
-        velocity_init = self._p_eff_model.predict_amp(
-            inp_arr[:, 1].flatten(), velocity_amp
+        return inp_arr
+
+    def _sigmoid_phi(self, phi: np.ndarray) -> np.ndarray:
+        """
+        Calculate velocity amplitude from porosity using sigmoid function.
+
+        Parameters
+        ----------
+        phi : np.ndarray
+            Porosity values [fraction].
+
+        Returns
+        -------
+        np.ndarray
+            Velocity amplitude values [m/s].
+        """
+        return (
+            self._phi_amplitude
+            / (1 + np.exp(-self._phi_x_scaling * (phi - self._phi_median_point)))
+            + self._phi_bias
         )
-        velocity_depl = self._p_eff_model.predict_amp(
-            inp_arr[:, 2].flatten(), velocity_amp
+
+    def _sigmoid_p_eff(self, p_eff: np.ndarray, amplitude: np.ndarray) -> np.ndarray:
+        """
+        Calculate velocity from effective pressure using sigmoid function with amplitude.
+
+        Parameters
+        ----------
+        p_eff : np.ndarray
+            Effective pressure values [Pa].
+        amplitude : np.ndarray
+            Velocity amplitude values [m/s].
+
+        Returns
+        -------
+        np.ndarray
+            Velocity values [m/s].
+        """
+        return (
+            amplitude
+            / (1 + np.exp(-self._p_eff_x_scaling * (p_eff - self._p_eff_median_point)))
+            + self._p_eff_bias
         )
-        return velocity_depl - velocity_init
 
     def predict_abs(self, inp_arr: np.ndarray, case: str = "in_situ") -> np.ndarray:
-        # Method for access to absolute results, not just the difference
-        self._validate_input(inp_arr)
-        velocity_amp = self._phi_model.predict(inp_arr[:, 0].flatten())
-        if case == "in_situ":
-            return self._p_eff_model.predict_amp(inp_arr[:, 1].flatten(), velocity_amp)
-        return self._p_eff_model.predict_amp(inp_arr[:, 2].flatten(), velocity_amp)
-
-    def _validate_input(self, input_array):
-        if not isinstance(input_array, np.ndarray):
-            raise ValueError(
-                f"{type(input_array)}: should be numpy array with shape n x 3"
-            )
-        if not ((input_array.ndim == 2) and (input_array.shape[1] == 3)):
-            raise ValueError(
-                f'{type(self)}: Input array should be of shape n x 3, with columns in sequence "PHIT", '
-                f'"P_EFF_in_situ" and "P_EFF_depleted"'
-            )
-
-    def todict(self):
+        """
+        Calculate absolute velocity for specified pressure case.
+
+        Parameters
+        ----------
+        inp_arr : np.ndarray
+            Validated input array (n,3).
+        case : str
+            Pressure case: "in_situ" or "depleted".
+
+        Returns
+        -------
+        np.ndarray
+            Velocity values [m/s].
+        """
+        arr = self.validate_input(inp_arr)
+
+        phi = arr[:, 0]
+        p_in_situ = arr[:, 1]
+        p_depleted = arr[:, 2]
+
+        # Calculate velocity amplitude from porosity
+        velocity_amplitude = self._sigmoid_phi(phi)
+
+        # Select pressure based on case
+        p_eff = p_in_situ if case == "in_situ" else p_depleted
+
+        # Calculate velocity from effective pressure and amplitude
+        return self._sigmoid_p_eff(p_eff, velocity_amplitude)
+
+    def todict(self) -> dict[str, Any]:
+        """Convert model to dictionary."""
         return {
-            "phi_model": self._phi_model.todict(),
-            "p_eff_model": self._p_eff_model.todict(),
+            "phi_amplitude": self._phi_amplitude,
+            "phi_median_point": self._phi_median_point,
+            "phi_x_scaling": self._phi_x_scaling,
+            "phi_bias": self._phi_bias,
+            "p_eff_median_point": self._p_eff_median_point,
+            "p_eff_x_scaling": self._p_eff_x_scaling,
+            "p_eff_bias": self._p_eff_bias,
+            "model_max_pressure": self._model_max_pressure,
+            "description": self._description,
         }
 
-    def save(self, file: Union[str, BufferedIOBase]):
-        with open(file, "wb") as f_out:
-            pickle.dump(self.todict(), f_out)
-
     @classmethod
-    def load(cls, file: Union[str, BufferedIOBase]):
+    def load(cls, file: str | bytes) -> "SigmoidalPressureModel":
+        """Load sigmoidal model from pickle file."""
         with open(file, "rb") as f_in:
-            load_dict = pickle.load(f_in)
-            return cls(
-                phi_model=load_dict["phi_model"], p_eff_model=load_dict["p_eff_model"]
-            )
+            d = pickle.load(f_in)
+
+        return cls(
+            phi_amplitude=d["phi_amplitude"],
+            phi_median_point=d["phi_median_point"],
+            phi_x_scaling=d["phi_x_scaling"],
+            phi_bias=d["phi_bias"],
+            p_eff_median_point=d["p_eff_median_point"],
+            p_eff_x_scaling=d["p_eff_x_scaling"],
+            p_eff_bias=d["p_eff_bias"],
+            model_max_pressure=d["model_max_pressure"],
+            description=d["description"],
+        )

rock_physics_open/equinor_utilities/optimisation_utilities/__init__.py

@@ -0,0 +1,19 @@
+from .opt_subst_utilities import (
+    gen_mod_routine,
+    gen_opt_routine,
+    gen_sub_routine,
+    load_opt_params,
+    opt_param_info,
+    opt_param_to_ascii,
+    save_opt_params,
+)
+
+__all__ = [
+    "gen_mod_routine",
+    "gen_sub_routine",
+    "gen_opt_routine",
+    "opt_param_to_ascii",
+    "opt_param_info",
+    "save_opt_params",
+    "load_opt_params",
+]

rock_physics_open/equinor_utilities/snapshot_test_utilities/compare_snapshots.py

@@ -1,7 +1,6 @@
 import inspect
 import math
 import re
-from typing import Union
 from warnings import warn
 
 import numpy as np
@@ -13,7 +12,7 @@ from .snapshots import get_snapshot_name
 
 
 def compare_snapshots(
-    test_results: Union[np.ndarray, tuple, DataFrame],
+    test_results: np.ndarray | tuple | DataFrame,
     saved_results: tuple,
     name_arr=None,
     display_results: bool = False,

rock_physics_open/fluid_models/brine_model/brine_properties.py

@@ -14,16 +14,16 @@ def brine_properties(
     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) of oil
-    :param temperature: Temperature (Celsius) of oil.
+    :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: vel_b [m/s], den_b [kg/m^3], k_b [Pa]
+    :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 * 1e-6, salinity * 1e-6)
-    den_b = brine_density(temperature, pressure * 1e-6, salinity * 1e-6) * 1000
+    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
 
@@ -35,19 +35,27 @@ def brine_density(
 ) -> np.ndarray | float:
     """
     density of sodium chloride solutions, equation 27 in Batzle & Wang [1].
-    :param salinity: Salinity of solution as weight fraction (ppm/1000000) of
-        sodium chloride.
-    :param pressure: Pressure (MPa) of oil
-    :param temperature: Temperature (Celsius) of oil.
-    :return: density of solution in g/cc.
+    :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]],
     ]
-    return water_density(temperature, pressure) + salinity * polyval3d(
-        salinity, temperature, pressure, coefficients
+    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(
@@ -58,12 +66,16 @@ def brine_primary_velocity(
     """
     Primary wave velocity of sodium chloride solutions, equation 29 in Batzle & Wang [1]
 
-    :param salinity: Salinity of solution as weight fraction (ppm/1000000) of
-        sodium chloride.
-    :param pressure: Pressure (MPa) of oil
-    :param temperature: Temperature (Celsius) of oil.
+    :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
@@ -77,8 +89,8 @@ def brine_primary_velocity(
     coefficients[1, 0, 2] = 0.16
     coefficients[2, 0, 0] = -820
 
-    return water_primary_velocity(temperature, pressure) + salinity * polyval3d(
-        sqrt(salinity), temperature, pressure, coefficients
+    return water_primary_velocity(temperature, pressure) + salinity_frac * polyval3d(
+        sqrt(salinity_frac), temperature, pressure_mpa, coefficients
     )
 
 
@@ -88,17 +100,20 @@ def water_density(
 ) -> np.ndarray | float:
     """
     Density of water,, equation 27a in Batzle & Wang [1].
-    :param pressure: Pressure (MPa) of oil
-    :param temperature: Temperature (Celsius) of oil.
-    :return: Density of water in g/cc.
+    :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, coefficients)
+    return polyval2d(temperature, pressure_mpa, coefficients) * 1000.0
 
 
 def water_primary_velocity(
@@ -107,11 +122,14 @@ def water_primary_velocity(
 ) -> np.ndarray | float:
     """
     Primary wave velocity of water, table 1 and equation 28 in Batzle & Wang [1].
-    :param pressure: Pressure (MPa) of oil
-    :param temperature: Temperature (Celsius) of oil.
+    :param pressure: Pressure [Pa]
+    :param temperature: Temperature [°C]
     :return: primary wave velocity of water in m/s.
     """
-    if np.any(pressure > 100):
+    # 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"
@@ -125,19 +143,36 @@ def water_primary_velocity(
         [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, coefficients)
+    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) of oil
-    :param temperature: Temperature (Celsius) of oil.
-    :return: water_density [kg/m^3], water_velocity [m/s], water_bulk_modulus [Pa]
+    :param pressure: Pressure [Pa]
+    :param temperature: Temperature [°C]
+    :return: water_velocity [m/s], water_density [kg/m^3], water_bulk_modulus [Pa]
     """
-    pressure_mpa = pressure * 1.0e-6
-    water_den = water_density(temperature, pressure_mpa)
-    water_vel = water_primary_velocity(temperature, pressure_mpa)
-    water_k = water_vel**2 * water_den * 1000.0
-    return water_den, water_vel, water_k
+    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)
+    )