rock-physics-open 0.2.1__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,
@@ -32,12 +31,16 @@ def compare_snapshots(
 
     for i, (test_item, saved_item) in enumerate(zip(test_results, saved_results)):
         try:
+            if name_arr:
+                err_msg = f"saved and generated result for {name_arr[i]} differ"
+            else:
+                err_msg = f"saved result for variable {i} differ"
             np.testing.assert_allclose(
                 test_item,
                 saved_item,
                 rtol=r_tol,
                 equal_nan=equal_nan,
-                err_msg=f"saved and generated result for variable {i} differ",
+                err_msg=err_msg,
             )
         except AssertionError as error:
             open_mode = "w" if no_difference_found else "a"
@@ -46,9 +49,14 @@ def compare_snapshots(
             log_file = re.sub("npz", "log", get_snapshot_name(step=2))
 
             with open(log_file, open_mode) as file:
-                file.write(f"Test filepath: {str(inspect.stack()[1].filename)} \n")
-                file.write(f"Test function: {str(inspect.stack()[1].function)} \n")
-                file.write(f"Test variable number: {i} \n")
+                file.write(
+                    f"Test function: "
+                    f"{get_snapshot_name(include_extension=False, include_snapshot_dir=False, include_filename=False)} \n"
+                )
+                if name_arr:
+                    file.write(f"Test variable: {name_arr[i]} \n")
+                else:
+                    file.write(f"Test variable number: {i} \n")
 
                 for line in str(error).splitlines():
                     mismatched_elements_index = (
@@ -72,7 +80,7 @@ def compare_snapshots(
                         file.write(line + "\n")
                         continue
 
-                    reg_index = re.search(r"\d+ differ", line)
+                    reg_index = re.search(r"differ", line)
 
                     if reg_index:
                         if isinstance(test_item, np.ndarray):
@@ -91,7 +99,7 @@ def compare_snapshots(
                             tab = "\t"
                             for difference in differences:
                                 file.write(
-                                    f"{tab}[{difference[0]:4}]=> {difference[1]:.4g} != {difference[2]:.4g}\n"
+                                    f"{tab}[{difference[0]:4}]=> {difference[1]:.8g} != {difference[2]:.8g}\n"
                                 )
                             file.write(f"{'_' * 40}\n")
     return no_difference_found

rock_physics_open/equinor_utilities/snapshot_test_utilities/snapshots.py

@@ -5,6 +5,34 @@ import numpy as np
 
 INITIATE = False
 
+SYSTEM_AND_DEBUG_FCN = [
+    "pydev",
+    "ipython-input",
+    "interactiveshell",
+    "async_helpers",
+    "handle_snapshots",
+    "run_code",
+    "run_ast_nodes",
+    "run_cell_async",
+    "_pseudo_sync_runner",
+    "_run_cell",
+    "run_cell",
+    "add_exec",
+    "do_add_exec",
+    "add_exec",
+    "ipython_exec_code",
+    "console_exec",
+    "do_it",
+    "process_internal_commands",
+    "_do_wait_suspend",
+    "do_wait_suspend",
+    "compare_snapshots",
+    "handle_snapshots",
+    "wrapper",
+    "run_tests",
+    "<module>",
+]
+
 
 def get_snapshot_name(
     step: int = 1,
@@ -18,6 +46,9 @@ def get_snapshot_name(
     ----------
     step: number of steps in the trace to collect information from
     include_snapshot_dir: absolute directory name included in snapshot name
+    include_filename: whether to include filename in snapshot name
+    include_function_name: whether to include function name in snapshot name
+    include_extension: whether to include extension in snapshot name
 
     Returns
     -------
@@ -25,20 +56,12 @@ def get_snapshot_name(
     """
     trace = inspect.stack()
     for frame in trace[step:]:
-        if not any(
-            keyword in frame.function
-            for keyword in [
-                "pydev",
-                "ipython-input",
-                "interactiveshell",
-                "async_helpers",
-            ]
-        ):
+        if not any(keyword in frame.function for keyword in SYSTEM_AND_DEBUG_FCN):
             break
     else:
         frame = trace[step]
 
-    dir_name = Path(frame.filename).parent / "snapshots"
+    dir_name = Path(frame.filename).parents[1] / "data" / "snapshots"
     file_name = Path(frame.filename).stem if include_filename else ""
     function_name = frame.function if include_function_name else ""
     extension = ".npz" if include_extension else ""