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

rock_physics_open/fluid_models/oil_model/oil_properties.py

@@ -0,0 +1,146 @@
+import warnings
+
+import numpy as np
+
+from .dead_oil_density import dead_oil_density
+from .dead_oil_velocity import dead_oil_velocity
+from .live_oil_density import live_oil_density
+from .live_oil_velocity import live_oil_velocity
+from .oil_bubble_point import bp_standing
+
+
+def oil_properties(
+    temperature: np.ndarray | float,
+    pressure: np.ndarray | float,
+    rho0: np.ndarray | float,
+    gas_oil_ratio: np.ndarray | float,
+    gas_gravity: np.ndarray | float,
+) -> np.ndarray | float:
+    """
+    :param temperature: Temperature [°C] of oil.
+    :param pressure: Pressure [Pa] of oil
+    :param rho0: Density of the oil without dissolved gas at 15.6 degrees Celsius and
+                 atmospheric pressure. [kg/m^3]
+    :param gas_oil_ratio: The volume ratio of gas to oil [l/l]
+    :param gas_gravity: Gas Gravity, molar mass of gas relative to air molar mas.
+    :return: vel_oil [m/s], den_oil [kg/m^3], k_oil [Pa]
+    """
+    # Since live_oil with gas_oil_ratio=0.0 is not equal to dead oil
+    # we use an apodization function to interpolate between the two
+
+    def triangular_window(x, length=2):
+        """
+        A triangular window function around the origin, 1.0 at x=0.0, linear
+        and 0.0 outside the window.
+        :param length: total length of the window, ie., function is nonzero in
+            [-length/2, length/2].
+        :param x: numpy array containing x'es to evaluate the window at
+        :return: value of window function at x.
+        """
+        x = np.asarray(x)  # Ensure x is a numpy array
+        window = np.clip((np.abs(x) - length / 2) / (length / 2), 0, 1)
+        return 1 - window
+
+    (
+        loil_vel,
+        loil_den,
+    ) = live_oil(temperature, pressure, rho0, gas_oil_ratio, gas_gravity)
+    doil_vel, doil_den = dead_oil(temperature, pressure, rho0)
+    window = triangular_window(gas_oil_ratio)
+    den_oil = doil_den * window + (1 - window) * loil_den
+    vel_oil = doil_vel * window + (1 - window) * loil_vel
+    k_oil = vel_oil**2 * den_oil
+    return vel_oil, den_oil, k_oil
+
+
+def dead_oil(
+    temperature: np.ndarray | float,
+    pressure: np.ndarray | float,
+    reference_density: np.ndarray | float,
+) -> tuple[np.ndarray | float, np.ndarray | float]:
+    """
+    :param reference_density: Density of the oil without dissolved gas
+        at 15.6 degrees Celsius and atmospheric pressure. [kg/m^3]
+    :param gas_oil_ratio: The volume ratio of gas to oil [l/l]
+    :param gas_gravity: molar mass of gas relative to air molar mas.
+    :param pressure: Pressure [Pa] of oil
+    :param temperature: Temperature [°C] of oil.
+    :return: dead_oil_density [kg/m^3], dead_oil_velocity [m/s]
+    """
+    dead_oil_den = dead_oil_density(temperature, pressure, reference_density)
+    dead_oil_vel = dead_oil_velocity(temperature, pressure, reference_density)
+    return dead_oil_vel, dead_oil_den
+
+
+def live_oil(
+    temperature: np.ndarray | float,
+    pressure: np.ndarray | float,
+    reference_density: np.ndarray | float,
+    gas_oil_ratio: np.ndarray | float,
+    gas_gravity: np.ndarray | float,
+) -> tuple[np.ndarray | float, np.ndarray | float]:
+    """
+    :param reference_density: Density of the oil without dissolved gas
+        at 15.6 degrees Celsius and atmospheric pressure. [kg/m^3]
+    :param gas_oil_ratio: The volume ratio of gas to oil [l/l]
+    :param gas_gravity: molar mass of gas relative to air molar mas.
+    :param pressure: Pressure [Pa] of oil
+    :param temperature: Temperature [°C] of oil.
+    :return: live_oil_density , live_oil_velocity
+    """
+    if np.any(
+        pressure
+        < bp_standing(reference_density, gas_oil_ratio, gas_gravity, temperature)
+    ):
+        warnings.warn(
+            "Pressure is below bubble point of oil, estimated elastic properties can be inaccurate",
+            stacklevel=1,
+        )
+    live_oil_den = live_oil_density(
+        temperature,
+        pressure,
+        reference_density,
+        gas_oil_ratio,
+        gas_gravity,
+    )
+    live_oil_vel = live_oil_velocity(
+        temperature,
+        pressure,
+        reference_density,
+        gas_oil_ratio,
+        gas_gravity,
+    )
+    return (
+        live_oil_vel,
+        live_oil_den,
+    )
+
+
+def oil_viscosity(
+    temperature: np.ndarray | float,
+    pressure: np.ndarray | float,
+    reference_density: np.ndarray | float,
+) -> np.ndarray | float:
+    """
+    Calculate dead oil viscosity. If dissolved gas is present in the oil, the reference density
+    should be substituted by live oil density.
+
+    Equations 25a, 25b, 26a & 26b in Batzle and Wang 1992
+
+    Based on Beggs and Robinson 1975
+
+    :param temperature: Temperature [°C] of oil
+    :param pressure: Pressure [Pa] of oil
+    :param reference_density: Density of the oil without dissolved gas
+    """
+    # Change unit in pressure to MPa
+    pressure_mpa = pressure / 1.0e6
+    # Change unit in density to g/cc
+    density_gcc = reference_density / 1000.0
+
+    y_factor = 10 ** (5.693 - 2.863 / density_gcc)
+    eta_t = -1.0 + 10 ** (0.505 * y_factor * (17.8 + temperature) ** -1.163)
+    i_factor = 10 ** (
+        18.6 * (0.1 * np.log10(eta_t) + (np.log10(eta_t) + 2) ** -0.1 - 0.985)
+    )
+    return eta_t + 0.145 * pressure_mpa * i_factor

rock_physics_open/sandstone_models/__init__.py

@@ -0,0 +1,59 @@
+from .cemented_shalysand_sandyshale_models import cemented_shaly_sand_sandy_shale_model
+from .constant_cement_models import (
+    constant_cement_model,
+    constant_cement_model_dry,
+)
+from .constant_cement_optimisation import constant_cement_model_optimisation
+from .contact_cement_model import contact_cement_model
+from .curvefit_sandstone_models import (
+    curvefit_constant_cement,
+    curvefit_friable,
+    curvefit_patchy_cement,
+)
+from .friable_models import (
+    friable_model,
+    friable_model_dry,
+)
+from .friable_optimisation import friable_model_optimisation
+from .friable_shalysand_sandyshale_models import friable_shaly_sand_sandy_shale_model
+from .patchy_cement_fluid_substitution_model import (
+    patchy_cement_pressure_fluid_substitution,
+)
+from .patchy_cement_model import (
+    constant_cement_model_pcm,
+    patchy_cement_model_cem_frac,
+    patchy_cement_model_dry,
+    patchy_cement_model_weight,
+)
+from .patchy_cement_optimisation import (
+    patchy_cement_model_optimisation,
+    patchy_cement_model_optimisation_multiwell,
+)
+from .unresolved_cemented_sandshale_models import (
+    unresolved_constant_cement_sand_shale_model,
+)
+from .unresolved_friable_sandshale_models import unresolved_friable_sand_shale_model
+
+__all__ = [
+    "cemented_shaly_sand_sandy_shale_model",
+    "constant_cement_model",
+    "constant_cement_model_dry",
+    "constant_cement_model_optimisation",
+    "contact_cement_model",
+    "curvefit_constant_cement",
+    "curvefit_friable",
+    "curvefit_patchy_cement",
+    "friable_model",
+    "friable_model_dry",
+    "friable_model_optimisation",
+    "friable_shaly_sand_sandy_shale_model",
+    "patchy_cement_pressure_fluid_substitution",
+    "constant_cement_model_pcm",
+    "patchy_cement_model_dry",
+    "patchy_cement_model_cem_frac",
+    "patchy_cement_model_weight",
+    "patchy_cement_model_optimisation",
+    "patchy_cement_model_optimisation_multiwell",
+    "unresolved_constant_cement_sand_shale_model",
+    "unresolved_friable_sand_shale_model",
+]

rock_physics_open/sandstone_models/cemented_shalysand_sandyshale_models.py

@@ -0,0 +1,304 @@
+import numpy as np
+
+from rock_physics_open import sandstone_models
+from rock_physics_open.equinor_utilities import gen_utilities, std_functions
+
+
+def cemented_shaly_sand_sandy_shale_model(
+    k_sst,
+    mu_sst,
+    rho_sst,
+    k_cem,
+    mu_cem,
+    rho_cem,
+    k_mud,
+    mu_mud,
+    rho_mud,
+    k_fl_sst,
+    rho_fl_sst,
+    k_fl_mud,
+    rho_fl_mud,
+    phi,
+    p_eff_mud,
+    shale_frac,
+    frac_cem,
+    phi_c_sst,
+    n_sst,
+    shear_red_sst,
+    phi_c_mud,
+    phi_intr_mud,
+    coord_num_func_mud,
+    n_mud,
+    shear_red_mud,
+):
+    """
+    Model for mixing of cemented sand and friable shale.
+
+    It is no point to use this model to calculate the shale response only,
+    in that case Friable Model with shale parameters does the job
+
+    The shale fluid should be brine.
+
+    Shale fraction shaleFrac is in the range 0 to 1. For shaleFrac = 0 we
+    have a pure sand end member with phi =< phi_c for sand. For shaleFrac = 1
+    we have pure shale with phi = intrinsic porosity. For shaleFrac < phi_c
+    the model is on the shaly sand trend, for shaleFrac > phi_c it is on the
+    sandy shale trend.
+
+    Parameters
+    ----------
+    k_sst : np.ndarray
+        Sandstone matrix bulk modulus [Pa].
+    mu_sst : np.ndarray
+        Sandstone matrix shear modulus [Pa].
+    rho_sst : np.ndarray
+        Sandstone matrix bulk density [kg/m^3].
+    k_cem : np.ndarray
+        Sandstone cement bulk modulus [Pa].
+    mu_cem : np.ndarray
+        Sandstone cement shear modulus [Pa].
+    rho_cem : np.ndarray
+        Sandstone cement bulk density [kg/m^3].
+    k_mud : np.ndarray
+        Shale bulk modulus [Pa].
+    mu_mud : np.ndarray
+        Shale shear modulus [Pa].
+    rho_mud : np.ndarray
+        Shale bulk density [kg/m^3].
+    k_fl_sst : np.ndarray
+        Fluid bulk modulus for sandstone fluid [Pa].
+    rho_fl_sst : np.ndarray
+        Fluid bulk density for sandstone fluid [kg/m^3].
+    k_fl_mud : np.ndarray
+        Fluid bulk modulus for shale fluid [Pa].
+    rho_fl_mud : np.ndarray
+        Fluid bulk density for shale fluid[kg/m^3].
+    phi : np.ndarray
+        Total porosity [fraction].
+    p_eff_mud : np.ndarray
+        Effective pressure in mud [Pa].
+    shale_frac : np.ndarray
+        Shale fraction [fraction].
+    frac_cem : np.ndarray
+        Cement volume fraction [fraction].
+    phi_c_sst : float
+        Critical porosity for sandstone[fraction].
+    phi_c_mud : float
+        Critical porosity for mud [fraction].
+    phi_intr_mud : float
+        Intrinsic porosity for mud [fraction].
+    n_sst : float
+        Coordination number for sandstone [unitless].
+    n_mud : float
+        Coordination number for shale [unitless].
+    coord_num_func_mud : str
+        Indication if coordination number should be calculated from porosity or kept constant for shale.
+    shear_red_sst : float
+        Shear reduction factor for sandstone [fraction].
+    shear_red_mud : float
+        Shear reduction factor for mud [fraction].
+
+    Returns
+    -------
+    tuple
+        vp, vs, rho, ai, vpvs  : (np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray)
+        vp [m/s] and vs [m/s], bulk density [kg/m^3], ai [m/s x kg/m^3], vpvs [ratio] of saturated rock.
+    """
+
+    # Valid porosity values must not exceed (phi_c - frac_cem)
+    # Assume that this only needs to be considered for the sandstone fraction
+    (
+        k_sst,
+        mu_sst,
+        rho_sst,
+        k_cem,
+        mu_cem,
+        rho_cem,
+        k_mud,
+        mu_mud,
+        rho_mud,
+        k_fl_sst,
+        rho_fl_sst,
+        k_fl_mud,
+        rho_fl_mud,
+        phi,
+        p_eff_mud,
+        shale_frac,
+        frac_cem,
+    ) = gen_utilities.dim_check_vector(
+        (
+            k_sst,
+            mu_sst,
+            rho_sst,
+            k_cem,
+            mu_cem,
+            rho_cem,
+            k_mud,
+            mu_mud,
+            rho_mud,
+            k_fl_sst,
+            rho_fl_sst,
+            k_fl_mud,
+            rho_fl_mud,
+            phi,
+            p_eff_mud,
+            shale_frac,
+            frac_cem,
+        )
+    )
+    (
+        idx_phi,
+        (
+            k_sst,
+            mu_sst,
+            rho_sst,
+            k_cem,
+            mu_cem,
+            rho_cem,
+            k_mud,
+            mu_mud,
+            rho_mud,
+            k_fl_sst,
+            rho_fl_sst,
+            k_fl_mud,
+            rho_fl_mud,
+            phi,
+            p_eff_mud,
+            shale_frac,
+            frac_cem,
+            _,
+            _,
+        ),
+    ) = gen_utilities.filter_input_log(
+        (
+            k_sst,
+            mu_sst,
+            rho_sst,
+            k_cem,
+            mu_cem,
+            rho_cem,
+            k_mud,
+            mu_mud,
+            rho_mud,
+            k_fl_sst,
+            rho_fl_sst,
+            k_fl_mud,
+            rho_fl_mud,
+            phi,
+            p_eff_mud,
+            shale_frac,
+            frac_cem,
+            phi_c_sst - frac_cem - phi,
+            phi - phi_intr_mud,
+        ),
+        no_zero=False,
+    )
+
+    # Reduce range of porosity by frac_cem
+    phi_c = phi_c_sst - frac_cem
+
+    sandy_shale_idx = shale_frac > phi
+    shaly_sand_idx = ~sandy_shale_idx
+
+    # Fraction of silt in silt - shale trend
+    frac_silt = (1 - shale_frac) / (1 - phi)
+    # Fraction of sand in sand - silt trend
+    frac_sand = 1 - shale_frac / phi
+
+    # Shale properties for intrinsic porosity point NB!  The phi_intr_mud is
+    # normally a parameter, but the assumption in Friable model is that it is a
+    # log.  Make sure that it is of the same length as the other
+
+    # Expand the needed variables from float to numpy array
+    phi, phi_intr_mud = gen_utilities.dim_check_vector((phi, phi_intr_mud))
+
+    vp_sat_mud, vs_sat_mud, rho_b_mud = sandstone_models.friable_model(
+        k_mud,
+        mu_mud,
+        rho_mud,
+        k_fl_mud,
+        rho_fl_mud,
+        phi_intr_mud,
+        p_eff_mud,
+        phi_c_mud,
+        coord_num_func_mud,
+        n_mud,
+        shear_red_mud,
+    )[0:3]
+    k_sat_mud, mu_sat_mud = std_functions.moduli(vp_sat_mud, vs_sat_mud, rho_b_mud)
+
+    # Calculate cemented zero-porosity sand
+    k_zero, mu_zero = std_functions.hashin_shtrikman_walpole(
+        k_cem, mu_cem, k_sst, mu_sst, frac_cem, bound="lower"
+    )
+    rho_zero = rho_cem * frac_cem + (1 - frac_cem) * rho_sst
+
+    # Silt end member
+    k_silt, mu_silt = std_functions.hashin_shtrikman_walpole(
+        k_sat_mud, mu_sat_mud, k_zero, mu_zero, phi_c
+    )
+    rho_silt = rho_b_mud * phi + rho_zero * (1 - phi)
+
+    # Estimate the sand end member through the constant cement model with phi =
+    # phiCSst <= maybe dubious to expand parameter to vector with assumption
+    # that kSst has the correct size
+
+    vp_sat_sst, vs_sat_sst, rho_sat_sst = sandstone_models.constant_cement_model(
+        k_sst,
+        mu_sst,
+        rho_sst,
+        k_cem,
+        mu_cem,
+        rho_cem,
+        k_fl_sst,
+        rho_fl_sst,
+        phi,
+        frac_cem,
+        phi_c_sst,
+        n_sst,
+        shear_red_sst,
+    )[0:3]
+    k_sat_sst, mu_sat_sst = std_functions.moduli(vp_sat_sst, vs_sat_sst, rho_sat_sst)
+
+    k = np.ones(shale_frac.shape) * np.nan
+    mu = np.ones(shale_frac.shape) * np.nan
+    rhob = np.ones(shale_frac.shape) * np.nan
+
+    # Points on sandy shale trend
+    k[sandy_shale_idx], mu[sandy_shale_idx] = std_functions.hashin_shtrikman_walpole(
+        k_silt[sandy_shale_idx],
+        mu_silt[sandy_shale_idx],
+        k_sat_mud[sandy_shale_idx],
+        mu_sat_mud[sandy_shale_idx],
+        frac_silt[sandy_shale_idx],
+    )
+
+    rhob[sandy_shale_idx] = (
+        rho_b_mud[sandy_shale_idx] * (1 - frac_silt[sandy_shale_idx])
+        + rho_silt[sandy_shale_idx] * frac_silt[sandy_shale_idx]
+    )
+
+    # Points on shaly sand trend
+    k[shaly_sand_idx], mu[shaly_sand_idx] = std_functions.hashin_shtrikman_walpole(
+        k_sat_sst[shaly_sand_idx],
+        mu_sat_sst[shaly_sand_idx],
+        k_silt[shaly_sand_idx],
+        mu_silt[shaly_sand_idx],
+        frac_sand[shaly_sand_idx],
+    )
+
+    rhob[shaly_sand_idx] = (
+        (1 - phi[shaly_sand_idx]) * rho_zero[shaly_sand_idx]
+        + phi[shaly_sand_idx] * rho_fl_sst[shaly_sand_idx]
+    ) * frac_sand[shaly_sand_idx] + (1 - frac_sand[shaly_sand_idx]) * rho_silt[
+        shaly_sand_idx
+    ]
+
+    vp, vs, ai, vpvs = std_functions.velocity(k, mu, rhob)
+
+    # Restore original length
+    vp, vs, rhob, ai, vpvs = gen_utilities.filter_output(
+        idx_phi, (vp, vs, rhob, ai, vpvs)
+    )
+
+    return vp, vs, rhob, ai, vpvs

rock_physics_open/sandstone_models/constant_cement_models.py

@@ -0,0 +1,204 @@
+import numpy as np
+from scipy.interpolate import interp1d
+
+from rock_physics_open.equinor_utilities import gen_utilities, std_functions
+
+
+def constant_cement_model(
+    k_min,
+    mu_min,
+    rho_min,
+    k_cem,
+    mu_cem,
+    rho_cem,
+    k_fl,
+    rho_fl,
+    phi,
+    frac_cem,
+    phi_c,
+    n,
+    shear_red,
+    extrapolate_to_max_phi=False,
+):
+    """
+    Constant cement model is a sandstone model that combined a cemented and a friable sand, so that a constant
+    proportion of the rock volume is made up of grain-bonding cement. Variation in porosity is due to grain sorting,
+    i.e. a well-sorted sand will have high porosity, and a poorly sorted one will have low porosity. In the extreme
+    end all porosity is removed and the effective mineral properties is returned.
+
+    Mineral properties k_min, mu_min, rho_min are effective properties. For mixtures of minerals, effective
+    properties are calculated by Hashin-Shtrikman or similar.
+
+    Cement properties k_cem, mu_cem, rho_cem and cement fraction, the latter as a part of the whole volume.
+
+    Fluid properties k_fl, rho_fl are in situ properties calculated by fluid models using reservoir properties.
+
+    Critical porosity phi_c is input to Dvorkin-Nur function. Coordination number n is normally set to a fixed
+    value (default 9) but it is possible to  override this. Porosity phi is used in Hashin-Shtrikman mixing
+    (together with phi_c) and Gassmann saturation.
+
+    Shear reduction parameter shear_red is used to account for tangential frictionless grain contacts
+
+    All inputs are assumed to be vectors of the same length
+
+    Parameters
+    ----------
+    k_min : np.ndarray
+        Mineral bulk modulus [Pa].
+    mu_min : np.ndarray
+        Mineral shear modulus [Pa].
+    rho_min : np.ndarray
+        Mineral bulk density [kg/m^3].
+    k_cem : np.ndarray
+        Cement bulk modulus [Pa].
+    mu_cem : np.ndarray
+        Cement shear modulus [Pa].
+    rho_cem : np.ndarray
+        Cement bulk density [kg/m^3].
+    k_fl : np.ndarray
+        Fluid bulk modulus [Pa].
+    rho_fl : np.ndarray
+        Fluid bulk density [kg/m^3].
+    phi : np.ndarray
+        Porosity [fraction].
+    frac_cem : np.ndarray or float
+        Cement fraction [fraction].
+    phi_c : float
+        Critical porosity [fraction].
+    n : float
+        Coordination number [unitless].
+    shear_red : float
+        Shear reduction factor [fraction].
+    extrapolate_to_max_phi : bool
+        If True, the model will extrapolate to the maximum porosity value (phi_c - frac_cem) if the input porosity
+        exceeds this value. If False, the model will return NaN for porosity values exceeding this limit.
+
+    Returns
+    -------
+    tuple
+        vp, vs, rho, ai, vpvs  : (np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray)
+        vp [m/s] and vs [m/s], bulk density [kg/m^3], ai [m/s x kg/m^3], vpvs [ratio] of saturated rock.
+    """
+    k_zero, k_dry, mu = constant_cement_model_dry(
+        k_min,
+        mu_min,
+        k_cem,
+        mu_cem,
+        phi,
+        frac_cem,
+        phi_c,
+        n,
+        shear_red,
+        extrapolate_to_max_phi=extrapolate_to_max_phi,
+        return_k_zero=True,
+    )
+    # Saturated rock incompressibility is calculated with Gassmann
+    k = std_functions.gassmann(k_dry, phi, k_fl, k_zero)
+
+    # Bulk density
+    rho = phi * rho_fl + (1 - phi - frac_cem) * rho_min + frac_cem * rho_cem
+    # Velocity
+    vp, vs, ai, vpvs = std_functions.velocity(k, mu, rho)
+
+    return vp, vs, rho, ai, vpvs
+
+
+def constant_cement_model_dry(
+    k_min,
+    mu_min,
+    k_cem,
+    mu_cem,
+    phi,
+    frac_cem,
+    phi_c,
+    n,
+    shear_red,
+    extrapolate_to_max_phi=False,
+    return_k_zero=False,
+):
+    """
+    Dry rock version of the constant cement model. The method is identical to the constant cement model function,
+    except that a saturation step is not performed at the end.
+
+    Parameters
+    ----------
+    k_min : np.ndarray
+        Mineral bulk modulus [Pa].
+    mu_min : np.ndarray
+        Mineral shear modulus [Pa].
+    k_cem : np.ndarray
+        Cement bulk modulus [Pa].
+    mu_cem : np.ndarray
+        Cement shear modulus [Pa].
+    phi : np.ndarray
+        Porosity [fraction].
+    frac_cem : float or np.ndarray
+        Cement fraction [fraction].
+    phi_c : float
+        Critical porosity [fraction].
+    n : float
+        Coordination number [unitless].
+    shear_red : float
+        Shear reduction factor [fraction].
+    extrapolate_to_max_phi : bool
+        If True, the model will extrapolate to the maximum porosity value (phi_c - frac_cem) if the input porosity
+        exceeds this value. If False, the model will return NaN for porosity values exceeding this limit.
+    return_k_zero : bool
+        If True, the model will return the zero-porosity end member bulk modulus k_zero in addition to the dry rock
+        bulk modulus k_dry and shear modulus mu.
+
+    Returns
+    -------
+    tuple
+        k_dry, mu : (np.ndarray, np.ndarray).
+        Bulk modulus k [Pa] and shear modulus mu [Pa] of dry rock.
+    """
+    # First check if there are input values that are unphysical, i.e. negative values, separate between dry and
+    # saturated rock properties. Use the filter_input_log function to identify these values
+    idx, (k_min, mu_min, k_cem, mu_cem, phi) = gen_utilities.filter_input_log(
+        (k_min, mu_min, k_cem, mu_cem, phi)
+    )
+
+    # Identify porosity values that exceed (phi_c - frac_cem). This is regardless of setting for extrapolate_to_max_phi
+    idx_phi = np.where(phi > phi_c - frac_cem)[0]
+
+    # At the zero-porosity point, all original porosity (critical porosity -
+    # cement fraction) is filled with grains. The cement fraction surrounds the
+    # original grains, so they will be fraction 1 according to the geometrical
+    # interpretation of Hashin-Shtrikman
+    k_zero, mu_zero = std_functions.hashin_shtrikman_walpole(
+        k_cem, mu_cem, k_min, mu_min, frac_cem, bound="lower"
+    )
+
+    # Dry rock properties of high-porosity end member calculated with
+    # Dvorkin-Nur equation. Cement is assumed to be evenly distributed on the
+    # grains (scheme 2 in Dvorkin and Nur's original paper)
+
+    k_cc, mu_cc = std_functions.dvorkin_contact_cement(
+        frac_cem, phi_c, mu_min, k_min, mu_cem, k_cem, shear_red, n
+    )
+
+    # Hashin-Shtrikman lower bound describes the dry rock property mixing from
+    # mineral properties to high-end porosity.
+
+    # Fraction of zero-porosity end member
+    f1 = 1 - phi / (phi_c - frac_cem)
+
+    k_dry, mu = std_functions.hashin_shtrikman_walpole(
+        k_zero, mu_zero, k_cc, mu_cc, f1, bound="lower"
+    )
+
+    # If extrapolate_to_max_phi is True, create extrapolation functions for k_dry and mu using scipy's interp1d
+    if extrapolate_to_max_phi:
+        k_dry_func = interp1d(phi, k_dry, fill_value="extrapolate")
+        mu_func = interp1d(phi, mu, fill_value="extrapolate")
+        k_dry[idx_phi] = k_dry_func(phi[idx_phi])
+        mu[idx_phi] = mu_func(phi[idx_phi])
+    else:
+        k_dry[idx_phi] = np.nan
+        mu[idx_phi] = np.nan
+
+    k_dry, mu = gen_utilities.filter_output(idx, (k_dry, mu))
+    if return_k_zero:
+        return k_zero, k_dry, mu
+    return k_dry, mu