structuralcodes 0.0.1__py3-none-any.whl

structuralcodes/sections/_reinforcement.py

@@ -0,0 +1,115 @@
+"""Functions related to reinforcement definition."""
+
+import typing as t
+
+import numpy as np
+from shapely import Point
+
+from structuralcodes.core.base import ConstitutiveLaw, Material
+from structuralcodes.geometry import (
+    CompoundGeometry,
+    PointGeometry,
+    SurfaceGeometry,
+)
+
+
+def add_reinforcement(
+    geo: t.Union[SurfaceGeometry, CompoundGeometry],
+    coords: t.Tuple[float, float],
+    diameter: float,
+    material: t.Union[Material, ConstitutiveLaw],
+) -> CompoundGeometry:
+    """Add a single bar given coordinate.
+
+    Arguments:
+        geo (Union(SurfaceGeometry, CompoundGeometry)): A geometry to which add
+            reinforcement.
+        coords (Tuple(float, float)): A tuple with cordinates of bar.
+        diameter (float): The diameter of the reinforcement.
+        material (Union(Material, ConstitutiveLaw)): A material or a
+            constitutive law for the behavior of the reinforcement.
+
+    Returns:
+        CompoundGeometry: A compound geometry with the original geometry and
+        the reinforcement.
+    """
+    bar = PointGeometry(Point(coords), diameter, material)
+    return geo + bar
+
+
+def add_reinforcement_line(
+    geo: t.Union[SurfaceGeometry, CompoundGeometry],
+    coords_i: t.Tuple[float, float],
+    coords_j: t.Tuple[float, float],
+    diameter: float,
+    material: t.Union[Material, ConstitutiveLaw],
+    n: int = 0,
+    s: float = 0.0,
+    first: bool = True,
+    last: bool = True,
+) -> CompoundGeometry:
+    """Adds a set of bars distributed in a line.
+
+    Arguments:
+        geo (Union(SurfaceGeometry, CompoundGeometry)): The geometry used as
+            input.
+        coords_i (Tuple(float, float)): Coordinates of the initial point of
+            line.
+        coords_j (Tuple(float, float)): Coordinates of the final point of line.
+        diamter (float): The diameter of the bars.
+        material (Union(Material, ConstitutiveLaw)): A valid material or
+            constitutive law.
+        n (int): The number of bars to be distributed inside the line (default
+            = 0).
+        s (float): The distance between the bars (default = 0).
+        first (bool): Boolean indicating if placing the first bar (default =
+            True).
+        last (bool): Boolean indicating if placing the last bar (default =
+            True).
+
+    Note:
+        At least n or s should be greater than zero.
+
+    Returns:
+        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)
+    v = (p2 - p1) / distance
+    if n > 0 and s > 0:
+        # Provided both the number of bars and spacing
+        # 1. Check the is enough space for fitting the bars
+        d = (n - 1) * s
+        if d > distance:
+            raise ValueError(
+                f'There is not room to fit {n} bars with a spacing of {s} \
+                in {distance}'
+            )
+        p1 = p1 + v * (distance - d) / 2.0
+    elif n > 0:
+        # Provided the number of bars
+        s = distance / (n - 1)
+    elif s > 0:
+        # Provided the spacing
+        # 1. Compute the number of bars
+        n = floor(distance / s) + 1
+        # 2. Distribute the bars centered in the segment
+        d = (n - 1) * s
+        p1 = p1 + v * (distance - d) / 2.0
+    else:
+        raise ValueError('At least n or s should be provided')
+    # add the bars
+    for i in range(n):
+        if i == 0 and not first:
+            continue
+        if i == n - 1 and not last:
+            continue
+        coords = p1 + v * s * i
+        geo = add_reinforcement(
+            geo, (coords[0], coords[1]), diameter, material
+        )
+    return geo

structuralcodes/sections/section_integrators/__init__.py

@@ -0,0 +1,14 @@
+"""Classes for integrating the response of sections."""
+
+from ._factory import integrator_factory
+from ._fiber_integrator import FiberIntegrator
+from ._marin_integrator import MarinIntegrator, marin_integration
+from ._section_integrator import SectionIntegrator
+
+__all__ = [
+    'integrator_factory',
+    'FiberIntegrator',
+    'MarinIntegrator',
+    'SectionIntegrator',
+    'marin_integration',
+]

structuralcodes/sections/section_integrators/_factory.py

@@ -0,0 +1,41 @@
+"""Factory for integrators."""
+
+import typing as t
+
+from ._fiber_integrator import FiberIntegrator
+from ._marin_integrator import MarinIntegrator
+from ._section_integrator import SectionIntegrator
+
+integrator_registry = {'marin': MarinIntegrator, 'fiber': FiberIntegrator}
+
+
+class IntegratorFactory:
+    """A factory for integrators."""
+
+    instances: t.Dict  # A dict of integrators that have been created.
+    registry: t.Dict[str, SectionIntegrator]
+
+    def __init__(self, registry: t.Dict[str, SectionIntegrator]):
+        self.instances = {}
+        self.registry = registry
+
+    def __call__(
+        self, method: t.Literal['marin', 'fiber']
+    ) -> SectionIntegrator:
+        """Create an integrator based on its name.
+
+        Arguments:
+            method (str): The name of the integrator to use.
+
+        Returns:
+            SectionIntegrator: The section integrator.
+        """
+        self.instances.setdefault(
+            method.lower(), self.registry.get(method.lower(), MarinIntegrator)
+        )
+        # Here we should throw a warning if the user input an integrator not
+        # given in the registry.
+        return self.instances.get(method.lower())
+
+
+integrator_factory = IntegratorFactory(integrator_registry)

structuralcodes/sections/section_integrators/_fiber_integrator.py

@@ -0,0 +1,238 @@
+"""The fiber section integrator."""
+
+from __future__ import annotations  # To have clean hints of ArrayLike in docs
+
+import typing as t
+
+import numpy as np
+import triangle
+from numpy.typing import ArrayLike
+from shapely import Polygon
+
+from structuralcodes.geometry import CompoundGeometry, SurfaceGeometry
+
+from ._section_integrator import SectionIntegrator
+
+
+class FiberIntegrator(SectionIntegrator):
+    """Section integrator based on the Marin algorithm."""
+
+    def prepare_triangulation(self, geo: SurfaceGeometry) -> t.Dict:
+        """Triangulate a SurfaceGeometry object.
+
+        Arguments:
+            geo (SurfaceGeometry): The geometry to triangulate.
+
+        Returns:
+            Dict: The triangulation data.
+        """
+        # Create the tri dictionary
+        tri: dict[str:ArrayLike] = {}
+        # 1. External boundary process
+        # 1a. Get vertices, skipping the last one
+        vertices = np.column_stack(geo.polygon.exterior.xy)[:-1, :]
+        n_vertices = vertices.shape[0]
+        # 1b. Create segments
+        node_i = np.arange(n_vertices)
+        node_j = np.roll(node_i, -1)
+        segments = np.column_stack((node_i, node_j))
+
+        # 2. Process holes
+        holes = []
+        for interior in geo.polygon.interiors:
+            # 2a. Get vertices, skipping the last one
+            vertices_int = np.column_stack(interior.xy)[:-1, :]
+            n_vertices_int = vertices_int.shape[0]
+            # 2b. Create segments
+            node_i = np.arange(n_vertices_int) + n_vertices
+            node_j = np.roll(node_i, -1)
+            segments_int = np.column_stack((node_i, node_j))
+            c = Polygon(interior)
+            holes.append([c.centroid.x, c.centroid.y])
+            # Append to the global arrays
+            vertices = np.vstack((vertices, vertices_int))
+            segments = np.vstack((segments, segments_int))
+            n_vertices += n_vertices_int
+        # Return the dictionary with data for triangulate
+        tri['vertices'] = vertices
+        tri['segments'] = segments
+        if len(holes) > 0:
+            tri['holes'] = holes
+        return tri
+
+    def prepare_input(
+        self, geo: CompoundGeometry, strain: ArrayLike, **kwargs
+    ) -> t.Tuple[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(List, Dict): The prepared input representing a list with
+            x-coordinates, y-coordinates and force for each fiber and a
+            dictionary containing the triangulation data that can be stored and
+            used later to avoid repetition of triangulation.
+        """
+        # This method should:
+        #  - discretize the section in a number of fibers (mesh_size)
+        #  - prepare input as y coordiates z coordinates forces
+
+        prepared_input = []
+
+        triangulated_data = kwargs.get('tri', None)
+        if triangulated_data is None:
+            # No triangulation is provided, triangulate the section
+            # Fiber integrator for generic section uses delaunay triangulation
+            # for discretizing in fibers
+            triangulated_data = []
+            mesh_size = kwargs.get('mesh_size', 0.01)
+            if mesh_size <= 0 or mesh_size > 1:
+                raise ValueError('mesh_size is a number from 0 to 1')
+            # For the surface geometries
+            for g in geo.geometries:
+                # prepare data structure for triangle module
+                tri = self.prepare_triangulation(g)
+                # define the maximum area of the triangles
+                max_area = g.area * mesh_size
+                # triangulate the geometry getting back the mesh
+                mesh = triangle.triangulate(
+                    tri, f'pq{30:.1f}Aa{max_area:.1f}o1'
+                )
+                mat = g.material
+                # Get x and y coordinates (centroid) and area for each fiber
+                x = []
+                y = []
+                area = []
+                for tr in mesh['triangles']:
+                    # get centroid of triangle
+                    xc = (
+                        mesh['vertices'][tr[0]][0]
+                        + mesh['vertices'][tr[1]][0]
+                        + mesh['vertices'][tr[2]][0]
+                    )
+                    xc /= 3.0
+                    x.append(xc)
+                    yc = (
+                        mesh['vertices'][tr[0]][1]
+                        + mesh['vertices'][tr[1]][1]
+                        + mesh['vertices'][tr[2]][1]
+                    )
+                    yc /= 3.0
+                    y.append(yc)
+                    # compute area
+                    a = (
+                        mesh['vertices'][tr[0]][0] * mesh['vertices'][tr[1]][1]
+                        - mesh['vertices'][tr[0]][1]
+                        * mesh['vertices'][tr[1]][0]
+                    )
+                    a += (
+                        mesh['vertices'][tr[1]][0] * mesh['vertices'][tr[2]][1]
+                        - mesh['vertices'][tr[1]][1]
+                        * mesh['vertices'][tr[2]][0]
+                    )
+                    a += (
+                        mesh['vertices'][tr[2]][0] * mesh['vertices'][tr[0]][1]
+                        - mesh['vertices'][tr[2]][1]
+                        * mesh['vertices'][tr[0]][0]
+                    )
+                    a = abs(a) * 0.5
+                    area.append(a)
+                    # pointer to the material
+
+                # return back the triangulation data
+                triangulated_data.append(
+                    (np.array(x), np.array(y), np.array(area), mat)
+                )
+            # For the reinforcement
+            # Tentative proposal for managing reinforcement (PointGeometry)
+            reinf_data = {}
+            # Preprocess geometries having the same material
+            for pg in geo.point_geometries:
+                x, y = pg._point.coords.xy
+                x = x[0]
+                y = y[0]
+                area = pg.area
+                mat = pg.material
+                if reinf_data.get(mat) is None:
+                    reinf_data[mat] = [
+                        np.array(x),
+                        np.array(y),
+                        np.array(area),
+                    ]
+                else:
+                    reinf_data[mat][0] = np.hstack((reinf_data[mat][0], x))
+                    reinf_data[mat][1] = np.hstack((reinf_data[mat][1], y))
+                    reinf_data[mat][2] = np.hstack((reinf_data[mat][2], area))
+            for mat, value in reinf_data.items():
+                triangulated_data.append((value[0], value[1], value[2], mat))
+
+        x = []
+        y = []
+        F = []
+        for tr in triangulated_data:
+            # All have the same material
+            strains = strain[0] - strain[2] * tr[0] + strain[1] * tr[1]
+            # compute stresses in all materials
+            stresses = tr[3].get_stress(strains)
+            x.append(tr[0])
+            y.append(tr[1])
+            F.append(stresses * tr[2])
+        prepared_input = [(np.hstack(x), np.hstack(y), np.hstack(F))]
+
+        return prepared_input, triangulated_data
+
+    def integrate(
+        self,
+        prepared_input: t.List[
+            t.Tuple[int, np.ndarray, np.ndarray, np.ndarray]
+        ],
+    ) -> t.Tuple[float, float, float]:
+        """Integrate stresses over the geometry.
+
+        Arguments:
+            prepared_input (List): The prepared input from .prepare_input().
+
+        Returns:
+            Tuple(float, float, float): The stress resultants N, Mx and My.
+        """
+        # Integration over all fibers
+        x, y, F = prepared_input[0]
+
+        N = np.sum(F)
+        Mx = np.sum(F * y)
+        My = np.sum(-F * x)
+
+        return N, Mx, My
+
+    def integrate_strain_response_on_geometry(
+        self, geo: CompoundGeometry, strain: ArrayLike, **kwargs
+    ):
+        """Integrate the strain response with the fiber algorithm.
+
+        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(Tuple(float, float, float), Dict): The stress resultants N,
+            Mx and My and the triangulation data.
+        """
+        # Prepare the general input based on the geometry and the input strains
+        prepared_input, triangulated_data = self.prepare_input(
+            geo, strain, **kwargs
+        )
+
+        # Return the calculated response
+        return *self.integrate(prepared_input), triangulated_data

structuralcodes/sections/section_integrators/_marin_integration.py

@@ -0,0 +1,47 @@
+"""Integration of area moments using algorithms by Joaquin Marin.
+
+Marin, J.: Computing columns, footings and gates through moments of area.
+Computers and Structures, 18(2), pp. 343-349, 1984.
+"""
+
+import functools
+import math
+import typing as t
+
+
+@functools.lru_cache
+def _coeff(m, n, j, k):
+    """Calculate the binomial coefficient used in Marin integration."""
+    return math.comb(j + k, j) * math.comb(m + n - j - k, n - k)
+
+
+def marin_integration(
+    y: t.List[float], z: t.List[float], m: int, n: int
+) -> float:
+    """Marin's algorithm for integrating a polynomial over a closed polygon.
+
+    The order of the polygon vertices is significant. If the points are in
+    counterclockwise order the integral is positive, otherwise the integral is
+    negative.
+
+    Arguments:
+        y (List(float)): Y coordinates of polygon vertices.
+        z (List(float)): Z coordinates of polygon vertices.
+        m (int): The degree of the polynomial in the y direction.
+        n (int): The degree of the polynomial in the z direction.
+
+    Returns:
+        float: The result of the integrated polynomial.
+    """
+    mom = 0
+    for i in range(len(y) - 1):
+        # Sum over j
+        ssj = 0
+        for j in range(m + 1):
+            # Sum over k
+            ssk = 0
+            for k in range(n + 1):
+                ssk += _coeff(m, n, j, k) * z[i] ** (n - k) * z[i + 1] ** k
+            ssj += ssk * y[i] ** (m - j) * y[i + 1] ** j
+        mom += ssj * (y[i] * z[i + 1] - y[i + 1] * z[i])
+    return mom / (math.comb(m + n, n) * (m + n + 1) * (m + n + 2))

structuralcodes/sections/section_integrators/_marin_integrator.py

@@ -0,0 +1,222 @@
+"""The Marin section integrator."""
+
+from __future__ import annotations  # To have clean hints of ArrayLike in docs
+
+import typing as t
+from math import atan2, cos, sin
+
+import numpy as np
+from numpy.typing import ArrayLike
+from shapely import MultiLineString, MultiPolygon, Polygon
+from shapely.geometry.polygon import orient
+
+from structuralcodes.geometry import CompoundGeometry, create_line_point_angle
+
+from ._marin_integration import marin_integration
+from ._section_integrator import SectionIntegrator
+
+
+class MarinIntegrator(SectionIntegrator):
+    """Section integrator based on the Marin algorithm."""
+
+    def prepare_input(
+        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.
+        """
+        # 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
+        angle = -atan2(strain[2], strain[1])
+
+        rotated_geom = geo.rotate(angle)
+        # 2. Get y coordinate of neutral axis in this new 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)
+            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 '
+                    '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))
+                )
+                # 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))
+                    )
+
+            if strains is None:
+                get_input_polygon(g.polygon, coeffs[0])
+            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]
+                    )
+                    if y0 > y1:
+                        y0, y1 = y1, y0
+                    bbox = g.polygon.bounds
+                    line0 = create_line_point_angle((0, y0), 0, bbox)
+                    line1 = create_line_point_angle((0, y1), 0, bbox)
+                    lines = MultiLineString((line0, line1))
+                    # intersection
+                    result = g.split_two_lines(lines=lines)
+
+                    if isinstance(result, Polygon):
+                        # If the result is a single polygon
+                        get_input_polygon(result, coeffs[p])
+                    elif isinstance(result, MultiPolygon):
+                        # If the result is a MultiPolygon
+                        for polygon in result.geoms:
+                            get_input_polygon(polygon, coeffs[p])
+        # Tentative proposal for managing reinforcement (PointGeometry)
+        x = []
+        y = []
+        F = []
+        for pg in rotated_geom.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
+            x.append(xp)
+            y.append(yp)
+            F.append(pg.material.get_stress(strain)[0] * A)
+        prepared_input.append((1, np.array(x), np.array(y), np.array(F)))
+
+        return angle, prepared_input
+
+    def integrate(
+        self,
+        angle: float,
+        prepared_input: t.List[
+            t.Tuple[int, np.ndarray, np.ndarray, np.ndarray]
+        ],
+    ) -> t.Tuple[float, float, float]:
+        """Integrate stresses over the geometry.
+
+        Arguments:
+            prepared_input (List): The prepared input from .prepare_input().
+
+        Returns:
+            Tuple(float, float, float): The stress resultants N, Mx and My.
+        """
+        # Set the stress resultants to zero
+        N, Mx, My = 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:
+            if i == 0:
+                # Find integration order from shape of stress coeff array
+                n = stress_coeff.shape[0]
+
+                # Calculate area moments
+                area_moments_N = np.array(
+                    [marin_integration(y, z, 0, k) for k in range(n)]
+                )
+                area_moments_Mx = np.array(
+                    [marin_integration(y, z, 0, k + 1) for k in range(n)]
+                )
+                area_moments_My = 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)
+            elif i == 1:
+                # Reinforcement
+                N += sum(stress_coeff)
+                Mx += sum(stress_coeff * z)
+                My += 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]])
+
+        return N, M[0, 0], M[1, 0]
+
+    def integrate_strain_response_on_geometry(
+        self, geo: CompoundGeometry, strain: ArrayLike, **kwargs
+    ):
+        """Integrate the strain response with the Marin algorithm.
+
+        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.
+
+        Returns:
+            Tuple(Tuple(float, float, float), Dict): The stress resultants N,
+            Mx and My and the triangulation data.
+        """
+        del kwargs
+        # Prepare the general input based on the geometry and the input strains
+        angle, prepared_input = self.prepare_input(geo, strain)
+
+        # Return the calculated response
+        return *self.integrate(angle, prepared_input), None