Initial AASHTO implementation (by Samuel Choi)

.vscode/settings.json

@@ -16,5 +16,5 @@
   "notebook.formatOnSave.enabled": true,
   "notebook.codeActionsOnSave": {
     "notebook.source.organizeImports": "explicit"
-  }
+  },
 }

prueba.py

@@ -0,0 +1,5 @@
+from structuralcodes.codes.aashto_2020 import _deflections
+from structuralcodes.codes.aashto_2020 import _punching
+
+mcr = _deflections.Mcr(fc_prime=5, b=200 / 25.4, h=500 / 25.4, d=450 / 25.4)
+print(mcr)

structuralcodes/codes/aashto_2024/_crack_control.py

@@ -0,0 +1,61 @@
+## AASHTO LRFD Functions for Control of Cracking ##
+
+
+def beta_s(h: float, dc) -> float:
+    """Determines the flexural strain ratio.
+
+    AASHTO LRFD 2024 10th Edition, Eq (5.6.7-2)
+
+    Args:
+        h (float): height of the cross section in (in)
+        dc (float): the thickness of the concrete cover from the surface
+        to the center of the reinforcement in (in)
+
+    Returns:
+        The flexural strain ratio
+
+    Raises:
+        ValueError: If h is less than 0
+        ValueError: If dc is less than 0
+    """
+    if h < 0:
+        raise ValueError(f'h={h} cannot be less than 0')
+    if dc < 0:
+        raise ValueError(f'dc={dc} cannot be less than 0')
+
+    return 1 + (dc / (0.7 * (h - dc)))
+
+
+def s(fyk: float, beta_s: float, gamma_e: float, dc: float) -> float:
+    """Determines the spacing of nonprestressed reinforcement.
+
+    AASHTO LRFD 2024 10th Edition, Eq. (5.6.7-1)
+
+    Args:
+        fyk (float): The steel reinforcement yielding strength in ksi
+        beta_s (float): The flexural strain ratio
+        gamma_e (float): The exposure factor
+        dc (float): The thickness of concrete cover from surface to center
+        of the reinforcement in (in)
+
+    Returns:
+        The spacing of nonprestressed reinforcement in (in)
+
+    Raises:
+        ValueError: If fyk is less than 0
+        ValueError: If gamma_e is less than 0
+        ValueError: If beta_s is less than 0
+        ValueError: If dc is less than 0
+    """
+    if fyk < 0:
+        raise ValueError(f'fyk={fyk} cannot be less than 0')
+    if gamma_e < 0:
+        raise ValueError(f'gamma_e={gamma_e} cannot be less than 0')
+    if beta_s < 0:
+        raise ValueError(f'beta_s={beta_s} cannot be less than 0')
+    if dc < 0:
+        raise ValueError(f'dc={dc} cannot be less than 0')
+
+    fss = 0.6 * fyk
+
+    return (700 * gamma_e / (beta_s * fss)) - (2 * dc)

structuralcodes/codes/aashto_2024/_deflections.py

@@ -0,0 +1,241 @@
+## AASHTO LRFD Functions for Deflections
+
+import math
+
+
+def Mu(
+    fc_prime: float,
+    fy: float,
+    As: float,
+    b: float,
+    h: float,
+    d: float,
+    L: float,
+    phi: float,
+) -> float:
+    """Determines the design ultimate moment.
+
+    AASHTO LRFD 2024 10th Edition, Eq (5.6.3.2a-1)
+
+    Args:
+        fc_prime (float): compressive strength of concrete in (ksi)
+        fy (float): yield strength of the steel reinforcement in (ksi)
+        As (float): area of steel reinforcement
+        b (float): width of the cross section in (in)
+        h (float): height of the cross section in (in)
+        d (float): effective depth of cross section in (in)
+        L (float): span in (in)
+        phi (flaot): design factor
+
+    Returns:
+        Design moment in (k-in)
+
+    Raises:
+        ValueError: If fc_prime is less than 0
+        ValueError: If fy is less than 0
+        ValueError: If As is less than 0
+        ValueError: If b is less than 0
+        ValueError: If h is less than 0
+        ValueError: If d is less than 0
+        ValueError: If L is less than 0
+        ValueError: If phi is less than 0
+    """
+    if fc_prime < 0:
+        raise ValueError(f'fc_prime={fc_prime} fc_prime cannot be less than 0')
+    if fy < 0:
+        raise ValueError(f'fy={fy} fy cannot be less than 0')
+    if As < 0:
+        raise ValueError(f'As={As} As cannot be less than 0')
+    if b < 0:
+        raise ValueError(f'b={b} b cannot be less than 0')
+    if h < 0:
+        raise ValueError(f'h={h} h cannot be less than 0')
+    if d < 0:
+        raise ValueError(f'd={d} d cannot be less than 0')
+    if L < 0:
+        raise ValueError(f'L={L} L cannot be less than 0')
+    if phi < 0:
+        raise ValueError(f'phi={phi} phi cannot be less than 0')
+
+    x = As * fy / (fc_prime * b * 0.8)
+
+    return phi * (As * fy * (d - 0.4 * x))
+
+
+def Mcr(fc_prime: float, b: float, h: float, d: float) -> float:
+    """Determines the cracking moment.
+
+    AASHTO LRFD 2024 10th Edition, Eq (5.6.3.2a-1)
+
+    Args:
+        fc_prime (float): compressive strength of concrete in (ksi)
+        b (float): width of the cross section in (in)
+        h (float): height of the cross section in (in)
+        d (float): effective depth of cross section in (in)
+
+    Returns:
+        Cracking moment in (k-in)
+
+    Raises:
+        ValueError: If fc_prime is less than 0
+        ValueError: If b is less than 0
+        ValueError: If h is less than 0
+        ValueError: If d is less than 0
+    """
+    if fc_prime < 0:
+        raise ValueError(f'fc_prime={fc_prime} fc_prime cannot be less than 0')
+    if b < 0:
+        raise ValueError(f'b={b} b cannot be less than 0')
+    if h < 0:
+        raise ValueError(f'h={h} h cannot be less than 0')
+    if d < 0:
+        raise ValueError(f'd={d} d cannot be less than 0')
+
+    fr = 0.24 * math.sqrt(fc_prime)
+    Ig = b * (h**3) / 12
+    y_bar = h / 2
+    yt = d - y_bar
+
+    return fr * Ig / yt
+
+
+def Ie(
+    fc_prime: float,
+    fy: float,
+    As: float,
+    b: float,
+    h: float,
+    d: float,
+    L: float,
+    phi: float,
+    Es: float,
+    Ec: float,
+) -> float:
+    """Determines the effective moment of inertia.
+
+    AASHTO LRFD 2024 10th Edition
+
+    Args:
+        fc_prime (float): compressive strength of concrete in (ksi)
+        fy (float): yield strength of the steel reinforcement in (ksi)
+        As (float): area of steel reinforcement
+        b (float): width of the cross section in (in)
+        h (float): height of the cross section in (in)
+        d (float): effective depth of cross section in (in)
+        L (float): span in (in)
+        phi (float): design factor
+        Es (float): modulus of elasticity of steel (ksi)
+        Ec (float): modulus of elasticity of concrete (ksi)
+
+    Returns:
+        Effective moment of inertia (in^4)
+
+    Raises:
+        ValueError: If fc_prime is less than 0
+        ValueError: If fy is less than 0
+        ValueError: If As is less than 0
+        ValueError: If b is less than 0
+        ValueError: If h is less than 0
+        ValueError: If d is less than 0
+        ValueError: If L is less than 0
+        ValueError: If phi is less than 0
+        ValueError: If Es is less than 0
+        ValueError: If Ec is less than 0
+    """
+    if fc_prime < 0:
+        raise ValueError(f'fc_prime={fc_prime} fc_prime cannot be less than 0')
+    if fy < 0:
+        raise ValueError(f'fy={fy} fy cannot be less than 0')
+    if As < 0:
+        raise ValueError(f'As={As} As cannot be less than 0')
+    if b < 0:
+        raise ValueError(f'b={b} b cannot be less than 0')
+    if h < 0:
+        raise ValueError(f'h={h} h cannot be less than 0')
+    if d < 0:
+        raise ValueError(f'd={d} d cannot be less than 0')
+    if L < 0:
+        raise ValueError(f'L={L} L cannot be less than 0')
+    if phi < 0:
+        raise ValueError(f'phi={phi} phi cannot be less than 0')
+    if Es < 0:
+        raise ValueError(f'Es={Es} Es cannot be less than 0')
+    if Ec < 0:
+        raise ValueError(f'Ec={Ec} Es cannot be less than 0')
+
+    n = Es / Ec
+    Ac = n * As
+    Ig = b * (h**3) / 12
+    Ma = Mu(fc_prime, fy, As, b, h, d, L, phi)
+    M_cr = Mcr(fc_prime, b, h, d)
+    two_thirds_Mcr = (2 / 3) * M_cr
+    x = As * fy / (fc_prime * b * 0.8)
+    Icr = ((b * x**3) / 3) + Ac * (d - x) ** 2
+
+    if Ma < two_thirds_Mcr:
+        return Ig
+
+    if Ma > two_thirds_Mcr:
+        return Icr / (1 - ((two_thirds_Mcr / Ma) ** 2) * (1 - (Icr / Ig)))
+
+
+def delta(
+    qqp: float,
+    L: float,
+    Ec: float,
+    Ieff: float,
+) -> float:
+    """Determines the instantaneous deflection of the beam.
+
+    Args:
+        qqp (float): quasi permanent load in (k/in)
+        L (float): span (in)
+        Ec (float): modulus of elasticity of concrete (ksi)
+        Ieff (float): effective moment of inertia (in^4)
+
+    Returns:
+        The deflection in (in)
+
+    Raises:
+        ValueError: If L is less than 0
+        ValueError: If Ec is less than 0
+        ValueError: If Ieff is less than 0
+    """
+    if L < 0:
+        raise ValueError(f'L={L} cannot be less than 0')
+    if Ec < 0:
+        raise ValueError(f'Ec={Ec} cannot be less than 0')
+    if Ieff < 0:
+        raise ValueError(f'Ieff={Ieff} cannot be less than 0')
+
+    return (5 * qqp * L**4) / (384 * Ec * Ieff)
+
+
+def time_delta(deflection: float, factor: float, rho_prime: float) -> float:
+    """Determines the time dependent deflection of the beam.
+
+    AASHTO LRFD 2024 10th Edition, Eq (5.6.3.5.2b-1)
+
+    Args:
+        deflection (float): instantaneous deflection in (in)
+        factor (float): time dependent factor for sustained loads
+        rho_prime (float): compressive reinforcement ratio
+
+    Returns:
+        The time dependent deflection in (in)
+
+    Raises:
+        ValueError: If deflection is less than 0
+        ValueError: If factor is less than 0
+        ValueError: If rho_prime is less than 0
+    """
+    if deflection < 0:
+        raise ValueError(f'deflection={deflection} cannot be less than 0')
+    if factor < 0:
+        raise ValueError(f'factor={factor} cannot be less than 0')
+    if rho_prime < 0:
+        raise ValueError(f'rho_prime={rho_prime} cannot be less than 0')
+
+    landa_delta = factor / (1 + 50 * rho_prime)
+
+    return landa_delta * deflection