structuralcodes 0.4.0__tar.gz → 0.5.0__tar.gz

{structuralcodes-0.4.0 → structuralcodes-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structuralcodes
-Version: 0.4.0
+Version: 0.5.0
 Summary: A Python package that contains models from structural design codes.
 Author-email: fib - International Federation for Structural Concrete <info@fib-international.org>
 Requires-Python: >=3.8

{structuralcodes-0.4.0 → structuralcodes-0.5.0}/structuralcodes/__init__.py

@@ -3,7 +3,7 @@
 from . import codes, core, geometry, materials, sections
 from .codes import get_design_codes, set_design_code, set_national_annex
 
-__version__ = '0.4.0'
+__version__ = '0.5.0'
 
 __all__ = [
     'set_design_code',

{structuralcodes-0.4.0 → structuralcodes-0.5.0}/structuralcodes/codes/ec2_2004/__init__.py

@@ -78,6 +78,7 @@ from ._section_7_3_crack_control import (
 )
 from .shear import (
     Asw_max,
+    Asw_s_required,
     VEdmax_unreinf,
     VRdc,
     VRdc_prin_stress,
@@ -90,6 +91,7 @@ __all__ = [
     'As_min_2',
     'As_min_p',
     'Asw_max',
+    'Asw_s_required',
     'alpha_e',
     'eps_sm_eps_cm',
     'hc_eff',

{structuralcodes-0.4.0 → structuralcodes-0.5.0}/structuralcodes/codes/ec2_2004/shear.py

@@ -112,8 +112,8 @@ def _theta(theta: float, cot_min: float = 1.0, cot_max: float = 2.5) -> None:
             'Wrong value for theta is chosen. Theta has '
             f'to be chosen such that 1/tan(theta) lies between '
             f'{cot_min} and {cot_max}. This corresponds to an angle '
-            f'between {round(math.degrees(math.atan(1/cot_min)),2)} '
-            f'and {round(math.degrees(math.atan(1/cot_max)),2)} '
+            f'between {round(math.degrees(math.atan(1 / cot_min)), 2)} '
+            f'and {round(math.degrees(math.atan(1 / cot_max)), 2)} '
             f'degrees, respectively. Current angle is set at {theta}'
             ' degrees.'
         )
@@ -152,7 +152,7 @@ def alpha_cw(Ned: float, Ac: float, fcd: float) -> float:
         value = 2.5 * (1 - sigma_cp / fcd)
     else:
         raise ValueError(
-            f'sigma_cp/fcd={sigma_cp/fcd}. Prestress has to be smaller'
+            f'sigma_cp/fcd={sigma_cp / fcd}. Prestress has to be smaller'
             ' than design compressive strength.'
         )
     return value
@@ -400,6 +400,46 @@ def VRds(
     )
 
 
+# Equation (6.8 & 6.13) -> Reinforcement ratio isolated from the equation.
+def Asw_s_required(
+    Ved: float,
+    z: float,
+    theta: float,
+    fywd: float,
+    alpha: float = 90.0,
+) -> float:
+    """Calculate the required shear reinforcement.
+
+    EN 1992-1-1 (2005). Eq. (6.13)
+
+    Args:
+        Ved (float): The shear force in N.
+        z (float): The inner lever arm of internal forces in mm.
+        theta (float): The angle of the compression strut in degrees.
+        fywd (float): The design strength of the shear reinforcement steel in
+            MPa.
+
+    Keyword Args:
+        alpha (float): The angle of the shear reinforcement with respect to the
+            neutral axis in degrees. Default value = 90 degrees.
+
+    Returns:
+        float: The amount of required shear reinforcement in mm2/mm.
+
+    Raises:
+        ValueError: When theta < 21.8 degrees or theta > 45 degrees.
+    """
+    theta = math.radians(theta)
+    alpha = math.radians(alpha)
+    return (
+        Ved
+        / z
+        / fywd
+        / (1 / math.tan(theta) + 1.0 / math.tan(alpha))
+        / math.sin(alpha)
+    )
+
+
 # Equation (6.9 & 6.14)
 # For alpha == 90 degrees, Equation (6.14) reduces to Equation (6.9).
 def VRdmax(
@@ -480,7 +520,7 @@ def Asw_max(
         bw (float): The smallest width of the cross-section in tension in mm.
         s (float): The centre-to-centre distance of the shear reinforcement in
             mm.
-        fwyd (float): The design strength of the shear reinforcement steel in
+        fywd (float): The design strength of the shear reinforcement steel in
             MPa.
         NEd (float): The normal force in the cross-section due to loading or
             prestress (NEd > 0 for compression) in N.

{structuralcodes-0.4.0 → structuralcodes-0.5.0}/structuralcodes/codes/mc2010/__init__.py

@@ -55,8 +55,17 @@ from ._concrete_material_properties import (
 )
 from ._concrete_punching import (
     b_0,
+    b_s,
+    b_sr,
+    k_dg,
+    k_psi,
     m_ed,
     psi_punching,
+    psi_punching_level_one,
+    psi_punching_level_three,
+    psi_punching_level_two,
+    r_s,
+    sigma_swd,
     v_rd_max_punching,
     v_rd_punching,
     v_rdc_punching,
@@ -184,6 +193,15 @@ __all__ = [
     's_tau_bu_split',
     'f_stm',
     'tau_yield',
+    'b_s',
+    'b_sr',
+    'k_dg',
+    'k_psi',
+    'r_s',
+    'psi_punching_level_one',
+    'psi_punching_level_two',
+    'psi_punching_level_three',
+    'sigma_swd',
 ]
 
 __title__: str = 'fib Model Code 2010'

structuralcodes-0.5.0/structuralcodes/codes/mc2010/_concrete_punching.py

@@ -0,0 +1,455 @@
+"""Covers punching in Model code 2010, 7.3.5.1 to 7.3.5.4."""
+
+import typing as t
+import warnings
+from math import cos, pi, sin
+
+
+def b_0(v_ed: float, v_prep_d_max: float) -> float:
+    """Gives the general output for b_0, shear-resisting control perimeter.
+
+    fib Model Code 2010, Eq. (7.3-57).
+
+    Args:
+        V_ed (float): The acting shear force from the columns.
+        v_prep_d_max (float): The maximum shear force per unit length
+            perpendicular to the basic control parameter (Figure 7.3-24).
+
+    Returns:
+        float: The shear-resisting control perimeter, b_0.
+    """
+    return v_ed / v_prep_d_max
+
+
+def b_s(
+    l_x: float,
+    l_y: float,
+) -> float:
+    """The width of the support strip for calculating m_ed.
+
+    fib Model Code 2010, Eq. (7.3-76).
+
+    Args:
+        l_x (float): The width in x direction that the collumn carries.
+        l_y (float): The width in y direction that the collumn carries.
+
+    Returns:
+        float: The width of the support strip for calculating m_ed.
+    """
+    r_sx = 0.22 * l_x  # see  MC2010 7.3.5.3
+    r_sy = 0.22 * l_y  # see  MC2010 7.3.5.3
+    l_min = min(l_x, l_y)
+    return min(1.5 * (r_sx * r_sy) ** 0.5, l_min)
+
+
+def m_ed(
+    v_ed: float,
+    e_u: float,
+    b_s: float,
+    inner: bool,
+    edge_par: bool,
+    edge_per: bool,
+    corner: bool,
+) -> float:
+    """The average bending moment acting in the support strip.
+
+    fib Model Code 2010, Eq. (7.3-71), (7.3-72), (7.3-73) and (7.3-74).
+
+    Args:
+        v_ed (float): The acting shear force from the columns.
+        e_u (float): Refers to the eccentricity of the resultant of shear
+            forces with respect to the centroid.
+        b_s (float): The width of the support strip for calculating m_ed.
+        inner (bool): Is true only if the column is a inner column.
+        edge_par (bool): Is true only if the column is a edge column with
+            tension reinforcement parallel to the edge.
+        edge_per (bool): Is true only if the column is a edge column with
+            tension reinforcement perpendicular to the edge.
+        corner (bool): Is true only if the column is a corner column.
+
+    Returns:
+        float: The bending moment acting in the support strip regardless of the
+        position of the column.
+    """
+    if inner:
+        return v_ed * ((1 / 8) + abs(e_u) / (2 * b_s))
+    if edge_par:
+        return max(v_ed * ((1 / 8) + e_u / (2 * b_s)), v_ed / 4)
+    if edge_per:
+        return v_ed * ((1 / 8) + e_u / (b_s))
+    if corner:
+        return max(v_ed * ((1 / 8) + e_u / (b_s)), v_ed / 2)
+    raise ValueError('Placement is not defined, only one needs to be True')
+
+
+def b_sr(
+    l_x: float,
+    l_y: float,
+) -> float:
+    """The width of the support strip in the radial direction.
+
+    fib Model Code 2010, 7.3.5.3.
+
+    Args:
+        l_x (float): The width in x direction that the collumn carries.
+        l_y (float): The width in y direction that the collumn carries.
+
+    Returns:
+        float: The width of the support strip in the radial direction.
+    """
+    return min(l_x, l_y)
+
+
+def r_s(
+    l_x: float,
+    l_y: float,
+    x_direction: bool,
+    is_level_three_approximation: bool = False,
+    column_edge_or_corner: bool = False,
+    b_sr: t.Optional[float] = None,
+) -> float:
+    """The position where the radial bending moment is zero with respect to the
+    support axis.
+
+    fib Model Code 2010, 7.3.5.3 and Eq. (7.3-78) for Level III of
+    Approximation.
+
+    Args:
+        l_x (float): The width in x direction that the collumn carries.
+        l_y (float): The width in y direction that the collumn carries.
+        x_direction (bool): True if the radial bending moment is zero in the x
+            direction, False if it is in the y direction.
+        column_edge_or_corner (bool): True if the column is an edge or corner
+            column, False if it is an inner column. To be used for Level III of
+            Approximation.
+        b_sr (float): The width of the support strip in the radial direction.
+
+    Returns:
+        float: The position where the radial bending moment is zero with
+        respect to the support axis.
+    """
+    r_s = 0.22 * l_x if x_direction is True else 0.22 * l_y
+
+    if column_edge_or_corner and is_level_three_approximation:
+        if b_sr is None:
+            raise ValueError(
+                'b_sr is not defined for Level 3 of Approximation'
+            )
+        return max(r_s, 0.67 * b_sr)
+    return r_s
+
+
+def psi_punching_level_one(
+    l_x: float,
+    l_y: float,
+    f_yd: float,
+    d_eff: float,
+    e_s: float,
+) -> float:
+    """The psi value for the punching level one.
+
+    fib Model Code 2010, Eq. (7.3-70).
+
+    Args:
+        r_s (float): The position where the radial bending moment is zero with
+            respect to the support axis.
+        f_yd (float): Design strength of reinforment steel in MPa.
+        d_eff (float): The mean value of the effective depth in mm.
+        e_s (float): The E_modulus for steel in MPa.
+
+    Returns:
+        float: The psi value for the punching level one.
+    """
+    r_s = max(0.22 * l_x, 0.22 * l_y)  # MC2010 7.3.5.3 - Unique for (7.3-70)
+    return 1.5 * r_s * f_yd / (d_eff * e_s)
+
+
+def psi_punching_level_two(
+    r_s: float,
+    f_yd: float,
+    d_eff: float,
+    e_s: float,
+    m_ed: float,
+    m_rd: float,
+    m_Pd: float = 0,
+) -> float:
+    """The psi value for the punching level two.
+
+    fib Model Code 2010, Eq. (7.3-75) and (7.3-77).
+
+    Args:
+        r_s (float): The position where the radial bending moment is zero with
+            respect to the support axis.
+        f_yd (float): Design strength of reinforment steel in MPa.
+        d_eff (float): The mean value of the effective depth in mm.
+        e_s (float): The E_modulus for steel in MPa.
+        m_ed (float): The average bending moment acting in the support strip.
+        m_rd (float): The design average strength per unit length in MPa.
+        m_Pd (float): Optional to cover Eq. (7.3-77) for prestressed slabs.
+            The average decompression moment over the width of the support
+            strip (b_s) due to prestressing.
+
+    Returns:
+        float: The psi value for the punching level two.
+    """
+    return (1.5 * r_s * f_yd / (d_eff * e_s)) * (
+        (m_ed - m_Pd) / (m_rd - m_Pd)
+    ) ** 1.5
+
+
+def psi_punching_level_three(
+    psi_punching_level_two: float,
+    is_uncracked_model: bool = False,
+    is_moment_from_uncracked_model: bool = False,
+) -> float:
+    """The psi value for the punching level three.
+
+    fib Model Code 2010, Level III of Approximation Eq. (7.3-75) and Eq.
+    (7.3-77) with coefficient 1.2 instead of 1.5 under specific conditions.
+
+    Args:
+        psi_punching_level_two (float): The psi value for the punching level 2.
+        is_uncracked_model (bool): True if r_s is calculated using a linear
+            elastic (uncracked) model.
+        is_moment_from_uncracked_model (bool): True if m_sd is calculated from
+            a linear elastic (uncracked) model as the average value of the
+            moment for design of the flexural reinforcement over the width of
+            the support strip (b_s).
+
+    Returns:
+        float: The psi value for the punching level three.
+    """
+    if is_uncracked_model and is_moment_from_uncracked_model:
+        return 1.2 / 1.5 * psi_punching_level_two
+    return psi_punching_level_two
+
+
+def psi_punching(
+    psi_punching_level_one: float,
+    psi_punching_level_two: float,
+    psi_punching_level_three: float,
+    approx_lvl_p: float,
+) -> float:
+    """The rotation of the slab around the supported area.
+
+    fib Model Code 2010, Clause 7.3.5.4.
+
+    Args:
+        psi_punching_level_one (float): The psi value for the punching level 1.
+        psi_punching_level_two (float): The psi value for the punching level 2.
+        psi_punching_level_three (float): The psi value for the punching level
+            3.
+        approx_lvl_p (float): The approx level for punching.
+
+    Returns:
+        float: psi for the chosen approx level in punching.
+    """
+    if approx_lvl_p == 1:
+        return psi_punching_level_one
+    if approx_lvl_p == 2:
+        return psi_punching_level_two
+    if approx_lvl_p == 3:
+        return psi_punching_level_three
+    raise ValueError('Approximation level is not defined')
+
+
+def k_dg(
+    d_g: float,
+) -> float:
+    """Calculate k_dg factor for punching resistance.
+
+    fib Model Code 2010, Eq. (7.3-62).
+
+    Args:
+        d_g (float): Maximum size of aggregate.
+
+    Returns:
+        float: k_dg factor.
+    """
+    return max(32 / (16 + d_g), 0.75)
+
+
+def k_psi(
+    k_dg: float,
+    d_eff: float,
+    psi_punching: float,
+) -> float:
+    """Calculate k_psi factor for punching resistance.
+
+    fib Model Code 2010, Eq. (7.3-63).
+
+    Args:
+        k_dg (float): k_dg factor.
+        d_eff (float): The mean value of the effective depth in mm.
+        psi_punching (float): psi value from psi_punching.
+
+    Returns:
+        float: k_psi factor.
+    """
+    return min(1 / (1.5 + 0.9 * k_dg * d_eff * psi_punching), 0.6)
+
+
+def v_rdc_punching(
+    k_psi_val: float,
+    b_0: float,
+    d_v: float,
+    f_ck: float,
+    gamma_c: float = 1.5,
+) -> float:
+    """Punching resistance from the concrete.
+
+    fib Model Code 2010, Eq. (7.3-61).
+
+    Args:
+        k_psi_val (float): k_psi value from k_psi.
+        b_0 (float): The shear-resisting control perimeter from b_0.
+        d_v (float): The effective depth considering support in mm.
+        f_ck (float): Characteristic strength in MPa.
+        gamma_c: Safety factor for concrete.
+
+    Returns:
+        float: v_rdc for punching with the right approx level.
+    """
+    return k_psi_val * b_0 * d_v * (f_ck**0.5) / gamma_c
+
+
+def f_ywd(
+    f_ywk: float,
+    gamma_s: float,
+) -> float:
+    """Calculate f_ywd for punching resistance.
+
+    fib Model Code 2010, Eq. (7.3-64).
+
+    Args:
+        f_ywk (float): Characteristic yield strength of the shear reinforcement
+            in MPa.
+        gamma_s (float): Safety factor for reinforcement.
+
+    Returns:
+        float: f_ywd for punching resistance.
+    """
+    return f_ywk / gamma_s
+
+
+def sigma_swd(
+    e_s: float,
+    psi_punching: float,
+    alpha: float,
+    f_bd: float,
+    d_eff: float,
+    f_ywd: float,
+    phi_w: float,
+) -> float:
+    """Calculate sigma_swd for punching resistance.
+
+    fib Model Code 2010, Eq. (7.3-65).
+
+    Args:
+        e_s (float): The E_modulus for steel in MPa.
+        psi_punching (float): psi value from psi_punching.
+        alpha (float): Inclination of the stirrups in degrees.
+        f_bd (float): The design bond strength in MPa.
+        d_eff (float): The mean value of the effective depth in mm.
+        f_ywd (float): Design yield strength of the shear reinforcement in MPa.
+        phi_w (float): The diameter of the shear reinforcement.
+
+    Returns:
+        float: sigma_swd.
+    """
+    return min(
+        (e_s * psi_punching / 6)
+        * (sin(alpha * pi / 180) + cos(alpha * pi / 180))
+        * (sin(alpha * pi / 180) + f_bd * d_eff / (f_ywd * phi_w)),
+        f_ywd,
+    )
+
+
+def v_rds_punching(
+    f_ywd: float,
+    e_u: float,
+    b_u: float,
+    alpha: float,
+    sigma_swd: float,
+    a_sw: float,
+    v_ed: float,
+) -> float:
+    """The punching resistance from shear reinforcement.
+
+    fib Model Code 2010, Eq. (7.3-64).
+
+    Args:
+        f_ywd (float): Design yield strength of the shear reinforcement in MPa.
+        e_u (float): The ecentrisity of the result of shear forces with respect
+            to the centroid (Figure 7.3-27b).
+        b_u (float): The diamter of a circle with same surface as the region
+            inside the basic control perimeter (Figure 7.3-27b).
+        alpha (float): Inclination of the stirrups in degrees.
+        sigma_swd (float): sigma_swd from sigma_swd.
+        a_sw (float): The area of the shear reinforcement in mm^2.
+        v_ed (float): The acting shear force from the columns.
+
+    Returns:
+        float: Punching resistance that comes from reinforcement.
+    """
+    k_e = 1 / (1 + e_u / b_u)
+    if (a_sw * k_e * f_ywd) < 0.5 * v_ed:
+        warnings.warn(
+            'Consider increasing punching shear reinforcement for sufficient '
+            'deformation capacity'
+        )
+    return a_sw * k_e * sigma_swd * sin(alpha * pi / 180)
+
+
+def v_rd_max_punching(
+    d_v: float,
+    f_ck: float,
+    d_head: bool,
+    stirrups_compression: bool,
+    b0_val: float,
+    k_psi_val: float,
+    gamma_c: float = 1.5,
+) -> float:
+    """Finds the maximum value you can have for v_rd_punching.
+
+    fib Model Code 2010, Eq. (7.3-69).
+
+    Args:
+        d_v (float): The effective depth considering support in mm.
+        f_ck (float): Characteristic strength in MPa.
+        d_head (bool): True if diameter of heads is three times larger than.
+        stirrups_compression: (bool): Stirrups with sufficient length at
+            compression face, and bent on tension face.
+        b0_val (float): The shear-resisting control perimeter from b_0.
+        k_psi_val (float): k_psi value from k_psi.
+        gamma_c (float): Safety factor for concrete.
+
+    Return:
+        float: The maximum allowed punching resistance.
+    """
+    if d_head:
+        k_sys = 2.8
+    elif stirrups_compression:
+        k_sys = 2.4
+    else:
+        k_sys = 2
+
+    base_resistance = b0_val * d_v * (f_ck**0.5 / gamma_c)
+
+    return min(k_sys * k_psi_val * base_resistance, base_resistance)
+
+
+def v_rd_punching(v_rd_c: float, v_rd_s: float, v_rd_max: float) -> float:
+    """The total resistance for punching.
+
+    fib Model Code 2010, Eq. (7.3-60).
+
+    Args:
+        v_rd_c: Concrete contribution to punching resistance.
+        v_rd_s: Shear reinforcement contribution to punching resistance.
+        v_rd_max: Maximum punching resistance.
+
+    Returns:
+        float: Total punching resistance as min(v_rd_c + v_rd_s, v_rd_max).
+    """
+    return min(v_rd_c + v_rd_s, v_rd_max)

{structuralcodes-0.4.0 → structuralcodes-0.5.0}/structuralcodes/core/base.py

@@ -29,7 +29,7 @@ class Material(abc.ABC):
         self._name = name if name is not None else 'Material'
 
     @property
-    def constitutive_law(self):
+    def constitutive_law(self) -> ConstitutiveLaw:
         """Returns the ConstitutiveLaw of the object."""
         return self._constitutive_law
 

{structuralcodes-0.4.0 → structuralcodes-0.5.0}/structuralcodes/geometry/_circular.py

@@ -12,7 +12,7 @@ import numpy as np
 from numpy.typing import ArrayLike
 from shapely import Polygon
 
-from structuralcodes.core.base import ConstitutiveLaw, Material
+from structuralcodes.core.base import Material
 
 from ._geometry import SurfaceGeometry
 
@@ -37,9 +37,8 @@ class CircularGeometry(SurfaceGeometry):
     def __init__(
         self,
         diameter: float,
-        material: t.Union[Material, ConstitutiveLaw],
+        material: Material,
         n_points: int = 20,
-        density: t.Optional[float] = None,
         concrete: bool = False,
         origin: t.Optional[ArrayLike] = None,
         name: t.Optional[str] = None,
@@ -49,14 +48,9 @@ class CircularGeometry(SurfaceGeometry):
 
         Arguments:
             diameter (float): The diameter of the geometry.
-            material (Union(Material, ConstitutiveLaw)): A Material or
-                ConsitutiveLaw class applied to the geometry.
+            material (Material): A Material class applied to the geometry.
             n_points (int): The number of points used to discretize the
                 circle as a shapely `Polygon` (default = 20).
-            density (Optional(float)): When a ConstitutiveLaw is passed as
-                material, the density can be provided by this argument. When
-                material is a Material object the density is taken from the
-                material.
             concrete (bool): Flag to indicate if the geometry is concrete.
             origin (Optional(ArrayLike)): The center point of the circle.
                 (0.0, 0.0) is used as default.
@@ -84,7 +78,6 @@ class CircularGeometry(SurfaceGeometry):
         super().__init__(
             poly=polygon,
             material=material,
-            density=density,
             concrete=concrete,
             name=name,
             group_label=group_label,