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

geolysis/bearing_capacity/abc/cohl/terzaghi_abc.py

@@ -1,131 +0,0 @@
-from geolysis.foundation import Foundation
-from geolysis.utils import round_
-
-from ._core import AllowableBearingCapacity
-
-
-class TerzaghiABC4PadFoundation(AllowableBearingCapacity):
-    r"""Allowable bearing capacity for pad foundation on cohesionless
-    soils according to ``Terzaghi & Peck (1948)``.
-
-    :Equation:
-
-    .. math::
-
-         q_a(kPa) &= 12N \dfrac{1}{c_w f_d}\left(\dfrac{S}{25.4}\right),
-                     \ B \ \le 1.2m
-
-         q_a(kPa) &= 8N\left(\dfrac{3.28B + 1}{3.28B} \right)^2\dfrac{1}
-                     {c_w f_d}\left(\dfrac{S}{25.4}\right), \ B \ \gt 1.2m
-
-         f_d &= 1 + 0.25 \cdot \frac{D_f}{B} \le 1.25
-
-         c_w &= 2 - \frac{D_w}{2B} \le 2, D_w \gt D_f
-
-         c_w &= 2 - \frac{D_f}{2B} \le 2, D_w \le D_f
-
-    ===================  ======================================  ===========
-     Symbol                Description                              Unit
-    ===================  ======================================  ===========
-    :math:`q_a`          Allowable bearing capacity               :math:`kPa`
-    :math:`N`            Corrected SPT N-value                     —
-    :math:`f_d`          Depth factor                              —
-    :math:`c_w`          Water correction factor                   —
-    :math:`S`            Tolerable settlement                     :math:`mm`
-    :math:`B`            Width of foundation footing              :math:`m`
-    :math:`D_f`          Depth of foundation footing              :math:`m`
-    :math:`D_w`          Depth of water below ground level        :math:`m`
-    ===================  ======================================  ===========
-    """
-
-    def __init__(self, corrected_spt_n_value: float,
-                 tol_settlement: float,
-                 foundation_size: Foundation) -> None:
-        """
-        :param corrected_spt_n_value: Lowest (or average) uncorrected SPT 
-                                      N-value (60% energy) within the foundation 
-                                      influence zone i.e :math:`D_f` to 
-                                      :math:`D_f + 2B`
-        :type corrected_spt_n_value: float
-
-        :param tol_settlement: Tolerable settlement of foundation (mm).
-        :type tol_settlement: float
-
-        :param foundation_size: Size of the foundation.
-        :type foundation_size: Foundation
-        """
-        super().__init__(corrected_spt_n_value=corrected_spt_n_value,
-                         tol_settlement=tol_settlement,
-                         foundation_size=foundation_size)
-
-    def _fd(self) -> float:
-        """Calculate the depth factor."""
-        depth = self.foundation_size.depth
-        width = self.foundation_size.width
-
-        return min(1.0 + 0.25 * depth / width, 1.25)
-
-    def _cw(self):
-        """Calculate the water correction factor."""
-        depth = self.foundation_size.depth
-        width = self.foundation_size.width
-        water_level = self.foundation_size.ground_water_level
-
-        if water_level is None:
-            return 2.0
-
-        if water_level <= depth:
-            cw = 2.0 - depth / (2.0 * width)
-        else:
-            cw = 2.0 - water_level / (2.0 * width)
-
-        return min(cw, 2.0)
-
-    @round_(ndigits=2)
-    def bearing_capacity(self):
-        """Calculates the allowable bearing capacity of the pad foundation."""
-        n_corr = self.corrected_spt_n_value
-        width = self.foundation_size.width
-
-        if width <= 1.2:
-            return 12 * n_corr * (1 / (self._cw() * self._fd())) * self._sr()
-
-        return (8 * n_corr * ((3.28 * width + 1) / (3.28 * width)) ** 2
-                * (1 / (self._cw() * self._fd())) * self._sr())
-
-
-class TerzaghiABC4MatFoundation(TerzaghiABC4PadFoundation):
-    r"""Allowable bearing capacity for mat foundation on cohesionless soils
-    according to ``Terzaghi & Peck (1948)``.
-
-    :Equation:
-
-    .. math::
-
-         q_a(kPa) &= 8N\dfrac{1}{c_w f_d}\left(\dfrac{S}{25.4}\right)
-
-         f_d &= 1 + 0.25 \cdot \frac{D_f}{B} \le 1.25
-
-         c_w &= 2 - \frac{D_w}{2B} \le 2, D_w \gt D_f
-
-         c_w &= 2 - \frac{D_f}{2B} \le 2, D_w \le D_f
-
-    ===================  ======================================  ===========
-     Symbol                Description                              Unit
-    ===================  ======================================  ===========
-    :math:`q_a`          Allowable bearing capacity               :math:`kPa`
-    :math:`N`            Corrected SPT N-value                     —
-    :math:`f_d`          Depth factor                              —
-    :math:`c_w`          Water correction factor                   —
-    :math:`S`            Tolerable settlement                     :math:`mm`
-    :math:`B`            Width of foundation footing              :math:`m`
-    :math:`D_f`          Depth of foundation footing              :math:`m`
-    :math:`D_w`          Depth of water below ground level        :math:`m`
-    ===================  ======================================  ===========
-    """
-
-    @round_(ndigits=2)
-    def bearing_capacity(self):
-        """Calculates the allowable bearing capacity of the mat foundation."""
-        n_corr = self.corrected_spt_n_value
-        return 8 * n_corr * (1 / (self._cw() * self._fd())) * self._sr()

geolysis/bearing_capacity/ubc/hansen_ubc.py

@@ -1,287 +0,0 @@
-from geolysis.foundation import Shape
-from geolysis.utils import cos, cot, exp, isclose, pi, round_, sin, tan
-
-from ._core import UltimateBearingCapacity
-
-__all__ = ["HansenUltimateBearingCapacity"]
-
-
-@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_(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_(ndigits=2)
-def n_gamma(friction_angle: float) -> float:
-    return 1.8 * (n_q(friction_angle) - 1.0) * tan(friction_angle)
-
-
-@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
-
-
-@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
-
-
-@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
-
-
-@round_(ndigits=2)
-def d_c(f_depth: float, f_width: float) -> float:
-    return 1.0 + 0.35 * f_depth / f_width
-
-
-@round_(ndigits=2)
-def d_q(f_depth: float, f_width: float) -> float:
-    return d_c(f_depth, f_width)
-
-
-@round_(ndigits=2)
-def d_gamma() -> float:
-    return 1.0
-
-
-@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)
-
-
-@round_(ndigits=2)
-def i_q(load_angle: float) -> float:
-    return 1.0 - (1.5 * sin(load_angle)) / cos(load_angle)
-
-
-@round_(ndigits=2)
-def i_gamma(load_angle: float) -> float:
-    return i_q(load_angle) ** 2.0
-
-
-class HansenUltimateBearingCapacity(UltimateBearingCapacity):
-    r"""Ultimate bearing capacity for soils according to ``Hansen (1961)``.
-
-    :Equation:
-
-    .. math::
-
-            q_u = cN_c s_c d_c i_c + qN_q s_q d_q i_q
-                  + 0.5 \gamma B N_{\gamma} s_{\gamma} d_{\gamma} i_{\gamma}
-
-    .. list-table::
-       :widths: auto
-       :header-rows: 1
-
-       * - Symbol
-         - Description
-         - Unit
-       * - :math:`q_u`
-         - Ultimate bearing capacity
-         - :math:`kPa`
-       * - :math:`c`
-         - Cohesion of soil
-         - :math:`kPa`
-       * - :math:`q`
-         - Overburden pressure of soil
-         - :math:`kPa`
-       * - :math:`\gamma`
-         - Unit weight of soil
-         - :math:`kN/m^3`
-       * - :math:`B`
-         - Width of foundation footing
-         - :math:`m`
-       * - :math:`N_c`, :math:`N_q`, :math:`N_{\gamma}`
-         - Bearing capacity factors
-         - —
-       * - :math:`s_c`, :math:`s_q`, :math:`s_{\gamma}`
-         - Shape factors
-         - —
-       * - :math:`d_c`, :math:`d_q`, :math:`d_{\gamma}`
-         - Depth factors
-         - —
-       * - :math:`i_c`, :math:`i_q`, :math:`i_{\gamma}`
-         - Inclination factors
-         - —
-    """
-
-    @property
-    def n_c(self) -> float:
-        r"""Bearing capacity factor :math:`N_c`.
-
-        :Equation:
-
-        .. math:: N_c = \cot(\phi) \left(N_q - 1\right)
-        """
-        return n_c(self.friction_angle)
-
-    @property
-    def n_q(self) -> float:
-        r"""Bearing capacity factor :math:`N_q`.
-
-        :Equation:
-
-        .. math::
-
-            N_q = \tan^2\left(45 + \frac{\phi}{2}\right) \cdot e^{\pi \tan(\phi)}
-        """
-        return n_q(self.friction_angle)
-
-    @property
-    def n_gamma(self) -> float:
-        r"""Bearing capacity factor :math:`N_{\gamma}`.
-
-        :Equation:
-
-        .. math:: N_{\gamma} = 1.8 \left(N_q - 1\right) \tan(\phi)
-        """
-        return n_gamma(self.friction_angle)
-
-    @property
-    def s_c(self) -> float:
-        r"""Shape factor :math:`S_c`.
-
-        :Equation:
-
-        .. math::
-
-            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 s_c(width, length, shape)
-
-    @property
-    def s_q(self) -> float:
-        r"""Shape factor :math:`S_q`.
-
-        :Equation:
-
-        .. math::
-
-            s_q &= 1.0 \rightarrow \text{Strip footing}
-
-            s_q &= 1.0 + 0.2 \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 s_q(width, length, shape)
-
-    @property
-    def s_gamma(self) -> float:
-        r"""Shape factor :math:`S_{\gamma}`.
-
-        :Equation:
-
-        .. math::
-
-            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 s_gamma(width, length, shape)
-
-    @property
-    def d_c(self) -> float:
-        r"""Depth factor :math:`D_c`.
-
-        :Equation:
-
-        .. math:: d_c = 1.0 + 0.35 \cdot \frac{D_f}{B}
-        """
-        depth = self.foundation_size.depth
-        width = self.foundation_size.width
-        return d_c(depth, width)
-
-    @property
-    def d_q(self) -> float:
-        r"""Depth factor :math:`D_q`.
-
-        :Equation:
-
-        .. math:: d_q = 1.0 + 0.35 \cdot \frac{D_f}{B}
-        """
-        depth = self.foundation_size.depth
-        width = self.foundation_size.width
-        return d_q(depth, width)
-
-    @property
-    def d_gamma(self) -> float:
-        r"""Depth factor :math:`D_{\gamma}`.
-
-        :Equation:
-
-        .. math:: d_{\gamma} = 1.0
-        """
-        return d_gamma()
-
-    @property
-    def i_c(self) -> float:
-        r"""Inclination factor :math:`I_c`.
-
-        :Equation:
-
-        .. math:: I_c = 1 - \frac{\sin(\alpha)}{2cBL}
-        """
-        width, length = self.foundation_size.width, self.foundation_size.length
-        return i_c(self.cohesion, self.load_angle, width, length)
-
-    @property
-    def i_q(self) -> float:
-        r"""Inclination factor :math:`I_q`.
-
-        :Equation:
-
-        .. math:: I_q = 1 - \frac{1.5 \sin(\alpha)}{\cos(\alpha)}
-        """
-        return i_q(self.load_angle)
-
-    @property
-    def i_gamma(self) -> float:
-        r"""Inclination factor :math:`I_{\gamma}`.
-
-        :Equation:
-
-        .. math:: I_{\gamma} = I_q^2
-        """
-        return i_gamma(self.load_angle)

geolysis/bearing_capacity/ubc/terzaghi_ubc.py

@@ -1,246 +0,0 @@
-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"]
-
-
-@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_(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_(ndigits=2)
-def n_gamma(friction_angle: float) -> float:
-    return (n_q(friction_angle) - 1.0) * tan(1.4 * friction_angle)
-
-
-class TerzaghiUltimateBearingCapacity(UltimateBearingCapacity, ABC):
-
-    @property
-    def n_c(self) -> float:
-        r"""Bearing capacity factor :math:`N_c`.
-
-        :Equation:
-
-        .. math:: N_c = \cot(\phi) \cdot (N_q - 1)
-        """
-        return n_c(self.friction_angle)
-
-    @property
-    def n_q(self) -> float:
-        r"""Bearing capacity factor :math:`N_q`.
-
-        :Equation:
-
-        .. math::
-
-            N_q = \dfrac{e^{(\frac{3\pi}{2} - \phi)\tan\phi}}
-                      {2\cos^2(45 + \frac{\phi}{2})}
-        """
-        return n_q(self.friction_angle)
-
-    @property
-    def n_gamma(self) -> float:
-        r"""Bearing capacity factor :math:`N_{\gamma}`.
-
-        :Equation:
-
-        .. math:: N_{\gamma} =  (N_q - 1) \cdot \tan(1.4\phi)
-        """
-        return n_gamma(self.friction_angle)
-
-
-class TerzaghiUBC4StripFooting(TerzaghiUltimateBearingCapacity):
-    r"""Ultimate bearing capacity for strip footing according to
-    ``Terzaghi 1943``.
-
-    :Equation:
-
-    .. math:: q_u = cN_c + qN_q + 0.5 \gamma BN_{\gamma}
-
-    .. list-table::
-       :widths: auto
-       :header-rows: 1
-
-       * - Symbol
-         - Description
-         - Unit
-       * - :math:`q_u`
-         - Ultimate bearing capacity
-         - :math:`kPa`
-       * - :math:`c`
-         - Cohesion of soil
-         - :math:`kPa`
-       * - :math:`q`
-         - Overburden pressure of soil
-         - :math:`kPa`
-       * - :math:`\gamma`
-         - Unit weight of soil
-         - :math:`kN/m^3`
-       * - :math:`B`
-         - Width of foundation footing
-         - :math:`m`
-       * - :math:`N_c`, :math:`N_q`, :math:`N_{\gamma}`
-         - Bearing capacity factors
-         - —
-    """
-
-    @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``.
-
-    :Equation:
-
-    .. math:: q_u = 1.3cN_c + qN_q + 0.3 \gamma BN_{\gamma}
-
-    .. list-table::
-       :widths: auto
-       :header-rows: 1
-
-       * - Symbol
-         - Description
-         - Unit
-       * - :math:`q_u`
-         - Ultimate bearing capacity
-         - :math:`kPa`
-       * - :math:`c`
-         - Cohesion of soil
-         - :math:`kPa`
-       * - :math:`q`
-         - Overburden pressure of soil
-         - :math:`kPa`
-       * - :math:`\gamma`
-         - Unit weight of soil
-         - :math:`kN/m^3`
-       * - :math:`B`
-         - Width of foundation footing
-         - :math:`m`
-       * - :math:`N_c`, :math:`N_q`, :math:`N_{\gamma}`
-         - Bearing capacity factors
-         - —
-    """
-
-    @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``.
-
-    :Equation:
-
-    .. math::
-
-            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}
-
-    .. list-table::
-       :widths: auto
-       :header-rows: 1
-
-       * - Symbol
-         - Description
-         - Unit
-       * - :math:`q_u`
-         - Ultimate bearing capacity
-         - :math:`kPa`
-       * - :math:`c`
-         - Cohesion of soil
-         - :math:`kPa`
-       * - :math:`q`
-         - Overburden pressure of soil
-         - :math:`kPa`
-       * - :math:`\gamma`
-         - Unit weight of soil
-         - :math:`kN/m^3`
-       * - :math:`B`
-         - Width of foundation footing
-         - :math:`m`
-       * - :math:`L`
-         - Length of foundation footing
-         - :math:`m`
-       * - :math:`N_c`, :math:`N_q`, :math:`N_{\gamma}`
-         - Bearing capacity factors
-         - —
-    """
-
-    @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``.
-
-    :Equation:
-
-    .. math:: q_u = 1.3cN_c + qN_q + 0.4 \gamma BN_{\gamma}
-
-    .. list-table::
-       :widths: auto
-       :header-rows: 1
-
-       * - Symbol
-         - Description
-         - Unit
-       * - :math:`q_u`
-         - Ultimate bearing capacity
-         - :math:`kPa`
-       * - :math:`c`
-         - Cohesion of soil
-         - :math:`kPa`
-       * - :math:`q`
-         - Overburden pressure of soil
-         - :math:`kPa`
-       * - :math:`\gamma`
-         - Unit weight of soil
-         - :math:`kN/m^3`
-       * - :math:`B`
-         - Width of foundation footing
-         - :math:`m`
-       * - :math:`N_c`, :math:`N_q`, :math:`N_{\gamma}`
-         - Bearing capacity factors
-         - —
-    """
-
-    def bearing_capacity(self):
-        """Calcalates ultimate bearing capacity for square footing.
-        """
-        return super().bearing_capacity()