geolysis 0.12.0__tar.gz → 0.14.0__tar.gz

{geolysis-0.12.0 → geolysis-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geolysis
-Version: 0.12.0
+Version: 0.14.0
 Summary: geolysis is an opensource software for geotechnical engineering analysis and modeling.
 Author-email: Patrick Boateng <boatengpato.pb@gmail.com>
 License: MIT License
@@ -161,7 +161,7 @@ These are the main components of the project structure
 >>> clf = aashto_clf.classify()
 >>> clf.symbol
 'A-6(4)'
->>> clf.symbol_no_grp_idx
+>>> clf.symbol_no_group_idx
 'A-6'
 >>> clf.group_index
 '4'

{geolysis-0.12.0 → geolysis-0.14.0}/README.md

@@ -128,7 +128,7 @@ These are the main components of the project structure
 >>> clf = aashto_clf.classify()
 >>> clf.symbol
 'A-6(4)'
->>> clf.symbol_no_grp_idx
+>>> clf.symbol_no_group_idx
 'A-6'
 >>> clf.group_index
 '4'

{geolysis-0.12.0 → geolysis-0.14.0}/geolysis/__init__.py

@@ -1,5 +1,5 @@
 from . import bearing_capacity, foundation, soil_classifier, spt
 
-__version__ = "0.12.0"
+__version__ = "0.14.0"
 
 __all__ = ["foundation", "soil_classifier", "spt", "bearing_capacity"]

{geolysis-0.12.0 → geolysis-0.14.0}/geolysis/bearing_capacity/abc/_cohl/__init__.py

@@ -1,10 +1,11 @@
 import enum
 from typing import Optional, Annotated
 
-from func_validator import MustBeMemberOf, validate_func_args
+from func_validator import MustBeMemberOf, validate_params
 
 from geolysis.foundation import FoundationType, Shape, create_foundation
 from geolysis.utils import AbstractStrEnum, inf
+
 from ._core import AllowableBearingCapacity
 from .bowles_abc import BowlesABC4MatFoundation, BowlesABC4PadFoundation
 from .meyerhof_abc import MeyerhofABC4MatFoundation, MeyerhofABC4PadFoundation
@@ -16,7 +17,7 @@ class ABCType(AbstractStrEnum):
 
     Each member represents a different method for determining
     the allowable bearing capacity of soil.
-   """
+    """
 
     BOWLES = enum.auto()
     """Bowles's method for calculating allowable bearing capacity"""
@@ -28,20 +29,34 @@ class ABCType(AbstractStrEnum):
     """Terzaghi's method for calculating allowable bearing capacity"""
 
 
-@validate_func_args
+abc_classes = {
+    ABCType.BOWLES: {
+        FoundationType.PAD: BowlesABC4PadFoundation,
+        FoundationType.MAT: BowlesABC4MatFoundation,
+    },
+    ABCType.MEYERHOF: {
+        FoundationType.PAD: MeyerhofABC4PadFoundation,
+        FoundationType.MAT: MeyerhofABC4MatFoundation,
+    },
+    ABCType.TERZAGHI: {
+        FoundationType.PAD: TerzaghiABC4PadFoundation,
+        FoundationType.MAT: TerzaghiABC4MatFoundation,
+    },
+}
+
+
+@validate_params
 def create_abc_4_cohesionless_soils(
-        corrected_spt_n_value: float,
-        tol_settlement: float,
-        depth: float,
-        width: float,
-        length: Optional[float] = None,
-        eccentricity: float = 0.0,
-        ground_water_level: float = inf,
-        shape: Shape | str = "square",
-        foundation_type: Annotated[
-            FoundationType | str, MustBeMemberOf(FoundationType)
-        ] = "pad",
-        abc_type: Annotated[ABCType | str, MustBeMemberOf(ABCType)] = "bowles",
+    corrected_spt_n_value: float,
+    tol_settlement: float,
+    depth: float,
+    width: float,
+    length: Optional[float] = None,
+    eccentricity: float = 0.0,
+    ground_water_level: float = inf,
+    shape: Shape | str = "square",
+    foundation_type: FoundationType | str = "pad",
+    abc_type: Annotated[ABCType | str, MustBeMemberOf(ABCType)] = "bowles",
 ) -> AllowableBearingCapacity:
     r"""A factory function that encapsulate the creation of  allowable
      bearing capacities.
@@ -58,13 +73,6 @@ def create_abc_4_cohesionless_soils(
     :param foundation_type: Type of foundation.
     :param abc_type: Type of allowable bearing capacity calculation to
                      apply.
-
-    :raises ValidationError: Raised if `abc_type` or `foundation_type`
-                              is not supported.
-    :raises ValidationError: Raised if an invalid footing `shape` is
-                              provided.
-    :raises ValueError: Raised when `length` is not provided for a
-                         rectangular footing.
     """
     abc_type = ABCType(abc_type)
     foundation_type = FoundationType(foundation_type)
@@ -80,30 +88,10 @@ def create_abc_4_cohesionless_soils(
         foundation_type=foundation_type,
         shape=shape,
     )
+    abc_class = abc_classes[abc_type][foundation_type]
 
-    abc_class = _get_allowable_bearing_capacity(abc_type,
-                                                fnd_size.foundation_type)
     return abc_class(
         corrected_spt_n_value=corrected_spt_n_value,
         tol_settlement=tol_settlement,
         foundation_size=fnd_size,
     )
-
-
-def _get_allowable_bearing_capacity(abc_type: ABCType,
-                                    foundation_type: FoundationType):
-    abc_classes = {
-        ABCType.BOWLES: {
-            FoundationType.PAD: BowlesABC4PadFoundation,
-            FoundationType.MAT: BowlesABC4MatFoundation,
-        },
-        ABCType.MEYERHOF: {
-            FoundationType.PAD: MeyerhofABC4PadFoundation,
-            FoundationType.MAT: MeyerhofABC4MatFoundation,
-        },
-        ABCType.TERZAGHI: {
-            FoundationType.PAD: TerzaghiABC4PadFoundation,
-            FoundationType.MAT: TerzaghiABC4MatFoundation,
-        },
-    }
-    return abc_classes[abc_type][foundation_type]

{geolysis-0.12.0 → geolysis-0.14.0}/geolysis/bearing_capacity/abc/_cohl/_core.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 from typing import Annotated
 
 from func_validator import (
-    validate_func_args,
+    validate_params,
     MustBeNonNegative,
     MustBeLessThanOrEqual,
 )
@@ -40,9 +40,12 @@ class AllowableBearingCapacity(ABC):
         return self._corrected_spt_n_value
 
     @corrected_spt_n_value.setter
-    @validate_func_args
-    def corrected_spt_n_value(self, val: Annotated[float, MustBeNonNegative]):
-        self._corrected_spt_n_value = val
+    @validate_params
+    def corrected_spt_n_value(
+        self,
+        corrected_spt_n_value: Annotated[float, MustBeNonNegative],
+    ):
+        self._corrected_spt_n_value = corrected_spt_n_value
 
     @property
     def tol_settlement(self) -> float:
@@ -50,7 +53,7 @@ class AllowableBearingCapacity(ABC):
         return self._tol_settlement
 
     @tol_settlement.setter
-    @validate_func_args
+    @validate_params
     def tol_settlement(
         self,
         tol_settlement: Annotated[float, MustBeLessThanOrEqual(25.4)],
@@ -68,8 +71,7 @@ class AllowableBearingCapacity(ABC):
         return min(1.0 + 0.33 * depth / width, 1.33)
 
     def bearing_capacity_results(self) -> AllowableBearingCapacityResult:
-        """Return a dictionary of bearing capacity results with
-        intermediate calculations.
+        """Return bearing capacity results with intermediate calculations.
 
         !!! info "Added in v0.11.0"
         """
@@ -79,12 +81,16 @@ class AllowableBearingCapacity(ABC):
         )
 
     @round_(ndigits=1)
-    def allowable_bearing_capacity(self):
+    def allowable_bearing_capacity(self) -> float:
         """Calculates the allowable bearing capacity.
 
         !!! info "Added in v0.12.0"
         """
         return self._bearing_capacity()
 
+    def allowable_applied_load(self) -> float:
+        """Calculate the allowable applied load on the foundation."""
+        return self._bearing_capacity() * self.foundation_size.foundation_area()
+
     @abstractmethod
-    def _bearing_capacity(self): ...
+    def _bearing_capacity(self) -> float: ...

{geolysis-0.12.0 → geolysis-0.14.0}/geolysis/bearing_capacity/abc/_cohl/terzaghi_abc.py

@@ -1,7 +1,7 @@
 from geolysis.foundation import Foundation
-from geolysis.utils import round_
+from geolysis.utils import round_, isinf
 
-from ._core import AllowableBearingCapacity
+from ._core import AllowableBearingCapacity, AllowableBearingCapacityResult
 
 
 class TerzaghiABC4PadFoundation(AllowableBearingCapacity):
@@ -46,7 +46,7 @@ class TerzaghiABC4PadFoundation(AllowableBearingCapacity):
         width = self.foundation_size.width
         water_level = self.foundation_size.ground_water_level
 
-        if water_level is None:
+        if isinf(water_level):
             return 2.0
 
         if water_level <= depth:
@@ -75,9 +75,9 @@ class TerzaghiABC4PadFoundation(AllowableBearingCapacity):
             * self._sr()
         )
 
-    def bearing_capacity_results(self) -> dict:
+    def bearing_capacity_results(self) -> AllowableBearingCapacityResult:
         res = super().bearing_capacity_results()
-        res["water_correction_factor"] = self._cw()
+        res.water_correction_factor = self._cw()
         return res
 
 

{geolysis-0.12.0 → geolysis-0.14.0}/geolysis/bearing_capacity/ubc/__init__.py

@@ -1,12 +1,12 @@
 import enum
 from typing import Optional, Annotated
 
-from func_validator import MustBeMemberOf, validate_func_args
+from func_validator import MustBeMemberOf, validate_params
 
 from geolysis.foundation import Shape, create_foundation
-from geolysis.utils import AbstractStrEnum
+from geolysis.utils import AbstractStrEnum, inf
+
 from ._core import UltimateBearingCapacity
-from ._hansen_ubc import HansenUltimateBearingCapacity
 from ._terzaghi_ubc import (
     TerzaghiUBC4CircularFooting,
     TerzaghiUBC4RectangularFooting,
@@ -20,7 +20,6 @@ __all__ = [
     "TerzaghiUBC4CircularFooting",
     "TerzaghiUBC4RectangularFooting",
     "TerzaghiUBC4SquareFooting",
-    "HansenUltimateBearingCapacity",
     "VesicUltimateBearingCapacity",
     "UBCType",
     "create_ubc_4_all_soil_types",
@@ -34,9 +33,6 @@ class UBCType(AbstractStrEnum):
     the ultimate bearing capacity of soil.
     """
 
-    HANSEN = enum.auto()
-    """Hansen's method for calculating ultimate bearing capacity."""
-
     TERZAGHI = enum.auto()
     """Terzaghi's method for calculating ultimate bearing capacity."""
 
@@ -44,7 +40,18 @@ class UBCType(AbstractStrEnum):
     """Vesic's method for calculating ultimate bearing capacity."""
 
 
-@validate_func_args
+ubc_classes = {
+    UBCType.TERZAGHI: {
+        Shape.STRIP: TerzaghiUBC4StripFooting,
+        Shape.CIRCLE: TerzaghiUBC4CircularFooting,
+        Shape.SQUARE: TerzaghiUBC4SquareFooting,
+        Shape.RECTANGLE: TerzaghiUBC4RectangularFooting,
+    },
+    UBCType.VESIC: VesicUltimateBearingCapacity,
+}
+
+
+@validate_params
 def create_ubc_4_all_soil_types(
         friction_angle: float,
         cohesion: float,
@@ -54,7 +61,7 @@ def create_ubc_4_all_soil_types(
         length: Optional[float] = None,
         saturated_unit_wgt: float = 20.5,
         eccentricity: float = 0.0,
-        ground_water_level: Optional[float] = None,
+        ground_water_level: Optional[float] = inf,
         load_angle: float = 0.0,
         apply_local_shear: bool = False,
         shape: Shape | str = "square",
@@ -86,8 +93,8 @@ def create_ubc_4_all_soil_types(
     :raises ValidationError: Raised if ubc_type is not supported.
     :raises ValidationError: Raised if an invalid footing shape is
                              provided.
-    :raises ValueError: Raised when length is not provided for a
-                        rectangular footing.
+    :raises ValidationError: Raised when length is not provided for a
+                             rectangular footing.
     """
     ubc_type = UBCType(ubc_type)
 
@@ -102,9 +109,10 @@ def create_ubc_4_all_soil_types(
         ground_water_level=ground_water_level,
         shape=shape,
     )
+    ubc_class = ubc_classes[ubc_type]
 
-    ubc_class = _get_ultimate_bearing_capacity(ubc_type,
-                                               fnd_size.footing_shape)
+    if ubc_type == UBCType.TERZAGHI:
+        ubc_class = ubc_classes[ubc_type][fnd_size.footing_shape]
 
     return ubc_class(
         friction_angle=friction_angle,
@@ -114,21 +122,3 @@ def create_ubc_4_all_soil_types(
         foundation_size=fnd_size,
         apply_local_shear=apply_local_shear,
     )
-
-
-def _get_ultimate_bearing_capacity(ubc_type: UBCType, foundation_shape: Shape):
-    ubc_classes = {
-        UBCType.HANSEN: HansenUltimateBearingCapacity,
-        UBCType.TERZAGHI: {
-            Shape.STRIP: TerzaghiUBC4StripFooting,
-            Shape.CIRCLE: TerzaghiUBC4CircularFooting,
-            Shape.SQUARE: TerzaghiUBC4SquareFooting,
-            Shape.RECTANGLE: TerzaghiUBC4RectangularFooting,
-        },
-        UBCType.VESIC: VesicUltimateBearingCapacity,
-    }
-    if ubc_type == UBCType.TERZAGHI:
-        ubc_class = ubc_classes[ubc_type][foundation_shape]
-    else:
-        ubc_class = ubc_classes[ubc_type]
-    return ubc_class

{geolysis-0.12.0 → geolysis-0.14.0}/geolysis/bearing_capacity/ubc/_core.py

@@ -1,15 +1,15 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Annotated, Optional
+from typing import Annotated
 
 from func_validator import (
-    validate_func_args,
+    validate_params,
     MustBeNonNegative,
     MustBePositive,
 )
 
 from geolysis.foundation import Foundation
-from geolysis.utils import arctandeg, round_, tandeg
+from geolysis.utils import arctandeg, round_, tandeg, isinf
 
 
 @dataclass(frozen=True, slots=True)
@@ -80,14 +80,17 @@ class UltimateBearingCapacity(ABC):
         return self._friction_angle
 
     @friction_angle.setter
-    @validate_func_args
-    def friction_angle(self, val: Annotated[float, MustBeNonNegative]):
-        self._friction_angle = val
+    @validate_params
+    def friction_angle(
+        self,
+        friction_angle: Annotated[float, MustBeNonNegative],
+    ):
+        self._friction_angle = friction_angle
 
     @property
     def cohesion(self) -> float:
-        r"""Return cohesion for local shear in the case of local shear failure
-        or general shear in the case of general shear failure.
+        r"""Return cohesion for local shear in the case of local shear
+        failure or general shear in the case of general shear failure.
 
         In the case of local shear failure:
 
@@ -98,9 +101,9 @@ class UltimateBearingCapacity(ABC):
         return self._cohesion
 
     @cohesion.setter
-    @validate_func_args
-    def cohesion(self, val: Annotated[float, MustBeNonNegative]):
-        self._cohesion = val
+    @validate_params
+    def cohesion(self, cohesion: Annotated[float, MustBeNonNegative]):
+        self._cohesion = cohesion
 
     @property
     def moist_unit_wgt(self) -> float:
@@ -108,9 +111,9 @@ class UltimateBearingCapacity(ABC):
         return self._moist_unit_wgt
 
     @moist_unit_wgt.setter
-    @validate_func_args
-    def moist_unit_wgt(self, val: Annotated[float, MustBePositive]):
-        self._moist_unit_wgt = val
+    @validate_params
+    def moist_unit_wgt(self, moist_unit_wgt: Annotated[float, MustBePositive]):
+        self._moist_unit_wgt = moist_unit_wgt
 
     @property
     def saturated_unit_wgt(self) -> float:
@@ -118,9 +121,12 @@ class UltimateBearingCapacity(ABC):
         return self._saturated_unit_wgt
 
     @saturated_unit_wgt.setter
-    @validate_func_args
-    def saturated_unit_wgt(self, val: Annotated[float, MustBePositive]):
-        self._saturated_unit_wgt = val
+    @validate_params
+    def saturated_unit_wgt(
+        self,
+        saturated_unit_wgt: Annotated[float, MustBePositive],
+    ):
+        self._saturated_unit_wgt = saturated_unit_wgt
 
     @property
     def load_angle(self):
@@ -169,10 +175,10 @@ class UltimateBearingCapacity(ABC):
     def _surcharge_term(self) -> float:
         depth = self.foundation_size.depth
         water_level = self.foundation_size.ground_water_level
-
         unit_wgt = self.moist_unit_wgt
         eop = unit_wgt * depth
-        if water_level is not None:
+
+        if not isinf(water_level):
             if water_level < depth:
                 d_1 = water_level
                 d_2 = depth - d_1
@@ -218,7 +224,6 @@ class UltimateBearingCapacity(ABC):
         intermediate calculations.
 
         !!! info "Added in v0.11.0"
-
         """
         return UltimateBearingCapacityResult(
             ultimate_bearing_capacity=self.ultimate_bearing_capacity(),

{geolysis-0.12.0 → geolysis-0.14.0}/geolysis/bearing_capacity/ubc/_terzaghi_ubc.py

@@ -100,6 +100,23 @@ class TerzaghiUBC4CircularFooting(TerzaghiUltimateBearingCapacity):
         )
 
 
+class TerzaghiUBC4SquareFooting(TerzaghiUltimateBearingCapacity):
+    """Ultimate bearing capacity for square footing according to
+    `Terzaghi 1943``.
+
+    See [implementation](../formulas/ultimate-bearing-capacity.md/#terzaghi-bearing-capacity-for-square-footing)
+    for more details on bearing capacity equation used.
+    """
+
+    def _bearing_capacity(self):
+        """Calcalates ultimate bearing capacity for square footing."""
+        return (
+            self._cohesion_term(1.3)
+            + self._surcharge_term()
+            + self._embedment_term(0.4)
+        )
+
+
 class TerzaghiUBC4RectangularFooting(TerzaghiUltimateBearingCapacity):
     r"""Ultimate bearing capacity for rectangular footing according to
     `Terzaghi 1943`.
@@ -121,16 +138,3 @@ class TerzaghiUBC4RectangularFooting(TerzaghiUltimateBearingCapacity):
             + self._surcharge_term()
             + self._embedment_term(emb_coef)
         )
-
-
-class TerzaghiUBC4SquareFooting(TerzaghiUBC4RectangularFooting):
-    """Ultimate bearing capacity for square footing according to
-    `Terzaghi 1943``.
-
-    See [implementation](../formulas/ultimate-bearing-capacity.md/#terzaghi-bearing-capacity-for-square-footing)
-    for more details on bearing capacity equation used.
-    """
-
-    def _bearing_capacity(self):
-        """Calcalates ultimate bearing capacity for square footing."""
-        return super()._bearing_capacity()

{geolysis-0.12.0 → geolysis-0.14.0}/geolysis/bearing_capacity/ubc/_vesic_ubc.py

@@ -1,7 +1,16 @@
 from geolysis.foundation import Shape
-from geolysis.utils import isclose, round_, sindeg, tandeg, atan, add_repr
+from geolysis.utils import (
+    isclose,
+    round_,
+    sindeg,
+    tandeg,
+    atan,
+    add_repr,
+    cotdeg,
+    exp,
+    pi,
+)
 from ._core import UltimateBearingCapacity
-from ._hansen_ubc import HansenBearingCapacityFactors
 
 __all__ = ["VesicUltimateBearingCapacity"]
 
@@ -11,12 +20,18 @@ class VesicBearingCapacityFactors:
     @staticmethod
     @round_(ndigits=2)
     def n_c(friction_angle: float) -> float:
-        return HansenBearingCapacityFactors.n_c(friction_angle)
+        if isclose(friction_angle, 0.0):
+            return 5.14
+        return cotdeg(friction_angle) * (
+            VesicBearingCapacityFactors.n_q(friction_angle) - 1.0
+        )
 
     @staticmethod
     @round_(ndigits=2)
     def n_q(friction_angle: float) -> float:
-        return HansenBearingCapacityFactors.n_q(friction_angle)
+        return tandeg(45.0 + friction_angle / 2.0) ** 2.0 * exp(
+            pi * tandeg(friction_angle)
+        )
 
     @staticmethod
     @round_(ndigits=2)