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

rock_physics_open/ternary_plots/shale_prop_ternary.py

@@ -0,0 +1,337 @@
+import numpy as np
+from matplotlib import pyplot as plt
+
+from .ternary_plot_utilities import _set_ternary_figure, _triangle_transform
+
+
+def _shale_prop_ternary(
+    quartz,
+    carb,
+    clay,
+    kero,
+    phit,
+    col_code,
+    name_col_code,
+    well_name,
+    draw_figures=True,
+):
+    """Calculate hardness.
+
+    Parameters
+    ----------
+    quartz : np.ndarray
+        Quartz volume fraction [fraction].
+    carb : np.ndarray
+        Carbonate volume fraction [fraction].
+    clay : np.ndarray
+        Clay volume fraction [fraction].
+    kero : np.ndarray
+        Kerogen volume fraction [fraction].
+    phit : np.ndarray
+        Porosity [fraction].
+    col_code : np.ndarray
+        Property used for colour coding [unknown].
+    name_col_code : str
+        Plot annotation of log used for colour coding.
+    well_name : str
+        Plot heading with well name.
+
+    Returns
+    -------
+    np.ndarray
+        hardness [float].
+    """
+    KEROMAX = 0.25
+
+    _, _ = _set_ternary_figure(
+        1, 1, "Hardness vs. Organic Content Ternary Plot", well_name
+    )
+
+    # Define patches
+    col = (
+        1
+        / 255
+        * np.array(
+            [
+                [
+                    208,
+                    208,
+                    208,
+                ],
+                [
+                    198,
+                    198,
+                    198,
+                ],
+                [
+                    189,
+                    189,
+                    189,
+                ],
+                [
+                    179,
+                    179,
+                    179,
+                ],
+                [
+                    169,
+                    169,
+                    169,
+                ],
+                [
+                    223,
+                    213,
+                    203,
+                ],
+                [
+                    214,
+                    203,
+                    193,
+                ],
+                [
+                    204,
+                    194,
+                    183,
+                ],
+                [
+                    195,
+                    183,
+                    174,
+                ],
+                [
+                    187,
+                    172,
+                    164,
+                ],
+                [
+                    239,
+                    218,
+                    197,
+                ],
+                [
+                    229,
+                    208,
+                    188,
+                ],
+                [
+                    221,
+                    197,
+                    178,
+                ],
+                [
+                    213,
+                    186,
+                    169,
+                ],
+                [
+                    205,
+                    174,
+                    159,
+                ],
+                [
+                    254,
+                    223,
+                    192,
+                ],
+                [
+                    246,
+                    211,
+                    182,
+                ],
+                [
+                    239,
+                    200,
+                    173,
+                ],
+                [
+                    231,
+                    189,
+                    164,
+                ],
+                [223, 177, 154],
+            ]
+        )
+    )
+
+    corner_points = np.array(
+        [
+            [0.00, 0.00],
+            [0.25, 0.00],
+            [0.25, 0.20],
+            [0.00, 0.20],
+        ]
+    )
+
+    start_x, start_y = np.meshgrid(
+        np.arange(0, 1, 0.25), np.arange(0, 1, 0.2), indexing="ij"
+    )
+    start_x = start_x.flatten()
+    start_y = start_y.flatten()
+    vertices = []
+    for i in range(len(start_x)):
+        vertices.append(corner_points + [start_x[i], start_y[i]])
+
+    vertices_xy = []
+    for i in range(len(vertices)):
+        vertices_xy.append(_triangle_transform(vertices[i]))
+
+    h_p = []
+    for i in range(len(vertices)):
+        # h_p.append(plt.fill(vertices_xy[i][:,0],vertices_xy[i][:,1],facecolor=col[i,:],edgecolor='k',linewidth=0.5))
+        h_p.append(
+            plt.fill(vertices_xy[i][:, 0], vertices_xy[i][:, 1], color=col[i, :])
+        )
+
+    # Draw lines around patches
+    x = np.array([[0], [1]])
+    y = np.array([[0], [0]])
+    for i in np.arange(0, 1, 0.2):
+        xy = np.column_stack((x, y + i))
+        t_xy = _triangle_transform(xy)
+        plt.plot(t_xy[:, 0], t_xy[:, 1], "k", linewidth=1)
+    x = np.array([[0], [0]])
+    y = np.array([[0], [1]])
+    for i in np.arange(0, 1.1, 0.25):
+        xy = np.column_stack((x + i, y))
+        t_xy = _triangle_transform(xy)
+        plt.plot(t_xy[:, 0], t_xy[:, 1], "k", linewidth=1)
+
+    # Annotate axes
+    xi = np.linspace(0, 1, 5)
+    yi = np.linspace(0, 0.25, 6)
+    for j in range(len(xi)):
+        plt.text(xi[j], -0.025, "%.2f" % (xi[j]))
+    for j in range(len(yi)):
+        plt.text(
+            1 - 0.5 / 0.25 * yi[j] + 0.015,
+            yi[j] * np.sqrt(3) / 2 / 0.25,
+            "%.2f" % (yi[j]),
+        )
+    handles = []
+    # Axes labels
+    handles.append(
+        plt.text(
+            0.5,
+            -0.07,
+            "Hardness percentage\nClay+TOC+Phit <== ==> Quartz+Feldspar+Carbonate",
+            horizontalalignment="center",
+            verticalalignment="center",
+        )
+    )
+    handles.append(
+        plt.text(
+            0.95,
+            np.sqrt(3) / 4,
+            "Organic percentage",
+            horizontalalignment="center",
+            verticalalignment="center",
+            rotation=-62,
+        )
+    )
+    plt.setp(handles, fontname="sans-serif", fontweight="bold", fontsize=11)
+
+    # Region boundaries
+    df = 0.1 * np.array([1, np.tan(np.pi / 6)])
+    bb = np.array(
+        [
+            [1.00, 0.20],
+            [1.00, 0.60],
+        ]
+    )
+    bbt = _triangle_transform(bb)
+    bet = bbt + df
+    for j in range(bb.shape[0]):
+        plt.plot(
+            [
+                bbt[j, 0],
+                bet[j, 0],
+            ],
+            [
+                bbt[j, 1],
+                bet[j, 1],
+            ],
+            "k",
+            linewidth=0.5,
+        )
+    df = 0.1 * np.array([-1, np.tan(np.pi / 6)])
+    bb = np.array(
+        [
+            [0.00, 0.20],
+            [0.00, 0.60],
+        ]
+    )
+    bbt = _triangle_transform(bb)
+    bet = bbt + df
+    for j in range(bb.shape[0]):
+        plt.plot(
+            [
+                bbt[j, 0],
+                bet[j, 0],
+            ],
+            [
+                bbt[j, 1],
+                bet[j, 1],
+            ],
+            "k",
+            linewidth=0.5,
+        )
+
+    # Annotate regions
+    names = [
+        "Organically lean\nclaystones",
+        "Organically rich\nclaystones",
+        "Organically dominated\nclaystones",
+        "Organically dominated\nmudstones",
+        "Organically rich\nmudstones",
+        "Organically lean\nmudstones",
+    ]
+    text_ang = [60, 60, 60, -60, -60, -60]
+    text_pos = np.array(
+        [
+            [0.0, 0.1],
+            [0.0, 0.4],
+            [0.0, 0.8],
+            [1.0, 0.8],
+            [1.0, 0.4],
+            [1.0, 0.1],
+        ]
+    )
+    text_pos = _triangle_transform(text_pos)
+    text_pos = text_pos + np.array(
+        [
+            [-0.05, 0.0],
+            [0.1, 0.05],
+        ]
+    ).reshape(2, 2).repeat(3, axis=0)
+    for i in range(len(names)):
+        plt.text(
+            text_pos[i, 0],
+            text_pos[i, 1],
+            names[i],
+            horizontalalignment="center",
+            verticalalignment="center",
+            fontsize=10,
+            rotation=text_ang[i],
+        )
+
+    # Calculate the hardness parameter
+    soft = clay + kero + phit
+    brit = quartz + carb
+
+    hard = brit / (brit + soft)
+
+    # Scale kerogen
+    kero = np.minimum(kero, KEROMAX)
+    kero_scal = kero / KEROMAX
+
+    data_xy = _triangle_transform(np.column_stack((hard, kero_scal)))
+    plt.scatter(data_xy[:, 0], data_xy[:, 1], s=64, c=col_code, zorder=4)
+
+    hcb = plt.colorbar(pad=0.1)
+    hcb.set_label(name_col_code, fontname="sans-serif", fontweight="bold", fontsize=11)
+
+    # plt.show()<= Show command is issued in controlling class method
+    if draw_figures:
+        plt.draw()
+
+    return hard

rock_physics_open/ternary_plots/ternary_patches.py

@@ -0,0 +1,277 @@
+import numpy as np
+from matplotlib import path as pa, pyplot as plt
+
+from .ternary_plot_utilities import (
+    _make_mesh,
+    _set_ternary_figure,
+    _ternary_coord_trans,
+)
+
+
+def _ternary_patches(quartz, carb, clay, kero, well_name, draw_figures=True):
+    """Class display of the shale.
+
+    Parameters
+    ----------
+    quartz : np.ndarray
+        Quartz volume fraction [fraction].
+    carb : np.ndarray
+        Carbonate volume fraction [fraction].
+    clay : np.ndarray
+        Clay volume fraction [fraction].
+    kero : np.ndarray
+        Kerogen volume fraction [fraction].
+    well_name : str
+        Plot heading with well name.
+
+    Returns
+    -------
+    np.ndarray
+        Lithology class [int].
+    """
+    fig, ax = _set_ternary_figure(0, 0, "Lithological Class Ternary Plot", well_name)
+
+    # Define patches 1 - 16
+    names = [
+        "Silica-\ndominated\nlithotype",
+        "Clay-rich\nsiliceous mudstone",
+        "Mixed\nsiliceous\nmudstone",
+        "Carbonate-rich\nsiliceous mudstone",
+        "Argilaceous/\nsiliceous\nmudstone",
+        "Mixed\nmudstone",
+        "Carbonate/\nsiliceous\nmudstone",
+        "Silica-rich\nargillaceous mudstone",
+        "Mixed\nargillaceous\nmudstone",
+        "Argillaceous/\ncarbonate\nmudstone\n(marl)",
+        "Mixed\ncarbonate\nmudstone",
+        "Silica-rich\ncarbonate mudstone",
+        "Clay-\ndominated\nlithotype",
+        "Carbonate-rich\nargillaceous mudstone",
+        "Clay-rich\ncarbonate mudstone",
+        "Carbonate-\ndominated\nlithotype",
+    ]
+    text_ang = [0, 60, 0, 0, 0, 0, 0, 60, 0, 0, 0, 0, 0, -60, -60, 0]
+    col = (
+        1
+        / 255
+        * np.array(
+            [
+                [244, 237, 29],
+                [249, 246, 142],
+                [255, 230, 137],
+                [249, 246, 137],
+                [254, 220, 95],
+                [222, 238, 197],
+                [131, 209, 193],
+                [214, 170, 40],
+                [197, 166, 114],
+                [169, 169, 134],
+                [193, 215, 239],
+                [150, 180, 218],
+                [175, 116, 76],
+                [169, 123, 44],
+                [96, 149, 202],
+                [114, 126, 188],
+            ]
+        )
+    )
+
+    vertices = [
+        np.array(
+            [
+                [1.0, 0.0, 0.0],
+                [0.8, 0.0, 0.2],
+                [0.8, 0.2, 0.0],
+            ]
+        ),
+        np.array(
+            [
+                [0.8, 0.0, 0.2],
+                [0.5, 0.0, 0.5],
+                [0.5, 0.1, 0.4],
+                [0.8, 0.1, 0.1],
+            ]
+        ),
+        np.array(
+            [
+                [0.8, 0.1, 0.1],
+                [0.5, 0.1, 0.4],
+                [0.5, 0.4, 0.1],
+            ]
+        ),
+        np.array(
+            [
+                [0.8, 0.1, 0.1],
+                [0.5, 0.4, 0.1],
+                [0.5, 0.5, 0.0],
+                [0.8, 0.2, 0.0],
+            ]
+        ),
+        np.array(
+            [
+                [0.5, 0.0, 0.5],
+                [0.3, 0.2, 0.5],
+                [0.5, 0.2, 0.3],
+            ]
+        ),
+        np.array(
+            [
+                [0.5, 0.2, 0.3],
+                [0.3, 0.2, 0.5],
+                [0.2, 0.3, 0.5],
+                [0.2, 0.5, 0.3],
+                [0.3, 0.5, 0.2],
+                [0.5, 0.3, 0.2],
+            ]
+        ),
+        np.array(
+            [
+                [0.5, 0.3, 0.2],
+                [0.3, 0.5, 0.2],
+                [0.5, 0.5, 0.0],
+            ]
+        ),
+        np.array(
+            [
+                [0.5, 0.0, 0.5],
+                [0.2, 0.0, 0.8],
+                [0.1, 0.1, 0.8],
+                [0.4, 0.1, 0.5],
+            ]
+        ),
+        np.array(
+            [
+                [0.4, 0.1, 0.5],
+                [0.1, 0.1, 0.8],
+                [0.1, 0.4, 0.5],
+            ]
+        ),
+        np.array(
+            [
+                [0.0, 0.5, 0.5],
+                [0.2, 0.5, 0.3],
+                [0.2, 0.3, 0.5],
+            ]
+        ),
+        np.array(
+            [
+                [0.1, 0.5, 0.4],
+                [0.1, 0.8, 0.1],
+                [0.4, 0.5, 0.1],
+            ]
+        ),
+        np.array(
+            [
+                [0.4, 0.5, 0.1],
+                [0.1, 0.8, 0.1],
+                [0.2, 0.8, 0.0],
+                [0.5, 0.5, 0.0],
+            ]
+        ),
+        np.array(
+            [
+                [0.2, 0.0, 0.8],
+                [0.0, 0.0, 1.0],
+                [0.0, 0.2, 0.8],
+            ]
+        ),
+        np.array(
+            [
+                [0.0, 0.2, 0.8],
+                [0.0, 0.5, 0.5],
+                [0.1, 0.4, 0.5],
+                [0.1, 0.1, 0.8],
+            ]
+        ),
+        np.array(
+            [
+                [0.0, 0.5, 0.5],
+                [0.0, 0.8, 0.2],
+                [0.1, 0.8, 0.1],
+                [0.1, 0.5, 0.4],
+            ]
+        ),
+        np.array(
+            [
+                [0.0, 0.8, 0.2],
+                [0.0, 1.0, 0.0],
+                [0.2, 0.8, 0.0],
+            ]
+        ),
+    ]
+
+    vertices_xy = []
+    for i in range(len(vertices)):
+        vertices_xy.append(_ternary_coord_trans(vertices[i]))
+
+    h_p = []
+    h_t = []
+    for i in range(len(vertices)):
+        h_p.append(
+            plt.fill(
+                vertices_xy[i][:, 0],
+                vertices_xy[i][:, 1],
+                facecolor=col[i, :],
+                edgecolor="k",
+            )
+        )
+        h_t.append(
+            plt.text(
+                np.mean(vertices_xy[i][:, 0]),
+                np.mean(vertices_xy[i][:, 1]),
+                names[i],
+                horizontalalignment="center",
+                verticalalignment="center",
+                fontsize=8,
+                rotation=text_ang[i],
+            )
+        )
+
+    # Make coordinate mesh
+    _, _ = _make_mesh(ax)
+
+    # Annotate the axes
+    label_handles = []
+    label_handles.append(
+        plt.text(0.5, -0.075, "Carbonate", horizontalalignment="center")
+    )
+    label_handles.append(
+        plt.text(
+            0.15,
+            np.sqrt(3) / 4 + 0.05,
+            "Quartz",
+            horizontalalignment="center",
+            rotation=60,
+        )
+    )
+    label_handles.append(
+        plt.text(
+            0.85,
+            np.sqrt(3) / 4 + 0.05,
+            "Clay",
+            horizontalalignment="center",
+            rotation=-60,
+        )
+    )
+    plt.setp(label_handles, fontname="sans-serif", fontweight="bold", fontsize=11)
+
+    # Plot data
+    data_xy = _ternary_coord_trans(quartz, carb, clay)
+    plt.scatter(data_xy[:, 0], data_xy[:, 1], s=64, c=kero, zorder=4)
+
+    # Classification - start at 2001 to match predefined lithology classes in
+    startclass = 2000
+    lith_class = np.ones(quartz.shape) * np.nan
+    for i in range(len(vertices_xy)):
+        # class_path = pa.Path(vertices_xy[i], closed=True)
+        class_path = pa.Path(vertices_xy[i])
+        in_path = class_path.contains_points(data_xy)
+        lith_class[in_path] = i + startclass
+
+    hcb = plt.colorbar()
+    hcb.set_label("Kerogen", fontname="sans-serif", fontweight="bold", fontsize=11)
+
+    # plt.show() <= Show command must be issued from the controlling class method
+    if draw_figures:
+        plt.draw()
+    return lith_class