geolysis 0.5.0__tar.gz → 0.6.1__tar.gz

{geolysis-0.5.0 → geolysis-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geolysis
-Version: 0.5.0
+Version: 0.6.1
 Summary: geolysis is an opensource software for geotechnical engineering analysis and modeling.
 Author-email: Patrick Boateng <boatengpato.pb@gmail.com>
 License: MIT License

{geolysis-0.5.0 → geolysis-0.6.1}/geolysis/__init__.py

@@ -1,5 +1,5 @@
 from . import foundation, soil_classifier, spt
 
-__version__ = "0.5.0"
+__version__ = "0.6.1"
 
 __all__ = ["foundation", "soil_classifier", "spt"]

{geolysis-0.5.0 → geolysis-0.6.1}/geolysis/bearing_capacity/abc/cohl/__init__.py

@@ -1,28 +1,12 @@
-""" Allowable bearing capacity package for cohesionless soils.
-
-Enums
-=====
-
-.. autosummary::
-    :toctree: _autosummary
-    :nosignatures:
-
-    ABCType
-
-Functions
-=========
-
-.. autosummary::
-    :toctree: _autosummary
-
-    create_allowable_bearing_capacity
+"""This package provides a factory function and utilities for creating 
+allowable bearing capacity calculations using methods like Bowles, Meyerhof, 
+and Terzaghi for various foundation types and shapes.
 """
-
 import enum
 from typing import Optional
 
 from geolysis.foundation import FoundationType, Shape, create_foundation
-from geolysis.utils import enum_repr, inf
+from geolysis.utils import ErrorMsg, enum_repr, inf
 
 from ._core import AllowableBearingCapacity
 from .bowles_abc import BowlesABC4MatFoundation, BowlesABC4PadFoundation
@@ -79,14 +63,14 @@ def create_allowable_bearing_capacity(corrected_spt_n_value: float,
     :type ground_water_level: float, optional
 
     :param shape: Shape of foundation footing, defaults to
-                  :attr:`~geolysis.foundation.Shape.SQUARE`.
+                  :py:enum:mem:`~geolysis.foundation.Shape.SQUARE`.
     :type shape: str, optional
 
     :param foundation_type: Type of foundation, defaults to "pad".
     :type foundation_type: FoundationType | str, optional
 
     :param abc_type: Type of allowable bearing capacity calculation to apply.
-                     Available values can be found in :class:`ABCType`,
+                     Available values can be found in :py:enum:`ABCType`,
                      defaults to None.
     :type abc_type:  ABCType | str, optional
 
@@ -96,8 +80,10 @@ def create_allowable_bearing_capacity(corrected_spt_n_value: float,
                         footing.
     :raises ValueError: Raised if an invalid footing ``shape`` is provided.
     """
-    msg = (f"{abc_type=} is not supported, Supported "
-           f"types are: {list(ABCType)}")
+
+    msg = ErrorMsg(param_name="abc_type",
+                   param_value=abc_type,
+                   param_type=ABCType)
 
     if abc_type is None:
         raise ValueError(msg)
@@ -107,12 +93,12 @@ def create_allowable_bearing_capacity(corrected_spt_n_value: float,
     except ValueError as e:
         raise ValueError(msg) from e
 
-    msg = (f"{foundation_type=} is not supported, Supported "
-           f"types are: {list(FoundationType)}")
-
     try:
         foundation_type = FoundationType(str(foundation_type).casefold())
     except ValueError as e:
+        msg = ErrorMsg(param_name="foundation_type",
+                       param_value=foundation_type,
+                       param_type=FoundationType)
         raise ValueError(msg) from e
 
     # exception from create_foundation will automaatically propagate

{geolysis-0.5.0 → geolysis-0.6.1}/geolysis/bearing_capacity/abc/cohl/_core.py

@@ -33,7 +33,7 @@ class AllowableBearingCapacity(ABC):
 
     @property
     def tol_settlement(self) -> float:
-        """Tolerable settlement foundation (mm)."""
+        """Tolerable settlement of foundation (mm)."""
         return self._tol_settlement
 
     @tol_settlement.setter

{geolysis-0.5.0 → geolysis-0.6.1}/geolysis/bearing_capacity/abc/cohl/bowles_abc.py

@@ -1,14 +1,3 @@
-""" Bowles allowable bearing capacity.
-
-Classes
-=======
-
-.. autosummary::
-    :toctree: _autosummary
-
-    BowlesABC4PadFoundation
-    BowlesABC4MatFoundation
-"""
 from geolysis.foundation import FoundationSize
 from geolysis.utils import round_
 
@@ -63,7 +52,7 @@ class BowlesABC4PadFoundation(AllowableBearingCapacity):
                          tol_settlement=tol_settlement,
                          foundation_size=foundation_size)
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self) -> float:
         """Calculate the allowable bearing capacity of the pad foundation."""
         n_corr = self.corrected_spt_n_value
@@ -100,7 +89,7 @@ class BowlesABC4MatFoundation(BowlesABC4PadFoundation):
     ===================  ======================================  ===========
     """
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self) -> float:
         """Calculate the allowable bearing capacity of the mat foundation."""
         n_corr = self.corrected_spt_n_value

{geolysis-0.5.0 → geolysis-0.6.1}/geolysis/bearing_capacity/abc/cohl/meyerhof_abc.py

@@ -1,14 +1,3 @@
-""" Meyerhof allowable bearing capacity.
-
-Classes
-=======
-
-.. autosummary::
-    :toctree: _autosummary
-
-    MeyerhofABC4PadFoundation
-    MeyerhofABC4MatFoundation
-"""
 from geolysis.foundation import FoundationSize
 from geolysis.utils import round_
 
@@ -63,7 +52,7 @@ class MeyerhofABC4PadFoundation(AllowableBearingCapacity):
                          tol_settlement=tol_settlement,
                          foundation_size=foundation_size)
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self):
         """Calculates the allowable bearing capacity of the pad foundation."""
         n_corr = self.corrected_spt_n_value
@@ -100,7 +89,7 @@ class MeyerhofABC4MatFoundation(MeyerhofABC4PadFoundation):
     ===================  ======================================  ===========
     """
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self):
         """Calculate the allowable bearing capacity of the mat foundation."""
         n_corr = self.corrected_spt_n_value

{geolysis-0.5.0 → geolysis-0.6.1}/geolysis/bearing_capacity/abc/cohl/terzaghi_abc.py

@@ -1,14 +1,3 @@
-"""Terzaghi allowable bearing capacity.
-
-Classes
-=======
-
-.. autosummary::
-    :toctree: _autosummary
-
-    TerzaghiABC4PadFoundation
-    TerzaghiABC4MatFoundation
-"""
 from geolysis.foundation import FoundationSize
 from geolysis.utils import round_
 
@@ -92,7 +81,7 @@ class TerzaghiABC4PadFoundation(AllowableBearingCapacity):
 
         return min(cw, 2.0)
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self):
         """Calculates the allowable bearing capacity of the pad foundation."""
         n_corr = self.corrected_spt_n_value
@@ -135,7 +124,7 @@ class TerzaghiABC4MatFoundation(TerzaghiABC4PadFoundation):
     ===================  ======================================  ===========
     """
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self):
         """Calculates the allowable bearing capacity of the mat foundation."""
         n_corr = self.corrected_spt_n_value

{geolysis-0.5.0 → geolysis-0.6.1}/geolysis/bearing_capacity/ubc/__init__.py

@@ -1,27 +1,13 @@
-""" Ultimate bearing capacity estimation package
-
-Enum
-====
-
-.. autosummary::
-    :toctree: _autosummary
-    :nosignatures:
-
-    UBCType
-
-Functions
-=========
-
-.. autosummary::
-    :toctree: _autosummary
-
-    create_ultimate_bearing_capacity
+""" 
+This package provides a factory function and utilities for creating ultimate 
+bearing capacity calculations using methods like Hansen, Terzaghi, and Vesic 
+for various foundation shapes.
 """
 import enum
 from typing import Optional
 
 from geolysis.foundation import Shape, create_foundation
-from geolysis.utils import enum_repr
+from geolysis.utils import ErrorMsg, enum_repr
 
 from ._core import UltimateBearingCapacity
 from .hansen_ubc import HansenUltimateBearingCapacity
@@ -118,8 +104,10 @@ def create_ultimate_bearing_capacity(friction_angle: float,
                         footing.
     :raises ValueError: Raised if an invalid footing shape is provided.
     """
-    msg = (f"{ubc_type=} is not supported, Supported "
-           f"types are: {list(UBCType)}")
+
+    msg = ErrorMsg(param_name="ubc_type",
+                   param_value=ubc_type,
+                   param_type=UBCType)
 
     if ubc_type is None:
         raise ValueError(msg)

{geolysis-0.5.0 → geolysis-0.6.1}/geolysis/bearing_capacity/ubc/_core.py

@@ -43,11 +43,20 @@ class UltimateBearingCapacity(ABC):
 
     @property
     def friction_angle(self) -> float:
-        """Return friction angle for local shear in the case of local shear
+        r"""Return friction angle for local shear in the case of local shear
         failure or general shear in the case of general shear failure.
+
+        :Equation:
+
+        In the case of local shear failure:
+
+        .. math::
+
+           \phi' = \tan^{-1} \left(\frac{2}{3} \tan \phi\right)
+
         """
         if self.apply_local_shear:
-            return arctan((2 / 3) * tan(self._friction_angle))
+            return arctan((2.0 / 3.0) * tan(self._friction_angle))
         return self._friction_angle
 
     @friction_angle.setter
@@ -57,8 +66,16 @@ class UltimateBearingCapacity(ABC):
 
     @property
     def cohesion(self) -> float:
-        """Return cohesion for local shear in the case of local 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.
+
+        :Equation:
+
+        In the case of local shear failure:
+
+        .. math::
+
+            C^{'} = \dfrac{2}{3} \cdot C
         """
         if self.apply_local_shear:
             return (2.0 / 3.0) * self._cohesion
@@ -169,8 +186,8 @@ class UltimateBearingCapacity(ABC):
         return (coef * self.moist_unit_wgt * width * self.n_gamma
                 * self.s_gamma * self.d_gamma * self.i_gamma * water_corr)
 
-    @round_
-    def bearing_capacity(self):
+    @round_(ndigits=2)
+    def bearing_capacity(self) -> float:
         """Calculates the ultimate bearing capacity."""
         return (self._cohesion_term(1.0)
                 + self._surcharge_term()

{geolysis-0.5.0 → geolysis-0.6.1}/geolysis/bearing_capacity/ubc/hansen_ubc.py

@@ -1,13 +1,3 @@
-""" Hansen ultimate bearing capacity module.
-
-Classes
-=======
-
-.. autosummary::
-    :toctree: _autosummary
-
-    HansenUltimateBearingCapacity
-"""
 from geolysis.foundation import Shape
 from geolysis.utils import cos, cot, exp, isclose, pi, round_, sin, tan
 
@@ -16,25 +6,25 @@ from ._core import UltimateBearingCapacity
 __all__ = ["HansenUltimateBearingCapacity"]
 
 
-@round_
+@round_(ndigits=2)
 def n_c(friction_angle: float) -> float:
     if isclose(friction_angle, 0.0):
         return 5.14
     return cot(friction_angle) * (n_q(friction_angle) - 1.0)
 
 
-@round_
+@round_(ndigits=2)
 def n_q(friction_angle: float) -> float:
     return (tan(45.0 + friction_angle / 2.0) ** 2.0
             * exp(pi * tan(friction_angle)))
 
 
-@round_
+@round_(ndigits=2)
 def n_gamma(friction_angle: float) -> float:
     return 1.8 * (n_q(friction_angle) - 1.0) * tan(friction_angle)
 
 
-@round_
+@round_(ndigits=2)
 def s_c(f_width: float, f_length: float, f_shape: Shape) -> float:
     if f_shape == Shape.STRIP:
         return 1.0
@@ -44,7 +34,7 @@ def s_c(f_width: float, f_length: float, f_shape: Shape) -> float:
         return 1.3
 
 
-@round_
+@round_(ndigits=2)
 def s_q(f_width: float, f_length: float, f_shape: Shape) -> float:
     if f_shape == Shape.STRIP:
         return 1.0
@@ -54,7 +44,7 @@ def s_q(f_width: float, f_length: float, f_shape: Shape) -> float:
         return 1.2
 
 
-@round_
+@round_(ndigits=2)
 def s_gamma(f_width: float, f_length: float, f_shape: Shape) -> float:
     if f_shape == Shape.STRIP:
         return 1.0
@@ -66,22 +56,22 @@ def s_gamma(f_width: float, f_length: float, f_shape: Shape) -> float:
         return 0.6
 
 
-@round_
+@round_(ndigits=2)
 def d_c(f_depth: float, f_width: float) -> float:
     return 1.0 + 0.35 * f_depth / f_width
 
 
-@round_
+@round_(ndigits=2)
 def d_q(f_depth: float, f_width: float) -> float:
     return d_c(f_depth, f_width)
 
 
-@round_
+@round_(ndigits=2)
 def d_gamma() -> float:
     return 1.0
 
 
-@round_
+@round_(ndigits=2)
 def i_c(cohesion: float,
         load_angle: float,
         f_width: float,
@@ -89,12 +79,12 @@ def i_c(cohesion: float,
     return 1.0 - sin(load_angle) / (2.0 * cohesion * f_width * f_length)
 
 
-@round_
+@round_(ndigits=2)
 def i_q(load_angle: float) -> float:
     return 1.0 - (1.5 * sin(load_angle)) / cos(load_angle)
 
 
-@round_
+@round_(ndigits=2)
 def i_gamma(load_angle: float) -> float:
     return i_q(load_angle) ** 2.0
 

{geolysis-0.5.0 → geolysis-0.6.1}/geolysis/bearing_capacity/ubc/terzaghi_ubc.py

@@ -1,16 +1,3 @@
-""" Terzaghi ultimate bearing capacity module.
-
-Classes
-=======
-
-.. autosummary::
-    :toctree: _autosummary
-
-    TerzaghiUBC4StripFooting
-    TerzaghiUBC4CircularFooting
-    TerzaghiUBC4SquareFooting
-    TerzaghiUBC4RectangularFooting
-"""
 from abc import ABC
 
 from geolysis.utils import cos, cot, deg2rad, exp, isclose, pi, round_, tan
@@ -23,21 +10,21 @@ __all__ = ["TerzaghiUBC4StripFooting",
            "TerzaghiUBC4RectangularFooting"]
 
 
-@round_
+@round_(ndigits=2)
 def n_c(friction_angle: float) -> float:
     if isclose(friction_angle, 0.0):
         return 5.7
     return cot(friction_angle) * (n_q(friction_angle) - 1.0)
 
 
-@round_
+@round_(ndigits=2)
 def n_q(friction_angle: float) -> float:
     return (exp((3.0 * pi / 2.0 - deg2rad(friction_angle))
                 * tan(friction_angle))
             / (2.0 * (cos(45.0 + friction_angle / 2.0)) ** 2.0))
 
 
-@round_
+@round_(ndigits=2)
 def n_gamma(friction_angle: float) -> float:
     return (n_q(friction_angle) - 1.0) * tan(1.4 * friction_angle)
 
@@ -113,7 +100,7 @@ class TerzaghiUBC4StripFooting(TerzaghiUltimateBearingCapacity):
          - —
     """
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self) -> float:
         """Calculates ultimate bearing capacity for strip footing."""
         return (self._cohesion_term(1.0)
@@ -156,7 +143,7 @@ class TerzaghiUBC4CircularFooting(TerzaghiUltimateBearingCapacity):
          - —
     """
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self) -> float:
         """Calculates ultimate bearing capacity for circular footing."""
         return (self._cohesion_term(1.3)
@@ -205,7 +192,7 @@ class TerzaghiUBC4RectangularFooting(TerzaghiUltimateBearingCapacity):
          - —
     """
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self) -> float:
         """Calculates ultimate bearing capacity for rectangular footing."""
         width = self.foundation_size.width

{geolysis-0.5.0 → geolysis-0.6.1}/geolysis/bearing_capacity/ubc/vesic_ubc.py

@@ -1,13 +1,3 @@
-"""Vesic ultimate bearing capacity module.
-
-Classes
-=======
-
-.. autosummary::
-    :toctree: _autosummary
-
-    VesicUltimateBearingCapacity
-"""
 from geolysis.foundation import Shape
 from geolysis.utils import isclose, round_, sin, tan
 
@@ -17,22 +7,22 @@ from ._core import UltimateBearingCapacity
 __all__ = ["VesicUltimateBearingCapacity"]
 
 
-@round_
+@round_(ndigits=2)
 def n_c(friction_angle: float) -> float:
     return hansen_ubc.n_c(friction_angle)
 
 
-@round_
+@round_(ndigits=2)
 def n_q(friction_angle: float) -> float:
     return hansen_ubc.n_q(friction_angle)
 
 
-@round_
+@round_(ndigits=2)
 def n_gamma(friction_angle: float) -> float:
     return 2.0 * (n_q(friction_angle) + 1.0) * tan(friction_angle)
 
 
-@round_
+@round_(ndigits=2)
 def s_c(friction_angle: float,
         f_width: float,
         f_length: float,
@@ -48,7 +38,7 @@ def s_c(friction_angle: float,
         return 1.0 + (_n_q / _n_c)
 
 
-@round_
+@round_(ndigits=2)
 def s_q(friction_angle: float,
         f_width: float,
         f_length: float,
@@ -61,7 +51,7 @@ def s_q(friction_angle: float,
         return 1.0 + tan(friction_angle)
 
 
-@round_
+@round_(ndigits=2)
 def s_gamma(f_width: float, f_length: float, f_shape: Shape) -> float:
     if f_shape == Shape.STRIP:
         return 1.0
@@ -71,34 +61,34 @@ def s_gamma(f_width: float, f_length: float, f_shape: Shape) -> float:
         return 0.6
 
 
-@round_
+@round_(ndigits=2)
 def d_c(f_depth: float, f_width: float) -> float:
     return 1.0 + 0.4 * f_depth / f_width
 
 
-@round_
+@round_(ndigits=2)
 def d_q(friction_angle: float, f_depth: float, f_width: float) -> float:
     return (1.0 + 2.0 * tan(friction_angle)
             * (1.0 - sin(friction_angle)) ** 2.0
             * (f_depth / f_width))
 
 
-@round_
+@round_(ndigits=2)
 def d_gamma() -> float:
     return 1.0
 
 
-@round_
+@round_(ndigits=2)
 def i_c(load_angle: float) -> float:
     return (1.0 - load_angle / 90.0) ** 2.0
 
 
-@round_
+@round_(ndigits=2)
 def i_q(load_angle: float) -> float:
     return i_c(load_angle)
 
 
-@round_
+@round_(ndigits=2)
 def i_gamma(friction_angle: float, load_angle: float) -> float:
     if isclose(friction_angle, 0.0):
         return 1.0