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

geolysis/bearing_capacity/ubc/vesic_ubc.py

@@ -1,293 +0,0 @@
-from geolysis.foundation import Shape
-from geolysis.utils import isclose, round_, sin, tan
-
-from . import hansen_ubc
-from ._core import UltimateBearingCapacity
-
-__all__ = ["VesicUltimateBearingCapacity"]
-
-
-@round_(ndigits=2)
-def n_c(friction_angle: float) -> float:
-    return hansen_ubc.n_c(friction_angle)
-
-
-@round_(ndigits=2)
-def n_q(friction_angle: float) -> float:
-    return hansen_ubc.n_q(friction_angle)
-
-
-@round_(ndigits=2)
-def n_gamma(friction_angle: float) -> float:
-    return 2.0 * (n_q(friction_angle) + 1.0) * tan(friction_angle)
-
-
-@round_(ndigits=2)
-def s_c(friction_angle: float,
-        f_width: float,
-        f_length: float,
-        f_shape: Shape) -> float:
-    _n_q = n_q(friction_angle)
-    _n_c = 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)
-
-
-@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)
-
-
-@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
-
-
-@round_(ndigits=2)
-def d_c(f_depth: float, f_width: float) -> float:
-    return 1.0 + 0.4 * f_depth / f_width
-
-
-@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_(ndigits=2)
-def d_gamma() -> float:
-    return 1.0
-
-
-@round_(ndigits=2)
-def i_c(load_angle: float) -> float:
-    return (1.0 - load_angle / 90.0) ** 2.0
-
-
-@round_(ndigits=2)
-def i_q(load_angle: float) -> float:
-    return i_c(load_angle)
-
-
-@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):
-    r"""Ultimate bearing capacity for soils according to ``Vesic (1973)``.
-
-    :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} = 2(N_q + 1) \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 + \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 s_c(self.friction_angle, 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 + \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 s_q(self.friction_angle, 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 \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 s_gamma(width, length, shape)
-
-    @property
-    def d_c(self) -> float:
-        r"""Depth factor :math:`D_c`.
-
-        :Equation:
-
-        .. math:: d_c = 1 + 0.4 \dfrac{D_f}{B}
-        """
-        depth, width = self.foundation_size.depth, 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 + 2 \tan(\phi) \cdot (1 - \sin(\phi))^2
-                  \cdot \dfrac{D_f}{B}
-        """
-        depth, width = self.foundation_size.depth, self.foundation_size.width
-        return d_q(self.friction_angle, 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 - \dfrac{\alpha}{90})^2
-        """
-        return i_c(self.load_angle)
-
-    @property
-    def i_q(self) -> float:
-        r"""Inclination factor :math:`I_q`.
-
-        :Equation:
-
-        .. math:: i_q = (1 - \dfrac{\alpha}{90})^2
-        """
-        return i_q(self.load_angle)
-
-    @property
-    def i_gamma(self) -> float:
-        r"""Inclination factor :math:`I_{\gamma}`.
-
-        :Equation:
-
-        .. math:: i_{\gamma} = \left(1 - \dfrac{\alpha}{\phi} \right)^2
-        """
-        return i_gamma(self.friction_angle, self.load_angle)

geolysis/utils/exceptions.py

@@ -1,65 +0,0 @@
-from collections import UserString
-from typing import Any
-
-
-class ErrorMsg(UserString):
-    def __init__(self, *, param_name: str = None,
-                 param_value: Any = None,
-                 symbol: str = None,
-                 param_value_bound: Any = None,
-                 msg: str = None):
-        if not msg:
-            msg = f"{param_name}: {param_value!r} must be {symbol} {param_value_bound}"
-
-        super().__init__(msg)
-
-        self.param_name = param_name
-        self.param_value = param_value
-        self.symbol = symbol
-        self.param_value_bound = param_value_bound
-
-    @property
-    def msg(self):
-        return self.data
-
-    def __add__(self, other):
-        msg = self.msg + str(other)
-        return self.__class__(param_name=self.param_name,
-                              param_value=self.param_value,
-                              symbol=self.symbol,
-                              param_value_bound=self.param_value_bound,
-                              msg=msg)
-
-    def __radd__(self, other):
-        msg = str(other) + self.msg
-        return self.__class__(param_name=self.param_name,
-                              param_value=self.param_value,
-                              symbol=self.symbol,
-                              param_value_bound=self.param_value_bound,
-                              msg=msg)
-
-    def __repr__(self) -> str:
-        return f"ErrorMsg(param_name={self.param_name}, " \
-               f"param_value={self.param_value}, " \
-               f"symbol={self.symbol}, " \
-               f"param_value_bound={self.param_value_bound}, msg={self.msg!r})"
-
-    def to_dict(self) -> dict:
-        return {
-            "param_name": self.param_name,
-            "param_value": self.param_value,
-            "symbol": self.symbol,
-            "param_value_bound": self.param_value_bound,
-            "message": self.msg
-        }
-
-
-class ValidationError(ValueError):
-    """Exception raised when a validation error occurs."""
-
-    def __init__(self, error: ErrorMsg):
-        super().__init__(error)
-        self.error = error
-
-    def __repr__(self):
-        return f"ValidationError(error={self.error!r})"

geolysis/utils/validators.py

@@ -1,119 +0,0 @@
-"""validators"""
-import operator
-from functools import wraps
-from typing import Any, Callable, Iterable, TypeAlias, List, Tuple, Sequence
-
-from .exceptions import ErrorMsg, ValidationError
-
-Number: TypeAlias = int | float
-
-
-class _Validator:
-
-    def __init__(self, bound: Any, /, *,
-                 symbol: str,
-                 check: Callable,
-                 exc_type: Callable,
-                 err_msg: str):
-        self.bound = bound
-        self.symbol = symbol
-        self.check = check
-        self.exc_type = exc_type
-        self.err_msg = err_msg
-
-    def check_val(self, val, fname: str):
-        raise NotImplementedError
-
-    def __call__(self, fn):
-        @wraps(fn)
-        def wrapper(obj, val):
-            if isinstance(val, List | Tuple):
-                for v in val:
-                    self.check_val(v, fn.__name__)
-            else:
-                self.check_val(val, fn.__name__)
-
-            fn(obj, val)
-
-        return wrapper
-
-
-class _NumValidator(_Validator):
-
-    def check_val(self, v: Number, fname: str):
-        if not self.check(v, self.bound):
-            msg = ErrorMsg(msg=self.err_msg,
-                           param_name=fname,
-                           param_value=v,
-                           symbol=self.symbol,
-                           param_value_bound=self.bound)
-            raise self.exc_type(msg)
-
-
-class _LenValidator(_Validator):
-
-    def __call__(self, fn):
-        @wraps(fn)
-        def wrapper(obj, val: Sequence):
-            if not self.check(len(val), self.bound):
-                msg = ErrorMsg(msg=self.err_msg,
-                               param_name=fn.__name__,
-                               param_value=val,
-                               symbol=self.symbol,
-                               param_value_bound=self.bound)
-                msg = "Length of " + msg
-                raise self.exc_type(msg)
-            fn(obj, val)
-
-        return wrapper
-
-
-class _InValidator(_Validator):
-    def check_val(self, v, fname):
-        if not self.check(self.bound, v):
-            msg = ErrorMsg(msg=self.err_msg,
-                           param_name=fname,
-                           param_value=v,
-                           symbol=self.symbol,
-                           param_value_bound=self.bound)
-            raise self.exc_type(msg)
-
-
-def in_(bound: Iterable[Any], /, *, exc_type=ValidationError, err_msg=None):
-    return _InValidator(bound, symbol="in", check=operator.contains,
-                        exc_type=exc_type, err_msg=err_msg)
-
-
-def min_len(bound: int, /, *, exc_type=ValidationError, err_msg=None):
-    return _LenValidator(bound, symbol=">=", check=operator.ge,
-                         exc_type=exc_type, err_msg=err_msg)
-
-
-def lt(bound: Number, /, *, exc_type=ValidationError, err_msg=None):
-    return _NumValidator(bound, symbol="<", check=operator.lt,
-                         exc_type=exc_type, err_msg=err_msg)
-
-
-def le(bound: Number, /, *, exc_type=ValidationError, err_msg=None):
-    return _NumValidator(bound, symbol="<=", check=operator.le,
-                         exc_type=exc_type, err_msg=err_msg)
-
-
-def eq(bound: Number, /, *, exc_type=ValidationError, err_msg=None):
-    return _NumValidator(bound, symbol="==", check=operator.eq,
-                         exc_type=exc_type, err_msg=err_msg)
-
-
-def ne(bound: Number, /, *, exc_type=ValidationError, err_msg=None):
-    return _NumValidator(bound, symbol="!=", check=operator.ne,
-                         exc_type=exc_type, err_msg=err_msg)
-
-
-def ge(bound: Number, /, *, exc_type=ValidationError, err_msg=None):
-    return _NumValidator(bound, symbol=">=", check=operator.ge,
-                         exc_type=exc_type, err_msg=err_msg)
-
-
-def gt(bound: Number, /, *, exc_type=ValidationError, err_msg=None):
-    return _NumValidator(bound, symbol=">", check=operator.gt,
-                         exc_type=exc_type, err_msg=err_msg)

geolysis-0.9.0.dist-info/METADATA

@@ -1,206 +0,0 @@
-Metadata-Version: 2.4
-Name: geolysis
-Version: 0.9.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/dev/docs/source/_static/branding/geolysislogo.svg" 
-alt="geolysislogo" width="75%" />
-</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/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. It offers tools for soil classification, Standard Penetration
-Test (SPT) analysis, and bearing capacity estimation, among others.
-
-The `geolysis` package is among three other projects, `geolysis.gui`,
-`geolysis.excel`, and `geolysis.ai`.
-
-Here are brief descriptions of the `geolysis` projects:
-
-1. `geolysis`
-
-   A python package (library) which provides the core functionalities for
-   `geolysis.gui` and the `geolysis.excel` applications. Current features
-   provided by the `geolysis` package are shown in the table below.
-
-   <table>
-    <tr>
-        <td><strong>Soil Classification</strong></td>
-        <td>AASHTO Classification System</td>
-    </tr>
-    <tr>
-        <td></td>
-        <td>Unified Soil Classification System</td>
-    </tr>
-    <tr>
-        <td><strong>Standard Penetration Test (SPT) Analysis</strong></td>
-        <td>SPT Energy Correction</td>
-    </tr>
-    <tr>
-        <td></td>
-        <td>SPT Overburden Pressure Correction</td>
-    </tr>
-    <tr>
-        <td></td>
-        <td>SPT Dilatancy Correction</td>
-    </tr>
-    <tr>
-        <td></td>
-        <td>SPT N-Design Calculation</td>
-    </tr>
-    <tr>
-        <td><strong>Bearing Capacity Estimation</strong></td>
-        <td>Allowable Bearing Capacity Estimation</td>
-    </tr>
-    <tr>
-        <td></td>
-        <td>Ultimate Bearing Capacity Estimation</td>
-    </tr>
-   </table>
-
-2. `geolysis.gui`
-
-   A graphical user interface that allows users to interact with the `geolysis`
-   package. Through this interface, users can view generated reports and
-   visualizations, such as Particle Size Distribution (PSD) curves, Atterberg
-   Limits plots, and Compaction curves, among others.
-
-3. `geolysis.excel`
-
-   An add-in for Microsoft Excel that performs simple geotechnical analysis.
-   It offers some features similar to `geolysis.gui` within Microsoft Excel.
-   Below is an example of the Microsoft Excel addin.
-
-   <div align="center">
-    <img src="https://raw.githubusercontent.com/patrickboateng/geolysis/main/docs/_static/geolysis_excel_example.gif" 
-    alt="geolysis excel example" width="100%" />
-   </div><br>
-
-4. `geolysis.ai`
-
-   Offers machine learning models that are trained using geotechnical data.
-
-## Project Structure
-
-    .
-    ├── .github        # GitHub Actions
-    ├── docs           # Documentation files
-    ├── geolysis       # Source files
-    ├── tests          # Automated tests
-    └── README.md
-
-## Table of Contents
-
-- [Installation](#installation)
-- [Usage Example](#usage-example)
-- [Documentation](#documentation)
-- [Contributing](#contributing)
-- [License](#license)
-- [Contact](#contact)
-
-## Installation
-
-```shell
-$ pip install geolysis
-```
-
-## Usage Example
-
-```python
-
->>> from geolysis.soil_classifier import create_soil_classifier
->>> uscs_clf = create_soil_classifier(liquid_limit=34.1,
-...                                   plastic_limit=21.1,
-...                                   fines=47.88,
-...                                   sand=37.84,
-...                                   clf_type="USCS")
->>> clf = uscs_clf.classify()
->>> clf
-SoilClf(symbol='SC', description='Clayey sands')
->>> clf.symbol
-'SC'
->>> clf.description
-'Clayey sands'
-
-```
-
-```python
-
->>> from geolysis.soil_classifier import create_soil_classifier
->>> aashto_clf = create_soil_classifier(liquid_limit=34.1,
-...                                     plastic_limit=21.1,
-...                                     fines=47.88,
-...                                     clf_type="AASHTO")
->>> clf = aashto_clf.classify()
->>> clf
-SoilClf(symbol='A-6(4)', description='Clayey soils')
->>> clf.symbol
-'A-6(4)'
->>> clf.description
-'Clayey soils'
-
-```
-
-Check out more examples
-[here](https://docs.geolysis.io/en/latest/user_guide/getting_started.html#quick-start)
-
-## Documentation
-
-Full documentation is available [here](https://docs.geolysis.io/en/latest/)
-
-## Contributing
-
-Contribution guidelines can be
-found [here](https://docs.geolysis.io/en/latest/dev_guide/index.html)
-
-## 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 [boatengpato.pb@gmail.com](mailto:boatengpato.pb@gmail.com)