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

rock_physics_open/equinor_utilities/machine_learning_utilities/polynomial_model.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import pickle
+from typing import Any
+
+import numpy as np
+
+from .base_pressure_model import BasePressureModel
+
+
+class PolynomialPressureModel(BasePressureModel):
+    """
+    Polynomial pressure sensitivity model for velocity prediction.
+
+    Uses polynomial function: v = v0 * P(p_depl) / P(p_in_situ)
+    where P(p) is a polynomial function with specified coefficients.
+
+    Input format (n,3): [velocity, p_eff_in_situ, p_eff_depleted]
+    """
+
+    def __init__(
+        self,
+        weights: list[float],
+        model_max_pressure: float | None = None,
+        description: str = "",
+    ):
+        """
+        Initialize polynomial pressure model.
+
+        Parameters
+        ----------
+        weights : list[float]
+            Polynomial coefficients [unitless]. First element is constant term,
+            second is linear coefficient, etc.
+        model_max_pressure : float | None
+            Maximum pressure for predict_max method [Pa].
+        description : str
+            Model description.
+        """
+        super().__init__(model_max_pressure, description)
+        self._weights = weights
+
+    @property
+    def weights(self) -> list[float]:
+        """Polynomial coefficients."""
+        return self._weights
+
+    def validate_input(self, inp_arr: np.ndarray) -> np.ndarray:
+        """
+        Validate input for polynomial 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(
+                "Input must be (n,3): [velocity, p_eff_in_situ, p_eff_depleted]"
+            )
+        return inp_arr
+
+    def predict_abs(self, inp_arr: np.ndarray, case: str = "in_situ") -> np.ndarray:
+        """
+        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)
+
+        # Validate weights are set
+        if not self._weights:
+            raise ValueError('Field "weights" is not set.')
+
+        vel = arr[:, 0]
+        p_in_situ = arr[:, 1]
+        p_depleted = arr[:, 2]
+
+        # Create polynomial from weights
+        polynomial_expr = np.polynomial.Polynomial(self._weights)
+
+        # Select pressure based on case
+        p_eff = p_in_situ if case == "in_situ" else p_depleted
+
+        # Calculate velocity using polynomial pressure correction
+        return vel * polynomial_expr(p_eff) / polynomial_expr(p_in_situ)
+
+    def todict(self) -> dict[str, Any]:
+        """Convert model to dictionary."""
+        return {
+            "weights": self._weights,
+            "model_max_pressure": self._model_max_pressure,
+            "description": self._description,
+        }
+
+    @classmethod
+    def load(cls, file: str | bytes) -> "PolynomialPressureModel":
+        """Load polynomial model from pickle file."""
+        with open(file, "rb") as f_in:
+            d = pickle.load(f_in)
+
+        return cls(
+            weights=d["weights"],
+            model_max_pressure=d["model_max_pressure"],
+            description=d["description"],
+        )

rock_physics_open/equinor_utilities/machine_learning_utilities/run_regression.py

@@ -108,7 +108,9 @@ def _perform_regression(
     return res_frame
 
 
-def run_regression(inp_df, vp_model_file_name, vs_model_file_name, model_dir=None):
+def run_regression(
+    inp_df, first_model_file_name, second_model_file_name, model_dir=None
+):
     """
     Estimate Vp and Vs by neural network regression with multiple inputs.
 
@@ -116,9 +118,9 @@ def run_regression(inp_df, vp_model_file_name, vs_model_file_name, model_dir=Non
     ----------
     inp_df : pd.DataFrame
         Input logs required for the regression.
-    vp_model_file_name : str
+    first_model_file_name : str
         Full file name for vp model.
-    vs_model_file_name : str
+    second_model_file_name : str
         Full file name for vs model.
     model_dir : str
         Directory.
@@ -139,7 +141,7 @@ def run_regression(inp_df, vp_model_file_name, vs_model_file_name, model_dir=Non
         category_var,
         column_names,
         column_units,
-    ) = _read_models(vp_model_file_name, vs_model_file_name, model_dir=model_dir)
+    ) = _read_models(first_model_file_name, second_model_file_name, model_dir=model_dir)
     return _perform_regression(
         inp_df,
         column_names,

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/equinor_utilities/std_functions/backus_ave.py

@@ -1,7 +1,22 @@
 import numpy as np
+import numpy.typing as npt
 
 
-def backus_average(vp1, vs1, rho1, vp2, vs2, rho2, f1):
+def backus_average(
+    vp1: npt.NDArray[np.float64],
+    vs1: npt.NDArray[np.float64],
+    rho1: npt.NDArray[np.float64],
+    vp2: npt.NDArray[np.float64],
+    vs2: npt.NDArray[np.float64],
+    rho2: npt.NDArray[np.float64],
+    f1: 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],
+]:
     """
     Backus average for a combination of two phases. The individual phases are isotropic
     but the resulting effective medium is not.

rock_physics_open/equinor_utilities/std_functions/dvorkin_nur.py

@@ -1,9 +1,17 @@
 import numpy as np
+import numpy.typing as npt
 
 
 def dvorkin_contact_cement(
-    frac_cem, por0_sst, mu0_sst, k0_sst, mu0_cem, k0_cem, vs_red, c
-):
+    frac_cem: npt.NDArray[np.float64],
+    por0_sst: npt.NDArray[np.float64],
+    mu0_sst: npt.NDArray[np.float64],
+    k0_sst: npt.NDArray[np.float64],
+    mu0_cem: npt.NDArray[np.float64],
+    k0_cem: npt.NDArray[np.float64],
+    vs_red: npt.NDArray[np.float64],
+    c: float,
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
     """
     Dvorkin-Nur contact cement model for estimation of elastic moduli.