py-pilecore 0.3.4__py3-none-any.whl → 0.4.1__py3-none-any.whl

pypilecore/results/grouper_result.py

@@ -1,77 +1,186 @@
 from __future__ import annotations
 
+from copy import deepcopy
 from dataclasses import dataclass
-from typing import Any, List, Tuple
+from functools import cached_property
+from typing import Any, Dict, List, Sequence, Tuple
 
 import natsort
 import numpy as np
 import pandas as pd
 from matplotlib import pyplot as plt
+from numpy.typing import NDArray
 from shapely import MultiPoint
 
+from pypilecore.results.multi_cpt_results import MultiCPTBearingResults
+from pypilecore.results.post_processing import (
+    MaxBearingResult,
+    MaxBearingResults,
+    MaxBearingTable,
+)
+
 
-@dataclass(frozen=True)
 class SingleClusterData:
     """
+    Data for a single CPT subgroup
     *Not meant to be instantiated by the user.*
-
-    Attributes:
-    ------------
-    characteristic_bearing_capacity: List[float]
-        characteristic bearing capacity [kN]
-    design_bearing_capacity: List[float]
-        design bearing capacity [kN]
-    design_negative_friction: List[float]
-        design negative friction [kN]
-    group_centre_to_centre_validation: List[bool]
-        group centre to centre validation
-    group_centre_to_centre_validation_15: List[bool]
-        group centre to centre validation 15 meter
-    group_centre_to_centre_validation_20: List[bool]
-        group centre to centre validation 20 meter
-    group_centre_to_centre_validation_25: List[bool]
-        group centre to centre validation 25 meter
-    mean_calculated_bearing_capacity: List[float]
-        mean calculated bearing capacity [kN]
-    min_calculated_bearing_capacity: List[float]
-        min calculated bearing capacity [kN]
-    net_design_bearing_capacity: List[float]
-        net design bearing capacity [kN]
-    nominal_cpt: List[str]
-        nominal cpt
-    pile_tip_level: List[float]
-        pile tip level [m w.r.t NAP]
-    variation_coefficient: List[float]
-        variation coefficient [-]
-    xi_factor: List[str]
-        xi factor
-    xi_values: List[float]
-        xi values [-]
     """
 
-    characteristic_bearing_capacity: List[float]
-    design_bearing_capacity: List[float]
-    design_negative_friction: List[float]
-    group_centre_to_centre_validation: List[bool]
-    group_centre_to_centre_validation_15: List[bool]
-    group_centre_to_centre_validation_20: List[bool]
-    group_centre_to_centre_validation_25: List[bool]
-    mean_calculated_bearing_capacity: List[float]
-    min_calculated_bearing_capacity: List[float]
-    net_design_bearing_capacity: List[float]
-    nominal_cpt: List[str]
-    pile_tip_level: List[float]
-    variation_coefficient: List[float]
-    xi_factor: List[str]
-    xi_values: List[float]
+    def __init__(
+        self,
+        characteristic_bearing_capacity: Sequence[float],
+        design_bearing_capacity: Sequence[float],
+        design_negative_friction: Sequence[float],
+        group_centre_to_centre_validation: Sequence[bool],
+        group_centre_to_centre_validation_15: Sequence[bool],
+        group_centre_to_centre_validation_20: Sequence[bool],
+        group_centre_to_centre_validation_25: Sequence[bool],
+        mean_calculated_bearing_capacity: Sequence[float],
+        min_calculated_bearing_capacity: Sequence[float],
+        net_design_bearing_capacity: Sequence[float],
+        nominal_cpt: Sequence[str],
+        pile_tip_level: Sequence[float],
+        variation_coefficient: Sequence[float],
+        xi_factor: Sequence[str],
+        xi_values: Sequence[float],
+    ):
+        """
+        Parameters
+        ----------
+        characteristic_bearing_capacity:
+            characteristic bearing capacity [kN]
+        design_bearing_capacity:
+            design bearing capacity [kN]
+        design_negative_friction:
+            design negative friction [kN]
+        group_centre_to_centre_validation:
+            group centre to centre validation
+        group_centre_to_centre_validation_15:
+            group centre to centre validation 15 meter
+        group_centre_to_centre_validation_20:
+            group centre to centre validation 20 meter
+        group_centre_to_centre_validation_25:
+            group centre to centre validation 25 meter
+        mean_calculated_bearing_capacity:
+            mean calculated bearing capacity [kN]
+        min_calculated_bearing_capacity:
+            min calculated bearing capacity [kN]
+        net_design_bearing_capacity:
+            net design bearing capacity [kN]
+        nominal_cpt:
+            nominal cpt
+        pile_tip_level:
+            pile tip level [m w.r.t NAP]
+        variation_coefficient:
+            variation coefficient [-]
+        xi_factor:
+            xi factor
+        xi_values:
+            xi values [-]
+        """
+        self._characteristic_bearing_capacity = characteristic_bearing_capacity
+        self._design_bearing_capacity = design_bearing_capacity
+        self._design_negative_friction = design_negative_friction
+        self._group_centre_to_centre_validation = group_centre_to_centre_validation
+        self._group_centre_to_centre_validation_15 = (
+            group_centre_to_centre_validation_15
+        )
+        self._group_centre_to_centre_validation_20 = (
+            group_centre_to_centre_validation_20
+        )
+        self._group_centre_to_centre_validation_25 = (
+            group_centre_to_centre_validation_25
+        )
+        self._mean_calculated_bearing_capacity = mean_calculated_bearing_capacity
+        self._min_calculated_bearing_capacity = min_calculated_bearing_capacity
+        self._net_design_bearing_capacity = net_design_bearing_capacity
+        self._nominal_cpt = nominal_cpt
+        self._pile_tip_level = pile_tip_level
+        self._variation_coefficient = variation_coefficient
+        self._xi_factor = xi_factor
+        self._xi_values = xi_values
 
-    def __post_init__(self) -> None:
         raw_lengths = [len(values) for values in self.__dict__.values()]
         if len(list(set(raw_lengths))) > 1:
             raise ValueError("All values in this dataclass must have the same length.")
 
     @property
-    def dataframe(self) -> pd.DataFrame:
+    def characteristic_bearing_capacity(self) -> NDArray[np.float64]:
+        """Characteristic bearing capacity [kN]"""
+        return np.array(self._characteristic_bearing_capacity).astype(np.float64)
+
+    @property
+    def design_bearing_capacity(self) -> NDArray[np.float64]:
+        """Design bearing capacity [kN]"""
+        return np.array(self._design_bearing_capacity).astype(np.float64)
+
+    @property
+    def design_negative_friction(self) -> NDArray[np.float64]:
+        """Design negative friction [kN]"""
+        return np.array(self._design_negative_friction).astype(np.float64)
+
+    @property
+    def group_centre_to_centre_validation(self) -> NDArray[np.bool_]:
+        """Group centre to centre validation"""
+        return np.array(self._group_centre_to_centre_validation).astype(np.bool_)
+
+    @property
+    def group_centre_to_centre_validation_15(self) -> NDArray[np.bool_]:
+        """Group centre to centre validation 15 meter"""
+        return np.array(self._group_centre_to_centre_validation_15).astype(np.bool_)
+
+    @property
+    def group_centre_to_centre_validation_20(self) -> NDArray[np.bool_]:
+        """Group centre to centre validation 20 meter"""
+        return np.array(self._group_centre_to_centre_validation_20).astype(np.bool_)
+
+    @property
+    def group_centre_to_centre_validation_25(self) -> NDArray[np.bool_]:
+        """Group centre to centre validation 25 meter"""
+        return np.array(self._group_centre_to_centre_validation_25).astype(np.bool_)
+
+    @property
+    def mean_calculated_bearing_capacity(self) -> NDArray[np.float64]:
+        """Mean calculated bearing capacity [kN]"""
+        return np.array(self._mean_calculated_bearing_capacity).astype(np.float64)
+
+    @property
+    def min_calculated_bearing_capacity(self) -> NDArray[np.float64]:
+        """Min calculated bearing capacity [kN]"""
+        return np.array(self._min_calculated_bearing_capacity).astype(np.float64)
+
+    @property
+    def net_design_bearing_capacity(self) -> NDArray[np.float64]:
+        """Net design bearing capacity [kN]"""
+        return np.array(self._net_design_bearing_capacity).astype(np.float64)
+
+    @property
+    def nominal_cpt(self) -> NDArray[np.str_]:
+        """Nominal cpt"""
+        return np.array(self._nominal_cpt).astype(str)
+
+    @property
+    def pile_tip_level(self) -> NDArray[np.float64]:
+        """Pile tip level [m w.r.t NAP]"""
+        return np.array(self._pile_tip_level).astype(np.float64)
+
+    @property
+    def variation_coefficient(self) -> NDArray[np.float64]:
+        """Variation coefficient [-]"""
+        return np.array(self._variation_coefficient).astype(np.float64)
+
+    @property
+    def xi_factor(self) -> NDArray[np.str_]:
+        """Xi factor"""
+        return np.array(self._xi_factor).astype(str)
+
+    @property
+    def xi_values(self) -> NDArray[np.float64]:
+        """Xi values [-]"""
+        return np.array(self._xi_values).astype(np.float64)
+
+    @cached_property
+    def to_pandas(self) -> pd.DataFrame:
         return pd.DataFrame(self.__dict__)
 
     def plot_variation_coefficient(
@@ -102,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
@@ -142,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
@@ -199,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
@@ -319,7 +428,7 @@ class SingleClusterResult:
                     ],
                     net_design_bearing_capacity=table["net_design_bearing_capacity"],
                     nominal_cpt=table["nominal_cpt"],
-                    pile_tip_level=table["pile_tip_level"],
+                    pile_tip_level=[round(elem, 2) for elem in table["pile_tip_level"]],
                     variation_coefficient=table["variation_coefficient"],
                     xi_factor=table["xi_factor"],
                     xi_values=table["xi_values"],
@@ -390,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
@@ -458,10 +567,45 @@ class GrouperResults:
     """
 
     clusters: List[SingleClusterResult]
+    multi_cpt_bearing_results: MultiCPTBearingResults
+
+    def __post_init__(self) -> None:
+        for cluster in self.clusters:
+            for cpt_name in cluster.cpt_names:
+                # check if the cpt names in the SingleClusterResults are also present
+                # in the MultiCPTBearingResults
+                if (
+                    cpt_name
+                    not in self.multi_cpt_bearing_results.cpt_results.cpt_results_dict.keys()
+                ):
+                    raise ValueError(
+                        "CPT names dont match between MultiCPTBearingResults object and GrouperResults. "
+                        "Make sure that you use the same MultiCPTBearingResults as you generated "
+                        "the subgroups/clusters with."
+                    )
+
+                # Check that all the pile tip levels in the SingleClusterResults are
+                # also present in the MultiCPTBearingResults
+                for pile_tip_level in cluster.data.pile_tip_level:
+                    if not np.isclose(
+                        pile_tip_level,
+                        self.multi_cpt_bearing_results.cpt_results.cpt_results_dict[
+                            cpt_name
+                        ].table.pile_tip_level_nap,
+                        rtol=1e-2,
+                    ).any():
+                        raise ValueError(
+                            "Pile tip levels dont match between MultiCPTBearingResults object and GrouperResults. "
+                            "Make sure that you use the same MultiCPTBearingResults as you generated "
+                            "the subgroups/clusters with."
+                        )
 
     @classmethod
     def from_api_response(
-        cls, response_dict: dict, pile_load_uls: float
+        cls,
+        response_dict: dict,
+        pile_load_uls: float,
+        multi_cpt_bearing_results: MultiCPTBearingResults,
     ) -> "GrouperResults":
         """
         Stores the response of the PileCore endpoint
@@ -473,12 +617,88 @@ class GrouperResults:
            The resulting response of a call to `get_groups_api_result()`
         pile_load_uls:
             ULS load in kN. Used to determine if a grouping configuration is valid.
+        multi_cpt_bearing_results:
+           The container that holds multiple SingleCPTBearingResults objects
         """
         results = [
             SingleClusterResult.from_api_response(item, pile_load_uls)
             for item in response_dict["sub_groups"]
         ]
-        return cls(clusters=results)
+        return cls(
+            clusters=results, multi_cpt_bearing_results=multi_cpt_bearing_results
+        )
+
+    @cached_property
+    def max_bearing_results(self) -> "MaxBearingResults":
+        """
+        Get the results of the maximum net design bearing capacity (R_c_d_net) for every CPT.
+        """
+        max_bearing: Dict[str, Any] = {}
+
+        # iterate over single cpt result
+        for (
+            cpt_name,
+            _single_cpt_result,
+        ) in self.multi_cpt_bearing_results.cpt_results.cpt_results_dict.items():
+            single_cpt_result = deepcopy(_single_cpt_result)
+            max_bearing[cpt_name] = dict(
+                pile_head_level_nap=single_cpt_result.pile_head_level_nap,
+                soil_properties=single_cpt_result.soil_properties,
+                results_table=dict(
+                    pile_tip_level_nap=single_cpt_result.table.pile_tip_level_nap,
+                    R_c_d_net=single_cpt_result.table.R_c_d_net,
+                    F_nk_d=single_cpt_result.table.F_nk_d,
+                    origin=[f"CPT:{cpt_name}"]
+                    * len(single_cpt_result.table.pile_tip_level_nap),
+                ),
+            )
+
+        # iterate over subgroups result
+        for cluster_idx, cluster in enumerate(self.clusters):
+            # iterate over cpts in subgroup
+            for cpt_name in cluster.cpt_names:
+                # iterate over pile tip levels in the cluster results for the cpt
+                for cluster_ptl_idx, ptl in enumerate(cluster.data.pile_tip_level):
+                    # find corresponding pile tip level index in the max_bearing results
+                    max_bearing_ptl_idx = np.abs(
+                        max_bearing[cpt_name]["results_table"]["pile_tip_level_nap"]
+                        - ptl
+                    ).argmin()
+
+                    # check bearing capacity
+                    if cluster.data.net_design_bearing_capacity[
+                        cluster_ptl_idx
+                    ] > np.nan_to_num(
+                        max_bearing[cpt_name]["results_table"]["R_c_d_net"][
+                            max_bearing_ptl_idx
+                        ]
+                    ):
+                        # replace data
+                        max_bearing[cpt_name]["results_table"]["R_c_d_net"][
+                            max_bearing_ptl_idx
+                        ] = cluster.data.net_design_bearing_capacity[cluster_ptl_idx]
+                        max_bearing[cpt_name]["results_table"]["F_nk_d"][
+                            max_bearing_ptl_idx
+                        ] = cluster.data.design_negative_friction[cluster_ptl_idx]
+                        max_bearing[cpt_name]["results_table"]["origin"][
+                            max_bearing_ptl_idx
+                        ] = f"Group:{cluster_idx}"
+
+        return MaxBearingResults(
+            cpt_results_dict={
+                cpt_name: MaxBearingResult(
+                    pile_head_level_nap=data["pile_head_level_nap"],
+                    soil_properties=data["soil_properties"],
+                    table=MaxBearingTable(
+                        pile_tip_level_nap=data["results_table"]["pile_tip_level_nap"],
+                        R_c_d_net=data["results_table"]["R_c_d_net"],
+                        F_nk_d=data["results_table"]["F_nk_d"],
+                        origin=data["results_table"]["origin"],
+                    ),
+                )
+                for cpt_name, data in max_bearing.items()
+            }
+        )
 
     def map(
         self,
@@ -555,6 +775,9 @@ class GrouperResults:
     ) -> plt.Figure:
         """
         Plot a summary of the valid subgroups.
+
+        Note
+        -----
         Plot contains the:
 
             - cpts within a subgroup

pypilecore/results/multi_cpt_results.py

@@ -135,7 +135,9 @@ class CPTGroupResultsTable:
         cpt_normative:
             The normative CPT. Can be "group average" if that was found to be the normative scenario.
         """
-        self.pile_tip_level_nap = np.array(pile_tip_level_nap).astype(np.float64)
+        self.pile_tip_level_nap = (
+            np.array(pile_tip_level_nap).astype(np.float64).round(decimals=2)
+        )
         """The pile-tip level [m] w.r.t. NAP."""
         self.R_s_k = np.array(R_s_k).astype(np.float64)
         """The characteristic value of the shaft bearingcapacity  [kN]."""
@@ -309,8 +311,7 @@ class SingleCPTBearingResultsContainer:
         cpt_results_dict:
             A dictionary that maps the cpt-names to SingleCPTBearingResults objects.
         """
-        self.cpt_results_dict = cpt_results_dict
-        """A dictionary that maps the cpt-names to SingleCPTBearingResults objects."""
+        self._cpt_results_dict = cpt_results_dict
 
     @classmethod
     def from_api_response(
@@ -341,6 +342,11 @@ class SingleCPTBearingResultsContainer:
 
         return self.get_cpt_results(test_id)
 
+    @property
+    def cpt_results_dict(self) -> Dict[str, SingleCPTBearingResults]:
+        """The dictionary that maps the cpt-names to SingleCPTBearingResults objects."""
+        return self._cpt_results_dict
+
     @property
     def test_ids(self) -> List[str]:
         """The test-ids of the CPTs."""