structuralcodes 0.5.0__tar.gz → 0.6.1__tar.gz

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: structuralcodes
-Version: 0.5.0
+Version: 0.6.1
 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
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent

{structuralcodes-0.5.0 → structuralcodes-0.6.1}/pyproject.toml

@@ -10,7 +10,7 @@ authors = [
     {name = "fib - International Federation for Structural Concrete", email = "info@fib-international.org"}
 ]
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 classifiers = [
     "Programming Language :: Python :: 3",
     "Operating System :: OS Independent"

{structuralcodes-0.5.0 → structuralcodes-0.6.1}/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.5.0'
+__version__ = '0.6.1'
 
 __all__ = [
     'set_design_code',

{structuralcodes-0.5.0 → structuralcodes-0.6.1}/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-0.5.0 → structuralcodes-0.6.1}/structuralcodes/codes/mc2010/_concrete_creep_and_shrinkage.py

@@ -95,13 +95,13 @@ def _check_initial_stress(sigma: float, fcm: float) -> None:
         raise ValueError(
             'The stress level exceeds the range of application.'
             'Maximum allowable stress is 0.6*fcm. Current stress level '
-            f'is {round(abs(sigma)/fcm, 3)}*fcm.'
+            f'is {round(abs(sigma) / fcm, 3)}*fcm.'
         )
     if abs(sigma) > 0.4 * fcm:
         warnings.warn(
             'Initial stress is too high to consider the '
             'concrete as an aging linear visco-elastic material: '
-            f'sigma = {round(abs(sigma)/fcm,3)}*fcm > 0.4*fcm. Nonlinear'
+            f'sigma = {round(abs(sigma) / fcm, 3)}*fcm > 0.4*fcm. Nonlinear'
             ' creep calculations are performed according to subclause '
             '5.1.9.4.3 (d) of the fib Model Code 2010 to account for '
             'large compressive stresses.'

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

@@ -15,17 +15,44 @@ class Material(abc.ABC):
     """Abstract base class for materials."""
 
     _constitutive_law = None
-
-    def __init__(self, density: float, name: t.Optional[str] = None) -> None:
+    _initial_strain: t.Optional[float] = None
+    _initial_stress: t.Optional[float] = None
+    _strain_compatibility: t.Optional[bool] = None
+
+    def __init__(
+        self,
+        density: float,
+        initial_strain: t.Optional[float] = None,
+        initial_stress: t.Optional[float] = None,
+        strain_compatibility: t.Optional[bool] = None,
+        name: t.Optional[str] = None,
+    ) -> None:
         """Initializes an instance of a new material.
 
         Args:
-            density (float): density of the material in kg/m3
+            density (float): Density of the material in kg/m3.
 
         Keyword Args:
+            initial_strain (Optional[float]): Initial strain of the material.
+            initial_stress (Optional[float]): Initial stress of the material.
+            strain_compatibility (Optional[bool]): Only relevant if
+                initial_strain or initial_stress are different from zero. If
+                True, the material deforms with the geometry. If False, the
+                stress in the material upon loading is kept constant
+                corresponding to the initial strain.
             name (Optional[str]): descriptive name of the material
+
+        Raise:
+            ValueError: if both initial_strain and initial_stress are provided
         """
         self._density = abs(density)
+        if initial_strain is not None and initial_stress is not None:
+            raise ValueError(
+                'Both initial_strain and initial_stress cannot be provided.'
+            )
+        self._initial_strain = initial_strain
+        self._initial_stress = initial_stress
+        self._strain_compatibility = strain_compatibility
         self._name = name if name is not None else 'Material'
 
     @property
@@ -43,6 +70,88 @@ class Material(abc.ABC):
         """Returns the density of the material in kg/m3."""
         return self._density
 
+    @property
+    def initial_strain(self):
+        """Returns the initial strain of the material."""
+        return self._initial_strain
+
+    @property
+    def initial_stress(self):
+        """Returns the initial stress of the material."""
+        return self._initial_stress
+
+    @property
+    def strain_compatibility(self):
+        """Returns the strain compatibility of the material.
+
+        If true (default), the strain compatibility is enforced
+        haveing the same strain as in all other materials of the
+        section at the same point. If false, the strain compatibility
+        is not enforced and the initial strain is applied to the section
+        independently.
+        """
+        return self._strain_compatibility
+
+    def _apply_initial_strain(self):
+        """Wraps the current constitutive law to apply initial strain."""
+        strain_compatibility = (
+            self._strain_compatibility
+            if self._strain_compatibility is not None
+            else True
+        )
+        if self._initial_stress is not None:
+            # Specified a stress, compute the strain from it
+            self._initial_strain_from_stress()
+        if self._initial_strain is not None:
+            # Lazy import to avoid circular dependency
+            from structuralcodes.materials.constitutive_laws import (  # noqa: PLC0415
+                InitialStrain,
+            )
+
+            if self._initial_stress is None:
+                # Compute the stress from the strain
+                self._initial_stress = self._constitutive_law.get_stress(
+                    self._initial_strain
+                )
+
+            self._constitutive_law = InitialStrain(
+                self._constitutive_law,
+                self._initial_strain,
+                strain_compatibility,
+            )
+
+    def _initial_strain_from_stress(self):
+        """Computes the initial strain from the initial stress.
+
+        This function is called internally so it assumes that the
+        initial stress is not None
+        """
+        # Iteratively compute the initial strain that gives the desired
+        # initial stress. Note that the wrapped law can be nonlinear
+        tol = 1e-12
+        max_iter = 100
+        target_stress = self._initial_stress
+        strain = 0.0
+        stress = self._constitutive_law.get_stress(strain)
+        d_stress = target_stress - stress
+        num_iter = 0
+        while abs(d_stress) > tol and num_iter < max_iter:
+            tangent = self._constitutive_law.get_tangent(strain)
+            if tangent == 0:
+                raise ValueError(
+                    'Tangent modulus = 0 during initial strain computation.'
+                )
+            d_strain = d_stress / tangent
+            strain += d_strain
+            stress = self._constitutive_law.get_stress(strain)
+            d_stress = target_stress - stress
+            num_iter += 1
+
+        if abs(d_stress) > tol:
+            raise RuntimeError('Failed to converge for given initial stress.')
+
+        self._initial_strain = strain
+
 
 class ConstitutiveLaw(abc.ABC):
     """Abstract base class for constitutive laws."""
@@ -150,7 +259,9 @@ class ConstitutiveLaw(abc.ABC):
 
         eps = np.concatenate((eps_neg, eps_pos))
         sig = self.get_stress(eps)
-        from structuralcodes.materials.constitutive_laws import UserDefined
+        from structuralcodes.materials.constitutive_laws import (  # noqa: PLC0415
+            UserDefined,
+        )
 
         return UserDefined(eps, sig)
 
@@ -176,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-0.5.0 → structuralcodes-0.6.1}/structuralcodes/geometry/__init__.py

@@ -1,5 +1,6 @@
 """Main entry point for geometry."""
 
+from . import profiles
 from ._circular import CircularGeometry
 from ._geometry import (
     CompoundGeometry,
@@ -14,7 +15,6 @@ from ._reinforcement import (
     add_reinforcement_circle,
     add_reinforcement_line,
 )
-from ._steel_sections import HE, IPE, IPN, UB, UBP, UC, UPN
 
 __all__ = [
     'Geometry',
@@ -22,13 +22,7 @@ __all__ = [
     'SurfaceGeometry',
     'CompoundGeometry',
     'create_line_point_angle',
-    'IPE',
-    'HE',
-    'UB',
-    'UC',
-    'UBP',
-    'IPN',
-    'UPN',
+    'profiles',
     'add_reinforcement',
     'add_reinforcement_line',
     'CircularGeometry',

{structuralcodes-0.5.0 → structuralcodes-0.6.1}/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."""
 
@@ -79,6 +113,17 @@ class Geometry:
             'This method should be implemented by subclasses'
         )
 
+    def __add__(self, other: Geometry) -> CompoundGeometry:
+        """Add operator "+" for geometries.
+
+        Arguments:
+            other (Geometry): The other geometry to add.
+
+        Returns:
+            CompoundGeometry: A new CompoundGeometry.
+        """
+        return CompoundGeometry([self, other])
+
 
 class PointGeometry(Geometry):
     """Class for a point geometry with material.
@@ -218,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,
@@ -470,17 +540,6 @@ class SurfaceGeometry(Geometry):
         # get the intersection
         return self.polygon.intersection(lines_polygon)
 
-    def __add__(self, other: Geometry) -> CompoundGeometry:
-        """Add operator "+" for geometries.
-
-        Arguments:
-            other (Geometry): The other geometry to add.
-
-        Returns:
-            CompoundGeometry: A new CompoundGeometry.
-        """
-        return CompoundGeometry([self, other])
-
     def __sub__(self, other: Geometry) -> SurfaceGeometry:
         """Add operator "-" for geometries.
 
@@ -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,16 +867,22 @@ class CompoundGeometry(Geometry):
             processed_geoms.append(pg.rotate(angle, point, use_radians))
         return CompoundGeometry(geometries=processed_geoms)
 
-    def __add__(self, other: Geometry) -> CompoundGeometry:
-        """Add operator "+" for geometries.
+    def mirror(self, axis: LineString) -> CompoundGeometry:
+        """Returns a new CompoundGeometry that is mirrored about the given
+        axis.
 
         Arguments:
-            other (Geometry): The other geometry to add.
+            axis (LineString): The axis to mirror about.
 
         Returns:
-            CompoundGeometry: A new CompoundGeometry.
+            CompoundGeometry: The mirrored CompoundGeometry.
         """
-        return CompoundGeometry([self, other])
+        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-0.5.0 → structuralcodes-0.6.1}/structuralcodes/geometry/_reinforcement.py

@@ -78,8 +78,6 @@ def add_reinforcement_line(
         CompoundGeometry: A compound geometry with the original geometry and
         the reinforcement.
     """
-    from math import floor
-
     p1 = np.array(coords_i)
     p2 = np.array(coords_j)
     distance = np.linalg.norm(p2 - p1)
@@ -100,7 +98,7 @@ def add_reinforcement_line(
     elif s > 0:
         # Provided the spacing
         # 1. Compute the number of bars
-        n = floor(distance / s) + 1
+        n = math.floor(distance / s) + 1
         # 2. Distribute the bars centered in the segment
         d = (n - 1) * s
         p1 = p1 + v * (distance - d) / 2.0

structuralcodes-0.6.1/structuralcodes/geometry/profiles/__init__.py

@@ -0,0 +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',
+]