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

pypilecore/input/tension.py

@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+import datetime
+from copy import deepcopy
+from typing import Any, Dict, List, Literal, Mapping, Sequence, Tuple
+
+from pygef.cpt import CPTData
+
+from pypilecore.common.piles import PileGridProperties, PileProperties
+from pypilecore.input.soil_properties import create_soil_properties_payload
+
+
+def create_multi_cpt_payload(
+    pile_tip_levels_nap: Sequence[float],
+    cptdata_objects: List[CPTData],
+    classify_tables: Dict[str, dict],
+    groundwater_level_nap: float,
+    pile: PileProperties,
+    pile_grid: PileGridProperties | None,
+    stiff_construction: bool = False,
+    ocr: float | None = None,
+    soil_load_sls: float = 0.0,
+    pile_head_level_nap: float | Literal["surface"] = "surface",
+    excavation_depth_nap: float | None = None,
+    top_of_tension_zone_nap: float | None = None,
+    individual_top_of_tension_zone_nap: Mapping[Any, float] | None = None,
+    excavation_param_t: float = 1.0,
+    individual_ocr: Mapping[str, float] | None = None,
+    overrule_xi: float | None = None,
+    gamma_f_nk: float = 1.0,
+    gamma_r_s: float = 1.2,
+    gamma_r_b: float = 1.2,
+    void_ratio_max: float = 0.8,
+    void_ratio_min: float = 0.4,
+    pile_load_sls_max: float = 1,
+    pile_load_sls_min: float = 0,
+    gamma_s_t: float = 1.35,
+    gamma_gamma: float = 1.1,
+) -> Tuple[dict, Dict[str, dict]]:
+    """
+    Creates a dictionary with the payload content for the PileCore endpoint
+    "/compression/multi-cpt/results"
+
+    This dictionary can be passed directly to `nuclei.client.call_endpoint()`.
+
+    Note
+    ----
+    The result 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()`.
+
+    Parameters
+    ----------
+    pile_tip_levels_nap:
+        Range of values for which the pile resistance is calculated.
+    cptdata_objects:
+        A list of pygef.CPTData objects
+    classify_tables:
+        A dictionary, mapping `CPTData.alias` values to dictionary with the resulting response
+        of a call to CPTCore `classify/*` information, containing the following keys:
+
+            - geotechnicalSoilName: Sequence[str]
+                Geotechnical Soil Name related to the ISO
+            - lowerBoundary: Sequence[float]
+                Lower boundary of the layer [m]
+            - upperBoundary: Sequence[float]
+                Upper boundary of the layer [m]
+            - color: Sequence[str]
+                Hex color code
+            - mainComponent: Sequence[Literal["rocks", "gravel", "sand", "silt", "clay", "peat"]]
+                Main soil component
+            - cohesion: Sequence[float]
+                Cohesion of the layer [kPa]
+            - gamma_sat: Sequence[float]
+                Saturated unit weight [kN/m^3]
+            - gamma_unsat: Sequence[float]
+                Unsaturated unit weight [kN/m^3]
+            - phi: Sequence[float]
+                Phi [degrees]
+            - undrainedShearStrength: Sequence[float]
+                Undrained shear strength [kPa]
+
+    groundwater_level_nap:
+        The groundwater level. Unit: [m] w.r.t. NAP.
+    pile:
+        A PileProperties object.
+    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.
+    ocr:
+        The Over-Consolidation-Ratio [-] of the foundation layer.
+    soil_load_sls:
+        Load on soil surface [kPa], used to calculate soil settlement. This is only required
+        with the settlement-driven friction-range strategy.
+        Default = 0.0
+    pile_head_level_nap:
+        The level of the pile head. Can be:
+
+            - float;
+                This is interpreted as an absolute level in [m w.r.t. NAP];
+            - Literal["surface"] (default).
+                In this case, the soil_properties.service_level
+                property is used.
+    excavation_depth_nap:
+        Soil excavation depth after the CPT was taken. Unit: [m] w.r.t. NAP.
+    excavation_param_t:
+        Excavation parameter depending on pile installation method and/or phasing.
+            - Use 1.0 (default) for post-excavation installation with vibration (i.e. hammering).
+            - Use 0.5 for reduced-vibration installation, or pile installation prior to
+              excavation method.
+
+        See for more info NEN 9997-1+C2:2017 7.6.2.3.(10)(k)
+    overrule_xi:
+        Set a fixed value for xi in all calculations. Use with caution. This will
+        overrule the calculation of xi-values based on the group-size, variation-
+        coefficient and construction stiffness.
+    gamma_f_nk:
+        Safety factor for design-values of the negative sleeve friction force.
+        Default = 1.0
+    gamma_r_s:
+        Safety factor, used to obtain design-values of the pile-tip bearingcapacity.
+        Default = 1.2
+    gamma_r_b:
+        Safety factor, used to obtain design-values of the sleeve bearingcapacity.
+        Default = 1.2
+    void_ratio_max:
+        Maximum void ratio of the soil (the loosest packing). The influence of this
+        parameter is limited and therefore it is typically sufficient to provide a
+        global estimation. For normally consolidated sands in The Netherlands, an
+        emax = 0.80 can be used in most cases.
+        Default = 0.8
+    void_ratio_min:
+        Minimum void ratio of the soil (the densest packing). The influence of this parameter
+        is limited and therefore it is typically sufficient to provide a global estimation.
+        For normally consolidated sands in The Netherlands, an emin = 0.40 can be used in most cases.
+        Default = 0.4
+    pile_load_sls_max:
+        Maximum tension force on pile Ft;max;k. Note that only positive values (tension force)
+        are accepted. unit: kN
+        Default = 1
+    pile_load_sls_min:
+        Minimum tension force (or maximum compression force) on pile -Ft;min;k (tension > 0). Positive
+        values (tension force), negative values (compression force) and 0.0 are accepted. Note that
+        the positive must be <= pile_load_sls_max. unit: kN
+        Default = 0
+    gamma_s_t:
+        Pile resistance factor gamma_s;t used to compute the design cone resistance values
+        qc;z;d as prescribed in NEN 9997-1+C2_2017 7.6.3.3(d).
+        Default = 1.35
+    gamma_gamma:
+        Partial factor for volumetric weight NEN 9997-1+C2:2017 A.3.2
+        Default = 1.1
+    Returns
+    -------
+    multi_cpt_payload:
+        Dictionary with the payload content for the PileCore endpoint
+        "/compression/multi-cpt/results"
+    results_kwargs:
+        Dictionary with keyword arguments for the `pilecore.MultiCPTBearingResults`
+        object.
+
+    Raises
+    ------
+    ValueError:
+        - 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:
+        raise ValueError(
+            "`excavation_param_t` cannot be None when `excavation_depth_nap` is not None."
+        )
+
+    soil_properties_list, results_kwargs = create_soil_properties_payload(
+        cptdata_objects=cptdata_objects,
+        classify_tables=classify_tables,
+        groundwater_level_nap=groundwater_level_nap,
+        friction_range_strategy="manual",
+        excavation_depth_nap=excavation_depth_nap,
+        master_ocr=ocr,
+        individual_negative_friction_range_nap=None,
+        individual_positive_friction_range_nap=None,
+        individual_ocr=individual_ocr,
+        master_top_of_tension_zone_nap=top_of_tension_zone_nap,
+        individual_top_of_tension_zone_nap=individual_top_of_tension_zone_nap,
+    )
+    multi_cpt_payload: dict = dict(
+        pile_tip_levels_nap=list(pile_tip_levels_nap),
+        list_soil_properties=soil_properties_list,
+        pile_properties=pile.serialize_payload(),
+        pile_head_level_nap=pile_head_level_nap,
+        stiff_construction=stiff_construction,
+        soil_load=soil_load_sls if soil_load_sls is not None else 0.0,
+        excavation_param_t=excavation_param_t,
+        gamma_f_nk=gamma_f_nk,
+        gamma_r_b=gamma_r_b,
+        gamma_r_s=gamma_r_s,
+        void_ratio_max=void_ratio_max,
+        void_ratio_min=void_ratio_min,
+        pile_load_sls_max=pile_load_sls_max,
+        pile_load_sls_min=pile_load_sls_min,
+        gamma_s_t=gamma_s_t,
+        gamma_gamma=gamma_gamma,
+    )
+
+    # Add optional properties
+    if excavation_depth_nap is not None:
+        multi_cpt_payload["excavation_depth_nap"] = excavation_depth_nap
+    if overrule_xi is not None:
+        multi_cpt_payload["overrule_xi"] = overrule_xi
+    if pile_grid is not None:
+        multi_cpt_payload["pile_grid"] = pile_grid.serialize_payload()
+
+    return multi_cpt_payload, results_kwargs
+
+
+def create_multi_cpt_report_payload(
+    multi_cpt_payload: dict,
+    project_name: str,
+    project_id: str,
+    author: str,
+    date: str | None = None,
+    group_results_content: bool = True,
+    individual_cpt_results_content: bool = True,
+    result_summary_content: bool = True,
+) -> dict:
+    """
+    Creates a dictionary with the payload content for the PileCore endpoint
+    "/compression/multi-cpt/report"
+
+    This dictionary can be passed directly to `nuclei.client.call_endpoint()`. Note that
+    it 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()`.
+
+    Parameters
+    ----------
+    multi_cpt_payload:
+        Index 0 of the resulting tuple of a call to `create_multi_cpt_payload()`
+    project_name:
+        The name of the project.
+    project_id:
+        The identifier (code) of the project.
+    author:
+        The author of the report.
+    date:
+        The date of the report. If None, the current date will be used.
+    group_results_content:
+        Whether or not to add the group-results section to the report. Default = True
+    individual_cpt_results_content:
+        Whether or not to add the individual-cpt-results section to the report.
+        Default = True
+    result_summary_content:
+        Whether or not to add the result-summary section to the report. Default = True
+
+    Returns
+    -------
+    report_payload:
+        Dictionary with the payload content for the PileCore endpoint
+        "/compression/multi-cpt/report"
+    """
+    report_payload = deepcopy(multi_cpt_payload)
+    report_payload.update(
+        dict(
+            content=dict(
+                group_results=group_results_content,
+                individual_cpt_results=individual_cpt_results_content,
+                result_summary=result_summary_content,
+            ),
+            general=dict(
+                author=author,
+                project_id=project_id,
+                project_name=project_name,
+                date=(
+                    date if date is None else datetime.date.today().strftime("%d-%m-%y")
+                ),
+            ),
+        )
+    )
+    return report_payload

pypilecore/results/__init__.py

@@ -1,13 +1,21 @@
 from pypilecore.results.cases_multi_cpt_results import CasesMultiCPTBearingResults
+from pypilecore.results.compression.multi_cpt_results import (
+    MultiCPTCompressionBearingResults,
+)
+from pypilecore.results.compression.single_cpt_results import (
+    SingleCPTCompressionBearingResults,
+)
 from pypilecore.results.grouper_result import GrouperResults
-from pypilecore.results.multi_cpt_results import MultiCPTBearingResults
-from pypilecore.results.single_cpt_results import SingleCPTBearingResults
 from pypilecore.results.soil_properties import SoilProperties
+from pypilecore.results.tension.multi_cpt_results import MultiCPTTensionBearingResults
+from pypilecore.results.tension.single_cpt_results import SingleCPTTensionBearingResults
 
 __all__ = [
     "CasesMultiCPTBearingResults",
-    "MultiCPTBearingResults",
-    "SingleCPTBearingResults",
+    "MultiCPTCompressionBearingResults",
+    "SingleCPTCompressionBearingResults",
+    "MultiCPTTensionBearingResults",
+    "SingleCPTTensionBearingResults",
     "SoilProperties",
     "GrouperResults",
 ]

pypilecore/results/cases_multi_cpt_results.py

@@ -6,11 +6,11 @@ import pandas as pd
 from natsort import natsorted
 from pygef.common import Location
 
-from pypilecore.results.multi_cpt_results import MultiCPTBearingResults
 from pypilecore.results.result_definitions import (
     CPTGroupResultDefinitions,
     CPTResultDefinitions,
 )
+from pypilecore.results.typing import MultiCPTBearingResults
 
 
 class CasesMultiCPTBearingResults:
@@ -77,23 +77,27 @@ class CasesMultiCPTBearingResults:
         records = []
         for case_name, case_results in results_per_case.items():
             for result_definition in CPTResultDefinitions:
-                df = case_results.cpt_results.get_results_per_cpt(
-                    column_name=result_definition.name
-                )
-                for idx_row, row in df.iterrows():
-                    for test_id, result in row.items():
-                        records.append(
-                            dict(
-                                case_name=case_name,
-                                result_name=result_definition.name,
-                                test_id=test_id,
-                                x=self.cpt_locations[test_id].x,
-                                y=self.cpt_locations[test_id].y,
-                                pile_tip_level_nap=idx_row,
-                                result=result,
-                                result_unit=result_definition.value.unit,
+                if (
+                    result_definition.name
+                    in case_results.cpt_results.to_pandas().columns
+                ):
+                    df = case_results.cpt_results.get_results_per_cpt(
+                        column_name=result_definition.name
+                    )
+                    for idx_row, row in df.iterrows():
+                        for test_id, result in row.items():
+                            records.append(
+                                dict(
+                                    case_name=case_name,
+                                    result_name=result_definition.name,
+                                    test_id=test_id,
+                                    x=self.cpt_locations[test_id].x,
+                                    y=self.cpt_locations[test_id].y,
+                                    pile_tip_level_nap=idx_row,
+                                    result=result,
+                                    result_unit=result_definition.value.unit,
+                                )
                             )
-                        )
         self._cpt_results_dataframe = pd.DataFrame.from_records(records)
 
     def _set_cpt_group_results_dataframe(
@@ -104,16 +108,17 @@ class CasesMultiCPTBearingResults:
         for case_name, case_results in result_cases.items():
             df = case_results.group_results_table.to_pandas()
             for result_definition in CPTGroupResultDefinitions:
-                for _, row in df.iterrows():
-                    records.append(
-                        dict(
-                            case_name=case_name,
-                            result_name=result_definition.name,
-                            pile_tip_level_nap=row["pile_tip_level_nap"],
-                            result=row[result_definition.value.name],
-                            result_unit=result_definition.value.unit,
+                if result_definition.name in df.columns:
+                    for _, row in df.iterrows():
+                        records.append(
+                            dict(
+                                case_name=case_name,
+                                result_name=result_definition.name,
+                                pile_tip_level_nap=row["pile_tip_level_nap"],
+                                result=row[result_definition.value.name],
+                                result_unit=result_definition.value.unit,
+                            )
                         )
-                    )
         self._cpt_group_results_dataframe = pd.DataFrame.from_records(records)
 
     def _set_cpt_locations(self, value: Dict[str, Location]) -> None:

pypilecore/results/{multi_cpt_results.py → compression/multi_cpt_results.py}

@@ -11,13 +11,15 @@ from matplotlib.patches import Patch
 
 from pypilecore.common.piles import PileProperties
 from pypilecore.exceptions import UserError
+from pypilecore.results.compression.single_cpt_results import (
+    SingleCPTCompressionBearingResults,
+)
 from pypilecore.results.load_settlement import get_load_settlement_plot
-from pypilecore.results.single_cpt_results import SingleCPTBearingResults
 
 Number = Union[float, int]
 
 
-class CPTGroupResultsTable:
+class CPTCompressionGroupResultsTable:
     """
     Dataclass that contains the bearing results of a group of CPTs.
     """
@@ -299,10 +301,10 @@ class CPTGroupResultsTable:
         return axes
 
 
-class SingleCPTBearingResultsContainer:
+class SingleCPTCompressionBearingResultsContainer:
     """A container that holds multiple SingleCPTBearingResults objects"""
 
-    def __init__(self, cpt_results_dict: Dict[str, SingleCPTBearingResults]):
+    def __init__(self, cpt_results_dict: Dict[str, SingleCPTCompressionBearingResults]):
         """
         Parameters
         ----------
@@ -314,14 +316,16 @@ class SingleCPTBearingResultsContainer:
     @classmethod
     def from_api_response(
         cls, cpt_results_list: list, cpt_input: dict
-    ) -> "SingleCPTBearingResultsContainer":
+    ) -> "SingleCPTCompressionBearingResultsContainer":
         """
         Instantiates the SingleCPTBearingResultsContainer object from the "cpts" array,
         which is returned in the response of a "compression/multiple-cpts/results" endpoint call.
         """
         return cls(
             cpt_results_dict={
-                cpt_results["test_id"]: SingleCPTBearingResults.from_api_response(
+                cpt_results[
+                    "test_id"
+                ]: SingleCPTCompressionBearingResults.from_api_response(
                     cpt_results_dict=cpt_results,
                     ref_height=cpt_input[cpt_results["test_id"]]["ref_height"],
                     surface_level_ref=cpt_input[cpt_results["test_id"]][
@@ -334,14 +338,14 @@ class SingleCPTBearingResultsContainer:
             }
         )
 
-    def __getitem__(self, test_id: str) -> SingleCPTBearingResults:
+    def __getitem__(self, test_id: str) -> SingleCPTCompressionBearingResults:
         if not isinstance(test_id, str):
             raise TypeError(f"Expected a test-id as a string, but got: {type(test_id)}")
 
         return self.get_cpt_results(test_id)
 
     @property
-    def cpt_results_dict(self) -> Dict[str, SingleCPTBearingResults]:
+    def cpt_results_dict(self) -> Dict[str, SingleCPTCompressionBearingResults]:
         """The dictionary that maps the cpt-names to SingleCPTBearingResults objects."""
         return self._cpt_results_dict
 
@@ -351,11 +355,11 @@ class SingleCPTBearingResultsContainer:
         return list(self.cpt_results_dict.keys())
 
     @property
-    def results(self) -> List[SingleCPTBearingResults]:
+    def results(self) -> List[SingleCPTCompressionBearingResults]:
         """The computed results, as a list of SingleCPTBearingResults objects."""
         return list(self.cpt_results_dict.values())
 
-    def get_cpt_results(self, test_id: str) -> SingleCPTBearingResults:
+    def get_cpt_results(self, test_id: str) -> SingleCPTCompressionBearingResults:
         """
         Returns the `SingleCPTBearingResults` object for the provided test_id.
         """
@@ -411,7 +415,7 @@ class SingleCPTBearingResultsContainer:
         return cpt_results_df
 
 
-class MultiCPTBearingResults:
+class MultiCPTCompressionBearingResults:
     """
     Object that contains the results of a PileCore multi-cpt calculation.
 
@@ -420,8 +424,8 @@ class MultiCPTBearingResults:
 
     def __init__(
         self,
-        cpt_results: SingleCPTBearingResultsContainer,
-        group_results_table: CPTGroupResultsTable,
+        cpt_results: SingleCPTCompressionBearingResultsContainer,
+        group_results_table: CPTCompressionGroupResultsTable,
         pile_properties: PileProperties,
         gamma_f_nk: float,
         gamma_r_b: float,
@@ -460,13 +464,15 @@ class MultiCPTBearingResults:
     @classmethod
     def from_api_response(
         cls, response_dict: dict, cpt_input: dict
-    ) -> "MultiCPTBearingResults":
+    ) -> "MultiCPTCompressionBearingResults":
         """
         Build the object from the response payload of the PileCore endpoint
         "/compression/multi-cpt/results".
         """
-        cpt_results_dict = SingleCPTBearingResultsContainer.from_api_response(
-            cpt_results_list=response_dict["cpts"], cpt_input=cpt_input
+        cpt_results_dict = (
+            SingleCPTCompressionBearingResultsContainer.from_api_response(
+                cpt_results_list=response_dict["cpts"], cpt_input=cpt_input
+            )
         )
         group_results = response_dict["group_results"]
         return cls(
@@ -474,7 +480,7 @@ class MultiCPTBearingResults:
             pile_properties=PileProperties.from_api_response(
                 response_dict["pile_properties"]
             ),
-            group_results_table=CPTGroupResultsTable(
+            group_results_table=CPTCompressionGroupResultsTable(
                 pile_tip_level_nap=group_results["pile_tip_level_nap"],
                 R_s_k=group_results["R_s_k"],
                 R_b_k=group_results["R_b_k"],
@@ -532,7 +538,7 @@ class MultiCPTBearingResults:
         return self._pp
 
     @property
-    def cpt_results(self) -> SingleCPTBearingResultsContainer:
+    def cpt_results(self) -> SingleCPTCompressionBearingResultsContainer:
         """The SingleCPTBearingResultsContainer object."""
         return self._cpt_results
 
@@ -542,7 +548,7 @@ class MultiCPTBearingResults:
         return self.cpt_results.test_ids
 
     @property
-    def group_results_table(self) -> CPTGroupResultsTable:
+    def group_results_table(self) -> CPTCompressionGroupResultsTable:
         """The CPTGroupResultsTable dataclass, containing the group results."""
         return self._group_results_table
 

pypilecore/results/{single_cpt_results.py → compression/single_cpt_results.py}

@@ -21,7 +21,7 @@ Number = Union[float, int]
 
 
 @dataclass(frozen=True)
-class CPTResultsTable:
+class CPTCompressionResultsTable:
     """Object containing the results of a single CPT."""
 
     pile_tip_level_nap: NDArray[np.float64]
@@ -127,7 +127,7 @@ class CPTResultsTable:
         s_el: Sequence[Number],
         k_v_b: Sequence[Number],
         k_v_1: Sequence[Number],
-    ) -> CPTResultsTable:
+    ) -> CPTCompressionResultsTable:
         return cls(
             pile_tip_level_nap=np.array(pile_tip_level_nap).astype(np.float64),
             F_nk_cal=np.array(F_nk_cal).astype(np.float64),
@@ -173,7 +173,7 @@ class CPTResultsTable:
         return pd.DataFrame(self.__dict__).dropna(axis=0, how="all")
 
 
-class SingleCPTBearingResults:
+class SingleCPTCompressionBearingResults:
     """
     Object that contains the results of a PileCore single-cpt calculation.
 
@@ -184,7 +184,7 @@ class SingleCPTBearingResults:
         self,
         soil_properties: SoilProperties,
         pile_head_level_nap: float,
-        results_table: CPTResultsTable,
+        results_table: CPTCompressionResultsTable,
     ) -> None:
         """
         Parameters
@@ -208,7 +208,7 @@ class SingleCPTBearingResults:
         surface_level_ref: float,
         x: float | None = None,
         y: float | None = None,
-    ) -> "SingleCPTBearingResults":
+    ) -> "SingleCPTCompressionBearingResults":
         results_table = cpt_results_dict["results_table"]
         return cls(
             soil_properties=SoilProperties(
@@ -226,7 +226,7 @@ class SingleCPTBearingResults:
                 y=y,
             ),
             pile_head_level_nap=cpt_results_dict["annotations"]["pile_head_level_nap"],
-            results_table=CPTResultsTable.from_sequences(
+            results_table=CPTCompressionResultsTable.from_sequences(
                 pile_tip_level_nap=results_table["pile_tip_level_nap"],
                 F_nk_cal=results_table["F_nk_cal"],
                 F_nk_k=results_table["F_nk_k"],
@@ -282,7 +282,7 @@ class SingleCPTBearingResults:
         return self._pile_head_level_nap
 
     @property
-    def table(self) -> CPTResultsTable:
+    def table(self) -> CPTCompressionResultsTable:
         """The object with single-CPT results table traces."""
         return self._results_table
 

pypilecore/results/grouper_result.py

@@ -13,7 +13,9 @@ from matplotlib.axes import Axes
 from numpy.typing import NDArray
 from shapely import MultiPoint
 
-from pypilecore.results.multi_cpt_results import MultiCPTBearingResults
+from pypilecore.results.compression.multi_cpt_results import (
+    MultiCPTCompressionBearingResults,
+)
 from pypilecore.results.post_processing import (
     MaxBearingResult,
     MaxBearingResults,
@@ -568,7 +570,7 @@ class GrouperResults:
     """
 
     clusters: List[SingleClusterResult]
-    multi_cpt_bearing_results: MultiCPTBearingResults
+    multi_cpt_bearing_results: MultiCPTCompressionBearingResults
 
     def __post_init__(self) -> None:
         for cluster in self.clusters:
@@ -606,7 +608,7 @@ class GrouperResults:
         cls,
         response_dict: dict,
         pile_load_uls: float,
-        multi_cpt_bearing_results: MultiCPTBearingResults,
+        multi_cpt_bearing_results: MultiCPTCompressionBearingResults,
     ) -> "GrouperResults":
         """
         Stores the response of the PileCore endpoint