geost 0.2.0__py3-none-any.whl

geost/__init__.py

@@ -0,0 +1,14 @@
+from geost.read import (
+    get_bro_objects_from_bbox,
+    get_bro_objects_from_geometry,
+    read_borehole_table,
+    read_gef_cores,
+    read_gef_cpts,
+    read_nlog_cores,
+    read_sst_cpts,
+    read_xml_cpts,
+    read_xml_geological_cores,
+    read_xml_geotechnical_cores,
+    read_xml_soil_cores,
+)
+from geost.utils import csv_to_parquet, excel_to_parquet

geost/_borehole.py

@@ -0,0 +1,86 @@
+# class CptCollection(PointDataCollection):
+#     """
+#     Class for collections of CPT data.
+
+#     Users must use the reader functions in
+#     :py:mod:`~geost.read` to create collections. The following readers generate CPT
+#     objects:
+
+#     :func:`~geost.read.read_sst_cpts`, :func:`~geost.read.read_gef_cpts`
+
+#     Args:
+#         data (pd.DataFrame): Dataframe containing borehole/CPT data.
+
+#         vertical_reference (str): Vertical reference, see
+#          :py:attr:`~geost.base.PointDataCollection.vertical_reference`
+
+#         horizontal_reference (int): Horizontal reference, see
+#          :py:attr:`~geost.base.PointDataCollection.horizontal_reference`
+
+#         header (pd.DataFrame): Header used for construction. see
+#          :py:attr:`~geost.base.PointDataCollection.header`
+#     """
+
+#     def __init__(
+#         self,
+#         data: pd.DataFrame,
+#         vertical_reference: str = "NAP",
+#         horizontal_reference: int = 28992,
+#         header: Optional[pd.DataFrame] = None,
+#         is_inclined: bool = False,
+#     ):
+#         super().__init__(
+#             data,
+#             vertical_reference,
+#             horizontal_reference,
+#             header=header,
+#             is_inclined=is_inclined,
+#         )
+
+#     def add_ic(
+#         self,
+#     ):  # Move to cpt analysis functions, use something like 'apply' function in classes
+#         """
+#         Calculate soil behaviour type index (Ic) for all CPT's in the collection.
+
+#         The data is added to :py:attr:`~geost.base.PointDataCollection.header`.
+#         """
+#         self.data["ic"] = calc_ic(self.data["qc"], self.data["friction_number"])
+
+#     def add_lithology(
+#         self,
+#     ):  # Move to cpt analysis functions, use something like 'apply' function in classes
+#         """
+#         Interpret lithoclass for all CPT's in the collection.
+
+#         The data is added to :py:attr:`~geost.base.PointDataCollection.header`.
+#         """
+#         if "ic" not in self.data.columns:
+#             self.add_ic()
+#         self.data["lith"] = calc_lithology(
+#             self.data["ic"], self.data["qc"], self.data["friction_number"]
+#         )
+
+#     def as_boreholecollection(self):  # No change
+#         """
+#         Export CptCollection to BoreholeCollection. Requires the "lith" column to be
+#         present. Use the method :py:meth:`~geost.borehole.CptCollection.add_lithology`
+
+#         Returns
+#         -------
+#         Instance of :class:`~geost.borehole.BoreholeCollection`
+#         """
+#         if "lith" not in self.data.columns:
+#             raise IndexError(
+#                 r"The column \"lith\" is required to convert to BoreholeCollection"
+#             )
+
+#         borehole_converted_dataframe = self.data[
+#             ["nr", "x", "y", "surface", "end", "top", "bottom", "lith"]
+#         ]
+#         cptcollection_as_bhcollection = BoreholeCollection(
+#             borehole_converted_dataframe,
+#             vertical_reference=self.vertical_reference,
+#             header=self.header,
+#         )
+#         return cptcollection_as_bhcollection

geost/abstract_classes.py

@@ -0,0 +1,251 @@
+from abc import ABC, abstractmethod
+
+
+class AbstractHeader(ABC):
+    @property
+    @abstractmethod
+    def gdf(self):
+        pass
+
+    @property
+    @abstractmethod
+    def horizontal_reference(self):
+        pass
+
+    @property
+    @abstractmethod
+    def vertical_reference(self):
+        pass
+
+    @gdf.setter
+    @abstractmethod
+    def gdf(self, gdf):
+        pass
+
+    @abstractmethod
+    def change_horizontal_reference(self):
+        pass
+
+    @abstractmethod
+    def change_vertical_reference(self):
+        pass
+
+    @abstractmethod
+    def get(self):
+        pass
+
+    @abstractmethod
+    def select_within_bbox(self):
+        pass
+
+    @abstractmethod
+    def select_with_points(self):
+        pass
+
+    @abstractmethod
+    def select_with_lines(self):
+        pass
+
+    @abstractmethod
+    def select_within_polygons(self):
+        pass
+
+    @abstractmethod
+    def select_by_depth(self):
+        pass
+
+    @abstractmethod
+    def select_by_length(self):
+        pass
+
+    @abstractmethod
+    def get_area_labels(self):
+        pass
+
+
+class AbstractData(ABC):
+    @property
+    @abstractmethod
+    def df(self):
+        pass
+
+    @property
+    @abstractmethod
+    def datatype(self):
+        pass
+
+    @df.setter
+    @abstractmethod
+    def df(self, df):
+        pass
+
+    @datatype.setter
+    @abstractmethod
+    def datatype(self):
+        pass
+
+    @abstractmethod
+    def to_header(self):
+        pass
+
+    @abstractmethod
+    def to_collection(self):
+        pass
+
+    @abstractmethod
+    def select_by_values(self):
+        pass
+
+    @abstractmethod
+    def slice_depth_interval(self):
+        pass
+
+    @abstractmethod
+    def slice_by_values(self):
+        pass
+
+    @abstractmethod
+    def get_cumulative_layer_thickness(self):
+        # Not sure if this should be here, potentially unsuitable with DiscreteData
+        pass
+
+    @abstractmethod
+    def get_layer_top(self):
+        pass
+
+    @abstractmethod
+    def to_multiblock(self):
+        pass
+
+    @abstractmethod
+    def to_vtm(self):
+        pass
+
+    @abstractmethod
+    def to_datafusiontools(self):
+        # supporting this is low priority, perhaps even deprecate
+        pass
+
+
+class AbstractCollection(ABC):
+    @property
+    @abstractmethod
+    def header(self):
+        pass
+
+    @property
+    @abstractmethod
+    def data(self):
+        pass
+
+    @property
+    def n_points(self):
+        pass
+
+    @property
+    @abstractmethod
+    def horizontal_reference(self):  # Move to header class in future refactor
+        pass
+
+    @property
+    @abstractmethod
+    def vertical_reference(self):  # move to data class in future refactor
+        pass
+
+    @header.setter
+    @abstractmethod
+    def header(self, header):
+        pass
+
+    @data.setter
+    @abstractmethod
+    def data(self, data):
+        pass
+
+    @horizontal_reference.setter
+    @abstractmethod
+    def horizontal_reference(self, to_epsg: int):
+        pass
+
+    @vertical_reference.setter
+    @abstractmethod
+    def vertical_reference(self, to_epsg: str):  # will use epsg after refactor
+        pass
+
+    @abstractmethod
+    def get(self):
+        pass
+
+    @abstractmethod
+    def reset_header(self):
+        pass
+
+    @abstractmethod
+    def check_header_to_data_alignment(self):
+        pass
+
+    @abstractmethod
+    def select_within_bbox(self):
+        pass
+
+    @abstractmethod
+    def select_with_points(self):
+        pass
+
+    @abstractmethod
+    def select_with_lines(self):
+        pass
+
+    @abstractmethod
+    def select_within_polygons(self):
+        pass
+
+    @abstractmethod
+    def select_by_depth(self):
+        pass
+
+    @abstractmethod
+    def select_by_length(self):
+        pass
+
+    @abstractmethod
+    def get_area_labels(self):
+        pass
+
+    @abstractmethod
+    def select_by_values(self):
+        pass
+
+    @abstractmethod
+    def slice_depth_interval(self):
+        pass
+
+    @abstractmethod
+    def slice_by_values(self):
+        pass
+
+    @abstractmethod
+    def get_cumulative_layer_thickness(self):
+        # Not sure if this should be here, potentially unsuitable with DiscreteData
+        # These kind of methods should go to a seperate layer_analysis module with
+        # functions to cover such analyses
+        pass
+
+    @abstractmethod
+    def get_layer_top(self):
+        # These kind of methods should go to a seperate layer_analysis module with
+        # functions to cover such analyses
+        pass
+
+    @abstractmethod
+    def to_multiblock(self):
+        pass
+
+    @abstractmethod
+    def to_vtm(self):
+        pass
+
+    @abstractmethod
+    def to_datafusiontools(self):
+        # supporting this is low priority, perhaps even deprecate
+        pass

geost/analysis/__init__.py

@@ -0,0 +1,6 @@
+from geost.analysis.layer_analysis import (
+    cumulative_thickness,
+    find_top_sand,
+    layer_top,
+    top_of_sand,
+)

geost/analysis/interpret_cpt.py

@@ -0,0 +1,50 @@
+import numpy as np
+
+# NOTE: temporary functions ripped from old code. To be made compatible with Geolib
+# functions
+
+
+def calc_ic(qc, rf) -> np.ndarray:
+    """
+    Calculate non-normalized IC values (I_SBT in Robertson 2010). The non-normalized
+    variant does not require calculations of stresses to normalize with and hence no PWP
+    data is required.
+
+    Please note the following when using non-normalized IC values:
+
+    "The non-normalized SBT index (ISBT) is essentially the same as the normalized SBTn
+    index (Ic) but only uses the basic CPT measurements. In general, the normalized Ic
+    provides more reliable identification of SBT than the non-normalized ISBT, but when
+    the insitu vertical effective stress is between 50 kPa to 150 kPa there is often
+    little difference between normalized and non-normalized SBT."
+
+    Parameters
+    ----------
+    qc : np.ndarray
+        Cone resistance values
+    rf : np.ndarray
+        Friction number
+
+    Returns
+    -------
+    np.ndarray
+        Non-normalized IC
+    """
+    ic = np.sqrt((3.47 - np.log10(qc / 0.1)) ** 2 + (np.log10(rf) + 1.22) ** 2)
+    return ic
+
+
+# TODO numpy searchsort
+def calc_lithology(ic, qc, rf) -> np.ndarray:
+    boundaries = [1.6, 2.0, 2.2, 2.6, 2.95, 3.6]
+    lith = np.full_like(ic, "NBE", dtype="<U3")
+    lith[ic < boundaries[0]] = "Z"
+    lith[(ic >= boundaries[0]) & (ic < boundaries[1])] = "Z"
+    lith[(ic >= boundaries[1]) & (ic < boundaries[2])] = "Z"
+    lith[(ic >= boundaries[2]) & (ic < boundaries[3])] = "Z"
+    lith[(ic >= boundaries[3]) & (ic < boundaries[4])] = "Kz"
+    lith[(ic >= boundaries[4]) & (ic < boundaries[5])] = "K"
+    lith[(ic >= boundaries[5]) & (rf > 8)] = "V"
+    lith[((rf > 5) & (qc < 1.5)) | (rf > 6)] = "V"
+    lith[(ic >= boundaries[5]) & (rf <= 8)] = "Kh"
+    return lith

geost/analysis/layer_analysis.py

@@ -0,0 +1,90 @@
+import numpy as np
+
+
+def find_top_sand(
+    lith: np.ndarray,
+    top: np.ndarray,
+    bottom: np.ndarray,
+    min_sand_frac: float,
+    min_sand_thickness: float,
+) -> float:
+    """
+    Find the top of sand depth in a borehole. The top of sand is defined by the
+    first layer of a specified thickness that contains a minimum percentage of
+    sand. By default: when the first layer of sand is detected, the next 1 meter
+    is scanned. Within this meter, if more than 50% of the lenght has a main
+    lithology of sand, the initially detected layer of sand is regarded as the top
+    of sand. If not, continue downward until the next layer of sand is detected and
+    repeat.
+
+    Parameters
+    ----------
+    lith : ndarray
+        Numpy array containing the lithology of the borehole.
+    top : ndarray
+        Numpy array containing the top depth of the layers of the borehole.
+    bottom : ndarray
+        Numpy array containing the bottom depth of the layers of the borehole.
+    min_sand_frac : float
+        Minimum percentage required to be sand.
+    min_sand_thickness : float
+        Minimum thickness of the sand to search for.
+
+    Returns
+    -------
+    top_sand : float
+        Top depth of the sand layer that meets the requirements.
+
+    """
+    is_sand = ("Z" == lith) + ("G" == lith)
+    is_unknown = ("GM" == lith) + ("NBE" == lith)
+
+    if np.any(is_sand) and not np.any(is_unknown):
+        idx_sand = np.where(is_sand)[0]
+        for idx in idx_sand:
+            top_sand = top[idx]
+            search_depth = top_sand - min_sand_thickness
+
+            search_mask = (top <= top_sand) & (top > search_depth)
+
+            tmp_top = top[search_mask]
+            tmp_bottom = bottom[search_mask]
+            tmp_bottom[-1] = search_depth
+
+            length = tmp_top - tmp_bottom
+
+            sand_frac = length[is_sand[search_mask]].sum() / min_sand_thickness
+
+            if sand_frac >= min_sand_frac:
+                break
+
+    else:
+        top_sand = np.nan
+
+    return top_sand
+
+
+def top_of_sand(boreholes, ids="nr", min_sand_frac=0.5, min_sand_thickness=1):
+    groupby = boreholes.groupby(ids)
+
+    for nr, df in groupby:
+        lith = df["lith"].values
+        top = df["top"].values
+        bottom = df["bottom"].values
+
+        top_sand = find_top_sand(lith, top, bottom, min_sand_frac, min_sand_thickness)
+
+        yield (nr, top_sand)
+
+
+def cumulative_thickness(data, top: str = "top", bottom: str = "bottom"):
+    return np.abs(np.sum(data[top] - data[bottom]))
+
+
+def layer_top(data, column: str, value: str): # TODO
+    for nr, obj in data.groupby("nr"):
+        try:
+            layer_top = obj[obj[column] == value].iloc[0]["top"]
+        except IndexError:
+            layer_top = np.nan
+        yield (nr, layer_top)