structuralcodes 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

structuralcodes/sections/section_integrators/_marin_integrator.py

@@ -6,11 +6,15 @@ import typing as t
 from math import atan2, cos, sin
 
 import numpy as np
-from numpy.typing import ArrayLike
+from numpy.typing import ArrayLike, NDArray
 from shapely import MultiLineString, MultiPolygon, Polygon
 from shapely.geometry.polygon import orient
 
-from structuralcodes.geometry import CompoundGeometry, create_line_point_angle
+from structuralcodes.geometry import (
+    CompoundGeometry,
+    SurfaceGeometry,
+    create_line_point_angle,
+)
 
 from ._marin_integration import marin_integration
 from ._section_integrator import SectionIntegrator
@@ -19,102 +23,104 @@ from ._section_integrator import SectionIntegrator
 class MarinIntegrator(SectionIntegrator):
     """Section integrator based on the Marin algorithm."""
 
-    def prepare_input(
+    def _rotate_geometry(
         self, geo: CompoundGeometry, strain: ArrayLike
-    ) -> t.Tuple[float, t.Tuple[np.ndarray, np.ndarray, np.ndarray]]:
-        """Prepare general input to the integration.
-
-        Calculate the stresses based on strains in a set of points.
-
-        Keyword Arguments:
-            geo (CompoundGeometry): The geometry of the section.
-            strain (ArrayLike): The strains and curvatures of the section,
-                given in the format (ea, ky, kz) which are i) strain at 0,0,
-                ii) curvature y axis, iii) curvature z axis.
-            mesh_size: Percentage of area (number from 0 to 1) max for triangle
-                elements.
-
-        Returns:
-            Tuple(float, Tuple(ndarray, ndarray, ndarray)): The prepared input
-            represented as the angle of rotation computed (needed for rotating
-            back the resultants) and as a tuple with 3 ndarrys collecting
-            respectively y, z and stress coefficients for each sub-part.
+    ) -> t.Tuple[float, CompoundGeometry, ArrayLike]:
+        """This function returns the geometry, strain and angle in a rotated
+        CRS for which bending is uniaxial.
         """
-        # This method should do the following tasks:
-        # - For each geo:
-        #   - ask constitutive law strain limits and coefficients
-        #   - For each material part, the part should furthermore be split
-        # according to constant, linear and parabolic stress distribution.
-        #   - For each part collect coordinates y and z in separate np.ndarray
-        # iterables, and stress coefficients in a two-dimensional np.ndarray.
-        #
-        # The method should therefore return a tuple that collects the y, z,
-        # and stress coefficients for each part.
-        prepared_input = []
-        # 1. Rotate section in order to have neutral axis horizontal
+        # Rotate section in order to have neutral axis horizontal
         angle = -atan2(strain[2], strain[1])
 
         rotated_geom = geo.rotate(angle)
-        # 2. Get y coordinate of neutral axis in this new CRS
+        # Determine strain in this rotated CRS
         strain_rotated = [strain[0], (strain[2] ** 2 + strain[1] ** 2) ** 0.5]
 
-        # 3. For each SurfaceGeometry on the CompoundGeometry:
-        for g in rotated_geom.geometries:
-            # 3a. get coefficients and strain limits from constitutive law
-            if hasattr(g.material, '__marin__'):
-                strains, coeffs = g.material.__marin__(strain=strain_rotated)
+        return angle, rotated_geom, strain_rotated
+
+    def _get_input_polygon(
+        self, polygon: Polygon, coeffs: ArrayLike, input: list
+    ):
+        """Appends to input list the coordinates and coefficient of polygon."""
+        # Let's be sure to orient in the right way
+        if polygon.is_empty:
+            return
+        polygon = orient(polygon, 1)
+        if not polygon.exterior.is_ccw:
+            raise ValueError(
+                'The exterior of a polygon should have vertices \
+                            ordered ccw'
+            )
+        # Manage exterior part
+        x, y = polygon.exterior.coords.xy
+        x = np.array(x)
+        y = np.array(y)
+        input.append((0, np.array(x), np.array(y), np.array(coeffs)))
+        # Manage holes
+        for i in polygon.interiors:
+            if i.is_ccw:
+                raise ValueError('A inner hole should have cw coordinates')
+            x, y = i.coords.xy
+            input.append((0, np.array(x), np.array(y), np.array(coeffs)))
+
+    def _get_coefficcients(
+        self,
+        geo: SurfaceGeometry,
+        strain: ArrayLike,
+        integrate: t.Literal['stress', 'modulus'] = 'stress',
+    ) -> t.Tuple[t.List[t.Tuple], t.List[t.Tuple]]:
+        """Get Marin coefficients."""
+        if integrate == 'stress':
+            if hasattr(geo.material, '__marin__'):
+                strains, coeffs = geo.material.__marin__(strain=strain)
             else:
                 raise AttributeError(
-                    f'The material object {g.material} of geometry {g} does \
-                    not have implement the __marin__ function. \
-                    Please implement the function or use another integrator, \
-                    like '
+                    f'The material object {geo.material} of geometry {geo} \
+                    does not have implement the __marin__ function. \
+                    Please implement the function or use another integrator,\
+                     like '
                     'Fibre'
                     ''
                 )
-
-            # 3b. Subdivide the polygon at the different strain limits
-            def get_input_polygon(polygon, coeffs):
-                # Let's be sure to orient in the right way
-                if polygon.is_empty:
-                    return
-                polygon = orient(polygon, 1)
-                if not polygon.exterior.is_ccw:
-                    raise ValueError(
-                        'The exterior of a polygon should have vertices \
-                                    ordered ccw'
-                    )
-                # Manage exterior part
-                x, y = polygon.exterior.coords.xy
-                x = np.array(x)
-                y = np.array(y)
-                prepared_input.append(
-                    (0, np.array(x), np.array(y), np.array(coeffs))
+        elif integrate == 'modulus':
+            if hasattr(geo.material, '__marin_tangent__'):
+                strains, coeffs = geo.material.__marin_tangent__(strain=strain)
+            else:
+                raise AttributeError(
+                    f'The material object {geo.material} of geometry {geo} \
+                    does not have implement the __marin_tangent__ function\
+                    . \
+                    Please implement the function or use another integrato\
+                    r, like '
+                    'Fibre'
+                    ''
                 )
-                # Manage holes
-                for i in polygon.interiors:
-                    if i.is_ccw:
-                        raise ValueError(
-                            'A inner hole should have cw coordinates'
-                        )
-                    x, y = i.coords.xy
-                    prepared_input.append(
-                        (0, np.array(x), np.array(y), np.array(coeffs))
-                    )
+        else:
+            raise ValueError(f'Unknown integrate type: {integrate}')
+
+        return strains, coeffs
 
+    def _process_surface_geometries(
+        self,
+        geo: CompoundGeometry,
+        strain: ArrayLike,
+        input: t.List,
+        integrate: t.Literal['stress', 'modulus'] = 'stress',
+    ):
+        """Process Surface geometries filling the input data for each one."""
+        # For each SurfaceGeometry on the CompoundGeometry:
+        for g in geo.geometries:
+            # Get coefficients and strain limits from constitutive law
+            strains, coeffs = self._get_coefficcients(g, strain, integrate)
+
+            # Subdivide the polygon at the different strain limits
             if strains is None:
-                get_input_polygon(g.polygon, coeffs[0])
+                self._get_input_polygon(g.polygon, coeffs[0], input)
             else:
                 for p in range(len(strains)):
                     # Create the two lines for selecting the needed part
-                    y0 = (
-                        -(strain_rotated[0] - strains[p][0])
-                        / strain_rotated[1]
-                    )
-                    y1 = (
-                        -(strain_rotated[0] - strains[p][1])
-                        / strain_rotated[1]
-                    )
+                    y0 = -(strain[0] - strains[p][0]) / strain[1]
+                    y1 = -(strain[0] - strains[p][1]) / strain[1]
                     if y0 > y1:
                         y0, y1 = y1, y0
                     bbox = g.polygon.bounds
@@ -126,29 +132,94 @@ class MarinIntegrator(SectionIntegrator):
 
                     if isinstance(result, Polygon):
                         # If the result is a single polygon
-                        get_input_polygon(result, coeffs[p])
+                        self._get_input_polygon(result, coeffs[p], input)
                     elif isinstance(result, MultiPolygon):
                         # If the result is a MultiPolygon
                         for polygon in result.geoms:
-                            get_input_polygon(polygon, coeffs[p])
+                            self._get_input_polygon(polygon, coeffs[p], input)
+
+    def _process_point_geometries(
+        self,
+        geo: CompoundGeometry,
+        strain: ArrayLike,
+        input: t.List,
+        integrate: t.Literal['stress', 'modulus'] = 'stress',
+    ):
+        """Process Point geometries filling the input data."""
         # Tentative proposal for managing reinforcement (PointGeometry)
         x = []
         y = []
-        F = []
-        for pg in rotated_geom.point_geometries:
+        IA = []
+        for pg in geo.point_geometries:
             xp, yp = pg._point.coords.xy
             xp = xp[0]
             yp = yp[0]
             A = pg.area
-            strain = strain_rotated[0] + strain_rotated[1] * yp
+            strain_ = strain[0] + strain[1] * yp
             x.append(xp)
             y.append(yp)
-            F.append(pg.material.get_stress(strain) * A)
-        prepared_input.append((1, np.array(x), np.array(y), np.array(F)))
+            if integrate == 'stress':
+                IA.append(pg.material.get_stress(strain_) * A)
+            elif integrate == 'modulus':
+                IA.append(pg.material.get_tangent(strain_) * A)
+        input.append((1, np.array(x), np.array(y), np.array(IA)))
+
+    def prepare_input(
+        self,
+        geo: CompoundGeometry,
+        strain: ArrayLike,
+        integrate: t.Literal['stress', 'modulus'] = 'stress',
+    ) -> t.Tuple[float, t.Tuple[np.ndarray, np.ndarray, np.ndarray]]:
+        """Prepare general input to the integration of stress or material
+        modulus in the section.
+
+        Calculate the stress resultants or tangent section stiffness based on
+        strains in a set of points.
+
+        Keyword Arguments:
+            geo (CompoundGeometry): The geometry of the section.
+            strain (ArrayLike): The strains and curvatures of the section,
+                given in the format (ea, ky, kz) which are i) strain at 0,0,
+                ii) curvature y axis, iii) curvature z axis.
+            integrate (str): a string indicating the quantity to integrate over
+                the section. It can be 'stress' or 'modulus'. When 'stress'
+                is selected, the return value will be the stress resultants N,
+                My, Mz, while if 'modulus' is selected, the return will be the
+                section stiffness matrix (default is 'stress').
+
+        Returns:
+            Tuple(float, Tuple(ndarray, ndarray, ndarray)): The prepared input
+            represented as the angle of rotation computed (needed for rotating
+            back the resultants) and as a tuple with 3 ndarrys collecting
+            respectively y, z and stress coefficients for each sub-part.
+
+        Raises:
+            ValueError: If a unkown value is passed to the `integrate`
+            parameter.
+        """
+        # The method should therefore return a tuple that collects the y, z,
+        # and stress coefficients for each part.
+        prepared_input = []
+        # Rotate section in order to have neutral axis horizontal
+        angle, rotated_geom, strain_rotated = self._rotate_geometry(
+            geo, strain
+        )
+
+        # Process all the surface geometries splitting them and appending
+        # coefficients and strain limits to prepared_input
+        self._process_surface_geometries(
+            rotated_geom, strain_rotated, prepared_input, integrate
+        )
+
+        # Process all the point geometries (i.e. reinforcement) splitting them
+        # and appending coefficients and strain limits to prepared_input
+        self._process_point_geometries(
+            rotated_geom, strain_rotated, prepared_input, integrate
+        )
 
         return angle, prepared_input
 
-    def integrate(
+    def integrate_stress(
         self,
         angle: float,
         prepared_input: t.List[
@@ -161,10 +232,10 @@ class MarinIntegrator(SectionIntegrator):
             prepared_input (List): The prepared input from .prepare_input().
 
         Returns:
-            Tuple(float, float, float): The stress resultants N, Mx and My.
+            Tuple(float, float, float): The stress resultants N, My and Mz.
         """
         # Set the stress resultants to zero
-        N, Mx, My = 0.0, 0.0, 0.0
+        N, My, Mz = 0.0, 0.0, 0.0
 
         # Loop through all parts of the section and add contributions
         for i, y, z, stress_coeff in prepared_input:
@@ -176,47 +247,147 @@ class MarinIntegrator(SectionIntegrator):
                 area_moments_N = np.array(
                     [marin_integration(y, z, 0, k) for k in range(n)]
                 )
-                area_moments_Mx = np.array(
+                area_moments_My = np.array(
                     [marin_integration(y, z, 0, k + 1) for k in range(n)]
                 )
-                area_moments_My = np.array(
+                area_moments_Mz = np.array(
                     [marin_integration(y, z, 1, k) for k in range(n)]
                 )
 
                 # Calculate contributions to stress resultants
                 N += sum(stress_coeff * area_moments_N)
-                Mx += sum(stress_coeff * area_moments_Mx)
                 My += sum(stress_coeff * area_moments_My)
+                Mz -= sum(stress_coeff * area_moments_Mz)
             elif i == 1:
                 # Reinforcement
                 N += sum(stress_coeff)
-                Mx += sum(stress_coeff * z)
-                My += sum(stress_coeff * y)
+                My += sum(stress_coeff * z)
+                Mz -= sum(stress_coeff * y)
 
         # Rotate back to section CRS
         T = np.array([[cos(-angle), -sin(-angle)], [sin(-angle), cos(-angle)]])
-        M = T @ np.array([[Mx], [-My]])
+        M = T @ np.array([[My], [Mz]])
 
         return N, M[0, 0], M[1, 0]
 
+    def integrate_modulus(
+        self,
+        angle: float,
+        prepared_input: t.List[
+            t.Tuple[int, np.ndarray, np.ndarray, np.ndarray]
+        ],
+    ) -> NDArray[np.float64]:
+        """Integrate material modulus over the geometry.
+
+        Arguments:
+            prepared_input (List): The prepared input from .prepare_input().
+
+        Returns:
+            ndarray: The section stiffness matrix as a (3, 3) ndarray.
+        """
+        # Create the stiffness matrix
+        stiffness = np.zeros((3, 3), dtype=np.float64)
+
+        # Create a map of indices
+        # (i,j), m, offset, sign
+        indices = [
+            ((0, 0), 0, 0, 1),
+            ((0, 1), 0, 1, 1),
+            ((0, 2), 1, 0, -1),
+            ((1, 1), 0, 2, 1),
+            ((1, 2), 1, 1, -1),
+            ((2, 2), 2, 0, 1),
+        ]
+
+        # Loop through all parts of the section and add contributions
+        for id, y, z, modulus_coeff in prepared_input:
+            if id == 0:
+                # Find integration order from shape of stress coeff array
+                n = modulus_coeff.shape[0]
+
+                # Calculate needed area moments
+                for (i, j), m, offset, sign in indices:
+                    area_moments = np.array(
+                        [
+                            marin_integration(y, z, m, k + offset)
+                            for k in range(n)
+                        ]
+                    )
+                    stiffness[i, j] += sign * sum(modulus_coeff * area_moments)
+            elif id == 1:
+                # Reinforcement
+                stiffness[0, 0] += sum(modulus_coeff)
+                stiffness[0, 1] += sum(modulus_coeff * z)
+                stiffness[0, 2] -= sum(modulus_coeff * y)
+                stiffness[1, 1] += sum(modulus_coeff * z * z)
+                stiffness[1, 2] -= sum(modulus_coeff * y * z)
+                stiffness[2, 2] += sum(modulus_coeff * y * y)
+
+        # Apply for simmetry
+        stiffness[1, 0] = stiffness[0, 1]
+        stiffness[2, 0] = stiffness[0, 2]
+        stiffness[2, 1] = stiffness[1, 2]
+
+        # Rotate back to section CRS
+        T = np.array([[cos(-angle), -sin(-angle)], [sin(-angle), cos(-angle)]])
+        T = T @ np.array([[100], [-100]])
+
+        T = np.array(
+            [
+                [1, 0, 0],
+                [0, cos(-angle), sin(-angle)],
+                [0, -sin(-angle), cos(-angle)],
+            ]
+        )
+
+        return T.T @ stiffness @ T
+
     def integrate_strain_response_on_geometry(
-        self, geo: CompoundGeometry, strain: ArrayLike, **kwargs
+        self,
+        geo: CompoundGeometry,
+        strain: ArrayLike,
+        integrate: t.Literal['stress', 'modulus'] = 'stress',
+        **kwargs,
     ):
-        """Integrate the strain response with the Marin algorithm.
+        """Integrate strees or material modulus in the section with the marin
+        algorithm.
+
+        Calculate the stress resultants or tangent section stiffness based on
+        strains in a set of points.
 
         Arguments:
             geo (CompoundGeometry): The geometry of the section.
             strain (ArrayLike): The strains and curvatures of the section,
                 given in the format (ea, ky, kz) which are i) strain at 0,0,
                 ii) curvature y axis, iii) curvature z axis.
+            integrate (str): a string indicating the quantity to integrate over
+                the section. It can be 'stress' or 'modulus'. When 'stress'
+                is selected, the return value will be the stress resultants N,
+                My, Mz, while if 'modulus' is selected, the return will be the
 
         Returns:
-            Tuple(Tuple(float, float, float), Dict): The stress resultants N,
-            Mx and My and the triangulation data.
+            Tuple(Union(Tuple(float, float, float), np.ndarray), None): The
+            first element is either a tuple of floats (for the stress
+            resultants (N, My, Mz) when `integrate='stress'`, or a numpy
+            array representing the stiffness matrix then `integrate='modulus'`.
+
+        Example:
+            result, _ = integrate_strain_response_on_geometry(geo, strain,
+            integrate='tanent')
+            # `result` will be the stiffness matrix (a 3x3 numpy array) if
+            # `integrate='modulus'`
+
+        Raises:
+            ValueError: If a unkown value is passed to the `integrate`
+            parameter.
         """
         del kwargs
         # Prepare the general input based on the geometry and the input strains
-        angle, prepared_input = self.prepare_input(geo, strain)
+        angle, prepared_input = self.prepare_input(geo, strain, integrate)
 
         # Return the calculated response
-        return *self.integrate(angle, prepared_input), None
+        if integrate == 'stress':
+            return *self.integrate_stress(angle, prepared_input), None
+        if integrate == 'modulus':
+            return self.integrate_modulus(angle, prepared_input), None
+        raise ValueError(f'Unknown integrate type: {integrate}')

structuralcodes/sections/section_integrators/_section_integrator.py

@@ -13,18 +13,22 @@ class SectionIntegrator(abc.ABC):
     """Abstract base class for section integrators."""
 
     @abc.abstractmethod
-    def prepare_input(self, geo: CompoundGeometry, strain: ArrayLike):
-        """Prepare general input to the integration method.
+    def prepare_input(
+        self, geo: CompoundGeometry, strain: ArrayLike, integrate: str
+    ):
+        """Prepare general input to the stress integration method.
 
         Args:
             geo (CompoundGeometry): The geometry to integrate over.
             strain (ArrayLike): The scalar strain components necessary for
                 describing the assumed strain distribution over the geometry.
+            integrate (str): The integrand, i.e., the quantity to be integrated
+                over the section.
         """
         raise NotImplementedError
 
     @abc.abstractmethod
-    def integrate(self, *prepared_input, **kwargs):
+    def integrate_stress(self, *prepared_input, **kwargs):
         """Integrate stresses over the geometry.
 
         The input to this method is generated by the prepare_input method. It
@@ -39,9 +43,29 @@ class SectionIntegrator(abc.ABC):
         """
         raise NotImplementedError
 
+    @abc.abstractmethod
+    def integrate_modulus(self, *prepared_input, **kwargs):
+        """Integrate material modulus over the geometry.
+
+        The input to this method is generated by the prepare_input method. It
+        also takes kwargs depending on the concrete implementation.
+
+        Arguments:
+            *prepared_input: The input prepared by the prepare_input method.
+
+        Keyword Arguments:
+            **kwargs: Keyword arguments depending on the concrete
+                implementation.
+        """
+        raise NotImplementedError
+
     @abc.abstractmethod
     def integrate_strain_response_on_geometry(
-        self, geo: CompoundGeometry, strain: ArrayLike, **kwargs
+        self,
+        geo: CompoundGeometry,
+        strain: ArrayLike,
+        integrate: str,
+        **kwargs,
     ):
         """Integrate stresses over the geometry to obtain the response due to
         strains.

{structuralcodes-0.2.0.dist-info → structuralcodes-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: structuralcodes
-Version: 0.2.0
+Version: 0.3.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

{structuralcodes-0.2.0.dist-info → structuralcodes-0.3.1.dist-info}/RECORD

@@ -1,7 +1,7 @@
-structuralcodes/__init__.py,sha256=pxmTgFCzRRSx9OPXM_I5KbP045gFiNqoR_v6N1Ni7as,390
+structuralcodes/__init__.py,sha256=KmmtACP7x6UA9QFVuSMxm22R39LlSE8AbhjRvA5Xirc,390
 structuralcodes/codes/__init__.py,sha256=g5xMAJ3jEZHFd0cypvZY6lMCi7XeVEntsO8zHzI2mWc,2803
 structuralcodes/codes/ec2_2004/__init__.py,sha256=DljXFNrCGE1lZIOsgyZgJ7Xo-xUidJomDrDKyfOHcH8,2431
-structuralcodes/codes/ec2_2004/_concrete_creep_and_shrinkage.py,sha256=y4HhOpaXwNMCHh4wu4LSn14oD1ylpPNvVJOJXLxStzQ,15284
+structuralcodes/codes/ec2_2004/_concrete_creep_and_shrinkage.py,sha256=Vbxxc3g0WZz2qFWDlfrVvC-uxMO2YJpfclnHxRPMuYQ,15301
 structuralcodes/codes/ec2_2004/_concrete_material_properties.py,sha256=Ol51tzcVOHUvc2Vea24WQJ4FABxXc-9cB5RVu2N1pio,5964
 structuralcodes/codes/ec2_2004/_reinforcement_material_properties.py,sha256=_ZlvdHcOswu1Ge1XjSvt4j5ue-znDceMOlA0s528IqM,2779
 structuralcodes/codes/ec2_2004/_section_7_3_crack_control.py,sha256=a91tWQKNTxB2SpSKu0Wtm-P5GdmifRLggNlEHIQ3XMY,31981
@@ -11,7 +11,7 @@ structuralcodes/codes/ec2_2023/_annexB_time_dependent.py,sha256=ykRAHBHzqtMSErkV
 structuralcodes/codes/ec2_2023/_section5_materials.py,sha256=-vYowBVcebyPyuGvX3wLfxiePdM0OrBgRrYil71Vd88,32384
 structuralcodes/codes/ec2_2023/_section9_sls.py,sha256=l1d3xcALAweU9jAAf1d91TJaGB_0p-eMzbRGuhfKydQ,11252
 structuralcodes/codes/mc2010/__init__.py,sha256=g2J2GTIy9jbLTVq_yF4DXau4WLmAkpmMTgnD4QmW2vI,2844
-structuralcodes/codes/mc2010/_concrete_creep_and_shrinkage.py,sha256=wFTVHfJKIyt0jUGthd1gWKfr4JfoFo9YN6d3nL6Ouq4,23277
+structuralcodes/codes/mc2010/_concrete_creep_and_shrinkage.py,sha256=lQAj8n0TVhRvttVFF9YLVNzCRo3O3wIqWvBdZRu9vDk,24295
 structuralcodes/codes/mc2010/_concrete_interface_different_casting_times.py,sha256=x_n9Z9WEPY6DFf8Og5UIERPivNh-O_3RM4ZnGBy64cs,3570
 structuralcodes/codes/mc2010/_concrete_material_properties.py,sha256=MTz70-9iaN_s0Z8gJksCEzP0Yza4pPfZ-vOI30pzbw4,12362
 structuralcodes/codes/mc2010/_concrete_punching.py,sha256=ZG2P7WXIRcFh5sGlmHP20BsJbz0o44cFO51FCru2kXw,17431
@@ -20,11 +20,13 @@ structuralcodes/codes/mc2010/_concrete_torsion.py,sha256=QBFnCYTOnP6FjN0MgX9iBrX
 structuralcodes/codes/mc2010/_reinforcement_material_properties.py,sha256=FELmgMcCrHlajGwQNRRHb8nqKnMCsLso1OyjonsTAdk,2842
 structuralcodes/codes/mc2020/__init__.py,sha256=5hrAfBtAeG69N_lroFpG10_ZKB1SuNlKBnuHug2DI3E,174
 structuralcodes/core/__init__.py,sha256=spnvZIm_w3jX_lV-v3bloDjgHh8lrH6UHpA1Nv1zeAI,55
-structuralcodes/core/_section_results.py,sha256=hHXoS71TpSmWqw276pBeLiLrEEiMEWclOd28ArRW_Kk,8280
-structuralcodes/core/base.py,sha256=7cpDM2hvBZp9nyU714XRiMzDPNdydJqLtIHHvcXZctE,8935
-structuralcodes/geometry/__init__.py,sha256=FwzywfyGKOk6v96ZyOfyBo5iVeuK_W0TQVz5llAkYW4,559
-structuralcodes/geometry/_geometry.py,sha256=8usT5UfDlT-A8sMwM6Bh4YKIB9QuyAU5tGgsujeACEA,31240
-structuralcodes/geometry/_reinforcement.py,sha256=N2wTH-NoZ1fG-_vRT9gGX2Kk3zlW7CbDtl1oqS_lMv0,4144
+structuralcodes/core/_section_results.py,sha256=MzUGThcxmZvyp0UBwxEiUAx2qz49UTlIo7MqoPEy3xk,7968
+structuralcodes/core/base.py,sha256=l8CgvUyz034F5HRyx6fBpiZvVRnD3cBDqJOTeuEV2hY,9505
+structuralcodes/geometry/__init__.py,sha256=STc2chf49NkWlnpcfB8n4mYWmR633VsKtbfyG8ylQ7s,771
+structuralcodes/geometry/_circular.py,sha256=vYk5mBY0bh_qqX_RrXn_NTE2iwPBvC-Uku3_AJEIZgQ,3557
+structuralcodes/geometry/_geometry.py,sha256=HE2pJaUdjgeFWp7WNA9Rm1Bt7QI6_Bjn-ePt6aO7AcY,31544
+structuralcodes/geometry/_rectangular.py,sha256=PLKgz998qDjcn76JjVW08fexN0jAke0K6yNeaOynqOQ,3458
+structuralcodes/geometry/_reinforcement.py,sha256=2l4I2tm5YEy9Oeqlzt1GulljSW0k5_4_iG6quvhlSRk,9097
 structuralcodes/geometry/_steel_sections.py,sha256=UdJmhhnK8r5gEfBzvWsMFHGs5gmuoOhFoduBanlRMQg,60225
 structuralcodes/materials/__init__.py,sha256=r5E5vsXVKB-BGZXTnEbsrYJbH6rr6Xlc_b4LlcUPIbc,173
 structuralcodes/materials/concrete/__init__.py,sha256=GRD5WcbYrnE4iN-L7qVkhVTi7w_PUP7pnbGueOaVeFs,2576
@@ -33,26 +35,27 @@ structuralcodes/materials/concrete/_concreteEC2_2004.py,sha256=gWG3O9yeGw3UeftCj
 structuralcodes/materials/concrete/_concreteEC2_2023.py,sha256=vguNzlfoPuaieTVw9T3xWU0wb230WvER4Vy1jswcdlo,14017
 structuralcodes/materials/concrete/_concreteMC2010.py,sha256=lHy-WYiVpXPwiNAyjUBxuGWuGFd0-Uirh6KiolMH4MY,15313
 structuralcodes/materials/constitutive_laws/__init__.py,sha256=r817qyeimqZyyan2mU8cVwjwMkiB--f-BOIBSzXKiZo,2954
-structuralcodes/materials/constitutive_laws/_bilinearcompression.py,sha256=mkuMSiKpfZv-meIvHedrlILfRBdOsR46QCiaiyxPxVs,4528
-structuralcodes/materials/constitutive_laws/_elastic.py,sha256=Kl-A_3W2qoJUEPE3meWABSqUlNChMExiq2LdRehbqrI,3722
-structuralcodes/materials/constitutive_laws/_elasticplastic.py,sha256=GDIIXJ93nqV-G8-o6HxXGUTd3TgNWiHQqXbULFcCGUI,6096
-structuralcodes/materials/constitutive_laws/_parabolarectangle.py,sha256=CvjmiGCmNTqxY6d5jNqCo6MAh_BUkypvv_-ZJB9JyQE,6489
+structuralcodes/materials/constitutive_laws/_bilinearcompression.py,sha256=wap9cPSj4baeAZ4dqSfajWb5wdidkpkcT2pgb2QHrBk,6083
+structuralcodes/materials/constitutive_laws/_elastic.py,sha256=xxSneoCW41AQy0vj3_x-sTuvE_SsS1kutaG_NbqAWbk,4306
+structuralcodes/materials/constitutive_laws/_elasticplastic.py,sha256=VXA4wgkfL8NdGnZa7AQX_TL-JCpEBjMVumIwQhhloFY,8118
+structuralcodes/materials/constitutive_laws/_parabolarectangle.py,sha256=9GeY0HuFE5l9L61OoKi-M5MgQemJpcKccysN0SQ0oXM,8609
 structuralcodes/materials/constitutive_laws/_popovics.py,sha256=dpXFQ9KHE245C9dgOLz9KXYHZiAYrRan5exgj0j_JxM,4322
 structuralcodes/materials/constitutive_laws/_sargin.py,sha256=WJGw0EtqkPh-d3N6vTPRIfhE1Ypyc16JpGcoi-0U1A8,3495
-structuralcodes/materials/constitutive_laws/_userdefined.py,sha256=urt0yuJicO51jnQ2S8bfmrgVTyYh09Olnzy9_tISGK4,8292
+structuralcodes/materials/constitutive_laws/_userdefined.py,sha256=vr01SyZTQvDimJLJN3-shvhIevvt9_qRtiy8OjodKQQ,9925
 structuralcodes/materials/reinforcement/__init__.py,sha256=-UA04GSNN6_xLKqnH_5taiOmgxYwD_wtT6Nw8UbfkJY,2757
 structuralcodes/materials/reinforcement/_reinforcement.py,sha256=zrSdBvHKTYqOHpkJzxit8w_b2JG2pggviOvgZyH246Q,5029
 structuralcodes/materials/reinforcement/_reinforcementEC2_2004.py,sha256=svLpubjaTH_DepwY68TQIA8fRwadoAE3Y3KsyViGQHk,3265
 structuralcodes/materials/reinforcement/_reinforcementEC2_2023.py,sha256=3tKpFcMNYK52s5K2K_PctRcuSgwZTe-QXX3xziHPUno,2887
 structuralcodes/materials/reinforcement/_reinforcementMC2010.py,sha256=az_IAQJNKSF6Vv9KMoXjWTdYkWI6xcEm7s8i8GETn3A,2939
-structuralcodes/sections/__init__.py,sha256=qPoD5eS31at-uveYtxtVkXGLNHPrIMRrxGYY3wOLQ4s,441
-structuralcodes/sections/_generic.py,sha256=I_YQNeK9ww3wDtkSBlhF7u6gXVAj2I5Sttv9i-uk8UI,50525
+structuralcodes/sections/__init__.py,sha256=gUGqiv8zyhiMmxEFme8E9nC2b3aJKs3ieBYz6X2GVFY,545
+structuralcodes/sections/_generic.py,sha256=ZsqOOTQJwj1VtXbpcxao1y21qK16QGq7xZ0jOwBsRcU,55744
+structuralcodes/sections/_rc_utils.py,sha256=KZGVyQNSsbol7Dcyx7StoN1ybzrXMeKlyIFdXAauJW0,4229
 structuralcodes/sections/section_integrators/__init__.py,sha256=PK4ixV0XrfHXN-itIrB1r90npoWo3aIJqMcenqcaees,399
 structuralcodes/sections/section_integrators/_factory.py,sha256=MHp14hfWU-oXTiIutCKLJEC47LirYsHgEAAmHVtnFMY,1242
-structuralcodes/sections/section_integrators/_fiber_integrator.py,sha256=Ucas8nA9BB4ILfFPplJp3WkgLc9ntf9UN7AmcUwqA_A,9263
+structuralcodes/sections/section_integrators/_fiber_integrator.py,sha256=7On87ESqRDorV4YdaOTq9h55XaJFC5h6mMN4ys6DYos,12873
 structuralcodes/sections/section_integrators/_marin_integration.py,sha256=SZgya6d_Tequ3jez7UEBlYioZepW2IDKaAxn_6WrMbU,1563
-structuralcodes/sections/section_integrators/_marin_integrator.py,sha256=DHAJwurHhVp68K9fozw0MbmxZvk_NAKnNVi5abp65sY,9118
-structuralcodes/sections/section_integrators/_section_integrator.py,sha256=O-jsG1Pu_doovgRJsFG1Sf0KlkN2wNfQdmgkJiSHNN0,1590
-structuralcodes-0.2.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-structuralcodes-0.2.0.dist-info/METADATA,sha256=7RAyKNKlQYjXC3sFiVRWTwp3HUMAhN5SvJAvcF2LTZ0,2444
-structuralcodes-0.2.0.dist-info/RECORD,,
+structuralcodes/sections/section_integrators/_marin_integrator.py,sha256=wdgscIWTIRfkPPafI77Lk4-FmtQLDNw2kanMkhNkfTc,15392
+structuralcodes/sections/section_integrators/_section_integrator.py,sha256=aPYuUpqeQLYauVi3_uJoEtXPSuXn79Aau3GTlISn-sI,2355
+structuralcodes-0.3.1.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+structuralcodes-0.3.1.dist-info/METADATA,sha256=G539Pjz7ht10TNndNfxWOJUh0_YZg1Rbpc3_d2o8k18,2444
+structuralcodes-0.3.1.dist-info/RECORD,,

{structuralcodes-0.2.0.dist-info → structuralcodes-0.3.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: flit 3.9.0
+Generator: flit 3.10.1
 Root-Is-Purelib: true
 Tag: py3-none-any