py-pilecore 0.4.0__tar.gz → 0.4.2__tar.gz

{py-pilecore-0.4.0/src/py_pilecore.egg-info → py_pilecore-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py-pilecore
-Version: 0.4.0
+Version: 0.4.2
 Summary: Public python SDK for the CEMS PileCore web-API.
 License: MIT License
         
@@ -37,6 +37,7 @@ Requires-Dist: matplotlib<4,>=3.8
 Requires-Dist: tqdm[notebook]<5,>4
 Requires-Dist: natsort<9,>8
 Requires-Dist: shapely<3,>=2
+Requires-Dist: scipy<2,>=1
 Provides-Extra: test
 Requires-Dist: coveralls; extra == "test"
 Requires-Dist: pytest; extra == "test"

{py-pilecore-0.4.0 → py_pilecore-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "py-pilecore"
-version = "0.4.0"
+version = "0.4.2"
 description = "Public python SDK for the CEMS PileCore web-API."
 requires-python = ">=3.9"
 dependencies = [
@@ -16,6 +16,7 @@ dependencies = [
     "tqdm[notebook]>4,<5",
     "natsort>8,<9",
     "shapely>=2,<3",
+    "scipy>=1, <2",
 ]
 license = { file = "LICENSE" }
 readme = "README.md"

{py-pilecore-0.4.0 → py_pilecore-0.4.2/src/py_pilecore.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py-pilecore
-Version: 0.4.0
+Version: 0.4.2
 Summary: Public python SDK for the CEMS PileCore web-API.
 License: MIT License
         
@@ -37,6 +37,7 @@ Requires-Dist: matplotlib<4,>=3.8
 Requires-Dist: tqdm[notebook]<5,>4
 Requires-Dist: natsort<9,>8
 Requires-Dist: shapely<3,>=2
+Requires-Dist: scipy<2,>=1
 Provides-Extra: test
 Requires-Dist: coveralls; extra == "test"
 Requires-Dist: pytest; extra == "test"

{py-pilecore-0.4.0 → py_pilecore-0.4.2}/src/py_pilecore.egg-info/requires.txt

@@ -6,6 +6,7 @@ matplotlib<4,>=3.8
 tqdm[notebook]<5,>4
 natsort<9,>8
 shapely<3,>=2
+scipy<2,>=1
 
 [docs]
 Sphinx==6.1.3

{py-pilecore-0.4.0 → py_pilecore-0.4.2}/src/pypilecore/_version.py

@@ -4,4 +4,4 @@ try:
     __version__ = version("py-pilecore")
 # during CI
 except PackageNotFoundError:
-    __version__ = "0.4.0"
+    __version__ = "0.4.2"

{py-pilecore-0.4.0 → py_pilecore-0.4.2}/src/pypilecore/input/grouper_properties.py

@@ -43,7 +43,7 @@ def create_grouper_payload(
     "/grouper/group_cpts"
 
 
-    Notes
+    Note
     ------
     The grouper uses pile bearing capacity results calculated by PileCore or other software to
     form  subgroups of the total group of CPT’s belonging to this project.
@@ -56,7 +56,6 @@ def create_grouper_payload(
         - is spatially coherent, which means there are no other CPTs in between the members
           of the subgroup. (Spatial check)
 
-
     Additionally, centre to centre validation (include_centre_to_centre_check; NEN9997-1 3.2.3) can be
     added to the cluster method. This check adds restrictions to the maximum allowable R;c;cal outliers
     and makes sure that the suitable data density requirements for the subgroup are met, by checking the

{py-pilecore-0.4.0 → py_pilecore-0.4.2}/src/pypilecore/input/multi_cpt.py

@@ -313,9 +313,9 @@ def create_multi_cpt_payload(
         individual_ocr=individual_ocr,
     )
     pile_properties = create_pile_properties_payload(
-        pile_type=pile_type,
-        specification=specification,
-        installation=installation,
+        pile_type=str(pile_type),
+        specification=str(specification),
+        installation=str(installation),
         pile_shape=pile_shape,
         diameter_base=diameter_base,
         diameter_shaft=diameter_shaft,
@@ -344,7 +344,7 @@ def create_multi_cpt_payload(
         pile_head_level_nap=pile_head_level_nap,
         stiff_construction=stiff_construction,
         rel_pile_load=relative_pile_load,
-        soil_load=soil_load_sls,
+        soil_load=soil_load_sls if soil_load_sls is not None else 0.0,
         excavation_param_t=excavation_param_t,
         use_almere_rules=use_almere_rules,
         gamma_f_nk=gamma_f_nk,

{py-pilecore-0.4.0 → py_pilecore-0.4.2}/src/pypilecore/input/pile_properties.py

@@ -29,8 +29,9 @@ def create_pile_properties_payload(
     Creates a dictionary with the `pile_properties` payload content for the PileCore
     endpoints.
 
-    Note that
-    the dictionary should be converted to a jsonifyable message before it can be passed
+    Note
+    ----
+    The dictionary should be converted to a jsonifyable message before it can be passed
     to a `requests` call directly, for instance with
     `nuclei.client.utils.python_types_to_message()`.
 

{py-pilecore-0.4.0 → py_pilecore-0.4.2}/src/pypilecore/input/soil_properties.py

@@ -35,7 +35,7 @@ def create_soil_properties_payload(
     Creates a dictionary with the `soil_properties` payload content for the PileCore
     endpoints.
 
-    Notes
+    Note
     ------
     the dictionary should be converted to a jsonifyable message before it can be passed
     to a `requests` call directly, for instance with

{py-pilecore-0.4.0 → py_pilecore-0.4.2}/src/pypilecore/results/grouper_result.py

@@ -211,7 +211,7 @@ class SingleClusterData:
         """
         Plot the bearing capacity and variation coefficient in a subplot
 
-        Notes
+        Note
         ------
         For the `Net bearing capacity` subplot there are two colors plotted:
          - orange:  conservative bearing capacity
@@ -251,7 +251,7 @@ class SingleClusterData:
         """
         Plot the spacing checks in a subplot
 
-        Notes
+        Note
         ------
         For the `spacing` subplot there are two colors plotted:
          - red:     invalid spacing
@@ -308,7 +308,7 @@ class SingleClusterData:
         """
         Plot the xi factor in a subplot
 
-        Notes
+        Note
         ------
         For the `xi factor` subplot there are two colors plotted:
          - olive:   xi3
@@ -499,7 +499,7 @@ class SingleClusterResult:
             - xi factor
             - centre to centre validation
 
-        Notes
+        Note
         ------
         For the `Net bearing capacity` subplot there are two colors plotted:
          - orange:  conservative bearing capacity
@@ -775,6 +775,9 @@ class GrouperResults:
     ) -> plt.Figure:
         """
         Plot a summary of the valid subgroups.
+
+        Note
+        -----
         Plot contains the:
 
             - cpts within a subgroup

{py-pilecore-0.4.0 → py_pilecore-0.4.2}/src/pypilecore/results/multi_cpt_results.py

@@ -7,6 +7,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 from matplotlib.axes import Axes
+from matplotlib.patches import Patch
 
 from pypilecore.exceptions import UserError
 from pypilecore.results.load_settlement import get_load_settlement_plot
@@ -548,6 +549,166 @@ class MultiCPTBearingResults:
         """The CPTGroupResultsTable dataclass, containing the group results."""
         return self._group_results_table
 
+    def boxplot(
+        self,
+        attribute: str,
+        axes: Axes | None = None,
+        figsize: Tuple[float, float] = (6.0, 6.0),
+        show_sqrt: bool = False,
+        **kwargs: Any,
+    ) -> Axes:
+        """
+        Plot a box and whisker plot for a given attribute.
+
+
+        .. code-block:: none
+
+                     MIN      Q1   median  Q3       MAX
+                               |-----:-----|
+                      |--------|     :     |--------|
+                               |-----:-----|
+
+        Parameters
+        ----------
+        attribute:
+            result attribute to create boxplot. Please note that the attribute name must be present in
+            the `CPTResultsTable` and `CPTGroupResultsTable` class.
+        axes:
+            Optional `Axes` object where the boxplot data can be plotted on.
+            If not provided, a new `plt.Figure` will be activated and the `Axes`
+            object will be created and returned.
+        figsize:
+            Size of the activate figure, as the `plt.figure()` argument.
+        show_sqrt:
+            Add sqrt(2) bandwidth to figure
+        **kwargs:
+            All additional keyword arguments are passed to the `pyplot.subplots()` call.
+
+        Returns
+        -------
+        axes:
+            The `Axes` object where the settlement curves were plotted on
+        """
+
+        # validate attribute
+        if (
+            attribute not in self.cpt_results.results[0].table.__dict__.keys()
+            or attribute not in self.group_results_table.__dict__.keys()
+        ):
+            raise ValueError(
+                f"""
+                {attribute} is not present in CPTResultsTable or CPTGroupResultsTable class.
+                Please select on of the following attributes:
+                {
+                    set(self.cpt_results.results[0].table.__dict__.keys())
+                     & set(self.group_results_table.__dict__.keys())
+                }
+                """
+            )
+
+        # Create axes objects if not provided
+        if axes is not None:
+            if not isinstance(axes, Axes):
+                raise ValueError(
+                    "'axes' argument to boxplot() must be a `pyplot.axes.Axes` object or None."
+                )
+        else:
+            kwargs_subplot = {
+                "figsize": figsize,
+                "tight_layout": True,
+            }
+
+            kwargs_subplot.update(kwargs)
+
+            _, axes = plt.subplots(
+                1,
+                1,
+                **kwargs_subplot,
+            )
+
+            if not isinstance(axes, Axes):
+                raise ValueError(
+                    "Could not create Axes objects. This is probably due to invalid matplotlib keyword arguments. "
+                )
+
+        # Collect data from single calculation
+        data = np.array(
+            [
+                item.table.__getattribute__(attribute)
+                for item in self.cpt_results.results
+            ]
+        )
+
+        # Draw a box and whisker plot
+        axes.boxplot(
+            np.flip(data, axis=0),
+            labels=np.flip(self.group_results_table.pile_tip_level_nap),
+            whis=(0, 100),
+            autorange=True,
+            vert=False,
+            patch_artist=True,
+            showmeans=True,
+            zorder=0,
+        )
+
+        # ad additional bandwidth of sqrt(2) of the mean value
+        if show_sqrt:
+            axes.scatter(
+                np.flip(data.mean(axis=0)) * np.sqrt(2),
+                np.flip(
+                    np.arange(len(self.group_results_table.pile_tip_level_nap)) + 1
+                ),
+                marker="^",
+                color="tab:purple",
+                zorder=1,
+            )
+            axes.scatter(
+                np.flip(data.mean(axis=0)) / np.sqrt(2),
+                np.flip(
+                    np.arange(len(self.group_results_table.pile_tip_level_nap)) + 1
+                ),
+                marker="^",
+                color="tab:purple",
+                zorder=1,
+            )
+
+        # Draw group result over single result
+        axes.scatter(
+            np.flip(self.group_results_table.__getattribute__(attribute)),
+            np.flip(np.arange(len(self.group_results_table.pile_tip_level_nap)) + 1),
+            marker="o",
+            color="tab:red",
+            zorder=1,
+        )
+
+        # Draw group result over single result
+        for i, x in enumerate(data.mean(axis=0)):
+            axes.annotate(f"{x.round(2)}", xy=(x, i + 1))
+
+        # add legend to figure
+        axes.legend(
+            handles=[
+                Patch(color=clr, label=key)
+                for (key, clr) in {
+                    "Single;min:max": "black",
+                    "Single;Q25:Q75": "tab:blue",
+                    "Single;Q50": "tab:orange",
+                    "Single;mean": "tab:green",
+                    "Single;mean;sqrt": "tab:purple",
+                    "Group;normative": "tab:red",
+                }.items()
+            ],
+            loc="upper left",
+            bbox_to_anchor=(1, 1),
+            title=f"Bandwidth {attribute}",
+        )
+
+        # set label
+        axes.set_ylabel("Depth [m NAP]")
+        axes.set_xlabel(f"{attribute}")
+
+        return axes
+
     def plot_load_settlement(
         self,
         pile_tip_level_nap: float,

{py-pilecore-0.4.0 → py_pilecore-0.4.2}/src/pypilecore/results/post_processing.py

@@ -9,8 +9,10 @@ import numpy as np
 import pandas as pd
 from matplotlib import pyplot as plt
 from matplotlib.axes import Axes
+from matplotlib.collections import PatchCollection
 from matplotlib.figure import Figure
 from numpy.typing import NDArray
+from scipy.spatial import Delaunay, Voronoi, voronoi_plot_2d
 
 from pypilecore.results.soil_properties import SoilProperties, get_soil_layer_handles
 
@@ -94,7 +96,7 @@ class MaxBearingResult:
         The object with soil properties
     pile_head_level_nap
         The elevation of the pile-head, in [m] w.r.t. NAP.
-    results_table
+    table
         The object with CPT results.
     """
 
@@ -371,6 +373,59 @@ class MaxBearingResults:
 
         return cpt_results_df
 
+    @lru_cache()
+    def triangulation(self, pile_tip_level_nap: float) -> List[Dict[str, list]]:
+        """
+        Delaunay tessellation based on the CPT location
+
+        Returns
+        -------
+        collection: List
+            A list of dictionaries containing the tessellation
+            geometry and corresponding cpt names:
+
+                - geometry: List[Tuple[float, float]]
+                - test_id: List[str]
+
+        """
+        _lookup = {
+            (point.soil_properties.x, point.soil_properties.y): key
+            for key, point in self.cpt_results_dict.items()
+        }
+        # select point with valid bearing capacity at pile tip level
+        _points = (
+            self.to_pandas()
+            .loc[
+                (self.to_pandas()["pile_tip_level_nap"] == pile_tip_level_nap)
+                & (~pd.isna(self.to_pandas()["R_c_d_net"])),
+                ["x", "y"],
+            ]
+            .to_numpy()
+            .tolist()
+        )
+
+        # check if enough points Delaunay
+        if len(_points) < 4:
+            raise ValueError(
+                "Not enough points at this pile tip level to construct "
+                "the delaunay tessellation based on the CPT location."
+            )
+        tri = Delaunay(
+            _points,
+            incremental=False,
+            furthest_site=False,
+            qhull_options="Qbb",
+        )
+        geometries = np.array(_points)[tri.simplices]
+
+        return [
+            {
+                "geometry": geometry.tolist(),
+                "test_id": [_lookup[(xy[0], xy[1])] for xy in geometry],
+            }
+            for geometry in geometries
+        ]
+
     def plot(
         self,
         projection: Optional[Literal["3d"]] = "3d",
@@ -413,20 +468,20 @@ class MaxBearingResults:
         kwargs_subplot.update(kwargs)
         fig = plt.figure(**kwargs_subplot)
         axes = fig.add_subplot(projection=projection)
+        df = self.to_pandas().dropna()
         # create color list based on hue option
         if hue == "category":
             colors = [
-                "red" if var < pile_load_uls else "green"
-                for var in self.to_pandas()["R_c_d_net"]
+                "red" if var < pile_load_uls else "green" for var in df["R_c_d_net"]
             ]
         else:
-            colors = self.to_pandas()["R_c_d_net"].tolist()
+            colors = df["R_c_d_net"].tolist()
         # create scatter plot
         if projection == "3d":
             cmap = axes.scatter(
-                self.to_pandas()["x"],
-                self.to_pandas()["y"],
-                self.to_pandas()["pile_tip_level_nap"],
+                df["x"],
+                df["y"],
+                df["pile_tip_level_nap"],
                 c=colors,
             )
             axes.set_xlabel("X")
@@ -444,12 +499,13 @@ class MaxBearingResults:
                 )
         else:
             cmap = axes.scatter(
-                self.to_pandas()["test_id"],
-                self.to_pandas()["pile_tip_level_nap"],
+                df["test_id"],
+                df["pile_tip_level_nap"],
                 c=colors,
             )
             axes.set_ylabel("Z [m w.r.t NAP]")
             axes.tick_params(axis="x", labelrotation=90)
+            axes.grid()
 
         if hue == "category":
             fig.legend(
@@ -475,3 +531,149 @@ class MaxBearingResults:
             fig.colorbar(cmap, orientation="vertical", label="$R_{c;d;net}$ [kN]")
 
         return fig
+
+    def map(
+        self,
+        pile_tip_level_nap: float,
+        pile_load_uls: float = 100,
+        show_delaunay_vertices: bool = True,
+        show_voronoi_vertices: bool = False,
+        figsize: Tuple[int, int] | None = None,
+        **kwargs: Any,
+    ) -> plt.Figure:
+        """
+        Plot a map of the valid ULS load for a given depth.
+
+        Note
+        ------
+        Based on the Delaunay methode a tessellation is created with
+        the location of the CPT's. Each triangle is then colored according to
+        the bearing capacity of the CPT its based on. If any of the CPT does
+        not meet the required capacity the triangle becomes also invalid.
+
+        Warnings
+        --------
+        Please note that this map indication of valid ULS zones is intended as a visual aid to help
+        the geotechnical engineer. It does not necessarily comply with the NEN 9997-1+C2:2017 since the NEN is open
+        to interpretation. It is therefore that the interpretation provided by this methode must be carefully
+        validated by a geotechnical engineer.
+
+        Parameters
+        ----------
+        pile_tip_level_nap:
+            Pile tip level to generate map.
+        pile_load_uls
+            default is 100 kN
+            ULS load in kN. Used to determine if a pile tip level configuration is valid.
+        show_delaunay_vertices
+            default is True
+            Add delaunay vertices to the figure
+        show_voronoi_vertices
+            default is False
+            Add voronoi vertices to the figure
+        figsize:
+            Size of the activate figure, as the `plt.figure()` argument.
+        **kwargs:
+            All additional keyword arguments are passed to the `pyplot.subplots()` call.
+
+        Returns
+        -------
+        figure:
+            The `Figure` object where the data was plotted on.
+        """
+        kwargs_subplot = {
+            "figsize": figsize,
+            "tight_layout": True,
+        }
+
+        kwargs_subplot.update(kwargs)
+        fig, axes = plt.subplots(**kwargs_subplot)
+
+        # filter data
+        df = (
+            self.to_pandas()
+            .loc[self.to_pandas()["pile_tip_level_nap"] == pile_tip_level_nap]
+            .dropna()
+        )
+
+        if df.empty:
+            raise ValueError(
+                "Pile tip level is not valid pile tip level. "
+                "Please select one of the following pile tip level: "
+                f"[{(self.to_pandas()['pile_tip_level_nap']).unique()}]"
+            )
+
+        df["valid"] = [
+            False if var < pile_load_uls else True for var in df["R_c_d_net"]
+        ]
+
+        # iterate over geometry
+        if show_delaunay_vertices:
+            _patches = []
+            for tri in self.triangulation(pile_tip_level_nap):
+                color = (
+                    "green"
+                    if all(
+                        df.where(df["test_id"].isin(tri["test_id"])).dropna()["valid"]
+                    )
+                    else "red"
+                )
+                _patches.append(
+                    patches.Polygon(
+                        np.array(tri["geometry"]), facecolor=color, edgecolor="grey"
+                    )
+                )
+
+            collection = PatchCollection(_patches, match_original=True)
+            axes.add_collection(collection)
+
+        if show_voronoi_vertices:
+            points = [
+                (point.soil_properties.x, point.soil_properties.y)
+                for point in self.cpt_results_dict.values()
+            ]
+            vor = Voronoi(points)
+            voronoi_plot_2d(
+                vor,
+                show_vertices=False,
+                show_points=False,
+                ax=axes,
+                line_colors="black",
+                line_alpha=0.7,
+                line_width=0.1,
+                point_size=0.0,
+            )
+
+        # add the cpt names
+        axes.scatter(
+            df["x"],
+            df["y"],
+            c=["green" if val else "red" for val in df["valid"]],
+        )
+        for label, x, y in zip(df["test_id"], df["x"], df["y"]):
+            axes.annotate(label, xy=(x, y), xytext=(3, 3), textcoords="offset points")
+        axes.set_xlabel("X")
+        axes.set_ylabel("Y")
+        axes.ticklabel_format(useOffset=False)
+        fig.legend(
+            title="$R_{c;d;net}$ [kN]",
+            title_fontsize=18,
+            fontsize=15,
+            loc="lower right",
+            handles=[
+                patches.Patch(
+                    facecolor=color,
+                    label=label,
+                    alpha=0.9,
+                    linewidth=2,
+                    edgecolor="black",
+                )
+                for label, color in zip(
+                    [f">= {pile_load_uls}", f"< {pile_load_uls}"],
+                    ["green", "red"],
+                )
+            ],
+        )
+        axes.set_title(f"Pile tip level at: {pile_tip_level_nap} [m w.r.t NAP]")
+
+        return fig

{py-pilecore-0.4.0 → py_pilecore-0.4.2}/tests/test_input.py

@@ -738,3 +738,26 @@ def test_create_multi_cpt_payload_errors(
             installation="1",
             pile_shape="rect",
         )
+
+def test_soil_load_is_always_float(
+    cpt: CPTData, mock_classify_response: dict
+) -> None:
+    """
+    Check that a soil-load value `float(0)` is passed even when the soil_load_sls
+    argument is None.
+    """
+
+    payload, _ = create_multi_cpt_payload(
+        pile_tip_levels_nap=[0, 1],
+        cptdata_objects=[cpt],
+        classify_tables={cpt.alias: mock_classify_response},
+        groundwater_level_nap=-2.5,
+        pile_type="concrete",
+        specification="1",
+        installation="A",
+        pile_shape="round",
+        diameter_base=0.3,
+        soil_load_sls=None,
+    )
+
+    assert np.isclose(payload.pop("soil_load"), 0.0)