structuralcodes 0.0.1__py3-none-any.whl

structuralcodes/materials/reinforcement/__init__.py

@@ -0,0 +1,84 @@
+"""Reinforcement material."""
+
+import typing as t
+
+from structuralcodes.codes import _use_design_code
+
+from ._reinforcement import Reinforcement
+from ._reinforcementEC2_2004 import ReinforcementEC2_2004
+from ._reinforcementEC2_2023 import ReinforcementEC2_2023
+from ._reinforcementMC2010 import ReinforcementMC2010
+
+__all__ = [
+    'create_reinforcement',
+    'Reinforcement',
+    'ReinforcementMC2010',
+    'ReinforcementEC2_2004',
+    'ReinforcementEC2_2023',
+]
+
+REINFORCEMENTS: t.Dict[str, Reinforcement] = {
+    'fib Model Code 2010': ReinforcementMC2010,
+    'EUROCODE 2 1992-1-1:2004': ReinforcementEC2_2004,
+    'EUROCODE 2 1992-1-1:2023': ReinforcementEC2_2023,
+}
+
+
+def create_reinforcement(
+    fyk: float,
+    Es: float,
+    ftk: float,
+    epsuk: float,
+    gamma_s: t.Optional[float] = None,
+    name: t.Optional[str] = None,
+    density: float = 7850,
+    design_code: t.Optional[str] = None,
+) -> t.Optional[Reinforcement]:
+    """A factory function to create the correct type of reinforcement based on
+    the desired design code.
+
+    Arguments:
+        fyk (float): Characteristic yield strength in MPa.
+        Es (float): The Young's modulus in MPa.
+        ftk (float): Characteristic ultimate strength in MPa.
+        epsuk (float): The characteristik strain at the ultimate stress level.
+
+    Keyword Arguments:
+        gamma_s (Optional(float)): The partial factor for reinforcement.
+        density (float): Density of the material in kg/m3 (default: 7850)
+        design_code (str): Optional string (default: None) indicating the
+            desired standard. If None (default) the globally used design
+            standard will be adopted. Otherwise the design standard specified
+            will be used for the instance of the material.
+
+    Raises:
+        ValueError: If the design code is not valid or does not cover
+            reinforcement as a material.
+    """
+    # Get the code from the global variable
+    _code = _use_design_code(design_code)
+
+    # Check if the code is a proper code for reinforcement
+    code = None
+    if _code is not None and 'reinforcement' in _code.__materials__:
+        code = _code
+    if code is None:
+        raise ValueError(
+            'The design code is not set, either use '
+            'structuralcodes.code.set_designcode, or provide a valid '
+            'string in the function.'
+        )
+
+    # Create the proper reinforcement object
+    current_reinforcement = REINFORCEMENTS.get(code.__title__, None)
+    if current_reinforcement is not None:
+        return current_reinforcement(
+            fyk=fyk,
+            Es=Es,
+            name=name,
+            density=density,
+            ftk=ftk,
+            epsuk=epsuk,
+            gamma_s=gamma_s,
+        )
+    return None

structuralcodes/materials/reinforcement/_reinforcement.py

@@ -0,0 +1,172 @@
+"""Core implementation of the reinforcement material."""
+
+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):
+    """The abstract reinforcement material."""
+
+    _fyk: float
+    _Es: float
+    _ftk: float
+    _epsuk: float
+    _gamma_s: t.Optional[float] = None
+
+    def __init__(
+        self,
+        fyk: float,
+        Es: float,
+        density: float,
+        ftk: float,
+        epsuk: float,
+        gamma_s: t.Optional[float] = None,
+        name: t.Optional[str] = None,
+    ) -> None:
+        """Initializes an abstract reinforcement material."""
+        name = name if name is not None else 'Reinforcement'
+        super().__init__(density, name)
+
+        self._fyk = abs(fyk)
+        self._Es = abs(Es)
+        self._ftk = abs(ftk)
+        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."""
+        return self._epsuk
+
+    @epsuk.setter
+    def epsuk(self, epsuk: float) -> None:
+        """Setter for epsuk."""
+        self._epsuk = abs(epsuk)
+
+    @property
+    def epsyk(self) -> float:
+        """Returns characteristic yield strain epsyk."""
+        return self.fyk / self.Es
+
+    @property
+    def constitutive_law(self) -> ConstitutiveLaw:
+        """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:
+        """Each reinforcement should implement its own getter for the partial
+        factor in order to interact with the globally set national annex.
+        """
+
+    @abc.abstractmethod
+    def fyd(self) -> float:
+        """Each reinforcement should implement its own method for calculating
+        the design yield strength.
+        """
+
+    @abc.abstractmethod
+    def ftd(self) -> float:
+        """Each reinforcement should implement its own method for calculating
+        the design ultimate strength.
+        """
+
+    @abc.abstractmethod
+    def epsud(self) -> float:
+        """Each reinforcement should implement its own method for calculating
+        the design ultimate strain.
+        """
+
+    @property
+    def epsyd(self) -> float:
+        """Return the design yield strain."""
+        return self.fyd() / self.Es

structuralcodes/materials/reinforcement/_reinforcementEC2_2004.py

@@ -0,0 +1,103 @@
+"""The concrete class for Eurocode 2 2004 Reinforcement Material."""
+
+import typing as t
+
+from structuralcodes.codes import ec2_2004
+
+from ._reinforcement import Reinforcement
+
+
+class ReinforcementEC2_2004(Reinforcement):  # noqa: N801
+    """Reinforcement implementation for EC2 2004."""
+
+    def __init__(
+        self,
+        fyk: float,
+        Es: float,
+        ftk: float,
+        epsuk: float,
+        gamma_s: t.Optional[float] = None,
+        gamma_eps: t.Optional[float] = None,
+        name: t.Optional[str] = None,
+        density: float = 7850.0,
+    ):
+        """Initializes a new instance of Reinforcement for EC2 2004.
+
+        Arguments:
+            fyk (float): Characteristic yield strength in MPa.
+            Es (float): The Young's modulus in MPa.
+            ftk (float): Characteristic ultimate strength in MPa.
+            epsuk (float): The characteristik strain at the ultimate stress
+                level.
+            gamma_s (Optional(float)): The partial factor for reinforcement.
+                Default value is 1.15.
+
+        Keyword Arguments:
+            name (str): A descriptive name for the reinforcement.
+            density (float): Density of material in kg/m3 (default: 7850).
+        """
+        if name is None:
+            name = f'Reinforcement{round(fyk):d}'
+
+        self._gamma_eps = gamma_eps
+        super().__init__(
+            fyk=fyk,
+            Es=Es,
+            name=name,
+            density=density,
+            ftk=ftk,
+            epsuk=epsuk,
+            gamma_s=gamma_s,
+        )
+
+    def fyd(self) -> float:
+        """The design yield strength."""
+        return ec2_2004.fyd(self.fyk, self.gamma_s)
+
+    @property
+    def gamma_s(self) -> float:
+        """The partial factor for reinforcement."""
+        # Here we should implement the interaction with the globally set
+        # national annex. For now, we simply return the default value.
+        return self._gamma_s or 1.15
+
+    def ftd(self) -> float:
+        """The design ultimate strength."""
+        return ec2_2004.fyd(self.ftk, self.gamma_s)
+
+    def epsud(self) -> float:
+        """The design ultimate strain."""
+        return ec2_2004.epsud(self.epsuk, self.gamma_eps)
+
+    @property
+    def gamma_eps(self) -> float:
+        """The partial factor for ultimate strain."""
+        # Here we should implement the interaction with the globally set
+        # national annex. For now, we simply return the default value.
+        return self._gamma_eps or 0.9
+
+    def __elastic__(self) -> dict:
+        """Returns kwargs for creating an elastic constitutive law."""
+        return {'E': self.Es}
+
+    def __elasticperfectlyplastic__(self) -> dict:
+        """Returns kwargs for ElasticPlastic constitutive law with no strain
+        hardening.
+        """
+        return {
+            'E': self.Es,
+            'fy': self.fyd(),
+            'eps_su': self.epsud(),
+        }
+
+    def __elasticplastic__(self) -> dict:
+        """Returns kwargs for ElasticPlastic constitutive law with strain
+        hardening.
+        """
+        Eh = (self.ftd() - self.fyd()) / (self.epsuk - self.epsyd)
+        return {
+            'E': self.Es,
+            'fy': self.fyd(),
+            'Eh': Eh,
+            'eps_su': self.epsud(),
+        }

structuralcodes/materials/reinforcement/_reinforcementEC2_2023.py

@@ -0,0 +1,93 @@
+"""The concrete class for Eurocode 2 2023 Reinforcement Material."""
+
+import typing as t
+
+from structuralcodes.codes import ec2_2023
+
+from ._reinforcement import Reinforcement
+
+
+class ReinforcementEC2_2023(Reinforcement):  # noqa: N801
+    """Reinforcement implementation for EC2 2023."""
+
+    def __init__(
+        self,
+        fyk: float,
+        Es: float,
+        ftk: float,
+        epsuk: float,
+        gamma_s: t.Optional[float] = None,
+        name: t.Optional[str] = None,
+        density: float = 7850.0,
+    ):
+        """Initializes a new instance of Reinforcement for EC2 2023.
+
+        Args:
+            fyk (float): Characteristic yield strength in MPa.
+            Es (float): The Young's modulus in MPa.
+            ftk (float): Characteristic ultimate strength in MPa.
+            epsuk (float): The characteristik strain at the ultimate stress
+                level.
+            gamma_s (Optional(float)): The partial factor for reinforcement.
+                Default value is 1.15.
+
+        Keyword Args:
+            name (str): A descriptive name for the reinforcement.
+            density (float): Density of material in kg/m3 (default: 7850).
+        """
+        if name is None:
+            name = f'Reinforcement{round(fyk):d}'
+        super().__init__(
+            fyk=fyk,
+            Es=Es,
+            name=name,
+            density=density,
+            ftk=ftk,
+            epsuk=epsuk,
+            gamma_s=gamma_s,
+        )
+
+    def fyd(self) -> float:
+        """The design yield strength."""
+        return ec2_2023.fyd(self.fyk, self.gamma_s)
+
+    def ftd(self) -> float:
+        """The design ultimate strength."""
+        return ec2_2023.fyd(self.ftk, self.gamma_s)
+
+    def epsud(self) -> float:
+        """The design ultimate strain."""
+        return ec2_2023.eps_ud(self.epsuk, self.gamma_s)
+
+    @property
+    def gamma_s(self) -> float:
+        """The partial factor for reinforcement."""
+        # Here we should implement the interaction with the globally set
+        # national annex. For now, we simply return the default value.
+        return self._gamma_s or 1.15
+
+    def __elastic__(self) -> dict:
+        """Returns kwargs for creating an elastic constitutive law."""
+        return {'E': self.Es}
+
+    def __elasticperfectlyplastic__(self) -> dict:
+        """Returns kwargs for ElasticPlastic constitutive law with no strain
+        hardening.
+        """
+        return {
+            'E': self.Es,
+            'fy': self.fyd(),
+            'eps_su': self.epsud(),
+        }
+
+    def __elasticplastic__(self) -> dict:
+        """Returns kwargs for ElasticPlastic constitutive law with strain
+        hardening.
+        """
+        Eh = (self.ftd() - self.fyd()) / (self.epsuk - self.epsyd)
+        return {
+            'E': self.Es,
+            'fy': self.fyd(),
+            'Eh': Eh,
+            'eps_su': self.epsud(),
+        }

structuralcodes/materials/reinforcement/_reinforcementMC2010.py

@@ -0,0 +1,98 @@
+"""The concrete class for Model Code 2010 Reinforcement Material."""
+
+import typing as t
+
+from structuralcodes.codes import mc2010
+
+from ._reinforcement import Reinforcement
+
+
+class ReinforcementMC2010(Reinforcement):
+    """Reinforcement implementation for MC 2010."""
+
+    def __init__(
+        self,
+        fyk: float,
+        Es: float,
+        ftk: float,
+        epsuk: float,
+        gamma_s: t.Optional[float] = None,
+        gamma_eps: t.Optional[float] = None,
+        name: t.Optional[str] = None,
+        density: float = 7850.0,
+    ):
+        """Initializes a new instance of Reinforcement for MC2010.
+
+        Args:
+            fyk (float): Characteristic yield strength in MPa.
+            Es (float): The Young's modulus in MPa.
+            ftk (float): Characteristic ultimate strength in MPa.
+            epsuk (float): The characteristik strain at the ultimate stress
+                level.
+            gamma_s (Optional(float)): The partial factor for reinforcement.
+                Default value is 1.15.
+
+        Keyword Args:
+            name (str): A descriptive name for the reinforcement.
+            density (float): Density of material in kg/m3 (default: 7850).
+        """
+        if name is None:
+            name = f'Reinforcement{round(fyk):d}'
+        self._gamma_eps = gamma_eps
+        super().__init__(
+            fyk=fyk,
+            Es=Es,
+            name=name,
+            density=density,
+            ftk=ftk,
+            epsuk=epsuk,
+            gamma_s=gamma_s,
+        )
+
+    def fyd(self) -> float:
+        """The design yield strength."""
+        return mc2010.fyd(self.fyk, self.gamma_s)
+
+    @property
+    def gamma_s(self) -> float:
+        """The partial factor for reinforcement."""
+        return self._gamma_s or 1.15
+
+    def ftd(self) -> float:
+        """The design ultimate strength."""
+        return mc2010.fyd(self.ftk, self.gamma_s)
+
+    def epsud(self) -> float:
+        """The design ultimate strain."""
+        return mc2010.epsud(self.epsuk, self.gamma_eps)
+
+    @property
+    def gamma_eps(self) -> float:
+        """The partial factor for ultimate strain."""
+        return self._gamma_eps or 0.9
+
+    def __elastic__(self) -> dict:
+        """Returns kwargs for creating an elastic constitutive law."""
+        return {'E': self.Es}
+
+    def __elasticperfectlyplastic__(self) -> dict:
+        """Returns kwargs for ElasticPlastic constitutive law with no strain
+        hardening.
+        """
+        return {
+            'E': self.Es,
+            'fy': self.fyd(),
+            'eps_su': self.epsud(),
+        }
+
+    def __elasticplastic__(self) -> dict:
+        """Returns kwargs for ElasticPlastic constitutive law with strain
+        hardening.
+        """
+        Eh = (self.ftd() - self.fyd()) / (self.epsuk - self.epsyd)
+        return {
+            'E': self.Es,
+            'fy': self.fyd(),
+            'Eh': Eh,
+            'eps_su': self.epsud(),
+        }

structuralcodes/sections/__init__.py

@@ -0,0 +1,23 @@
+"""Main entry point for sections."""
+
+from ._generic import GenericSection, GenericSectionCalculator
+from ._reinforcement import add_reinforcement, add_reinforcement_line
+from .section_integrators import (
+    FiberIntegrator,
+    MarinIntegrator,
+    SectionIntegrator,
+    integrator_factory,
+    marin_integration,
+)
+
+__all__ = [
+    'GenericSection',
+    'GenericSectionCalculator',
+    'add_reinforcement',
+    'add_reinforcement_line',
+    'SectionIntegrator',
+    'FiberIntegrator',
+    'MarinIntegrator',
+    'integrator_factory',
+    'marin_integration',
+]