geolysis 0.8.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

geolysis/{utils/__init__.py → utils.py}

@@ -1,30 +1,46 @@
+import enum
 import functools
 import math
 from math import exp, inf, isclose, log10, pi, sqrt
 from statistics import fmean as mean
-from typing import (Any, Callable, NotRequired, Optional, SupportsRound,
-                    TypedDict, Unpack)
-
-from . import validators
-
-__all__ = ["ErrorMsg",
-           "enum_repr",
-           "inf",
-           "pi",
-           "deg2rad",
-           "rad2deg",
-           "tan",
-           "cot",
-           "sin",
-           "cos",
-           "arctan",
-           "round_",
-           "mean",
-           "exp",
-           "isclose",
-           "log10",
-           "sqrt",
-           "validators"]
+from typing import Callable
+
+__all__ = [
+    "AbstractStrEnum",
+    "inf",
+    "pi",
+    "deg2rad",
+    "rad2deg",
+    "tan",
+    "cot",
+    "sin",
+    "cos",
+    "arctan",
+    "round_",
+    "mean",
+    "exp",
+    "isclose",
+    "log10",
+    "sqrt",
+]
+
+
+class StrEnumMeta(enum.EnumMeta):
+    def __contains__(cls, item) -> bool:
+        if isinstance(item, (str, cls)):
+            return str(item) in (member.value for member in cls)
+        return NotImplemented
+
+    def __repr__(cls) -> str:
+        return str([member.value for member in cls])
+
+
+class AbstractStrEnum(enum.StrEnum, metaclass=StrEnumMeta):
+    """An abstract string enumeration class that inherits from StrEnum.
+
+    This class can be used as a base class for creating string
+    enumerations.
+    """
 
 
 def deg2rad(x: float, /) -> float:
@@ -62,23 +78,19 @@ def arctan(x: float, /) -> float:
     return rad2deg(math.atan(x))
 
 
-def enum_repr(cls):
-    cls.__repr__ = lambda self: f"{self.value}"
-    return cls
-
+def round_(ndigits: int) -> Callable:
+    """A decorator that rounds the result of a callable to a specified
+    number of decimal places.
 
-def round_(ndigits: int | Callable[..., SupportsRound]) -> Callable:
-    """A decorator that rounds the result of a callable to a specified number
-    of decimal places.
+    The returned value of the callable should support the `__round__`
+    dunder method and should be a numeric value.
 
-    The returned value of the callable should support the ``__round__`` dunder
-    method and should be a numeric value. ``ndigits`` can either be an int
-    which will indicate the number of decimal places to round to or a
-    callable. If ``ndigits`` is callable the default decimal places is 2.
-
-    TypeError is raised when ``ndigits`` is neither an int nor a callable.
+    TypeError is raised when `ndigits` is not an int.
     """
 
+    if not isinstance(ndigits, int):
+        raise TypeError("ndigits must be an int")
+
     def dec(fn) -> Callable[..., float]:
         @functools.wraps(fn)
         def wrapper(*args, **kwargs) -> float:

geolysis-0.10.0.dist-info/METADATA

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: geolysis
+Version: 0.10.0
+Summary: geolysis is an opensource software for geotechnical engineering analysis and modeling.
+Author-email: Patrick Boateng <boatengpato.pb@gmail.com>
+License: MIT License
+Project-URL: Homepage, https://docs.geolysis.io
+Project-URL: Documentation, https://docs.geolysis.io
+Project-URL: Repository, https://github.com/patrickboateng/geolysis
+Project-URL: Discussions, https://github.com/patrickboateng/geolysis/discussions
+Project-URL: Issue Tracker, https://github.com/patrickboateng/geolysis/issues
+Keywords: geotechnical-engineering,soil-classification,bearing-capacity-analysis,standard-penetration-test-analysis
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Dynamic: license-file
+
+<div align="center">
+<img src="https://raw.githubusercontent.com/patrickboateng/geolysis/main/docs/assets/pkg-logo.svg" 
+alt="logo" width="30%" height="30%" />
+</div><br>
+
+<div align="center">
+
+[![PyPI Latest Release](https://img.shields.io/pypi/v/geolysis?style=flat&logo=pypi)](https://pypi.org/project/geolysis/)
+[![PyPI Downloads](https://static.pepy.tech/badge/geolysis)](https://pepy.tech/projects/geolysis)
+[![PyPI pyversions](https://img.shields.io/pypi/pyversions/geolysis.svg?logo=python&style=flat)](https://pypi.python.org/pypi/geolysis/)
+[![license](https://img.shields.io/pypi/l/geolysis?style=flat&logo=opensourceinitiative)](https://opensource.org/license/mit/)
+
+![Coveralls Status](https://img.shields.io/coverallsCoverage/github/patrickboateng/geolysis?logo=coveralls)
+[![Codacy Badge](https://app.codacy.com/project/badge/Grade/17f88084c6a84a08a20f9d8da1438107)](https://app.codacy.com/gh/patrickboateng/geolysis/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
+[![Unit-Tests](https://github.com/patrickboateng/geolysis/actions/workflows/geolysis-unit-tests.yml/badge.svg)](https://github.com/patrickboateng/geolysis/actions/workflows/geolysis-unit-tests.yml)
+[![Documentation Status](https://readthedocs.org/projects/geolysis/badge/?version=latest)](https://geolysis.readthedocs.io/en/latest/?badge=latest)
+
+</div>
+
+`geolysis` is an open-source python package (library) for geotechnical analysis
+and modeling.
+
+The `geolysis` python package is among three other projects, `geolysis.excel`,
+`geolysis.gui`, and `geolysis.ai`. More details about these projects are
+provided [here](https://github.com/geolysis-dev).
+
+The rest of this **README** provides an overview of the `geolysis` python
+package.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [API Reference](#api-reference)
+- [Imports](#imports)
+- [Project Structure](#project-structure)
+- [Usage](#usage)
+- [Documentation](#documentation)
+- [Contributing](#contributing)
+- [License](#license)
+- [Contact](#contact)
+
+## Installation
+
+```shell
+$ pip install geolysis
+```
+
+## API Reference
+
+- [Python API](https://docs.geolysis.io/en/latest/reference/) 
+    - [geolysis.bearing_capacity.abc](https://docs.geolysis.io/en/latest/reference/allowable_bearing_capacity/) - _Allowable bearing capacity
+      estimation_
+    - [geolysis.bearing_capacity.ubc](https://docs.geolysis.io/en/latest/reference/ultimate_bearing_capacity/) - _Ultimate bearing capacity
+      estimation_
+    - [geolysis.foundation](https://docs.geolysis.io/en/latest/reference/foundation/) - _Foundation Representation_
+    - [geolysis.soil_classifier](https://docs.geolysis.io/en/latest/reference/soil_classifier/) - _Soil classification_
+    - [geolysis.spt](https://docs.geolysis.io/en/latest/reference/spt/) - _Standard Penetration Test (SPT) Analysis_
+    - [geolysis.utils](https://docs.geolysis.io/en/latest/reference/utils/) - _Utilities_
+
+
+## Imports
+
+- **Bearing Capacity**
+
+    - **Allowable Bearing Capacity (ABC)**
+     
+      ```python
+      from geolysis.bearing_capacity.abc import create_abc_4_cohesionless_soils
+      ```
+        
+    - **Ultimate Bearing Capacity (UBC)**
+     
+      ```python
+      from geolysis.bearing_capacity.ubc import create_ubc_4_all_soil_types
+      ```
+
+- **Foundation**
+ 
+  ```python
+  from geolysis.foundation import create_foundation
+  ```
+
+
+- **Soil Classification**
+ 
+  ```python
+  from geolysis.soil_classifier import create_uscs_classifier
+  from geolysis.soil_classifier import create_aashto_classifier
+  ```
+ 
+- **Standard Penetration Test (SPT) Analysis**
+ 
+  ```python
+  from geolysis.spt import DilatancyCorrection
+  from geolysis.spt import EnergyCorrection
+  from geolysis.spt import SPT
+  from geolysis.spt import create_overburden_pressure_correction
+  ```
+  
+## Project Structure
+
+    .
+    ├── .github            # GitHub Actions
+    ├── docs               # Documentation files
+    ├── geolysis           # Source files
+    ├── tests              # Automated tests
+    ├── pyproject.toml     # Project configuration file
+    └── README.md          # Project README file
+
+## Usage
+
+```python
+
+>>> from geolysis.soil_classifier import create_aashto_classifier
+>>> aashto_clf = create_aashto_classifier(liquid_limit=34.1,
+...                                       plastic_limit=21.1,
+...                                       fines=47.88, )
+>>> clf = aashto_clf.classify()
+>>> clf.symbol
+'A-6(4)'
+>>> clf.symbol_no_grp_idx
+'A-6'
+>>> clf.group_index
+'4'
+>>> clf.description
+'Clayey soils'
+
+```
+
+Check out more [examples](https://docs.geolysis.io/en/latest/usage/)
+
+## Documentation
+
+Check out the full [documentation](https://docs.geolysis.io/en/latest/).
+
+## Contributing
+
+Check out the [contribution guidelines](https://docs.geolysis.io/en/latest/dev_guide/)
+
+## License
+
+This project is licensed under the MIT License - see the
+[LICENSE](https://github.com/patrickboateng/geolysis/blob/main/LICENSE.txt)
+file for more details.
+
+## Contact
+
+For questions or feedback, please
+contact [patrickboateng at patrickboateng dot tech](mailto:patrickboateng@patrickboateng.tech)

geolysis-0.10.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+geolysis/__init__.py,sha256=_BzryYcgDYjfkWn75IfellVNRi3uyzQcTD4P8z7pElE,161
+geolysis/foundation.py,sha256=khmZCa8V-UEqp7A4WlIwt8Oy5tVQdT0UsaLMuxEbDQU,12819
+geolysis/soil_classifier.py,sha256=rScsrMR7mNOkKuWWiduJzsakibyYR2S0-tLrXbYSobQ,27427
+geolysis/spt.py,sha256=_AWfs5Ho5ScCwPlVDNh6cuhcLOR4-u7Dr7UoagRlDoM,18620
+geolysis/utils.py,sha256=hgAeuMoGxL_GRbzYD3jZHglFxAmeqUa8FBqM0sm40lc,2394
+geolysis/bearing_capacity/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+geolysis/bearing_capacity/abc/__init__.py,sha256=QCSni6_QI059y3JF5UU9Gd_wAyVLmVEMR7ajq_EZQRg,518
+geolysis/bearing_capacity/abc/_cohl/__init__.py,sha256=M1EBn2WMgtG-Dg-LT7N-OVke6upwL6plqyPCn3ebR0M,4110
+geolysis/bearing_capacity/abc/_cohl/_core.py,sha256=Ix6bSkTlP0zxN6CuH_lHT1B3ug9ZvbGjOImlU4IABOU,1739
+geolysis/bearing_capacity/abc/_cohl/bowles_abc.py,sha256=AC0OslIUZBxC5ClB0HNvLoVDwnt982l8OGPuxyE2uZ0,3153
+geolysis/bearing_capacity/abc/_cohl/meyerhof_abc.py,sha256=Zf4X6YVrPMH5Sgm0bORbWe4RgfO-jVJBdeRWl8jBRH8,3056
+geolysis/bearing_capacity/abc/_cohl/terzaghi_abc.py,sha256=KKutVHYRFlS5SFFRVJEMKOfROFPk5MnCgQ6LmIdv1ow,4131
+geolysis/bearing_capacity/ubc/__init__.py,sha256=5EtGLFW0vwCfUGxQDKPQJ687C9AKRlbYEPYb2aY2AgA,4578
+geolysis/bearing_capacity/ubc/_core.py,sha256=Fbp5AXdixDUAL4YRz-BP92AHhYL1ROBOX_FEVUGxEaw,6057
+geolysis/bearing_capacity/ubc/_hansen_ubc.py,sha256=aVu40WFCtvstWNq3x65Klb9am4UfJq00MtfaJYIwifI,6995
+geolysis/bearing_capacity/ubc/_terzaghi_ubc.py,sha256=U9mt92glUuooXnd_NPOFDpEdG15bTdb_KPPXLu5zjPw,5503
+geolysis/bearing_capacity/ubc/_vesic_ubc.py,sha256=a8TvlJCZ4AMU_YEVE0DEXb_Eo75uVOtOLDg-mC3zYlc,7034
+geolysis-0.10.0.dist-info/licenses/LICENSE.txt,sha256=ap6sMs3lT7ICbEXBhgihwH1BTCVcjmCQkIkwVnil1Ak,1065
+geolysis-0.10.0.dist-info/METADATA,sha256=l5am6GR_xC1gpLUEVO-Ase9kCGXrBxocPLiVcMtkXYg,6611
+geolysis-0.10.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+geolysis-0.10.0.dist-info/top_level.txt,sha256=9mnQgOaCRr11dtXff8X-q3FfXjRONd6kHseSy5q2y8g,9
+geolysis-0.10.0.dist-info/RECORD,,

{geolysis-0.8.0.dist-info → geolysis-0.10.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.1.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

geolysis/bearing_capacity/abc/cohl/__init__.py

@@ -1,137 +0,0 @@
-"""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.exceptions import ErrorMsg, ValidationError
-
-from ._core import AllowableBearingCapacity
-from .bowles_abc import BowlesABC4MatFoundation, BowlesABC4PadFoundation
-from .meyerhof_abc import MeyerhofABC4MatFoundation, MeyerhofABC4PadFoundation
-from .terzaghi_abc import TerzaghiABC4MatFoundation, TerzaghiABC4PadFoundation
-
-
-@enum_repr
-class ABCType(enum.StrEnum):
-    """Enumeration of available allowable bearing capacity types."""
-    BOWLES = enum.auto()
-    MEYERHOF = enum.auto()
-    TERZAGHI = enum.auto()
-
-
-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,
-    }
-}
-
-
-def create_allowable_bearing_capacity(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 = Shape.SQUARE,
-                                      foundation_type: FoundationType | str =
-                                      FoundationType.PAD,
-                                      abc_type: Optional[
-                                          ABCType | str] = None,
-                                      ) -> AllowableBearingCapacity:
-    """ A factory function that encapsulate the creation of  allowable bearing
-    capacities.
-
-    :param corrected_spt_n_value: The corrected SPT N-value.
-    :type corrected_spt_n_value: float
-
-    :param tol_settlement: Tolerable settlement of foundation (mm).
-    :type tol_settlement: float
-
-    :param depth: Depth of foundation (m).
-    :type depth: float
-
-    :param width: Width of foundation footing (m).
-    :type width: float
-
-    :param length: Length of foundation footing (m).
-    :type length: float, optional
-
-    :param eccentricity: The deviation of the foundation load from the center 
-                         of gravity of the foundation footing (m), defaults to
-                         0.0. This means that the foundation load aligns with
-                         the center of gravity of the foundation footing.
-    :type eccentricity: float, optional
-
-    :param ground_water_level: Depth of water below ground level (m).
-    :type ground_water_level: float, optional
-
-    :param shape: Shape of foundation footing, defaults to
-                  :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 :py:enum:`ABCType`,
-                     defaults to None.
-    :type abc_type:  ABCType | str, optional
-
-    :raises ValueError: Raised if ``abc_type`` or ``foundation_type`` is not
-                        supported.
-    :raises ValueError: Raised when ``length`` is not provided for a rectangular
-                        footing.
-    :raises ValueError: Raised if an invalid footing ``shape`` is provided.
-    """
-
-    msg = ErrorMsg(param_name="abc_type",
-                   param_value=abc_type,
-                   symbol="in",
-                   param_value_bound=list(ABCType))
-
-    if abc_type is None:
-        raise ValidationError(msg)
-
-    try:
-        abc_type = ABCType(str(abc_type).casefold())
-    except ValueError as e:
-        raise ValidationError(msg) from e
-
-    try:
-        foundation_type = FoundationType(str(foundation_type).casefold())
-    except ValueError as e:
-        msg = ErrorMsg(param_name="foundation_type",
-                       param_value=foundation_type,
-                       symbol="in",
-                       param_value_bound=list(FoundationType))
-        raise ValidationError(msg) from e
-
-    # exception from create_foundation will automaatically propagate
-    # no need to catch and handle it.
-    fnd_size = create_foundation(depth=depth,
-                                 width=width,
-                                 length=length,
-                                 eccentricity=eccentricity,
-                                 ground_water_level=ground_water_level,
-                                 foundation_type=foundation_type,
-                                 shape=shape)
-
-    abc_class = abc_classes[abc_type][fnd_size.foundation_type]
-    abc = abc_class(corrected_spt_n_value=corrected_spt_n_value,
-                    tol_settlement=tol_settlement,
-                    foundation_size=fnd_size)
-    return abc

geolysis/bearing_capacity/abc/cohl/bowles_abc.py

@@ -1,96 +0,0 @@
-from geolysis.foundation import FoundationSize
-from geolysis.utils import round_
-
-from ._core import AllowableBearingCapacity
-
-
-class BowlesABC4PadFoundation(AllowableBearingCapacity):
-    r"""Allowable bearing capacity for pad foundation on cohesionless soils
-    according to ``Bowles (1997)``.
-
-    :Equation:
-
-    .. math::
-
-        q_a(kPa) &= 19.16(N_1)_{55} f_d\left(\dfrac{S}{25.4}\right),
-                        \ B \ \le \ 1.2m
-
-        q_a(kPa) &= 11.98(N_1)_{55}\left(\dfrac{3.28B + 1}{3.28B} \right)^2
-                        f_d \left(\dfrac{S}{25.4}\right), \ B \ \gt 1.2m
-
-        f_d &= 1 + 0.33 \cdot \frac{D_f}{B} \le 1.33
-
-    ===================  ======================================  ===========
-     Symbol                Description                              Unit
-    ===================  ======================================  ===========
-    :math:`q_a`          Allowable bearing capacity               :math:`kPa`
-    :math:`(N_1)_{55}`   Corrected SPT N-value                     —
-    :math:`f_d`          Depth factor                              —
-    :math:`S`            Tolerable settlement                     :math:`mm`
-    :math:`B`            Width of foundation footing              :math:`m`
-    :math:`D_f`          Depth of foundation footing              :math:`m`
-    ===================  ======================================  ===========
-    """
-
-    def __init__(self, corrected_spt_n_value: float,
-                 tol_settlement: float,
-                 foundation_size: FoundationSize) -> None:
-        """
-        :param corrected_spt_n_value: Statistical average of corrected SPT
-                                      N-value (55% energy with overburden 
-                                      pressure correction) within the foundation 
-                                      influence zone i.e ``0.5B`` to ``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: FoundationSize
-        """
-        super().__init__(corrected_spt_n_value=corrected_spt_n_value,
-                         tol_settlement=tol_settlement,
-                         foundation_size=foundation_size)
-
-    @round_(ndigits=2)
-    def bearing_capacity(self) -> float:
-        """Calculate 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 19.16 * n_corr * self._fd() * self._sr()
-
-        return (11.98 * n_corr * ((3.28 * width + 1) / (3.28 * width)) ** 2
-                * self._fd() * self._sr())
-
-
-class BowlesABC4MatFoundation(BowlesABC4PadFoundation):
-    r"""Allowable bearing capacity for mat foundation on cohesionless soils
-    according to ``Bowles (1997)``.
-
-    :Equation:
-
-    .. math::
-
-         q_a(kPa) &= 11.98(N_1)_{55}f_d\left(\dfrac{S}{25.4}\right)
-
-         f_d &= 1 + 0.33 \cdot \frac{D_f}{B} \le 1.33
-
-    ===================  ======================================  ===========
-     Symbol                Description                              Unit
-    ===================  ======================================  ===========
-    :math:`q_a`          Allowable bearing capacity               :math:`kPa`
-    :math:`(N_1)_{55}`   Corrected SPT N-value                     —
-    :math:`f_d`          Depth factor                              —
-    :math:`S`            Tolerable settlement                     :math:`mm`
-    :math:`B`            Width of foundation footing              :math:`m`
-    :math:`D_f`          Depth of foundation footing              :math:`m`
-    ===================  ======================================  ===========
-    """
-
-    @round_(ndigits=2)
-    def bearing_capacity(self) -> float:
-        """Calculate the allowable bearing capacity of the mat foundation."""
-        n_corr = self.corrected_spt_n_value
-        return 11.98 * n_corr * self._fd() * self._sr()

geolysis/bearing_capacity/abc/cohl/meyerhof_abc.py

@@ -1,96 +0,0 @@
-from geolysis.foundation import FoundationSize
-from geolysis.utils import round_
-
-from ._core import AllowableBearingCapacity
-
-
-class MeyerhofABC4PadFoundation(AllowableBearingCapacity):
-    r"""Allowable bearing capacity for pad foundation on cohesionless soils
-    according to ``Meyerhof (1956)``.
-
-    :Equation:
-
-    .. math::
-
-         q_a(kPa) &= 12N 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 f_d\left(
-                 \dfrac{S}{25.4}\right), \ B \ \gt 1.2m
-
-         f_d &= 1 + 0.33 \cdot \frac{D_f}{B} \le 1.33
-
-    ===================  ======================================  ===========
-     Symbol                Description                              Unit
-    ===================  ======================================  ===========
-    :math:`q_a`          Allowable bearing capacity               :math:`kPa`
-    :math:`N`            Corrected SPT N-value                     —
-    :math:`f_d`          Depth factor                              —
-    :math:`S`            Tolerable settlement                     :math:`mm`
-    :math:`B`            Width of foundation footing              :math:`m`
-    :math:`D_f`          Depth of foundation footing              :math:`m`
-    ===================  ======================================  ===========
-    """
-
-    def __init__(self, corrected_spt_n_value: float,
-                 tol_settlement: float,
-                 foundation_size: FoundationSize):
-        """
-        :param corrected_spt_n_value: Average uncorrected SPT N-value (60% 
-                                      energy with dilatancy (water) correction 
-                                      if applicable) 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: FoundationSize
-        """
-        super().__init__(corrected_spt_n_value=corrected_spt_n_value,
-                         tol_settlement=tol_settlement,
-                         foundation_size=foundation_size)
-
-    @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 * self._fd() * self._sr()
-
-        return (8 * n_corr * ((3.28 * width + 1) / (3.28 * width)) ** 2
-                * self._fd() * self._sr())
-
-
-class MeyerhofABC4MatFoundation(MeyerhofABC4PadFoundation):
-    r"""Allowable bearing capacity for mat foundation on cohesionless soils
-    according to ``Meyerhof (1956)``.
-
-    :Equation:
-
-    .. math::
-
-         q_a(kPa) &= 8 N f_d\left(\dfrac{S}{25.4}\right)
-
-         f_d &= 1 + 0.33 \cdot \frac{D_f}{B} \le 1.33
-
-    ===================  ======================================  ===========
-     Symbol                Description                              Unit
-    ===================  ======================================  ===========
-    :math:`q_a`          Allowable bearing capacity               :math:`kPa`
-    :math:`N`            Corrected SPT N-value                     —
-    :math:`f_d`          Depth factor                              —
-    :math:`S`            Tolerable settlement                     :math:`mm`
-    :math:`B`            Width of foundation footing              :math:`m`
-    :math:`D_f`          Depth of foundation footing              :math:`m`
-    ===================  ======================================  ===========
-    """
-
-    @round_(ndigits=2)
-    def bearing_capacity(self):
-        """Calculate the allowable bearing capacity of the mat foundation."""
-        n_corr = self.corrected_spt_n_value
-        return 8 * n_corr * self._fd() * self._sr()