structuralcodes 0.6.1__tar.gz → 0.6.3__tar.gz

{structuralcodes-0.6.1 → structuralcodes-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structuralcodes
-Version: 0.6.1
+Version: 0.6.3
 Summary: A Python package that contains models from structural design codes.
 Author-email: fib - International Federation for Structural Concrete <info@fib-international.org>
 Requires-Python: >=3.9

{structuralcodes-0.6.1 → structuralcodes-0.6.3}/structuralcodes/__init__.py

@@ -3,7 +3,7 @@
 from . import codes, core, geometry, materials, sections
 from .codes import get_design_codes, set_design_code, set_national_annex
 
-__version__ = '0.6.1'
+__version__ = '0.6.3'
 
 __all__ = [
     'set_design_code',

{structuralcodes-0.6.1 → structuralcodes-0.6.3}/structuralcodes/codes/ec2_2004/__init__.py

@@ -31,6 +31,10 @@ from ._concrete_creep_and_shrinkage import (
 )
 from ._concrete_material_properties import (
     Ecm,
+    Ecm_time,
+    beta_cc,
+    beta_ct,
+    beta_E,
     eps_c1,
     eps_c2,
     eps_c3,
@@ -39,11 +43,17 @@ from ._concrete_material_properties import (
     eps_cu3,
     fcd,
     fcm,
+    fcm_time,
     fctk_5,
     fctk_95,
     fctm,
+    fctm_time,
     k_sargin,
     n_parabolic_rectangular,
+    s_time_development,
+)
+from ._cracking_restraint_imposed_deformations import (
+    eps_sm_eps_cm_restraint_end,
 )
 from ._reinforcement_material_properties import (
     epsud,
@@ -94,6 +104,7 @@ __all__ = [
     'Asw_s_required',
     'alpha_e',
     'eps_sm_eps_cm',
+    'eps_sm_eps_cm_restraint_end',
     'hc_eff',
     'k',
     'k1',
@@ -160,6 +171,13 @@ __all__ = [
     'phi_RH',
     't0_adj',
     't_T',
+    'beta_cc',
+    'beta_ct',
+    'beta_E',
+    's_time_development',
+    'fcm_time',
+    'fctm_time',
+    'Ecm_time',
 ]
 
 __title__: str = 'EUROCODE 2 1992-1-1:2004'

{structuralcodes-0.6.1 → structuralcodes-0.6.3}/structuralcodes/codes/ec2_2004/_concrete_material_properties.py

@@ -1,9 +1,21 @@
 """Concrete material properties according to Tab. 3.1."""
 
+from __future__ import annotations  # To have clean hints of ArrayLike in docs
+
 import math
+import typing as t
+
+import numpy as np
+from numpy.typing import ArrayLike
 
 from structuralcodes.codes import mc2010
 
+S_TIME_DEVELOPMENT_DICT = {
+    'R': 0.20,
+    'N': 0.25,
+    'S': 0.38,
+}  # As defined in Eq. (3.2)
+
 
 def fcm(fck: float, delta_f: float = 8) -> float:
     """The mean compressive strength of concrete.
@@ -124,7 +136,7 @@ def k_sargin(
 ) -> float:
     """Computation of k parameter for Sargin constitutive Law.
 
-    EN 1992-1-1:2004, Eq. (3.14)
+    EN 1992-1-1:2004, Eq. (3.14).
 
     Args:
         Ecm (float): the mean elastic modulus of concrete in MPa.
@@ -225,7 +237,7 @@ def eps_cu3(fck: float) -> float:
 def fcd(fck: float, alpha_cc: float, gamma_c: float) -> float:
     """The design compressive strength of concrete.
 
-    EN 1992-1-1:2004, Eq. (3.15)
+    EN 1992-1-1:2004, Eq. (3.15).
 
     Args:
         fck (float): The characteristic compressive strength in MPa.
@@ -237,3 +249,158 @@ def fcd(fck: float, alpha_cc: float, gamma_c: float) -> float:
         float: The design compressive strength of concrete in MPa
     """
     return abs(alpha_cc) * abs(fck) / abs(gamma_c)
+
+
+def beta_cc(t: ArrayLike, s: float) -> ArrayLike:
+    """The time development function for compressive strength of concrete.
+
+    EN 1992-1-1:2004, Eq. (3.2).
+
+    Args:
+        t (ArrayLike): The time in days to evaluate the development function
+            for.
+        s (float): The scale factor in the exponent for the time development
+            function. s = 0.20 for class R, 0.25 for class N, and 0.38 for
+            class N.
+
+    Returns:
+        ArrayLike: The value of the time development function.
+    """
+    return np.exp(s * (1 - np.sqrt(28 / t)))
+
+
+def beta_ct(t: ArrayLike, s: float) -> ArrayLike:
+    """The time development function for tensile strength of concrete.
+
+    EN 1992-1-1:2004, part of Eq. (3.4).
+
+    Args:
+        t (ArrayLike): The time in days to evaluate the development function
+            for.
+        s (float): The scale factor in the exponent for the time development
+            function. s = 0.20 for class R, 0.25 for class N, and 0.38 for
+            class N.
+
+    Returns:
+        ArrayLike: The value of the time development function.
+    """
+    if np.isscalar(t):
+        beta = beta_cc(t, s)
+        if t < 28:
+            return beta
+        return np.pow(beta, 2 / 3)
+    t = np.atleast_1d(t)
+    beta = beta_cc(t, s)
+    beta[t >= 28] = np.pow(beta[t >= 28], 2 / 3)
+    return beta
+
+
+def beta_E(t: ArrayLike, s: float) -> ArrayLike:
+    """The time development function for Young's modulus of concrete.
+
+    EN 1992-1-1:2004, part of Eq. (3.5).
+
+    Args:
+        t (ArrayLike): The time in days to evaluate the development function
+            for.
+        s (float): The scale factor in the exponent for the time development
+            function. s = 0.20 for class R, 0.25 for class N, and 0.38 for
+            class N.
+
+    Returns:
+        ArrayLike: The value of the time development function.
+    """
+    return np.pow(beta_cc(t, s), 0.3)
+
+
+def s_time_development(cement_class: t.Literal['S', 'N', 'R']) -> float:
+    """Return the scale factor for the exponent for the time development
+    function.
+
+    EN 1992-1-1:2004, Eq. (3.2).
+
+    Args:
+        cement_class (str): The cement class, either 'S', 'N' or 'R'.
+
+    Returns:
+        float: The scale factor that depends on the cement type.
+
+    Raises:
+        ValueError: If an invalid cement class is provided.
+
+    """
+    cement_class = (
+        cement_class.upper().strip() if cement_class is not None else ''
+    )
+    s = S_TIME_DEVELOPMENT_DICT.get(cement_class)
+
+    if s is None:
+        raise ValueError(
+            (
+                f'"{cement_class}" is not a valid cement class. '
+                'Use either S, N or R.'
+            )
+        )
+    return s
+
+
+def fcm_time(fcm: float, beta_cc: ArrayLike) -> ArrayLike:
+    """Calculate the compressive strength as function of time.
+
+    EN 1992-1-1:2004, Eq. (3.1).
+
+    Args:
+        fcm (float): The reference value for the compressive strength.
+        beta_cc (ArrayLike): The value(s) of the time development function.
+
+    Returns:
+        ArrayLike: The calculated value(s) of the compressive strength.
+
+    Note:
+        The value of beta_cc should be calculated with the function beta_cc.
+    """
+    return fcm * beta_cc
+
+
+def fctm_time(fctm: float, beta_cc: ArrayLike, alpha: ArrayLike) -> ArrayLike:
+    """Calculate the tensile strength as function of time.
+
+    EN 1992-1-1:2004, Eq. (3.4).
+
+    Args:
+        fctm (float): The reference value for the tensile strength.
+        beta_cc (ArrayLike): The value(s) of the time development function.
+        alpha (ArrayLike): An exponent for the time development function. It
+            should be set to 1 for t < 28, and 2/3 else.
+
+    Returns:
+        ArrayLike: The calculated value(s) of the tensile strength.
+
+    Note:
+        The value of beta_cc should be calculated with the function beta_cc.
+        Alternatively, the time development function for the tensile strength
+        could be calculated directly with the function beta_ct.
+    """
+    return np.pow(beta_cc, alpha) * fctm
+
+
+def Ecm_time(fcm: float, fcm_time: ArrayLike, Ecm: float) -> ArrayLike:
+    """Calculate the Young's modulus as function of time.
+
+    EN 1992-1-1:2004, Eq. (3.5).
+
+    Args:
+        fcm (float): The reference value for the compressive strength.
+        fcm_time (float): The value(s) of the compressive strength at the
+            point(s) in time.
+        Ecm (float): The reference value for the Young's modulus.
+
+    Returns:
+        ArrayLike: The calculated value(s) of the Young's modulus.
+
+    Note:
+        The value of fcm_time should be calculated with the function fcm_time.
+        Alternatively, the time development function for the Young's modulus
+        could be calculated directly with the function beta_E.
+    """
+    return np.pow(fcm_time / fcm, 0.3) * Ecm

structuralcodes-0.6.3/structuralcodes/codes/ec2_2004/_cracking_restraint_imposed_deformations.py

@@ -0,0 +1,41 @@
+"""Collection of functions from EUROCODE 1992-3:2006."""
+
+
+def eps_sm_eps_cm_restraint_end(
+    alpha_e: float,
+    rho_p_eff: float,
+    kc: float,
+    k: float,
+    fct_eff: float,
+    Es: float,
+) -> float:
+    """Returns the strain difference (epsilon_sm - epsilon_cm) needed to
+    compute the crack width for restraint member at its end.
+
+    EN 1992-3:2006, Eq. (M.1).
+
+    Args:
+        alpha_e (float): Is the ratio Es/Ecm.
+        rho_p_eff (float): Effective bond ratio between areas given by Eq.
+            (7.10).
+        kc (float): is a coefficient which takes account of the stress
+            distribution within the section immediately prior to cracking and
+            the change of the lever arm.
+        k (float): is the coefficient which allow for the effect of
+            non-uniform self-equilibrating stresses, which lead to a
+            reduction of restraint forces.
+            k=1 for webs w<=300mm or flanges widths less than 300mm
+            k=0.65 for webs w>=800mm or flanges with widths greater than 800mm
+            Intermediate values may be interpolated.
+        fct_eff (float): Is the mean value of the tensile strength in MPa of
+            the concrete effective at the time when the cracks may first be
+            expected to occur: fct_eff=fctm or fctm(t) if crack is expected
+            earlier than 28 days.
+        Es (float): Steel elastic modulus in MPa.
+
+    Returns:
+        float: The calculated strain difference.
+    """
+    return (
+        0.5 * alpha_e * kc * k * fct_eff * (1 + 1 / (alpha_e * rho_p_eff)) / Es
+    )

{structuralcodes-0.6.1 → structuralcodes-0.6.3}/structuralcodes/core/_section_results.py

@@ -4,6 +4,7 @@ from __future__ import annotations  # To have clean hints of ArrayLike in docs
 
 from dataclasses import dataclass, field, fields
 
+import numpy as np
 from numpy.typing import ArrayLike
 
 
@@ -125,6 +126,24 @@ class SectionProperties:
         """
         return f'{self}'
 
+    def isclose(self, other, rtol=1e-5, atol=1e-8):
+        """Check if two SectionProperties are close to each other.
+
+        Arguments:
+            other (SectionProperties): The other SectionProperties to compare.
+            rtol (float): The relative tolerance.
+            atol (float): The absolute tolerance.
+
+        Returns:
+            bool: True if the two SectionProperties are close, False otherwise.
+        """
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+
+        a = np.array(list(vars(self).values()))
+        b = np.array(list(vars(other).values()))
+        return np.allclose(a, b, rtol=rtol, atol=atol)
+
 
 @dataclass
 class MomentCurvatureResults:

{structuralcodes-0.6.1 → structuralcodes-0.6.3}/structuralcodes/materials/basic/_elastic.py

@@ -15,6 +15,9 @@ class ElasticMaterial(Material):
         self,
         E: float,
         density: float,
+        ultimate_strain: t.Optional[
+            t.Union[float, t.Tuple[float, float]]
+        ] = None,
         initial_strain: t.Optional[float] = None,
         initial_stress: t.Optional[float] = None,
         strain_compatibility: t.Optional[float] = None,
@@ -25,6 +28,13 @@ class ElasticMaterial(Material):
         Arguments:
             E (float): The Young's modulus.
             density (float): The density.
+            ultimate_strain (Optional[float, Tuple[float, float]]): The
+                ultimate strain of the material. If a single float is given,
+                it is used for both the positive and negative directions. If a
+                tuple of two floats is given, the first value is used for the
+                negative direction and the second value is used for the
+                positive direction. If None, the material has no ultimate
+                strain. Default value is None.
             initial_strain (Optional[float]): Initial strain of the material.
             initial_stress (Optional[float]): Initial stress of the material.
             strain_compatibility (Optional[bool]): Only relevant if
@@ -42,6 +52,7 @@ class ElasticMaterial(Material):
             name=name if name else 'ElasticMaterial',
         )
         self._E = E
+        self._ultimate_strain = ultimate_strain
         self._constitutive_law = create_constitutive_law('elastic', self)
         self._apply_initial_strain()
 
@@ -52,7 +63,7 @@ class ElasticMaterial(Material):
 
     def __elastic__(self) -> dict:
         """Returns kwargs for creating an elastic constitutive law."""
-        return {'E': self.E}
+        return {'E': self.E, 'eps_u': self._ultimate_strain}
 
     @classmethod
     def from_material(cls, other_material: Material):

{structuralcodes-0.6.1 → structuralcodes-0.6.3}/structuralcodes/materials/concrete/_concreteEC2_2004.py

@@ -392,11 +392,11 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
             float: The maximum strength at failure of concrete.
 
         Note:
-            The returned value is derived from fcm if eps_cu1 is not manually
+            The returned value is derived from fck if eps_cu1 is not manually
             provided when initializing the object.
         """
         if self._eps_cu1 is None:
-            return ec2_2004.eps_cu1(self.fcm)
+            return ec2_2004.eps_cu1(self.fck)
         return self._eps_cu1
 
     @property

{structuralcodes-0.6.1 → structuralcodes-0.6.3}/structuralcodes/materials/constitutive_laws/__init__.py

@@ -8,6 +8,7 @@ from ._elastic import Elastic
 from ._elasticplastic import ElasticPlastic
 from ._initial_strain import InitialStrain
 from ._parabolarectangle import ParabolaRectangle
+from ._parallel import Parallel
 from ._popovics import Popovics
 from ._sargin import Sargin
 from ._userdefined import UserDefined
@@ -21,6 +22,7 @@ __all__ = [
     'Sargin',
     'UserDefined',
     'InitialStrain',
+    'Parallel',
     'get_constitutive_laws_list',
     'create_constitutive_law',
 ]

{structuralcodes-0.6.1 → structuralcodes-0.6.3}/structuralcodes/materials/constitutive_laws/_elastic.py

@@ -19,7 +19,12 @@ class Elastic(ConstitutiveLaw):
         'rebars',
     )
 
-    def __init__(self, E: float, name: t.Optional[str] = None) -> None:
+    def __init__(
+        self,
+        E: float,
+        name: t.Optional[str] = None,
+        eps_u: t.Optional[t.Union[float, t.Tuple[float, float]]] = None,
+    ) -> None:
         """Initialize an Elastic Material.
 
         Arguments:
@@ -27,11 +32,20 @@ class Elastic(ConstitutiveLaw):
 
         Keyword Arguments:
             name (str): A descriptive name for the constitutive law.
+            eps_u (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). Default value = None.
         """
         name = name if name is not None else 'ElasticLaw'
         super().__init__(name=name)
         self._E = E
-        self._eps_su = None
+        if E <= 0:
+            raise ValueError('Elastic modulus should be greater than 0')
+        if eps_u is not None:
+            self._set_ultimate_strain(eps_u)
+        else:
+            self._eps_u = None
 
     def get_stress(
         self, eps: t.Union[float, ArrayLike]
@@ -91,12 +105,12 @@ class Elastic(ConstitutiveLaw):
     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
+        # unless specified by the user differently
         del kwargs
-        return self._eps_su or (-100, 100)
+        return self._eps_u or (-100, 100)
 
-    def set_ultimate_strain(
-        self, eps_su=t.Union[float, t.Tuple[float, float]]
+    def _set_ultimate_strain(
+        self, eps_u=t.Union[float, t.Tuple[float, float]]
     ) -> None:
         """Set ultimate strains for Elastic Material if needed.
 
@@ -106,26 +120,26 @@ class Elastic(ConstitutiveLaw):
                 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:
+        if isinstance(eps_u, float):
+            self._eps_u = (-abs(eps_u), abs(eps_u))
+        elif isinstance(eps_u, tuple):
+            if len(eps_u) < 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:
+            eps_u_n = eps_u[0]
+            eps_u_p = eps_u[1]
+            if eps_u_p < eps_u_n:
+                eps_u_p, eps_u_n = eps_u_n, eps_u_p
+            if eps_u_p < 0:
                 raise ValueError(
                     'Positive ultimate strain should be non-negative'
                 )
-            if eps_su_n > 0:
+            if eps_u_n > 0:
                 raise ValueError(
                     'Negative utimate strain should be non-positive'
                 )
-            self._eps_su = (eps_su_n, eps_su_p)
+            self._eps_u = (eps_u_n, eps_u_p)
         else:
             raise ValueError(
                 'set_ultimate_strain requires a single value or a tuple \