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

structuralcodes/sections/_generic.py

@@ -7,7 +7,8 @@ import typing as t
 import warnings
 
 import numpy as np
-from numpy.typing import ArrayLike
+from numpy.typing import ArrayLike, NDArray
+from scipy.linalg import lu_factor, lu_solve
 from shapely import MultiPolygon
 from shapely.ops import unary_union
 
@@ -20,7 +21,7 @@ from structuralcodes.geometry import (
 )
 from structuralcodes.materials.constitutive_laws import Elastic
 
-from .section_integrators import integrator_factory
+from .section_integrators import SectionIntegrator, integrator_factory
 
 
 class GenericSection(Section):
@@ -82,7 +83,7 @@ class GenericSection(Section):
         self._gross_properties = None
 
     @property
-    def gross_properties(self) -> s_res.GrossProperties:
+    def gross_properties(self) -> s_res.SectionProperties:
         """Return the gross properties of the section."""
         if self._gross_properties is None:
             self._gross_properties = (
@@ -94,6 +95,8 @@ class GenericSection(Section):
 class GenericSectionCalculator(SectionCalculator):
     """Calculator class implementing analysis algorithms for code checks."""
 
+    integrator: SectionIntegrator
+
     def __init__(
         self,
         sec: GenericSection,
@@ -123,17 +126,17 @@ class GenericSectionCalculator(SectionCalculator):
         self._n_max = None
         self._n_min = None
 
-    def _calculate_gross_section_properties(self) -> s_res.GrossProperties:
+    def _calculate_gross_section_properties(self) -> s_res.SectionProperties:
         """Calculates the gross section properties of the GenericSection.
 
         This function is private and called when the section is created.
         It stores the result into the result object.
 
         Returns:
-            GrossProperties: The gross properties of the section.
+            SectionProperties: The gross properties of the section.
         """
         # It will use the algorithms for generic sections
-        gp = s_res.GrossProperties()
+        gp = s_res.SectionProperties()
 
         # Computation of perimeter using shapely
         polygon = unary_union(
@@ -335,7 +338,7 @@ class GenericSectionCalculator(SectionCalculator):
 
     def find_equilibrium_fixed_pivot(
         self, geom: CompoundGeometry, n: float, yielding: bool = False
-    ) -> t.Tuple[float, float, float]:
+    ) -> t.List[float]:
         """Find the equilibrium changing curvature fixed a pivot.
         The algorithm uses bisection algorithm between curvature
         of balanced failure and 0. Selected the pivot point as
@@ -349,8 +352,8 @@ class GenericSectionCalculator(SectionCalculator):
             yielding (bool): ...
 
         Returns:
-            Tuple(float, float, float): 3 floats: Axial strain at (0,0), and
-            curvatures of y* and z* axes. Note that being uniaxial bending,
+            List(float): 3 floats: Axial strain at (0,0), and curvatures of y*
+            and z* axes. Note that being uniaxial bending,
             curvature along z* is 0.0.
         """
         # Number of maximum iteration for the bisection algorithm
@@ -369,6 +372,10 @@ class GenericSectionCalculator(SectionCalculator):
         ) = self.integrator.integrate_strain_response_on_geometry(
             geom, strain, tri=self.triangulated_data, mesh_size=self.mesh_size
         )
+        # save the triangulation data
+        if self.triangulated_data is None and tri is not None:
+            self.triangulated_data = tri
+
         # Check if there is equilibrium with this strain distribution
         chi_a = strain[1]
         dn_a = n_int - n
@@ -414,9 +421,6 @@ class GenericSectionCalculator(SectionCalculator):
             s = f'Last iteration reached a unbalance of {dn_c}'
             raise ValueError(f'Maximum number of iterations reached.\n{s}')
         # Found equilibrium
-        # save the triangulation data
-        if self.triangulated_data is None:
-            self.triangulated_data = tri
         # Return the strain distribution
         return [eps_0, chi_c, 0]
 
@@ -496,7 +500,7 @@ class GenericSectionCalculator(SectionCalculator):
         ) = self.integrator.integrate_strain_response_on_geometry(
             geom, [eps_0, curv, 0], tri=self.triangulated_data
         )
-        if self.triangulated_data is None:
+        if self.triangulated_data is None and tri is not None:
             self.triangulated_data = tri
         dn_a = n_int - n
         # It may occur that dn_a is already almost zero (in eqiulibrium)
@@ -557,7 +561,7 @@ class GenericSectionCalculator(SectionCalculator):
             self.section.geometry, [eps_p, 0, 0], tri=tri
         )
 
-        if self.triangulated_data is None:
+        if self.triangulated_data is None and tri is not None:
             self.triangulated_data = tri
         return n_min, n_max
 
@@ -604,25 +608,60 @@ class GenericSectionCalculator(SectionCalculator):
         self.triangulated_data = rotated_triangulated_data
 
     def integrate_strain_profile(
-        self, strain: ArrayLike
-    ) -> t.Tuple[float, float, float]:
-        """Integrate a strain profile returning internal forces.
+        self,
+        strain: ArrayLike,
+        integrate: t.Literal['stress', 'modulus'] = 'stress',
+    ) -> t.Union[t.Tuple[float, float, float], NDArray]:
+        """Integrate a strain profile returning stress resultants or tangent
+        section stiffness matrix.
 
         Arguments:
             strain (ArrayLike): Represents the deformation plane. The strain
                 should have three entries representing respectively: axial
                 strain (At 0,0 coordinates), curv_y, curv_z.
+            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
+                tangent section stiffness matrix (default is 'stress').
 
         Returns:
-            Tuple(float, float, float): N, My and Mz.
+            Union(Tuple(float, float, float),NDArray): N, My and Mz when
+            `integrate='stress'`, or a numpy array representing the stiffness
+            matrix then `integrate='modulus'`.
+
+        Examples:
+            result = self.integrate_strain_profile(strain,integrate='tangent')
+            # `result` will be the tangent stiffness matrix (a 3x3 numpy array)
+
+            result = self.integrate_strain_profile(strain)
+            # `result` will be a tuple containing section forces (N, My, Mz)
+
+        Raises:
+            ValueError: If a unkown value is passed to the `integrate`
+            parameter.
         """
-        N, My, Mz, _ = self.integrator.integrate_strain_response_on_geometry(
+        result = self.integrator.integrate_strain_response_on_geometry(
             geo=self.section.geometry,
             strain=strain,
+            integrate=integrate,
             tri=self.triangulated_data,
             mesh_size=self.mesh_size,
         )
-        return N, My, Mz
+
+        # Save triangulation data for future use
+        if self.triangulated_data is None and result[-1] is not None:
+            self.triangulated_data = result[-1]
+
+        # manage the returning from integrate_strain_response_on_geometry:
+        # this function returns one of the two:
+        # a. float, float, float, tri (i.e. N, My, Mz, tri)
+        # b. (NDArray, tri) (i.e. section stiff matrix, tri)
+        # We need to return only forces or stifness
+        # (without triangultion data)
+        if len(result) == 2:
+            return result[0]
+        return result[:-1]
 
     def calculate_bending_strength(
         self, theta=0, n=0
@@ -664,13 +703,15 @@ class GenericSectionCalculator(SectionCalculator):
         if self.triangulated_data is not None:
             # Rotate back also triangulated data!
             self._rotate_triangulated_data(theta)
+        # Rotate also curvature!
+        strain_rotated = T @ np.array([[strain[1]], [strain[2]]])
 
         # Create result object
         res = s_res.UltimateBendingMomentResults()
         res.theta = theta
         res.n = N
-        res.chi_y = strain[1]
-        res.chi_z = strain[2]
+        res.chi_y = strain_rotated[0, 0]
+        res.chi_z = strain_rotated[1, 0]
         res.eps_a = strain[0]
         res.m_y = M[0, 0]
         res.m_z = M[1, 0]
@@ -969,7 +1010,7 @@ class GenericSectionCalculator(SectionCalculator):
                     mesh_size=self.mesh_size,
                 )
             )
-            if self.triangulated_data is None:
+            if self.triangulated_data is None and tri is not None:
                 self.triangulated_data = tri
             forces[i, 0] = N
             forces[i, 1] = My
@@ -1239,7 +1280,7 @@ class GenericSectionCalculator(SectionCalculator):
                     tri=self.triangulated_data,
                 )
             )
-            if self.triangulated_data is None:
+            if self.triangulated_data is None and tri is not None:
                 self.triangulated_data = tri
             forces[i, 0] = N
             forces[i, 1] = My
@@ -1285,3 +1326,99 @@ class GenericSectionCalculator(SectionCalculator):
             res.strains[i, 2] = res_bend_strength.chi_z
 
         return res
+
+    def calculate_strain_profile(
+        self,
+        n,
+        my,
+        mz,
+        initial: bool = False,
+        max_iter: int = 10,
+        tol: float = 1e-6,
+    ) -> t.List[float]:
+        """Get the strain plane for a given axial force and biaxial bending.
+
+        Args:
+            n (float): Axial load.
+            my (float): Bending moment around y-axis.
+            mz (float): Bending moment around z-axis.
+            initial (bool): If True the modified newton with initial tanget is
+                used (default = False).
+            max_iter (int): the maximum number of iterations in the iterative
+                process (default = 10).
+            tol (float): the tolerance for convergence test in terms of strain
+                increment.
+
+        Returns:
+            List(float): 3 floats: Axial strain at (0,0), and curvatures of the
+            section around y and z axes.
+        """
+        # Get the gometry
+        geom = self.section.geometry
+
+        # Collect loads in a numpy array
+        loads = np.array([n, my, mz])
+
+        # Compute initial tangent stiffness matrix
+        stiffness_tangent, tri = (
+            self.integrator.integrate_strain_response_on_geometry(
+                geom,
+                [0, 0, 0],
+                integrate='modulus',
+                tri=self.triangulated_data,
+            )
+        )
+        # eventually save the triangulation data
+        if self.triangulated_data is None and tri is not None:
+            self.triangulated_data = tri
+
+        # Calculate strain plane with Newton Rhapson Iterative method
+        num_iter = 0
+        strain = np.zeros(3)
+
+        # Factorize once the stiffness matrix if using initial
+        if initial:
+            # LU factorization
+            # (maybe also Choelesky could work if matrix always SPD?)
+            lu, piv = lu_factor(stiffness_tangent)
+
+        # Do Newton loops
+        while True:
+            # Check if number of iterations exceeds the maximum
+            if num_iter > max_iter:
+                break
+
+            # Calculate response and residuals
+            response = np.array(self.integrate_strain_profile(strain=strain))
+            residual = loads - response
+
+            if initial:
+                # Solve using the decomposed matrix
+                delta_strain = lu_solve((lu, piv), residual)
+            else:
+                # Calculate the current tangent stiffness
+                stiffness_tangent, _ = (
+                    self.integrator.integrate_strain_response_on_geometry(
+                        geom,
+                        strain,
+                        integrate='modulus',
+                        tri=self.triangulated_data,
+                    )
+                )
+
+                # Solve using the current tangent stiffness
+                delta_strain = np.linalg.solve(stiffness_tangent, residual)
+
+            # Update the strain
+            strain += delta_strain
+
+            num_iter += 1
+
+            # Check for convergence:
+            if np.linalg.norm(delta_strain) < tol:
+                break
+
+        if num_iter >= max_iter:
+            raise StopIteration('Maximum number of iterations reached.')
+
+        return strain.tolist()

structuralcodes/sections/_rc_utils.py

@@ -0,0 +1,114 @@
+"""A collection of functions related to reinforced concrete sections."""
+
+import typing as t
+
+import structuralcodes.core._section_results as s_res
+from structuralcodes.geometry import CompoundGeometry, SurfaceGeometry
+from structuralcodes.materials.constitutive_laws import Elastic, UserDefined
+from structuralcodes.sections import GenericSection
+from structuralcodes.sections.section_integrators import FiberIntegrator
+
+
+def calculate_elastic_cracked_properties(
+    section: GenericSection,
+    theta: float = 0,
+    return_cracked_section: bool = False,
+) -> t.Union[
+    s_res.SectionProperties, t.Tuple[s_res.SectionProperties, CompoundGeometry]
+]:
+    """Calculates the cracked section properties of a reinforced concrete
+    section. (GenericSection). Materials in surface geometries and point
+    geometries are elastic-linear in order to make the cracking properties
+    independent of the stress state. Tension in all surface geometries is
+    neglected.
+
+    Args:
+        section (GenericSection): The section to use as basis for the
+            calculation.
+        theta (float): Angle of the neutral axis to the horizontal in radians.
+            theta=0 implies upper compression block.
+        return_cracked_section (bool): If true, returns also the cracked
+            section.
+
+    Returns:
+        t.Union[SectionProperties, t.Tuple[SectionProperties, GenericSection]]:
+        SectionProperties data of a cracked section (i.e cracked section
+        properties) and (if return_cracked_section is True) the cracked
+        section.
+    """
+
+    def create_surface_geometries(polygons_list, material):
+        """Process shapely polygons to SurfaceGeometries."""
+        # Create an empty list to store SurfaceGeometry objects
+        surface_geometries = []
+
+        # Iterate over the list of polygons and create SurfaceGeometry for each
+        for polygon in polygons_list:
+            # Create a new SurfaceGeometry for the current polygon
+            surface_geometry = SurfaceGeometry(polygon, material)
+            # Add the new SurfaceGeometry to the list
+            surface_geometries.append(surface_geometry)
+
+        return CompoundGeometry(surface_geometries)
+
+    if not section.geometry.reinforced_concrete:
+        return None
+
+    rotated_geometry = section.geometry.rotate(-theta)
+
+    for geo in rotated_geometry.geometries:
+        Ec = geo.material.get_tangent(eps=0)
+        elastic_concrete = UserDefined([-100, 0], [-100 * Ec, 0])
+        geo._material = elastic_concrete
+
+    for pg in rotated_geometry.point_geometries:
+        Es = pg.material.get_tangent(eps=0)
+        elastic_steel = Elastic(Es, 'elastic steel')
+        pg._material = elastic_steel
+
+    curv = -1e-5  # Any curvature should return the same mechanical properties.
+    # Find the equilibrium with fixed curvature
+    eps = section.section_calculator.find_equilibrium_fixed_curvature(
+        rotated_geometry, 0, curv, 0
+    )[0]
+    z_na = -eps / curv  # distance to neutral fibre
+
+    # Cutting concrete geometries and retaining the compressed block
+    cut_geom = None
+    for part in rotated_geometry.geometries:
+        upper_div, lower_div = part.split(((0, z_na), 0))
+        # Convert to SurfaceGeometry
+        subpart = create_surface_geometries(upper_div, part.material)
+        if cut_geom is None:
+            cut_geom = subpart
+        else:
+            cut_geom += subpart
+
+    # Add reinforcement geometries
+    for reinf in rotated_geometry.point_geometries:
+        cut_geom += reinf
+
+    # return geoemtry to original rotation
+    cracked_geom = cut_geom.rotate(theta)
+
+    # Define the cracked section
+    if isinstance(section.section_calculator.integrator, FiberIntegrator):
+        mesh_size = getattr(
+            section.section_calculator.integrator, 'mesh_size', 0.01
+        )
+        cracked_sec = GenericSection(
+            cracked_geom,
+            integrator='fiber',
+            mesh_size=mesh_size,
+        )
+    else:
+        cracked_sec = GenericSection(cracked_geom, integrator='marin')
+
+    cracked_prop = cracked_sec.gross_properties
+
+    if return_cracked_section:
+        result = (cracked_prop, cracked_geom)
+    else:
+        result = cracked_prop
+
+    return result