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

rock_physics_open/t_matrix_models/opt_subst_utilities.py

@@ -0,0 +1,415 @@
+import os
+import pickle
+
+# from scipy.optimize import minimize, Bounds
+import sys
+
+import numpy as np
+from scipy.optimize import curve_fit
+
+
+def curve_fit_wrapper(x_init, opt_func, x_data, y_data, *args, **opt_kwargs):
+    """Use in tests with scipy.optimize.minimize instead of curve_fit.
+
+    Parameters
+    ----------
+    x_init : np.ndarray
+        Initial guess for parameters.
+    opt_func : callable
+        Function to optimize.
+    x_data : np.ndarray
+        Input data to opt_func.
+    y_data : np.ndarray
+        Results that the optimisation should match.
+    args :
+        args opt_func.
+    opt_kwargs :
+        kwargs opt_func.
+
+    Returns
+    -------
+    np.ndarray
+        res values.
+    """
+    y_pred = opt_func(x_data, *x_init, *args, **opt_kwargs)
+    return np.sum(np.sqrt((y_data - y_pred) ** 2))
+
+
+def gen_opt_routine(
+    opt_function, x_data_orig, y_data, x_init, low_bound, high_bound, **opt_kwargs
+):
+    """
+    This function is a lean method for running optimisation with the given opt_function in curve_fit. Predicted values,
+    residuals to the observed values and optimal parameters are returned.
+
+    Parameters
+    ----------
+    opt_function : callable
+        function to optimise
+    x_data_orig : np.ndarray
+        input data to the function - independent variables
+    y_data : np.ndarray
+        results that the optimisation should match - dependent variables
+    x_init : np.ndarray
+        initial guess for parameters
+    low_bound : np.ndarray
+        parameter low bound
+    high_bound : np.ndarray
+        parameter high bound
+    opt_kwargs : dict
+        optional meta-parameters to the optimisation function
+
+    Returns
+    -------
+    tuple
+        y_pred, y_res, opt_params : (np.ndarray, np.ndarray, np.ndarray).
+        y_pred : predicted values,
+        y_res : residual values,
+        opt_params : optimal model parameters.
+    """
+    try:
+        opt_params, param_cov = curve_fit(
+            opt_function,
+            x_data_orig,
+            y_data.flatten("F"),
+            x_init,
+            bounds=(low_bound, high_bound),
+            method="trf",
+            loss="soft_l1",
+            **opt_kwargs,
+        )
+
+    except ValueError:
+        raise ValueError(
+            "gen_opt_routine: failed in optimisation step: {}".format(
+                str(sys.exc_info())
+            )
+        )
+    else:
+        y_pred = np.reshape(
+            opt_function(x_data_orig, *opt_params), y_data.shape, order="F"
+        )
+        y_res = y_pred - y_data
+
+        # Alternative implementation, not shown to improve results
+        # alt_opt_params = minimize(curve_fit_wrapper, x_init, args=(opt_function, x_data_orig, y_data.flatten('F')),
+        #                          bounds=Bounds(low_bound, high_bound), method='SLSQP', options={'maxiter': 10000})
+        # y_pred_1 = np.reshape(opt_function(x_data_orig, *alt_opt_params['x'], **opt_kwargs), y_data.shape, order='F')
+        # y_res_1 = y_pred_1 - y_data
+        # return y_pred_1, y_res_1, alt_opt_params['x']
+
+        return y_pred, y_res, opt_params
+
+
+def gen_mod_routine(opt_function, xdata_orig, ydata_shape, opt_params):
+    """Predict modelled values based on an earlier optimisation run for optimal model parameters.
+
+    Parameters
+    ----------
+    opt_function : callable
+        Function to optimise.
+    xdata_orig : np.ndarray
+        Input data to the function - independent variables.
+    ydata_shape : (int, int)
+        Shape of y_data.
+    opt_params : np.ndarray
+        Optimal model parameters.
+
+    Returns
+    -------
+    np.ndarray
+        Predicted values.
+    """
+    # Estimation of values
+    return np.reshape(opt_function(xdata_orig, *opt_params), ydata_shape, order="F")
+
+
+def gen_sub_routine(opt_function, xdata_orig, xdata_new, ydata, opt_params):
+    """General substitution function based on a calibrated/optimised model and with two sets of input parameters.
+    The substituted values are calculated as the original observations plus the difference of the two modelling
+    steps.
+
+    Parameters
+    ----------
+    opt_function : callable
+        Function to optimise.
+    xdata_orig : np.ndarray
+        Input data to the function step 1 - independent variables.
+    xdata_new : np.ndarray
+        Input data to the function step 2 - independent variables.
+    ydata : np.ndarray
+        Original observed values step 1.
+    opt_params : np.ndarray
+        Set of optimal parameters to model.
+
+    Returns
+    -------
+    tuple
+        y_final, y_pred, y_res : (np.ndarray, np.ndarray, np.ndarray).
+        Original observed data + difference in estimation between steps 0 and 1, y_pred - modelled data,
+        y_res - residuals, opt_params - best parameter setting.
+    """
+    # Estimation of initial values
+    y_pred = np.reshape(opt_function(xdata_orig, *opt_params), ydata.shape, order="F")
+    # Estimation step for substituted fluid properties
+    y_subst = np.reshape(opt_function(xdata_new, *opt_params), ydata.shape, "F")
+
+    y_res = y_pred - ydata
+    y_diff = y_subst - y_pred
+    y_final = ydata + y_diff
+
+    return y_final, y_pred, y_res
+
+
+def save_opt_params(
+    opt_type: str,
+    opt_params: np.ndarray,
+    file_name: str = "opt_params.pkl",
+    well_name: str = "Unknown well",
+):
+    """
+    Utility to save optimal parameters as a pickle file in a more readable format so that the optimisation method can be
+    recognised.
+
+    Parameters
+    ----------
+    opt_type : str
+        String defining optimisation type.
+    opt_params : np.ndarray
+        Numpy array with parameters from optimisation.
+    file_name : str, optional
+        File to save results to, by default 'opt_params.pkl'.
+    well_name : str, optional
+        Name of the well which is used in optimisation, by default 'Unknown well'.
+
+    Raises
+    ------
+    ValueError
+        If unknown optimisation opt_type.
+    """
+    # Save the optimal parameters with info
+    if opt_type == "min":  # optimisation with mineral input from well
+        opt_param_dict = {
+            "well_name": well_name,
+            "opt_ver": opt_type,
+            "f_ani": opt_params[0],
+            "f_con": opt_params[1],
+            "alpha_opt": opt_params[2:4],
+            "v_opt": opt_params[4],
+            "opt_vec": opt_params,
+        }
+    elif opt_type == "exp":
+        opt_param_dict = {
+            "well_name": well_name,
+            "opt_ver": opt_type,
+            "f_ani": opt_params[0],
+            "f_con": opt_params[1],
+            "alpha_opt": opt_params[2:4],
+            "v_opt": opt_params[4],
+            "k_carb": opt_params[5],
+            "mu_carb": opt_params[6],
+            "rho_carb": opt_params[7],
+            "k_sh": opt_params[8],
+            "mu_sh": opt_params[9],
+            "rho_sh": opt_params[10],
+            "opt_vec": opt_params,
+        }
+    elif opt_type == "pat_cem":
+        opt_param_dict = {
+            "well_name": well_name,
+            "opt_ver": opt_type,
+            "weight_k": opt_params[0],
+            "weight_mu": opt_params[1],
+            "shear_red": opt_params[2],
+            "frac_cem": opt_params[3],
+            "opt_vec": opt_params,
+        }
+    elif opt_type == "const_cem":
+        opt_param_dict = {
+            "well_name": well_name,
+            "opt_ver": opt_type,
+            "phi_c": opt_params[0],
+            "shear_red": opt_params[1],
+            "frac_cem": opt_params[2],
+            "opt_vec": opt_params,
+        }
+    elif opt_type == "friable":
+        opt_param_dict = {
+            "well_name": well_name,
+            "opt_ver": opt_type,
+            "phi_c": opt_params[0],
+            "shear_red": opt_params[1],
+            "opt_vec": opt_params,
+        }
+    else:
+        raise ValueError(
+            "save_opt_params: unknown optimisation opt_type: {}".format(opt_type)
+        )
+
+    with open(file_name, "wb") as file_out:
+        pickle.dump(opt_param_dict, file_out)
+
+
+def opt_param_info():
+    """Hard coded dictionaries returned.
+    Returns
+    -------
+    tuple
+        parameter_translation_dict, value_translation_dict, type_translation_dict.
+    """
+    parameter_translation_dict = {
+        "opt_ver": "Optimisation version",
+        "no_incl_sets": "Number of inclusion sets",
+        "ang_sym": "Angle of symmetry plane [°]",
+        "f_ani": "Fraction of anisotropic inclusions",
+        "f_con": "Fraction of connected inclusions",
+        "alpha_opt": "Optimal aspect ratios for inclusion sets",
+        "v_opt": "Ratio of volume for inclusion sets",
+        "k_carb": "Matrix (carbonate) bulk modulus [Pa]",
+        "mu_carb": "Matrix (carbonate) shear modulus [Pa]",
+        "rho_carb": "Matrix (carbonate) density [kg/m^3]",
+        "k_sh": "Mud/shale bulk modulus [Pa]",
+        "mu_sh": "Mud/shale shear modulus [Pa]",
+        "rho_sh": "Mud/shale density [kg/m^3]",
+        "k_sst": "Sst bulk modulus [Pa]",
+        "mu_sst": "Sst shear modulus [Pa]",
+        "rho_sst": "Sst density [kg/m^3]",
+        "frac_cem": "Cement fraction [fraction]",
+        "phi_c": "Critical porosity [fraction]",
+        "shear_red": "Reduction in tangential friction [fraction]",
+        "weight_k": "Bulk modulus weight for constant cement model",
+        "weight_mu": "Shear modulus weight for constant cement model",
+    }
+    value_translation_dict = {
+        "ang_sym": 90.0,
+        "k_carb": 95.0e9,
+        "mu_carb": 45.0e9,
+        "rho_carb": 2950.0,
+        "k_sh": 35.0e9,
+        "mu_sh": 20.0e9,
+        "rho_sh": 2750.0,
+        "k_sst": 45.0e9,
+        "mu_sst": 50.0e9,
+        "rho_sst": 2750.0,
+    }
+    type_translation_dict = {
+        "min": "PETEC (Mineral input) optimisation",
+        "exp": "Exploration type optimisation",
+        "pat_cem": "Patchy cement model",
+        "const_cem": "Constant cement model",
+        "friable": "Friable sand model",
+    }
+    return parameter_translation_dict, value_translation_dict, type_translation_dict
+
+
+def load_opt_params(file_name: str):
+    """Utility to load parameter file from optimisation run.
+
+    Parameters
+    ----------
+    file_name : str
+        Input file name including path.
+
+    Returns
+    -------
+    tuple
+        opt_type: model type, no_sets: number of inclusion sets, opt_param: with all parameters for model.
+    """
+    with open(file_name, "rb") as fin:
+        param_dict = pickle.load(fin)
+        opt_type = param_dict["opt_ver"]
+        opt_param = param_dict["opt_vec"]
+        opt_dict = param_dict
+
+        return opt_type, opt_param, opt_dict
+
+
+def opt_param_to_ascii(
+    in_file, display_results=True, out_file=None, well_name="Unknown well", **kwargs
+):
+    """Utility to convert stored optimised parameters to ascii and display results or save to file.
+
+    Parameters
+    ----------
+    in_file : str
+        File name for stored optimised parameters.
+    display_results : bool
+        Display results on screen, default True.
+    out_file : str or None
+        Optional store optimised parameters in ascii file.
+    well_name : str
+        Optional name of the well that is used in optimisation.
+    """
+    with open(in_file, "rb") as f_in:
+        param_dict = pickle.load(f_in)
+        if well_name.lower() == "unknown well":
+            well_name = param_dict.pop("well_name", "Unknown Well")
+
+        (
+            parameter_translation_dict,
+            value_translation_dict,
+            type_translation_dict,
+        ) = opt_param_info()
+
+        item = []
+        value = []
+        disp_string = ""
+        for opt_key, opt_value in param_dict.items():
+            if opt_key in parameter_translation_dict:
+                if opt_key in value_translation_dict:
+                    opt_value = opt_value * value_translation_dict[opt_key]
+                    opt_str = f" {opt_value:.4f}"
+                elif opt_key == "opt_ver":
+                    opt_str = type_translation_dict[opt_value]
+                elif opt_key == "v_opt":
+                    opt_value = np.append(opt_value, 1.0 - np.sum(opt_value))
+                    opt_str = f" {opt_value:}"
+                else:
+                    if isinstance(opt_value, float):
+                        opt_str = f" {opt_value:.4f}"
+                    else:
+                        opt_str = f" {opt_value:}"
+                item.append(f"{parameter_translation_dict[opt_key]}: ")
+                value.append(opt_str)
+                disp_string += f"{parameter_translation_dict[opt_key]}: {opt_str}\n"
+        info_array = np.stack((item, value), axis=1)
+
+        if display_results:
+            from tkinter import END, Entry, Tk
+
+            class Table:
+                def __init__(self, tk_root, no_rows, no_cols, info):
+                    # code for creating table
+                    str_len = np.vectorize(len)
+                    text_justify = ["right", "left"]
+                    for i in range(no_rows):
+                        for j in range(no_cols):
+                            just = text_justify[0] if j == 0 else text_justify[1]
+                            max_len = np.max(str_len(info[:, j]))
+                            self.e = Entry(
+                                root,
+                                width=max_len + 2,
+                                fg="black",
+                                font=("Consolas", 11, "normal"),
+                                justify=just,
+                            )
+                            self.e.grid(row=i, column=j)
+                            self.e.insert(END, info[i][j])
+
+            root = Tk(**kwargs)
+            if well_name.lower() == "unknown well":
+                root.title("T Matrix Optimised Parameters")
+            else:
+                root.title(well_name)
+            if sys.platform.startswith("win"):
+                ico_file = os.path.join(os.path.dirname(__file__), "Equinor_logo.ico")
+                root.iconbitmap(ico_file)
+            Table(root, info_array.shape[0], info_array.shape[1], info_array)
+            root.attributes("-topmost", True)
+            root.mainloop()
+
+        if out_file is not None:
+            with open(out_file, "w") as f_out:
+                f_out.write(disp_string)
+
+        return

rock_physics_open/t_matrix_models/parse_t_matrix_inputs.py

@@ -0,0 +1,297 @@
+import sys
+
+import numpy as np
+
+from rock_physics_open import t_matrix_models
+from rock_physics_open.equinor_utilities import gen_utilities
+
+
+def 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,
+):
+    """Function to do all necessary checking of input type, dimension, reshaping etc. that clutter up the start of T-Matrix
+    NB: Setting scenario will override the settings for alpha, v and tau.
+
+    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 : list or np.ndarray
+         > 1 value list or numpy array in ascending order, effective pressure [Pa].
+    scenario : int
+        pre-set scenarios for alpha, v and tau
+    fcn : callable
+        function with which to run the T-Matrix model.
+
+    Returns
+    -------
+    tuple
+        All inputs in correct dimension and data type plus ctrl_connected, ctrl_anisotropy - control parameters.
+    """
+
+    def _assert_type(arg, exp_dtype, err_str="check inputs, wrong type encountered"):
+        """Assert type.
+
+        Parameters
+        ----------
+        arg : any
+            To be asserted.
+        exp_dtype : type
+            Expected data type.
+        err_str : str, optional
+            Error string, by default 'check inputs, wrong type encountered'.
+
+        Raises
+        ------
+        ValueError
+            Content of err_str.
+        """
+        if not isinstance(arg, exp_dtype):
+            raise ValueError("t-matrix inputs: " + err_str)
+
+    # 1: Check all single float values, silently cast int to float
+    # Permeability and viscosity: Check that they are floats and convert them to to SI units
+    _assert_type(
+        perm, (float, int), "expect permeability given as single float in units mD"
+    )
+    perm = perm * 0.986923e-15
+
+    _assert_type(
+        visco, (float, int), "expect viscosity given as single float in units cP"
+    )
+    visco = visco * 1.0e-2
+
+    _assert_type(
+        frequency, (float, int), "expect frequency given as single float value in Hz"
+    )
+    frequency = float(frequency)
+
+    _assert_type(
+        angle, (float, int), "expect angle given as single float value in degrees"
+    )
+    angle = float(angle)
+
+    # 2: Determine the T-Matrix function, use the C++ implementation as default in case of None
+    # If it given as a string, it must belong to the t_matrix_models module
+    if not fcn:  # None
+        t_matrix_fcn = t_matrix_models.t_matrix_porosity_c_alpha_v
+    elif not callable(fcn):
+        fcn_err_str = (
+            "T-Matrix function should be given as the callable function or a string "
+            "to the function name within t_matrix_models "
+        )
+        _assert_type(fcn, str, fcn_err_str)
+        if not hasattr(t_matrix_models, fcn):
+            raise ValueError(fcn_err_str)
+        t_matrix_fcn = getattr(t_matrix_models, fcn)
+
+    else:  # Function must be recognised
+        if not fcn:  # check that the function exists
+            raise ValueError(
+                "t-matrix inputs: function for T-Matrix model is not known"
+            )
+        t_matrix_fcn = fcn
+
+    # 3: Check all inputs that should be one value per sample, expand perm and visco to match this.
+    # frac_inc_ani and frac_inc_con can be single floats or vectors of the same length as the other vector inputs
+
+    log_length = len(phi)
+
+    # Check that the inputs that should have the same length actually do
+    # dim_check_vector may throw an error message, modify it to show origin
+    try:
+        (
+            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(float),
+        )
+    except ValueError:
+        raise ValueError("t-matrix inputs: {}".format(str(sys.exc_info())))
+
+    # 4: Scenario will override settings for alpha, v and tau
+    if scenario:
+        scenario = int(scenario)
+        if scenario == 1:  # Mostly rounded pores
+            alpha = np.array([0.9, 0.1])
+            v = np.array([0.9, 0.1])
+        elif scenario == 2:  # Dual porosity with little rounded pores
+            alpha = np.array([0.58, 0.027])
+            v = np.array([0.85, 0.15])
+        elif scenario == 3:  # Mixed pores
+            alpha = np.array([0.9, 0.1, 0.01])
+            v = np.array([0.8, 0.19, 0.01])
+        elif scenario == 4:  # Flat pores and cracks
+            alpha = np.array([0.9, 0.1, 0.01, 0.001])
+            v = np.array([0.689, 0.3, 0.01, 0.001])
+        tau = np.ones_like(alpha) * 1.0e-7
+
+    # 4a: Check alpha, v, tau
+    # alpha and v is either 1D vector with inclusion aspect ratios and proportions applying to all samples or 2D arrays
+    # where the first dimension must coincide with the log_length
+    # tau should be a 1D vector with length equal to the number of inclusions per sample
+    _assert_type(
+        alpha,
+        np.ndarray,
+        "alpha should be a 1D or 2D numpy array of matching size with v",
+    )
+    _assert_type(
+        v, np.ndarray, "v should be a 1D or 2D numpy array og matching size with alpha"
+    )
+    _assert_type(
+        tau,
+        (float, np.ndarray),
+        "tau should be a single float or 1D numpy array with length matching "
+        "the number of inclusions",
+    )
+
+    alpha_shape = alpha.shape
+    # First make sure that alpha and v have the same number of elements
+    try:
+        alpha, v = gen_utilities.dim_check_vector(
+            (alpha, v), force_type=np.dtype(float)
+        )
+    except ValueError:
+        raise ValueError("t-matrix inputs: {}".format(str(sys.exc_info())))
+    alpha = alpha.reshape(alpha_shape)
+    v = v.reshape(alpha_shape)
+    # If they are 2D arrays, the first dimension should match log_length
+    if alpha.ndim == 2:
+        if not (alpha_shape[0] == log_length or alpha_shape[0] == 1):
+            raise ValueError(
+                "t-matrix inputs: number of samples in alpha is not matching length of inputs"
+            )
+        if alpha_shape[0] == 1:
+            alpha = np.tile(alpha, (log_length, 1))
+            v = np.tile(v, (log_length, 1))
+
+    elif alpha.ndim == 1:
+        alpha = np.tile(alpha.reshape(1, alpha_shape[0]), (log_length, 1))
+        v = np.tile(v.reshape(1, alpha_shape[0]), (log_length, 1))
+    # Check that the number of elements in tau matches dim 1 of alpha
+    if isinstance(tau, float):
+        tau = np.ones(alpha_shape) * tau
+    else:
+        if not tau.ndim == 1 and tau.shape[0] == alpha.shape[1]:
+            raise ValueError(
+                "t-matrix inputs: number of elements in tau is not matching number of inclusions"
+            )
+
+    # 5: Check pressure
+    # Check that pressure either consists of at least two elements in ascending order or is None
+    # in the case there is no pressure modelling
+    if pressure is not None:
+        _assert_type(
+            pressure,
+            (list, np.ndarray),
+            "pressure should be a list or numpy array of at least two "
+            "elements in ascending order",
+        )
+        pressure = np.sort(np.array(pressure).flatten())
+        if not pressure.shape[0] > 1:
+            raise ValueError(
+                "t-matrix inputs: if pressure is given, it should contain two or more values"
+            )
+
+    # 6: Determine case for connected/isolated and isotropic/anisotropic inclusions
+    # Assume the most general case: mix of isotropic and anisotropic inclusions and connected and isolated inclusions
+    ctrl_anisotropy = 1
+    if np.all(frac_inc_ani == 0):
+        ctrl_anisotropy = 0  # All isotropic
+        angle = 0
+    elif np.all(frac_inc_ani == 1):
+        ctrl_anisotropy = 2  # All anisotropic
+
+    ctrl_connected = 1
+    # Create case based on amount of connected inclusions
+    if np.all(frac_inc_con == 0):
+        ctrl_connected = 0  # All isolated
+    elif np.all(frac_inc_con == 1):
+        ctrl_connected = 2  # All connected
+
+    return (
+        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,
+        t_matrix_fcn,
+        ctrl_connected,
+        ctrl_anisotropy,
+    )