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

structuralcodes/materials/constitutive_laws/_elasticplastic.py

@@ -0,0 +1,227 @@
+"""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 __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]:
+        """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)

structuralcodes/materials/constitutive_laws/_parabolarectangle.py

@@ -0,0 +1,255 @@
+"""Parabola-Rectangle 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 ParabolaRectangle(ConstitutiveLaw):
+    """Class for parabola rectangle constitutive law.
+
+    The stresses and strains are assumed negative in compression and positive
+    in tension.
+    """
+
+    __materials__: t.Tuple[str] = ('concrete',)
+
+    def __init__(
+        self,
+        fc: float,
+        eps_0: float = -0.002,
+        eps_u: float = -0.0035,
+        n: float = 2.0,
+        name: t.Optional[str] = None,
+    ) -> None:
+        """Initialize a Parabola-Rectangle Material.
+
+        Arguments:
+            fc (float): The strength of concrete in compression.
+
+        Keyword Arguments:
+            eps_0 (float): Peak strain of concrete in compression. Default
+                value = -0.002.
+            eps_u (float): Ultimate strain of concrete in compression. Default
+                value = -0.0035.
+            n (float): Exponent for the pre-peak branch. Default value = 2.
+            name (str): A name for the constitutive law.
+        """
+        name = name if name is not None else 'ParabolaRectangleLaw'
+        super().__init__(name=name)
+        self._fc = -abs(fc)
+        self._eps_0 = -abs(eps_0)
+        self._eps_u = -abs(eps_u)
+        self._n = n
+
+    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._eps_0 <= eps <= 0:
+                sig = self._fc * (1 - (1 - eps / self._eps_0) ** self._n)
+            if self._eps_u <= eps < self._eps_0:
+                sig = self._fc
+            return sig
+        # If it is an array
+        sig = np.zeros_like(eps)
+        # Parabolic branch
+        sig[(eps <= 0) & (eps >= self._eps_0)] = self._fc * (
+            1
+            - (1 - (eps[(eps <= 0) & (eps >= self._eps_0)] / self._eps_0))
+            ** self._n
+        )
+        # Rectangle branch
+        sig[eps < self._eps_0] = self._fc
+        # Zero elsewhere
+        sig[eps < self._eps_u] = 0
+        sig[eps > 0] = 0
+        return sig
+
+    def get_tangent(
+        self, eps: t.Union[float, ArrayLike]
+    ) -> t.Union[float, ArrayLike]:
+        """Return the tangent 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._eps_0 <= eps <= 0:
+                tangent = (
+                    self._n
+                    * self._fc
+                    / self._eps_0
+                    * (1 - (eps / self._eps_0)) ** (self._n - 1)
+                )
+            return tangent
+        # If it is an array
+        # parabolic branch
+        tangent = np.zeros_like(eps)
+        tangent[(eps <= 0) & (eps >= self._eps_0)] = (
+            self._n
+            * self._fc
+            / self._eps_0
+            * (1 - (eps[(eps <= 0) & (eps >= self._eps_0)] / self._eps_0))
+            ** (self._n - 1)
+        )
+        # Elsewhere tangent is zero
+        tangent[eps < self._eps_0] = 0.0
+        tangent[eps > 0] = 0.0
+        return tangent
+
+    def __marin__(
+        self, strain: t.Tuple[float, float]
+    ) -> t.Tuple[t.List[float], t.List[float]]:
+        """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)]
+        """
+        if self._n != 2:
+            # The constitutive law is not writtable as a polynomial,
+            # Call the generic distretizing method
+            return super().__marin__(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
+                    * strain[0]
+                    / self._eps_0
+                    * (1 - 0.5 * (strain[0] / self._eps_0))
+                )
+                a1 = (
+                    2
+                    * self._fc
+                    / self._eps_0
+                    * strain[1]
+                    * (1 - strain[0] / self._eps_0)
+                )
+                coeff.append((a0, a1, 0.0))
+            elif strain[0] >= self._eps_u:
+                # 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:
+            # Parabolic part
+            strains.append((self._eps_0, 0))
+            a0 = (
+                2
+                * self._fc
+                * strain[0]
+                / self._eps_0
+                * (1 - 0.5 * (strain[0] / self._eps_0))
+            )
+            a1 = (
+                2
+                * self._fc
+                / self._eps_0
+                * strain[1]
+                * (1 - strain[0] / self._eps_0)
+            )
+            a2 = -self._fc * strain[1] ** 2 / self._eps_0**2
+            coeff.append((a0, a1, a2))
+            # Constant part
+            strains.append((self._eps_u, self._eps_0))
+            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]:
+        """Return the ultimate strain (negative and positive)."""
+        if yielding:
+            return (self._eps_0, 100)
+        return (self._eps_u, 100)

structuralcodes/materials/constitutive_laws/_popovics.py

@@ -0,0 +1,133 @@
+"""Popovics 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 Popovics(ConstitutiveLaw):
+    """Class for Popovics-Mander constitutive law.
+
+    The stresses and strains are assumed negative in compression and positive
+    in tension.
+
+    If the relation Ec = 5000 * sqrt(fc) is used for elastic modulus, the
+    constitutive law is identical to the one proposed by Mander et al. (1988).
+
+    References:
+    Popovics, S., 1973, “A Numerical Approach to the Complete Stress-Strain
+    Curve of Concrete”, Cement and Concrete Research, 3(4), 583-599.
+
+    Mander, J.B., Priestley, M.J.N., Park, R., 1988, "Theoretical Stress-Strain
+    Model for Confined Concrete", Journal of Structural Engineering, 114(8),
+    1804-1826.
+    """
+
+    __materials__: t.Tuple[str] = ('concrete',)
+
+    def __init__(
+        self,
+        fc: float,
+        eps_c: float = -0.002,
+        eps_cu: float = -0.0035,
+        Ec: t.Optional[float] = None,
+        name: t.Optional[str] = None,
+    ) -> None:
+        """Initialize a Popovics Material.
+
+        Arguments:
+            fc (float): the strength of concrete in compression
+
+        Keyword Arguments:
+            eps_c (float): Peak strain of concrete in compression. Default
+                value = -0.002.
+            eps_cu (float): Ultimate strain of concrete in compression. Default
+                value = -0.0035.
+            E (optional float): Elastic modulus of concrete. If None, the
+                equation Ec = 5000 * fc**0.5 proposed by Mander et al. (1988)
+                is adopted (fc in MPa). Default value = None.
+            name (str): A name for the constitutive law.
+
+        Raises:
+            ValueError: If E is less or equal to 0.
+
+        Note:
+            If positive values are input for fc, eps_c and eps_cu are input,
+            they will be assumed negative.
+        """
+        name = name if name is not None else 'PopovicsLaw'
+        super().__init__(name=name)
+        self._fc = -abs(fc)
+        self._eps_c = -abs(eps_c)
+        self._eps_cu = -abs(eps_cu)
+        if Ec is None:
+            # fc in MPa, relation of Mander et al. (1988)
+            Ec = 5000 * abs(fc) ** 0.5
+        if Ec <= 0:
+            raise ValueError('Elastic modulus must be a positive number.')
+        E_sec = self._fc / self._eps_c
+        self._n = Ec / (Ec - E_sec)
+
+    def get_stress(
+        self, eps: t.Union[float, ArrayLike]
+    ) -> t.Union[float, ArrayLike]:
+        """Return the stress given the 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
+        # Compression branch
+        eta = eps / self._eps_c
+
+        sig = self._fc * eta * self._n / (self._n - 1 + eta**self._n)
+
+        # Elsewhere stress is 0.0
+        if np.isscalar(eps):
+            if eps < self._eps_cu or eps > 0:
+                return 0.0
+        else:
+            sig[eps < self._eps_cu] = 0.0
+            sig[eps > 0] = 0.0
+
+        return sig
+
+    def get_tangent(
+        self, eps: t.Union[float, ArrayLike]
+    ) -> t.Union[float, ArrayLike]:
+        """Return the tangent 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)
+        # Compression branch
+        eta = eps / self._eps_c
+
+        tangent = (
+            (1 - eta**self._n)
+            / (self._n - 1 + eta**self._n) ** 2
+            * self._n
+            * (self._n - 1)
+            * self._fc
+            / self._eps_c
+        )
+        # Elsewhere tangent is zero
+        if np.isscalar(eps):
+            if eps < self._eps_cu or eps > 0:
+                return 0
+        else:
+            tangent[eps < self._eps_cu] = 0.0
+            tangent[eps > 0] = 0.0
+
+        return tangent
+
+    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)