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

structuralcodes/materials/constitutive_laws/__init__.py

@@ -61,24 +61,25 @@ def create_constitutive_law(
 
         If the consitutive law selected is not available for the specific
         material, an exception will be raised.
+
+    Raises:
+        ValueError: If the constitutive law is not available for the material.
+        ValueError: If the constitutive law name is unknown.
     """
-    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):
+        if hasattr(material, method_name) and callable(
+            getattr(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
+            # get the kwargs from the special dunder method
+            kwargs = method()
+            # create and return the constitutive law
+            return const_law(**kwargs)
+        raise ValueError(
+            f'Constitutive law {constitutive_law_name} not available for'
+            f' material {material.__class__.__name__}'
+        )
+    raise ValueError(f'Unknown constitutive law: {constitutive_law_name}')

structuralcodes/materials/reinforcement/_reinforcement.py

@@ -4,10 +4,6 @@ import abc
 import typing as t
 
 from structuralcodes.core.base import ConstitutiveLaw, Material
-from structuralcodes.materials.constitutive_laws import (
-    ElasticPlastic,
-    create_constitutive_law,
-)
 
 
 class Reinforcement(Material):
@@ -39,45 +35,21 @@ class Reinforcement(Material):
         self._epsuk = abs(epsuk)
         self._gamma_s = gamma_s
 
-        # Calculate the plastic hardening modulus
-        if self.epsuk - self.fyk / self.Es > 0.0 and self.ftk - self.fyk > 0:
-            Eh = (self.ftk - self.fyk) / (self.epsuk - self.fyk / self.Es)
-        else:
-            Eh = 0.0
-        self._constitutive_law = ElasticPlastic(
-            E=self.Es, fy=self.fyd(), Eh=Eh, eps_su=self.epsud()
-        )
-
     @property
     def fyk(self) -> float:
         """Returns fyk in MPa."""
         return self._fyk
 
-    @fyk.setter
-    def fyk(self, fyk: float) -> None:
-        """Setter for fyk (in MPa)."""
-        self._fyk = abs(fyk)
-
     @property
     def Es(self) -> float:
         """Returns Es in MPa."""
         return self._Es
 
-    @Es.setter
-    def Es(self, Es: float) -> None:
-        """Setter for Es (in MPa)."""
-        self._Es = abs(Es)
-
     @property
     def ftk(self) -> float:
         """Returns ftk in MPa."""
         return self._ftk
 
-    @ftk.setter
-    def ftk(self, ftk: float) -> None:
-        """Setter for ftk (in MPa)."""
-        self._ftk = abs(ftk)
-
     @property
     def epsuk(self) -> float:
         """Returns epsuk."""
@@ -98,49 +70,6 @@ class Reinforcement(Material):
         """Returns the constitutive law object."""
         return self._constitutive_law
 
-    @constitutive_law.setter
-    def constitutive_law(
-        self,
-        constitutive_law: t.Union[
-            ConstitutiveLaw,
-            t.Literal[
-                'elastic',
-                'elasticperfecltyplastic',
-                'elasticplastic',
-            ],
-        ],
-    ) -> None:
-        """Setter for constitutive law.
-
-        Arguments:
-            consitutive_law (ConstitutiveLaw | str): a valid ConstitutiveLaw
-                object for reinforcement or  a string defining a valid
-                constitutive law type for reinforcement. (valid options:
-                'elastic', 'elasticperfectlyplastic', 'elasticplastic').
-        """
-        if constitutive_law is None:
-            raise ValueError(
-                'At least a constitutive law or a string defining the '
-                'constitutive law must be provided.'
-            )
-        if isinstance(constitutive_law, str):
-            constitutive_law = create_constitutive_law(
-                constitutive_law_name=constitutive_law, material=self
-            )
-
-        if isinstance(constitutive_law, ConstitutiveLaw):
-            if 'rebars' in constitutive_law.__materials__:
-                self._constitutive_law = constitutive_law
-            else:
-                raise ValueError(
-                    'The constitutive law selected is not suitable '
-                    'for being used with a Reinforcement material.'
-                )
-        else:
-            raise ValueError(
-                f'The constitutive law {constitutive_law} could not be created'
-            )
-
     @property
     @abc.abstractmethod
     def gamma_s(self) -> float:

structuralcodes/materials/reinforcement/_reinforcementEC2_2004.py

@@ -4,6 +4,7 @@ import typing as t
 
 from structuralcodes.codes import ec2_2004
 
+from ..constitutive_laws import ConstitutiveLaw, create_constitutive_law
 from ._reinforcement import Reinforcement
 
 
@@ -20,6 +21,16 @@ class ReinforcementEC2_2004(Reinforcement):  # noqa: N801
         gamma_eps: t.Optional[float] = None,
         name: t.Optional[str] = None,
         density: float = 7850.0,
+        constitutive_law: t.Optional[
+            t.Union[
+                t.Literal[
+                    'elastic',
+                    'elasticperfectlyplastic',
+                    'elasticplastic',
+                ],
+                ConstitutiveLaw,
+            ]
+        ] = 'elasticplastic',
     ):
         """Initializes a new instance of Reinforcement for EC2 2004.
 
@@ -33,13 +44,25 @@ class ReinforcementEC2_2004(Reinforcement):  # noqa: N801
                 Default value is 1.15.
 
         Keyword Arguments:
+            gamma_eps (float): The partial factor for ultimate strain. Default
+                value is 0.9.
             name (str): A descriptive name for the reinforcement.
             density (float): Density of material in kg/m3 (default: 7850).
+            constitutive_law (ConstitutiveLaw | str): A valid ConstitutiveLaw
+                object for reinforcement or a string defining a valid
+                constitutive law type for reinforcement. (valid options for
+                string: 'elastic', 'elasticplastic', or
+                'elasticperfectlyplastic').
+
+        Raises:
+            ValueError: If the constitutive law name is not available for the
+                material.
+            ValueError: If the provided constitutive law is not valid for
+                reinforcement.
         """
         if name is None:
             name = f'Reinforcement{round(fyk):d}'
 
-        self._gamma_eps = gamma_eps
         super().__init__(
             fyk=fyk,
             Es=Es,
@@ -49,6 +72,18 @@ class ReinforcementEC2_2004(Reinforcement):  # noqa: N801
             epsuk=epsuk,
             gamma_s=gamma_s,
         )
+        self._gamma_eps = gamma_eps
+        self._constitutive_law = (
+            constitutive_law
+            if isinstance(constitutive_law, ConstitutiveLaw)
+            else create_constitutive_law(
+                constitutive_law_name=constitutive_law, material=self
+            )
+        )
+        if 'steel' not in self._constitutive_law.__materials__:
+            raise ValueError(
+                'The provided constitutive law is not valid for reinforcement.'
+            )
 
     def fyd(self) -> float:
         """The design yield strength."""
@@ -94,7 +129,7 @@ class ReinforcementEC2_2004(Reinforcement):  # noqa: N801
         """Returns kwargs for ElasticPlastic constitutive law with strain
         hardening.
         """
-        Eh = (self.ftd() - self.fyd()) / (self.epsuk - self.epsyd)
+        Eh = (self.ftd() - self.fyd()) / (self.epsud() - self.epsyd)
         return {
             'E': self.Es,
             'fy': self.fyd(),

structuralcodes/materials/reinforcement/_reinforcementEC2_2023.py

@@ -4,6 +4,7 @@ import typing as t
 
 from structuralcodes.codes import ec2_2023
 
+from ..constitutive_laws import ConstitutiveLaw, create_constitutive_law
 from ._reinforcement import Reinforcement
 
 
@@ -19,6 +20,16 @@ class ReinforcementEC2_2023(Reinforcement):  # noqa: N801
         gamma_s: t.Optional[float] = None,
         name: t.Optional[str] = None,
         density: float = 7850.0,
+        constitutive_law: t.Optional[
+            t.Union[
+                t.Literal[
+                    'elastic',
+                    'elasticperfectlyplastic',
+                    'elasticplastic',
+                ],
+                ConstitutiveLaw,
+            ]
+        ] = 'elasticplastic',
     ):
         """Initializes a new instance of Reinforcement for EC2 2023.
 
@@ -34,6 +45,17 @@ class ReinforcementEC2_2023(Reinforcement):  # noqa: N801
         Keyword Args:
             name (str): A descriptive name for the reinforcement.
             density (float): Density of material in kg/m3 (default: 7850).
+            constitutive_law (ConstitutiveLaw | str): A valid ConstitutiveLaw
+                object for reinforcement or a string defining a valid
+                constitutive law type for reinforcement. (valid options for
+                string: 'elastic', 'elasticplastic', or
+                'elasticperfectlyplastic').
+
+        Raises:
+            ValueError: If the constitutive law name is not available for the
+                material.
+            ValueError: If the provided constitutive law is not valid for
+                reinforcement.
         """
         if name is None:
             name = f'Reinforcement{round(fyk):d}'
@@ -46,6 +68,17 @@ class ReinforcementEC2_2023(Reinforcement):  # noqa: N801
             epsuk=epsuk,
             gamma_s=gamma_s,
         )
+        self._constitutive_law = (
+            constitutive_law
+            if isinstance(constitutive_law, ConstitutiveLaw)
+            else create_constitutive_law(
+                constitutive_law_name=constitutive_law, material=self
+            )
+        )
+        if 'steel' not in self._constitutive_law.__materials__:
+            raise ValueError(
+                'The provided constitutive law is not valid for reinforcement.'
+            )
 
     def fyd(self) -> float:
         """The design yield strength."""
@@ -84,7 +117,7 @@ class ReinforcementEC2_2023(Reinforcement):  # noqa: N801
         """Returns kwargs for ElasticPlastic constitutive law with strain
         hardening.
         """
-        Eh = (self.ftd() - self.fyd()) / (self.epsuk - self.epsyd)
+        Eh = (self.ftd() - self.fyd()) / (self.epsud() - self.epsyd)
         return {
             'E': self.Es,
             'fy': self.fyd(),

structuralcodes/materials/reinforcement/_reinforcementMC2010.py

@@ -4,6 +4,7 @@ import typing as t
 
 from structuralcodes.codes import mc2010
 
+from ..constitutive_laws import ConstitutiveLaw, create_constitutive_law
 from ._reinforcement import Reinforcement
 
 
@@ -20,6 +21,16 @@ class ReinforcementMC2010(Reinforcement):
         gamma_eps: t.Optional[float] = None,
         name: t.Optional[str] = None,
         density: float = 7850.0,
+        constitutive_law: t.Optional[
+            t.Union[
+                t.Literal[
+                    'elastic',
+                    'elasticperfectlyplastic',
+                    'elasticplastic',
+                ],
+                ConstitutiveLaw,
+            ]
+        ] = 'elasticplastic',
     ):
         """Initializes a new instance of Reinforcement for MC2010.
 
@@ -33,12 +44,25 @@ class ReinforcementMC2010(Reinforcement):
                 Default value is 1.15.
 
         Keyword Args:
+            gamma_eps (float): The partial factor for ultimate strain. Default
+                value is 0.9.
             name (str): A descriptive name for the reinforcement.
             density (float): Density of material in kg/m3 (default: 7850).
+            constitutive_law (ConstitutiveLaw | str): A valid ConstitutiveLaw
+                object for reinforcement or a string defining a valid
+                constitutive law type for reinforcement. (valid options for
+                string: 'elastic', 'elasticplastic', or
+                'elasticperfectlyplastic').
+
+        Raises:
+            ValueError: If the constitutive law name is not available for the
+                material.
+            ValueError: If the provided constitutive law is not valid for
+                reinforcement.
         """
         if name is None:
             name = f'Reinforcement{round(fyk):d}'
-        self._gamma_eps = gamma_eps
+
         super().__init__(
             fyk=fyk,
             Es=Es,
@@ -48,6 +72,18 @@ class ReinforcementMC2010(Reinforcement):
             epsuk=epsuk,
             gamma_s=gamma_s,
         )
+        self._gamma_eps = gamma_eps
+        self._constitutive_law = (
+            constitutive_law
+            if isinstance(constitutive_law, ConstitutiveLaw)
+            else create_constitutive_law(
+                constitutive_law_name=constitutive_law, material=self
+            )
+        )
+        if 'steel' not in self._constitutive_law.__materials__:
+            raise ValueError(
+                'The provided constitutive law is not valid for reinforcement.'
+            )
 
     def fyd(self) -> float:
         """The design yield strength."""
@@ -89,7 +125,7 @@ class ReinforcementMC2010(Reinforcement):
         """Returns kwargs for ElasticPlastic constitutive law with strain
         hardening.
         """
-        Eh = (self.ftd() - self.fyd()) / (self.epsuk - self.epsyd)
+        Eh = (self.ftd() - self.fyd()) / (self.epsud() - self.epsyd)
         return {
             'E': self.Es,
             'fy': self.fyd(),

structuralcodes/sections/_generic.py

@@ -19,7 +19,7 @@ from structuralcodes.geometry import (
     PointGeometry,
     SurfaceGeometry,
 )
-from structuralcodes.materials.constitutive_laws import Elastic
+from structuralcodes.materials.basic import ElasticMaterial
 
 from .section_integrators import SectionIntegrator, integrator_factory
 
@@ -42,6 +42,8 @@ class GenericSection(Section):
             strength, moment curvature, etc.).
     """
 
+    geometry: CompoundGeometry
+
     def __init__(
         self,
         geometry: t.Union[SurfaceGeometry, CompoundGeometry],
@@ -96,6 +98,7 @@ class GenericSectionCalculator(SectionCalculator):
     """Calculator class implementing analysis algorithms for code checks."""
 
     integrator: SectionIntegrator
+    section: GenericSection
 
     def __init__(
         self,
@@ -155,13 +158,17 @@ class GenericSectionCalculator(SectionCalculator):
         # Computation of surface area, reinforcement area, EA (axial rigidity)
         # and mass: Morten -> problem with units! how do we deal with it?
         for geo in self.section.geometry.geometries:
-            gp.ea += geo.area * geo.material.get_tangent(eps=0)
+            gp.ea += geo.area * geo.material.constitutive_law.get_tangent(
+                eps=0
+            )
             if geo.density is not None:
                 # this assumes area in mm2 and density in kg/m3
                 gp.mass += geo.area * geo.density * 1e-9
 
         for geo in self.section.geometry.point_geometries:
-            gp.ea += geo.area * geo.material.get_tangent(eps=0)
+            gp.ea += geo.area * geo.material.constitutive_law.get_tangent(
+                eps=0
+            )
             gp.area_reinforcement += geo.area
             if geo.density is not None:
                 # this assumes area in mm2 and density in kg/m3
@@ -237,7 +244,7 @@ class GenericSectionCalculator(SectionCalculator):
 
         # Create a dummy material for integration of area moments
         # This is used for J, S etc, not for E_J E_S etc
-        dummy_mat = Elastic(E=1)
+        dummy_mat = ElasticMaterial(E=1, density=1)
         # Computation of moments of area (material-independet)
         # Note: this could be un-meaningfull when many materials
         # are combined
@@ -309,15 +316,40 @@ class GenericSectionCalculator(SectionCalculator):
         chi_min = 1e10
         for g in geom.geometries + geom.point_geometries:
             for other_g in geom.geometries + geom.point_geometries:
+                # This is left on purpose: even if tempted we should not do
+                # this check:
                 # if g != other_g:
-                eps_p = g.material.get_ultimate_strain(yielding=yielding)[1]
+                eps_p = g.material.constitutive_law.get_ultimate_strain(
+                    yielding=yielding
+                )[1]
                 if isinstance(g, SurfaceGeometry):
                     y_p = g.polygon.bounds[1]
                 elif isinstance(g, PointGeometry):
                     y_p = g._point.coords[0][1]
-                eps_n = other_g.material.get_ultimate_strain(
-                    yielding=yielding
+                # Check if the section is a reinforced concrete section:
+                # If it is, we need to obtain the "yield" strain of concrete
+                # (-0.002 for default parabola-rectangle concrete)
+                # If the geometry is not concrete, don't get the yield strain
+                # If it is not a reinforced concrete section, return
+                # the yield strain if asked.
+                is_rc_section = self.section.geometry.reinforced_concrete
+                is_concrete_geom = (
+                    isinstance(other_g, SurfaceGeometry) and other_g.concrete
+                )
+
+                use_yielding = (
+                    yielding
+                    if (
+                        (is_rc_section and is_concrete_geom)
+                        or (not is_rc_section)
+                    )
+                    else False
+                )
+
+                eps_n = other_g.material.constitutive_law.get_ultimate_strain(
+                    yielding=use_yielding
                 )[0]
+
                 if isinstance(other_g, SurfaceGeometry):
                     y_n = other_g.polygon.bounds[3]
                 elif isinstance(other_g, PointGeometry):
@@ -439,12 +471,18 @@ class GenericSectionCalculator(SectionCalculator):
         apply the bisection algorithm.
         """
         ITMAX = 20
+        MAXRESTATTEMPTS = 20
         sign = -1 if dn_a > 0 else 1
         found = False
         it = 0
+        restarts = 0
         delta = 1e-3
-        while not found and it < ITMAX:
-            eps_0_b = eps_0_a + sign * delta * (it + 1)
+        # Use a growth factor for an exponential finding
+        r = 2.0
+        diverging = False
+        diverging_steps = 0
+        while not found and it < ITMAX and restarts < MAXRESTATTEMPTS:
+            eps_0_b = eps_0_a + sign * delta * r ** (it)
             (
                 n_int,
                 _,
@@ -457,10 +495,20 @@ class GenericSectionCalculator(SectionCalculator):
             if dn_a * dn_b < 0:
                 found = True
             elif abs(dn_b) > abs(dn_a):
-                # we are driving aay from the solution, probably due
+                # we are driving away from the solution, probably due
                 # to failure of a material
-                delta /= 2
-                it -= 1
+                diverging = True
+                if diverging:
+                    # Count for how many steps we are diverging
+                    diverging_steps += 1
+                # If we are consistently diverging for more than 10 steps,
+                # Restart the process with a small delta
+                if diverging_steps > 10:
+                    delta /= 2
+                    it = 0
+                    restarts += 1
+                    diverging = False
+                    diverging_steps = 0
             it += 1
         if it >= ITMAX and not found:
             s = f'Last iteration reached a unbalance of: \
@@ -567,14 +615,20 @@ class GenericSectionCalculator(SectionCalculator):
 
     @property
     def n_min(self) -> float:
-        """Return minimum axial load."""
+        """Return minimum axial load.
+
+        In most situations, this is the capacity in compression.
+        """
         if self._n_min is None:
             self._n_min, self._n_max = self.calculate_limit_axial_load()
         return self._n_min
 
     @property
     def n_max(self) -> float:
-        """Return maximum axial load."""
+        """Return maximum axial load.
+
+        In most situations, this is the capacity in tension.
+        """
         if self._n_max is None:
             self._n_min, self._n_max = self.calculate_limit_axial_load()
         return self._n_max
@@ -631,7 +685,7 @@ class GenericSectionCalculator(SectionCalculator):
             matrix then `integrate='modulus'`.
 
         Examples:
-            result = self.integrate_strain_profile(strain,integrate='tangent')
+            result = self.integrate_strain_profile(strain,integrate='modulus')
             # `result` will be the tangent stiffness matrix (a 3x3 numpy array)
 
             result = self.integrate_strain_profile(strain)
@@ -678,6 +732,9 @@ class GenericSectionCalculator(SectionCalculator):
         Returns:
             UltimateBendingMomentResults: The results from the calculation.
         """
+        # Check if the section can carry the axial load
+        self.check_axial_load(n=n)
+
         # Compute the bending strength with the bisection algorithm
         # Rotate the section of angle theta
         rotated_geom = self.section.geometry.rotate(-theta)
@@ -685,8 +742,6 @@ class GenericSectionCalculator(SectionCalculator):
             # Rotate also triangulated data!
             self._rotate_triangulated_data(-theta)
 
-        # Check if the section can carry the axial load
-        self.check_axial_load(n=n)
         # Find the strain distribution corresponding to failure and equilibrium
         # with external axial force
         strain = self.find_equilibrium_fixed_pivot(rotated_geom, n)
@@ -752,6 +807,9 @@ class GenericSectionCalculator(SectionCalculator):
         Returns:
             MomentCurvatureResults: The calculation results.
         """
+        # Check if the section can carry the axial load
+        self.check_axial_load(n=n)
+
         # Create an empty response object
         res = s_res.MomentCurvatureResults()
         res.n = n
@@ -761,9 +819,6 @@ class GenericSectionCalculator(SectionCalculator):
             # Rotate also triangulated data!
             self._rotate_triangulated_data(-theta)
 
-        # Check if the section can carry the axial load
-        self.check_axial_load(n=n)
-
         if chi is None:
             # Find ultimate curvature from the strain distribution
             # corresponding to failure and equilibrium with external axial
@@ -1342,7 +1397,7 @@ class GenericSectionCalculator(SectionCalculator):
             n (float): Axial load.
             my (float): Bending moment around y-axis.
             mz (float): Bending moment around z-axis.
-            initial (bool): If True the modified newton with initial tanget is
+            initial (bool): If True the modified newton with initial tangent is
                 used (default = False).
             max_iter (int): the maximum number of iterations in the iterative
                 process (default = 10).

structuralcodes/sections/_rc_utils.py

@@ -4,7 +4,8 @@ import typing as t
 
 import structuralcodes.core._section_results as s_res
 from structuralcodes.geometry import CompoundGeometry, SurfaceGeometry
-from structuralcodes.materials.constitutive_laws import Elastic, UserDefined
+from structuralcodes.materials.basic import ElasticMaterial, GenericMaterial
+from structuralcodes.materials.constitutive_laws import UserDefined
 from structuralcodes.sections import GenericSection
 from structuralcodes.sections.section_integrators import FiberIntegrator
 
@@ -57,13 +58,22 @@ def calculate_elastic_cracked_properties(
     rotated_geometry = section.geometry.rotate(-theta)
 
     for geo in rotated_geometry.geometries:
-        Ec = geo.material.get_tangent(eps=0)
-        elastic_concrete = UserDefined([-100, 0], [-100 * Ec, 0])
+        Ec = geo.material.constitutive_law.get_tangent(eps=0)
+        density = geo.material.density
+        elastic_concrete_law = UserDefined([-100, 0], [-100 * Ec, 0])
+        elastic_concrete = GenericMaterial(
+            density=density,
+            constitutive_law=elastic_concrete_law,
+            name='elastic concrete',
+        )
         geo._material = elastic_concrete
 
     for pg in rotated_geometry.point_geometries:
-        Es = pg.material.get_tangent(eps=0)
-        elastic_steel = Elastic(Es, 'elastic steel')
+        Es = pg.material.constitutive_law.get_tangent(eps=0)
+        density = pg.material.density
+        elastic_steel = ElasticMaterial(
+            E=Es, density=density, name='elastic steel'
+        )
         pg._material = elastic_steel
 
     curv = -1e-5  # Any curvature should return the same mechanical properties.