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

rock_physics_open/equinor_utilities/gen_utilities/dict_to_float.py

@@ -1,4 +1,9 @@
-def dict_value_to_float(input_dict):
+from typing import Any
+
+
+def dict_value_to_float(
+    input_dict: dict[str, Any],
+) -> dict[str, float | list[float]]:
     """
     Convert dictionary strings to floating point numbers. Each value can have multiple floats.
 

rock_physics_open/equinor_utilities/gen_utilities/dim_check_vector.py

@@ -1,8 +1,38 @@
+from typing import Any, overload
+
 import numpy as np
+import numpy.typing as npt
 import pandas as pd
 
 
-def dim_check_vector(args, force_type=None):
+@overload
+def dim_check_vector(
+    args: list[Any] | tuple[Any, ...],
+    force_type: np.dtype | None = ...,
+) -> list[npt.NDArray[Any] | pd.DataFrame]:
+    """Overload for when the input is a list or tuple."""
+
+
+@overload
+def dim_check_vector(
+    args: pd.DataFrame,
+    force_type: np.dtype | None = ...,
+) -> pd.DataFrame:
+    """Overload for when the input is a pandas DataFrame."""
+
+
+@overload
+def dim_check_vector(
+    args: npt.NDArray[Any],
+    force_type: np.dtype | None = ...,
+) -> npt.NDArray[Any]:
+    """Overload for when the input is a numpy array."""
+
+
+def dim_check_vector(
+    args: list[Any] | tuple[Any, ...] | npt.NDArray[Any] | pd.DataFrame,
+    force_type: np.dtype | None = None,
+) -> npt.NDArray[Any] | pd.DataFrame | list[npt.NDArray[Any] | pd.DataFrame]:
     """
     Check that all inputs are of the same (one-dimensional) size. Raise ValueError in case there are several lengths
     present in the inputs. All inputs will be checked and possibly expanded to common length. Only the first dimension
@@ -23,8 +53,8 @@ def dim_check_vector(args, force_type=None):
     single_types = (np.ndarray, pd.DataFrame)
     iterable_types = (list, tuple)
     allowed_types = single_types + iterable_types
-    if not isinstance(args, allowed_types):
-        raise ValueError("dim_check_vector: unknown input type: {}".format(type(args)))
+    if not isinstance(args, allowed_types):  # pyright: ignore[reportUnnecessaryIsInstance] | Kept for backward compatibility
+        raise ValueError("dim_check_vector: unknown input type: {}".format(type(args)))  # pyright: ignore[reportUnreachable] | Kept for backward compatibility
 
     # Single array or dataframe is just returned
     if isinstance(args, single_types):
@@ -56,13 +86,13 @@ def dim_check_vector(args, force_type=None):
         args = [np.array(item, ndmin=1) if np.isscalar(item) else item for item in args]
 
     # Can now test for length - must either be a scalar or have the same length
-    max_length = np.max([item.shape[0] for item in args])
+    max_length: int = np.max([item.shape[0] for item in args])
     if not np.all([item.shape[0] == max_length or item.shape[0] == 1 for item in args]):
         raise ValueError(
             "dim_check_vector: Unequal array lengths in input to dim_check_vector"
         )
 
-    output_arg = []
+    output_arg: list[npt.NDArray[Any] | pd.DataFrame] = []
     for item in args:
         if item.shape[0] == max_length:
             output_arg.append(item)

rock_physics_open/equinor_utilities/gen_utilities/filter_input.py

@@ -1,14 +1,20 @@
 from sys import byteorder
+from typing import Any
 
 import numpy as np
+import numpy.typing as npt
 import pandas as pd
 
 WRONG_BYTEORDER = ">" if byteorder == "little" else "<"
 
 
 def filter_input_log(
-    args, working_int=None, negative=False, no_zero=False, positive=True
-):
+    args: list[Any] | tuple[Any, ...] | npt.NDArray[Any] | pd.DataFrame,
+    working_int: npt.NDArray[Any] | None = None,
+    negative: bool = False,
+    no_zero: bool = False,
+    positive: bool = True,
+) -> tuple[npt.NDArray[np.bool_], list[npt.NDArray[Any] | pd.DataFrame]]:
     """
     Check for valid input values in numpy arrays or pandas data frames. Default behaviour is to
     identify missing values - assumed to be NaN and Inf. Other conditions
@@ -40,9 +46,8 @@ def filter_input_log(
     type_error = "filter_input_log: unknown input data type: {}".format(type(args))
     size_error = "filter_input_log: inputs of different length"
 
-    if not isinstance(args, (list, tuple, np.ndarray, pd.DataFrame)):
-        raise ValueError(type_error)
-
+    if not isinstance(args, (list, tuple, np.ndarray, pd.DataFrame)):  # pyright: ignore[reportUnnecessaryIsInstance] | Kept for backward compatibility
+        raise ValueError(type_error)  # pyright: ignore[reportUnreachable] | Kept for backward compatibility
     # Make sure that 'args' is iterable
     if isinstance(args, (np.ndarray, pd.DataFrame)):
         args = [args]
@@ -70,7 +75,7 @@ def filter_input_log(
     # https://github.com/pandas-dev/pandas/issues/32432
     # idx = ~logs.any(bool_only=True, axis=1)
     # Need to do it the cumbersome way for the time being
-    bool_col = logs.dtypes.apply(lambda dtype: dtype == "bool")
+    bool_col = logs.dtypes == "bool"
     if any(bool_col):
         idx = ~logs.loc[:, logs.columns[bool_col]].any(axis=1)
         logs.drop(columns=logs.columns[bool_col], inplace=True)

rock_physics_open/equinor_utilities/gen_utilities/filter_output.py

@@ -1,12 +1,17 @@
-from sys import byteorder
+from typing import Any
 
 import numpy as np
+import numpy.typing as npt
 import pandas as pd
 
-WRONG_BYTEORDER = ">" if byteorder == "little" else "<"
 
-
-def filter_output(idx_inp, inp_log):
+def filter_output(
+    idx_inp: npt.NDArray[np.bool_],
+    inp_log: list[npt.NDArray[Any] | pd.DataFrame]
+    | tuple[npt.NDArray[Any] | pd.DataFrame, ...]
+    | npt.NDArray[Any]
+    | pd.DataFrame,
+) -> list[npt.NDArray[Any] | pd.DataFrame]:
     """
     Function to restore outputs from a plugin to original length and
     with values at correct positions. The logs are assumed to go through
@@ -27,7 +32,9 @@ def filter_output(idx_inp, inp_log):
         Expanded inputs.
     """
 
-    def _expand_array(idx, inp_single_log):
+    def _expand_array(
+        idx: npt.NDArray[np.bool_], inp_single_log: npt.NDArray[Any]
+    ) -> npt.NDArray[Any]:
         logs = np.ones(idx.shape, dtype=float) * np.nan
         try:
             logs[idx] = inp_single_log.flatten()
@@ -37,30 +44,33 @@ def filter_output(idx_inp, inp_log):
             logs[idx] = inp_single_log
         return logs.reshape(idx.shape)
 
-    def _expand_df(idx, inp_df):
-        logs = pd.DataFrame(columns=inp_df.columns, index=np.arange(idx.shape[0]))
+    def _expand_df(idx: npt.NDArray[np.bool_], inp_df: pd.DataFrame) -> pd.DataFrame:
+        logs = pd.DataFrame(
+            columns=inp_df.columns, index=np.arange(idx.shape[0], dtype=np.intp)
+        )
         logs.loc[idx] = inp_df
         return logs
 
-    if not isinstance(inp_log, (list, tuple, np.ndarray, pd.DataFrame)):
-        raise ValueError(
+    if not isinstance(inp_log, (list, tuple, np.ndarray, pd.DataFrame)):  # pyright: ignore[reportUnnecessaryIsInstance] | Kept for backward compatibility
+        raise ValueError(  # pyright: ignore[reportUnreachable] | Kept for backward compatibility
             "filter_output: unknown input data type: {}".format(type(inp_log))
         )
-    if not isinstance(idx_inp, (list, np.ndarray)):
-        raise ValueError(
+    if not isinstance(idx_inp, (list, np.ndarray)):  # pyright: ignore[reportUnnecessaryIsInstance] | Kept for backward compatibility
+        raise ValueError(  # pyright: ignore[reportUnreachable] | Kept for backward compatibility
             "filter_output: unknown filter array data type: {}".format(type(idx_inp))
         )
 
     # Make iterable in case of single input
     if isinstance(inp_log, (np.ndarray, pd.DataFrame)):
         inp_log = [inp_log]
-    if isinstance(idx_inp, np.ndarray):
-        idx_inp = [idx_inp]
+
+    if isinstance(idx_inp, np.ndarray):  # pyright: ignore[reportUnnecessaryIsInstance] | Kept for backward compatibility
+        idx_inp_ = [idx_inp]
 
     # Possible to simplify?
-    if len(idx_inp) != len(inp_log):
-        if len(idx_inp) == 1:
-            idx_inp = idx_inp * len(inp_log)
+    if len(idx_inp_) != len(inp_log):
+        if len(idx_inp_) == 1:
+            idx_inp_ = idx_inp_ * len(inp_log)
         else:
             raise ValueError(
                 "filter_output: mismatch between length of filter arrays and inputs: {} and {}".format(
@@ -68,11 +78,11 @@ def filter_output(idx_inp, inp_log):
                 )
             )
 
-    return_logs = []
-    for this_idx, this_log in zip(idx_inp, inp_log):
+    return_logs: list[npt.NDArray[Any] | pd.DataFrame] = []
+    for this_idx, this_log in zip(idx_inp_, inp_log):
         if isinstance(this_log, np.ndarray):
             return_logs.append(_expand_array(this_idx, this_log))
-        elif isinstance(this_log, pd.DataFrame):
+        elif isinstance(this_log, pd.DataFrame):  # pyright: ignore[reportUnnecessaryIsInstance] | Kept for backward compatibility
             return_logs.append(_expand_df(this_idx, this_log))
 
     return return_logs

rock_physics_open/equinor_utilities/machine_learning_utilities/__init__.py

@@ -1,14 +1,27 @@
 from .dummy_vars import generate_dummy_vars
-from .exponential_model import CarbonateExponentialPressure
+from .exponential_model import ExponentialPressureModel
+from .friable_pressure_models import (
+    FriableDryBulkModulusPressureModel,
+    FriableDryShearModulusPressureModel,
+)
 from .import_ml_models import import_model
+from .patchy_cement_pressure_models import (
+    PatchyCementDryBulkModulusPressureModel,
+    PatchyCementDryShearModulusPressureModel,
+)
+from .polynomial_model import PolynomialPressureModel
 from .run_regression import run_regression
-from .sigmoidal_model import CarbonateSigmoidalPressure, Sigmoid
+from .sigmoidal_model import SigmoidalPressureModel
 
 __all__ = [
     "generate_dummy_vars",
-    "CarbonateExponentialPressure",
     "import_model",
     "run_regression",
-    "CarbonateSigmoidalPressure",
-    "Sigmoid",
+    "ExponentialPressureModel",
+    "PolynomialPressureModel",
+    "SigmoidalPressureModel",
+    "FriableDryBulkModulusPressureModel",
+    "FriableDryShearModulusPressureModel",
+    "PatchyCementDryShearModulusPressureModel",
+    "PatchyCementDryBulkModulusPressureModel",
 ]

rock_physics_open/equinor_utilities/machine_learning_utilities/base_pressure_model.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+import pickle
+from abc import ABC, abstractmethod
+from typing import Any, Self
+
+import numpy as np
+
+
+class BasePressureModel(ABC):
+    """
+    Abstract base class for pressure sensitivity models.
+
+    All pressure models follow the convention:
+    - predict(): returns differential change (depleted - in_situ)
+    - predict_abs(): returns absolute values for specified case
+    - predict_max(): uses model_max_pressure instead of depleted pressure
+
+    Input validation is delegated to concrete implementations since
+    each model has different column requirements.
+    """
+
+    def __init__(self, model_max_pressure: float | None = None, description: str = ""):
+        """
+        Initialize base pressure model.
+
+        Parameters
+        ----------
+        model_max_pressure : float | None
+            Maximum pressure for predict_max method. Required for predict_max to work.
+        description : str
+            Human-readable description of the model instance.
+        """
+        self._model_max_pressure = model_max_pressure
+        self._description = description
+
+    @property
+    def max_pressure(self) -> float | None:
+        """Maximum pressure setting for predict_max method."""
+        return self._model_max_pressure
+
+    @property
+    def description(self) -> str:
+        """Model description."""
+        return self._description
+
+    def predict(self, inp_arr: np.ndarray) -> np.ndarray:
+        """
+        Predict differential change: result(depleted) - result(in_situ).
+
+        Parameters
+        ----------
+        inp_arr : np.ndarray
+            Input array with pressure columns and other model-specific parameters.
+
+        Returns
+        -------
+        np.ndarray
+            Differential change values.
+        """
+        arr = self.validate_input(inp_arr)
+        return self.predict_abs(arr, case="depleted") - self.predict_abs(
+            arr, case="in_situ"
+        )
+
+    def predict_max(self, inp_arr: np.ndarray) -> np.ndarray:
+        """
+        Predict using model_max_pressure instead of depleted pressure.
+
+        Parameters
+        ----------
+        inp_arr : np.ndarray
+            Input array where last column (depleted pressure) will be replaced.
+
+        Returns
+        -------
+        np.ndarray
+            Values at model_max_pressure minus values at in_situ pressure.
+
+        Raises
+        ------
+        ValueError
+            If model_max_pressure is not set.
+        """
+        if self._model_max_pressure is None:
+            raise ValueError('Field "model_max_pressure" is not set')
+
+        arr = self.validate_input(inp_arr).copy()
+        # Replace last column (assumed to be depleted pressure) with max pressure
+        arr[:, -1] = self._model_max_pressure
+        return self.predict_abs(arr, case="depleted") - self.predict_abs(
+            arr, case="in_situ"
+        )
+
+    @abstractmethod
+    def validate_input(self, inp_arr: np.ndarray) -> np.ndarray:
+        """
+        Validate input array format for this specific model.
+
+        Parameters
+        ----------
+        inp_arr : np.ndarray
+            Input array to validate.
+
+        Returns
+        -------
+        np.ndarray
+            Validated input array.
+
+        Raises
+        ------
+        ValueError
+            If input format is invalid for this model.
+        """
+
+    @abstractmethod
+    def predict_abs(self, inp_arr: np.ndarray, case: str = "in_situ") -> np.ndarray:
+        """
+        Predict absolute values for specified pressure case.
+
+        Parameters
+        ----------
+        inp_arr : np.ndarray
+            Validated input array.
+        case : str
+            Either "in_situ" or "depleted" to specify which pressure to use.
+
+        Returns
+        -------
+        np.ndarray
+            Absolute predicted values.
+        """
+
+    @abstractmethod
+    def todict(self) -> dict[str, Any]:
+        """
+        Convert model to dictionary for serialization.
+
+        Returns
+        -------
+        dict[str, Any]
+            Dictionary containing all model parameters.
+        """
+
+    def save(self, file: str | bytes) -> None:
+        """
+        Save model to pickle file.
+
+        Parameters
+        ----------
+        file : str | bytes
+            File path for saving.
+        """
+        with open(file, "wb") as f_out:
+            pickle.dump(self.todict(), f_out)
+
+    @classmethod
+    @abstractmethod
+    def load(cls, file: str | bytes) -> Self:
+        """
+        Load model from pickle file.
+
+        Parameters
+        ----------
+        file : str | bytes
+            File path for loading.
+
+        Returns
+        -------
+        BasePressureModel
+            Loaded model instance.
+        """

rock_physics_open/equinor_utilities/machine_learning_utilities/exponential_model.py

@@ -1,119 +1,133 @@
+from __future__ import annotations
+
 import pickle
-from typing import Union
+from typing import Any
 
 import numpy as np
 
+from .base_pressure_model import BasePressureModel
 
-def _verify_input(inp_arr):
-    if isinstance(inp_arr, np.ndarray) and not (
-        inp_arr.ndim == 2 and inp_arr.shape[1] == 3
-    ):
-        raise ValueError(
-            "Input to predict method should be an nx3 numpy array with columns velocity, in situ "
-            "pressure and depleted pressure"
-        )
 
+class ExponentialPressureModel(BasePressureModel):
+    """
+    Exponential pressure sensitivity model for velocity prediction.
+
+    Uses exponential decay function: v = v0 * (1 - a*exp(-p/b)) / (1 - a*exp(-p0/b))
+    where v0 is reference velocity, p is pressure, a and b are model parameters.
+
+    Input format (n,3): [velocity, p_eff_in_situ, p_eff_depleted]
+    """
 
-class CarbonateExponentialPressure:
     def __init__(
         self,
-        a_factor: float = None,
-        b_factor: float = None,
-        model_max_pressure: float = None,
+        a_factor: float,
+        b_factor: float,
+        model_max_pressure: float | None = None,
         description: str = "",
     ):
+        """
+        Initialize exponential pressure model.
+
+        Parameters
+        ----------
+        a_factor : float
+            Exponential amplitude parameter [unitless].
+        b_factor : float
+            Exponential decay parameter [Pa].
+        model_max_pressure : float | None
+            Maximum pressure for predict_max method [Pa].
+        description : str
+            Model description.
+        """
+        super().__init__(model_max_pressure, description)
         self._a_factor = a_factor
         self._b_factor = b_factor
-        self._model_max_pressure = model_max_pressure
-        self._description = description
-
-    def todict(self):
-        return {
-            "a_factor": self._a_factor,
-            "b_factor": self._b_factor,
-            "model_max_pressure": self._model_max_pressure,
-            "description": self._description,
-        }
 
     @property
     def a_factor(self) -> float:
+        """Exponential amplitude factor."""
         return self._a_factor
 
     @property
     def b_factor(self) -> float:
+        """Exponential decay factor."""
         return self._b_factor
 
-    @property
-    def max_pressure(self) -> float:
-        return self._model_max_pressure
+    def validate_input(self, inp_arr: np.ndarray) -> np.ndarray:
+        """
+        Validate input for exponential 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
 
-    @property
-    def description(self) -> str:
-        return self._description
-
-    def predict(self, inp_arr: np.ndarray) -> Union[np.ndarray, None]:
-        _verify_input(inp_arr)
-        if not self._valid():
-            return None
-        vel = inp_arr[:, 0]
-        eff_pres_in_situ = inp_arr[:, 1]
-        eff_pres_depl = inp_arr[:, 2]
-        # Return differential velocity to match alternative models
-        return (
-            vel
-            * (1.0 - self._a_factor * np.exp(-eff_pres_depl / self._b_factor))
-            / (1.0 - self._a_factor * np.exp(-eff_pres_in_situ / self._b_factor))
-            - vel
-        )
+    def predict_abs(self, inp_arr: np.ndarray, case: str = "in_situ") -> np.ndarray:
+        """
+        Calculate absolute velocity for specified pressure case.
 
-    def predict_max(self, inp_arr: np.ndarray) -> Union[np.ndarray, None]:
-        _verify_input(inp_arr)
-        if not self._valid():
-            return None
-        vel = inp_arr[:, 0]
-        eff_pres_in_situ = inp_arr[:, 1]
-        return (
-            vel
-            * (
-                1.0
-                - self._a_factor * np.exp(-self._model_max_pressure / self._b_factor)
-            )
-            / (1.0 - self._a_factor * np.exp(-eff_pres_in_situ / self.b_factor))
-        )
+        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)
+
+        vel = arr[:, 0]
+        p_in_situ = arr[:, 1]
+        p_depleted = arr[:, 2]
+
+        p_eff = p_in_situ if case == "in_situ" else p_depleted
 
-    def predict_abs(self, inp_arr: np.ndarray) -> Union[np.ndarray, None]:
-        _verify_input(inp_arr)
-        if not self._valid():
-            return None
-        vel = inp_arr[:, 0]
-        eff_pres_in_situ = inp_arr[:, 1]
-        eff_pres_depl = inp_arr[:, 2]
         return (
             vel
-            * (1.0 - self._a_factor * np.exp(-eff_pres_depl / self._b_factor))
-            / (1.0 - self._a_factor * np.exp(-eff_pres_in_situ / self._b_factor))
+            * (1.0 - self._a_factor * np.exp(-p_eff / self._b_factor))
+            / (1.0 - self._a_factor * np.exp(-p_in_situ / self._b_factor))
         )
 
-    def save(self, file):
-        with open(file, "wb") as f_out:
-            pickle.dump(self.todict(), f_out)
+    def todict(self) -> dict[str, Any]:
+        """Convert model to dictionary."""
+        return {
+            "a_factor": self._a_factor,
+            "b_factor": self._b_factor,
+            "model_max_pressure": self._model_max_pressure,
+            "description": self._description,
+        }
 
     @classmethod
-    def load(cls, file):
+    def load(cls, file: str | bytes) -> "ExponentialPressureModel":
+        """Load exponential model from pickle file."""
         with open(file, "rb") as f_in:
-            inp_pcl = pickle.load(f_in)
-            return cls(
-                a_factor=inp_pcl["a_factor"],
-                b_factor=inp_pcl["b_factor"],
-                model_max_pressure=inp_pcl["model_max_pressure"],
-                description=inp_pcl["description"],
-            )
+            d = pickle.load(f_in)
 
-    def _valid(self):
-        if self.a_factor is None:
-            raise ValueError('object field "a_factor" is not set')
-        if self.b_factor is None:
-            raise ValueError('object field "b_factor" is not set')
-        if self.max_pressure is None:
-            raise ValueError('object field "max_pressure" is not set')
-        return True
+        return cls(
+            a_factor=d["a_factor"],
+            b_factor=d["b_factor"],
+            model_max_pressure=d["model_max_pressure"],
+            description=d["description"],
+        )