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

structuralcodes/geometry/_geometry.py

@@ -272,7 +272,7 @@ class PointGeometry(Geometry):
         else:
             # new_material not provided, assume elastic material with same
             # elastic modulus
-            new_material = Elastic(E=geo.material.get_tangent(eps=0)[0])
+            new_material = Elastic(E=geo.material.get_tangent(eps=0))
 
         return PointGeometry(
             point=geo._point,
@@ -557,6 +557,7 @@ class SurfaceGeometry:
             poly=affinity.translate(self.polygon, dx, dy),
             material=self.material,
             density=self._density,
+            concrete=self.concrete
         )
 
     def rotate(
@@ -584,6 +585,7 @@ class SurfaceGeometry:
             ),
             material=self.material,
             density=self._density,
+            concrete=self.concrete,
         )
 
     @staticmethod
@@ -622,7 +624,7 @@ class SurfaceGeometry:
         else:
             # new_material not provided, assume elastic material with same
             # elastic modulus
-            new_material = Elastic(E=geo.material.get_tangent(eps=0)[0])
+            new_material = Elastic(E=geo.material.get_tangent(eps=0))
 
         return SurfaceGeometry(
             poly=geo.polygon, material=new_material, density=geo._density

structuralcodes/geometry/_reinforcement.py

@@ -18,6 +18,7 @@ def add_reinforcement(
     coords: t.Tuple[float, float],
     diameter: float,
     material: t.Union[Material, ConstitutiveLaw],
+    group_label: t.Optional[str] = None,
 ) -> CompoundGeometry:
     """Add a single bar given coordinate.
 
@@ -28,12 +29,16 @@ def add_reinforcement(
         diameter (float): The diameter of the reinforcement.
         material (Union(Material, ConstitutiveLaw)): A material or a
             constitutive law for the behavior of the reinforcement.
+        group_label (Optional(str)): A label for grouping several objects
+            (default is None).
 
     Returns:
         CompoundGeometry: A compound geometry with the original geometry and
         the reinforcement.
     """
-    bar = PointGeometry(Point(coords), diameter, material)
+    bar = PointGeometry(
+        Point(coords), diameter, material, group_label=group_label
+    )
     return geo + bar
 
 
@@ -47,6 +52,7 @@ def add_reinforcement_line(
     s: float = 0.0,
     first: bool = True,
     last: bool = True,
+    group_label: t.Optional[str] = None,
 ) -> CompoundGeometry:
     """Adds a set of bars distributed in a line.
 
@@ -66,6 +72,8 @@ def add_reinforcement_line(
             True).
         last (bool): Boolean indicating if placing the last bar (default =
             True).
+        group_label (Optional(str)): A label for grouping several objects
+            (default is None).
 
     Note:
         At least n or s should be greater than zero.
@@ -110,6 +118,10 @@ def add_reinforcement_line(
             continue
         coords = p1 + v * s * i
         geo = add_reinforcement(
-            geo, (coords[0], coords[1]), diameter, material
+            geo,
+            (coords[0], coords[1]),
+            diameter,
+            material,
+            group_label=group_label,
         )
     return geo

structuralcodes/materials/constitutive_laws/__init__.py

@@ -0,0 +1,84 @@
+"""Constitutive laws for materials."""
+
+import typing as t
+
+from ...core.base import ConstitutiveLaw, Material
+from ._bilinearcompression import BilinearCompression
+from ._elastic import Elastic
+from ._elasticplastic import ElasticPlastic
+from ._parabolarectangle import ParabolaRectangle
+from ._popovics import Popovics
+from ._sargin import Sargin
+from ._userdefined import UserDefined
+
+__all__ = [
+    'Elastic',
+    'ElasticPlastic',
+    'ParabolaRectangle',
+    'BilinearCompression',
+    'Popovics',
+    'Sargin',
+    'UserDefined',
+    'get_constitutive_laws_list',
+    'create_constitutive_law',
+]
+
+CONSTITUTIVE_LAWS: t.Dict[str, ConstitutiveLaw] = {
+    'elastic': Elastic,
+    'elasticplastic': ElasticPlastic,
+    'elasticperfectlyplastic': ElasticPlastic,
+    'bilinearcompression': BilinearCompression,
+    'parabolarectangle': ParabolaRectangle,
+    'popovics': Popovics,
+    'sargin': Sargin,
+}
+
+
+def get_constitutive_laws_list() -> t.List[str]:
+    """Returns a list with valid keywords for constitutive law factory."""
+    return list(CONSTITUTIVE_LAWS.keys())
+
+
+def create_constitutive_law(
+    constitutive_law_name: str, material: Material
+) -> ConstitutiveLaw:
+    """A factory function to create the constitutive law.
+
+    Arguments:
+        constitutive_law_name (str): A string defining a valid constitutive law
+            type. The available keys can be get with the method
+            `get_constitutive_laws_list`.
+        material (Material): The material containing the properties needed for
+            the definition of the constitutive law.
+
+    Note:
+        For working with this facotry function, the material class
+        implementations need to provide special dunder methods (__elastic__,
+        __parabolarectangle__, etc.) needed for the specific material that
+        return the kwargs needed to create the corresponding constitutive
+        law object. If the special dunder method is not found an exception
+        will be raised.
+
+        If the consitutive law selected is not available for the specific
+        material, an exception will be raised.
+    """
+    law = None
+    const_law = CONSTITUTIVE_LAWS.get(constitutive_law_name.lower())
+    if const_law is not None:
+        method_name = f'__{constitutive_law_name}__'
+        # check if the material object has the special method needed
+        if hasattr(material, method_name):
+            method = getattr(material, method_name)
+            if callable(method):
+                # get the kwargs from the special dunder method
+                kwargs = method()
+                # create the constitutive law
+                law = const_law(**kwargs)
+        else:
+            raise ValueError(
+                f'Constitutive law {constitutive_law_name} not available for'
+                f' material {material.__class__.__name__}'
+            )
+    else:
+        raise ValueError(f'Unknown constitutive law: {constitutive_law_name}')
+    return law

structuralcodes/materials/constitutive_laws/_bilinearcompression.py

@@ -0,0 +1,138 @@
+"""Bilinear compression constitutive law."""
+
+from __future__ import annotations  # To have clean hints of ArrayLike in docs
+
+import typing as t
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+from ...core.base import ConstitutiveLaw
+
+
+class BilinearCompression(ConstitutiveLaw):
+    """Class for Bilinear Elastic-PerfectlyPlastic Constitutive Law for
+    Concrete (only compression behavior).
+    """
+
+    __materials__: t.Tuple[str] = ('concrete',)
+
+    def __init__(
+        self,
+        fc: float,
+        eps_c: float,
+        eps_cu: t.Optional[float] = None,
+        name: t.Optional[str] = None,
+    ) -> None:
+        """Initialize a BilinearCompression Material.
+
+        Arguments:
+            fc (float): Compressive strength (negative number).
+            eps_c (float): Strain at compressive strength (pure number).
+
+        Keyword Arguments:
+            eps_cu (float): Ultimate strain (pure number).
+            name (str): A descriptive name for the constitutive law.
+        """
+        name = name if name is not None else 'BilinearCompressionLaw'
+        super().__init__(name=name)
+        self._fc = -abs(fc)
+        self._eps_c = -abs(eps_c)
+        self._eps_cu = -abs(eps_cu)
+        self._E = self._fc / self._eps_c
+
+    def get_stress(
+        self, eps: t.Union[float, ArrayLike]
+    ) -> t.Union[float, ArrayLike]:
+        """Return the stress given strain."""
+        eps = eps if np.isscalar(eps) else np.atleast_1d(eps)
+        # Preprocess eps array in order
+        eps = self.preprocess_strains_with_limits(eps=eps)
+        # 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 it is an array
+        sig = self._E * eps
+        sig[sig < self._fc] = self._fc
+        sig[eps > 0] = 0
+        sig[eps < self._eps_cu] = 0
+        return sig
+
+    def get_tangent(
+        self, eps: t.Union[float, ArrayLike]
+    ) -> t.Union[float, ArrayLike]:
+        """Return the tangent for given strain."""
+        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 it is an array
+        tangent = np.ones_like(eps) * self._E
+        tangent[eps < self._eps_c] = 0.0
+
+        return tangent
+
+    def __marin__(
+        self, strain: t.Tuple[float, float]
+    ) -> t.Tuple[t.List[t.Tuple], t.List[t.Tuple]]:
+        """Returns coefficients and strain limits for Marin integration 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_0:
+                # We are in the linear branch
+                strains = None
+                a0 = self._E * strain[0]
+                a1 = self._E * strain[1]
+                coeff.append((a0, a1))
+            elif strain[0] >= self._eps_cu:
+                # We are in the constant branch
+                strains = None
+                coeff.append((self._fc,))
+            else:
+                # 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 * strain[0]
+            a1 = self._E * strain[1]
+            coeff.append((a0, a1))
+            # Constant part
+            strains.append((self._eps_cu, self._eps_c))
+            coeff.append((self._fc,))
+        return strains, coeff
+
+    def get_ultimate_strain(
+        self, yielding: bool = False
+    ) -> t.Tuple[float, float]:
+        """Return the ultimate strain (negative and positive)."""
+        if yielding:
+            return (self._eps_c, 100)
+        return (self._eps_cu, 100)

structuralcodes/materials/constitutive_laws/_elastic.py

@@ -0,0 +1,114 @@
+"""Elastic constitutive law."""
+
+from __future__ import annotations  # To have clean hints of ArrayLike in docs
+
+import typing as t
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+from ...core.base import ConstitutiveLaw
+
+
+class Elastic(ConstitutiveLaw):
+    """Class for elastic constitutive law."""
+
+    __materials__: t.Tuple[str] = (
+        'concrete',
+        'steel',
+        'rebars',
+    )
+
+    def __init__(self, E: float, name: t.Optional[str] = None) -> None:
+        """Initialize an Elastic Material.
+
+        Arguments:
+            E (float): The elastic modulus.
+
+        Keyword Arguments:
+            name (str): A descriptive name for the constitutive law.
+        """
+        name = name if name is not None else 'ElasticLaw'
+        super().__init__(name=name)
+        self._E = E
+        self._eps_su = None
+
+    def get_stress(
+        self, eps: t.Union[float, ArrayLike]
+    ) -> t.Union[float, ArrayLike]:
+        """Return stress given strain."""
+        eps = eps if np.isscalar(eps) else np.atleast_1d(eps)
+        return self._E * eps
+
+    def get_tangent(
+        self, eps: t.Union[float, ArrayLike]
+    ) -> t.Union[float, ArrayLike]:
+        """Return the tangent."""
+        if np.isscalar(eps):
+            return self._E
+        eps = np.atleast_1d(eps)
+        return np.ones_like(eps) * self._E
+
+    def __marin__(
+        self, strain: t.Tuple[float, float]
+    ) -> t.Tuple[t.List[t.Tuple], t.List[t.Tuple]]:
+        """Returns coefficients and strain limits for Marin integration 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 * strain[0]
+        a1 = self._E * strain[1]
+        coeff = [(a0, a1)]
+        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
+        # unlesse specified by the user differently
+        del kwargs
+        return self._eps_su or (-100, 100)
+
+    def set_ultimate_strain(
+        self, eps_su=t.Union[float, t.Tuple[float, float]]
+    ) -> None:
+        """Set ultimate strains for Elastic Material if needed.
+
+        Arguments:
+            eps_su (float or (float, float)): Defining ultimate strain. If a
+                single value is provided the same is adopted for both negative
+                and positive strains. If a tuple is provided, it should be
+                given as (negative, positive).
+        """
+        if isinstance(eps_su, float):
+            self._eps_su = (-abs(eps_su), abs(eps_su))
+        elif isinstance(eps_su, tuple):
+            if len(eps_su) < 2:
+                raise ValueError(
+                    'Two values need to be provided when setting the tuple'
+                )
+            eps_su_n = eps_su[0]
+            eps_su_p = eps_su[1]
+            if eps_su_p < eps_su_n:
+                eps_su_p, eps_su_n = eps_su_n, eps_su_p
+            if eps_su_p < 0:
+                raise ValueError(
+                    'Positive ultimate strain should be non-negative'
+                )
+            if eps_su_n > 0:
+                raise ValueError(
+                    'Negative utimate strain should be non-positive'
+                )
+            self._eps_su = (eps_su_n, eps_su_p)
+        else:
+            raise ValueError(
+                'set_ultimate_strain requires a single value or a tuple \
+                with  two values'
+            )

structuralcodes/materials/constitutive_laws/_elasticplastic.py

@@ -0,0 +1,172 @@
+"""Elastic-plastic constitutive law."""
+
+from __future__ import annotations  # To have clean hints of ArrayLike in docs
+
+import typing as t
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+from ...core.base import ConstitutiveLaw
+
+
+class ElasticPlastic(ConstitutiveLaw):
+    """Class for elastic-plastic Constitutive Law."""
+
+    __materials__: t.Tuple[str] = (
+        'steel',
+        'rebars',
+    )
+
+    def __init__(
+        self,
+        E: float,
+        fy: float,
+        Eh: float = 0.0,
+        eps_su: t.Optional[float] = None,
+        name: t.Optional[str] = None,
+    ) -> None:
+        """Initialize an Elastic-Plastic Material.
+
+        Arguments:
+            E (float): The elastic modulus.
+            fy (float): The yield strength.
+
+        Keyword Arguments:
+            Eh (float): The hardening modulus.
+            eps_su (float): The ultimate strain.
+            name (str): A descriptive name for the constitutive law.
+        """
+        name = name if name is not None else 'ElasticPlasticLaw'
+        super().__init__(name=name)
+        if E > 0:
+            self._E = E
+        else:
+            raise ValueError('Elastic modulus E must be greater than zero')
+        self._fy = fy
+        self._Eh = Eh
+        self._eps_su = eps_su
+        self._eps_sy = fy / E
+
+    def get_stress(
+        self, eps: t.Union[float, ArrayLike]
+    ) -> t.Union[float, ArrayLike]:
+        """Return the stress given strain."""
+        eps = eps if np.isscalar(eps) else np.atleast_1d(eps)
+        # Preprocess eps array in order
+        eps = self.preprocess_strains_with_limits(eps=eps)
+        # Compute stress
+        sig = self._E * eps
+        delta_sig = self._fy * (1 - self._Eh / self._E)
+        if np.isscalar(sig):
+            if sig < -self._fy:
+                sig = eps * self._Eh - delta_sig
+            if sig > self._fy:
+                sig = eps * self._Eh + delta_sig
+            if (self._eps_su is not None) and (
+                eps > self._eps_su or eps < -self._eps_su
+            ):
+                sig = 0
+            return sig
+        sig[sig < -self._fy] = eps[sig < -self._fy] * self._Eh - delta_sig
+        sig[sig > self._fy] = eps[sig > self._fy] * self._Eh + delta_sig
+        if self._eps_su is not None:
+            sig[eps > self._eps_su] = 0
+            sig[eps < -self._eps_su] = 0  # pylint: disable=E1130
+        return sig
+
+    def get_tangent(
+        self, eps: t.Union[float, ArrayLike]
+    ) -> t.Union[float, ArrayLike]:
+        """Return the tangent for given strain."""
+        if np.isscalar(eps):
+            tangent = (
+                self._E if -self._eps_sy <= eps <= self._eps_sy else self._Eh
+            )
+            if (self._eps_su is not None) and (
+                eps > self._eps_su or eps < -self._eps_su
+            ):
+                tangent = 0
+            return tangent
+
+        eps = np.atleast_1d(eps)
+        tangent = np.ones_like(eps) * self._E
+        tangent[eps > self._eps_sy] = self._Eh
+        tangent[eps < -self._eps_sy] = self._Eh
+        if self._eps_su is not None:
+            tangent[eps > self._eps_su] = 0
+            tangent[eps < -self._eps_su] = 0  # pylint: disable=E1130
+
+        return tangent
+
+    def __marin__(
+        self, strain: t.Tuple[float, float]
+    ) -> t.Tuple[t.List[t.Tuple], t.List[t.Tuple]]:
+        """Returns coefficients and strain limits for Marin integration 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 * strain[0] + self._fy * (1 - self._Eh / self._E)
+                a1 = self._Eh * strain[1]
+                coeff.append((a0, a1))
+            elif strain[0] < eps_sy_n and strain[0] >= eps_su_n:
+                # We are in the Hardening part negative
+                strains = None
+                a0 = self._Eh * strain[0] - self._fy * (1 - self._Eh / self._E)
+                a1 = self._Eh * strain[1]
+                coeff.append((a0, a1))
+            elif abs(strain[0]) <= self._eps_sy:
+                # We are in the elastic part
+                strains = None
+                a0 = self._E * strain[0]
+                a1 = self._E * strain[1]
+                coeff.append((a0, a1))
+            else:
+                strains = None
+                coeff.append((0.0,))
+        else:
+            # Hardening part negative
+            strains.append((eps_su_n, eps_sy_n))
+            a0 = self._Eh * strain[0] - self._fy * (1 - self._Eh / self._E)
+            a1 = self._Eh * strain[1]
+            coeff.append((a0, a1))
+            # Elastic part
+            strains.append((eps_sy_n, eps_sy_p))
+            a0 = self._E * strain[0]
+            a1 = self._E * strain[1]
+            coeff.append((a0, a1))
+            # Hardening part positive
+            strains.append((eps_sy_p, eps_su_p))
+            a0 = self._Eh * strain[0] + self._fy * (1 - self._Eh / self._E)
+            a1 = self._Eh * strain[1]
+            coeff.append((a0, a1))
+        return strains, coeff
+
+    def get_ultimate_strain(
+        self, yielding: bool = False
+    ) -> t.Tuple[float, float]:
+        """Return the ultimate strain (negative and positive)."""
+        if yielding:
+            return (-self._eps_sy, self._eps_sy)
+        # If not specified eps
+        if self._eps_su is None:
+            return (-self._eps_sy * 2, self._eps_sy * 2)
+        return (-self._eps_su, self._eps_su)