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

rock_physics_open/equinor_utilities/anisotropy.py

@@ -0,0 +1,162 @@
+import numpy as np
+
+from rock_physics_open.equinor_utilities import gen_utilities
+
+# These routines are not finalised or used in any plugins yet
+"""
+	c11, c12, c13, c33, c44, c66 = c_ij_2_c_factors(cij)
+
+	Transform a single stiffness tensor into components. VTI medium is assumed
+	"""
+
+
+def c_ij_2_c_factors(cij):
+    """Transform a single stifness tensor into components. VTI medium is assumed
+
+    Parameters
+    ----------
+    cij : np.ndarray
+            A 6x6 matrix.
+
+    Returns
+    -------
+    tuple
+            (c11, c12, c13, c33, c44, c66).
+    """
+    if not isinstance(cij, np.ndarray):
+        try:
+            cij = np.array(cij, dtype=float)
+        except ValueError:
+            print("Input data can't be transformed into a NumPy array")
+    try:
+        num_samp = int(cij.size / 36)
+        cij = cij.reshape((6, 6, num_samp))
+        c11 = cij[0, 0, :].reshape(num_samp, 1)
+        c12 = cij[0, 1, :].reshape(num_samp, 1)
+        c13 = cij[0, 2, :].reshape(num_samp, 1)
+        c33 = cij[2, 2, :].reshape(num_samp, 1)
+        c44 = cij[3, 3, :].reshape(num_samp, 1)
+        c66 = cij[5, 5, :].reshape(num_samp, 1)
+        return c11, c12, c13, c33, c44, c66
+
+    except ValueError:
+        print("Input data is not a 6x6xN array")
+
+
+def cfactors2cij(c11, c12, c13, c33, c44, c66):
+    """Transform individual stiffness factors to stiffness tensor 6x6x(number of samples).
+
+    Parameters
+    ----------
+    c11, c12, c13, c33, c44, c66 : np.ndarray
+            All 1-dimensional of same length.
+
+    Returns
+    -------
+    np.ndarray
+            A 6xx6x(number of samples) stifness teensor.
+    """
+    c11, c12, c13, c33, c44, c66 = gen_utilities.dim_check_vector(
+        (c11, c12, c13, c33, c44, c66)
+    )
+
+    num_samp = c11.shape[1]
+
+    cij = np.zeros((6, 6, num_samp))
+    cij[0, 0, :] = c11
+    cij[0, 1, :] = c12
+    cij[0, 2, :] = c13
+    cij[1, 0, :] = c12
+    cij[1, 1, :] = c11
+    cij[1, 2, :] = c13
+    cij[2, 0, :] = c13
+    cij[2, 1, :] = c13
+    cij[2, 1, :] = c33
+    cij[3, 3, :] = c44
+    cij[4, 4, :] = c44
+    cij[5, 5, :] = c66
+
+    return cij
+
+
+def c_ij_2_thomsen(c, rho):
+    """Thomsen parameter for weak anisotropy.
+
+    Parameters
+    ----------
+    c : np.ndarray
+            A (log of or single instance of) 6x6 elastic tensor.
+    rho : np.ndarray
+            Density - log of same length as c.
+
+    Returns
+    -------
+    tuple
+            alpha, beta, gamma, delta, epsilon.
+    """
+    # C matrix should be 6x6
+    if not isinstance(c, np.ndarray):
+        try:
+            c = np.array(c, dtype=float)
+        except ValueError:
+            print("Input data can't be transformed into a NumPy array")
+    try:
+        num_samp = int(c.size / 36)
+        c = c.reshape((6, 6, num_samp))
+        rho = rho.reshape(num_samp, 1)
+        alpha = np.sqrt(c[2, 2, :].reshape(num_samp, 1) / rho)
+        beta = np.sqrt(c[3, 3, :].reshape(num_samp, 1) / rho)
+        gamma = ((c[5, 5, :] - c[3, 3, :]) / (2 * c[3, 3, :])).reshape(num_samp, 1)
+        epsilon = ((c[0, 0, :] - c[2, 2, :]) / (2 * c[2, 2, :])).reshape(num_samp, 1)
+        delta = (
+            ((c[0, 2, :] + c[3, 3, :]) ** 2 - (c[2, 2, :] - c[3, 3, :]) ** 2)
+            / (2 * c[2, 2, :] * (c[2, 2, :] - c[3, 3, :]))
+        ).reshape(num_samp, 1)
+
+        return alpha, beta, epsilon, gamma, delta
+    except ValueError:
+        print("Input data is not a 6x6xN array")
+
+
+def thomsen_2_c_ij(alpha, beta, gamma, delta, epsilon, rho):
+    """Elastic stiffness. Assumptions:
+            Thomsen's parameters apply for weak anisotropy in a transversly isotropic medium:
+
+            c11 c12 c13  0   0   0
+
+            c12 c11 c13  0   0   0
+
+            c13 c13 c33  0   0   0
+
+            0   0   0    c44 0   0
+
+            0   0   0    0   c44 0
+
+            0   0   0    0   0   c66
+
+            Where c66 = 1/2(c11 - c12)
+
+    Parameters
+    ----------
+    alpha, beta, gamma, delta, epsilon :
+            Thomsen's parameters.
+    rho :
+            Bulk density.
+
+    Returns
+    -------
+    tuple
+            Elastic stiffness c11, c12, c13, c33, c44, c66.
+    """
+    alpha, beta, gamma, delta, epsilon = gen_utilities.dim_check_vector(
+        (alpha, beta, gamma, delta, epsilon)
+    )
+
+    c33 = rho * alpha**2
+    c44 = rho * beta**2
+    c11 = c33 * (1 + 2 * epsilon)
+    c66 = c44 * (1 + 2 * gamma)
+    c12 = c11 - 2 * c66
+    c13 = np.sqrt(2 * c33 * (c33 - c44) * delta + (c33 - c44) ** 2) - c44
+
+    return c11, c12, c13, c33, c44, c66

rock_physics_open/equinor_utilities/classification_functions/__init__.py

@@ -0,0 +1,17 @@
+from .class_stats import gen_class_stats
+from .lin_class import lin_class
+from .mahal_class import mahal_class
+from .norm_class import norm_class
+from .poly_class import poly_class
+from .post_prob import posterior_probability
+from .two_step_classification import gen_two_step_class_stats
+
+__all__ = [
+    "gen_class_stats",
+    "lin_class",
+    "mahal_class",
+    "norm_class",
+    "poly_class",
+    "posterior_probability",
+    "gen_two_step_class_stats",
+]

rock_physics_open/equinor_utilities/classification_functions/class_stats.py

@@ -0,0 +1,58 @@
+import numpy as np
+
+NULL_CLASS = 0
+
+
+def gen_class_stats(obs, class_val):
+    """
+    Generate statistics - mean, covariance and prior probability - for each
+    class in the training data.	The observations are an n x m array, where n
+    is the number of observations and m is the number of variables. With p
+    classes the returned mean value will be an array of dimension p x m,
+    covariance m x m x p and the class_id and prior probability p length vector.
+    class_mean, class_cov, prior_prob, class_counts, class_id = gen_class_stats(obs, class_val).
+
+    Parameters
+    ----------
+    obs : np.ndarray
+        An nxm array of data samples (observations).
+    class_val : np.ndarray
+        n length vector with class ID of the observations. Assumed to
+        be integer.
+
+    Returns
+    -------
+    tuple
+        class_mean, class_cov, prior_prob, class_counts, class_id : (np.ndarray, np.ndarray, np.ndarray, np.ndarray,
+        np.ndarray).
+    """
+
+    n, m = obs.shape
+    # Find number of classes. If class_val input is not integer, raise an exception
+    if not (
+        isinstance(class_val, np.ndarray)
+        and issubclass(class_val.dtype.type, np.integer)
+    ):
+        raise ValueError(f"{__file__}: class values are not discrete numbers")
+
+    class_id, class_counts = np.unique(class_val, return_counts=True)
+    # Remove Null class
+    idx_null = np.where(class_id == NULL_CLASS)
+    class_id = np.delete(class_id, idx_null)
+    class_counts = np.delete(class_counts, idx_null)
+    p = class_id.shape[0]
+
+    # Very simple prior probability - number of observations in each class
+    # divided by total number of observations
+    prior_prob = class_counts / n
+
+    # Assign output arrays
+    class_mean = np.zeros((p, m))
+    class_cov = np.zeros((m, m, p))
+
+    for i in range(len(class_id)):
+        idx = class_val == class_id[i]
+        class_mean[i, :] = np.mean(obs[idx, :], axis=0)
+        class_cov[:, :, i] = np.cov(obs[idx, :], rowvar=False)
+
+    return class_mean, class_cov, prior_prob, class_counts, class_id

rock_physics_open/equinor_utilities/classification_functions/lin_class.py

@@ -0,0 +1,47 @@
+import numpy as np
+
+NULL_CLASS = 0
+
+
+def lin_class(obs, class_mean, class_id, thresh=np.inf):
+    """
+    Linear classification routine. All data points are assigned a class, unless a threshold is set.
+
+    Parameters
+    ----------
+    obs : np.ndarray
+        An nxm array, where n is the number of samples and m is the number of features.
+    class_mean : np.ndarray
+        A pxm array, where p is the number of classes and m is the number of features.
+    class_id : np.ndarray
+        A p length vector, where p is the number of classes, containing class_id (integer numbers).
+    thresh : float
+        Unclassified threshold.
+
+    Returns
+    -------
+    tuple
+        lin_class_arr, lin_dist : (np.ndarray, np.ndarray).
+        lin_class_arr: nx1 vector. The classes are numbered according to class_id,
+        and unclassified samples (with distance greater than thresh) are set to 0,
+        lin_dist: nx1 vector with linear distance from the closest class centre to each sample.
+    """
+
+    # Find dimensions
+    n = obs.shape[0]
+    p = class_mean.shape[0]
+
+    # Assign matrices
+    dist = np.zeros((n, p))
+
+    # Calculate distance for each class
+    for i in range(p):
+        dist[:, i] = np.sqrt(np.sum((obs - class_mean[i, :]) ** 2, axis=1))
+
+    # Find the shortest distance, assign class, filter out observations with distance
+    # greater than the threshold
+    lin_class_arr = np.choose(np.argmin(dist, axis=1), class_id)
+    lin_dist = np.amin(dist, axis=1)
+    lin_class_arr[lin_dist > thresh] = NULL_CLASS
+
+    return lin_class_arr, lin_dist

rock_physics_open/equinor_utilities/classification_functions/mahal_class.py

@@ -0,0 +1,56 @@
+import numpy as np
+
+from .post_prob import posterior_probability
+
+NULL_CLASS = 0
+
+
+def mahal_class(obs, class_mean, class_cov, class_id, thresh=np.inf):
+    """
+    Mahalanobis classification routine. All data points are assigned a class, unless a threshold is set
+
+    Parameters
+    ----------
+    obs : np.ndarray
+        An nxm array, where n is the number of samples and m is the number of variables.
+    class_mean : np.ndarray
+        A pxm array, where p is the number of classes and m is the number of variables.
+    class_cov : np.ndarray
+        A pxm array, where p is the number of classes and m is the number of variables.
+    class_id : np.ndarray
+        A p length vector, where p is the number of classes, containing class_id (integer numbers).
+    thresh : float
+        Unclassified threshold.
+
+    Returns
+    -------
+    tuple
+        mahal_class_arr, mahal_dist, mahal_pp : (np.ndarray, np.ndarray, np.ndarray).
+        mahal_class_arr: nx1 vector. The classes are numbered 1 to m, and unclassified samples (with distance
+        greater than thresh) are set to 0,
+        mahal_dist:	nx1 vector with mahalanobis distance from the closest class centre to sample,
+        mahal_pp: nx1 vector with posterior probability based on the distance to each class
+    """
+
+    # Find dimensions
+    n = obs.shape[0]
+    p = class_mean.shape[0]
+
+    # Assign matrices
+    dist = np.zeros((n, p))
+
+    # Calculate distance for each class
+    for i in range(p):
+        cov_inv = np.linalg.inv(class_cov[:, :, i])
+        delta = obs - class_mean[i, :]
+        dist[:, i] = np.sqrt(np.einsum("nj,jk,nk->n", delta, cov_inv, delta))
+
+    # Find the shortest distance, assign class, calculate posterior probability and
+    # filter out observations with distance greater than the threshold
+    mahal_class_arr = np.choose(np.argmin(dist, axis=1), class_id)
+    mahal_dist = np.amin(dist, axis=1)
+    mahal_pp = posterior_probability(mahal_dist, dist)
+    d_idx = mahal_dist > thresh
+    mahal_class_arr[d_idx] = NULL_CLASS
+
+    return mahal_class_arr, mahal_dist, mahal_pp

rock_physics_open/equinor_utilities/classification_functions/norm_class.py

@@ -0,0 +1,65 @@
+import numpy as np
+
+NULL_CLASS = 0
+
+
+def norm_class(obs, class_mean, class_cov, prior_prob, class_id, thresh=np.inf):
+    """
+    Normal distribution classification routine. All data points are assigned a
+    class, unless a threshold is set. The "dist" calculated here is the quadratic
+    discriminant function according to a Bayes classification. This is a negative
+    number, and the closest class has the smallest absolute value.
+
+    Parameters
+    ----------
+    obs : np.ndarray
+        An nxm array, where n is the number of samples and m is the number of variables.
+    class_mean : np.ndarray
+        A pxm array, where p is the number of classes and m is the number of variables.
+    class_cov : np.ndarray
+        A pxm array, where p is the number of classes and m is the number of variables.
+    prior_prob : np.ndarray
+        A p length vector, where p is the number of classes containing prior probabilities for each class.
+    class_id : np.ndarray
+        A p length vector, where p is the number of classes, containing class_id (integer numbers).
+    thresh : float
+        Unclassified threshold.
+
+
+    Returns
+    --------
+    tuple
+        norm_class_id, norm_dist, norm_pp : (np.ndarray, np.ndarray, np.ndarray).
+        norm_class_id:	nx1 vector. The classes are numbered 1 to m, and unclassified
+        samples (with absolute distance greater than thresh) are set to 0,
+        norm_dist: nx1 vector with quadratic discriminant distance from the closest class centre to sample,
+        norm_pp: nx1 vector with posterior probability based on the distance to each class.
+    """
+
+    # Find dimensions
+    n = obs.shape[0]
+    p = class_mean.shape[0]
+
+    # Assign matrices
+    dist = np.zeros((n, p))
+
+    # Calculate distance for each class
+    for i in range(p):
+        cov_inv = np.linalg.inv(class_cov[:, :, i])
+        delta = obs - class_mean[i, :]
+        dist[:, i] = (
+            -0.5 * np.log(np.linalg.det(class_cov[:, :, i]))
+            - 0.5 * np.sqrt(np.einsum("nj,jk,nk->n", delta, cov_inv, delta))
+            + np.log(prior_prob[i])
+        )
+
+    # The discrimination function ("dist") are negative numbers. Choose the one
+    # with the smallest value as the closest class
+    norm_class_id = np.choose(np.argmax(dist, axis=1), class_id)
+    norm_dist = np.amax(dist, axis=1)
+    norm_pp = -np.exp(norm_dist) / np.sum(np.exp(dist), axis=1)
+
+    # Compare the absolute value of the discriminator with the threshold
+    norm_class_id[np.abs(norm_dist) > thresh] = NULL_CLASS
+
+    return norm_class_id, norm_dist, norm_pp

rock_physics_open/equinor_utilities/classification_functions/poly_class.py

@@ -0,0 +1,40 @@
+import matplotlib.path as mplpath
+import numpy as np
+
+
+def poly_class(train_data, polygons, labels):
+    """
+    Points within the polygons are assigned to class labels. Point that do not
+    fall within any polygon are set to NULL_CLASS.
+
+    Parameters
+    ----------
+
+    train_data : np.ndarray
+        Data points of two variables.
+    polygons : np.ndarray
+        Vertices of polygons in two-dimensional space.
+    labels : np.ndarray
+        Class label for each polygon.
+
+    Returns
+    -------
+    np.ndarray
+        Class id.
+    """
+    if len(labels) != len(polygons):
+        raise ValueError("Number of labels are not matching number of polygons")
+
+    # Create output variables
+    idx_filtered = np.zeros(train_data.shape[0]).astype("bool")
+    poly_class_id = np.zeros(train_data.shape[0]).astype("int")
+
+    for i in range(len(polygons)):
+        class_polygon = polygons[i]
+        path = mplpath.Path(class_polygon)
+        # Only points within the given polygon are used
+        idx_poly = path.contains_points(train_data)
+        poly_class_id[idx_poly] = labels[i]
+        idx_filtered = np.logical_or(idx_filtered, idx_poly)
+    # idx_filtered is no longer returned
+    return poly_class_id

rock_physics_open/equinor_utilities/classification_functions/post_prob.py

@@ -0,0 +1,26 @@
+import numpy as np
+
+NULL_CLASS = 0
+
+
+def posterior_probability(min_dist, dist):
+    """
+    Posterior probability, which is defined as the exponential of minimum distance divided by the sum of the
+    exponentials of distance to all classes.
+
+    Parameters
+    ----------
+    min_dist : np.ndarray
+        Minimum class distance according to some metric.
+    dist : np.ndarray
+        All class distances, each class in a column in a two-dimensional array.
+
+    Returns
+    -------
+    np.ndarray
+        Posterior probability array.
+    """
+    dist *= -1.0
+    n_exp = np.exp(dist)
+    d_sum = n_exp.sum(axis=1)
+    return np.exp(-min_dist) / d_sum

rock_physics_open/equinor_utilities/classification_functions/two_step_classification.py

@@ -0,0 +1,46 @@
+from .class_stats import gen_class_stats
+from .mahal_class import mahal_class
+
+NULL_CLASS = 0
+
+
+def gen_two_step_class_stats(obs, class_val, thresh):
+    """
+    The observations are an n x m array, where n
+    is the number of observations and m is the number of variables. With p
+    classes the returned mean value will be an array of dimension p x m,
+    covariance m x m x p and the class_id and prior probability p length vector.
+
+    Generate statistics - mean, covariance and prior probability - for each
+    class in the training data.	Run a mahalanobis classification, and exclude
+    values that have distance above the threshold. Generate class statistics again
+    and return them.
+
+    Parameters
+    ----------
+    obs : np.ndarray
+        An nxm array, where n is the number of samples and m is the number of variables.
+    class_val : np.ndarray
+        A p length vector, where p is the number of classes, containing class_id (integer numbers).
+    thresh : float
+        Unclassified threshold.
+
+    Returns
+    -------
+    tuple
+        (np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray).
+        class_mean, class_cov: statistics for each class after rejects;
+        prior_prob, class_counts: based on number of observations in each class,
+        find the prior probability of each class;
+        class_id: label for each class;
+        mahal_class_id: class id from mahalanobis classification.
+    """
+    mean_class_id, class_cov, _, _, class_id = gen_class_stats(obs, class_val)
+    mahal_class_id = mahal_class(obs, mean_class_id, class_cov, class_id, thresh)[0]
+
+    idx = mahal_class_id != NULL_CLASS
+    mean_class_id, class_cov, prior_prob, class_counts, class_id = gen_class_stats(
+        obs[idx], class_val[idx]
+    )
+
+    return mean_class_id, class_cov, prior_prob, class_counts, class_id, mahal_class_id

rock_physics_open/equinor_utilities/conversions.py

@@ -0,0 +1,10 @@
+"""
+Simple conversions required for the material models.
+"""
+
+
+def celsius_to_kelvin(temperature):
+    """
+    Convert temperature from Celsius to kelvin
+    """
+    return temperature + 273.15

rock_physics_open/equinor_utilities/gen_utilities/__init__.py

@@ -0,0 +1,11 @@
+from .dict_to_float import dict_value_to_float
+from .dim_check_vector import dim_check_vector
+from .filter_input import filter_input_log
+from .filter_output import filter_output
+
+__all__ = [
+    "dict_value_to_float",
+    "dim_check_vector",
+    "filter_input_log",
+    "filter_output",
+]

rock_physics_open/equinor_utilities/gen_utilities/dict_to_float.py

@@ -0,0 +1,33 @@
+def dict_value_to_float(input_dict):
+    """
+    Convert dictionary strings to floating point numbers. Each value can have multiple floats.
+
+    Parameters
+    ----------
+    input_dict : dict
+        Input dictionary.
+
+    Returns
+    -------
+    dict
+        Output dictionary.
+    """
+
+    for item in input_dict:
+        if isinstance(input_dict[item], float):
+            pass
+        else:
+            try:
+                ff = float(input_dict[item])
+                input_dict[item] = ff
+            except ValueError:  # if a list or tuple is hidden in the string
+                try:
+                    ll = eval(input_dict[item])
+                    ff = [float(i) for i in ll]
+                    input_dict[item] = ff
+                except ValueError:
+                    raise ValueError(
+                        "dict_value_to_float: not possible to convert value to float"
+                    )
+
+    return input_dict

rock_physics_open/equinor_utilities/gen_utilities/dim_check_vector.py

@@ -0,0 +1,83 @@
+import numpy as np
+import pandas as pd
+
+
+def dim_check_vector(args, force_type=None):
+    """
+    Check that all inputs are of the same (one-dimensional) size. Raise ValueError in case there are several lengths
+    present in the inputs. All inputs will be checked and possibly expanded to common length. Only the first dimension
+    is harmonised.
+
+    Parameters
+    ----------
+    args : list or tuple
+        Input list or tuple of scalars, numpy arrays or pandas data frames of numerical or boolean type.
+    force_type : np.dtype
+        Force all outputs to be of a specific dtype.
+
+    Returns
+    -------
+    output_args : list
+        List of inputs where all are of the same length.
+    """
+    single_types = (np.ndarray, pd.DataFrame)
+    iterable_types = (list, tuple)
+    allowed_types = single_types + iterable_types
+    if not isinstance(args, allowed_types):
+        raise ValueError("dim_check_vector: unknown input type: {}".format(type(args)))
+
+    # Single array or dataframe is just returned
+    if isinstance(args, single_types):
+        if force_type is not None:
+            try:
+                args = args.astype(force_type)
+            except ValueError:
+                raise ValueError(
+                    "dim_check_vector: not possible to force dtype to {}".format(
+                        force_type
+                    )
+                )
+        return args
+
+    # If any input is a scalar, make it into an array
+    if force_type is not None:
+        try:
+            args = [
+                np.array(item, ndmin=1, dtype=force_type)
+                if np.isscalar(item)
+                else item.astype(force_type)
+                for item in args
+            ]
+        except ValueError:
+            raise ValueError(
+                "dim_check_vector: not possible to force dtype to {}".format(force_type)
+            )
+    else:
+        args = [np.array(item, ndmin=1) if np.isscalar(item) else item for item in args]
+
+    # Can now test for length - must either be a scalar or have the same length
+    max_length = np.max([item.shape[0] for item in args])
+    if not np.all([item.shape[0] == max_length or item.shape[0] == 1 for item in args]):
+        raise ValueError(
+            "dim_check_vector: Unequal array lengths in input to dim_check_vector"
+        )
+
+    output_arg = []
+    for item in args:
+        if item.shape[0] == max_length:
+            output_arg.append(item)
+        else:
+            item_dim = item.ndim
+            repeat_tuple = tuple([max_length] + [1] * (item_dim - 1))
+            if isinstance(item, pd.DataFrame):
+                output_arg.append(
+                    pd.DataFrame(
+                        np.tile(np.array(item), repeat_tuple),
+                        columns=item.columns,
+                        index=np.arange(max_length),
+                    )
+                )
+            else:
+                output_arg.append(np.tile(item, repeat_tuple))
+
+    return output_arg