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

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)

structuralcodes/materials/constitutive_laws/_sargin.py

@@ -0,0 +1,115 @@
+"""Sargin 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 Sargin(ConstitutiveLaw):
+    """Class for Sargin constitutive law.
+
+    The stresses and strains are assumed negative in compression and positive
+    in tension.
+
+    References:
+    Sargin, M. (1971), "Stress-strain relationship for concrete and the
+    analysis of structural concrete section, Study No. 4,
+    Solid Mechanics Division, University of Waterloo, Ontario, Canada
+    """
+
+    __materials__: t.Tuple[str] = ('concrete',)
+
+    def __init__(
+        self,
+        fc: float,
+        eps_c1: float = -0.0023,
+        eps_cu1: float = -0.0035,
+        k: float = 2.04,
+        name: t.Optional[str] = None,
+    ) -> None:
+        """Initialize a Sargin Material.
+
+        Arguments:
+            fc (float): The strength of concrete in compression
+
+        Keyword Arguments:
+            eps_c1 (float): Peak strain of concrete in compression. Default
+                value = -0.0023.
+            eps_u (float): Ultimate strain of concrete in compression. Default
+                value = -0.0035.
+            k (float): Plasticity number. Default value = 2.04.
+            name (str): A name for the constitutive law.
+
+        Raises:
+            ValueError: If k is less or equal to 0.
+
+        Note:
+            If positive values are input for fc, eps_c1 and eps_cu1 are input,
+            they will be assumed negative.
+        """
+        name = name if name is not None else 'SarginLaw'
+        super().__init__(name=name)
+        self._fc = -abs(fc)
+        self._eps_c1 = -abs(eps_c1)
+        self._eps_cu1 = -abs(eps_cu1)
+        self._k = k
+
+    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
+        # Polynomial branch
+        eta = eps / self._eps_c1
+
+        sig = self._fc * (self._k * eta - eta**2) / (1 + (self._k - 2) * eta)
+
+        # Elsewhere stress is 0.0
+        if np.isscalar(eps):
+            if eps < self._eps_cu1 or eps > 0:
+                return 0.0
+        else:
+            sig[eps < self._eps_cu1] = 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)
+        # polynomial branch
+        eta = eps / self._eps_c1
+
+        tangent = (
+            self._fc
+            / self._eps_c1
+            * ((2 - self._k) * eta**2 - 2 * eta + self._k)
+            / (1 + (self._k - 2) * eta) ** 2
+        )
+        # Elsewhere tangent is zero
+        if np.isscalar(eps):
+            if eps < self._eps_cu1 or eps > 0:
+                return 0
+        else:
+            tangent[eps < self._eps_cu1] = 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_c1, 100)
+        return (self._eps_cu1, 100)

structuralcodes/materials/constitutive_laws/_userdefined.py

@@ -0,0 +1,218 @@
+"""User defined 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 UserDefined(ConstitutiveLaw):
+    """Class for a user defined constitutive law.
+
+    The curve is defined with positive and optionally negative values. After
+    the last value, the stress can go to zero to simulate failure (default), or
+    be maintained constante, or the last tanget or secant values may be
+    maintained indefinetely. The flag parameter controls this behavior.
+    """
+
+    __materials__: t.Tuple[str] = ('concrete', 'steel', 'rebars')
+
+    def __init__(
+        self,
+        x: ArrayLike,
+        y: ArrayLike,
+        name: t.Optional[str] = None,
+        flag: int = 0,
+    ) -> None:
+        """Initialize a UserDefined constitutive law.
+
+        Arguments:
+            x (ArrayLike): Data for strains.
+            y (ArrayLike): Data for stresses. Must be of same length as x.
+
+        Keyword Arguments:
+            name (Optional, str): A name for the constitutive law.
+            flag (Optional): A flag specifying the behavior after the last
+                point. Admissible values: 0 (default): stress drops to zero
+                after ultimate strain, 1: stress is mantained constant, 2:
+                last tangent is used, 3: last secant is used.
+        """
+        name = name if name is not None else 'UserDefinedLaw'
+        super().__init__(name=name)
+        x = np.atleast_1d(np.asarray(x))
+        y = np.atleast_1d(np.asarray(y))
+        if len(x) != len(y):
+            raise ValueError('The two arrays should have the same length')
+        if not np.any(x < 0):
+            # User provided only positive part, reflect in negative
+            self._x = np.concatenate((-np.flip(x)[:-1], x))
+            self._y = np.concatenate((-np.flip(y)[:-1], y))
+        else:
+            # User gave both positive and negative parts
+            self._x = x
+            self._y = y
+        # Define what happens after last strain
+        if flag not in (0, 1, 2, 3):
+            raise ValueError('Flag can assume values 0, 1, 2 or 3.')
+        self._ultimate_strain_p = self._x[-1]
+        self._ultimate_strain_n = self._x[0]
+        if flag in (1, 2, 3):
+            x = np.insert(self._x, 0, self._x[0] * 100)
+            x = np.append(x, self._x[-1] * 100)
+            if flag == 1:
+                y = np.insert(self._y, 0, self._y[0])
+                y = np.append(y, self._y[-1])
+            elif flag == 2:
+                tangent_p = (self._y[-1] - self._y[-2]) / (
+                    self._x[-1] - self._x[-2]
+                )
+                tangent_n = (self._y[1] - self._y[0]) / (
+                    self._x[1] - self._x[0]
+                )
+                y = np.insert(
+                    self._y, 0, (x[0] - x[1]) * tangent_n + self._y[0]
+                )
+                y = np.append(y, (x[-1] - x[-2]) * tangent_p + self._y[-1])
+            elif flag == 3:
+                secant_p = self._y[-1] / self._x[-1]
+                secant_n = self._y[0] / self._x[0]
+                y = np.insert(
+                    self._y, 0, (x[0] - x[1]) * secant_n + self._y[0]
+                )
+                y = np.append(y, (x[-1] - x[-2]) * secant_p + self._y[-1])
+            self._x = x
+            self._y = y
+
+        # Compute slope of each segment
+        self._slopes = np.diff(self._y) / np.diff(self._x)
+
+    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
+        return np.interp(eps, self._x, self._y, left=0, right=0)
+
+    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)
+
+        # Find the segment index for each x value
+        indices = np.searchsorted(self._x, eps) - 1
+
+        # Check that indices are within vlaid range
+        indices = np.clip(indices, 0, len(self._slopes) - 1)
+
+        # Get the corresponding slopes
+        tangent = self._slopes[indices]
+
+        # Elsewhere tangent is zero
+        if np.isscalar(eps):
+            if eps < self._x[0] or eps > self._x[-1]:
+                tangent = 0
+        else:
+            tangent[eps < self._x[0]] = 0.0
+            tangent[eps > self._x[-1]] = 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 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]
+                    )
+                    a0 = stiffness * (strain[0] - self._x[i]) + self._y[i]
+                    a1 = stiffness * strain[1]
+                    coeff.append((a0, a1))
+                    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]))
+                a0 = stiffness * (strain[0] - self._x[i]) + self._y[i]
+                a1 = stiffness * strain[1]
+                coeff.append((a0, a1))
+
+        return strains, coeff
+
+    def get_ultimate_strain(self, **kwargs) -> t.Tuple[float, float]:
+        """Return the ultimate strain (negative and positive)."""
+        del kwargs
+        return (self._ultimate_strain_n, self._ultimate_strain_p)
+
+    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._ultimate_strain_p = abs(eps_su)
+            self._ultimate_strain_n = -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._ultimate_strain_p = eps_su_p
+            self._ultimate_strain_n = eps_su_n
+        else:
+            raise ValueError(
+                'set_ultimate_strain requires a single value or a tuple \
+                with  two values'
+            )

structuralcodes/sections/_generic.py

@@ -55,6 +55,16 @@ class GenericSection(Section):
                 of the section.
             name (str): The name of the section.
             integrator (str): The name of the SectionIntegrator to use.
+            kwargs (dict): A collection of keyword arguments to pass on to the
+                section calculator.
+
+        Note:
+            The GenericSection uses a GenericSectionCalculator for all
+            calculations. The GenericSectionCalculator uses a SectionIntegrator
+            for integrating over the section. Any additional keyword arguments
+            used when creating the GenericSection are passed on to the
+            SectionCalculator to customize the behaviour. See
+            GenericSectionCalculator for available keyword arguments.
         """
         if name is None:
             name = 'GenericSection'
@@ -98,7 +108,7 @@ class GenericSectionCalculator(SectionCalculator):
                 (default = 'marin').
 
         Note:
-            When using 'fiber' integrator the kwarg 'mesh_size' can be used to
+            When using `fiber` integrator the kwarg `mesh_size` can be used to
             specify a dimensionless number (between 0 and 1) specifying the
             size of the resulting mesh.
         """
@@ -142,13 +152,13 @@ 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)[0]
+            gp.ea += geo.area * geo.material.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)[0]
+            gp.ea += geo.area * geo.material.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

structuralcodes/sections/section_integrators/_fiber_integrator.py

@@ -103,9 +103,7 @@ class FiberIntegrator(SectionIntegrator):
                 # define the maximum area of the triangles
                 max_area = g.area * mesh_size
                 # triangulate the geometry getting back the mesh
-                mesh = triangle.triangulate(
-                    tri, f'pq{30:.1f}Aa{max_area:.1f}o1'
-                )
+                mesh = triangle.triangulate(tri, f'pq{30:.1f}Aa{max_area}o1')
                 mat = g.material
                 # Get x and y coordinates (centroid) and area for each fiber
                 x = []

structuralcodes/sections/section_integrators/_marin_integrator.py

@@ -143,7 +143,7 @@ class MarinIntegrator(SectionIntegrator):
             strain = strain_rotated[0] + strain_rotated[1] * yp
             x.append(xp)
             y.append(yp)
-            F.append(pg.material.get_stress(strain)[0] * A)
+            F.append(pg.material.get_stress(strain) * A)
         prepared_input.append((1, np.array(x), np.array(y), np.array(F)))
 
         return angle, prepared_input

{structuralcodes-0.1.1.dist-info → structuralcodes-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: structuralcodes
-Version: 0.1.1
+Version: 0.2.0
 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.8

{structuralcodes-0.1.1.dist-info → structuralcodes-0.2.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-structuralcodes/__init__.py,sha256=4WhcwbLVv6pNyZiQjaNHUXYs0YzQTVU0kkM9EMA9ZyE,390
+structuralcodes/__init__.py,sha256=pxmTgFCzRRSx9OPXM_I5KbP045gFiNqoR_v6N1Ni7as,390
 structuralcodes/codes/__init__.py,sha256=g5xMAJ3jEZHFd0cypvZY6lMCi7XeVEntsO8zHzI2mWc,2803
-structuralcodes/codes/ec2_2004/__init__.py,sha256=_PdL9kX7qlfn9VBfqUCJQy6V9fWmIyugzIiSZczjNAA,1986
+structuralcodes/codes/ec2_2004/__init__.py,sha256=DljXFNrCGE1lZIOsgyZgJ7Xo-xUidJomDrDKyfOHcH8,2431
+structuralcodes/codes/ec2_2004/_concrete_creep_and_shrinkage.py,sha256=y4HhOpaXwNMCHh4wu4LSn14oD1ylpPNvVJOJXLxStzQ,15284
 structuralcodes/codes/ec2_2004/_concrete_material_properties.py,sha256=Ol51tzcVOHUvc2Vea24WQJ4FABxXc-9cB5RVu2N1pio,5964
 structuralcodes/codes/ec2_2004/_reinforcement_material_properties.py,sha256=_ZlvdHcOswu1Ge1XjSvt4j5ue-znDceMOlA0s528IqM,2779
 structuralcodes/codes/ec2_2004/_section_7_3_crack_control.py,sha256=a91tWQKNTxB2SpSKu0Wtm-P5GdmifRLggNlEHIQ3XMY,31981
-structuralcodes/codes/ec2_2004/annex_b_shrink_and_creep.py,sha256=kaMXZ_Ufp-k1wYQDXB27Tt2BUmi_lGYYuNzQxGtC6SQ,7348
 structuralcodes/codes/ec2_2004/shear.py,sha256=gzhgIa-EgoD9gLO_Hfa8VeCmjAxuPK0wZ0soDKC7W5w,17095
 structuralcodes/codes/ec2_2023/__init__.py,sha256=UohRxikCUqPAUpHj4uSWHw5drICjZm3zvJJw7clljo0,1618
 structuralcodes/codes/ec2_2023/_annexB_time_dependent.py,sha256=ykRAHBHzqtMSErkVA-rwTHBdUq8-L7q2AOaEd2YW5wc,472
@@ -21,31 +21,38 @@ structuralcodes/codes/mc2010/_reinforcement_material_properties.py,sha256=FELmgM
 structuralcodes/codes/mc2020/__init__.py,sha256=5hrAfBtAeG69N_lroFpG10_ZKB1SuNlKBnuHug2DI3E,174
 structuralcodes/core/__init__.py,sha256=spnvZIm_w3jX_lV-v3bloDjgHh8lrH6UHpA1Nv1zeAI,55
 structuralcodes/core/_section_results.py,sha256=hHXoS71TpSmWqw276pBeLiLrEEiMEWclOd28ArRW_Kk,8280
-structuralcodes/core/base.py,sha256=TqgsXzIXITQmER3tKNjzjPrbSN5uT_PqCpG3PVMd3Yw,8562
+structuralcodes/core/base.py,sha256=7cpDM2hvBZp9nyU714XRiMzDPNdydJqLtIHHvcXZctE,8935
 structuralcodes/geometry/__init__.py,sha256=FwzywfyGKOk6v96ZyOfyBo5iVeuK_W0TQVz5llAkYW4,559
-structuralcodes/geometry/_geometry.py,sha256=kmY7TER5yS-TVw0XY4EuwNviLuEhExtLoon8oO2TJbA,31175
+structuralcodes/geometry/_geometry.py,sha256=8usT5UfDlT-A8sMwM6Bh4YKIB9QuyAU5tGgsujeACEA,31240
 structuralcodes/geometry/_reinforcement.py,sha256=N2wTH-NoZ1fG-_vRT9gGX2Kk3zlW7CbDtl1oqS_lMv0,4144
 structuralcodes/geometry/_steel_sections.py,sha256=UdJmhhnK8r5gEfBzvWsMFHGs5gmuoOhFoduBanlRMQg,60225
 structuralcodes/materials/__init__.py,sha256=r5E5vsXVKB-BGZXTnEbsrYJbH6rr6Xlc_b4LlcUPIbc,173
-structuralcodes/materials/constitutive_laws.py,sha256=DX_yuC4OpgDCl_g3sl0Hi2ee7lFD2fy3yO4PTINKBzE,34455
 structuralcodes/materials/concrete/__init__.py,sha256=GRD5WcbYrnE4iN-L7qVkhVTi7w_PUP7pnbGueOaVeFs,2576
 structuralcodes/materials/concrete/_concrete.py,sha256=3zMTFtaqFeUl7ne7-pe9wF4LryzqvGpUwThnHTidCZU,3774
 structuralcodes/materials/concrete/_concreteEC2_2004.py,sha256=gWG3O9yeGw3UeftCjYTajZco_XYDmBxPGqhAEpH3nY0,14666
 structuralcodes/materials/concrete/_concreteEC2_2023.py,sha256=vguNzlfoPuaieTVw9T3xWU0wb230WvER4Vy1jswcdlo,14017
 structuralcodes/materials/concrete/_concreteMC2010.py,sha256=lHy-WYiVpXPwiNAyjUBxuGWuGFd0-Uirh6KiolMH4MY,15313
+structuralcodes/materials/constitutive_laws/__init__.py,sha256=r817qyeimqZyyan2mU8cVwjwMkiB--f-BOIBSzXKiZo,2954
+structuralcodes/materials/constitutive_laws/_bilinearcompression.py,sha256=mkuMSiKpfZv-meIvHedrlILfRBdOsR46QCiaiyxPxVs,4528
+structuralcodes/materials/constitutive_laws/_elastic.py,sha256=Kl-A_3W2qoJUEPE3meWABSqUlNChMExiq2LdRehbqrI,3722
+structuralcodes/materials/constitutive_laws/_elasticplastic.py,sha256=GDIIXJ93nqV-G8-o6HxXGUTd3TgNWiHQqXbULFcCGUI,6096
+structuralcodes/materials/constitutive_laws/_parabolarectangle.py,sha256=CvjmiGCmNTqxY6d5jNqCo6MAh_BUkypvv_-ZJB9JyQE,6489
+structuralcodes/materials/constitutive_laws/_popovics.py,sha256=dpXFQ9KHE245C9dgOLz9KXYHZiAYrRan5exgj0j_JxM,4322
+structuralcodes/materials/constitutive_laws/_sargin.py,sha256=WJGw0EtqkPh-d3N6vTPRIfhE1Ypyc16JpGcoi-0U1A8,3495
+structuralcodes/materials/constitutive_laws/_userdefined.py,sha256=urt0yuJicO51jnQ2S8bfmrgVTyYh09Olnzy9_tISGK4,8292
 structuralcodes/materials/reinforcement/__init__.py,sha256=-UA04GSNN6_xLKqnH_5taiOmgxYwD_wtT6Nw8UbfkJY,2757
 structuralcodes/materials/reinforcement/_reinforcement.py,sha256=zrSdBvHKTYqOHpkJzxit8w_b2JG2pggviOvgZyH246Q,5029
 structuralcodes/materials/reinforcement/_reinforcementEC2_2004.py,sha256=svLpubjaTH_DepwY68TQIA8fRwadoAE3Y3KsyViGQHk,3265
 structuralcodes/materials/reinforcement/_reinforcementEC2_2023.py,sha256=3tKpFcMNYK52s5K2K_PctRcuSgwZTe-QXX3xziHPUno,2887
 structuralcodes/materials/reinforcement/_reinforcementMC2010.py,sha256=az_IAQJNKSF6Vv9KMoXjWTdYkWI6xcEm7s8i8GETn3A,2939
 structuralcodes/sections/__init__.py,sha256=qPoD5eS31at-uveYtxtVkXGLNHPrIMRrxGYY3wOLQ4s,441
-structuralcodes/sections/_generic.py,sha256=jpubO8wBsVWJajpOkUYzBpunf4ltse8rmiNFyiwDuoI,49968
+structuralcodes/sections/_generic.py,sha256=I_YQNeK9ww3wDtkSBlhF7u6gXVAj2I5Sttv9i-uk8UI,50525
 structuralcodes/sections/section_integrators/__init__.py,sha256=PK4ixV0XrfHXN-itIrB1r90npoWo3aIJqMcenqcaees,399
 structuralcodes/sections/section_integrators/_factory.py,sha256=MHp14hfWU-oXTiIutCKLJEC47LirYsHgEAAmHVtnFMY,1242
-structuralcodes/sections/section_integrators/_fiber_integrator.py,sha256=5sxcfbmxMJfy45Pfd84I4sAh6HpPc5B4r6ab0WpjSNI,9305
+structuralcodes/sections/section_integrators/_fiber_integrator.py,sha256=Ucas8nA9BB4ILfFPplJp3WkgLc9ntf9UN7AmcUwqA_A,9263
 structuralcodes/sections/section_integrators/_marin_integration.py,sha256=SZgya6d_Tequ3jez7UEBlYioZepW2IDKaAxn_6WrMbU,1563
-structuralcodes/sections/section_integrators/_marin_integrator.py,sha256=rtEtd1X0QYAWNcaH7Pjd_b6LEzVjHqD_fbIrX64p7fg,9121
+structuralcodes/sections/section_integrators/_marin_integrator.py,sha256=DHAJwurHhVp68K9fozw0MbmxZvk_NAKnNVi5abp65sY,9118
 structuralcodes/sections/section_integrators/_section_integrator.py,sha256=O-jsG1Pu_doovgRJsFG1Sf0KlkN2wNfQdmgkJiSHNN0,1590
-structuralcodes-0.1.1.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-structuralcodes-0.1.1.dist-info/METADATA,sha256=CDs31oS5sYYBt1hk-gRLTGPJtfa6SiM1H5QP3IlGecI,2444
-structuralcodes-0.1.1.dist-info/RECORD,,
+structuralcodes-0.2.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+structuralcodes-0.2.0.dist-info/METADATA,sha256=7RAyKNKlQYjXC3sFiVRWTwp3HUMAhN5SvJAvcF2LTZ0,2444
+structuralcodes-0.2.0.dist-info/RECORD,,