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/friable_pressure_models.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+import pickle
+from typing import Any, Self
+
+import numpy as np
+
+from rock_physics_open.sandstone_models.friable_models import friable_model_dry
+
+from .base_pressure_model import BasePressureModel
+
+
+class FriableDryPressureModel(BasePressureModel):
+    """
+    Pressure sensitivity model using friable dry rock bulk modulus.
+
+    This model calculates pressure-dependent bulk modulus using the friable
+    sandstone model, which represents unconsolidated sands where porosity
+    variation is due to grain sorting.
+
+    Input format (n,5): [phi, k_min, mu_min, p_eff_in_situ, p_eff_depleted]
+
+    Where:
+    - phi: porosity [fraction]
+    - k_min: mineral bulk modulus per sample [Pa]
+    - mu_min: mineral shear modulus per sample [Pa]
+    - p_eff_in_situ: effective pressure in-situ [Pa]
+    - p_eff_depleted: effective pressure depleted [Pa]
+
+    The model returns bulk and shear modulus changes due to pressure variations.
+    """
+
+    def __init__(
+        self,
+        phi_c: float,
+        coord_num_func: str = "Porosity",
+        n: float | None = None,
+        shear_red: float = 1.0,
+        model_max_pressure: float | None = None,
+        description: str = "",
+    ):
+        """
+        Initialize friable dry pressure model.
+
+        Parameters
+        ----------
+        phi_c : float
+            Critical porosity [fraction]. Porosity above this value is undefined.
+        coord_num_func : str
+            Coordination number calculation method: "Porosity" or "ConstVal".
+        n : float | None
+            Coordination number [unitless]. Used only if coord_num_func="ConstVal".
+        shear_red : float
+            Shear reduction factor [fraction] for tangential grain contacts.
+        model_max_pressure : float | None
+            Maximum pressure for predict_max method [Pa].
+        description : str
+            Human-readable description of this model instance.
+        """
+        super().__init__(model_max_pressure, description)
+        self._phi_c = phi_c
+        self._coord_num_func = coord_num_func
+        self._n = n
+        self._shear_red = shear_red
+
+    def validate_input(self, inp_arr: np.ndarray) -> np.ndarray:
+        """
+        Validate input array for friable model.
+
+        Parameters
+        ----------
+        inp_arr : np.ndarray
+            Input array to validate.
+
+        Returns
+        -------
+        np.ndarray
+            Validated input array.
+
+        Raises
+        ------
+        ValueError
+            If input is not a 2D numpy array with 5 columns.
+        """
+        if not isinstance(inp_arr, np.ndarray):
+            raise ValueError("Input must be numpy ndarray.")
+        if inp_arr.ndim != 2 or inp_arr.shape[1] != 5:
+            raise ValueError(
+                "Input must be (n,5): [phi, k_min, mu_min, p_eff_in_situ, p_eff_depleted]"
+            )
+        return inp_arr
+
+    def _compute_moduli(
+        self, inp_arr: np.ndarray, case: str = "in_situ"
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """
+        Calculate absolute bulk modulus for specified pressure case.
+
+        Parameters
+        ----------
+        inp_arr : np.ndarray
+            Validated input array (n,5).
+        case : str
+            Pressure case: "in_situ" or "depleted".
+
+        Returns
+        -------
+        np.ndarray
+            Bulk modulus values [Pa].
+        """
+        arr = self.validate_input(inp_arr)
+
+        # Parse input columns
+        phi = arr[:, 0]
+        k_min = arr[:, 1]
+        mu_min = arr[:, 2]
+        p_in_situ = arr[:, 3]
+        p_depleted = arr[:, 4]
+
+        # Select pressure based on case
+        p_eff = p_in_situ if case == "in_situ" else p_depleted
+
+        # Calculate dry bulk modulus using friable model
+        k_dry, mu = friable_model_dry(
+            k_min,
+            mu_min,
+            phi,
+            p_eff,
+            self._phi_c,
+            self._coord_num_func,
+            self._n,
+            self._shear_red,
+        )
+
+        return k_dry, mu
+
+    def todict(self) -> dict[str, Any]:
+        """
+        Convert model to dictionary for serialization.
+
+        Returns
+        -------
+        dict[str, Any]
+            Dictionary containing all model parameters.
+        """
+        return {
+            "phi_c": self._phi_c,
+            "coord_num_func": self._coord_num_func,
+            "n": self._n,
+            "shear_red": self._shear_red,
+            "model_max_pressure": self._model_max_pressure,
+            "description": self._description,
+        }
+
+    @classmethod
+    def load(cls, file: str | bytes) -> Self:
+        """
+        Load friable model from pickle file.
+
+        Parameters
+        ----------
+        file : str, bytes
+            File path for loading.
+
+        Returns
+        -------
+        FriableDryPressureModel
+            Loaded model instance.
+        """
+        with open(file, "rb") as f_in:
+            d = pickle.load(f_in)
+
+        return cls(
+            phi_c=d["phi_c"],
+            coord_num_func=d["coord_num_func"],
+            n=d["n"],
+            shear_red=d["shear_red"],
+            model_max_pressure=d["model_max_pressure"],
+            description=d["description"],
+        )
+
+
+class FriableDryShearModulusPressureModel(FriableDryPressureModel):
+    """
+    Pressure sensitivity model using friable dry rock bulk modulus.
+
+    This model calculates pressure-dependent bulk modulus using the friable
+    sandstone model, which represents unconsolidated sands where porosity
+    variation is due to grain sorting.
+
+    Input format (n,5): [phi, k_min, mu_min, p_eff_in_situ, p_eff_depleted]
+
+    Where:
+    - phi: porosity [fraction]
+    - k_min: mineral bulk modulus per sample [Pa]
+    - mu_min: mineral shear modulus per sample [Pa]
+    - p_eff_in_situ: effective pressure in-situ [Pa]
+    - p_eff_depleted: effective pressure depleted [Pa]
+
+    The model returns shear modulus changes due to pressure variations.
+    """
+
+    def predict_abs(self, inp_arr: np.ndarray, case: str = "in_situ") -> np.ndarray:
+        k_dry, mu = self._compute_moduli(inp_arr, case)
+        return mu
+
+
+class FriableDryBulkModulusPressureModel(FriableDryPressureModel):
+    """
+    Pressure sensitivity model using friable dry rock bulk modulus.
+
+    This model calculates pressure-dependent bulk modulus using the friable
+    sandstone model, which represents unconsolidated sands where porosity
+    variation is due to grain sorting.
+
+    Input format (n,5): [phi, k_min, mu_min, p_eff_in_situ, p_eff_depleted]
+
+    Where:
+    - phi: porosity [fraction]
+    - k_min: mineral bulk modulus per sample [Pa]
+    - mu_min: mineral shear modulus per sample [Pa]
+    - p_eff_in_situ: effective pressure in-situ [Pa]
+    - p_eff_depleted: effective pressure depleted [Pa]
+
+    The model returns bulk modulus changes due to pressure variations.
+    """
+
+    def predict_abs(self, inp_arr: np.ndarray, case: str = "in_situ") -> np.ndarray:
+        k_dry, mu = self._compute_moduli(inp_arr, case)
+        return k_dry

rock_physics_open/equinor_utilities/machine_learning_utilities/import_ml_models.py

@@ -1,5 +1,14 @@
-from .exponential_model import CarbonateExponentialPressure
-from .sigmoidal_model import CarbonateSigmoidalPressure
+from .exponential_model import ExponentialPressureModel
+from .friable_pressure_models import (
+    FriableDryBulkModulusPressureModel,
+    FriableDryShearModulusPressureModel,
+)
+from .patchy_cement_pressure_models import (
+    PatchyCementDryBulkModulusPressureModel,
+    PatchyCementDryShearModulusPressureModel,
+)
+from .polynomial_model import PolynomialPressureModel
+from .sigmoidal_model import SigmoidalPressureModel
 
 
 def import_model(model_file_name):
@@ -33,9 +42,19 @@ def import_model(model_file_name):
             mod_dict = load(fin)
 
     if mod_dict["model_type"] == "Sigmoid":
-        models = CarbonateSigmoidalPressure.load(mod_dict["nn_mod"])
+        models = SigmoidalPressureModel.load(mod_dict["nn_mod"])
     elif mod_dict["model_type"] == "Exponential":
-        models = CarbonateExponentialPressure.load(mod_dict["nn_mod"])
+        models = ExponentialPressureModel.load(mod_dict["nn_mod"])
+    elif mod_dict["model_type"] == "Polynomial":
+        models = PolynomialPressureModel.load(mod_dict["nn_mod"])
+    elif mod_dict["model_type"] == "FriableDryBulk":
+        models = FriableDryBulkModulusPressureModel.load(mod_dict["nn_mod"])
+    elif mod_dict["model_type"] == "FriableDryShear":
+        models = FriableDryShearModulusPressureModel.load(mod_dict["nn_mod"])
+    elif mod_dict["model_type"] == "PatchyCementDryBulk":
+        models = PatchyCementDryBulkModulusPressureModel.load(mod_dict["nn_mod"])
+    elif mod_dict["model_type"] == "PatchyCementDryShear":
+        models = PatchyCementDryShearModulusPressureModel.load(mod_dict["nn_mod"])
     else:
         raise ValueError("unknown model type {}".format(mod_dict["model_type"]))
 

rock_physics_open/equinor_utilities/machine_learning_utilities/patchy_cement_pressure_models.py

@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+import pickle
+from typing import Any, Self
+
+import numpy as np
+
+from rock_physics_open.sandstone_models.patchy_cement_model import (
+    patchy_cement_model_dry,
+)
+
+from .base_pressure_model import BasePressureModel
+
+
+class PatchyCementDryPressureModel(BasePressureModel):
+    """
+    Pressure sensitivity model using patchy cement dry rock properties.
+
+    This model combines friable and cemented sandstone behavior, representing
+    partially cemented sands with heterogeneous cement distribution.
+
+    Input format (n,9): [phi, k_min, mu_min, rho_min, k_cem, mu_cem, rho_cem, p_eff_in_situ, p_eff_depleted]
+
+    Where:
+    - phi: porosity [fraction]
+    - k_min: mineral bulk modulus [Pa]
+    - mu_min: mineral shear modulus [Pa]
+    - rho_min: mineral density [kg/m³]
+    - k_cem: cement bulk modulus [Pa]
+    - mu_cem: cement shear modulus [Pa]
+    - rho_cem: cement density [kg/m³]
+    - p_eff_in_situ: effective pressure in-situ [Pa]
+    - p_eff_depleted: effective pressure depleted [Pa]
+    """
+
+    def __init__(
+        self,
+        frac_cem: float,
+        phi_c: float,
+        coord_num_func: str = "Porosity",
+        n: float | None = None,
+        shear_red: float = 1.0,
+        model_max_pressure: float | None = None,
+        description: str = "",
+    ):
+        """
+        Initialize patchy cement dry pressure model.
+
+        Parameters
+        ----------
+        frac_cem : float
+            Cement volume fraction [fraction] defining upper bound behavior.
+        phi_c : float
+            Critical porosity [fraction].
+        coord_num_func : str
+            Coordination number method: "Porosity" or "ConstVal".
+        n : float | None
+            Coordination number [unitless]. Used if coord_num_func="ConstVal".
+        shear_red : float
+            Shear reduction factor [fraction].
+        model_max_pressure : float | None
+            Maximum pressure for predict_max method [Pa].
+        description : str
+            Model description.
+        """
+        super().__init__(model_max_pressure, description)
+        self._frac_cem = frac_cem
+        self._phi_c = phi_c
+        self._coord_num_func = coord_num_func
+        self._n = n
+        self._shear_red = shear_red
+
+    def validate_input(self, inp_arr: np.ndarray) -> np.ndarray:
+        """
+        Validate input array for patchy cement model.
+
+        Parameters
+        ----------
+        inp_arr : np.ndarray
+            Input array to validate.
+
+        Returns
+        -------
+        np.ndarray
+            Validated input array.
+
+        Raises
+        ------
+        ValueError
+            If input is not a 2D numpy array with 9 columns.
+        """
+        if not isinstance(inp_arr, np.ndarray):
+            raise ValueError("Input must be numpy ndarray.")
+        if inp_arr.ndim != 2 or inp_arr.shape[1] != 9:
+            raise ValueError(
+                "Input must be (n,9): [phi, k_min, mu_min, rho_min, k_cem, mu_cem, rho_cem, p_eff_in_situ, p_eff_depleted]"
+            )
+        return inp_arr
+
+    def _compute_moduli(
+        self, inp_arr: np.ndarray, case: str = "in_situ"
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """
+        Calculate absolute bulk modulus for specified pressure case.
+
+        Parameters
+        ----------
+        inp_arr : np.ndarray
+            Validated input array (n,9).
+        case : str
+            Pressure case: 'in_situ' or 'depleted'.
+
+        Returns
+        -------
+        np.ndarray
+            Bulk modulus values [Pa].
+        """
+        arr = self.validate_input(inp_arr)
+
+        # Parse input columns
+        phi = arr[:, 0]
+        k_min = arr[:, 1]
+        mu_min = arr[:, 2]
+        rho_min = arr[:, 3]
+        k_cem = arr[:, 4]
+        mu_cem = arr[:, 5]
+        rho_cem = arr[:, 6]
+        p_in_situ = arr[:, 7]
+        p_depleted = arr[:, 8]
+
+        # Select pressure based on case
+        p_eff = p_in_situ if case == "in_situ" else p_depleted
+
+        # Calculate dry bulk modulus using patchy cement model
+        k_dry, mu, _ = patchy_cement_model_dry(
+            k_min,
+            mu_min,
+            rho_min,
+            k_cem,
+            mu_cem,
+            rho_cem,
+            phi,
+            p_eff,
+            self._frac_cem,
+            self._phi_c,
+            self._coord_num_func,
+            self._n,
+            self._shear_red,
+        )
+
+        return k_dry, mu
+
+    def todict(self) -> dict[str, Any]:
+        """
+        Convert model to dictionary for serialization.
+
+        Returns
+        -------
+        dict[str, Any]
+            Dictionary containing all model parameters.
+        """
+        return {
+            "frac_cem": self._frac_cem,
+            "phi_c": self._phi_c,
+            "coord_num_func": self._coord_num_func,
+            "n": self._n,
+            "shear_red": self._shear_red,
+            "model_max_pressure": self._model_max_pressure,
+            "description": self._description,
+        }
+
+    @classmethod
+    def load(cls, file: str | bytes) -> Self:
+        """
+        Load patchy cement model from pickle file.
+
+        Parameters
+        ----------
+        file : str | bytes
+            File path for loading.
+
+        Returns
+        -------
+        PatchyCementDryPressureModel
+            Loaded model instance.
+        """
+        with open(file, "rb") as f_in:
+            d = pickle.load(f_in)
+
+        return cls(
+            frac_cem=d["frac_cem"],
+            phi_c=d["phi_c"],
+            coord_num_func=d["coord_num_func"],
+            n=d["n"],
+            shear_red=d["shear_red"],
+            model_max_pressure=d["model_max_pressure"],
+            description=d["description"],
+        )
+
+
+class PatchyCementDryShearModulusPressureModel(PatchyCementDryPressureModel):
+    """
+    Pressure sensitivity model using patchy cement dry rock properties.
+
+    This model combines friable and cemented sandstone behavior, representing
+    partially cemented sands with heterogeneous cement distribution.
+
+    Input format (n,9): [phi, k_min, mu_min, rho_min, k_cem, mu_cem, rho_cem, p_eff_in_situ, p_eff_depleted]
+
+    Where:
+    - phi: porosity [fraction]
+    - k_min: mineral bulk modulus [Pa]
+    - mu_min: mineral shear modulus [Pa]
+    - rho_min: mineral density [kg/m³]
+    - k_cem: cement bulk modulus [Pa]
+    - mu_cem: cement shear modulus [Pa]
+    - rho_cem: cement density [kg/m³]
+    - p_eff_in_situ: effective pressure in-situ [Pa]
+    - p_eff_depleted: effective pressure depleted [Pa]
+    """
+
+    def predict_abs(self, inp_arr: np.ndarray, case: str = "in_situ") -> np.ndarray:
+        """
+        Calculate absolute shear modulus for specified pressure case.
+
+        Parameters
+        ----------
+        inp_arr : np.ndarray
+            Validated input array (n,9).
+        case : str
+            Pressure case: "in_situ" or "depleted".
+
+        Returns
+        -------
+        np.ndarray
+            Shear modulus values [Pa].
+        """
+        k_dry, mu = self._compute_moduli(inp_arr, case)
+        return mu
+
+
+class PatchyCementDryBulkModulusPressureModel(PatchyCementDryPressureModel):
+    """
+    Pressure sensitivity model using patchy cement dry rock properties.
+
+    This model combines friable and cemented sandstone behavior, representing
+    partially cemented sands with heterogeneous cement distribution.
+
+    Input format (n,9): [phi, k_min, mu_min, rho_min, k_cem, mu_cem, rho_cem, p_eff_in_situ, p_eff_depleted]
+
+    Where:
+    - phi: porosity [fraction]
+    - k_min: mineral bulk modulus [Pa]
+    - mu_min: mineral shear modulus [Pa]
+    - rho_min: mineral density [kg/m³]
+    - k_cem: cement bulk modulus [Pa]
+    - mu_cem: cement shear modulus [Pa]
+    - rho_cem: cement density [kg/m³]
+    - p_eff_in_situ: effective pressure in-situ [Pa]
+    - p_eff_depleted: effective pressure depleted [Pa]
+    """
+
+    def predict_abs(self, inp_arr: np.ndarray, case: str = "in_situ") -> np.ndarray:
+        """
+        Calculate absolute bulk modulus for specified pressure case.
+
+        Parameters
+        ----------
+        inp_arr : np.ndarray
+            Validated input array (n,9).
+        case : str
+            Pressure case: "in_situ" or "depleted".
+
+        Returns
+        -------
+        np.ndarray
+            Bulk modulus values [Pa].
+        """
+        k_dry, mu = self._compute_moduli(inp_arr, case)
+        return k_dry

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"],
+        )