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

geolysis/spt.py

@@ -1,69 +1,103 @@
-"""This module provides classes for performing Standard Penetration Test (SPT) 
-corrections, including energy, overburden pressure, and dilatancy corrections, 
-as well as calculating design N-values.
-"""
 import enum
 from abc import abstractmethod
-from typing import Final, Literal, Sequence
-
-from .utils import enum_repr, isclose, log10, mean, round_, sqrt, validators
-from .utils.exceptions import ErrorMsg, ValidationError
-
-__all__ = ["SPTNDesign",
-           "HammerType",
-           "SamplerType",
-           "EnergyCorrection",
-           "GibbsHoltzOPC",
-           "BazaraaPeckOPC",
-           "PeckOPC",
-           "LiaoWhitmanOPC",
-           "SkemptonOPC",
-           "DilatancyCorrection",
-           "OPCType",
-           "create_overburden_pressure_correction"]
-
-
-class SPTNDesign:
+from typing import Annotated, Final, Sequence
+
+from func_validator import (
+    validate_func_args,
+    MustBeBetween,
+    MustBePositive,
+    MustBeMemberOf,
+    MustBeNonNegative,
+    MustBeGreaterThanOrEqual,
+    MustHaveLengthGreaterThan,
+    MustHaveValuesBetween,
+)
+
+from .utils import AbstractStrEnum, isclose, log10, mean, round_, sqrt
+
+__all__ = [
+    "SPT",
+    "HammerType",
+    "SamplerType",
+    "EnergyCorrection",
+    "GibbsHoltzOPC",
+    "BazaraaPeckOPC",
+    "PeckOPC",
+    "LiaoWhitmanOPC",
+    "SkemptonOPC",
+    "DilatancyCorrection",
+    "OPCType",
+    "create_overburden_pressure_correction",
+]
+
+
+class SPTDesignMethod(AbstractStrEnum):
+    """Enumeration of Standard Penetration Test (SPT) design methods.
+
+    Each member represents a different method for interpreting SPT
+    results in geotechnical design calculations.
+    """
+
+    MINIMUM = "min"
+    """Use the minimum SPT value."""
+
+    AVERAGE = "avg"
+    """Use the average SPT value."""
+
+    WEIGHTED = "wgt"
+    """Use the weighted SPT value."""
+
+
+class SPT:
     """SPT Design Calculations.
 
-    Due to uncertainty in field procedure in standard penetration test and also
-    to consider all the N-value in the influence zone of a foundation, a method
-    was suggested to calculate the design N-value which should be used in
-    calculating the allowable bearing capacity of shallow foundation rather
-    than using a particular N-value. All the N-value from the influence zone is
-    taken under consideration by giving the highest weightage to the closest
-    N-value from the base.
+    Due to uncertainty in field procedure in standard penetration test
+    and also to consider all the N-value in the influence zone of a
+    foundation, a method was suggested to calculate the design N-value
+    which should be used in calculating the allowable bearing capacity
+    of shallow foundation rather than using a particular N-value. All
+    the N-value from the influence zone is taken under consideration by
+    giving the highest weightage to the closest N-value from the base.
     """
 
-    def __init__(self, corrected_spt_n_values: Sequence[float],
-                 method: Literal["min", "avg", "wgt"] = "wgt") -> None:
+    def __init__(
+            self,
+            corrected_spt_n_values: Sequence[float],
+            method: SPTDesignMethod.WEIGHTED = "wgt",
+    ):
         """
         :param corrected_spt_n_values: Corrected SPT N-values within the
                                        foundation influence zone.
-        :type corrected_spt_n_values: Sequence[float]
         """
         self.corrected_spt_n_values = corrected_spt_n_values
         self.method = method
 
     @property
     def corrected_spt_n_values(self) -> Sequence[float]:
-        """Corrected SPT N-values within the foundation influence zone."""
+        """
+        Corrected SPT N-values within the foundation influence zone.
+        """
         return self._corrected_spt_n_values
 
     @corrected_spt_n_values.setter
-    @validators.le(100.0)
-    @validators.gt(0.0)
-    @validators.min_len(1)
-    def corrected_spt_n_values(self, val: Sequence[float]) -> None:
-        self._corrected_spt_n_values = val
+    @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),
+            ],
+    ) -> None:
+        self._corrected_spt_n_values = corrected_spt_n_values
 
     @property
     def method(self):
         return self._method
 
     @method.setter
-    @validators.in_(("min", "avg", "wgt"))
-    def method(self, val: str) -> None:
+    @validate_func_args
+    def method(self, val: Annotated[str, MustBeMemberOf(SPTDesignMethod)]):
         self._method = val
 
     @staticmethod
@@ -89,97 +123,121 @@ class SPTNDesign:
 
     @round_(ndigits=1)
     def n_design(self):
-        r"""Calculates the SPT N-design within the foundation influence zone.
+        r"""Calculates the SPT N-design within the foundation influence
+        zone.
 
-        If ``method="min"``, it returns the minimum N-value within the foundation
-        influence zone as the SPT N-design value. This approach was suggested
-        by ``Terzaghi & Peck (1948)``.
+        If `method="min"`, it returns the minimum N-value within the
+        foundation influence zone as the SPT N-design value. This
+        approach was suggested by `Terzaghi & Peck (1948)`.
 
-        if ``method="avg"``, it returns the average N-value within the foundation
-        influence zone as the SPT N-design value.
-
-        if ``method="wgt"``, it returns the weighted average N-value within the
+        if `method="avg"`, it returns the average N-value within the
         foundation influence zone as the SPT N-design value.
 
-        :Equation:
+        if `method="wgt"`, it returns the weighted average N-value
+        within the foundation influence zone as the SPT N-design value.
 
-        .. math::
 
-            N_{design} = \dfrac{\sum_{i=1}^{n} \frac{N_i}{i^2}}
-                         {\sum_{i=1}^{n}\frac{1}{i^2}}
+        $$
+        N_{design} = \dfrac{\sum_{i=1}^{n} \frac{N_i}{i^2}}
+                      {\sum_{i=1}^{n}\frac{1}{i^2}}
+        $$
         """
         if self.method == "min":
-            return self._min_spt_n_design(self.corrected_spt_n_values)
+            _n_design = self._min_spt_n_design
         elif self.method == "avg":
-            return self._avg_spt_n_design(self.corrected_spt_n_values)
-        else:  # method="wgt"
-            return self._wgt_spt_n_design(self.corrected_spt_n_values)
+            _n_design = self._avg_spt_n_design
+        else:
+            _n_design = self._wgt_spt_n_design
 
+        return _n_design(self.corrected_spt_n_values)
+
+
+class HammerType(AbstractStrEnum):
+    """Enumeration of hammer types used in geotechnical testing.
+
+    Each member represents a different type of hammer used for
+    Standard Penetration Test (SPT) or other soil testing methods.
+    """
 
-@enum_repr
-class HammerType(enum.StrEnum):
-    """Enumeration of hammer types."""
     AUTOMATIC = enum.auto()
+    """Automatic hammer."""
+
     DONUT_1 = enum.auto()
+    """Donut-type hammer, variant 1."""
+
     DONUT_2 = enum.auto()
+    """Donut-type hammer, variant 2."""
+
     SAFETY = enum.auto()
+    """Safety hammer."""
+
     DROP = enum.auto()
+    """Drop hammer."""
+
     PIN = enum.auto()
+    """Pin-type hammer."""
+
 
+class SamplerType(AbstractStrEnum):
+    """Enumeration of soil sampler types.
+
+    Each member represents a different type of sampler used in
+    Standard Penetration Tests (SPT) or other geotechnical sampling
+    methods.
+    """
 
-@enum_repr
-class SamplerType(enum.StrEnum):
-    """Enumeration of sampler types."""
     STANDARD = enum.auto()
+    """Standard sampler."""
+
     NON_STANDARD = enum.auto()
+    """Non-standard sampler."""
 
 
 class EnergyCorrection:
     r"""SPT N-value standardized for field procedures.
 
-    On the basis of field observations, it appears reasonable to standardize
-    the field SPT N-value as a function of the input driving energy and its
-    dissipation around the sampler around the surrounding soil. The variations
-    in testing procedures may be at least partially compensated by converting
-    the measured N-value to :math:`N_{60}` assuming 60% hammer energy being
-    transferred to the tip of the standard split spoon.
+    On the basis of field observations, it appears reasonable to
+    standardize the field SPT N-value as a function of the input driving
+    energy and its dissipation around the sampler around the surrounding
+    soil. The variations in testing procedures may be at least partially
+    compensated by converting the measured N-value to $N_{60}$
+    assuming 60% hammer energy being transferred to the tip of the
+    standard split spoon.
     """
 
-    _HAMMER_EFFICIENCY_FACTORS = {HammerType.AUTOMATIC: 0.70,
-                                  HammerType.DONUT_1: 0.60,
-                                  HammerType.DONUT_2: 0.50,
-                                  HammerType.SAFETY: 0.55,
-                                  HammerType.DROP: 0.45,
-                                  HammerType.PIN: 0.45}
-
-    _SAMPLER_CORRECTION_FACTORS = {SamplerType.STANDARD: 1.00,
-                                   SamplerType.NON_STANDARD: 1.20}
-
-    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):
+    _HAMMER_EFFICIENCY_FACTORS = {
+        HammerType.AUTOMATIC: 0.70,
+        HammerType.DONUT_1: 0.60,
+        HammerType.DONUT_2: 0.50,
+        HammerType.SAFETY: 0.55,
+        HammerType.DROP: 0.45,
+        HammerType.PIN: 0.45,
+    }
+
+    _SAMPLER_CORRECTION_FACTORS = {
+        SamplerType.STANDARD: 1.00,
+        SamplerType.NON_STANDARD: 1.20,
+    }
+
+    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,
+    ):
         """
         :param recorded_spt_n_value: Recorded SPT N-value from field.
-        :type recorded_spt_n_value: int
-
-        :param energy_percentage: Energy percentage reaching the tip of the 
-                                  sampler, defaults to 0.6
-        :type energy_percentage: float, optional
-
-        :param borehole_diameter: Borehole diameter (mm), defaults to 65.0.
-        :type borehole_diameter: float, optional
 
-        :param rod_length: Length of SPT rod, defaults to 3.0. (m)
-        :type rod_length: float, optional
-
-        :param hammer_type: Hammer type, defaults to :py:enum:mem:`~HammerType.DONUT_1`
-        :type hammer_type: HammerType, optional
-
-        :param sampler_type: Sampler type, defaults to :py:enum:mem:`~SamplerType.STANDARD`
-        :type sampler_type: SamplerType, optional
+        :param energy_percentage: Energy percentage reaching the tip of
+                                  the sampler.
+        :param borehole_diameter: Borehole diameter (mm).
+        :param rod_length: Length of SPT rod, defaults to 3.0 (m).
+        :param hammer_type: Hammer type.
+        :param sampler_type: Sampler type.
         """
         self.recorded_spt_n_value = int(recorded_spt_n_value)
         self.energy_percentage = energy_percentage
@@ -194,9 +252,11 @@ class EnergyCorrection:
         return self._recorded_spt_value
 
     @recorded_spt_n_value.setter
-    @validators.le(100)
-    @validators.gt(0)
-    def recorded_spt_n_value(self, val: int) -> None:
+    @validate_func_args
+    def recorded_spt_n_value(
+            self,
+            val: Annotated[int, MustBeBetween(min_value=0, max_value=100)]
+    ) -> None:
         self._recorded_spt_value = val
 
     @property
@@ -205,9 +265,11 @@ class EnergyCorrection:
         return self._energy_percentage
 
     @energy_percentage.setter
-    @validators.le(1.0)
-    @validators.gt(0.0)
-    def energy_percentage(self, val: float) -> None:
+    @validate_func_args
+    def energy_percentage(
+            self,
+            val: Annotated[float, MustBeBetween(min_value=0.0, max_value=1.0)]
+    ) -> None:
         self._energy_percentage = val
 
     @property
@@ -216,9 +278,11 @@ class EnergyCorrection:
         return self._borehole_diameter
 
     @borehole_diameter.setter
-    @validators.le(200.0)
-    @validators.ge(65.0)
-    def borehole_diameter(self, val: float) -> None:
+    @validate_func_args
+    def borehole_diameter(
+            self, val: Annotated[
+                float, MustBeBetween(min_value=65.0, max_value=200.0)]
+    ) -> None:
         self._borehole_diameter = val
 
     @property
@@ -227,8 +291,8 @@ class EnergyCorrection:
         return self._rod_length
 
     @rod_length.setter
-    @validators.gt(0.0)
-    def rod_length(self, val: float) -> None:
+    @validate_func_args
+    def rod_length(self, val: Annotated[float, MustBePositive]):
         self._rod_length = val
 
     @property
@@ -236,17 +300,21 @@ class EnergyCorrection:
         return self._hammer_type
 
     @hammer_type.setter
-    @validators.in_(tuple(HammerType))
-    def hammer_type(self, val: HammerType) -> None:
-        self._hammer_type = val
+    @validate_func_args
+    def hammer_type(
+            self,
+            hammer_type: Annotated[HammerType, MustBeMemberOf(HammerType)]
+    ):
+        self._hammer_type = hammer_type
 
     @property
     def sampler_type(self) -> SamplerType:
         return self._sampler_type
 
     @sampler_type.setter
-    @validators.in_(tuple(SamplerType))
-    def sampler_type(self, val: SamplerType) -> None:
+    @validate_func_args
+    def sampler_type(self,
+                     val: Annotated[SamplerType, MustBeMemberOf(SamplerType)]):
         self._sampler_type = val
 
     @property
@@ -286,18 +354,19 @@ class EnergyCorrection:
     def correction(self) -> float:
         r"""Energy correction factor.
 
-        :Equation:
-
-        .. math::
+        $$
+        N_{ENERGY} = \dfrac{E_H \cdot C_B \cdot C_S
+                     \cdot C_R \cdot N}{ENERGY}
+        $$
 
-            N_{ENERGY} = \dfrac{E_H \cdot C_B \cdot C_S \cdot C_R \cdot N}{ENERGY}
-
-        ``ENERGY``: 0.6, 0.55, etc
+        `ENERGY`: 0.6, 0.55, etc
         """
-        numerator = (self.hammer_efficiency
-                     * self.borehole_diameter_correction
-                     * self.sampler_correction
-                     * self.rod_length_correction)
+        numerator = (
+                self.hammer_efficiency
+                * self.borehole_diameter_correction
+                * self.sampler_correction
+                * self.rod_length_correction
+        )
         return numerator / self.energy_percentage
 
     @round_(ndigits=1)
@@ -309,41 +378,52 @@ class EnergyCorrection:
 class OPC:
     """Base class for Overburden Pressure Correction (OPC)."""
 
-    def __init__(self, std_spt_n_value: float, eop: float) -> None:
+    def __init__(self, std_spt_n_value: float, eop: float):
         """
-        :param std_spt_n_value: SPT N-value standardized for field procedures.
-        :type std_spt_n_value: float
-
-        :param eop: Effective overburden pressure (:math:`kPa`).
-        :type eop: float
+        :param std_spt_n_value: SPT N-value standardized for field
+                                procedures.
+        :param eop: Effective overburden pressure ($kPa$).
         """
         self.std_spt_n_value = std_spt_n_value
         self.eop = eop
 
+    @property
+    def eop(self) -> float:
+        """Effective overburden pressure ($kPa$)."""
+        return self._eop
+
+    @eop.setter
+    @validate_func_args
+    def eop(self, val: Annotated[float, MustBeNonNegative]):
+        """Effective overburden pressure ($kPa$)."""
+        self._eop = val
+
     @property
     def std_spt_n_value(self) -> float:
         """SPT N-value standardized for field procedures."""
         return self._std_spt_n_value
 
     @std_spt_n_value.setter
-    @validators.le(100)
-    @validators.gt(0.0)
-    def std_spt_n_value(self, val: float) -> None:
+    @validate_func_args
+    def std_spt_n_value(
+            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.
 
-        :Equation:
-
-        .. math:: (N_1)_{60} = C_N \cdot N_{60}
+        $$
+        (N_1)_{60} = C_N \cdot N_{60}
+        $$
 
-        .. note::
+        !!! note
 
-            ``60`` is used in this case to represent ``60%`` hammer efficiency
-            and can be any percentage of hammer efficiency e.g :math:`N_{55}`
-            for ``55%`` hammer efficiency.
+            `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
         # Corrected SPT should not be more
@@ -356,67 +436,61 @@ class OPC:
 
 
 class GibbsHoltzOPC(OPC):
-    """Overburden Pressure Correction according to ``Gibbs & Holtz (1957)``."""
+    """Overburden Pressure Correction according to
+    `Gibbs & Holtz (1957)`.
+    """
 
     @property
     def eop(self) -> float:
-        """Effective overburden pressure (:math:`kpa`)."""
+        """Effective overburden pressure ($kPa$)."""
         return self._eop
 
     @eop.setter
-    @validators.le(280.0)
-    @validators.gt(0.0)
-    def eop(self, val: float) -> None:
+    @validate_func_args
+    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.
 
-        :Equation:
-
-        .. math:: C_N = \dfrac{350}{\sigma_o + 70} \, \sigma_o \le 280kN/m^2
+        $$
+        C_N = \dfrac{350}{\sigma_o + 70} \, \sigma_o \le 280kN/m^2
+        $$
 
-        :math:`\frac{N_c}{N_{60}}` should lie between 0.45 and 2.0, if
-        :math:`\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.
+        $\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.
         """
         corr = 350.0 / (self.eop + 70.0)
         return corr / 2.0 if corr > 2.0 else corr
 
 
 class BazaraaPeckOPC(OPC):
-    """Overburden Pressure Correction according to ``Bazaraa (1967)``, and
-    also by ``Peck and Bazaraa (1969)``.
+    """Overburden Pressure Correction according to `Bazaraa (1967)`, and
+    also by `Peck and Bazaraa (1969)`.
     """
 
     #: Maximum effective overburden pressure (:math:`kPa`).
     STD_PRESSURE: Final = 71.8
 
-    @property
-    def eop(self) -> float:
-        """Effective overburden pressure (:math:`kPa`)."""
-        return self._eop
-
-    @eop.setter
-    @validators.ge(0.0)
-    def eop(self, val: float) -> None:
-        """Effective overburden pressure (:math:`kPa`)."""
-        self._eop = val
-
     def correction(self) -> float:
         r"""SPT Correction.
 
-        :Equation:
-
-        .. math::
+        $$
+        C_N = \dfrac{4}{1 + 0.0418 \cdot \sigma_o}, \,
+              \sigma_o \lt 71.8kN/m^2
+        $$
 
-            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 &= \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
+        $$
+        C_N = 1 \, , \, \sigma_o = 71.8kN/m^2
+        $$
         """
         if isclose(self.eop, self.STD_PRESSURE, rel_tol=0.01):
             corr = 1.0
@@ -428,165 +502,157 @@ class BazaraaPeckOPC(OPC):
 
 
 class PeckOPC(OPC):
-    """Overburden Pressure Correction according to ``Peck et al. (1974)``."""
+    """Overburden Pressure Correction according to
+    `Peck et al. (1974)`.
+    """
 
     @property
     def eop(self) -> float:
-        """Effective overburden pressure (:math:`kPa`)."""
+        """Effective overburden pressure ($kPa$)."""
         return self._eop
 
     @eop.setter
-    @validators.ge(24.0)
-    def eop(self, val: float) -> None:
+    @validate_func_args
+    def eop(self, val: Annotated[float, MustBeGreaterThanOrEqual(24.0)]):
         self._eop = val
 
     def correction(self) -> float:
         r"""SPT Correction.
 
-        :Equation:
-
-        .. math:: C_N = 0.77 \log \left(\dfrac{2000}{\sigma_o} \right)
+        $$
+        C_N = 0.77 \log \left(\dfrac{2000}{\sigma_o} \right)
+        $$
         """
         return 0.77 * log10(2000.0 / self.eop)
 
 
 class LiaoWhitmanOPC(OPC):
-    """Overburden Pressure Correction according to ``Liao & Whitman (1986)``.
+    """Overburden Pressure Correction according to
+    `Liao & Whitman (1986)`.
     """
 
-    @property
-    def eop(self) -> float:
-        """Effective overburden pressure (:math:`kPa`)."""
-        return self._eop
-
-    @eop.setter
-    @validators.gt(0.0)
-    def eop(self, val: float) -> None:
-        self._eop = val
-
     def correction(self) -> float:
         r"""SPT Correction.
 
-        :Equation:
-
-        .. math:: C_N = \sqrt{\dfrac{100}{\sigma_o}}
+        $$
+        C_N = \sqrt{\dfrac{100}{\sigma_o}}
+        $$
         """
         return sqrt(100.0 / self.eop)
 
 
 class SkemptonOPC(OPC):
-    """Overburden Pressure Correction according to ``Skempton (1986)``."""
-
-    @property
-    def eop(self) -> float:
-        """Effective overburden pressure (:math:`kPa`)."""
-        return self._eop
-
-    @eop.setter
-    @validators.ge(0.0)
-    def eop(self, val: float) -> None:
-        self._eop = val
+    """Overburden Pressure Correction according to `Skempton (1986)`."""
 
     def correction(self) -> float:
         r"""SPT Correction.
 
-        :Equation:
-
-        .. math:: C_N = \dfrac{2}{1 + 0.01044 \cdot \sigma_o}
+        $$
+        C_N = \dfrac{2}{1 + 0.01044 \cdot \sigma_o}
+        $$
         """
         return 2.0 / (1.0 + 0.01044 * self.eop)
 
 
 class DilatancyCorrection:
-    """Dilatancy SPT Correction according to ``Terzaghi & Peck (1948)``.
+    """Dilatancy SPT Correction according to `Terzaghi & Peck (1948)`.
 
     For coarse sand, this correction is not required. In applying this
     correction, overburden pressure correction is applied first and then
     dilatancy correction is applied.
     """
 
-    def __init__(self, corr_spt_n_value: float) -> None:
+    def __init__(self, corr_spt_n_value: float):
         """
-        :param corr_spt_n_value: SPT N-value standardized for field procedures
-                                and/or corrected for overburden pressure.
-        :type corr_spt_n_value: float
+        :param corr_spt_n_value: SPT N-value standardized for field
+                                 procedures and/or corrected for
+                                 overburden pressure.
         """
         self.corr_spt_n_value = corr_spt_n_value
 
     @property
     def corr_spt_n_value(self) -> float:
-        """SPT N-value standardized for field procedures and/or corrected for
-        overburden pressure.
+        """SPT N-value standardized for field procedures and/or corrected
+        for overburden pressure.
         """
         return self._corr_spt_n_value
 
     @corr_spt_n_value.setter
-    @validators.le(100.0)
-    @validators.gt(0.0)
-    def corr_spt_n_value(self, val: float) -> None:
+    @validate_func_args
+    def corr_spt_n_value(
+            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.
 
-        :Equation:
-
-        .. math::
+        $$
+        (N_1)_{60} = 15 + \dfrac{1}{2}((N_1)_{60} - 15) \, , \,
+                     (N_1)_{60} \gt 15
+        $$
 
-            (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
+        $$
+        (N_1)_{60} = (N_1)_{60} \, , \, (N_1)_{60} \le 15
+        $$
         """
         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)
 
 
-@enum_repr
-class OPCType(enum.StrEnum):
-    """Enumeration of overburden pressure correction types."""
+class OPCType(AbstractStrEnum):
+    """
+    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.
+    """
+
     GIBBS = enum.auto()
+    """Gibbs method for overburden pressure correction."""
+
     BAZARAA = enum.auto()
+    """Bazaraa method for overburden pressure correction."""
+
     PECK = enum.auto()
+    """Peck method for overburden pressure correction."""
+
     LIAO = enum.auto()
+    """Liao method for overburden pressure correction."""
+
     SKEMPTON = enum.auto()
+    """Skempton method for overburden pressure correction."""
 
 
-_opctypes = {OPCType.GIBBS: GibbsHoltzOPC,
-             OPCType.BAZARAA: BazaraaPeckOPC,
-             OPCType.PECK: PeckOPC,
-             OPCType.LIAO: LiaoWhitmanOPC,
-             OPCType.SKEMPTON: SkemptonOPC}
+_opctypes = {
+    OPCType.GIBBS: GibbsHoltzOPC,
+    OPCType.BAZARAA: BazaraaPeckOPC,
+    OPCType.PECK: PeckOPC,
+    OPCType.LIAO: LiaoWhitmanOPC,
+    OPCType.SKEMPTON: SkemptonOPC,
+}
 
 
-def create_overburden_pressure_correction(std_spt_n_value: float, eop,
-                                          opc_type: OPCType | str = OPCType.GIBBS) -> OPC:
+@validate_func_args
+def create_overburden_pressure_correction(
+        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.
-    :type std_spt_n_value: float
+    :param std_spt_n_value: SPT N-value standardized for field
+                            procedures.
 
-    :param eop: Effective overburden pressure (:math:`kPa`).
-    :type eop: float
+    :param eop: Effective overburden pressure ($kPa$).
 
-    :param opc_type: Overburden Pressure Correction type to apply,
-                    defaults to :py:enum:mem:`~OPCType.GIBBS`
-    :type opc_type: OPCType, optional
+    :param opc_type: Overburden Pressure Correction type to apply.
     """
-
-    try:
-        opc_type = OPCType(str(opc_type).casefold())
-    except ValueError as e:
-        msg = ErrorMsg(param_name="opc_type",
-                       param_value=opc_type,
-                       symbol="in",
-                       param_value_bound=list(OPCType))
-        raise ValidationError(msg) from e
-
+    opc_type = OPCType(opc_type)
     opc_class = _opctypes[opc_type]
     opc_corr = opc_class(std_spt_n_value=std_spt_n_value, eop=eop)
-
     return opc_corr