structuralcodes 0.5.0__tar.gz → 0.6.0__tar.gz

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: structuralcodes
-Version: 0.5.0
+Version: 0.6.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
+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.0}/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.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.5.0'
+__version__ = '0.6.0'
 
 __all__ = [
     'set_design_code',

{structuralcodes-0.5.0 → structuralcodes-0.6.0}/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.0}/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)
 

{structuralcodes-0.5.0 → structuralcodes-0.6.0}/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.0}/structuralcodes/geometry/_geometry.py

@@ -79,6 +79,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.
@@ -470,17 +481,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.
 
@@ -789,17 +789,6 @@ 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.
-
-        Arguments:
-            other (Geometry): The other geometry to add.
-
-        Returns:
-            CompoundGeometry: A new CompoundGeometry.
-        """
-        return CompoundGeometry([self, other])
-
     def __sub__(self, other: Geometry) -> CompoundGeometry:
         """Add operator "-" for geometries.
 

{structuralcodes-0.5.0 → structuralcodes-0.6.0}/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.0/structuralcodes/geometry/profiles/__init__.py

@@ -0,0 +1,19 @@
+"""Main entry point for profiles."""
+
+from ._he import HE
+from ._ipe import IPE
+from ._ipn import IPN
+from ._ub import UB
+from ._ubp import UBP
+from ._uc import UC
+from ._upn import UPN
+
+__all__ = [
+    'HE',
+    'IPE',
+    'IPN',
+    'UB',
+    'UBP',
+    'UC',
+    'UPN',
+]

structuralcodes-0.6.0/structuralcodes/geometry/profiles/_base_profile.py

@@ -0,0 +1,305 @@
+"""Base class for profiles."""
+
+import numpy as np
+from shapely import (
+    LinearRing,
+    LineString,
+    Polygon,
+)
+from shapely.affinity import rotate, translate
+from shapely.ops import split
+
+from structuralcodes.core._marin_integration import marin_integration
+
+
+class BaseProfile:
+    """Base class representing a profile.
+
+    Contains the common code for all profiles.
+    """
+
+    def __init__(self):
+        """Creates an empty base profile."""
+        self._polygon: Polygon = None
+        self._A: float = None
+        self._Iy: float = None
+        self._Iz: float = None
+        self._Icsi: float = None
+        self._Ieta: float = None
+        self._Iyz: float = None
+        self._Wely: float = None
+        self._Welz: float = None
+        self._iy: float = None
+        self._iz: float = None
+        self._Wply: float = None
+        self._Wplz: float = None
+
+    def _check_polygon_defined(self):
+        """Just checks if polygon attribute is defined.
+
+        If the polygon is not defined (it should never happen), an exception
+        is Raised.
+        """
+        # The polygon attribute should be already defined
+        if self._polygon is None:
+            raise RuntimeError(
+                'The polygon for some reason was not correctly defined.'
+            )
+
+    def _find_plastic_neutral_axis_y(self) -> float:
+        """Find posizion z of plastic neutral axes parallel to y.
+
+        We use bisection algorithm within the section limits.
+        """
+        bounds = self.polygon.bounds
+        zmin, zmax = bounds[1], bounds[3]
+
+        zA = zmin
+        zB = zmax
+
+        daA = self._find_delta_area_above_minus_below(z=zA)
+
+        ITMAX = 200
+        it = 0
+
+        while (it < ITMAX) and (abs(zB - zA) > (zmax - zmin) * 1e-10):
+            zC = (zA + zB) / 2.0
+            daC = self._find_delta_area_above_minus_below(z=zC)
+            if abs(daC) < 1e-10:
+                break
+            if daA * daC < 0:
+                # The solution is between A and C
+                zB = zC
+            else:
+                # The solution is between C and B
+                zA = zC
+                daA = daC
+            it += 1
+        if it >= ITMAX:
+            s = f'Last iteration reached a unbalance of {daC}'
+            raise ValueError(f'Maximum number of iterations reached.\n{s}')
+
+        return zC
+
+    def _find_delta_area_above_minus_below(self, z: float) -> float:
+        """Returns area difference between above and below parts.
+
+        Above and below parts are computed splitting the polygon with a line
+        parallel to Y axes at z coordinate.
+        """
+        bounds = self._polygon.bounds
+        xmax = max(abs(bounds[0]), bounds[2])
+        line = LineString([[-xmax * 1.05, z], [xmax * 1.05, z]])
+
+        area_above = 0
+        area_below = 0
+        # divide polygons "above" and "below" line
+        if line.intersects(self._polygon):
+            result = split(self._polygon, line)
+            # divide polygons "above" and "below" line
+            for geom in result.geoms:
+                if LinearRing(
+                    (line.coords[0], line.coords[1], geom.centroid.coords[0])
+                ).is_ccw:
+                    area_above += geom.area
+                else:
+                    area_below += geom.area
+        else:
+            # not intersecting, all the polygon is above or below the line
+            geom = self.polygon
+            if LinearRing(
+                (line.coords[0], line.coords[1], geom.centroid.coords[0])
+            ).is_ccw:
+                area_above += geom.area
+            else:
+                area_below += geom.area
+        return area_above - area_below
+
+    def _find_principals_direction_and_moments(self):
+        """Computes principal direction and second area moments."""
+        eigres = np.linalg.eig(
+            np.array([[self.Iy, self.Iyz], [self.Iyz, self.Iz]])
+        )
+        max_idx = np.argmax(eigres[0])
+        min_idx = 0 if max_idx == 1 else 1
+        self._Icsi = eigres[0][max_idx]
+        self._Ieta = eigres[0][min_idx]
+        self._theta = np.arccos(
+            np.dot(np.array([1, 0]), eigres[1][:, max_idx])
+        )
+
+    @property
+    def A(self) -> float:
+        """Returns area of profile."""
+        if self._A is None:
+            # Check if the polygon is defined
+            self._check_polygon_defined()
+            # Get the polygon coordinates:
+            xy = self._polygon.exterior.coords.xy
+            # Compute area
+            self._A = marin_integration(xy[0], xy[1], 0, 0)
+        return self._A
+
+    @property
+    def Iy(self) -> float:
+        """Returns second moment of area around y axis."""
+        if self._Iy is None:
+            # Check if the polygon is defined
+            self._check_polygon_defined()
+            # Get the polygon coordinates:
+            xy = self._polygon.exterior.coords.xy
+            # Compute second moments of inertia
+            self._Iy = marin_integration(xy[0], xy[1], 0, 2)
+        return self._Iy
+
+    @property
+    def Iz(self) -> float:
+        """Returns second moment of area around z axis."""
+        if self._Iz is None:
+            # Check if the polygon is defined
+            self._check_polygon_defined()
+            # Get the polygon coordinates:
+            xy = self._polygon.exterior.coords.xy
+            # Compute second moments of inertia
+            self._Iz = marin_integration(xy[0], xy[1], 2, 0)
+        return self._Iz
+
+    @property
+    def Iyz(self) -> float:
+        """Returns product moment of inertia."""
+        if self._Iyz is None:
+            # Check if the polygon is defined
+            self._check_polygon_defined()
+            # Get the polygon coordinates:
+            xy = self._polygon.exterior.coords.xy
+            # Compute product moment of area
+            self._Iyz = marin_integration(xy[0], xy[1], 1, 1)
+        return self._Iyz
+
+    @property
+    def Icsi(self) -> float:
+        """Returns second moment of area around principal csi axis.
+
+        It is assumed that Icsi is maximum second moment, while Ieta is the
+        minimum one.
+        """
+        if self._Icsi is None:
+            self._find_principals_direction_and_moments()
+        return self._Icsi
+
+    @property
+    def Ieta(self) -> float:
+        """Returns second moment of area around principal eta axis.
+
+        It is assumed that Icsi is maximum second moment, while Ieta is the
+        minimum one.
+        """
+        if self._Ieta is None:
+            self._find_principals_direction_and_moments()
+        return self._Ieta
+
+    @property
+    def theta(self) -> float:
+        """Returns angle between x and principal eta axis.
+
+        It is assumed that Icsi is maximum second moment, while Ieta is the
+        minimum one.
+
+        Returns:
+            float: The angle in radians.
+        """
+        if self._theta is None:
+            self._find_principals_direction_and_moments()
+        return self._theta
+
+    def _compute_elastic_moduli(self):
+        """Compute elastic moduli Wely and Welz."""
+        # Check if the polygon is defined
+        self._check_polygon_defined()
+        # For computing section modulus get bounds
+        bounds = self._polygon.bounds
+        xmax = max(abs(bounds[0]), bounds[2])
+        ymax = max(abs(bounds[1]), bounds[3])
+        # Then compute section modulus
+        self._Wely = self.Iy / ymax
+        self._Welz = self.Iz / xmax
+
+    @property
+    def Wely(self) -> float:
+        """Returns section modulus in y direction."""
+        if self._Wely is None:
+            # Compute elastic moduli
+            self._compute_elastic_moduli()
+        return self._Wely
+
+    @property
+    def Welz(self) -> float:
+        """Returns section modulus in z direction."""
+        if self._Welz is None:
+            # Compute elastic moduli
+            self._compute_elastic_moduli()
+        return self._Welz
+
+    @property
+    def Wply(self) -> float:
+        """Returns plastic section modulus in y direction."""
+        if self._Wply is None:
+            # Check if the polygon is defined
+            self._check_polygon_defined()
+            # For computing section modulus get bounds
+            bounds = self._polygon.bounds
+            xmax = max(abs(bounds[0]), bounds[2])
+            # Compute plastic section modulus
+            # find plastic neutral axis parallel to y
+            self._Wply = 0
+            z_pna = self._find_plastic_neutral_axis_y()
+            poly = translate(self._polygon, xoff=0, yoff=-z_pna)
+            result = split(
+                poly,
+                LineString([[-xmax * 1.05, 0], [xmax * 1.05, 0]]),
+            )
+            for poly in result.geoms:
+                xy = poly.exterior.coords.xy
+                self._Wply += abs(marin_integration(xy[0], xy[1], 0, 1))
+        return self._Wply
+
+    @property
+    def Wplz(self) -> float:
+        """Returns plastic section modulus in z direction."""
+        if self._Wplz is None:
+            # Check if the polygon is defined
+            self._check_polygon_defined()
+            # For computing section modulus get bounds
+            bounds = self._polygon.bounds
+            ymax = max(abs(bounds[1]), bounds[3])
+            # Compute plastic section modulus
+            # # find plastic neutral axis parallel to z
+            self._polygon = rotate(geom=self._polygon, angle=90, origin=(0, 0))
+            self._Wplz = 0
+            y_pna = self._find_plastic_neutral_axis_y()
+            poly = translate(self._polygon, xoff=0, yoff=-y_pna)
+            result = split(
+                poly,
+                LineString([[-ymax * 1.05, 0], [ymax * 1.05, 0]]),
+            )
+            for poly in result.geoms:
+                xy = poly.exterior.coords.xy
+                self._Wplz += abs(marin_integration(xy[0], xy[1], 0, 1))
+            self._polygon = rotate(
+                geom=self._polygon, angle=-90, origin=(0, 0)
+            )
+        return self._Wplz
+
+    @property
+    def iy(self) -> float:
+        """Returns radius of inertia of profile."""
+        # Compute radius of inertia
+        self._iy = self._iy or (self.Iy / self.A) ** 0.5
+        return self._iy
+
+    @property
+    def iz(self) -> float:
+        """Returns radius of inertia of profile."""
+        # Compute radius of inertia
+        self._iz = self._iz or (self.Iz / self.A) ** 0.5
+        return self._iz