py-pilecore 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

pypilecore/common/piles/main.py

@@ -0,0 +1,290 @@
+from __future__ import annotations
+
+from typing import Dict, List
+
+from pypilecore.common.piles.geometry import PileGeometry
+from pypilecore.common.piles.geometry.components import (
+    PrimaryPileComponentDimension,
+    RectPileGeometryComponent,
+    RoundPileGeometryComponent,
+)
+from pypilecore.common.piles.geometry.materials import MATERIALS, PileMaterial
+from pypilecore.common.piles.type import PileType
+
+
+class PileProperties:
+    """The PileProperties class represents all properties of a pile."""
+
+    def __init__(
+        self, geometry: PileGeometry, pile_type: PileType, name: str | None = None
+    ):
+        """
+        Represents all properties of a pile.
+
+        Parameters:
+        -----------
+        geometry: PileGeometry
+            The geometry of the pile.
+        pile_type: PileType
+            The type of the pile.
+        name: str, optional
+            The name of the pile, by default None.
+        """
+        self._geometry = geometry
+        self._pile_type = pile_type
+        self._name = name
+
+    @classmethod
+    def from_api_response(cls, pile_properties: dict) -> PileProperties:
+        """
+        Instantiates a PileProperties from a response dictionary.
+
+        Parameters:
+        -----------
+        pile_properties: dict
+            A dictionary that is retrieved from the API response payload at "/pile_properties".
+
+        Returns:
+        --------
+        PileProperties
+            A pile properties object.
+        """
+        return cls(
+            geometry=PileGeometry.from_api_response(pile_properties["geometry"]),
+            pile_type=PileType.from_api_response(pile_properties["pile_type"]),
+            name=pile_properties.get("name"),
+        )
+
+    @property
+    def geometry(self) -> PileGeometry:
+        """The geometry of the pile."""
+        return self._geometry
+
+    @property
+    def pile_type(self) -> PileType:
+        """The type of the pile."""
+        return self._pile_type
+
+    @property
+    def name(self) -> str | None:
+        """The name of the pile."""
+        return self._name
+
+    def serialize_payload(self) -> Dict[str, dict | str]:
+        """
+        Serialize the pile properties to a dictionary payload for the API.
+
+        Returns:
+            A dictionary payload containing the geometry, pile type, and name (if set).
+        """
+        payload: Dict[str, dict | str] = {
+            "geometry": self.geometry.serialize_payload(),
+            "pile_type": self.pile_type.serialize_payload(),
+        }
+
+        if self.name is not None:
+            payload["name"] = self.name
+
+        return payload
+
+
+def create_basic_pile(
+    pile_shape: str,
+    pile_name: str | None = None,
+    main_type: str | None = None,
+    specification: str | int | float | None = None,
+    installation: str | None = None,
+    height_base: float | None = None,
+    core_secondary_dimension: float | None = None,
+    core_tertiary_dimension: float | None = None,
+    base_secondary_dimension: float | None = None,
+    base_tertiary_dimension: float | None = None,
+    core_diameter: float | None = None,
+    base_diameter: float | None = None,
+    pile_material: str | None = None,
+    custom_material: dict | None = None,
+    settlement_curve: int | None = None,
+    adhesion: float | None = None,
+    alpha_p: float | None = None,
+    alpha_s_clay: float | None = None,
+    alpha_s_sand: float | None = None,
+    beta_p: 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,
+) -> PileProperties:
+    """
+    Create a basic pile with the provided parameters.
+    A "basic" pile is a pile with a basic geometry, containing at most 2 components,
+    namely a core component and an optional shell/widened-base component.
+
+    Parameters
+    ----------
+    pile_shape : str
+        The shape of the pile. Either "round" or "rect".
+    pile_name : str, optional
+        The name of the pile, by default None.
+    main_type : str, optional
+        The main type of the standard pile type definition, by default None.
+    specification : str | int | float, optional
+        The specification of the standard pile type definition, by default None.
+        Required if `main_type` is provided.
+    installation : str, optional
+        The installation of the standard pile type definition, by default None.
+    height_base : float, optional
+        The height [m] of the base component, by default None.
+        Required if base dimensions are provided.
+    core_secondary_dimension : float, optional
+        The largest dimension [m] of the core component's cross-section, by default None.
+        Required for rectangular piles.
+    core_tertiary_dimension : float, optional
+        The smallest dimension [m] of the core component's cross-section, by default None.
+    base_secondary_dimension : float, optional
+        The largest dimension [m] of the base/shell component's cross-section, by default None.
+    base_tertiary_dimension : float, optional
+        The smallest dimension [m] of the base/shell component's cross-section, by default None.
+    core_diameter : float, optional
+        The diameter [m] of the core component's cross-section, by default None.
+        Required for round piles.
+    base_diameter : float, optional
+        The diameter [m] of the base/shell component's cross-section, by default None.
+    pile_material : str, optional
+        The material of the pile, by default None.
+        Required if no standard pile type was specified.
+    custom_material : dict, optional
+        A custom material for the pile, by default None.
+    settlement_curve : int, optional
+        The settlement curve of the pile, by default None.
+        Required if no standard pile type was specified.
+    adhesion : float, optional
+        The adhesion of the pile, by default None.
+        Required if no standard pile type was specified.
+    alpha_p : float, optional
+        The alpha_p of the pile, by default None.
+        Required if no standard pile type was specified.
+    alpha_s_clay : float, optional
+        The alpha_s_clay of the pile, by default None.
+        Required if no standard pile type was specified.
+    alpha_s_sand : float, optional
+        The alpha_s_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.
+    pile_tip_factor_s : float, optional
+        The pile tip factor s of the pile, by default None.
+        Required if no standard pile type was specified.
+    is_auger : bool, optional
+        Whether the pile is an auger pile, by default None.
+        Required if no standard pile type was specified.
+    is_low_vibrating : bool, optional
+        Whether the pile is low vibrating, by default None.
+        Required if no standard pile type was specified.
+    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.
+
+    Returns
+    -------
+    PileProperties
+        The pile properties object.
+    """
+    materials = [
+        PileMaterial(**material_value) for material_value in MATERIALS.values()  # type: ignore
+    ]
+
+    if custom_material is not None:
+        materials = [PileMaterial(**custom_material)]
+
+    if pile_shape == "round":
+        if core_diameter is None:
+            raise ValueError("`core_diameter` must be provided for a round pile.")
+
+        components: List[RoundPileGeometryComponent | RectPileGeometryComponent] = [
+            RoundPileGeometryComponent(
+                diameter=core_diameter,
+                primary_dimension=PrimaryPileComponentDimension(
+                    length=None,
+                ),
+                material=pile_material,
+            )
+        ]
+
+        if base_diameter is not None:
+            components.append(
+                RoundPileGeometryComponent(
+                    diameter=base_diameter,
+                    primary_dimension=PrimaryPileComponentDimension(
+                        length=height_base,
+                    ),
+                    material=pile_material,
+                )
+            )
+
+    elif pile_shape in ["rect", "rectangle"]:
+        if core_secondary_dimension is None:
+            raise ValueError(
+                "`core_secondary_dimension` must be provided for a rectangular pile."
+            )
+
+        components = [
+            RectPileGeometryComponent(
+                primary_dimension=PrimaryPileComponentDimension(length=None),
+                secondary_dimension=core_secondary_dimension,
+                tertiary_dimension=core_tertiary_dimension,
+                material=pile_material,
+            )
+        ]
+
+        if base_secondary_dimension is not None:
+            components.append(
+                RectPileGeometryComponent(
+                    secondary_dimension=base_secondary_dimension,
+                    tertiary_dimension=base_tertiary_dimension,
+                    primary_dimension=PrimaryPileComponentDimension(
+                        length=height_base,
+                    ),
+                    material=pile_material,
+                )
+            )
+
+    else:
+        raise ValueError(f"Invalid pile shape: {pile_shape}")
+
+    geometry = PileGeometry(
+        components=components,
+        materials=materials,
+        pile_tip_factor_s=pile_tip_factor_s,
+        beta_p=beta_p,
+    )
+
+    if main_type is not None:
+        if specification is None:
+            raise ValueError("Specification must be provided if main type is provided.")
+
+        standard_pile: Dict[str, str | int] | None = {
+            "main_type": main_type,
+            "specification": int(specification),
+        }
+
+        if installation is not None:
+            standard_pile["installation"] = installation  # type: ignore
+
+    else:
+        standard_pile = None
+
+    pile_type = PileType(
+        standard_pile=standard_pile,
+        alpha_s_sand=alpha_s_sand,
+        alpha_s_clay=alpha_s_clay,
+        alpha_p=alpha_p,
+        alpha_t_sand=None,
+        settlement_curve=settlement_curve,
+        negative_fr_delta_factor=negative_fr_delta_factor,
+        adhesion=adhesion,
+        is_low_vibrating=is_low_vibrating,
+        is_auger=is_auger,
+    )
+
+    return PileProperties(geometry=geometry, pile_type=pile_type, name=pile_name)

pypilecore/common/piles/type.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+from typing import Dict
+
+
+class PileType:
+    """The PileType class represents the type of a pile."""
+
+    def __init__(
+        self,
+        standard_pile: Dict[str, str | int] | None = None,
+        alpha_s_sand: float | None = None,
+        alpha_s_clay: float | None = None,
+        alpha_p: float | None = None,
+        alpha_t_sand: 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,
+    ):
+        """
+        Represents the type of a pile.
+
+        Parameters:
+        -----------
+        standard_pile : dict, optional
+            The standard pile definition of the pile type (if applicable), by default None.
+        alpha_s_sand : float, optional
+            The alpha_s_sand value of the pile type, by default None.
+        alpha_s_clay : float, optional
+            The alpha_s_clay value of the pile type, by default None.
+        alpha_p : float, optional
+            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.
+        settlement_curve : int, optional
+            The settlement curve of the pile type, by default None.
+        negative_fr_delta_factor : float, optional
+            The negative_fr_delta_factor value of the pile type, by default None.
+        adhesion : float, optional
+            The adhesion value of the pile type, by default None.
+        is_low_vibrating : bool, optional
+            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.
+        """
+        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._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
+
+    @classmethod
+    def from_api_response(cls, pile_type: dict) -> PileType:
+        """
+        Instantiates a PileType from a pile type object in the API response payload.
+
+        Parameters:
+        -----------
+        pile_type: dict
+            A dictionary that is retrieved from the API response payload at "/pile_properties/pile_type".
+
+        Returns:
+        --------
+        PileType
+            A pile type.
+        """
+        return cls(
+            standard_pile=pile_type.get("standard_pile"),
+            alpha_s_sand=pile_type["properties"]["alpha_s_sand"],
+            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"],
+            settlement_curve=pile_type["properties"]["settlement_curve"],
+            negative_fr_delta_factor=pile_type["properties"][
+                "negative_fr_delta_factor"
+            ],
+            adhesion=pile_type["properties"]["adhesion"],
+            is_low_vibrating=pile_type["properties"]["is_low_vibrating"],
+            is_auger=pile_type["properties"]["is_auger"],
+        )
+
+    @property
+    def standard_pile(self) -> Dict[str, str | int] | None:
+        """The standard pile definition of the pile type (if applicable)"""
+        return self._standard_pile
+
+    @property
+    def alpha_s_sand(self) -> float | None:
+        """The alpha_s_sand value of the pile type"""
+        return self._alpha_s_sand
+
+    @property
+    def alpha_s_clay(self) -> float | None:
+        """The alpha_s_clay value of the pile type"""
+        return self._alpha_s_clay
+
+    @property
+    def alpha_p(self) -> float | None:
+        """The alpha_p value of the pile type"""
+        return self._alpha_p
+
+    @property
+    def alpha_t_sand(self) -> float | None:
+        """The alpha_t_sand value of the pile type"""
+        return self._alpha_t_sand
+
+    @property
+    def settlement_curve(self) -> int | None:
+        """The settlement curve of the pile type"""
+        return self._settlement_curve
+
+    @property
+    def negative_fr_delta_factor(self) -> float | None:
+        """The negative_fr_delta_factor value of the pile type"""
+        return self._negative_fr_delta_factor
+
+    @property
+    def adhesion(self) -> float | None:
+        """The adhesion value of the pile type"""
+        return self._adhesion
+
+    @property
+    def is_low_vibrating(self) -> bool | None:
+        """The is_low_vibrating value of the pile type"""
+        return self._is_low_vibrating
+
+    @property
+    def is_auger(self) -> bool | None:
+        """The is_auger value of the pile type"""
+        return self._is_auger
+
+    def serialize_payload(self) -> Dict[str, str | dict]:
+        """
+        Serialize the pile type to a dictionary payload for the API.
+
+        Returns:
+            A dictionary payload containing the standard pile (if set), alpha_s_sand, alpha_s_clay, alpha_p,
+            alpha_t_sand, settlement curve, negative_fr_delta_factor, adhesion, is_low_vibrating, and is_auger.
+        """
+        payload: Dict[str, str | dict] = {}
+
+        if self.standard_pile is not None:
+            payload["standard_pile"] = {
+                "main_type": str(self.standard_pile["main_type"]),
+                "specification": str(self.standard_pile["specification"]),
+            }
+            if (
+                "installation" in self.standard_pile
+                and self.standard_pile["installation"] is not None
+            ):
+                payload["standard_pile"]["installation"] = str(  # type: ignore
+                    self.standard_pile["installation"]
+                )
+
+        custom_type_properties: Dict[str, float | bool] = {}
+
+        if self.alpha_s_sand is not None:
+            custom_type_properties["alpha_s_sand"] = self.alpha_s_sand
+
+        if self.alpha_s_clay is not None:
+            custom_type_properties["alpha_s_clay"] = self.alpha_s_clay
+
+        if self.alpha_p is not None:
+            custom_type_properties["alpha_p"] = self.alpha_p
+
+        if self.alpha_t_sand is not None:
+            custom_type_properties["alpha_t_sand"] = self.alpha_t_sand
+
+        if self.settlement_curve is not None:
+            custom_type_properties["settlement_curve"] = self.settlement_curve
+
+        if self.negative_fr_delta_factor is not None:
+            custom_type_properties[
+                "negative_fr_delta_factor"
+            ] = self.negative_fr_delta_factor
+
+        if self.adhesion is not None:
+            custom_type_properties["adhesion"] = self.adhesion
+
+        if self.is_low_vibrating is not None:
+            custom_type_properties["is_low_vibrating"] = self.is_low_vibrating
+
+        if self.is_auger is not None:
+            custom_type_properties["is_auger"] = self.is_auger
+
+        if len(custom_type_properties.keys()) > 0:
+            payload["custom_properties"] = custom_type_properties
+
+        return payload

pypilecore/input/__init__.py

@@ -6,11 +6,9 @@ from pypilecore.input.multi_cpt import (
     create_multi_cpt_payload,
     create_multi_cpt_report_payload,
 )
-from pypilecore.input.pile_properties import create_pile_properties_payload
 from pypilecore.input.soil_properties import create_soil_properties_payload
 
 __all__ = [
-    "create_pile_properties_payload",
     "create_soil_properties_payload",
     "create_multi_cpt_payload",
     "create_grouper_payload",

pypilecore/input/multi_cpt.py

@@ -6,7 +6,7 @@ from typing import Dict, List, Literal, Mapping, Sequence, Tuple
 
 from pygef.cpt import CPTData
 
-from pypilecore.input.pile_properties import create_pile_properties_payload
+from pypilecore.common.piles import PileProperties
 from pypilecore.input.soil_properties import create_soil_properties_payload
 
 
@@ -15,10 +15,7 @@ def create_multi_cpt_payload(
     cptdata_objects: List[CPTData],
     classify_tables: Dict[str, dict],
     groundwater_level_nap: float,
-    pile_type: Literal["concrete", "steel", "micro", "wood"],
-    specification: Literal["1", "2", "3", "4", "5", "6", "7"],
-    installation: Literal["A", "B", "C", "D", "E", "F", "G"],
-    pile_shape: Literal["round", "rect"],
+    pile: PileProperties,
     friction_range_strategy: Literal[
         "manual", "lower_bound", "settlement_driven"
     ] = "lower_bound",
@@ -43,24 +40,6 @@ def create_multi_cpt_payload(
     ]
     | None = None,
     individual_ocr: Mapping[str, float] | None = None,
-    diameter_base: float | None = None,
-    diameter_shaft: float | None = None,
-    width_base_large: float | None = None,
-    width_base_small: float | None = None,
-    width_shaft_large: float | None = None,
-    width_shaft_small: float | None = None,
-    height_base: float | None = None,
-    settlement_curve: float | None = None,
-    adhesion: float | None = None,
-    alpha_p: float | None = None,
-    alpha_s_clay: float | None = None,
-    alpha_s_sand: float | None = None,
-    beta_p: float | None = None,
-    pile_tip_factor_s: float | None = None,
-    elastic_modulus: float | None = None,
-    is_auger: float | None = None,
-    is_low_vibrating: float | None = None,
-    negative_fr_delta_factor: float | None = None,
     use_almere_rules: bool = False,
     overrule_xi: float | None = None,
     gamma_f_nk: float = 1.0,
@@ -112,19 +91,13 @@ def create_multi_cpt_payload(
 
     groundwater_level_nap:
         The groundwater level. Unit: [m] w.r.t. NAP.
-    pile_type:
-        The equaly named entry in the "pile_type_specification" settings.
+    pile:
+        A PileProperties object.
     friction_range_strategy:
         Sets the method to determine the sleeve friction zones on the pile. The soil
         friction in the positive zone contributes to the bearing capacity, while the
         negative zone adds an extra load on the pile. Accepted values: "manual",
         "lower_bound" (default) or "settlement_driven".
-    specification:
-        The equaly named entry in the "pile_type_specification" settings.
-    installation:
-        The equaly named entry in the "pile_type_specification" settings.
-    pile_shape:
-        The shape of the pile.
     stiff_construction:
         Set to True if it's a stiff costruction. This will have influence on the xi factor
         if you don't overrule it. Default = False.
@@ -197,66 +170,6 @@ def create_multi_cpt_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.
-    diameter_base:
-        Pile base diameter [m].
-        Only relevant if ``pile_shape`` = "round".
-    diameter_shaft:
-        Pile shaft diameter [m].
-        Only relevant if ``pile_shape`` = "round".
-    width_base_large:
-        Largest dimension of the pile base [m].
-        Only relevant if ``pile_shape`` = "rect".
-    width_base_small:
-        Smallest dimension of the pile base [m].
-        Only relevant if ``pile_shape`` = "rect".
-    width_shaft_large:
-        Largest dimension of the pile shaft [m].
-        Only relevant if ``pile_shape`` = "rect".
-    width_shaft_small:
-        Smallest dimension of the pile shaft [m].
-        Only relevant if ``pile_shape`` = "rect".
-    height_base:
-        Height of pile base [m]. If None, a pile with constant dimension is inferred.
-        Cannot be None if diameter_base and diameter_shaft are unequal.
-    settlement_curve:
-        Settlement lines for figures 7.n and 7.o of NEN-9997-1 As defined in table 7.c
-        of NEN-9997-1. The value is inferred from the pile_type_specifications, but can
-        be overwritten.
-    adhesion:
-        Optional adhesion value [kPa], use it if the pile shaft has undergone a special
-        treatment. Examples: - adhesion = 50 kN/m2 for synthetic coating - adhesion = 20
-        kN/m2 for bentonite - adhesion = 10 kN/m2 for bitumen coating See 7.3.2.2(d) of
-        NEN 9997-1 for examples.
-    alpha_p:
-        Alpha p factor used in pile tip resistance calculation. The value is inferred
-        from the pile_type_specifications, but can be overwritten.
-    alpha_s_clay:
-        Alpha s factor for soft layers used in the positive friction calculation. If
-        None the factor is determined as specified in table 7.d of NEN 9997-1.
-    alpha_s_sand:
-        Alpha s factor for coarse layers used in the positive friction calculation. The
-        value is inferred from the pile_type_specifications, but can be overwritten.
-    beta_p:
-        Factor s used in pile tip resistance calculation as per NEN 9997-1 7.6.2.3 (h).
-        The value is inferred from the pile dimension properties, but can be overwritten.
-    pile_tip_factor_s:
-        Factor s used in pile tip resistance calculation as per NEN 9997-1 7.6.2.3 (h).
-        The value is inferred from the pile dimension properties, but can be overwritten.
-    elastic_modulus:
-        Modulus of elasticity of the pile [Mpa]. The value is inferred from the
-        pile_type_specifications, but can be overwritten.
-    is_auger:
-        Determines weather the pile the pile is an auger pile or not. The value is
-        inferred from the pile_type_specifications, but can be overwritten.
-    is_low_vibrating:
-        Determines weather the pile has an installation type with low vibration. The
-        value is inferred from the pile_type_specifications, but can be overwritten.
-    negative_fr_delta_factor:
-        factor * φ = δ. This parameter will be multiplied with phi to get the delta
-        parameter used in negative friction calculation according to NEN-9997-1 7.3.2.2
-        (e). Typically values are 1.0 for piles cast in place, and 0.75 for other pile
-        types. The value is inferred from the pile_type_specifications, but can be
-        overwritten.
     use_almere_rules:
         If set to True the contribution, produced by the positive shaft friction, to the
         total bearing capacity is limited to at most 75% the contribution provided by
@@ -287,9 +200,8 @@ def create_multi_cpt_payload(
     Raises
     ------
     ValueError:
-        - if `pile_shape`=="round" & `diameter_base` is None
-        - if `pile_shape`=="rect" & `width_base_large` is None
-        - if `pile_shape` not in ["rect", "round"]
+        - If `excavation_depth_nap` is not None and `excavation_param_t` is None.
+        - If both `relative_pile_load` and `pile_load_sls` are None.
     """
     # Input validation
     if excavation_depth_nap is not None and excavation_param_t is None:
@@ -312,34 +224,10 @@ def create_multi_cpt_payload(
         individual_positive_friction_range_nap=individual_positive_friction_range_nap,
         individual_ocr=individual_ocr,
     )
-    pile_properties = create_pile_properties_payload(
-        pile_type=str(pile_type),
-        specification=str(specification),
-        installation=str(installation),
-        pile_shape=pile_shape,
-        diameter_base=diameter_base,
-        diameter_shaft=diameter_shaft,
-        width_base_large=width_base_large,
-        width_base_small=width_base_small,
-        width_shaft_large=width_shaft_large,
-        width_shaft_small=width_shaft_small,
-        height_base=height_base,
-        settlement_curve=settlement_curve,
-        adhesion=adhesion,
-        alpha_p=alpha_p,
-        alpha_s_clay=alpha_s_clay,
-        alpha_s_sand=alpha_s_sand,
-        beta_p=beta_p,
-        pile_tip_factor_s=pile_tip_factor_s,
-        elastic_modulus=elastic_modulus,
-        is_auger=is_auger,
-        is_low_vibrating=is_low_vibrating,
-        negative_fr_delta_factor=negative_fr_delta_factor,
-    )
     multi_cpt_payload: dict = dict(
         pile_tip_levels_nap=list(pile_tip_levels_nap),
         list_soil_properties=soil_properties_list,
-        pile_properties=pile_properties,
+        pile_properties=pile.serialize_payload(),
         friction_range_strategy=friction_range_strategy,
         pile_head_level_nap=pile_head_level_nap,
         stiff_construction=stiff_construction,