geolysis 0.9.0__py3-none-any.whl → 0.10.1__py3-none-any.whl

geolysis/bearing_capacity/ubc/_hansen_ubc.py

@@ -0,0 +1,271 @@
+from geolysis.foundation import Shape
+from geolysis.utils import cos, cot, exp, isclose, pi, round_, sin, tan
+
+from ._core import UltimateBearingCapacity
+
+__all__ = ["HansenUltimateBearingCapacity"]
+
+
+class HansenBearingCapacityFactors:
+
+    @staticmethod
+    @round_(ndigits=2)
+    def n_c(friction_angle: float) -> float:
+        if isclose(friction_angle, 0.0):
+            return 5.14
+        return cot(friction_angle) * (
+            HansenBearingCapacityFactors.n_q(friction_angle) - 1.0
+        )
+
+    @staticmethod
+    @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))
+
+    @staticmethod
+    @round_(ndigits=2)
+    def n_gamma(friction_angle: float) -> float:
+        return (
+            1.8
+            * (HansenBearingCapacityFactors.n_q(friction_angle) - 1.0)
+            * tan(friction_angle)
+        )
+
+
+class HansenShapeFactors:
+
+    @staticmethod
+    @round_(ndigits=2)
+    def s_c(f_width: float, f_length: float, f_shape: Shape) -> float:
+        if f_shape == Shape.STRIP:
+            return 1.0
+        elif f_shape == Shape.RECTANGLE:
+            return 1.0 + 0.2 * f_width / f_length
+        else:  # SQUARE & CIRCLE
+            return 1.3
+
+    @staticmethod
+    @round_(ndigits=2)
+    def s_q(f_width: float, f_length: float, f_shape: Shape) -> float:
+        if f_shape == Shape.STRIP:
+            return 1.0
+        elif f_shape == Shape.RECTANGLE:
+            return 1.0 + 0.2 * f_width / f_length
+        else:  # SQUARE & CIRCLE
+            return 1.2
+
+    @staticmethod
+    @round_(ndigits=2)
+    def s_gamma(f_width: float, f_length: float, f_shape: Shape) -> float:
+        if f_shape == Shape.STRIP:
+            return 1.0
+        elif f_shape == Shape.RECTANGLE:
+            return 1.0 - 0.4 * f_width / f_length
+        elif f_shape == Shape.SQUARE:
+            return 0.8
+        else:  # CIRCLE
+            return 0.6
+
+
+class HansenDepthFactors:
+
+    @staticmethod
+    @round_(ndigits=2)
+    def d_c(f_depth: float, f_width: float) -> float:
+        return 1.0 + 0.35 * f_depth / f_width
+
+    @staticmethod
+    @round_(ndigits=2)
+    def d_q(f_depth: float, f_width: float) -> float:
+        return HansenDepthFactors.d_c(f_depth, f_width)
+
+    @staticmethod
+    @round_(ndigits=2)
+    def d_gamma() -> float:
+        return 1.0
+
+
+class HansenInclinationFactors:
+
+    @staticmethod
+    @round_(ndigits=2)
+    def i_c(
+        cohesion: float,
+        load_angle: float,
+        f_width: float,
+        f_length: float,
+    ) -> float:
+        return 1.0 - sin(load_angle) / (2.0 * cohesion * f_width * f_length)
+
+    @staticmethod
+    @round_(ndigits=2)
+    def i_q(load_angle: float) -> float:
+        return 1.0 - (1.5 * sin(load_angle)) / cos(load_angle)
+
+    @staticmethod
+    @round_(ndigits=2)
+    def i_gamma(load_angle: float) -> float:
+        return HansenInclinationFactors.i_q(load_angle) ** 2.0
+
+
+class HansenUltimateBearingCapacity(UltimateBearingCapacity):
+    r"""Ultimate bearing capacity for soils according to `Hansen (1961)`."""
+
+    @property
+    def n_c(self) -> float:
+        r"""Bearing capacity factor $N_c$.
+
+        $$
+        N_c = \cot(\phi) \left(N_q - 1\right)
+        $$
+        """
+        return HansenBearingCapacityFactors.n_c(self.friction_angle)
+
+    @property
+    def n_q(self) -> float:
+        r"""Bearing capacity factor $N_q$.
+
+        $$
+        N_q = \tan^2\left(45 + \frac{\phi}{2}\right) \cdot e^{\pi \tan(\phi)}
+        $$
+        """
+        return HansenBearingCapacityFactors.n_q(self.friction_angle)
+
+    @property
+    def n_gamma(self) -> float:
+        r"""Bearing capacity factor $N_{\gamma}$.
+
+        $$
+        N_{\gamma} = 1.8 \left(N_q - 1\right) \tan(\phi)
+        $$
+        """
+        return HansenBearingCapacityFactors.n_gamma(self.friction_angle)
+
+    @property
+    def s_c(self) -> float:
+        r"""Shape factor $S_c$.
+
+        $$
+        s_c = 1.0 \rightarrow \text{Strip footing}
+        $$
+
+        $$
+        s_c = 1.0 + 0.2 \frac{B}{L} \rightarrow \text{Rectangular footing}
+        $$
+
+        $$
+        s_c = 1.3 \rightarrow \text{Square or circular footing}
+        $$
+        """
+        width, length, shape = self.foundation_size.footing_params()
+        return HansenShapeFactors.s_c(width, length, shape)
+
+    @property
+    def s_q(self) -> float:
+        r"""Shape factor $S_q$.
+
+        $$
+        s_q = 1.0 \rightarrow \text{Strip footing}
+        $$
+
+        $$
+        s_q = 1.0 + 0.2 \cdot \frac{B}{L} \rightarrow \text{Rectangular footing}
+        $$
+
+        $$
+        s_q = 1.2 \rightarrow \text{Square or circular footing}
+        $$
+        """
+        width, length, shape = self.foundation_size.footing_params()
+        return HansenShapeFactors.s_q(width, length, shape)
+
+    @property
+    def s_gamma(self) -> float:
+        r"""Shape factor $S_{\gamma}$.
+
+        $$
+        s_{\gamma} = 1.0 \rightarrow \text{Strip footing}
+        $$
+
+        $$
+        s_{\gamma} = 1.0 - 0.4 \frac{B}{L} \rightarrow
+                      \text{Rectangular footing}
+        $$
+
+        $$
+        s_{\gamma} = 0.8 \rightarrow \text{Square footing}
+        $$
+
+        $$
+        s_{\gamma} = 0.6 \rightarrow \text{Circular footing}
+        $$
+        """
+        width, length, shape = self.foundation_size.footing_params()
+        return HansenShapeFactors.s_gamma(width, length, shape)
+
+    @property
+    def d_c(self) -> float:
+        r"""Depth factor $D_c$.
+
+        $$
+        d_c = 1.0 + 0.35 \cdot \frac{D_f}{B}
+        $$
+        """
+        depth = self.foundation_size.depth
+        width = self.foundation_size.width
+        return HansenDepthFactors.d_c(depth, width)
+
+    @property
+    def d_q(self) -> float:
+        r"""Depth factor $D_q$.
+
+        $$
+        d_q = 1.0 + 0.35 \cdot \frac{D_f}{B}
+        $$
+        """
+        depth = self.foundation_size.depth
+        width = self.foundation_size.width
+        return HansenDepthFactors.d_q(depth, width)
+
+    @property
+    def d_gamma(self) -> float:
+        r"""Depth factor $D_{\gamma}$.
+
+        $$
+        d_{\gamma} = 1.0
+        $$
+        """
+        return HansenDepthFactors.d_gamma()
+
+    @property
+    def i_c(self) -> float:
+        r"""Inclination factor $I_c$.
+
+        $$
+        I_c = 1 - \frac{\sin(\alpha)}{2cBL}
+        $$
+        """
+        width, length = self.foundation_size.width, self.foundation_size.length
+        return HansenInclinationFactors.i_c(
+            self.cohesion, self.load_angle, width, length
+        )
+
+    @property
+    def i_q(self) -> float:
+        r"""Inclination factor $I_q$.
+
+        $$
+        I_q = 1 - \frac{1.5 \sin(\alpha)}{\cos(\alpha)}
+        $$
+        """
+        return HansenInclinationFactors.i_q(self.load_angle)
+
+    @property
+    def i_gamma(self) -> float:
+        r"""Inclination factor $I_{\gamma}$.
+
+        $$
+        I_{\gamma} = I_q^2
+        $$
+        """
+        return HansenInclinationFactors.i_gamma(self.load_angle)

geolysis/bearing_capacity/ubc/_terzaghi_ubc.py

@@ -0,0 +1,178 @@
+from abc import ABC
+
+from geolysis.utils import cos, cot, deg2rad, exp, isclose, pi, round_, tan
+from ._core import UltimateBearingCapacity
+
+__all__ = [
+    "TerzaghiUBC4StripFooting",
+    "TerzaghiUBC4CircularFooting",
+    "TerzaghiUBC4SquareFooting",
+    "TerzaghiUBC4RectangularFooting",
+]
+
+from geolysis.foundation import Foundation
+
+
+class TerzaghiBearingCapacityFactors:
+
+    @staticmethod
+    @round_(ndigits=2)
+    def n_c(friction_angle: float) -> float:
+        if isclose(friction_angle, 0.0):
+            return 5.7
+        return cot(friction_angle) * (
+                TerzaghiBearingCapacityFactors.n_q(friction_angle) - 1.0
+        )
+
+    @staticmethod
+    @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
+        )
+
+    @staticmethod
+    @round_(ndigits=2)
+    def n_gamma(friction_angle: float) -> float:
+        return (TerzaghiBearingCapacityFactors.n_q(
+            friction_angle) - 1.0) * tan(
+            1.4 * friction_angle
+        )
+
+
+class TerzaghiUltimateBearingCapacity(UltimateBearingCapacity, ABC):
+
+    def __init__(
+            self,
+            friction_angle: float,
+            cohesion: float,
+            moist_unit_wgt: float,
+            foundation_size: Foundation,
+            apply_local_shear: bool = False,
+    ) -> None:
+        r"""
+
+        - $q_u$ (kPa): Ultimate bearing capacity
+        - $c$ (kPa): Cohesion of soil
+        - $q$ (kPa): Overburden pressure of soil
+        - $\gamma$ (kN/m³): Unit weight of soil
+        - $B$ (m): Width of foundation footing
+        - $L$ (m): Length of foundation footing
+        - $N_c$, $N_q$, $N_{\gamma}$: Bearing capacity factors
+
+
+        :param friction_angle: Internal angle of friction for general
+                               shear failure (degrees).
+        :param cohesion: Cohesion of soil ($kPa$).
+        :param moist_unit_wgt: Moist unit weight of soil ($kN/m^3$).
+        :param foundation_size: Size of the foundation.
+        :param apply_local_shear: Indicate whether bearing capacity
+                                  failure is general shear or local
+                                  shear failure.
+        """
+        super().__init__(
+            friction_angle=friction_angle,
+            cohesion=cohesion,
+            moist_unit_wgt=moist_unit_wgt,
+            foundation_size=foundation_size,
+            apply_local_shear=apply_local_shear,
+        )
+
+    @property
+    def n_c(self) -> float:
+        r"""Bearing capacity factor $N_c$.
+
+        $$N_c = \cot(\phi) \cdot (N_q - 1)$$
+        """
+        return TerzaghiBearingCapacityFactors.n_c(self.friction_angle)
+
+    @property
+    def n_q(self) -> float:
+        r"""Bearing capacity factor $N_q$.
+
+        $$
+        N_q = \dfrac{e^{(\frac{3\pi}{2} - \phi)\tan\phi}}
+                    {2\cos^2(45 + \frac{\phi}{2})}
+        $$
+        """
+        return TerzaghiBearingCapacityFactors.n_q(self.friction_angle)
+
+    @property
+    def n_gamma(self) -> float:
+        r"""Bearing capacity factor $N_{\gamma}$.
+
+        $$N_{\gamma} =  (N_q - 1) \cdot \tan(1.4\phi)$$
+        """
+        return TerzaghiBearingCapacityFactors.n_gamma(self.friction_angle)
+
+
+class TerzaghiUBC4StripFooting(TerzaghiUltimateBearingCapacity):
+    r"""Ultimate bearing capacity for strip footing according to
+    `Terzaghi 1943`.
+
+    $$q_u = cN_c + qN_q + 0.5 \gamma BN_{\gamma}$$
+    """
+
+    @round_(ndigits=2)
+    def bearing_capacity(self) -> float:
+        """Calculates ultimate bearing capacity for strip footing."""
+        return (
+                self._cohesion_term(1.0)
+                + self._surcharge_term()
+                + self._embedment_term(0.5)
+        )
+
+
+class TerzaghiUBC4CircularFooting(TerzaghiUltimateBearingCapacity):
+    r"""Ultimate bearing capacity for circular footing according to
+    `Terzaghi 1943`.
+
+    $$q_u = 1.3cN_c + qN_q + 0.3 \gamma BN_{\gamma}$$
+    """
+
+    @round_(ndigits=2)
+    def bearing_capacity(self) -> float:
+        """Calculates ultimate bearing capacity for circular footing."""
+        return (
+                self._cohesion_term(1.3)
+                + self._surcharge_term()
+                + self._embedment_term(0.3)
+        )
+
+
+class TerzaghiUBC4RectangularFooting(TerzaghiUltimateBearingCapacity):
+    r"""Ultimate bearing capacity for rectangular footing according to
+    `Terzaghi 1943`.
+
+    $$
+    q_u = \left(1 + 0.3 \dfrac{B}{L} \right) c N_c + qN_q
+          + \left(1 - 0.2 \dfrac{B}{L} \right) 0.5 B \gamma N_{\gamma}
+    $$
+    """
+
+    @round_(ndigits=2)
+    def bearing_capacity(self) -> float:
+        """Calculates ultimate bearing capacity for rectangular footing."""
+        width = self.foundation_size.width
+        length = self.foundation_size.length
+        coh_coef = 1.0 + 0.3 * (width / length)
+        emb_coef = (1.0 - 0.2 * (width / length)) / 2.0
+
+        return (
+                self._cohesion_term(coh_coef)
+                + self._surcharge_term()
+                + self._embedment_term(emb_coef)
+        )
+
+
+class TerzaghiUBC4SquareFooting(TerzaghiUBC4RectangularFooting):
+    r"""Ultimate bearing capacity for square footing according to
+    `Terzaghi 1943``.
+
+    $$q_u = 1.3cN_c + qN_q + 0.4 \gamma BN_{\gamma}$$
+    """
+
+    def bearing_capacity(self):
+        """Calcalates ultimate bearing capacity for square footing."""
+        return super().bearing_capacity()

geolysis/bearing_capacity/ubc/_vesic_ubc.py

@@ -0,0 +1,253 @@
+from geolysis.foundation import Shape
+from geolysis.utils import isclose, round_, sin, tan
+from ._core import UltimateBearingCapacity
+from ._hansen_ubc import HansenBearingCapacityFactors
+
+__all__ = ["VesicUltimateBearingCapacity"]
+
+
+class VesicBearingCapacityFactors:
+
+    @staticmethod
+    @round_(ndigits=2)
+    def n_c(friction_angle: float) -> float:
+        return HansenBearingCapacityFactors.n_c(friction_angle)
+
+    @staticmethod
+    @round_(ndigits=2)
+    def n_q(friction_angle: float) -> float:
+        return HansenBearingCapacityFactors.n_q(friction_angle)
+
+    @staticmethod
+    @round_(ndigits=2)
+    def n_gamma(friction_angle: float) -> float:
+        return (
+            2.0
+            * (VesicBearingCapacityFactors.n_q(friction_angle) + 1.0)
+            * tan(friction_angle)
+        )
+
+
+class VesicShapeFactors:
+    @staticmethod
+    @round_(ndigits=2)
+    def s_c(
+        friction_angle: float,
+        f_width: float,
+        f_length: float,
+        f_shape: Shape,
+    ) -> float:
+        _n_q = VesicBearingCapacityFactors.n_q(friction_angle)
+        _n_c = VesicBearingCapacityFactors.n_c(friction_angle)
+
+        if f_shape == Shape.STRIP:
+            return 1.0
+        elif f_shape == Shape.RECTANGLE:
+            return 1.0 + (f_width / f_length) * (_n_q / _n_c)
+        else:  # SQUARE, CIRCLE
+            return 1.0 + (_n_q / _n_c)
+
+    @staticmethod
+    @round_(ndigits=2)
+    def s_q(
+        friction_angle: float,
+        f_width: float,
+        f_length: float,
+        f_shape: Shape,
+    ) -> float:
+        if f_shape == Shape.STRIP:
+            return 1.0
+        elif f_shape == Shape.RECTANGLE:
+            return 1.0 + (f_width / f_length) * tan(friction_angle)
+        else:  # SQUARE, CIRCLE
+            return 1.0 + tan(friction_angle)
+
+    @staticmethod
+    @round_(ndigits=2)
+    def s_gamma(f_width: float, f_length: float, f_shape: Shape) -> float:
+        if f_shape == Shape.STRIP:
+            return 1.0
+        elif f_shape == Shape.RECTANGLE:
+            return 1.0 - 0.4 * (f_width / f_length)
+        else:  # SQUARE, CIRCLE
+            return 0.6
+
+
+class VesicDepthFactors:
+
+    @staticmethod
+    @round_(ndigits=2)
+    def d_c(f_depth: float, f_width: float) -> float:
+        return 1.0 + 0.4 * f_depth / f_width
+
+    @staticmethod
+    @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
+        )
+
+    @staticmethod
+    @round_(ndigits=2)
+    def d_gamma() -> float:
+        return 1.0
+
+
+class VesicInclinationFactors:
+
+    @staticmethod
+    @round_(ndigits=2)
+    def i_c(load_angle: float) -> float:
+        return (1.0 - load_angle / 90.0) ** 2.0
+
+    @staticmethod
+    @round_(ndigits=2)
+    def i_q(load_angle: float) -> float:
+        return VesicInclinationFactors.i_c(load_angle)
+
+    @staticmethod
+    @round_(ndigits=2)
+    def i_gamma(friction_angle: float, load_angle: float) -> float:
+        if isclose(friction_angle, 0.0):
+            return 1.0
+        return (1.0 - load_angle / friction_angle) ** 2.0
+
+
+class VesicUltimateBearingCapacity(UltimateBearingCapacity):
+    """Ultimate bearing capacity for soils according to `Vesic (1973)`."""
+
+    @property
+    def n_c(self) -> float:
+        r"""Bearing capacity factor $N_c$.
+
+        $$N_c = \cot(\phi) \left(N_q - 1\right)$$
+        """
+        return VesicBearingCapacityFactors.n_c(self.friction_angle)
+
+    @property
+    def n_q(self) -> float:
+        r"""Bearing capacity factor $N_q$.
+
+        $$
+        N_q = \tan^2\left(45 + \frac{\phi}{2}\right) \cdot
+               e^{\pi \tan(\phi)}
+        $$
+        """
+        return VesicBearingCapacityFactors.n_q(self.friction_angle)
+
+    @property
+    def n_gamma(self) -> float:
+        r"""Bearing capacity factor $N_{\gamma}$.
+
+        $$N_{\gamma} = 2(N_q + 1) \tan(\phi)$$
+        """
+        return VesicBearingCapacityFactors.n_gamma(self.friction_angle)
+
+    @property
+    def s_c(self) -> float:
+        r"""Shape factor $S_c$.
+
+        $$s_c = 1.0 \rightarrow \text{Strip footing}$$
+
+        $$
+        s_c = 1 + \dfrac{B}{L} \cdot \dfrac{N_q}{N_c} \rightarrow
+                 \text{Rectangular footing}
+        $$
+
+        $$
+        s_c &= 1 + \dfrac{N_q}{N_c} \rightarrow
+                \text{Square or circular footing}
+        $$
+        """
+        width, length, shape = self.foundation_size.footing_params()
+        return VesicShapeFactors.s_c(self.friction_angle, width, length, shape)
+
+    @property
+    def s_q(self) -> float:
+        r"""Shape factor $S_q$.
+
+
+        $$s_q = 1.0 \rightarrow \text{Strip footing}$$
+
+        $$
+        s_q = 1 + \dfrac{B}{L} \cdot \tan(\phi) \rightarrow
+                     \text{Rectangular footing}
+        $$
+
+        $$
+        s_q = 1 + \tan(\phi) \rightarrow \text{Square or circular footing}
+        $$
+        """
+        width, length, shape = self.foundation_size.footing_params()
+        return VesicShapeFactors.s_q(self.friction_angle, width, length, shape)
+
+    @property
+    def s_gamma(self) -> float:
+        r"""Shape factor $S_{\gamma}$.
+
+        $$s_{\gamma} = 1.0 \rightarrow \text{Strip footing}$$
+
+        $$
+        s_{\gamma} = 1.0 - 0.4 \dfrac{B}{L} \rightarrow
+                        \text{Rectangular footing}
+        $$
+
+        $$
+        s_{\gamma} = 0.6 \rightarrow \text{Square or circular footing}
+        $$
+        """
+        width, length, shape = self.foundation_size.footing_params()
+        return VesicShapeFactors.s_gamma(width, length, shape)
+
+    @property
+    def d_c(self) -> float:
+        r"""Depth factor $D_c$.
+
+        $$d_c = 1 + 0.4 \dfrac{D_f}{B}$$
+        """
+        depth, width = self.foundation_size.depth, self.foundation_size.width
+        return VesicDepthFactors.d_c(depth, width)
+
+    @property
+    def d_q(self) -> float:
+        r"""Depth factor $D_q$.
+
+        $$
+        d_q = 1 + 2 \tan(\phi) \cdot (1 - \sin(\phi))^2
+              \cdot \dfrac{D_f}{B}
+        $$
+        """
+        depth, width = self.foundation_size.depth, self.foundation_size.width
+        return VesicDepthFactors.d_q(self.friction_angle, depth, width)
+
+    @property
+    def d_gamma(self) -> float:
+        r"""Depth factor $D_{\gamma}$.
+
+        $$d_{\gamma} = 1.0$$
+        """
+        return VesicDepthFactors.d_gamma()
+
+    @property
+    def i_c(self) -> float:
+        r"""Inclination factor $I_c$.
+
+        $$i_c = (1 - \dfrac{\alpha}{90})^2$$
+        """
+        return VesicInclinationFactors.i_c(self.load_angle)
+
+    @property
+    def i_q(self) -> float:
+        r"""Inclination factor $I_q$.
+
+        $$i_q = (1 - \dfrac{\alpha}{90})^2$$
+        """
+        return VesicInclinationFactors.i_q(self.load_angle)
+
+    @property
+    def i_gamma(self) -> float:
+        r"""Inclination factor $I_{\gamma}$.
+
+        $$i_{\gamma} = \left(1 - \dfrac{\alpha}{\phi} \right)^2$$
+        """
+        return VesicInclinationFactors.i_gamma(self.friction_angle, self.load_angle)