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

rock_physics_open/sandstone_models/patchy_cement_model.py

@@ -0,0 +1,384 @@
+import numpy as np
+
+from rock_physics_open.equinor_utilities import std_functions
+from rock_physics_open.equinor_utilities.gen_utilities import (
+    dim_check_vector,
+    filter_input_log,
+    filter_output,
+)
+
+from .constant_cement_models import constant_cement_model_dry
+from .friable_models import friable_model_dry
+
+FRAC_CEM_UP = 0.1
+P_EFF_LOW = 20.0e6
+
+
+def constant_cement_model_pcm(
+    kmin, mymin, kcem, mycem, kzero, myzero, phi, cem_frac, phic, n, red_shear
+):
+    """
+    kdry, mydry = contantcementmodel_pcm(kmin, mymin, kcem, mycem, kzero, myzero, phi, cem_frac, phic, n, red_shear)
+    """
+
+    #   Contact cement model (Dvorkin-Nur)for given cem_frac
+    kcc, mycc = std_functions.dvorkin_contact_cement(
+        cem_frac, phic, mymin, kmin, mycem, kcem, red_shear, n
+    )
+
+    #   Fraction of zero-porosity end member
+    f1 = 1 - phi / (phic - cem_frac)
+
+    #   Interpolating using Hashin -Shtrikman lower bound = Constant cement model.
+    #   Same mineral point as upper and lower bound in patchy cement model
+    kdry, mydry = std_functions.hashin_shtrikman_walpole(
+        kzero, myzero, kcc, mycc, f1, bound="lower"
+    )
+
+    return kdry, mydry
+
+
+def patchy_cement_model_weight(
+    k_min,
+    mu_min,
+    rho_min,
+    k_cem,
+    mu_cem,
+    rho_cem,
+    k_fl,
+    rho_fl,
+    phi,
+    p_eff,
+    frac_cem,
+    phi_c,
+    coord_num_func,
+    n,
+    shear_red,
+    weight_k,
+    weight_mu,
+):
+    """
+    Patchy cement model for sands that are a combination of friable model and constant cement model. No fluid or
+    pressure substitution. Input variables for weight of K and Mu determine the model's position between upper and
+    lower bound.
+
+    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
+        Sandstone cement bulk modulus [Pa].
+    mu_cem : np.ndarray
+        Sandstone 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
+        Total porosity [fraction].
+    p_eff : np.ndarray
+        Effective pressure [Pa].
+    frac_cem : float
+        Upper bound cement volume fraction [fraction].
+    shear_red : float
+        Shear reduction factor for sandstone [fraction].
+    phi_c : float
+        Critical porosity [fraction].
+    n : float
+        Coordination number [unitless].
+    coord_num_func : str
+        Indication if coordination number should be calculated from porosity or kept constant.
+    weight_k : float
+        Weight between friable and cemented model for bulk modulus.
+    weight_mu : float
+        Weight between friable and cemented model for shear modulus.
+
+    Returns
+    -------
+    tuple
+        k, mu, rhob, vp, vs : (np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray).
+        vp :Saturated P-velocity [m/s] after fluid and pressure substitution,
+        vs : Saturated S-velocity [m/s] after fluid and pressure substitution,
+        rhob : Saturated density [kg/m3] after fluid and pressure substitution,
+        k : Saturated rock bulk modulus [Pa],
+        mu : Shear modulus [Pa].
+    """
+
+    k_zero, mu_zero = std_functions.hashin_shtrikman_walpole(
+        k_cem, mu_cem, k_min, mu_min, frac_cem, bound="lower"
+    )
+
+    # In this implementation of the patchy cement model the given cement fraction for the constant cement model defines
+    # the upper bound, and the effective pressure for the friable model defines the lower bound
+
+    k_fri, mu_fri = friable_model_dry(
+        k_zero, mu_zero, phi, p_eff, phi_c, coord_num_func, n, shear_red
+    )[0:2]
+
+    k_up, mu_up = constant_cement_model_dry(
+        k_min,
+        mu_min,
+        k_cem,
+        mu_cem,
+        phi,
+        frac_cem,
+        phi_c,
+        n,
+        shear_red,
+        extrapolate_to_max_phi=True,
+    )[0:2]
+
+    k_dry = k_fri + weight_k * (k_up - k_fri)
+    mu = mu_fri + weight_mu * (mu_up - mu_fri)
+
+    k = std_functions.gassmann(k_dry, phi, k_fl, k_zero)
+
+    weight_rho = 0.5 * (weight_k + weight_mu)
+    rhob = (
+        phi * rho_fl
+        + (1 - phi - frac_cem * weight_rho) * rho_min
+        + frac_cem * weight_rho * rho_cem
+    )
+
+    vp, vs, ai, vpvs = std_functions.velocity(k, mu, rhob)
+
+    return vp, vs, rhob, ai, vpvs
+
+
+def patchy_cement_model_cem_frac(
+    k_min,
+    mu_min,
+    rho_min,
+    k_cem,
+    mu_cem,
+    rho_cem,
+    k_fl,
+    rho_fl,
+    phi,
+    p_eff,
+    frac_cem,
+    phi_c,
+    coord_num_func,
+    n,
+    shear_red,
+):
+    """
+    Patchy cement model for sands that are a combination of friable model and constant cement model. No fluid or
+    pressure substitution. In this implementation of the patchy cement model the given cement fraction for the constant
+    cement model defines the upper bound, and the effective pressure for the friable model defines the lower bound
+
+    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
+        Sandstone cement bulk modulus [Pa].
+    mu_cem : np.ndarray
+        Sandstone 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
+        Total porosity [fraction].
+    p_eff : np.ndarray
+        Effective pressure [Pa].
+    frac_cem : float
+        Upper bound cement volume fraction [fraction].
+    shear_red : float
+        Shear reduction factor for sandstone [fraction].
+    phi_c : float
+        Critical porosity [fraction].
+    n : float
+        Coordination number [unitless].
+    coord_num_func : str
+        Indication if coordination number should be calculated from porosity or kept constant, either "ConstVal" or
+        "PoreBased" [default]
+
+    Returns
+    -------
+    tuple
+        vp, vs, rhob, ai, vpvs : (np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray).
+        vp :Saturated P-velocity [m/s] after fluid and pressure substitution,
+        vs : Saturated S-velocity [m/s] after fluid and pressure substitution,
+        rhob : Saturated density [kg/m3] after fluid and pressure substitution,
+        ai : Saturated rock acoustic impedance [kg/m3 * m/s] after fluid and pressure substitution,
+        vpvs : Saturated rock velocity ratio [ratio].
+    """
+
+    k_dry, mu, _ = patchy_cement_model_dry(
+        k_min,
+        mu_min,
+        rho_min,
+        k_cem,
+        mu_cem,
+        rho_cem,
+        phi,
+        p_eff,
+        frac_cem,
+        phi_c,
+        coord_num_func,
+        n,
+        shear_red,
+    )
+    k_zero, mu_zero = std_functions.hashin_shtrikman_walpole(
+        k_cem, mu_cem, k_min, mu_min, FRAC_CEM_UP, bound="lower"
+    )
+
+    k = std_functions.gassmann(k_dry, phi, k_fl, k_zero)
+
+    rhob = phi * rho_fl + (1 - phi - frac_cem) * rho_min + frac_cem * rho_cem
+
+    vp, vs, ai, vpvs = std_functions.velocity(k, mu, rhob)
+
+    return vp, vs, rhob, ai, vpvs
+
+
+def patchy_cement_model_dry(
+    k_min,
+    mu_min,
+    rho_min,
+    k_cem,
+    mu_cem,
+    rho_cem,
+    phi,
+    p_eff,
+    frac_cem,
+    phi_c,
+    coord_num_func,
+    n,
+    shear_red,
+):
+    """
+    Patchy cement model for sands that are a combination of friable model and constant cement model. No fluid or
+    pressure substitution. In this implementation of the patchy cement model the given cement fraction for the constant
+    cement model defines the upper bound, and the effective pressure for the friable model defines the lower bound
+
+    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
+        Sandstone cement bulk modulus [Pa].
+    mu_cem : np.ndarray
+        Sandstone cement shear modulus [Pa].
+    rho_cem : np.ndarray
+        Cement bulk density [kg/m^3].
+    phi : np.ndarray
+        Total porosity [fraction].
+    p_eff : np.ndarray
+        Effective pressure [Pa].
+    frac_cem : float
+        Upper bound cement volume fraction [fraction].
+    shear_red : float
+        Shear reduction factor for sandstone [fraction].
+    phi_c : float
+        Critical porosity [fraction].
+    n : float
+        Coordination number [unitless].
+    coord_num_func : str
+        Indication if coordination number should be calculated from porosity or kept constant, either "ConstVal" or
+        "PoreBased" [default]
+
+    Returns
+    -------
+    tuple
+        k:dry, mu, rho_dry : (np.ndarray, np.ndarray, np.ndarray).
+        k_dry: dry rock bulk modulus [Pa],
+        mu : dry rock shear modulus [Pa],
+        rho_dry : dry rock density [kg/m3].,
+    """
+    # There are cases which suffer from a lack of consistency check at this stage,
+    # add dim_check_vector and filter input/output
+    phi, k_min, mu_min, rho_min, k_cem, mu_cem, rho_cem, p_eff = dim_check_vector(
+        (phi, k_min, mu_min, rho_min, k_cem, mu_cem, rho_cem, p_eff)
+    )
+    (idx, (phi, k_min, mu_min, rho_min, k_cem, mu_cem, rho_cem, p_eff)) = (
+        filter_input_log((phi, k_min, mu_min, rho_min, k_cem, mu_cem, rho_cem, p_eff))
+    )
+
+    k_zero, mu_zero = std_functions.hashin_shtrikman_walpole(
+        k_cem, mu_cem, k_min, mu_min, FRAC_CEM_UP, bound="lower"
+    )
+
+    k_low, mu_low = friable_model_dry(
+        k_zero,
+        mu_zero,
+        phi,
+        P_EFF_LOW * np.ones_like(phi),
+        phi_c,
+        coord_num_func,
+        n,
+        shear_red,
+    )[0:2]
+
+    k_fri, mu_fri = friable_model_dry(
+        k_zero, mu_zero, phi, p_eff, phi_c, coord_num_func, n, shear_red
+    )[0:2]
+
+    k_up, mu_up = constant_cement_model_dry(
+        k_min,
+        mu_min,
+        k_cem,
+        mu_cem,
+        phi,
+        FRAC_CEM_UP,
+        phi_c,
+        n,
+        shear_red,
+        extrapolate_to_max_phi=True,
+    )[0:2]
+
+    # Special case for the constant cement model that represents the mean of the data
+    k_cc, mu_cc = constant_cement_model_pcm(
+        k_min,
+        mu_min,
+        k_cem,
+        mu_cem,
+        k_zero,
+        mu_zero,
+        phi,
+        frac_cem,
+        phi_c,
+        n,
+        shear_red,
+    )[0:2]
+
+    idwk = k_up == k_low
+    idwmu = mu_up == mu_low
+
+    weight_k = np.ones(k_zero.shape)
+    weight_mu = np.ones(mu_zero.shape)
+
+    weight_k[~idwk] = (k_cc[~idwk] - k_low[~idwk]) / (k_up[~idwk] - k_low[~idwk])
+    weight_mu[~idwmu] = (mu_cc[~idwmu] - mu_low[~idwmu]) / (
+        mu_up[~idwmu] - mu_low[~idwmu]
+    )
+
+    weight_mu = np.clip(weight_mu, 0.0, 1.0)
+    weight_k = np.clip(weight_k, 0.0, 1.0)
+
+    k_dry = k_fri + weight_k * (k_up - k_fri)
+    mu = mu_fri + weight_mu * (mu_up - mu_fri)
+
+    rho_dry = (1 - phi - frac_cem) * rho_min + frac_cem * rho_cem
+
+    k_dry, mu, rho_dry = filter_output(idx, (k_dry, mu, rho_dry))
+
+    return k_dry, mu, rho_dry

rock_physics_open/sandstone_models/patchy_cement_optimisation.py

@@ -0,0 +1,254 @@
+import numpy as np
+
+from rock_physics_open.equinor_utilities import gen_utilities
+from rock_physics_open.equinor_utilities.optimisation_utilities import (
+    gen_opt_routine,
+    save_opt_params,
+)
+
+from .curvefit_sandstone_models import (
+    curvefit_patchy_cement,
+    patchy_cement_model_weight,
+)
+
+
+def patchy_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,
+    p_eff: np.ndarray,
+    vp: np.ndarray,
+    vs: np.ndarray,
+    rhob: np.ndarray,
+    phi_c,
+    file_out_str: str = "patchy_cement_optimal_params.pkl",
+    display_results: bool = False,
+    well_name: str = "Unknown well",
+    opt_params_only=False,
+):
+    """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].
+    p_eff :
+        Effective pressure log [Pa].
+    file_out_str :
+        Output file name (string) to store optimal parameters (pickle format).
+    phi_c : float
+        Critical porosity [fraction]
+    display_results :
+        Display optimal parameters in a window after run.
+    well_name : str
+        Name of well to be displayed in info box title.
+    opt_params_only : bool
+        return parameters from optimisation only
+    Returns
+    -------
+    tuple
+        vp_mod, vs_mod, rho_mod, ai_mod, vpvs_mod - modelled logs,
+        vp_res, vs_res, rho_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_patchy_cement
+    # expand single value parameters to match logs length
+    por, phi_c, def_vpvs = gen_utilities.dim_check_vector((por, phi_c, def_vpvs))
+    x_data = np.stack(
+        (
+            k_min,
+            mu_min,
+            rho_min,
+            k_cem,
+            mu_cem,
+            rho_cem,
+            k_fl,
+            rho_fl,
+            por,
+            p_eff,
+            def_vpvs,
+            phi_c,
+        ),
+        axis=1,
+    )
+
+    # Params: weight_k, weight_mu, shear_red, frac_cem
+    lower_bound = np.array(
+        [
+            0.0,  # weight_k
+            0.0,  # weight_mu
+            0.0,  # shear_red
+            0.01,  # frac_cem
+        ],
+        dtype=float,
+    )
+    upper_bound = np.array(
+        [
+            1.0,  # weight_k
+            1.0,  # weight_mu
+            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
+    )
+
+    # 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
+    # rho_cem??
+    rhob_mod = rho_min * (1.0 - por) + por * rho_fl
+    ai_mod = vp_mod * rhob_mod
+    rhob_res = rhob_mod - rhob
+    # Save the optimal parameters
+    save_opt_params("pat_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)
+
+    if opt_params_only:
+        return opt_params
+    return vp_mod, vs_mod, rhob_mod, ai_mod, vpvs_mod, vp_res, vs_res, rhob_res
+
+
+def patchy_cement_model_optimisation_multiwell(
+    k_min,
+    mu_min,
+    rho_min,
+    k_cem,
+    mu_cem,
+    rho_cem,
+    k_fl,
+    rho_fl,
+    por,
+    p_eff,
+    vp,
+    vs,
+    rhob,
+    phi_c,
+    file_out_str: str = "pat_cem.pkl",
+    display_results: bool = False,
+    well_name: str = "Unknown well",
+):
+    # First: perform a calibration with all data, return optimal parameters only. Concatenate all list of arrays to
+    # make a single set of input arrays
+    k_min_all = np.concatenate(k_min, axis=0)
+    mu_min_all = np.concatenate(mu_min, axis=0)
+    rho_min_all = np.concatenate(rho_min, axis=0)
+    k_cem_all = np.concatenate(k_cem, axis=0)
+    mu_cem_all = np.concatenate(mu_cem, axis=0)
+    rho_cem_all = np.concatenate(rho_cem, axis=0)
+    k_fl_all = np.concatenate(k_fl, axis=0)
+    rho_fl_all = np.concatenate(rho_fl, axis=0)
+    por_all = np.concatenate(por, axis=0)
+    p_eff_all = np.concatenate(p_eff, axis=0)
+    vp_all = np.concatenate(vp, axis=0)
+    vs_all = np.concatenate(vs, axis=0)
+    rhob_all = np.concatenate(rhob, axis=0)
+
+    opt_param = patchy_cement_model_optimisation(
+        k_min_all,
+        mu_min_all,
+        rho_min_all,
+        k_cem_all,
+        mu_cem_all,
+        rho_cem_all,
+        k_fl_all,
+        rho_fl_all,
+        por_all,
+        p_eff_all,
+        vp_all,
+        vs_all,
+        rhob_all,
+        phi_c,
+        file_out_str=file_out_str,
+        display_results=display_results,
+        well_name=well_name,
+        opt_params_only=True,
+    )
+
+    # Next: run patchy cement model for all wells using the optimal parameters
+    weight_k = opt_param[0]
+    weight_mu = opt_param[1]
+    shear_red = opt_param[2]
+    frac_cem = opt_param[3]
+    vp_mod = []
+    vs_mod = []
+    rhob_mod = []
+    ai_mod = []
+    vpvs_mod = []
+    vp_res = []
+    vs_res = []
+    rhob_res = []
+    for i in range(len(k_min)):
+        vp_tmp, vs_tmp, rhob_tmp = patchy_cement_model_weight(
+            k_min[i],
+            mu_min[i],
+            rho_min[i],
+            k_cem[i],
+            mu_cem[i],
+            rho_cem[i],
+            k_fl[i],
+            rho_fl[i],
+            por[i],
+            p_eff[i],
+            frac_cem,
+            phi_c,
+            "por_based",
+            9,
+            shear_red,
+            weight_k,
+            weight_mu,
+        )[0:3]
+        vp_mod.append(vp_tmp)
+        vs_mod.append(vs_tmp)
+        rhob_mod.append(rhob_tmp)
+        ai_mod.append(vp_tmp * rhob_tmp)
+        vpvs_mod.append(vp_tmp / vs_tmp)
+        vp_res.append(vp_tmp - vp[i])
+        vs_res.append(vs_tmp - vs[i])
+        rhob_res.append(rhob_tmp - rhob[i])
+
+    return vp_mod, vs_mod, rhob_mod, ai_mod, vpvs_mod, vp_res, vs_res, rhob_res