rock-physics-open 0.0__py3-none-any.whl

rock_physics_open/equinor_utilities/machine_learning_utilities/sigmoidal_model.py

@@ -0,0 +1,188 @@
+import pickle
+from io import BufferedIOBase
+from typing import Union
+
+import numpy as np
+
+
+class Sigmoid:
+    def __init__(
+        self,
+        amplitude: float = None,
+        median_point: float = None,
+        x_scaling: float = None,
+        bias: float = None,
+        description="",
+    ):
+        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,
+        }
+
+    @property
+    def amplitude(self):
+        return self._amplitude
+
+    @property
+    def median_point(self):
+        return self._median_point
+
+    @property
+    def x_scaling(self):
+        return self._x_scaling
+
+    @property
+    def bias(self):
+        return self._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
+
+    @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)}"
+            )
+
+    @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:
+            raise ValueError(
+                f"{type(self)}: expected input Sigmoid object, received {type(p_eff_mod)}"
+            )
+
+    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
+        )
+        velocity_depl = self._p_eff_model.predict_amp(
+            inp_arr[:, 2].flatten(), velocity_amp
+        )
+        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):
+        return {
+            "phi_model": self._phi_model.todict(),
+            "p_eff_model": self._p_eff_model.todict(),
+        }
+
+    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]):
+        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"]
+            )

rock_physics_open/equinor_utilities/snapshot_test_utilities/__init__.py

@@ -0,0 +1,10 @@
+from .compare_snapshots import compare_snapshots
+from .snapshots import INITIATE, get_snapshot_name, read_snapshot, store_snapshot
+
+__all__ = [
+    "compare_snapshots",
+    "INITIATE",
+    "get_snapshot_name",
+    "read_snapshot",
+    "store_snapshot",
+]

rock_physics_open/equinor_utilities/snapshot_test_utilities/compare_snapshots.py

@@ -0,0 +1,145 @@
+import inspect
+import math
+import re
+from typing import Union
+from warnings import warn
+
+import numpy as np
+from pandas import DataFrame
+
+from rock_physics_open.equinor_utilities.various_utilities import disp_result_stats
+
+from .snapshots import get_snapshot_name
+
+DISPLAY_RESULTS = False
+
+
+def compare_snapshots(
+    test_results: Union[np.ndarray, tuple, DataFrame],
+    saved_results: tuple,
+) -> bool:
+    test_results = _validate_input(test_results, saved_results)
+
+    if DISPLAY_RESULTS:
+        title = str(inspect.stack()[1].function)
+        name_arr = [f"arr_{i}" for i in range(len(test_results))]
+        disp_result_stats(title, test_results, name_arr)
+
+    r_tol = 0.01
+    equal_nan = True
+    no_difference_found = True
+
+    for i, (test_item, saved_item) in enumerate(zip(test_results, saved_results)):
+        try:
+            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",
+            )
+        except AssertionError as error:
+            open_mode = "w" if no_difference_found else "a"
+            no_difference_found = False
+            warn(f"comparison test failed for item {i}: {error}")
+            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")
+
+                for line in str(error).splitlines():
+                    mismatched_elements_index = (
+                        line.replace(" ", "").lower().find("mismatchedelements")
+                    )
+                    if mismatched_elements_index != -1:
+                        file.write(line + "\n")
+                        continue
+
+                    max_abs_diff_index = (
+                        line.replace(" ", "").lower().find("maxabsolutedifference")
+                    )
+                    if max_abs_diff_index != -1:
+                        file.write(line + "\n")
+                        continue
+
+                    max_rel_diff_index = (
+                        line.replace(" ", "").lower().find("maxrelativedifference")
+                    )
+                    if max_rel_diff_index != -1:
+                        file.write(line + "\n")
+                        continue
+
+                    reg_index = re.search(r"\d+ differ", line)
+
+                    if reg_index:
+                        if isinstance(test_item, np.ndarray):
+                            differences, num_nans = _compare_ndarray(
+                                saved_item, test_item, equal_nan, r_tol
+                            )
+                        elif isinstance(test_results, DataFrame):
+                            differences, num_nans = _compare_df(
+                                saved_item, test_item, equal_nan, r_tol
+                            )
+                        file.write("Number of NaN elements: " + str(num_nans) + "\n")
+                        file.write("Index:\t\tSaved:\t\tGenerated:\n")
+
+                        # Write test results and saved results differences to file
+                        if len(differences) > 0:
+                            tab = "\t"
+                            for difference in differences:
+                                file.write(
+                                    f"{tab}[{difference[0]:4}]=> {difference[1]:.4g} != {difference[2]:.4g}\n"
+                                )
+                            file.write(f"{'_' * 40}\n")
+    return no_difference_found
+
+
+def _compare_ndarray(
+    saved_array: np.ndarray, test_array: np.ndarray, eq_nan: bool, rel_tol: float
+) -> (list, int):
+    differ_indexes = np.where(saved_array != test_array)[0]
+    differences = []
+    num_nans = 0
+
+    for index in differ_indexes:
+        if eq_nan and (
+            np.isnan(test_array[int(index)]) and np.isnan(saved_array[int(index)])
+        ):
+            num_nans += 1
+        elif math.isclose(
+            saved_array[int(index)], test_array[int(index)], rel_tol=rel_tol
+        ):
+            pass
+        else:
+            differences.append([index, saved_array[index], test_array[index]])
+    return differences, num_nans
+
+
+def _compare_df(saved_results, test_results, equal_nan, r_tol):
+    return _compare_ndarray(
+        saved_results.to_numpy().flatten(),
+        test_results.to_numpy().flatten(),
+        equal_nan,
+        r_tol,
+    )
+
+
+def _validate_input(test_obj, saved_obj: tuple) -> tuple:
+    # Check for compatibility of test results and stored data
+    if isinstance(test_obj, (np.ndarray, DataFrame)):
+        return_test_obj = (test_obj,)
+    else:
+        return_test_obj = test_obj
+    if isinstance(return_test_obj, (tuple, list)):
+        if len(saved_obj) != len(return_test_obj):
+            raise ValueError(
+                f"unable to compare snapshots, different number of saved: ({len(saved_obj)})"
+                f"  and generated results ({len(test_obj)})"
+            )
+    else:
+        raise ValueError(
+            f"test_obj should be one of list, tuple, numpy array or pandas DataFrame, is {type(test_obj)}"
+        )
+    return return_test_obj

rock_physics_open/equinor_utilities/snapshot_test_utilities/snapshots.py

@@ -0,0 +1,54 @@
+import inspect
+import os
+from pathlib import Path
+
+import numpy as np
+
+INITIATE = False
+
+
+def get_snapshot_name(step: int = 1, include_snapshot_dir=True) -> str:
+    """
+
+    Parameters
+    ----------
+    step: number of steps in the trace to collect information from
+    include_snapshot_dir: absolute directory name included in snapshot name
+
+    Returns
+    -------
+    name of snapshot file
+
+    """
+    # Get filename and function name of calling function
+    trace = inspect.stack()
+    dir_name = Path(trace[step].filename).parent.joinpath("snapshots")
+    file_name = "_".join(
+        (Path(trace[step].filename).stem, trace[step].function + ".npz")
+    )
+    return os.path.join(dir_name, file_name) if include_snapshot_dir else file_name
+
+
+def store_snapshot(snapshot_name: str, *args: np.ndarray) -> bool:
+    """
+    Examples
+    --------
+    In case there are multiple arrays to store:
+    store_snapshot(snapshot_name='snap_to_store.npz', *args)
+
+    Important: If there is only one array to store:
+    store_snapshot(snapshot_name='snap_to_store.npz', args)
+    """
+    try:
+        np.savez(snapshot_name, *args)
+    except IOError as e:
+        raise IOError(f"Could not store snapshot {snapshot_name}: {e}")
+    return True
+
+
+def read_snapshot(snapshot_name: str) -> tuple:
+    try:
+        with np.load(snapshot_name) as stored_npz:
+            return tuple(stored_npz[arr_name] for arr_name in stored_npz.files)
+    except IOError as e:
+        raise ValueError(f"unable to load snapshot {snapshot_name}: {e}")

rock_physics_open/equinor_utilities/std_functions/__init__.py

@@ -0,0 +1,43 @@
+from .backus_ave import backus_average
+from .dvorkin_nur import dvorkin_contact_cement
+from .gassmann import gassmann, gassmann2, gassmann_dry
+from .hashin_shtrikman import (
+    hashin_shtrikman,
+    hashin_shtrikman_average,
+    hashin_shtrikman_walpole,
+    multi_hashin_shtrikman,
+)
+from .hertz_mindlin import hertz_mindlin
+from .moduli_velocity import moduli, velocity
+from .reflection_eq import aki_richards, smith_gidlow
+from .rho import rho_b, rho_m
+from .voigt_reuss_hill import multi_voigt_reuss_hill, reuss, voigt, voigt_reuss_hill
+from .walton import walton_smooth
+from .wood_brie import brie, multi_wood, wood
+
+__all__ = [
+    "backus_average",
+    "dvorkin_contact_cement",
+    "gassmann",
+    "gassmann2",
+    "gassmann_dry",
+    "hashin_shtrikman",
+    "hashin_shtrikman_average",
+    "hashin_shtrikman_walpole",
+    "multi_hashin_shtrikman",
+    "hertz_mindlin",
+    "moduli",
+    "velocity",
+    "aki_richards",
+    "smith_gidlow",
+    "rho_b",
+    "rho_m",
+    "multi_voigt_reuss_hill",
+    "reuss",
+    "voigt",
+    "voigt_reuss_hill",
+    "walton_smooth",
+    "brie",
+    "multi_wood",
+    "wood",
+]

rock_physics_open/equinor_utilities/std_functions/backus_ave.py

@@ -0,0 +1,53 @@
+import numpy as np
+
+
+def backus_average(vp1, vs1, rho1, vp2, vs2, rho2, f1):
+    """
+    Backus average for a combination of two phases. The individual phases are isotropic
+    but the resulting effective medium is not.
+
+    Parameters
+    ----------
+    vp1 : np.ndarray
+        Pressure wave velocity for phase 1 [m/s].
+    vs1 : np.ndarray
+        Shear wave velocity for phase 1 [m/s].
+    rho1 : np.ndarray
+        Density for phase 1 [kg/m^3].
+    vp2 : np.ndarray
+        Pressure wave velocity for phase 2 [m/s].
+    vs2 : np.ndarray
+        Shear wave velocity for phase 2 [m/s].
+    rho2 : np.ndarray
+        Density for phase 2 [kg/m^3].
+    f1 : np.ndarray
+        Fraction of phase 1.
+
+    Returns
+    -------
+    tuple
+        vpv, vsv, vph, vsh, rho : np.ndarray
+        vpv: vertical pressure velocity, vsv: vertical shear velocity, vph: horizontal pressure velocity,
+        vsh: horizontal shear velocity, rho: density.
+    """
+
+    a = (
+        4 * f1 * rho1 * vs1**2 * (1 - vs1**2 / vp1**2)
+        + 4 * (1 - f1) * rho2 * vs2**2 * (1 - (vs2 / vp2) ** 2)
+        + (f1 * (1 - 2 * (vs1 / vp1) ** 2) + (1 - f1) * (1 - 2 * (vs2 / vp2) ** 2)) ** 2
+        * (1 / (f1 / (rho1 * vp1**2) + (1 - f1) / (rho2 * vp2**2)))
+    )
+
+    c = 1 / (f1 / (rho1 * vp1**2) + (1 - f1) / (rho2 * vp2**2))
+    d = 1 / (f1 / (rho1 * vs1**2) + (1 - f1) / (rho2 * vs2**2))
+
+    m = f1 * rho1 * vs1**2 + (1 - f1) * rho2 * vs2**2
+
+    rho = f1 * rho1 + (1 - f1) * rho2
+
+    vpv = np.sqrt(c / rho)
+    vsv = np.sqrt(d / rho)
+    vph = np.sqrt(a / rho)
+    vsh = np.sqrt(m / rho)
+
+    return vpv, vsv, vph, vsh, rho

rock_physics_open/equinor_utilities/std_functions/dvorkin_nur.py

@@ -0,0 +1,69 @@
+import numpy as np
+
+
+def dvorkin_contact_cement(
+    frac_cem, por0_sst, mu0_sst, k0_sst, mu0_cem, k0_cem, vs_red, c
+):
+    """
+    Dvorkin-Nur contact cement model for estimation of elastic moduli.
+
+    Parameters
+    ----------
+    frac_cem : numpy.ndarray
+        Cement fraction of volume [ratio].
+    por0_sst : numpy.ndarray
+        Critical porosity of sand [ratio].
+    mu0_sst : numpy.ndarray
+        Mineral shear modulus of sand [Pa].
+    k0_sst : numpy.ndarray
+        Mineral bulk modulus of sand [Pa].
+    mu0_cem : numpy.ndarray
+        Mineral shear modulus of cement [Pa].
+    k0_cem : numpy.ndarray
+        Mineral bulk modulus of cement [Pa].
+    vs_red : numpy.ndarray
+        Shear modulus reduction factor [ratio].
+    c : float
+        Coordination number (grain contacts per grain) [unitless].
+
+    Returns
+    -------
+    tuple
+        k_cc, mu_cc : numpy.ndarray.
+        k_cc: bulk modulus [Pa], mu_cc: shear modulus [Pa].
+    """
+    alpha = (2 * frac_cem / (3 * (1 - por0_sst))) ** 0.5
+    poiss = (3 * k0_sst - 2 * mu0_sst) / (2 * (3 * k0_sst + mu0_sst))
+    poiss_c = (3 * k0_cem - 2 * mu0_cem) / (2 * (3 * k0_cem + mu0_cem))
+    a_an = (2 * mu0_cem / (np.pi * mu0_sst)) * (
+        (1 - poiss) * (1 - poiss_c) / (1 - 2 * poiss_c)
+    )
+    a_at = mu0_cem / (np.pi * mu0_sst)
+
+    a_t = (
+        -1e-2
+        * (2.26 * poiss**2 + 2.07 * poiss + 2.3)
+        * a_at ** (0.079 * poiss**2 + 0.1754 * poiss - 1.342)
+    )
+    b_t = (0.0573 * poiss**2 + 0.0937 * poiss + 0.202) * a_at ** (
+        0.0274 * poiss**2 + 0.0529 * poiss - 0.8765
+    )
+    c_t = (
+        1e-4
+        * (9.654 * poiss**2 + 4.945 * poiss + 3.1)
+        * a_at ** (0.01867 * poiss**2 + 0.4011 * poiss - 1.8186)
+    )
+
+    s_t = a_t * alpha**2 + b_t * alpha + c_t
+
+    c_n = 0.00024649 * a_an ** (-1.9864)
+    b_n = 0.20405 * a_an ** (-0.89008)
+    a_n = -0.024153 * a_an ** (-1.3646)
+
+    s_n = a_n * alpha**2 + b_n * alpha + c_n
+
+    m0_cem = k0_cem + 4 / 3 * mu0_cem
+    k_cc = (1 / 6) * c * (1 - por0_sst) * m0_cem * s_n
+    mu_cc = (3 / 5) * k_cc + vs_red * (3 / 20) * c * (1 - por0_sst) * mu0_cem * s_t
+
+    return k_cc, mu_cc

rock_physics_open/equinor_utilities/std_functions/gassmann.py

@@ -0,0 +1,140 @@
+import warnings
+
+import numpy as np
+
+from rock_physics_open.equinor_utilities.gen_utilities import dim_check_vector
+
+
+def gassmann(k_dry, por, k_fl, k_min):
+    """
+    Fluid substitution according to the Gassmann equation.
+
+    Parameters
+    ----------
+    k_dry : np.ndarray
+        Dry rock bulk modulus [Pa].
+    por : np.ndarray
+        Porosity [fraction].
+    k_fl : np.ndarray
+        Fluid bulk modulus.
+    k_min : np.ndarray
+        Mineral bulk modulus [Pa].
+
+    Returns
+    -------
+    np.ndarray
+        k_sat: bulk modulus for saturated rock [Pa]
+    """
+    k_dry, por, k_fl, k_min = dim_check_vector((k_dry, por, k_fl, k_min))
+
+    idx = np.logical_or(k_dry == k_min, por == 0)
+    k_sat = np.ones(k_dry.shape) * np.nan
+    b = k_dry[~idx] / (k_min[~idx] - k_dry[~idx]) + k_fl[~idx] / (
+        (k_min[~idx] - k_fl[~idx]) * por[~idx]
+    )
+    idx1 = b < 0
+    if any(idx1):
+        b[idx1] = np.nan
+
+    k_sat[~idx] = b / (1 + b) * k_min[~idx]
+    k_sat[idx] = k_min[idx]
+
+    return k_sat
+
+
+def gassmann2(k_sat_1, k_fl_1, k_fl_2, por, k_min):
+    """
+    Fluid substitution by Gassmann method with substitution of one fluid to another
+
+    Parameters
+    ----------
+    k_sat_1 : np.ndarray
+        bulk modulus for saturated rock with original fluid [Pa]
+    k_fl_1 : np.ndarray
+        bulk modulus for original fluid [Pa]
+    k_fl_2 : np.ndarray
+        bulk modulus for replaced fluid [Pa]
+    por : np.ndarray
+        porosity of rock [fraction]
+    k_min : np.ndarray
+        mineral bulk modulus of rock [Pa]
+
+    Returns
+    -------
+    np.ndarray
+        k_sat_2: bulk modulus of rock saturated with replaced fluid [Pa]
+    """
+    k_sat_1, k_fl_1, k_fl_2, por, k_min = dim_check_vector(
+        (k_sat_1, k_fl_1, k_fl_2, por, k_min)
+    )
+
+    idx = np.any(
+        np.array([k_sat_1 == k_min, por == 0, k_fl_1 == k_min, k_fl_2 == k_min]), axis=0
+    )
+
+    k_sat_2 = np.ones(k_sat_1.shape) * np.nan
+
+    b = (
+        k_fl_2[~idx] / (por[~idx] * (k_min[~idx] - k_fl_2[~idx]))
+        - k_fl_1[~idx] / (por[~idx] * (k_min[~idx] - k_fl_1[~idx]))
+        + k_sat_1[~idx] / (k_min[~idx] - k_sat_1[~idx])
+    )
+
+    idx1 = b < 0
+    if any(idx1):
+        warn_str = (
+            "{0:d} unstable solution(s) to Gassmann equation, changed to NaN".format(
+                np.sum(idx1)
+            )
+        )
+        warnings.warn(warn_str, UserWarning)
+        b[idx1] = np.nan
+
+    k_sat_2[~idx] = b / (1 + b) * k_min[~idx]
+    k_sat_2[idx] = k_sat_1[idx]
+
+    return k_sat_2
+
+
+def gassmann_dry(k_sat, por, k_fl, k_min):
+    """
+    Dry rock properties of saturated rock by Gassmann equation
+
+    Parameters
+    ----------
+    k_sat : np.ndarray
+        saturated rock bulk modulus [Pa]
+    por : np.ndarray
+        porosity of rock [fraction]
+    k_fl : np.ndarray
+        bulk modulus of fluid [Pa]
+    k_min : np.ndarray
+        bulk modulus of mineral [Pa]
+
+    Returns
+    -------
+    np.ndarray
+        k_dry: dry rock bulk modulus [Pa]
+    """
+    k_sat, por, k_fl, k_min = dim_check_vector((k_sat, por, k_fl, k_min))
+
+    idx = np.any(np.array([k_sat == k_min, por == 0, k_fl == k_min]), axis=0)
+    k_dry = np.ones(k_sat.shape)
+    b = k_sat[~idx] / (k_min[~idx] - k_sat[~idx]) - k_fl[~idx] / (
+        (k_min[~idx] - k_fl[~idx]) * por[~idx]
+    )
+
+    idx1 = b < 0
+    if any(idx1):
+        warn_str = (
+            "{0:d} unstable solution(s) to Gassmann equation, changed to NaN".format(
+                np.sum(idx1)
+            )
+        )
+        warnings.warn(warn_str, UserWarning)
+        b[idx1] = np.nan
+
+    k_dry[~idx] = b / (1 + b) * k_min[~idx]
+    k_dry[idx] = k_min[idx]
+
+    return k_dry