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

rock_physics_open/span_wagner/tables/lookup_table.py

@@ -0,0 +1,33 @@
+import functools
+
+import numpy as np
+from scipy.interpolate import RegularGridInterpolator
+
+
+def generate_lookup_table(func, x, y, filename):
+    grids2d = np.meshgrid(x, y, indexing="ij")
+    grids = [g.flatten() for g in grids2d]
+    z = func(*grids)
+    z_grid = z.reshape(grids2d[0].shape)
+    np.savez(filename, z_grid=z_grid, x=x, y=y)
+    return grids2d, z_grid
+
+
+@functools.lru_cache(maxsize=10)
+def load_lookup_table_interpolator(filename):
+    data = np.load(filename)
+    reg = RegularGridInterpolator(
+        (data["x"], data["y"]), data["z_grid"], method="nearest", bounds_error=False
+    )
+
+    def _interp(_x, _y):
+        _x, _y = np.asarray(_x), np.asarray(_y)
+        pts = np.full((max(_x.size, _y.size), 2), fill_value=np.nan)
+        pts[:, 0] = _x
+        pts[:, 1] = _y
+        res = reg(pts)
+        if _x.ndim == 0 and _y.ndim == 0:
+            return res[0]
+        return res
+
+    return _interp

rock_physics_open/t_matrix_models/__init__.py

@@ -0,0 +1,35 @@
+from .carbonate_pressure_substitution import carbonate_pressure_model
+from .parse_t_matrix_inputs import parse_t_matrix_inputs
+from .run_t_matrix import run_t_matrix
+from .t_matrix_C import t_matrix_porosity_c_alpha_v
+from .t_matrix_opt_fluid_sub_exp import run_t_matrix_with_opt_params_exp
+from .t_matrix_opt_fluid_sub_petec import run_t_matrix_with_opt_params_petec
+from .t_matrix_opt_forward_model_exp import (
+    run_t_matrix_forward_model_with_opt_params_exp,
+)
+from .t_matrix_opt_forward_model_min import (
+    run_t_matrix_forward_model_with_opt_params_petec,
+)
+from .t_matrix_parameter_optimisation_exp import t_matrix_optimisation_exp
+from .t_matrix_parameter_optimisation_min import t_matrix_optimisation_petec
+from .t_matrix_vector import (
+    array_inverse,
+    array_matrix_mult,
+    t_matrix_porosity_vectorised,
+)
+
+__all__ = [
+    "carbonate_pressure_model",
+    "parse_t_matrix_inputs",
+    "run_t_matrix",
+    "t_matrix_porosity_c_alpha_v",
+    "run_t_matrix_with_opt_params_exp",
+    "run_t_matrix_with_opt_params_petec",
+    "run_t_matrix_forward_model_with_opt_params_exp",
+    "run_t_matrix_forward_model_with_opt_params_petec",
+    "t_matrix_optimisation_exp",
+    "t_matrix_optimisation_petec",
+    "array_inverse",
+    "array_matrix_mult",
+    "t_matrix_porosity_vectorised",
+]

rock_physics_open/t_matrix_models/carbonate_pressure_substitution.py

@@ -0,0 +1,124 @@
+import pandas as pd
+
+from rock_physics_open.equinor_utilities.machine_learning_utilities.run_regression import (
+    run_regression,
+)
+
+
+def carbonate_pressure_model(
+    rho_fluid,
+    vp_in_situ,
+    vs_in_situ,
+    rho_in_situ,
+    vp_fluid_sub,
+    vs_fluid_sub,
+    rho_fluid_sub,
+    phi,
+    pres_overburden,
+    pres_formation,
+    pres_form_depleted,
+    vp_model,
+    vs_model,
+    model_path,
+    b_add_fluid_sub=False,
+):
+    """
+    Function for estimating relative changes in Vp and Vs as a function of formation pressure depletion for carbonates.
+    The models that are used are based on laboratory plug measurements at close to in situ conditions,
+    and with simulated formation pressure depletion. The training and validation data set is based on pre-salt
+    carbonates from producing fields from the Brazilian continental shelf.
+
+    Similar to other substitution routines, the estimated difference between in situ case and depletion case is added
+    to observed logs.
+
+    A fluid substitution is assumed to be run in advance of the pressure substitution, and the depletion effect is added
+    to the substituted logs. In case there is no preceding fluid substitution, the in situ logs are presented for both
+    the in situ and fluid substituted case.
+
+    Parameters
+    ----------
+    rho_fluid : np.ndarray
+        Fluid density [kg/m^3]
+    vp_in_situ : np.ndarray
+        In situ Vp [m/s]
+    vs_in_situ : np.ndarray
+        In situ Vs [m/s]
+    rho_in_situ : np.ndarray
+        In situ bulk density [kg/m^3]
+    vp_fluid_sub : np.ndarray
+        Fluid substituted Vp [m/s]
+    vs_fluid_sub : np.ndarray
+        Fluid substituted Vs [m/s]
+    rho_fluid_sub : np.ndarray
+        Fluid substituted bulk density [kg/m^3]
+    phi : np.ndarray
+        Porosity [fraction]
+    pres_overburden : np.ndarray
+        Overburden pressure [Pa]
+    pres_formation : np.ndarray
+        In situ formation pressure [Pa]
+    pres_form_depleted : np.ndarray
+        Depleted formation pressure [Pa]
+    vp_model : Path
+        Full name to neural network model for Vp
+    vs_model : Path
+        Full name to neural network model for Vs
+    model_path : Path
+        Path to model directory
+    b_add_fluid_sub : bool
+        Control whether effect of fluid substitution should be added to the final result
+
+    Returns
+    -------
+    Tuple[np.ndarray]
+        vp_pres_sub : pressure substituted p-velocity [m/s]
+        vs_pres_sub : pressure substituted s-velocity [m/s]
+        rho_pres_sub : fluid substituted density is returned as the pressure substitution does not change this [kg/m^3]
+        ai_pres_sub : derived acoustic impedance [m/s x kg/m^3]
+        vpvs_pres_sub : derived vp/vs-ratio [fraction]
+    """
+
+    # Plug measurements are reported or dry rock density, bulk density needs to be corrected for fluid effect
+    rho_dry = rho_in_situ - rho_fluid * phi
+
+    # Change unit to comply with laboratory units
+    # Porosity in percent
+    phi_percent = phi * 100.0
+    # Pressure in MPa
+    pres_overburden *= 1.0e-6
+    pres_formation *= 1.0e-6
+    pres_form_depleted *= 1.0e-6
+    # Density in g/cm^3
+    rho_dry *= 1.0e-3
+
+    # Generate DataFrame with necessary inputs for in situ and depleted cases
+    input_dict = {
+        "PHIT": phi_percent,
+        "VP": vp_in_situ,
+        "VSX": vs_in_situ,
+        "PEFF_in_situ": pres_overburden - pres_formation,
+        "PEFF_depleted": pres_overburden - pres_form_depleted,
+    }
+    input_df = pd.DataFrame(input_dict)
+
+    results_df = run_regression(
+        input_df, str(vp_model), str(vs_model), model_dir=str(model_path)
+    )
+    results_df.columns = ["vp_delta", "vs_delta"]
+
+    if b_add_fluid_sub:
+        start_vp = vp_fluid_sub
+        start_vs = vs_fluid_sub
+        start_rho = rho_fluid_sub
+    else:
+        start_vp = vp_in_situ
+        start_vs = vs_in_situ
+        start_rho = rho_in_situ
+
+    vp_pres_sub = (start_vp + results_df["vp_delta"]).to_numpy()
+    vs_pres_sub = (start_vs + results_df["vs_delta"]).to_numpy()
+    rho_pres_sub = start_rho
+    ai_pres_sub = vp_pres_sub * rho_pres_sub
+    vpvs_pres_sub = vp_pres_sub / vs_pres_sub
+
+    return vp_pres_sub, vs_pres_sub, rho_pres_sub, ai_pres_sub, vpvs_pres_sub

rock_physics_open/t_matrix_models/curvefit_t_matrix_exp.py

@@ -0,0 +1,123 @@
+import numpy as np
+
+from rock_physics_open.equinor_utilities.gen_utilities import dim_check_vector
+from rock_physics_open.equinor_utilities.optimisation_utilities import opt_param_info
+from rock_physics_open.equinor_utilities.std_functions import hashin_shtrikman_average
+from rock_physics_open.t_matrix_models import t_matrix_porosity_c_alpha_v
+
+
+def curvefit_t_matrix_exp(
+    x_data,
+    frac_ani,
+    frac_con,
+    alpha1,
+    alpha2,
+    v1,
+    k_c,
+    mu_c,
+    rho_c,
+    k_sh,
+    mu_sh,
+    rho_sh,
+):
+    """Optimisation of input parameters to T-Matrix for carbonate in case where the mineral composition for each
+    sample is not known, so that effective mineral moduli for each sample are part of the parameters to be optimised
+    for. The optimisation is also made for the inclusion parameters in addition to fraction of connected and anisotropic
+    porosity and the VTI plane angle.
+
+    Parameters
+    ----------
+    x_data : np.ndarray
+        Inputs to unpack.
+    frac_ani : float
+        Fraction of anisotropic inclusions.
+    frac_con : float
+        Fraction of connected inclusions.
+    alpha1 : float
+        Aspect ratio of first inclusion set.
+    alpha2 : float
+        Aspect ratio of second inclusion set.
+    v1 : float
+        Concentration ratio of first inclusion set.
+    k_c : float
+        p-wave velocity for carbonate matrix.
+    mu_c : float
+        vp/vs ratio for carbonate matrix.
+    rho_c : float
+        vp/vs ratio for carbonate matrix.
+    k_sh : float
+        p-wave velocity for shale.
+    mu_sh : float
+        vp/vs ratio for shale.
+    rho_sh : float
+        Density for shale.
+
+    Returns
+    -------
+    np.ndarray
+        Modelled velocity, vp and vs.
+    """
+    # Restore original value range for parameters - must match the scaling performed in calling function
+    scale_val = opt_param_info()[1]
+    k_c *= scale_val["k_carb"]
+    mu_c *= scale_val["mu_carb"]
+    rho_c *= scale_val["rho_carb"]
+    k_sh *= scale_val["k_sh"]
+    mu_sh *= scale_val["mu_sh"]
+    rho_sh *= scale_val["rho_sh"]
+
+    # Unpack x inputs
+    # In calling function:
+    # x_data = np.stack((por, vsh, k_fl, rho_fl, k_r, eta_f, tau, freq, def_vpvs), axis=1)
+    phi = x_data[:, 0]
+    vsh = x_data[:, 1]
+    k_fl = x_data[:, 2]
+    rho_fl = x_data[:, 3]
+    angle_sym_plane = x_data[0, 4]
+    perm = x_data[:, 5]
+    visco = x_data[:, 6]
+    tau = x_data[:, 7]
+    # Both frequency and vp/vs ratio has to be in the same format as the others, but only a scalar value is used
+    freq = x_data[0, 8]
+    def_vp_vs_ratio = x_data[0, 9]
+
+    # Mineral properties
+    # Expand elastic properties to vectors of the same length as the x_data inputs
+    k_c, mu_c, rho_c, k_sh, mu_sh, rho_sh, _ = dim_check_vector(
+        (k_c, mu_c, rho_c, k_sh, mu_sh, rho_sh, phi)
+    )
+    k_min, mu_min = hashin_shtrikman_average(k_sh, mu_sh, k_c, mu_c, vsh)
+    rho_min = vsh * rho_sh + (1.0 - vsh) * rho_c
+
+    # Inclusion aspect ratios and concentrations
+    log_len = phi.shape[0]
+    alpha = np.zeros((log_len, 2))
+    v = np.zeros((log_len, 2))
+    alpha[:, 0] = alpha1 * np.ones(log_len)
+    alpha[:, 1] = alpha2 * np.ones(log_len)
+    v[:, 0] = v1 * np.ones(log_len)
+    v[:, 1] = (1 - v1) * np.ones(log_len)
+
+    try:
+        vp, vsv, _, _ = t_matrix_porosity_c_alpha_v(
+            k_min,
+            mu_min,
+            rho_min,
+            k_fl,
+            rho_fl,
+            phi,
+            perm,
+            visco,
+            alpha,
+            v,
+            tau,
+            freq,
+            angle_sym_plane,
+            frac_con,
+            frac_ani,
+        )
+    except ValueError:
+        vp = np.zeros(k_min.shape)
+        vsv = np.zeros(k_min.shape)
+
+    return np.stack((vp, def_vp_vs_ratio * vsv), axis=1).flatten("F")

rock_physics_open/t_matrix_models/curvefit_t_matrix_min.py

@@ -0,0 +1,86 @@
+import numpy as np
+
+from rock_physics_open.t_matrix_models import t_matrix_porosity_c_alpha_v
+
+
+def curve_fit_2_inclusion_sets(x_data, frac_ani, frac_con, alpha1, alpha2, v1):
+    """Optimisation of input parameters to T-Matrix for carbonate in case where the mineral composition for each
+    sample is known, so that effective mineral moduli for each sample are part of the inputs. The optimisation
+    is made for the inclusion parameters in addition to fraction of connected and anisotropic porosity and the
+    VTI plane angle.
+
+    Parameters
+    ----------
+    x_data : np.ndarray
+        Inputs to unpack.
+    frac_ani : float
+        Fraction of anisotropic inclusions.
+    frac_con : float
+        Fraction of connected inclusions.
+    alpha1 : float
+        Aspect ratio of first inclusion set.
+    alpha2 : float
+        Aspect ratio of second inclusion set.
+    v1 : float
+        Concentration ratio of first inclusion set.
+
+    Returns
+    -------
+    np.ndarray
+        Modelled velocity.
+    """
+    # Unpack x inputs
+    # In calling function:
+    # x_data = np.stack((por, k_min, mu_min, rho_min, k_fl, rho_fl, k_r, eta_f, tau, freq, def_vp_vs_ratio), axis=1)
+    phi = x_data[:, 0]
+    k_min = x_data[:, 1]
+    mu_min = x_data[:, 2]
+    rho_min = x_data[:, 3]
+    k_fl = x_data[:, 4]
+    rho_fl = x_data[:, 5]
+    angle_sym_plane = x_data[0, 6]
+    perm = x_data[:, 7]
+    visco = x_data[:, 8]
+    tau = x_data[:, 9]
+    # Both frequency and vp/vs ratio has to be in the same format as the others, but only a scalar value is used
+    freq = x_data[0, 10]
+    def_vp_vs_ratio = x_data[0, 11]
+
+    log_length = len(phi)
+
+    # alpha and v values should follow these conditions:
+    # - alphas are given in decreasing values
+    # - the sum of v's should add up to unity
+    if not (alpha1 > alpha2 and 0.0 < v1 <= 1.0):
+        raise ValueError(
+            "curvefit_t_matrix: alpha 1 must have higher value than alpha 2, and v1 must be a "
+            "positive fraction"
+        )
+    alpha = np.array([alpha1, alpha2]).reshape(1, 2)
+    v = np.array([v1, 1.0 - v1]).reshape(1, 2)
+    alpha_vec = alpha * np.ones((log_length, 1))
+    v_vec = v * np.ones((log_length, 1))
+
+    try:
+        vp, vsv, _, _ = t_matrix_porosity_c_alpha_v(
+            k_min,
+            mu_min,
+            rho_min,
+            k_fl,
+            rho_fl,
+            phi,
+            perm,
+            visco,
+            alpha_vec,
+            v_vec,
+            tau,
+            freq,
+            angle_sym_plane,
+            frac_con,
+            frac_ani,
+        )
+    except ValueError:
+        vp = np.zeros(k_min.shape)
+        vsv = np.zeros(k_min.shape)
+
+    return np.stack((vp, def_vp_vs_ratio * vsv), axis=1).flatten("F")