py-pilecore 0.8.3__py3-none-any.whl → 0.9.0__py3-none-any.whl

{py_pilecore-0.8.3.dist-info → py_pilecore-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: py-pilecore
-Version: 0.8.3
+Version: 0.9.0
 Summary: Public python SDK for the CEMS PileCore web-API.
 License: MIT License
         
@@ -41,6 +41,7 @@ Requires-Dist: scipy<2,>=1.13
 Requires-Dist: ipywidgets<9,>=8
 Requires-Dist: dash<3,>=2.17
 Requires-Dist: plotly-geo<2,>=1.0.0
+Requires-Dist: plotly<6,>=5
 Provides-Extra: test
 Requires-Dist: coveralls; extra == "test"
 Requires-Dist: pytest; extra == "test"

py_pilecore-0.9.0.dist-info/RECORD

@@ -0,0 +1,49 @@
+pypilecore/__init__.py,sha256=oJvwYShj_7FyNVlUgQda4tTdYyLIi5H1asdiS_uYt9M,162
+pypilecore/_version.py,sha256=uYUhbKiJfH5uxwBkA8VSVjnbTH1Hes0J6kWOvCSTafE,175
+pypilecore/api.py,sha256=20kaAU-rwMzOz_N-nrKIme_vfWRLNEV1lYkcnnwqof4,9857
+pypilecore/exceptions.py,sha256=-MZOfsxyHLCI0k1-wZFfVsMxc1lya5buuhLks5rxlCo,89
+pypilecore/plot_utils.py,sha256=rK5_067-4-x7LzZgt_t6ahcGrZInxNrqHqsy0RzCnq8,954
+pypilecore/utils.py,sha256=ib9LgJBIgWukL7zd_Zk1LP27UTMIZTRJ4RBB6ubn97o,1186
+pypilecore/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypilecore/common/piles/__init__.py,sha256=wyAI8cxs_FvCOR7R7vsAhN-o9vfI9vx6M68ufVPpLvc,177
+pypilecore/common/piles/grid.py,sha256=u38mMbPo-Tg8AA5_vfniU_rNvPkUaNCLs7cKRTFBDlQ,7258
+pypilecore/common/piles/main.py,sha256=JUiTPXO7Pe-UddeTohape0SfJKwIQ-y68VwpEddehnA,11215
+pypilecore/common/piles/type.py,sha256=eWpjWr6i7ZqEFifyUTbvKMols8wcy-CMQ9FJbHD7080,8180
+pypilecore/common/piles/geometry/__init__.py,sha256=dFCVazEXnPCt5cQeHkSi5wp-yHRB9gKvtlQ3V5kBuOQ,438
+pypilecore/common/piles/geometry/main.py,sha256=ant3y1ZTGRN2off5-dwz2024Xa7pC0K7auBbmjTy9p8,11231
+pypilecore/common/piles/geometry/materials.py,sha256=ffyq71HHYg-sXKFAa3AANhLkf2fAApsTmyStlOTm9DI,5813
+pypilecore/common/piles/geometry/components/__init__.py,sha256=KugR37RWegxasqrf93h_PencnKzR4_Mi8s0GhEGzctM,326
+pypilecore/common/piles/geometry/components/common.py,sha256=scYoF-4aE0Wknx9GgSO-qhaIJHfwV6vdIOdtfwExW4U,15127
+pypilecore/common/piles/geometry/components/rectangle.py,sha256=591KyIejyjNAMnKg8yThFjbrPXAVHQdf08vaiQYHZdk,18411
+pypilecore/common/piles/geometry/components/round.py,sha256=MX2_qGmxr1dTtodblFfkNGkoDYqd6xgXHJ57xFuz_Z0,14735
+pypilecore/input/__init__.py,sha256=Gyqsp6zqc8AYnIp17SfqbBNjDaUkRgAam8x2r0XibwM,492
+pypilecore/input/grouper_properties.py,sha256=HPGc9n7o1cDe6YtIuMHuSxmNl0yNsYzvlwIctvXvdnM,11168
+pypilecore/input/multi_cpt.py,sha256=b5poixEs5ex8WGcu3rJiFMdS5Q4DE807L6jmeqiFE64,17506
+pypilecore/input/soil_properties.py,sha256=WympKatXyGKr6IL4RhW-sUKOKov2wV_0Wq9YkdBAQgs,9968
+pypilecore/input/tension.py,sha256=W9YbuNZJz8xp-9-RVl3ejxOqGfZ9UF8uTwxMeeLuAyE,11135
+pypilecore/results/__init__.py,sha256=UCMRRVNZxHTtTD4yTrJ-vpHy-Pga8vvxRu45d8pu5DM,844
+pypilecore/results/cases_multi_cpt_results.py,sha256=meCqFDBCGiSwgmwSzvTLxF5Z0HYkKK-LKrvDp5rAUy8,10253
+pypilecore/results/grouper_result.py,sha256=35Yx8VsIT1hridIZLhgcrqBtxszWvaUljBDroFhzCdg,31006
+pypilecore/results/load_settlement.py,sha256=EbfTrSvH_g96KE-x8ZjmO8D0mt5KFaQ_-AR8u4blLsU,9752
+pypilecore/results/post_processing.py,sha256=UWXcdff5dhPFDwzKbVIayEIp3HX6pxW8oQR3Z7AHPn0,22262
+pypilecore/results/result_definitions.py,sha256=Y6lXp_Idm4nrtN-39CDtQGZnaYsgU2uIZCO9MMQR35g,8558
+pypilecore/results/soil_properties.py,sha256=KaQe-2dTDXhjNnYA7nB7jOqqcbxyw3av4JhJdv3qQPE,23578
+pypilecore/results/typing.py,sha256=74oHMuadWnlbvE_1OaZEuphIehnuuCgDMXIcc6ZX-Dc,1085
+pypilecore/results/compression/multi_cpt_results.py,sha256=8fzhttWhT8c5BU0t7WFngsmExcyjD8rQZfRBmwS-Qqw,31232
+pypilecore/results/compression/single_cpt_results.py,sha256=j_Q35Qf_ZB7_8uctN_A75t-d0rrdWcg-1pbTkiRIlVE,17536
+pypilecore/results/tension/multi_cpt_results.py,sha256=elbn7gwRHBAyHt5ULNaQpOlRQCbr1KC7RD8uO5s-hzw,14526
+pypilecore/results/tension/single_cpt_results.py,sha256=PKfonF7mNMAmWSqnSFLRhLuv8fLfPbMZ1VES8U-TV7g,13402
+pypilecore/viewers/__init__.py,sha256=GjPAj7O_L5QsK2fhewi7yd5fZnbYeCvauDAD37I20Rg,330
+pypilecore/viewers/viewer_cpt_group_results.py,sha256=uPm0xltU7yQhOgeS2tqTSFrmU0cVtQbl3L9kmHMyO5M,2563
+pypilecore/viewers/viewer_cpt_results.py,sha256=EWY8S_Xuabz8EGz4JWTD2RJ0dzz5zCmkRqtFt8VskZw,2999
+pypilecore/viewers/viewer_cpt_results_plan_view.py,sha256=BI8VSg55E6QATJsNKskEzmLFRtGSY3Kr_yWaC1QxRME,3689
+pypilecore/viewers/interactive_figures/__init__.py,sha256=u6fkLqDB35J2bdGvUewzRC8UEQUFF6AoXxR-_v8AX0A,481
+pypilecore/viewers/interactive_figures/figure_cpt_group_results_versus_ptls.py,sha256=RzNOYQmP_yT8oYeIMW9aYNl7aAKU-uFQfygxP9AwDsU,6471
+pypilecore/viewers/interactive_figures/figure_cpt_results_plan_view.py,sha256=cTR-huJn_RigWH_xdN19mi8kwngbKhDhUevgsDKcvjs,9287
+pypilecore/viewers/interactive_figures/figure_cpt_results_versus_ptls.py,sha256=6huCKcQ4bsBE-LNY-ZPa13IWuye0ENxPK4wT1dcCFRs,5964
+pypilecore/viewers/interactive_figures/utils.py,sha256=B2X8hbbmJqjm8E2VrS2EoX5F1yQ5qOQnQUG_vbsseT8,1692
+py_pilecore-0.9.0.dist-info/LICENSE,sha256=3OCAZXffN0Bettjeya8uF_ZYegyvvCfH1WUt6CrHb_0,1061
+py_pilecore-0.9.0.dist-info/METADATA,sha256=xkXCyFKicB8hqrhApsveG1hMnOg9EEI5th0srHytIoo,5859
+py_pilecore-0.9.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+py_pilecore-0.9.0.dist-info/top_level.txt,sha256=7BKIWZuSkbQtJ0ho5P1JvcaEbHzqADCcBuOduZmIaiI,11
+py_pilecore-0.9.0.dist-info/RECORD,,

pypilecore/_version.py

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

pypilecore/api.py

@@ -1,5 +1,6 @@
 import logging
 from time import sleep
+from typing import Literal
 
 from nuclei.client import NucleiClient
 from requests import Response
@@ -235,3 +236,91 @@ def get_groups_api_report(
     return client.call_endpoint(
         "PileCore", "/get-task-result", version="v3", schema=ticket.json()
     )
+
+
+def get_multi_cpt_api_result_tension(
+    client: NucleiClient,
+    payload: dict,
+    verbose: bool = False,
+    standard: Literal["NEN9997-1", "CUR236"] = "NEN9997-1",
+) -> dict:
+    """
+    Wrapper around the PileCore endpoint "/tension/[nen or cur]/multiple-cpts/results".
+
+    Parameters
+    ----------
+    client: NucleiClient
+        client object created by [nuclei](https://github.com/cemsbv/nuclei)
+    payload: dict
+        the payload of the request, can be created by calling `create_grouper_payload()`
+    verbose: bool
+        if True, print additional information to the console
+    standard: str
+        Norm used to calculate bearing capacities
+    """
+    logging.info(
+        "Calculating bearing capacities... \n"
+        "Depending on the amount of pile tip levels and CPT's this can take a while."
+    )
+    if standard == "NEN9997-1":
+        endpoint = "/tension/nen/multiple-cpt/results"
+    else:
+        endpoint = "/tension/cur/multiple-cpt/results"
+
+    ticket = client.call_endpoint(
+        "PileCore",
+        endpoint=endpoint,
+        version="v3",
+        schema=payload,
+        return_response=True,
+    )
+
+    wait_until_ticket_is_ready(client=client, ticket=ticket, verbose=verbose)
+
+    return client.call_endpoint(
+        "PileCore", "/get-task-result", version="v3", schema=ticket.json()
+    )
+
+
+def get_multi_cpt_api_report_tension(
+    client: NucleiClient,
+    payload: dict,
+    verbose: bool = False,
+    standard: Literal["NEN9997-1", "CUR236"] = "NEN9997-1",
+) -> bytes:
+    """
+    Wrapper around the PileCore endpoint "/tension/[nen or cur]/multiple-cpts/report".
+
+    Parameters
+    ----------
+    client: NucleiClient
+        client object created by [nuclei](https://github.com/cemsbv/nuclei)
+    payload: dict
+        the payload of the request, can be created by calling `create_grouper_payload()`
+    verbose: bool
+        if True, print additional information to the console
+    standard: str
+        Norm used to calculate bearing capacities
+    """
+    logging.info(
+        "Generate report... \n"
+        "Depending on the amount of pile tip levels and CPT's this can take a while."
+    )
+
+    if standard == "NEN9997-1":
+        endpoint = "/tension/nen/multiple-cpt/report"
+    else:
+        endpoint = "/tension/cur/multiple-cpt/report"
+
+    ticket = client.call_endpoint(
+        "PileCore",
+        endpoint=endpoint,
+        version="v3",
+        schema=payload,
+        return_response=True,
+    )
+    wait_until_ticket_is_ready(client=client, ticket=ticket, verbose=verbose)
+
+    return client.call_endpoint(
+        "PileCore", "/get-task-result", version="v3", schema=ticket.json()
+    )

pypilecore/common/piles/__init__.py

@@ -1,6 +1,8 @@
+from .grid import PileGridProperties
 from .main import PileProperties, create_basic_pile
 
 __all__ = [
     "PileProperties",
+    "PileGridProperties",
     "create_basic_pile",
 ]

pypilecore/common/piles/geometry/materials.py

@@ -10,12 +10,14 @@ MATERIALS = {
         "name": "grout",
         "elastic_modulus": 15000,
         "yield_stress": 1.5,
+        "tensile_strength": 1500,
         "color": "#8A8A8A",
     },
     "grout_extorted": {
         "name": "grout_extorted",
         "elastic_modulus": 20000,
         "yield_stress": 2,
+        "tensile_strength": 2000,
         "color": "#8A8A8A",
     },
 }
@@ -82,6 +84,7 @@ class PileMaterial:
         name: str,
         elastic_modulus: float,
         yield_stress: float | None = None,
+        tensile_strength: float | None = None,
         color: Color | str | Dict[str, int] | None = None,
     ):
         """
@@ -95,12 +98,15 @@ class PileMaterial:
             The elastic modulus [MPa] of the material.
         yield_stress : float, optional
             The yield stress [MPa] of the material, by default None.
+        tensile_strength : float, optional
+            The tensile strengths [MPa] of the material, by default None.
         color : Color or str or dict, optional
             The color of the material, by default None.
         """
         self._name = name
         self._elastic_modulus = elastic_modulus
         self._yield_stress = yield_stress
+        self._tensile_strength = tensile_strength
         if isinstance(color, str):
             color = Color.from_hex(hex=color)
         elif isinstance(color, dict):
@@ -132,6 +138,7 @@ class PileMaterial:
             name=material["name"],
             elastic_modulus=material["elastic_modulus"],
             yield_stress=material.get("yield_stress"),
+            tensile_strength=material.get("tensile_strength"),
             color=color,
         )
 
@@ -150,6 +157,11 @@ class PileMaterial:
         """The yield stress [MPa] of the material"""
         return self._yield_stress
 
+    @property
+    def tensile_strength(self) -> float | None:
+        """The tensile strength [MPa] of the material"""
+        return self._tensile_strength
+
     @property
     def color(self) -> Color | Color | None:
         """The color of the material"""
@@ -170,4 +182,7 @@ class PileMaterial:
         if self.color is not None:
             payload["color"] = self.color.serialize_payload()
 
+        if self.tensile_strength is not None:
+            payload["tensile_strength"] = self.tensile_strength
+
         return payload

pypilecore/common/piles/grid.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+from typing import Any, List, Tuple
+
+import matplotlib.patches as patches
+import matplotlib.ticker as ticker
+import numpy as np
+from matplotlib import pyplot as plt
+from matplotlib.axes import Axes
+from matplotlib.lines import Line2D
+from shapely.geometry import MultiPolygon, shape
+from shapely.plotting import plot_polygon
+
+
+class PileGridProperties:
+    def __init__(
+        self,
+        points: List[Tuple[float, float]],
+        index_location: int,
+        geometry: MultiPolygon | None = None,
+        _validate: bool = True,
+    ):
+        """
+        Class that holds the information of the pile placement.
+        The structure of the grid effects the effective area of the
+        pile.
+
+        Parameters
+        ----------
+        points: List of tuple
+            List of tuple with xy coordinates.
+        index_location: int
+            selected index of the points list as pile location
+        geometry: MultiPolygon, optional
+            A;eff as polygon
+        _validate: bool, optional
+            flag that overrules validation of the parameters
+
+        """
+        if len(points) < 2 and _validate:
+            raise ValueError("Provide at least two points to the pile grid.")
+
+        if len(points) != len(set(points)):
+            raise ValueError("All points of the pile grid must be unique.")
+        if len(points) - 1 < index_location > 0:
+            raise IndexError(
+                f"Index out of range, must be between 0 and {len(points) - 1} got {index_location}."
+            )
+
+        self._points = points
+        self._index_location = index_location
+        self._geometry = geometry
+
+    @classmethod
+    def regular(cls, ctc: float, index_location: int) -> "PileGridProperties":
+        """
+        Create a regular grid with a centre to centre distance provided by the user.
+        The regular grid contains 9 points. Numbering start in the lower left corner.
+        So for the
+            - center pile `index_location= 4`
+            - middle pile `index_location= 1 or 3 or 4 or 5 or 7`
+            - corner pile `index_location= 0 or 2 or 6 or 8`
+
+        x --- x --- x
+        |     |     |
+        x --- x --- x
+        |     |     |
+        x --- x --- x   with --- == | == ctc
+
+        Parameters
+        ----------
+        ctc: float
+            Centre to centre distance of regular grid [m]
+        index_location: int
+            Location of the pile to calculate
+        Returns
+        -------
+        PileGrid
+        """
+        xx, yy = np.meshgrid(np.arange(0, 3) * ctc, np.arange(0, 3) * ctc)
+
+        return cls(
+            points=list(zip(xx.flatten(), yy.flatten())), index_location=index_location
+        )
+
+    @classmethod
+    def from_api_response(cls, payload: dict) -> PileGridProperties:
+        """
+        Instantiates a PileGeometry from a geometry object in the API response payload.
+
+        Parameters:
+        -----------
+        geometry: dict
+            A dictionary that is retrieved from the API response payload at "/pile_properties/geometry".
+
+        Returns:
+        --------
+        PileGeometry
+            A pile geometry.
+        """
+        # make list type hashable
+        points = [(point[0], point[1]) for point in payload["points"]]
+        return cls(
+            points=points,
+            index_location=payload["index_location"],
+            geometry=shape(payload["geometry"]),
+            _validate=False,
+        )
+
+    def serialize_payload(self) -> dict:
+        return {
+            "locations": self._points,
+            "pile_index": self._index_location,
+        }
+
+    def plot_overview(
+        self,
+        figsize: Tuple[float, float] = (6.0, 6.0),
+        axes: Axes | None = None,
+        add_ticks: bool = False,
+        add_legend: bool = True,
+        **kwargs: Any,
+    ) -> Axes:
+        """
+        Plot the Bird's-eye view of the pile grid. When provided the effect area of
+        the pile influence zone is add to the figure.
+
+        Parameters
+        ----------
+        figsize : tuple, optional
+            The figure size (width, height) in inches, by default (6.0, 6.0).
+        axes : Axes
+            The axes object to plot the cross-section on.
+        add_ticks : bool
+            Add ticks to figure, by default False
+        add_legend : bool
+            Add legend to figure, by default True
+        **kwargs
+            Additional keyword arguments to pass to the `plt
+        """
+
+        # Create axes objects if not provided
+        if axes is not None:
+            if not isinstance(axes, Axes):
+                raise ValueError(
+                    "'axes' argument to plot_overview() 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. "
+                )
+        handles = [
+            Line2D(
+                [0],
+                [0],
+                label="Selected pile",
+                marker=".",
+                color="None",
+                markerfacecolor="tab:orange",
+                markeredgecolor="None",
+                ls="",
+            ),
+        ]
+
+        if len(self._points) >= 2:
+            handles.append(
+                Line2D(
+                    [0],
+                    [0],
+                    color="None",
+                    label="Other piles",
+                    marker=".",
+                    markerfacecolor="gray",
+                    markeredgecolor="None",
+                    ls="",
+                )
+            )
+        # add the effective area of the pile with the pile grid
+        if self._geometry is not None:
+            plot_polygon(self._geometry, ax=axes, add_points=False, color="tab:blue")
+            handles.append(
+                patches.Patch(
+                    facecolor="tab:blue",
+                    alpha=0.3,
+                    label=r"$A_{eff}$" + rf" {self._geometry.area:.1f} $m^2$",
+                    edgecolor="tab:blue",
+                )
+            )
+
+        # plot points
+        colors = ["gray"] * len(self._points)
+        colors[self._index_location] = "tab:orange"
+        axes.scatter(*zip(*self._points), color=colors, marker=".")
+
+        # add labels to points
+        for x, y, label in zip(*zip(*self._points), range(len(self._points))):
+            axes.annotate(label, xy=(x, y), xytext=(3, 3), textcoords="offset points")
+
+        axes.ticklabel_format(useOffset=False, style="plain")
+        axes.set_aspect("equal", adjustable="box")
+        if add_ticks:
+            axes.xaxis.set_major_locator(ticker.NullLocator())
+            axes.yaxis.set_major_locator(ticker.NullLocator())
+
+        if add_legend:
+            axes.legend(
+                title="Pile grid configuration",
+                bbox_to_anchor=(1.04, 1),
+                loc="upper left",
+                handles=handles,
+            )
+        return axes

pypilecore/common/piles/main.py

@@ -111,10 +111,13 @@ def create_basic_pile(
     alpha_s_clay: float | None = None,
     alpha_s_sand: float | None = None,
     beta_p: float | None = None,
+    alpha_t_clay: float | None = None,
+    alpha_t_sand: float | None = None,
     pile_tip_factor_s: float | None = None,
     is_auger: bool | None = None,
     is_low_vibrating: bool | None = None,
     negative_fr_delta_factor: float | None = None,
+    chamfered: float | None = None,
 ) -> PileProperties:
     """
     Create a basic pile with the provided parameters.
@@ -171,6 +174,12 @@ def create_basic_pile(
     alpha_s_sand : float, optional
         The alpha_s_sand of the pile, by default None.
         Required if no standard pile type was specified.
+    alpha_t_clay : float, optional
+        The alpha_t_clay of the pile, by default None.
+        Required if no standard pile type was specified.
+    alpha_t_sand : float, optional
+        The alpha_t_sand of the pile, by default None.
+        Required if no standard pile type was specified.
     beta_p : float, optional
         The beta_p of the pile, by default None.
         Required if no standard pile type was specified.
@@ -186,6 +195,9 @@ def create_basic_pile(
     negative_fr_delta_factor : float, optional
         The negative friction delta factor of the pile, by default None.
         Required if no standard pile type was specified.
+    chamfered : float, optional
+        The chamfered value of the pile type, by default None.
+        Required if no standard pile type was specified.
 
     Returns
     -------
@@ -281,12 +293,14 @@ def create_basic_pile(
         alpha_s_sand=alpha_s_sand,
         alpha_s_clay=alpha_s_clay,
         alpha_p=alpha_p,
-        alpha_t_sand=None,
+        alpha_t_sand=alpha_t_sand,
+        alpha_t_clay=alpha_t_clay,
         settlement_curve=settlement_curve,
         negative_fr_delta_factor=negative_fr_delta_factor,
         adhesion=adhesion,
         is_low_vibrating=is_low_vibrating,
         is_auger=is_auger,
+        chamfered=chamfered,
     )
 
     return PileProperties(geometry=geometry, pile_type=pile_type, name=pile_name)

pypilecore/common/piles/type.py

@@ -13,11 +13,13 @@ class PileType:
         alpha_s_clay: float | None = None,
         alpha_p: float | None = None,
         alpha_t_sand: float | None = None,
+        alpha_t_clay: float | None = None,
         settlement_curve: int | None = None,
         negative_fr_delta_factor: float | None = None,
         adhesion: float | None = None,
         is_low_vibrating: bool | None = None,
         is_auger: bool | None = None,
+        chamfered: float | None = None,
     ):
         """
         Represents the type of a pile.
@@ -34,6 +36,8 @@ class PileType:
             The alpha_p value of the pile type, by default None.
         alpha_t_sand : float, optional
             The alpha_t_sand value of the pile type, by default None.
+        alpha_t_clay : float, optional
+            The alpha_t_clay value of the pile type, by default None.
         settlement_curve : int, optional
             The settlement curve of the pile type, by default None.
         negative_fr_delta_factor : float, optional
@@ -44,17 +48,21 @@ class PileType:
             The is_low_vibrating value of the pile type, by default None.
         is_auger : bool, optional
             The is_auger value of the pile type, by default None.
+        chamfered : float, optional
+            The chamfered value of the pile type, by default None.
         """
         self._standard_pile = standard_pile
         self._alpha_s_sand = alpha_s_sand
         self._alpha_s_clay = alpha_s_clay
         self._alpha_p = alpha_p
         self._alpha_t_sand = alpha_t_sand
+        self._alpha_t_clay = alpha_t_clay
         self._settlement_curve = settlement_curve
         self._negative_fr_delta_factor = negative_fr_delta_factor
         self._adhesion = adhesion
         self._is_low_vibrating = is_low_vibrating
         self._is_auger = is_auger
+        self._chamfered = chamfered
 
     @classmethod
     def from_api_response(cls, pile_type: dict) -> PileType:
@@ -77,6 +85,7 @@ class PileType:
             alpha_s_clay=pile_type["properties"]["alpha_s_clay"],
             alpha_p=pile_type["properties"]["alpha_p"],
             alpha_t_sand=pile_type["properties"]["alpha_t_sand"],
+            alpha_t_clay=pile_type["properties"].get("alpha_t_clay", None),
             settlement_curve=pile_type["properties"]["settlement_curve"],
             negative_fr_delta_factor=pile_type["properties"][
                 "negative_fr_delta_factor"
@@ -111,6 +120,11 @@ class PileType:
         """The alpha_t_sand value of the pile type"""
         return self._alpha_t_sand
 
+    @property
+    def alpha_t_clay(self) -> float | None:
+        """The alpha_t_clay value of the pile type"""
+        return self._alpha_t_clay
+
     @property
     def settlement_curve(self) -> int | None:
         """The settlement curve of the pile type"""
@@ -136,6 +150,11 @@ class PileType:
         """The is_auger value of the pile type"""
         return self._is_auger
 
+    @property
+    def chamfered(self) -> float | None:
+        """The chamfered value of the pile type"""
+        return self._chamfered
+
     def serialize_payload(self) -> Dict[str, str | dict]:
         """
         Serialize the pile type to a dictionary payload for the API.
@@ -173,6 +192,9 @@ class PileType:
         if self.alpha_t_sand is not None:
             custom_type_properties["alpha_t_sand"] = self.alpha_t_sand
 
+        if self.alpha_t_clay is not None:
+            custom_type_properties["alpha_t_clay"] = self.alpha_t_clay
+
         if self.settlement_curve is not None:
             custom_type_properties["settlement_curve"] = self.settlement_curve
 
@@ -190,6 +212,9 @@ class PileType:
         if self.is_auger is not None:
             custom_type_properties["is_auger"] = self.is_auger
 
+        if self.chamfered is not None:
+            custom_type_properties["chamfered"] = self.chamfered
+
         if len(custom_type_properties.keys()) > 0:
             payload["custom_properties"] = custom_type_properties
 

pypilecore/input/grouper_properties.py

@@ -7,7 +7,7 @@ from typing import Any, Dict, List, Literal
 import numpy as np
 from shapely.geometry import Polygon, mapping
 
-from pypilecore.results import SingleCPTBearingResults
+from pypilecore.results import SingleCPTCompressionBearingResults
 
 _dft_optimize_result_by = [
     "minimum_pile_level",
@@ -17,7 +17,7 @@ _dft_optimize_result_by = [
 
 
 def create_grouper_payload(
-    cpt_results_dict: Dict[str, SingleCPTBearingResults],
+    cpt_results_dict: Dict[str, SingleCPTCompressionBearingResults],
     pile_load_uls: float,
     building_polygon: Polygon | None = None,
     cpt_grid_rotation: float = 0.0,

pypilecore/input/soil_properties.py

@@ -52,6 +52,8 @@ def create_soil_properties_payload(
     ]
     | None = None,
     individual_ocr: Mapping[Any, float] | None = None,
+    master_top_of_tension_zone_nap: float | None = None,
+    individual_top_of_tension_zone_nap: Mapping[Any, float] | None = None,
     verbose: bool = False,
 ) -> Tuple[List[dict], Dict[str, dict]]:
     """
@@ -112,6 +114,10 @@ def create_soil_properties_payload(
         A dictionary, mapping ``CPTData.alias`` values to Over-Consolidation-Ratio [-]
         values of the foundation layer. This will overrule the general `ocr` setting for
         these specific CPTs only.
+    master_top_of_tension_zone_nap:
+        Set a fixed top of the tension zone for all CPT's
+    individual_top_of_tension_zone_nap:
+        A dictionary, mapping `CPTData.alias` values to fixed top of the tension zone.
     verbose:
         If True, show progress bars and status messages in stdout.
 
@@ -211,6 +217,19 @@ def create_soil_properties_payload(
             ] = individual_positive_friction_range_nap[cpt.alias]
             soil_properties["friction_range_strategy"] = "manual"
 
+        # Optionally add top_of_tension_zone_nap parameter
+        if (
+            individual_top_of_tension_zone_nap is not None
+            and cpt.alias in individual_top_of_tension_zone_nap.keys()
+        ):
+            top_of_tension_zone_nap: float | None = individual_top_of_tension_zone_nap[
+                cpt.alias
+            ]
+        else:
+            top_of_tension_zone_nap = master_top_of_tension_zone_nap
+        if top_of_tension_zone_nap is not None:
+            soil_properties["top_of_tension_zone_nap"] = top_of_tension_zone_nap
+
         # Optionally add OCR parameter
         if individual_ocr is not None and cpt.alias in individual_ocr.keys():
             ocr: float | None = individual_ocr[cpt.alias]