structuralcodes 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

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.6.0'
+__version__ = '0.6.1'
 
 __all__ = [
     'set_design_code',

structuralcodes/codes/ec2_2004/shear.py

@@ -203,14 +203,15 @@ def VRdc(
         float: The concrete shear resistance in MPa.
     """
     CRdc = CRdc or 0.18 / gamma_c
-    return (
+    return max(
         max(
             CRdc * _k(d) * (100 * _rho_L(Asl, bw, d) * fck) ** (1.0 / 3.0)
             + k1 * _sigma_cp(NEd, Ac, fcd),  # VRdc
             vmin(fck, d) + k1 * _sigma_cp(NEd, Ac, fcd),  # VRdcmin
         )
         * bw
-        * d
+        * d,
+        0,
     )
 
 

structuralcodes/core/base.py

@@ -287,14 +287,29 @@ class ConstitutiveLaw(abc.ABC):
         piecewise_law = self._discretize_law()
         return piecewise_law.__marin_tangent__(**kwargs)
 
-    def get_secant(self, eps: float) -> float:
-        """Method to return the
-        secant at a given strain level.
-        """
-        if eps != 0:
-            sig = self.get_stress(eps)
-            return sig / eps
-        return self.get_tangent(eps)
+    def get_secant(
+        self, eps: t.Union[float, ArrayLike]
+    ) -> t.Union[float, ArrayLike]:
+        """Method to return the secant at a given strain level."""
+        # Adjust eps if it is not scalar
+        eps = eps if np.isscalar(eps) else np.atleast_1d(eps)
+
+        # Calculate secant for scalar eps
+        if np.isscalar(eps):
+            if eps != 0:
+                sig = self.get_stress(eps)
+                return sig / eps
+            return self.get_tangent(eps)
+
+        # Calculate secant for array eps
+        secant = np.zeros_like(eps)
+        strain_is_zero = eps == 0
+        strain_is_nonzero = eps != 0
+        secant[strain_is_zero] = self.get_tangent(eps[strain_is_zero])
+        secant[strain_is_nonzero] = (
+            self.get_stress(eps[strain_is_nonzero]) / eps[strain_is_nonzero]
+        )
+        return secant
 
 
 class Section(abc.ABC):

structuralcodes/geometry/_geometry.py

@@ -4,6 +4,7 @@ from __future__ import annotations  # To have clean hints of ArrayLike in docs
 
 import typing as t
 import warnings
+from math import atan2
 
 import numpy as np
 from numpy.typing import ArrayLike
@@ -23,6 +24,39 @@ from structuralcodes.materials.basic import ElasticMaterial
 from structuralcodes.materials.concrete import Concrete
 
 
+def _mirror_about_axis_matrix(axis: LineString) -> np.ndarray:
+    if not isinstance(axis, LineString):
+        raise TypeError('axis should be a shapely LineString object')
+
+    (x1, y1), (x2, y2) = axis.coords
+
+    # angle of the line with respect to the horizontal axis
+    dx, dy = x2 - x1, y2 - y1
+    theta = atan2(dy, dx)
+
+    # Translation matrix T (move line start to origin)
+    T = np.array([[1, 0, -x1], [0, 1, -y1], [0, 0, 1]])
+
+    # Rotation matrix R (align line with x-axis)
+    R = np.array(
+        [
+            [np.cos(theta), np.sin(theta), 0],
+            [-np.sin(theta), np.cos(theta), 0],
+            [0, 0, 1],
+        ]
+    )
+
+    # Mirror across x-axis
+    M = np.array([[1, 0, 0], [0, -1, 0], [0, 0, 1]])
+
+    # Inverses of T and R
+    T_inv = np.linalg.inv(T)
+    R_inv = np.linalg.inv(R)
+
+    # Final transformation matrix
+    return T_inv @ R_inv @ M @ R @ T
+
+
 class Geometry:
     """Base class for a geometry object."""
 
@@ -229,6 +263,31 @@ class PointGeometry(Geometry):
             group_label=self._group_label,
         )
 
+    def mirror(self, axis: LineString) -> PointGeometry:
+        """Returns a new PointGeometry that is mirrored with respect to the
+        axis.
+
+        Arguments:
+            axis (LineString): The axis to mirror about.
+
+        Returns:
+            PointGeometry: The mirrored PointGeometry.
+        """
+        if not isinstance(axis, LineString):
+            raise TypeError('axis should be a shapely LineString object')
+
+        # Build the transformation matrix
+        A = _mirror_about_axis_matrix(axis)
+        # Apply the transformation to the point
+        params = [A[0, 0], A[0, 1], A[1, 0], A[1, 1], A[0, 2], A[1, 2]]
+        return PointGeometry(
+            point=affinity.affine_transform(self._point, params),
+            diameter=self._diameter,
+            material=self._material,
+            name=self._name,
+            group_label=self._group_label,
+        )
+
     @staticmethod
     def from_geometry(
         geo: PointGeometry,
@@ -552,6 +611,28 @@ class SurfaceGeometry(Geometry):
             concrete=self.concrete,
         )
 
+    def mirror(self, axis: LineString) -> SurfaceGeometry:
+        """Returns a new SurfaceGeometry that is mirrored about the given axis.
+
+        Arguments:
+            axis (LineString): The axis to mirror about.
+
+        Returns:
+            SurfaceGeometry: The mirrored SurfaceGeometry.
+        """
+        if not isinstance(axis, LineString):
+            raise TypeError('axis should be a shapely LineString object')
+        # Build the transformation matrix
+        A = _mirror_about_axis_matrix(axis)
+        # Apply transformation matrix A
+        # Apply the transformation to the polygon
+        params = [A[0, 0], A[0, 1], A[1, 0], A[1, 1], A[0, 2], A[1, 2]]
+        return SurfaceGeometry(
+            poly=affinity.affine_transform(self.polygon, params),
+            material=self.material,
+            concrete=self.concrete,
+        )
+
     @staticmethod
     def from_geometry(
         geo: SurfaceGeometry,
@@ -595,9 +676,6 @@ class SurfaceGeometry(Geometry):
     # from_surface_geometry
     # from_dxf
     # from_ascii
-    # ...
-    # we could also add methods wrapping shapely function, like:
-    # mirror, translation, rotation, etc.
 
 
 def _process_geometries_multipolygon(
@@ -789,6 +867,23 @@ class CompoundGeometry(Geometry):
             processed_geoms.append(pg.rotate(angle, point, use_radians))
         return CompoundGeometry(geometries=processed_geoms)
 
+    def mirror(self, axis: LineString) -> CompoundGeometry:
+        """Returns a new CompoundGeometry that is mirrored about the given
+        axis.
+
+        Arguments:
+            axis (LineString): The axis to mirror about.
+
+        Returns:
+            CompoundGeometry: The mirrored CompoundGeometry.
+        """
+        processed_geoms = []
+        for g in self.geometries:
+            processed_geoms.append(g.mirror(axis))
+        for pg in self.point_geometries:
+            processed_geoms.append(pg.mirror(axis))
+        return CompoundGeometry(geometries=processed_geoms)
+
     def __sub__(self, other: Geometry) -> CompoundGeometry:
         """Add operator "-" for geometries.
 

structuralcodes/geometry/profiles/__init__.py

@@ -1,19 +1,33 @@
 """Main entry point for profiles."""
 
+from ._hd import HD
 from ._he import HE
+from ._hp import HP
 from ._ipe import IPE
 from ._ipn import IPN
+from ._l import L
+from ._li import LI
+from ._u import U
 from ._ub import UB
 from ._ubp import UBP
 from ._uc import UC
+from ._upe import UPE
 from ._upn import UPN
+from ._w import W
 
 __all__ = [
     'HE',
+    'HP',
+    'HD',
     'IPE',
     'IPN',
     'UB',
     'UBP',
     'UC',
     'UPN',
+    'UPE',
+    'U',
+    'W',
+    'L',
+    'LI',
 ]

structuralcodes/geometry/profiles/_common_functions.py

@@ -1,5 +1,7 @@
 """Common functions for creating profiles."""
 
+import math
+
 import numpy as np
 from shapely import (
     LineString,
@@ -59,9 +61,17 @@ def _create_I_section(h: float, b: float, tw: float, tf: float, r: float):
     fillet = translate(
         scale(fillet, 1, -1), xoff=0, yoff=h - 2 * tf - r
     ).union(fillet)
+
+    # Estimate grid_size value
+    # Tentative geometry (due to approximations can be a MultiPolygon)
+    geom_trial = unary_union([fillet, top_flange, bottom_flange, web])
+    # minx, miny, maxx, maxy
+    bounds = geom_trial.bounds
+    min_size = min(bounds[2] - bounds[0], bounds[3] - bounds[1])
+    grid_size = 10 ** int(math.floor(math.log10(abs(min_size)))) * 1e-12
     # Create the geometry
     geometries = [
-        set_precision(geometry, grid_size=1e-13)
+        set_precision(geometry, grid_size=grid_size)
         for geometry in [fillet, top_flange, bottom_flange, web]
     ]
     return orient(unary_union(geometries), 1)
@@ -192,3 +202,106 @@ def _create_taper_U_section(
     return orient(
         translate(poly, xoff=-poly.centroid.x, yoff=-poly.centroid.y), 1
     )
+
+
+def _create_parallel_U_section(
+    h: float,
+    b: float,
+    tw: float,
+    tf: float,
+    r: float,
+) -> Polygon:
+    """Returns a shapely polygon representing a Parallel Flange U Section."""
+    # top flange
+    top_flange = Polygon(
+        [
+            (0, h / 2 - tf),
+            (b, h / 2 - tf),
+            (b, h / 2),
+            (0, h / 2),
+        ]
+    )
+    # bottom flange
+    bottom_flange = translate(top_flange, xoff=0, yoff=-h + tf)
+    web = Polygon(
+        [
+            (0, -h / 2 + tf),
+            (tw, -h / 2 + tf),
+            (tw, h / 2 - tf),
+            (0, h / 2 - tf),
+        ]
+    )
+    # fillets
+    p = Point([tw + r, -h / 2 + tf + r]).buffer(r)
+    s = Polygon(
+        [
+            (tw, -h / 2 + tf),
+            (tw + r, -h / 2 + tf),
+            (tw + r, -h / 2 + tf + r),
+            (tw, -h / 2 + tf + r),
+        ]
+    )
+    fillet = s.difference(p)
+    fillet = translate(
+        scale(fillet, 1, -1), xoff=0, yoff=h - 2 * tf - r
+    ).union(fillet)
+    # Estimate grid_size value
+    # Tentative geometry (due to approximations can be a MultiPolygon)
+    geom_trial = unary_union([fillet, top_flange, bottom_flange, web])
+    # minx, miny, maxx, maxy
+    bounds = geom_trial.bounds
+    min_size = min(bounds[2] - bounds[0], bounds[3] - bounds[1])
+    grid_size = 10 ** int(math.floor(math.log10(abs(min_size)))) * 1e-12
+    # Create the geometry
+    geometries = [
+        set_precision(geometry, grid_size=grid_size)
+        for geometry in [fillet, top_flange, bottom_flange, web]
+    ]
+    geometry = orient(unary_union(geometries), 1)
+    # Return the geometry centered at the origin
+    return translate(
+        geometry, xoff=-geometry.centroid.x, yoff=-geometry.centroid.y
+    )
+
+
+def _create_L_section(
+    h: float, b: float, t1: float, t2: float, r1: float, r2: float
+) -> Polygon:
+    """Returns a shapely polygon representing a L Section."""
+    # Create first part of line
+    ls = [set_precision(LineString([[0, h], [0, 0], [b, 0]]), grid_size=1e-13)]
+    # Create fillet
+    xy = np.array([[b, 0], [b, t1], [b / 2, t1]])
+    ls.append(
+        set_precision(
+            LineString(xy).offset_curve(r2).offset_curve(-r2), grid_size=1e-13
+        )
+    )
+    # Create second fillet
+    xy = np.array([[b / 2, t1], [t2, t1], [t2, h / 2]])
+    ls.append(
+        set_precision(
+            LineString(xy).offset_curve(-r1).offset_curve(r1), grid_size=1e-13
+        )
+    )
+    # Last fillet
+    xy = np.array([[t2, h / 2], [t2, h], [0, h]])
+    ls.append(
+        set_precision(
+            LineString(xy).offset_curve(r2).offset_curve(-r2), grid_size=1e-13
+        )
+    )
+    # Merge filleted
+    merged_ls = linemerge(ls)
+
+    merged_ls
+
+    # Create a polygon
+    poly = polygonize([merged_ls])
+
+    # Return the first and only polygon of this collection
+    poly = get_geometry(poly, 0)
+    # Translate it to the centroid when returning
+    return orient(
+        translate(poly, xoff=-poly.centroid.x, yoff=-poly.centroid.y), 1
+    )