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

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 rock_physics_open.equinor_utilities.optimisation_utilities import (
+    gen_mod_routine,
+    gen_sub_routine,
+    load_opt_params,
+    opt_param_info,
+)
+
+from .curvefit_t_matrix_exp import curvefit_t_matrix_exp
+
+
+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,
+    )

rock_physics_open/t_matrix_models/t_matrix_opt_fluid_sub_petec.py

@@ -0,0 +1,167 @@
+import numpy as np
+
+from rock_physics_open.equinor_utilities import gen_utilities
+from rock_physics_open.equinor_utilities.optimisation_utilities import (
+    gen_mod_routine,
+    gen_sub_routine,
+    load_opt_params,
+)
+
+from .curvefit_t_matrix_min import curve_fit_2_inclusion_sets
+
+
+def run_t_matrix_with_opt_params_petec(
+    min_k,
+    min_mu,
+    min_rho,
+    fl_k_orig,
+    fl_rho_orig,
+    fl_k_sub,
+    fl_rho_sub,
+    vp,
+    vs,
+    rhob,
+    phi,
+    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.
+    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):
+        Parameters
+        ----------
+        min_k : np.ndarray
+            Effective mineral bulk modulus [Pa].
+        min_mu : np.ndarray
+            Effective mineral shear modulus [Pa].
+        min_rho : np.ndarray
+            Effective mineral density [kg/m^3].
+        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 : 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].
+        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 = curve_fit_2_inclusion_sets
+    # Generate x_data according to method min
+    x_data = np.stack(
+        (
+            phi,
+            min_k,
+            min_mu,
+            min_rho,
+            fl_k_orig,
+            fl_rho_orig,
+            angle,
+            perm,
+            visco,
+            tau,
+            freq,
+            def_vpvs,
+        ),
+        axis=1,
+    )
+    if fluid_sub:
+        x_data_new = np.stack(
+            (
+                phi,
+                min_k,
+                min_mu,
+                min_rho,
+                fl_k_sub,
+                fl_rho_sub,
+                angle,
+                perm,
+                visco,
+                tau,
+                freq,
+                def_vpvs,
+            ),
+            axis=1,
+        )
+    rho_mod = min_rho * (1.0 - phi) + fl_rho_orig * phi
+
+    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,
+    )

rock_physics_open/t_matrix_models/t_matrix_opt_forward_model_exp.py

@@ -0,0 +1,76 @@
+import numpy as np
+
+from rock_physics_open.equinor_utilities import gen_utilities
+from rock_physics_open.equinor_utilities.optimisation_utilities import (
+    gen_mod_routine,
+    load_opt_params,
+    opt_param_info,
+)
+
+from .curvefit_t_matrix_exp import curvefit_t_matrix_exp
+
+
+def run_t_matrix_forward_model_with_opt_params_exp(
+    fl_k, fl_rho, phi, vsh, angle, perm, visco, tau, freq, f_name
+):
+    """Based on the input file with parameters for the optimally fitted model, a forward modelling is done
+    with inputs of mineral properties, fluid properties and porosity per sample. Other parameters (constants)
+    can also be varied from their setting when the optimal parameters were found.
+
+    Parameters
+    ----------
+    fl_k : np.ndarray.
+        Effective in situ fluid bulk modulus [Pa].
+    fl_rho : np.ndarray
+        Effective in situ fluid density [kg/m^3].
+    phi : np.ndarray
+        Porosity [fraction].
+    vsh : np.ndarray
+        Shale volume [fraction].
+    angle : float
+        Angle of symmetry plane
+    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.
+
+    Returns
+    -------
+    tuple
+        Tuple of np.ndarrays: vp [m/s], vs [m/s], rho [kg/m^3], ai [kg/m^3 x m/s], vp/vs [fraction] for forward model.
+    """
+    opt_type, opt_params, opt_dict = load_opt_params(f_name)
+    scale_val = opt_param_info()[1]
+    phi, angle, perm, visco, tau, freq, def_vpvs = gen_utilities.dim_check_vector(
+        (phi, angle, perm, visco, tau, freq, 1.0)
+    )
+    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
+    y_shape = (phi.shape[0], 2)
+
+    if opt_type != "exp":
+        raise ValueError(
+            f"{__file__}: incorrect type of optimal parameter input file, must come from EXP "
+            f"optimisation"
+        )
+    # No Need for preprocessing
+    opt_fcn = curvefit_t_matrix_exp
+    # Generate x_data according to method min
+    x_data = np.stack(
+        (phi, vsh, fl_k, fl_rho, angle, perm, visco, tau, freq, def_vpvs), axis=1
+    )
+    v_mod = gen_mod_routine(opt_fcn, x_data, y_shape, opt_params)
+    if not isinstance(v_mod, np.ndarray):
+        raise ValueError(f"{__file__}: no solution to forward model")
+    vp_mod, vs_mod = [arr.flatten() for arr in np.split(v_mod, 2, axis=1)]
+    vpvs_mod = vp_mod / vs_mod
+    ai_mod = vp_mod * rho_mod
+    return vp_mod, vs_mod, rho_mod, ai_mod, vpvs_mod

rock_physics_open/t_matrix_models/t_matrix_opt_forward_model_min.py

@@ -0,0 +1,89 @@
+import numpy as np
+
+from rock_physics_open.equinor_utilities import gen_utilities
+from rock_physics_open.equinor_utilities.optimisation_utilities import (
+    gen_mod_routine,
+    load_opt_params,
+)
+
+from .curvefit_t_matrix_min import curve_fit_2_inclusion_sets
+
+
+def run_t_matrix_forward_model_with_opt_params_petec(
+    min_k, min_mu, min_rho, fl_k, fl_rho, phi, angle, perm, visco, tau, freq, f_name
+):
+    """Based on the input file with parameters for the optimally fitted model, a forward modelling is done
+    with inputs of mineral properties, fluid properties and porosity per sample. Other parameters (constants)
+    can also be varied from their setting when the optimal parameters were found.
+
+    Parameters
+    ----------
+    min_k : np.ndarray
+        Effective mineral bulk modulus [Pa].
+    min_mu : np.ndarray
+        Effective mineral shear modulus [Pa].
+    min_rho : np.ndarray
+        Effective mineral density [kg/m^3].
+    fl_k : np.ndarray
+        Effective in situ fluid bulk modulus [Pa].
+    fl_rho : np.ndarray
+        Effective in situ fluid density [kg/m^3].
+    phi : np.ndarray
+        Porosity [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.
+
+    Returns
+    -------
+    tuple
+        Tuple of np.ndarrays: vp [m/s], vs [m/s], rho [kg/m^3], ai [kg/m^3 x m/s], vp/vs [fraction] for forward model.
+    """
+    opt_type, opt_params, opt_dict = load_opt_params(f_name)
+    phi, angle, perm, visco, tau, freq, def_vpvs = gen_utilities.dim_check_vector(
+        (phi, angle, perm, visco, tau, freq, 1.0)
+    )
+    rho_mod = min_rho * (1.0 - phi) + fl_rho * phi
+    y_shape = (phi.shape[0], 2)
+
+    if opt_type != "min":
+        raise ValueError(
+            f"{__file__}: incorrect type of optimal parameter input file, must come from PETEC "
+            f"optimisation"
+        )
+    # No Need for preprocessing
+    opt_fcn = curve_fit_2_inclusion_sets
+    # Generate x_data according to method min
+    x_data = np.stack(
+        (
+            phi,
+            min_k,
+            min_mu,
+            min_rho,
+            fl_k,
+            fl_rho,
+            angle,
+            perm,
+            visco,
+            tau,
+            freq,
+            def_vpvs,
+        ),
+        axis=1,
+    )
+    v_mod = gen_mod_routine(opt_fcn, x_data, y_shape, opt_params)
+    if not isinstance(v_mod, np.ndarray):
+        raise ValueError(f"{__file__}: no solution to forward model")
+    vp_mod, vs_mod = [arr.flatten() for arr in np.split(v_mod, 2, axis=1)]
+    vpvs_mod = vp_mod / vs_mod
+    ai_mod = vp_mod * rho_mod
+    return vp_mod, vs_mod, rho_mod, ai_mod, vpvs_mod