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

structuralcodes/geometry/_rectangular.py

@@ -0,0 +1,101 @@
+"""Classes for rectangular geometries.
+
+The class `RectangularGeometry` represents a rectangular SurfaceGeometry with
+homogenous material.
+This class is simply a wrapper of `SurfaceGeometry` class and permits an easy
+input by the user.
+"""
+
+import typing as t
+
+from numpy.typing import ArrayLike
+from shapely import Polygon
+
+from structuralcodes.core.base import ConstitutiveLaw, Material
+
+from ._geometry import SurfaceGeometry
+
+
+class RectangularGeometry(SurfaceGeometry):
+    """This is a wrapper class for defining a `SurfaceGeometry` of rectangular
+    shape with a homogeneous material.
+    """
+
+    _width: float
+    _height: float
+
+    def __init__(
+        self,
+        width: float,
+        height: float,
+        material: t.Union[Material, ConstitutiveLaw],
+        density: t.Optional[float] = None,
+        concrete: bool = False,
+        origin: t.Optional[ArrayLike] = None,
+        name: t.Optional[str] = None,
+        group_label: t.Optional[str] = None,
+    ) -> None:
+        """Initialize a RectangularGeometry.
+
+        Arguments:
+            width (float): The width of the geometry.
+            height (float): The height of the geometry.
+            material (Union(Material, ConstitutiveLaw)): A Material or
+                ConsitutiveLaw class applied to the geometry.
+            density (Optional(float)): When a ConstitutiveLaw is passed as
+                material, the density can be provided by this argument. When
+                material is a Material object the density is taken from the
+                material.
+            concrete (bool): Flag to indicate if the geometry is concrete. When
+                passing a Material as material, this is automatically inferred.
+            origin (Optional(ArrayLike)): The center point of the rectangle.
+                (0.0, 0.0) is used as default.
+            name (Optional(str)): The name to be given to the object.
+            group_label (Optional(str)): A label for grouping several objects.
+
+        Note:
+            The RectangularGeometry is simply a wrapper for a SurfaceGeometry
+            object.
+        """
+        # Check that size is strictly positive
+        if width <= 0:
+            raise ValueError('Width must be a positive number.')
+        if height <= 0:
+            raise ValueError('Height must be a positive number.')
+
+        self._width = width
+        self._height = height
+
+        # Parse origin
+        if origin is not None and len(origin) != 2:
+            raise ValueError('origin must be an ArrayLike with len == 2')
+        origin = origin if origin is not None else (0.0, 0.0)
+
+        # Create the shapely polygon
+        polygon = Polygon(
+            (
+                (-width / 2 + origin[0], -height / 2 + origin[1]),
+                (width / 2 + origin[0], -height / 2 + origin[1]),
+                (width / 2 + origin[0], height / 2 + origin[1]),
+                (-width / 2 + origin[0], height / 2 + origin[1]),
+            )
+        )
+        # Pass everything to the base class
+        super().__init__(
+            poly=polygon,
+            material=material,
+            density=density,
+            concrete=concrete,
+            name=name,
+            group_label=group_label,
+        )
+
+    @property
+    def width(self):
+        """Returns the width of the rectangle."""
+        return self._width
+
+    @property
+    def height(self):
+        """Return the height of the rectangle."""
+        return self._height

structuralcodes/geometry/_reinforcement.py

@@ -1,16 +1,14 @@
 """Functions related to reinforcement definition."""
 
+import math
 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,
-)
+
+from ._geometry import CompoundGeometry, PointGeometry, SurfaceGeometry
 
 
 def add_reinforcement(
@@ -125,3 +123,132 @@ def add_reinforcement_line(
             group_label=group_label,
         )
     return geo
+
+
+def add_reinforcement_circle(
+    geo: t.Union[SurfaceGeometry, CompoundGeometry],
+    center: t.Tuple[float, float],
+    radius: float,
+    diameter: float,
+    material: t.Union[Material, ConstitutiveLaw],
+    n: int = 0,
+    s: float = 0.0,
+    first: bool = True,
+    last: bool = True,
+    start_angle: float = 0.0,
+    stop_angle: float = 2 * np.pi,
+    group_label: t.Optional[str] = None,
+) -> CompoundGeometry:
+    """Adds a set of bars distributed in a circular arch line.
+    By default the whole circle is considered. If one wants to specify a
+    circular arch, the `start_angle` and `stop_angle` attributes need to be
+    specified.
+
+    Arguments:
+        geo (Union(SurfaceGeometry, CompoundGeometry)): The geometry used as
+            input.
+        center (Tuple(float, float)): Coordinates of the center point of
+            the circle line where reinforcement will be added.
+        radius (float): Radius of the circle line where reinforcement will be
+            added.
+        diameter (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).
+        start_angle (float): Start angle (respect to X axis) for defining the
+            arch where to add bars in radians (default = 0)
+        stop_angle (float): Stop angle (respect to X axis) for defining the
+            arch where to add bars in radians (default = 2pi)
+        group_label (Optional(str)): A label for grouping several objects
+            (default is None).
+
+    Note:
+        At least n or s should be greater than zero.
+        Attribues start_angle and stop_angle by default are 0 and 2pi
+        respectively, so that bars will be distributed along the whole circle.
+        If only a portion of the circle must be used (i.e. an arch of
+        circumference), then set start and stop angles correspondingly.
+        stop_angle must always be larger than start_angle.
+
+    Returns:
+        CompoundGeometry: A compound geometry with the original geometry and
+        the reinforcement.
+    """
+    # Check that difference between stop and start angle is
+    # positive and less than 2pi
+    if stop_angle - start_angle <= 0 or stop_angle - start_angle > 2 * np.pi:
+        raise ValueError(
+            'Stop angle should be larger than start angle and difference \
+            them should be at most 2pi.'
+        )
+    # Calculate length from start_angle to stop_angle
+    length = radius * (stop_angle - start_angle)
+
+    # If the whole circle, than deal with the case that would add an extra bar
+    whole = math.isclose(length - 2 * np.pi * radius, 0, abs_tol=1e-4)
+    add_n = 0 if not whole else 1
+
+    # delta_angle is used if we need to center the set of bars
+    # in the curve.
+    delta_angle = 0
+    if n > 0 and s > 0:
+        # Provided both the number of bars and spacing
+        # Check there is enough space for fitting the bars
+        n += add_n
+        needed_length = (n - 1) * s
+        if needed_length > length:
+            raise ValueError(
+                f'There is not room to fit {n} bars with a spacing of {s} \
+                in {length}'
+            )
+        # Compute delta_angle to make bars centered in the curvilinear segment
+        delta_angle = (length - needed_length) / 2.0 / radius
+    elif n > 0:
+        # Provided the number of bars
+        s = length / (n - 1)
+        # If we are distributing bars i the whole circle add a fictitious extra
+        # bar (than later will be removed).
+        n += add_n
+    elif s > 0:
+        # Provided the spacing
+        # 1. Compute the number of bars
+        n = math.floor(length / s) + 1
+        # 2. Distribute the bars centered in the curvilinear segment
+        needed_length = (n - 1) * s
+        delta_angle = (length - needed_length) / 2.0 / radius
+        # set whole to False bacause in this case we don't need to deal with
+        # the special case
+        whole = False
+    else:
+        raise ValueError('At least n or s should be provided')
+
+    phi_rebars = np.linspace(
+        start_angle + delta_angle, stop_angle - delta_angle, n
+    )
+    if whole:
+        n -= 1
+        phi_rebars = phi_rebars[:-1]
+
+    x = center[0] + radius * np.cos(phi_rebars)
+    y = center[1] + radius * np.sin(phi_rebars)
+
+    # add the bars
+    for i in range(n):
+        if i == 0 and not first:
+            continue
+        if i == n - 1 and not last:
+            continue
+        geo = add_reinforcement(
+            geo,
+            (x[i], y[i]),
+            diameter,
+            material,
+            group_label=group_label,
+        )
+    return geo

structuralcodes/materials/constitutive_laws/_bilinearcompression.py

@@ -51,10 +51,10 @@ class BilinearCompression(ConstitutiveLaw):
         # Compute stress
         # If it is a scalar
         if np.isscalar(eps):
-            sig = 0
-            if self._fc / self._E <= eps <= 0:
-                sig = self._E * eps
-            return sig
+            if eps > 0 or eps < self._eps_cu:
+                return 0
+            return max(self._E * eps, self._fc)
+
         # If it is an array
         sig = self._E * eps
         sig[sig < self._fc] = self._fc
@@ -69,13 +69,14 @@ class BilinearCompression(ConstitutiveLaw):
         eps = eps if np.isscalar(eps) else np.atleast_1d(eps)
         # If it is a scalar
         if np.isscalar(eps):
-            tangent = 0
-            if self._fc / self._E <= eps <= 0:
-                tangent = self._E
-            return tangent
+            if self._eps_c < eps <= 0:
+                return self._E
+            return 0
+
         # If it is an array
         tangent = np.ones_like(eps) * self._E
-        tangent[eps < self._eps_c] = 0.0
+        tangent[eps >= 0] = 0
+        tangent[eps < self._eps_c] = 0
 
         return tangent
 
@@ -103,7 +104,7 @@ class BilinearCompression(ConstitutiveLaw):
                 # We are in tensile branch
                 strains = None
                 coeff.append((0.0,))
-            elif strain[0] > self._eps_0:
+            elif strain[0] > self._eps_c:
                 # We are in the linear branch
                 strains = None
                 a0 = self._E * strain[0]
@@ -129,6 +130,51 @@ class BilinearCompression(ConstitutiveLaw):
             coeff.append((self._fc,))
         return strains, coeff
 
+    def __marin_tangent__(
+        self, strain: t.Tuple[float, float]
+    ) -> t.Tuple[t.List[t.Tuple], t.List[t.Tuple]]:
+        """Returns coefficients and strain limits for Marin integration of
+        tangent in a simply formatted way.
+
+        Arguments:
+            strain (float, float): Tuple defining the strain profile: eps =
+                strain[0] + strain[1]*y.
+
+        Example:
+            [(0, -0.002), (-0.002, -0.003)]
+            [(a0, a1, a2), (a0)]
+        """
+        strains = []
+        coeff = []
+        if strain[1] == 0:
+            # Uniform strain equal to strain[0]
+            # understand in which branch we are
+            strain[0] = self.preprocess_strains_with_limits(strain[0])
+            if strain[0] > 0:
+                # We are in tensile branch
+                strains = None
+                coeff.append((0.0,))
+            elif strain[0] > self._eps_c:
+                # We are in the linear branch
+                strains = None
+                a0 = self._E
+                coeff.append((a0,))
+            else:
+                # We are in the constant branch or
+                # We are in a branch of non-resisting concrete
+                # Too much compression
+                strains = None
+                coeff.append((0.0,))
+        else:
+            # linear part
+            strains.append((self._eps_c, 0))
+            a0 = self._E
+            coeff.append((a0,))
+            # Constant part
+            strains.append((self._eps_cu, self._eps_c))
+            coeff.append((0.0,))
+        return strains, coeff
+
     def get_ultimate_strain(
         self, yielding: bool = False
     ) -> t.Tuple[float, float]:

structuralcodes/materials/constitutive_laws/_elastic.py

@@ -69,6 +69,25 @@ class Elastic(ConstitutiveLaw):
         coeff = [(a0, a1)]
         return strains, coeff
 
+    def __marin_tangent__(
+        self, strain: t.Tuple[float, float]
+    ) -> t.Tuple[t.List[t.Tuple], t.List[t.Tuple]]:
+        """Returns coefficients and strain limits for Marin integration of
+        tangent in a simply formatted way.
+
+        Arguments:
+            strain (float, float): Tuple defining the strain profile: eps =
+                strain[0] + strain[1]*y.
+
+        Example:
+            [(0, -0.002), (-0.002, -0.003)]
+            [(a0, a1, a2), (a0)]
+        """
+        strains = None
+        a0 = self._E
+        coeff = [(a0,)]
+        return strains, coeff
+
     def get_ultimate_strain(self, **kwargs) -> t.Tuple[float, float]:
         """Return the ultimate strain (negative and positive)."""
         # There is no real strain limit, so set it to very large values

structuralcodes/materials/constitutive_laws/_elasticplastic.py

@@ -160,6 +160,61 @@ class ElasticPlastic(ConstitutiveLaw):
             coeff.append((a0, a1))
         return strains, coeff
 
+    def __marin_tangent__(
+        self, strain: t.Tuple[float, float]
+    ) -> t.Tuple[t.List[t.Tuple], t.List[t.Tuple]]:
+        """Returns coefficients and strain limits for Marin integration of
+        tangent in a simply formatted way.
+
+        Arguments:
+            strain (float, float): Tuple defining the strain profile: eps =
+                strain[0] + strain[1]*y.
+
+        Example:
+            [(0, -0.002), (-0.002, -0.003)]
+            [(a0, a1, a2), (a0)]
+        """
+        strains = []
+        coeff = []
+        eps_sy_n, eps_sy_p = self.get_ultimate_strain(yielding=True)
+        eps_su_n, eps_su_p = self.get_ultimate_strain()
+        if strain[1] == 0:
+            # Uniform strain equal to strain[0]
+            # Understand in which branch are we
+            strain[0] = self.preprocess_strains_with_limits(strain[0])
+            if strain[0] > eps_sy_p and strain[0] <= eps_su_p:
+                # We are in the Hardening part positive
+                strains = None
+                a0 = self._Eh
+                coeff.append((a0,))
+            elif strain[0] < eps_sy_n and strain[0] >= eps_su_n:
+                # We are in the Hardening part negative
+                strains = None
+                a0 = self._Eh
+                coeff.append((a0,))
+            elif abs(strain[0]) <= self._eps_sy:
+                # We are in the elastic part
+                strains = None
+                a0 = self._E
+                coeff.append((a0,))
+            else:
+                strains = None
+                coeff.append((0.0,))
+        else:
+            # Hardening part negative
+            strains.append((eps_su_n, eps_sy_n))
+            a0 = self._Eh
+            coeff.append((a0,))
+            # Elastic part
+            strains.append((eps_sy_n, eps_sy_p))
+            a0 = self._E
+            coeff.append((a0,))
+            # Hardening part positive
+            strains.append((eps_sy_p, eps_su_p))
+            a0 = self._Eh
+            coeff.append((a0,))
+        return strains, coeff
+
     def get_ultimate_strain(
         self, yielding: bool = False
     ) -> t.Tuple[float, float]:

structuralcodes/materials/constitutive_laws/_parabolarectangle.py

@@ -189,6 +189,63 @@ class ParabolaRectangle(ConstitutiveLaw):
             coeff.append((self._fc,))
         return strains, coeff
 
+    def __marin_tangent__(
+        self, strain: t.Tuple[float, float]
+    ) -> t.Tuple[t.List[t.Tuple], t.List[t.Tuple]]:
+        """Returns coefficients and strain limits for Marin integration of
+        tangent in a simply formatted way.
+
+        Arguments:
+            strain (float, float): Tuple defining the strain profile: eps =
+                strain[0] + strain[1]*y.
+
+        Example:
+            [(0, -0.002), (-0.002, -0.003)]
+            [(a0, a1, a2), (a0)]
+        """
+        if self._n != 2:
+            # The constitutive law is not writtable as a polynomial,
+            # Call the generic distretizing method
+            return super().__marin_tangent__(strain=strain)
+
+        strains = []
+        coeff = []
+        if strain[1] == 0:
+            # Uniform strain equal to strain[0]
+            # understand in which branch are we
+            strain[0] = self.preprocess_strains_with_limits(strain[0])
+            if strain[0] > 0:
+                # We are in tensile branch
+                strains = None
+                coeff.append((0.0,))
+            elif strain[0] > self._eps_0:
+                # We are in the parabolic branch
+                strains = None
+                a0 = (
+                    2
+                    * self._fc
+                    / self._eps_0
+                    * (1 - (strain[0] / self._eps_0))
+                )
+                a1 = -2 * self._fc / self._eps_0**2 * strain[1]
+                coeff.append((a0, a1))
+            else:
+                # We are in the constant branch or
+                # We are in a branch of non-resisting concrete
+                # Too much compression
+                strains = None
+                coeff.append((0.0,))
+        else:
+            # Parabolic part
+            strains.append((self._eps_0, 0))
+            a0 = 2 * self._fc / self._eps_0 * (1 - (strain[0] / self._eps_0))
+            a1 = -2 * self._fc / self._eps_0**2 * strain[1]
+            coeff.append((a0, a1))
+            # Constant part
+            strains.append((self._eps_u, self._eps_0))
+            coeff.append((0.0,))
+        return strains, coeff
+
     def get_ultimate_strain(
         self, yielding: bool = False
     ) -> t.Tuple[float, float]:

structuralcodes/materials/constitutive_laws/_userdefined.py

@@ -173,6 +173,50 @@ class UserDefined(ConstitutiveLaw):
 
         return strains, coeff
 
+    def __marin_tangent__(
+        self, strain: t.Tuple[float, float]
+    ) -> t.Tuple[t.List[t.Tuple], t.List[t.Tuple]]:
+        """Returns coefficients and strain limits for Marin integration of
+        tangent in a simply formatted way.
+
+        Arguments:
+            strain (float, float): Tuple defining the strain profile: eps =
+                strain[0] + strain[1]*y.
+
+        Example:
+            [(0, -0.002), (-0.002, -0.003)]
+            [(a0, a1, a2), (a0)]
+        """
+        strains = []
+        coeff = []
+        if strain[1] == 0:
+            # Uniform strain equal to strain[0]
+            # understand in which branch are we
+            strain[0] = self.preprocess_strains_with_limits(strain[0])
+            found = False
+            for i in range(len(self._x) - 1):
+                if self._x[i] <= strain[0] and self._x[i + 1] >= strain[0]:
+                    strains = None
+                    stiffness = (self._y[i + 1] - self._y[i]) / (
+                        self._x[i + 1] - self._x[i]
+                    )
+                    coeff.append((stiffness,))
+                    found = True
+                    break
+            if not found:
+                strains = None
+                coeff.append((0.0,))
+        else:
+            for i in range(len(self._x) - 1):
+                # For each branch of the linear piecewise function
+                stiffness = (self._y[i + 1] - self._y[i]) / (
+                    self._x[i + 1] - self._x[i]
+                )
+                strains.append((self._x[i], self._x[i + 1]))
+                coeff.append((stiffness,))
+
+        return strains, coeff
+
     def get_ultimate_strain(self, **kwargs) -> t.Tuple[float, float]:
         """Return the ultimate strain (negative and positive)."""
         del kwargs

structuralcodes/sections/__init__.py

@@ -1,6 +1,7 @@
 """Main entry point for sections."""
 
 from ._generic import GenericSection, GenericSectionCalculator
+from ._rc_utils import calculate_elastic_cracked_properties
 from .section_integrators import (
     FiberIntegrator,
     MarinIntegrator,
@@ -17,4 +18,5 @@ __all__ = [
     'MarinIntegrator',
     'integrator_factory',
     'marin_integration',
+    'calculate_elastic_cracked_properties',
 ]