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

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

rock_physics_open/sandstone_models/constant_cement_optimisation.py

@@ -0,0 +1,122 @@
+import numpy as np
+
+from rock_physics_open.equinor_utilities import gen_utilities
+from rock_physics_open.t_matrix_models import gen_opt_routine, save_opt_params
+
+from .curvefit_sandstone_models import curvefit_constant_cement
+
+
+def constant_cement_model_optimisation(
+    k_min: np.ndarray,
+    mu_min: np.ndarray,
+    rho_min: np.ndarray,
+    k_cem: np.ndarray,
+    mu_cem: np.ndarray,
+    rho_cem: np.ndarray,
+    k_fl: np.ndarray,
+    rho_fl: np.ndarray,
+    por: np.ndarray,
+    vp: np.ndarray,
+    vs: np.ndarray,
+    rhob: np.ndarray,
+    file_out_str: str = "constant_cement_optimal_params.pkl",
+    display_results: bool = False,
+    well_name: str = "Unknown well",
+):
+    """Patchy cement model with optimisation for a selection of parameters.
+
+    Parameters
+    ----------
+    k_min :
+        Cement bulk modulus [Pa].
+    mu_min :
+        Cement shear modulus [Pa].
+    rho_min :
+        Cement density [kg/m^3].
+    k_cem :
+        Cement bulk modulus [Pa].
+    mu_cem :
+        Cement shear modulus [Pa].
+    rho_cem :
+        Cement density [kg/m^3].
+    k_fl :
+        Fluid bulk modulus [Pa].
+    rho_fl :
+        Fluid density [kg/m^3].
+    por :
+        Inclusion porosity [ratio].
+    vp :
+        Compressional velocity log [m/s].
+    vs :
+        Shear velocity log [m/s].
+    rhob :
+        Bulk density log [kg/m^3].
+    file_out_str :
+        Output file name (string) to store optimal parameters (pickle format).
+    display_results :
+        Display optimal parameters in a window after run.
+    well_name :
+        Name of well to be displayed in info box title.
+
+    Returns
+    -------
+    tuple
+        vp_mod, vs_mod - modelled logs, vp_res, vs_res - residual logs.
+    """
+
+    # Skip hardcoded Vp/Vs ratio
+    def_vpvs = np.mean(vp / vs)
+    # Set weight to vs to give vp and vs similar influence on optimisation
+    y_data = np.stack([vp, vs * def_vpvs], axis=1)
+    # Optimisation function for selected parameters
+    opt_fun = curvefit_constant_cement
+    # expand single value parameters to match logs length
+    por, def_vpvs = gen_utilities.dim_check_vector((por, def_vpvs))
+    x_data = np.stack(
+        (k_min, mu_min, rho_min, k_cem, mu_cem, rho_cem, k_fl, rho_fl, por, def_vpvs),
+        axis=1,
+    )
+
+    # Params: weight_k, weight_mu, shear_red, frac_cem
+    lower_bound = np.array(
+        [
+            0.35,  # phi_c
+            0.0,  # shear_red
+            0.01,  # frac_cem
+        ],
+        dtype=float,
+    )
+    upper_bound = np.array(
+        [
+            0.45,  # phi_c
+            1.0,  # shear_red
+            0.1,  # frac_cem
+        ],
+        dtype=float,
+    )
+
+    x0 = (upper_bound + lower_bound) / 2.0
+    # Optimisation step without fluid substitution
+    vel_mod, vel_res, opt_params = gen_opt_routine(
+        opt_fun, x_data, y_data, x0, lower_bound, upper_bound
+    )
+    frac_cem = opt_params[2]
+
+    # Reshape outputs and remove weight from vs
+    vp_mod, vs_mod = [arr.flatten() for arr in np.split(vel_mod, 2, axis=1)]
+    vp_res, vs_res = [arr.flatten() for arr in np.split(vel_res, 2, axis=1)]
+    vs_mod = vs_mod / def_vpvs
+    vs_res = vs_res / def_vpvs
+    vpvs_mod = vp_mod / vs_mod
+    # Calculate the modelled density
+    rhob_mod = rho_min * (1.0 - por - frac_cem) + frac_cem * rho_cem + por * rho_fl
+    ai_mod = vp_mod * rhob_mod
+    rhob_res = rhob_mod - rhob
+    # Save the optimal parameters
+    save_opt_params("const_cem", opt_params, file_out_str, well_name=well_name)
+    if display_results:
+        from rock_physics_open.t_matrix_models import opt_param_to_ascii
+
+        opt_param_to_ascii(file_out_str, well_name=well_name)
+
+    return vp_mod, vs_mod, rhob_mod, ai_mod, vpvs_mod, vp_res, vs_res, rhob_res