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

rock_physics_open/t_matrix_models/run_t_matrix.py

@@ -0,0 +1,243 @@
+import numpy as np
+
+from .parse_t_matrix_inputs import parse_t_matrix_inputs
+from .t_matrix_vector import calc_pressure_vec, pressure_input_utility
+
+
+def run_t_matrix(
+    k_min,
+    mu_min,
+    rho_min,
+    k_fl,
+    rho_fl,
+    phi,
+    perm,
+    visco,
+    alpha,
+    v,
+    tau,
+    frequency,
+    angle,
+    frac_inc_con,
+    frac_inc_ani,
+    pressure=None,
+    scenario=None,
+    fcn=None,
+):
+    """Function to run T-Matrix in different flavours, with or without pressure steps included.
+    A frontend to running T-Matrix model, including testing of all input parameters in the parse_t_matrix_inputs.
+
+    Parameters
+    ----------
+    k_min : np.ndarray
+        N length numpy array, mineral bulk modulus [Pa].
+    mu_min : np.ndarray
+        N length numpy array, mineral shear modulus [Pa].
+    rho_min : np.ndarray
+        N length numpy array, mineral density [kg/m^3].
+    k_fl : np.ndarray
+        N length numpy array, fluid bulk modulus [Pa].
+    rho_fl : np.ndarray
+        N length numpy array, mineral density [kg/m^3].
+    phi : np.ndarray or float
+        N length numpy array, total porosity [ratio].
+    perm : np.ndarray or float
+        Float or N length numpy array, permeability [mD].
+    visco : np.ndarray or float
+        Float or N length numpy array, fluid viscosity [cP].
+    alpha : np.ndarray
+        M or NxM length numpy array, inclusion aspect ratio [ratio].
+    v : np.ndarray
+        M or NxM length numpy array, inclusion concentration [ratio].
+    tau : np.ndarray
+        M length numpy array, relaxation time [s].
+    frequency : float
+        Single float, signal frequency [Hz].
+    angle : float
+        Single float, angle of symmetry plane [degree].
+    frac_inc_con : np.ndarray or float
+        Single float or N length numpy array, fraction of connected inclusions [ratio].
+    frac_inc_ani : np.ndarray or float
+        Single float or N length numpy array, fraction of anisotropic inclusions [ratio].
+    pressure : [type], optional
+        > 1 value list or numpy array in ascending order, effective pressure [Pa], by default None.
+    scenario : int, optional
+        Pre-set scenarios for alpha, v and tau, by default None.
+    fcn : callable, optional
+        Function with which to run the T-Matrix model, by default None.
+
+    Returns
+    -------
+    tuple
+        vp, vsv, vsh, rho: (np.ndarray, np.ndarray, np.ndarray, np.ndarray).
+    """
+    # Check all input parameters and make sure that they are on expected format and shape
+    (
+        k_min,
+        mu_min,
+        rho_min,
+        k_fl,
+        rho_fl,
+        phi,
+        perm,
+        visco,
+        alpha,
+        v,
+        tau,
+        frequency,
+        angle,
+        frac_inc_con,
+        frac_inc_ani,
+        pressure,
+        fcn,
+        ctrl_connected,
+        ctrl_anisotropy,
+    ) = parse_t_matrix_inputs(
+        k_min,
+        mu_min,
+        rho_min,
+        k_fl,
+        rho_fl,
+        phi,
+        perm,
+        visco,
+        alpha,
+        v,
+        tau,
+        frequency,
+        angle,
+        frac_inc_con,
+        frac_inc_ani,
+        pressure,
+        scenario,
+        fcn,
+    )
+
+    # If there are no pressure steps to consider the whole task can be assigned to the T-Matrix function
+    if pressure is None:
+        vp, vsv, vsh, rho = fcn(
+            k_min,
+            mu_min,
+            rho_min,
+            k_fl,
+            rho_fl,
+            phi,
+            perm,
+            visco,
+            alpha,
+            v,
+            tau,
+            frequency,
+            angle,
+            frac_inc_con,
+            frac_inc_ani,
+        )
+        return vp, vsv, vsh, rho
+
+    # Pressure steps is mimicking depletion, and inclusion shape parameters can be changed
+    # In Remy's implementation it is generally possible to have different alpha's and v's for connected and
+    # isolated part, but this is not included directly in Calculo's implementation in C++. For the time being,
+    # this possibility is not included here
+
+    log_length = phi.shape[0]
+    pressure_steps = pressure.shape[0]
+    # It is the change from initial pressure (first value in the pressure vector) that is input to the function
+    # that estimates matrix pressure sensitivity
+    delta_pres = np.diff(pressure)
+
+    # Predefine output vectors
+    vp = np.zeros((log_length, pressure_steps))
+    vs_v = np.zeros((log_length, pressure_steps))
+    vs_h = np.zeros((log_length, pressure_steps))
+    rho_b_est = np.zeros((log_length, pressure_steps))
+
+    # Matrix properties needed as input to calc_pressure_vec
+    c0, s0, gd = pressure_input_utility(k_min, mu_min, log_length)
+
+    for i in range(pressure_steps):
+        vp[:, i], vs_v[:, i], vs_h[:, i], rho_b_est[:, i] = fcn(
+            k_min,
+            mu_min,
+            rho_min,
+            k_fl,
+            rho_fl,
+            phi,
+            perm,
+            visco,
+            alpha,
+            v,
+            tau,
+            frequency,
+            angle,
+            frac_inc_con,
+            frac_inc_ani,
+        )
+
+        if i != pressure_steps - 1:
+            # Need to check for extreme cases with all connected or all isolated
+            if ctrl_connected != 0:
+                v_con = v * (phi * frac_inc_con).reshape(log_length, 1)
+            else:
+                v_con = np.zeros(v.shape)
+            if ctrl_connected != 2:
+                v_iso = v * (phi * (1 - frac_inc_con)).reshape(log_length, 1)
+            else:
+                v_iso = np.zeros(v.shape)
+            alpha_con, v_con, alpha_iso, v_iso, tau, gamma = calc_pressure_vec(
+                alpha,
+                alpha,
+                v_con,
+                v_iso,
+                c0,
+                s0,
+                gd,
+                delta_pres[i],
+                tau,
+                np.zeros_like(tau),
+                k_fl,
+                ctrl_connected,
+                frac_inc_ani,
+            )
+
+            # Post-process outputs from calc_pressure_vec to match required inputs to the T-Matrix function
+            # frac_inc_con, v and alpha are inputs that need to be updated
+            # As mentioned: assume that there is no distinction between alpha_con and alpha_iso, that could only
+            # happen if they differed from the start
+
+            # v_con, alpha_con or v_iso, alpha_iso can be returned as None from calc_pressure_vec
+            if ctrl_connected == 0:
+                v_con = np.zeros_like(v_iso)
+                alpha = alpha_iso
+            elif ctrl_connected == 2:
+                alpha = alpha_con
+                v_iso = np.zeros_like(v_con)
+            else:
+                alpha = alpha_con
+            # Don't divide by zero
+            idx_zero = phi == 0
+            if np.any(idx_zero):
+                v = v_con + v_iso
+                no_zero = np.sum(idx_zero)
+                v[~idx_zero, :] = v[~idx_zero, :] / phi[~idx_zero].reshape(
+                    log_length - no_zero, 1
+                )
+            else:
+                v = (v_con + v_iso) / phi.reshape(log_length, 1)
+
+            # frac_inc_con is close to a single value, only numerical difference in the range 10^-16, can safely
+            # take the average over the alphas to make it match expected input shape
+            frac_inc_con = np.mean(v_con / (v_con + v_iso), axis=1)
+
+    # Return variables for each pressure step
+    vp_out = []
+    vs_v_out = []
+    vs_h_out = []
+
+    # Only one rho is needed - no change
+    rho_out = rho_b_est[:, 0]
+
+    for i in range(pressure_steps):
+        vp_out.append(vp[:, i])
+        vs_v_out.append(vs_v[:, i])
+        vs_h_out.append(vs_h[:, i])
+    return vp_out + vs_v_out + vs_h_out + [rho_out]

rock_physics_open/t_matrix_models/t_matrix_C.py

@@ -0,0 +1,210 @@
+import inspect
+import sys
+from ctypes import c_double, c_int
+
+import numpy as np
+import numpy.ctypeslib as npct
+from tmatrix._tmatrix import tmatrix_porosity_noscenario
+
+from rock_physics_open.equinor_utilities import gen_utilities
+
+# Definition of input types for the T Matrix function
+# this will affect the tests on the input data, dim_check_vector is therefore set up to
+# return data on the specified format
+array_1d_double = npct.ndpointer(dtype=c_double, ndim=1, flags="CONTIGUOUS")
+array_1d_int = npct.ndpointer(dtype=c_int, ndim=1, flags="CONTIGUOUS")
+array_2d_double = npct.ndpointer(dtype=c_double, ndim=2, flags="CONTIGUOUS")
+
+
+# noinspection PyUnusedLocal
+def T_matrix_porosity_C_scenario(*args):
+    """Deprecated."""
+    raise DeprecationWarning(
+        "{}: deprecated function, all T-Matrix runs should be parsed through run_t_matrix".format(
+            inspect.stack()[0][3]
+        )
+    )
+
+
+def t_matrix_porosity_c_alpha_v(
+    k_min,
+    mu_min,
+    rho_min,
+    k_fl,
+    rho_fl,
+    phi,
+    perm,
+    visco,
+    alpha,
+    v,
+    tau,
+    frequency,
+    angle,
+    frac_inc_con,
+    frac_inc_ani,
+):
+    """This function can be called directly from top level, but the present recommendation is to go though the run_t_matrix
+    in order to check inputs. It is used directly from the optimisation functions for efficiency. This gives direct
+    access to the C++ compiled library for T-Matrix.
+
+    Parameters
+    ----------
+    k_min : np.ndarray
+        N length array, mineral bulk modulus [Pa]
+    mu_min: np.ndarray
+        N length array, mineral shear modulus [Pa]
+    rho_min: np.ndarray
+        N length array, mineral density [kg/m^3]
+    k_fl:np.ndarray
+        N length array, fluid bulk modulus [Pa]
+    rho_fl: np.ndarray
+        N length array, fluid density [kg/m^3]
+    phi:np.ndaray
+        N length array, porosity
+    perm: np.ndarray
+        N length array, permeability [mD]
+    visco: np.ndarray
+        N length array, viscosity [cP]
+    alpha: np.ndarray or float
+        aspect ratios for inclusions
+    v: np. ndarray or float
+        fraction of porosity with given aspect ratio
+    tau: float
+        relaxation time
+    frequency:  float
+        float single value, signal frequency [Hz]
+    angle: float
+        float single value, angle of symmetry plane (0 = HTI, 90 = VTI medium) [deg]
+    frac_inc_con: np.ndarray or float
+        float single value or array, fraction of inclusions that are connected
+    frac_inc_ani: np.ndarray or float
+        float single value or array, fraction of inclusions that are anisotropic
+
+    Returns
+    -------
+    tuple
+        Tuple of np.ndarrays. Vp: Vertical P-wave velocity [m/s], Vsv: Vertical polarity S-wave velocity [m/s],
+        Vsh: Horizontal polarity S-wave velocity [m/s], Rhob [kg/m^3].
+    """
+
+    # ToDo: tau input is not used in the Calculo implementation of T-Matrix
+    del tau
+
+    # Make sure that what can be vectors are vectors of the same length.
+    # frac_inc_con and frac_inc_ani can either be the same length as the log, be constants or have the same length as
+    # alpha and v
+
+    # frac_inc_con and frac_inc_ani must be of the same length
+    frac_inc_con, frac_inc_ani = gen_utilities.dim_check_vector(
+        (frac_inc_con, frac_inc_ani)
+    )
+
+    # test for frac_inc_con and frac_inc_ani being of the same length as the logs
+    log_length = len(phi)
+    if frac_inc_con.shape[0] == log_length:
+        (
+            k_min,
+            mu_min,
+            rho_min,
+            k_fl,
+            rho_fl,
+            phi,
+            perm,
+            visco,
+            frac_inc_con,
+            frac_inc_ani,
+        ) = gen_utilities.dim_check_vector(
+            (
+                k_min,
+                mu_min,
+                rho_min,
+                k_fl,
+                rho_fl,
+                phi,
+                perm,
+                visco,
+                frac_inc_con,
+                frac_inc_ani,
+            ),
+            force_type=np.dtype("float64"),
+        )
+        frac_inc_length = log_length
+    else:  # Single float value of frac_inc_con, frac_inc_ani or matching number of inclusions
+        (
+            k_min,
+            mu_min,
+            rho_min,
+            k_fl,
+            rho_fl,
+            phi,
+            perm,
+            visco,
+        ) = gen_utilities.dim_check_vector(
+            (k_min, mu_min, rho_min, k_fl, rho_fl, phi, perm, visco),
+            np.dtype("float64"),
+        )
+        frac_inc_length = frac_inc_ani.shape[0]
+
+    # Create output array, gather mineral and fluid properties in 2D arrays
+    out_arr = np.zeros((log_length, 4), dtype=float, order="C")
+    min_prop = np.stack([k_min, mu_min, rho_min], axis=1)
+    fl_prop = np.stack([k_fl, rho_fl, perm, visco], axis=1)
+
+    # Make sure that alpha and v are of the same shape - more about length of alpha further down
+    alpha_shape = alpha.shape
+    alpha, v = gen_utilities.dim_check_vector(
+        (alpha, v), force_type=np.dtype("float64")
+    )
+    alpha = alpha.reshape(alpha_shape)
+    v = v.reshape(alpha_shape)
+
+    # Number of alphas can vary from sample to sample - not used here, regular number of alphas for all
+    # samples. Need to declare the number of alphas per sample in an array. Alpha can also be a constant, in which case
+    # it should be expanded to an array of log_length. Both alpha and v should be a 2D array
+    if len(alpha) != log_length and len(alpha) < 5:
+        # Interpret alpha as a vector of aspect ratios
+        alpha_vec = (
+            np.ones((log_length, len(alpha)), dtype=float, order="c") * alpha.flatten()
+        )
+        v_vec = np.ones((log_length, len(alpha)), dtype=float, order="c") * v.flatten()
+        alpha = alpha_vec
+        v = v_vec
+
+    # Expect 2-dimensional input to t_mat_lib for alpha and v
+    if alpha.ndim == 1:
+        alpha = alpha.reshape((len(alpha), 1))
+        v = v.reshape((len(alpha), 1))
+
+    # Have to declare the number of alphas per sample, even if it is constant
+    alpha_length_array = np.ones(log_length, dtype=c_int, order="c") * alpha.shape[1]
+    alpha_length = alpha.shape[0]
+
+    try:
+        tmatrix_porosity_noscenario(
+            out_arr,
+            log_length,
+            min_prop,
+            fl_prop,
+            phi,
+            alpha,
+            v,
+            alpha_length_array,
+            alpha_length,
+            frequency,
+            angle,
+            frac_inc_con,
+            frac_inc_ani,
+            frac_inc_length,
+        )
+    except ValueError:
+        # Get more info in case this goes wrong
+        raise TypeError(
+            "tMatrix:t_matrix_porosity_c_alpha_v: {0}".format(str(sys.exc_info()))
+        )
+
+    vp = out_arr[:, 0]
+    vsv = out_arr[:, 1]
+    vsh = out_arr[:, 2]
+    rhob = out_arr[:, 3]
+
+    return vp, vsv, vsh, rhob

rock_physics_open/t_matrix_models/t_matrix_opt_fluid_sub_exp.py

@@ -0,0 +1,137 @@
+import numpy as np
+
+from rock_physics_open.equinor_utilities import gen_utilities
+
+from .curvefit_t_matrix_exp import curvefit_t_matrix_exp
+from .opt_subst_utilities import (
+    gen_mod_routine,
+    gen_sub_routine,
+    load_opt_params,
+    opt_param_info,
+)
+
+
+def run_t_matrix_with_opt_params_exp(
+    fl_k_orig,
+    fl_rho_orig,
+    fl_k_sub,
+    fl_rho_sub,
+    vp,
+    vs,
+    rhob,
+    phi,
+    vsh,
+    angle,
+    perm,
+    visco,
+    tau,
+    freq,
+    f_name,
+    fluid_sub=True,
+):
+    """Based on the input file with parameters for the optimally fitted model, the correct modelling version is run.
+    Fluid substitution follows, in case it is selected. If not, the vp_sub and vs_sub will contain the same values as
+    the input logs.
+
+    Parameters
+    ----------
+    fl_k_orig : np.ndarray
+        Effective in situ fluid bulk modulus [Pa].
+    fl_rho_orig : np.ndarray
+        Effective in situ fluid density [kg/m^3].
+    fl_k_sub : np.ndarray
+        Effective substituted fluid bulk modulus [Pa].
+    fl_rho_sub : np.ndarray
+        Effective substituted density [kg/m^3].
+    vp : np.ndarray
+        Compressional velocity [m/s].
+    vs : np.ndarray
+        Shear velocity [m/s].
+    rhob : np.ndarray
+        Bulk density [kg/m^3].
+    phi : np.ndarray
+        Porosity [fraction].
+    vsh : np.ndarray
+        Shale volume [fraction].
+    angle : float
+        Angle of symmetry plane [degrees]
+    perm : float
+        Permeability [mD].
+    visco : float
+        Viscosity [cP].
+    tau : float
+        Relaxation time constant [s].
+    freq : float
+        Signal frequency [Hz].
+    f_name : str
+        File name for parameter file for optimal parameters.
+    fluid_sub : bool
+        Boolean parameter to perform fluid substitution.
+
+    Returns
+    -------
+    tuple
+        Tuple of np.ndarrays: vp and vs for pressure substituted case, vp, vs and density for fluid substituted case, vp and vs for
+        optimal fitted model, vp and vs residuals (observed logs minus modelled values).
+    """
+
+    opt_type, opt_params, opt_dict = load_opt_params(f_name)
+    y_data = np.stack([vp, vs], axis=1)
+    y_shape = y_data.shape
+    phi, angle, perm, visco, tau, freq, def_vpvs = gen_utilities.dim_check_vector(
+        (phi, angle, perm, visco, tau, freq, 1.0)
+    )
+
+    rho_sub = rhob + (fl_rho_sub - fl_rho_orig) * phi
+    # Set None values for inputs that will be defined in the different cases
+    x_data_new = None
+
+    opt_fcn = curvefit_t_matrix_exp
+    scale_val = opt_param_info()[1]
+    # Generate x_data according to method exp
+    x_data = np.stack(
+        (phi, vsh, fl_k_orig, fl_rho_orig, angle, perm, visco, tau, freq, def_vpvs),
+        axis=1,
+    )
+    if fluid_sub:
+        x_data_new = np.stack(
+            (phi, vsh, fl_k_sub, fl_rho_sub, angle, perm, visco, tau, freq, def_vpvs),
+            axis=1,
+        )
+    rho_mod = (
+        (1.0 - vsh) * opt_dict["rho_carb"] * scale_val["rho_carb"]
+        + vsh * opt_dict["rho_sh"] * scale_val["rho_sh"]
+    ) * (1.0 - phi) + phi * fl_rho_orig
+
+    if fluid_sub:
+        v_sub, v_mod, v_res = gen_sub_routine(
+            opt_fcn, x_data, x_data_new, y_data, opt_params
+        )
+        vp_sub, vs_sub = [arr.flatten() for arr in np.split(v_sub, 2, axis=1)]
+        vp_mod, vs_mod = [arr.flatten() for arr in np.split(v_mod, 2, axis=1)]
+        vp_res, vs_res = [arr.flatten() for arr in np.split(v_res, 2, axis=1)]
+    else:
+        v_mod = gen_mod_routine(opt_fcn, x_data, y_shape, opt_params)
+        vp_mod, vs_mod = [arr.flatten() for arr in np.split(v_mod, 2, axis=1)]
+        vp_sub = vp
+        vs_sub = vs
+        vp_res = vp_mod - vp
+        vs_res = vs_mod - vs
+
+    rho_res = rho_mod - rhob
+    ai_sub = vp_sub * rho_sub
+    vpvs_sub = vp_sub / vs_sub
+
+    return (
+        vp_sub,
+        vs_sub,
+        rho_sub,
+        ai_sub,
+        vpvs_sub,
+        vp_mod,
+        vs_mod,
+        rho_mod,
+        vp_res,
+        vs_res,
+        rho_res,
+    )