geolysis 0.10.3__py3-none-any.whl → 0.12.0__py3-none-any.whl

geolysis/soil_classifier.py

@@ -35,8 +35,7 @@ class _Clf(tuple, enum.Enum):
 
 
 class USCSSymbol(_Clf):
-    """
-    Unified Soil Classification System (USCS) symbols and descriptions.
+    """Unified Soil Classification System (USCS) symbols and descriptions.
 
     Each member represents a USCS soil type, grading, or plasticity symbol.
     Aliases are provided where applicable.
@@ -354,8 +353,7 @@ class _SizeDistribution:
     Features obtained from the Particle Size Distribution graph.
     """
 
-    def __init__(self, d_10: float = 0.0, d_30: float = 0.0,
-                 d_60: float = 0.0):
+    def __init__(self, d_10: float = 0.0, d_30: float = 0.0, d_60: float = 0.0):
         self.d_10 = d_10
         self.d_30 = d_30
         self.d_60 = d_60
@@ -365,7 +363,7 @@ class _SizeDistribution:
 
     @property
     def coeff_of_curvature(self) -> float:
-        return (self.d_30 ** 2.0) / (self.d_60 * self.d_10)
+        return (self.d_30**2.0) / (self.d_60 * self.d_10)
 
     @property
     def coeff_of_uniformity(self) -> float:
@@ -398,12 +396,12 @@ class PSD:
     """
 
     def __init__(
-            self,
-            fines: float,
-            sand: float,
-            d_10: float = 0,
-            d_30: float = 0,
-            d_60: float = 0,
+        self,
+        fines: float,
+        sand: float,
+        d_10: float = 0,
+        d_30: float = 0,
+        d_60: float = 0,
     ):
         """
         :param fines: Percentage of fines in soil sample (%) i.e. The
@@ -650,10 +648,10 @@ class USCS:
     """
 
     def __init__(
-            self,
-            atterberg_limits: AtterbergLimits,
-            psd: PSD,
-            organic=False,
+        self,
+        atterberg_limits: AtterbergLimits,
+        psd: PSD,
+        organic=False,
     ):
         """
         :param atterberg_limits: Atterberg limits of the soil.
@@ -780,9 +778,9 @@ class USCS:
 
 
 def create_aashto_classifier(
-        liquid_limit: float,
-        plastic_limit: float,
-        fines: float,
+    liquid_limit: float,
+    plastic_limit: float,
+    fines: float,
 ) -> AASHTO:
     """A helper function that encapsulates the creation of a AASHTO
     classifier.
@@ -807,14 +805,14 @@ def create_aashto_classifier(
 
 
 def create_uscs_classifier(
-        liquid_limit: float,
-        plastic_limit: float,
-        fines: float,
-        sand: float,
-        d_10: float = 0,
-        d_30: float = 0,
-        d_60: float = 0,
-        organic: bool = False,
+    liquid_limit: float,
+    plastic_limit: float,
+    fines: float,
+    sand: float,
+    d_10: float = 0,
+    d_30: float = 0,
+    d_60: float = 0,
+    organic: bool = False,
 ):
     """A helper function that encapsulates the creation of a USCS
     classifier.

geolysis/spt.py

@@ -61,9 +61,9 @@ class SPT:
     """
 
     def __init__(
-            self,
-            corrected_spt_n_values: Sequence[float],
-            method: SPTDesignMethod.WEIGHTED = "wgt",
+        self,
+        corrected_spt_n_values: Sequence[float],
+        method: SPTDesignMethod.WEIGHTED = "wgt",
     ):
         """
         :param corrected_spt_n_values: Corrected SPT N-values within the
@@ -82,12 +82,12 @@ class SPT:
     @corrected_spt_n_values.setter
     @validate_func_args
     def corrected_spt_n_values(
-            self,
-            corrected_spt_n_values: Annotated[
-                Sequence[float],
-                MustHaveLengthGreaterThan(1),
-                MustHaveValuesBetween(min_value=1.0, max_value=100.0),
-            ],
+        self,
+        corrected_spt_n_values: Annotated[
+            Sequence[float],
+            MustHaveLengthGreaterThan(1),
+            MustHaveValuesBetween(min_value=1.0, max_value=100.0),
+        ],
     ) -> None:
         self._corrected_spt_n_values = corrected_spt_n_values
 
@@ -115,7 +115,7 @@ class SPT:
         sum_wgts = 0.0
 
         for i, corr_spt_n_val in enumerate(vals, start=1):
-            wgt = 1 / i ** 2
+            wgt = 1 / i**2
             sum_total += wgt * corr_spt_n_val
             sum_wgts += wgt
 
@@ -220,14 +220,14 @@ class EnergyCorrection:
     }
 
     def __init__(
-            self,
-            recorded_spt_n_value: int,
-            *,
-            energy_percentage=0.6,
-            borehole_diameter=65.0,
-            rod_length=3.0,
-            hammer_type=HammerType.DONUT_1,
-            sampler_type=SamplerType.STANDARD,
+        self,
+        recorded_spt_n_value: int,
+        *,
+        energy_percentage=0.6,
+        borehole_diameter=65.0,
+        rod_length=3.0,
+        hammer_type=HammerType.DONUT_1,
+        sampler_type=SamplerType.STANDARD,
     ):
         """
         :param recorded_spt_n_value: Recorded SPT N-value from field.
@@ -254,8 +254,7 @@ class EnergyCorrection:
     @recorded_spt_n_value.setter
     @validate_func_args
     def recorded_spt_n_value(
-            self,
-            val: Annotated[int, MustBeBetween(min_value=0, max_value=100)]
+        self, val: Annotated[int, MustBeBetween(min_value=0, max_value=100)]
     ) -> None:
         self._recorded_spt_value = val
 
@@ -267,8 +266,7 @@ class EnergyCorrection:
     @energy_percentage.setter
     @validate_func_args
     def energy_percentage(
-            self,
-            val: Annotated[float, MustBeBetween(min_value=0.0, max_value=1.0)]
+        self, val: Annotated[float, MustBeBetween(min_value=0.0, max_value=1.0)]
     ) -> None:
         self._energy_percentage = val
 
@@ -280,8 +278,7 @@ class EnergyCorrection:
     @borehole_diameter.setter
     @validate_func_args
     def borehole_diameter(
-            self, val: Annotated[
-                float, MustBeBetween(min_value=65.0, max_value=200.0)]
+        self, val: Annotated[float, MustBeBetween(min_value=65.0, max_value=200.0)]
     ) -> None:
         self._borehole_diameter = val
 
@@ -302,8 +299,7 @@ class EnergyCorrection:
     @hammer_type.setter
     @validate_func_args
     def hammer_type(
-            self,
-            hammer_type: Annotated[HammerType, MustBeMemberOf(HammerType)]
+        self, hammer_type: Annotated[HammerType, MustBeMemberOf(HammerType)]
     ):
         self._hammer_type = hammer_type
 
@@ -313,8 +309,7 @@ class EnergyCorrection:
 
     @sampler_type.setter
     @validate_func_args
-    def sampler_type(self,
-                     val: Annotated[SamplerType, MustBeMemberOf(SamplerType)]):
+    def sampler_type(self, val: Annotated[SamplerType, MustBeMemberOf(SamplerType)]):
         self._sampler_type = val
 
     @property
@@ -362,10 +357,10 @@ class EnergyCorrection:
         `ENERGY`: 0.6, 0.55, etc
         """
         numerator = (
-                self.hammer_efficiency
-                * self.borehole_diameter_correction
-                * self.sampler_correction
-                * self.rod_length_correction
+            self.hammer_efficiency
+            * self.borehole_diameter_correction
+            * self.sampler_correction
+            * self.rod_length_correction
         )
         return numerator / self.energy_percentage
 
@@ -406,29 +401,17 @@ class OPC:
     @std_spt_n_value.setter
     @validate_func_args
     def std_spt_n_value(
-            self, val: Annotated[
-                float, MustBeBetween(min_value=0.0, max_value=100.0)]
+        self, val: Annotated[float, MustBeBetween(min_value=0.0, max_value=100.0)]
     ):
         self._std_spt_n_value = val
 
     @round_(ndigits=1)
     def corrected_spt_n_value(self) -> float:
-        r"""Corrected SPT N-value.
-
-        $$
-        (N_1)_{60} = C_N \cdot N_{60}
-        $$
-
-        !!! note
-
-            `60` is used in this case to represent `60%` hammer
-             efficiency and can be any percentage of hammer efficiency
-             e.g. $N_{55}$ for `55%` hammer efficiency.
-        """
-        corrected_spt = self.correction() * self.std_spt_n_value
+        r"""Corrected SPT N-value."""
         # Corrected SPT should not be more
         # than 2 times the Standardized SPT
-        return min(corrected_spt, 2 * self.std_spt_n_value)
+        correction = min(self.correction(), 2.0)
+        return correction * self.std_spt_n_value
 
     @abstractmethod
     def correction(self) -> float:
@@ -447,22 +430,11 @@ class GibbsHoltzOPC(OPC):
 
     @eop.setter
     @validate_func_args
-    def eop(self, val: Annotated[
-        float, MustBeBetween(min_value=0.0, max_value=280.0)]):
+    def eop(self, val: Annotated[float, MustBeBetween(min_value=0.0, max_value=280.0)]):
         self._eop = val
 
     def correction(self) -> float:
-        r"""SPT Correction.
-
-        $$
-        C_N = \dfrac{350}{\sigma_o + 70} \, \sigma_o \le 280kN/m^2
-        $$
-
-        $\frac{N_c}{N_{60}}$ should lie between 0.45 and 2.0, if
-        $\frac{N_c}{N_{60}}$ is greater than 2.0, :math:`N_c` should be
-        divided by 2.0 to obtain the design value used in finding the
-        bearing capacity of the soil.
-        """
+        r"""SPT Correction."""
         corr = 350.0 / (self.eop + 70.0)
         return corr / 2.0 if corr > 2.0 else corr
 
@@ -476,22 +448,7 @@ class BazaraaPeckOPC(OPC):
     STD_PRESSURE: Final = 71.8
 
     def correction(self) -> float:
-        r"""SPT Correction.
-
-        $$
-        C_N = \dfrac{4}{1 + 0.0418 \cdot \sigma_o}, \,
-              \sigma_o \lt 71.8kN/m^2
-        $$
-
-        $$
-        C_N = \dfrac{4}{3.25 + 0.0104 \cdot \sigma_o},
-               \, \sigma_o \gt 71.8kN/m^2
-        $$
-
-        $$
-        C_N = 1 \, , \, \sigma_o = 71.8kN/m^2
-        $$
-        """
+        r"""SPT Correction."""
         if isclose(self.eop, self.STD_PRESSURE, rel_tol=0.01):
             corr = 1.0
         elif self.eop < self.STD_PRESSURE:
@@ -517,12 +474,7 @@ class PeckOPC(OPC):
         self._eop = val
 
     def correction(self) -> float:
-        r"""SPT Correction.
-
-        $$
-        C_N = 0.77 \log \left(\dfrac{2000}{\sigma_o} \right)
-        $$
-        """
+        r"""SPT Correction."""
         return 0.77 * log10(2000.0 / self.eop)
 
 
@@ -532,12 +484,7 @@ class LiaoWhitmanOPC(OPC):
     """
 
     def correction(self) -> float:
-        r"""SPT Correction.
-
-        $$
-        C_N = \sqrt{\dfrac{100}{\sigma_o}}
-        $$
-        """
+        r"""SPT Correction."""
         return sqrt(100.0 / self.eop)
 
 
@@ -545,12 +492,7 @@ class SkemptonOPC(OPC):
     """Overburden Pressure Correction according to `Skempton (1986)`."""
 
     def correction(self) -> float:
-        r"""SPT Correction.
-
-        $$
-        C_N = \dfrac{2}{1 + 0.01044 \cdot \sigma_o}
-        $$
-        """
+        r"""SPT Correction."""
         return 2.0 / (1.0 + 0.01044 * self.eop)
 
 
@@ -580,32 +522,20 @@ class DilatancyCorrection:
     @corr_spt_n_value.setter
     @validate_func_args
     def corr_spt_n_value(
-            self, val: Annotated[
-                float, MustBeBetween(min_value=0.0, max_value=100.0)]
+        self, val: Annotated[float, MustBeBetween(min_value=0.0, max_value=100.0)]
     ):
         self._corr_spt_n_value = val
 
     @round_(ndigits=1)
     def corrected_spt_n_value(self) -> float:
-        r"""Corrected SPT N-value.
-
-        $$
-        (N_1)_{60} = 15 + \dfrac{1}{2}((N_1)_{60} - 15) \, , \,
-                     (N_1)_{60} \gt 15
-        $$
-
-        $$
-        (N_1)_{60} = (N_1)_{60} \, , \, (N_1)_{60} \le 15
-        $$
-        """
+        r"""Corrected SPT N-value."""
         if self.corr_spt_n_value <= 15.0:
             return self.corr_spt_n_value
         return 15.0 + 0.5 * (self.corr_spt_n_value - 15.0)
 
 
 class OPCType(AbstractStrEnum):
-    """
-    Enumeration of overburden pressure correction (OPC) methods.
+    """Enumeration of overburden pressure correction (OPC) methods.
 
     Each member represents a method used to correct SPT results
     for the effects of overburden pressure in geotechnical design.
@@ -638,18 +568,16 @@ _opctypes = {
 
 @validate_func_args
 def create_overburden_pressure_correction(
-        std_spt_n_value: float,
-        eop: float,
-        opc_type: Annotated[OPCType | str, MustBeMemberOf(OPCType)] = "gibbs",
+    std_spt_n_value: float,
+    eop: float,
+    opc_type: Annotated[OPCType | str, MustBeMemberOf(OPCType)] = "gibbs",
 ):
     """A factory function that encapsulates the creation of overburden
     pressure correction.
 
     :param std_spt_n_value: SPT N-value standardized for field
                             procedures.
-
     :param eop: Effective overburden pressure ($kPa$).
-
     :param opc_type: Overburden Pressure Correction type to apply.
     """
     opc_type = OPCType(opc_type)

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

@@ -1,31 +1,12 @@
 import enum
 import functools
-import math
-from math import exp, inf, isclose, log10, pi, sqrt
-from statistics import fmean as mean
 from typing import Callable
 
 from func_validator import ValidationError
 
-__all__ = [
-    "AbstractStrEnum",
-    "ValidationError",
-    "inf",
-    "pi",
-    "deg2rad",
-    "rad2deg",
-    "tan",
-    "cot",
-    "sin",
-    "cos",
-    "arctan",
-    "round_",
-    "mean",
-    "exp",
-    "isclose",
-    "log10",
-    "sqrt",
-]
+from .math import *
+
+__all__ = ["AbstractStrEnum", "ValidationError", "add_repr", "round_"]
 
 
 class StrEnumMeta(enum.EnumMeta):
@@ -46,39 +27,21 @@ class AbstractStrEnum(enum.StrEnum, metaclass=StrEnumMeta):
     """
 
 
-def deg2rad(x: float, /) -> float:
-    """Convert angle x from degrees to radians."""
-    return math.radians(x)
-
-
-def rad2deg(x: float, /) -> float:
-    """Convert angle x from radians to degrees."""
-    return math.degrees(x)
-
-
-def tan(x: float, /) -> float:
-    """Return the tangent of x (measured in degrees)."""
-    return math.tan(deg2rad(x))
-
-
-def cot(x: float, /) -> float:
-    """Return the cotangent of x (measured in degrees)."""
-    return 1 / tan(x)
-
-
-def sin(x: float, /) -> float:
-    """Return the sine of x (measured in degrees)."""
-    return math.sin(deg2rad(x))
+def add_repr(cls):
+    """A class decorator that adds a __repr__ method to the class."""
 
+    def __repr__(self) -> str:
+        inst_attrs = self.__dict__
+        attrs = (f"{key.strip('_')}={val}" for key, val in inst_attrs.items())
+        return f"{type(self).__name__}({', '.join(attrs)})"
 
-def cos(x: float, /) -> float:
-    """Return the cosine of x (measured in degrees)."""
-    return math.cos(deg2rad(x))
+    def __str__(self) -> str:
+        return repr(self)
 
+    cls.__repr__ = __repr__
+    cls.__str__ = __str__
 
-def arctan(x: float, /) -> float:
-    """Return the arc tangent (measured in degrees) of x."""
-    return rad2deg(math.atan(x))
+    return cls
 
 
 def round_(ndigits: int) -> Callable:

geolysis/utils/math.py

@@ -0,0 +1,57 @@
+import math
+from math import exp, inf, isclose, log10, pi, sqrt, isinf, atan
+from statistics import fmean as mean
+
+__all__ = [
+    "atan",
+    "inf",
+    "isinf",
+    "pi",
+    "deg2rad",
+    "rad2deg",
+    "tandeg",
+    "cotdeg",
+    "sindeg",
+    "cosdeg",
+    "arctandeg",
+    "mean",
+    "exp",
+    "isclose",
+    "log10",
+    "sqrt",
+]
+
+
+def deg2rad(x: float, /) -> float:
+    """Convert angle x from degrees to radians."""
+    return math.radians(x)
+
+
+def rad2deg(x: float, /) -> float:
+    """Convert angle x from radians to degrees."""
+    return math.degrees(x)
+
+
+def tandeg(x: float, /) -> float:
+    """Return the tangent of x (measured in degrees)."""
+    return math.tan(deg2rad(x))
+
+
+def cotdeg(x: float, /) -> float:
+    """Return the cotangent of x (measured in degrees)."""
+    return 1 / tandeg(x)
+
+
+def sindeg(x: float, /) -> float:
+    """Return the sine of x (measured in degrees)."""
+    return math.sin(deg2rad(x))
+
+
+def cosdeg(x: float, /) -> float:
+    """Return the cosine of x (measured in degrees)."""
+    return math.cos(deg2rad(x))
+
+
+def arctandeg(x: float, /) -> float:
+    """Return the arc tangent (measured in degrees) of x."""
+    return rad2deg(math.atan(x))

{geolysis-0.10.3.dist-info → geolysis-0.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geolysis
-Version: 0.10.3
+Version: 0.12.0
 Summary: geolysis is an opensource software for geotechnical engineering analysis and modeling.
 Author-email: Patrick Boateng <boatengpato.pb@gmail.com>
 License: MIT License
@@ -57,7 +57,8 @@ 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).
 
-`geolysis` has only one project dependency which is [func-validator](https://github.com/patrickboateng/func-validator/)
+`geolysis` has only one project dependency which
+is [func-validator](https://github.com/patrickboateng/func-validator/)
 for validating `function` (and `method`) arguments.
 
 The rest of this **README** provides an overview of the `geolysis` python
@@ -83,58 +84,64 @@ $ 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
+- [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
+    - [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_
-
+    - [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
-  ```
+### Bearing Capacity
+
+- **Allowable Bearing Capacity (ABC)**
+
+    ```python
+    from geolysis.bearing_capacity.abc import create_abc_4_cohesionless_soils
+    ```
 
+- **Ultimate Bearing Capacity (UBC)**
 
-- **Soil Classification**
- 
   ```python
-  from geolysis.soil_classifier import create_uscs_classifier
-  from geolysis.soil_classifier import create_aashto_classifier
+  from geolysis.bearing_capacity.ubc import create_ubc_4_all_soil_types
   ```
- 
-- **Standard Penetration Test (SPT) Analysis**
- 
+
+### 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
 
+These are the main components of the project structure
+
     .
     ├── .github            # GitHub Actions
     ├── docs               # Documentation files
@@ -171,7 +178,8 @@ 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/)
+Check out
+the [contribution guidelines](https://docs.geolysis.io/en/latest/dev_guide/)
 
 ## License