structuralcodes 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

structuralcodes/materials/basic/_elasticplastic.py

@@ -0,0 +1,92 @@
+"""A material class with elastic plastic properties."""
+
+import typing as t
+
+from ...core.base import Material
+from ..constitutive_laws import create_constitutive_law
+
+
+class ElasticPlasticMaterial(Material):
+    """A material class with elastic plastic properties."""
+
+    _E: float
+    _fy: float
+    _Eh: float
+    _eps_su: float
+
+    def __init__(
+        self,
+        E: float,
+        fy: float,
+        density: float,
+        Eh: float = 0,
+        eps_su: t.Optional[float] = None,
+        initial_strain: t.Optional[float] = None,
+        initial_stress: t.Optional[float] = None,
+        strain_compatibility: t.Optional[float] = None,
+        name: t.Optional[str] = None,
+    ):
+        """Initialize a material with an elastic plastic constitutive law.
+
+        Arguments:
+            E (float): The Young's modulus.
+            fy (float): The yield stress.
+            density (float): The density.
+            Eh (float, optional): The hardening modulus, default value 0.
+            eps_su (float, optional): The ultimate strain, default value 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
+                initial_strain or initial_stress are different from zero. If
+                True, the material deforms with the geometry. If False, the
+                stress in the material upon loading is kept constant
+                corresponding to the initial strain.
+            name (str, optional): The name of the material, default value None.
+        """
+        super().__init__(
+            density=density,
+            initial_strain=initial_strain,
+            initial_stress=initial_stress,
+            strain_compatibility=strain_compatibility,
+            name=name if name else 'ElasticPlasticMaterial',
+        )
+        self._E = E
+        self._fy = fy
+        self._Eh = Eh
+        self._eps_su = eps_su
+
+        self._constitutive_law = create_constitutive_law(
+            'elasticplastic', self
+        )
+        self._apply_initial_strain()
+
+    @property
+    def E(self) -> float:
+        """Returns the Young's modulus."""
+        return self._E
+
+    @property
+    def fy(self) -> float:
+        """Returns the yield stress."""
+        return self._fy
+
+    @property
+    def Eh(self) -> float:
+        """Returns the hardening modulus."""
+        return self._Eh
+
+    @property
+    def eps_su(self) -> float:
+        """Returns the ultimate strain."""
+        return self._eps_su
+
+    def __elasticplastic__(self) -> dict:
+        """Returns kwargs for ElasticPlastic constitutive law with strain
+        hardening.
+        """
+        return {
+            'E': self.E,
+            'fy': self.fy,
+            'Eh': self.Eh,
+            'eps_su': self.eps_su,
+        }

structuralcodes/materials/basic/_generic.py

@@ -0,0 +1,43 @@
+"""A generic material that could hold any type of constitutive law."""
+
+import typing as t
+
+from ...core.base import ConstitutiveLaw, Material
+
+
+class GenericMaterial(Material):
+    """A material class that accepts any constitutive law."""
+
+    def __init__(
+        self,
+        density: float,
+        constitutive_law: ConstitutiveLaw,
+        initial_strain: t.Optional[float] = None,
+        initial_stress: t.Optional[float] = None,
+        strain_compatibility: t.Optional[bool] = None,
+        name: t.Optional[str] = None,
+    ):
+        """Initialize a material with a constitutive law.
+
+        Arguments:
+            density (float): The density.
+            constitutive_law (ConstitutiveLaw): The constitutive law of the
+                material.
+            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
+                initial_strain or initial_stress are different from zero. If
+                True, the material deforms with the geometry. If False, the
+                stress in the material upon loading is kept constant
+                corresponding to the initial strain.
+            name (str, optional): The name of the material, default value None.
+        """
+        super().__init__(
+            density=density,
+            initial_strain=initial_strain,
+            initial_stress=initial_stress,
+            strain_compatibility=strain_compatibility,
+            name=name if name else 'GenericMaterial',
+        )
+        self._constitutive_law = constitutive_law
+        self._apply_initial_strain()

structuralcodes/materials/concrete/__init__.py

@@ -49,6 +49,9 @@ def create_concrete(
             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.
+        **kwargs: Other valid keyword arguments that are collected and passed
+            to the specific concrete material. Please inspect the documentation
+            of the other concrete materials to see valid arguments.
 
     Raises:
         ValueError: if the design code is not valid or does not cover concrete

structuralcodes/materials/concrete/_concrete.py

@@ -21,10 +21,19 @@ class Concrete(Material):
         density: float = 2400,
         gamma_c: t.Optional[float] = None,
         existing: t.Optional[bool] = False,
+        initial_strain: t.Optional[float] = None,
+        initial_stress: t.Optional[float] = None,
+        strain_compatibility: t.Optional[bool] = None,
     ) -> None:
         """Initializes an abstract concrete material."""
         name = name if name is not None else 'Concrete'
-        super().__init__(density=density, name=name)
+        super().__init__(
+            density=density,
+            initial_strain=initial_strain,
+            initial_stress=initial_stress,
+            strain_compatibility=strain_compatibility,
+            name=name,
+        )
 
         self._fck = abs(fck)
         if existing:

structuralcodes/materials/concrete/_concreteEC2_2004.py

@@ -46,6 +46,9 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
                 ConstitutiveLaw,
             ]
         ] = 'parabolarectangle',
+        initial_strain: t.Optional[float] = None,
+        initial_stress: t.Optional[float] = None,
+        strain_compatibility: t.Optional[bool] = None,
         fcm: t.Optional[float] = None,
         fctm: t.Optional[float] = None,
         fctk_5: t.Optional[float] = None,
@@ -80,6 +83,13 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
                 law type for concrete. (valid options for string: 'elastic',
                 'parabolarectangle', 'bilinearcompression', 'sargin',
                 'popovics').
+            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
+                initial_strain or initial_stress are different from zero. If
+                True, the material deforms with the geometry. If False, the
+                stress in the material upon loading is kept constant
+                corresponding to the initial strain.
             fcm (float, optional): The mean compressive strength.
             fctm (float, optional): The mean tensile strength.
             fctk_5 (float, optional): The 5% fractile for the tensile strength.
@@ -130,6 +140,9 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
             density=density,
             existing=False,
             gamma_c=gamma_c,
+            initial_strain=initial_strain,
+            initial_stress=initial_stress,
+            strain_compatibility=strain_compatibility,
         )
         self._alpha_cc = alpha_cc
         self._fcm = abs(fcm) if fcm is not None else None
@@ -165,6 +178,7 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
             raise ValueError(
                 'The provided constitutive law is not valid for concrete.'
             )
+        self._apply_initial_strain()
 
     def __post_init__(self):
         """Validator for the attributes that are set in the constructor."""

structuralcodes/materials/concrete/_concreteEC2_2023.py

@@ -48,6 +48,9 @@ class ConcreteEC2_2023(Concrete):  # noqa: N801
                 ConstitutiveLaw,
             ]
         ] = 'parabolarectangle',
+        initial_strain: t.Optional[float] = None,
+        initial_stress: t.Optional[float] = None,
+        strain_compatibility: t.Optional[bool] = None,
         fcm: t.Optional[float] = None,
         fctm: t.Optional[float] = None,
         fctk_5: t.Optional[float] = None,
@@ -80,6 +83,13 @@ class ConcreteEC2_2023(Concrete):  # noqa: N801
                 law type for concrete. (valid options for string: 'elastic',
                 'parabolarectangle', 'bilinearcompression', 'sargin',
                 'popovics').
+            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
+                initial_strain or initial_stress are different from zero. If
+                True, the material deforms with the geometry. If False, the
+                stress in the material upon loading is kept constant
+                corresponding to the initial strain.
             fcm (float, optional): The mean compressive strength.
             fctm (float, optional): The mean tensile strength.
             fctk_5 (float, optional): The 5% fractile for the tensile strength.
@@ -124,6 +134,9 @@ class ConcreteEC2_2023(Concrete):  # noqa: N801
             density=density,
             existing=False,
             gamma_c=gamma_c,
+            initial_strain=initial_strain,
+            initial_stress=initial_stress,
+            strain_compatibility=strain_compatibility,
         )
         self._kE = kE
         self._strength_dev_class = strength_dev_class.strip().lower()
@@ -158,6 +171,7 @@ class ConcreteEC2_2023(Concrete):  # noqa: N801
             raise ValueError(
                 'The provided constitutive law is not valid for concrete.'
             )
+        self._apply_initial_strain()
 
     def __post_init__(self):
         """Validator for the attributes that are set in the constructor."""

structuralcodes/materials/concrete/_concreteMC2010.py

@@ -48,6 +48,9 @@ class ConcreteMC2010(Concrete):
                 ConstitutiveLaw,
             ]
         ] = 'parabolarectangle',
+        initial_strain: t.Optional[float] = None,
+        initial_stress: t.Optional[float] = None,
+        strain_compatibility: t.Optional[bool] = None,
         fcm: t.Optional[float] = None,
         fctm: t.Optional[float] = None,
         fctkmin: t.Optional[float] = None,
@@ -77,6 +80,18 @@ class ConcreteMC2010(Concrete):
             alpha_cc (float, optional): A factor for considering long-term
                 effects on the strength, and effects that arise from the way
                 the load is applied.
+            consitutive_law (ConstitutiveLaw | str): A valid ConstitutiveLaw
+                object for concrete or a string defining a valid constitutive
+                law type for concrete. (valid options for string: 'elastic',
+                'parabolarectangle', 'bilinearcompression', 'sargin',
+                'popovics').
+            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
+                initial_strain or initial_stress are different from zero. If
+                True, the material deforms with the geometry. If False, the
+                stress in the material upon loading is kept constant
+                corresponding to the initial strain.
             fcm (float, optional): The mean compressive strength.
             fctm (float, optional): The mean tensile strength.
             fctkmin (float, optional): The minimum tensile strength.
@@ -126,6 +141,9 @@ class ConcreteMC2010(Concrete):
             name=name,
             density=density,
             gamma_c=gamma_c,
+            initial_strain=initial_strain,
+            initial_stress=initial_stress,
+            strain_compatibility=strain_compatibility,
         )
         self._alpha_cc = alpha_cc
         self._fcm = abs(fcm) if fcm is not None else None
@@ -162,6 +180,7 @@ class ConcreteMC2010(Concrete):
             raise ValueError(
                 'The provided constitutive law is not valid for concrete.'
             )
+        self._apply_initial_strain()
 
     def __post_init__(self):
         """Validator for the attributes that are set in the constructor."""

structuralcodes/materials/constitutive_laws/__init__.py

@@ -6,6 +6,7 @@ from ...core.base import ConstitutiveLaw, Material
 from ._bilinearcompression import BilinearCompression
 from ._elastic import Elastic
 from ._elasticplastic import ElasticPlastic
+from ._initial_strain import InitialStrain
 from ._parabolarectangle import ParabolaRectangle
 from ._popovics import Popovics
 from ._sargin import Sargin
@@ -19,6 +20,7 @@ __all__ = [
     'Popovics',
     'Sargin',
     'UserDefined',
+    'InitialStrain',
     'get_constitutive_laws_list',
     'create_constitutive_law',
 ]
@@ -31,6 +33,7 @@ CONSTITUTIVE_LAWS: t.Dict[str, ConstitutiveLaw] = {
     'parabolarectangle': ParabolaRectangle,
     'popovics': Popovics,
     'sargin': Sargin,
+    'initialstrain': InitialStrain,
 }
 
 

structuralcodes/materials/constitutive_laws/_elasticplastic.py

@@ -34,8 +34,8 @@ class ElasticPlastic(ConstitutiveLaw):
 
         Keyword Arguments:
             Eh (float): The hardening modulus.
-            eps_su (float): The ultimate strain.
-            name (str): A descriptive name for the constitutive law.
+            eps_su (float, optional): The ultimate strain.
+            name (str, optional): A descriptive name for the constitutive law.
         """
         name = name if name is not None else 'ElasticPlasticLaw'
         super().__init__(name=name)

structuralcodes/materials/constitutive_laws/_initial_strain.py

@@ -0,0 +1,130 @@
+"""Initial strain 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 InitialStrain(ConstitutiveLaw):
+    """Class for initial strain Constitutive Law."""
+
+    _strain_compatibility: bool = True
+
+    __materials__: t.Tuple[str] = (
+        'steel',
+        'rebars',
+        'concrete',
+    )
+
+    _wrapped_law: ConstitutiveLaw = None
+
+    def __init__(
+        self,
+        constitutive_law: ConstitutiveLaw,
+        initial_strain: float,
+        strain_compatibility: bool = True,
+        name: t.Optional[str] = None,
+    ) -> None:
+        """Initialize an Initial Strain Constitutive Law.
+
+        This constitutive law is a wrapper for another constitutive law
+        that assigns an initial strain.
+
+        Arguments:
+            constitutive_law (ConstitutiveLaw): Wrapped constitutive law.
+            initial_strain (float): The initial strain to be applied.
+            strain_compatibility (bool): If True, the strain compatibility is
+                enforced, otherwise the strain compatibility is released. This
+                is helpful for instance for modelling unbonded tendons.
+                Default value True.
+        """
+        name = name if name is not None else 'InitialStrainLaw'
+        super().__init__(name=name)
+        if not isinstance(constitutive_law, ConstitutiveLaw):
+            raise TypeError(
+                f'Expected a ConstitutiveLaw instance, '
+                f'got {type(constitutive_law)}'
+            )
+        self._wrapped_law = constitutive_law
+        self._initial_strain = initial_strain
+        self._initial_stress = self._wrapped_law.get_stress(initial_strain)
+        self._strain_compatibility = strain_compatibility
+
+    @property
+    def strain_compatibility(self) -> bool:
+        """Return the strain compatibility status."""
+        return self._strain_compatibility
+
+    @property
+    def wrapped_law(self) -> ConstitutiveLaw:
+        """Return the wrapped constitutive law."""
+        return self._wrapped_law
+
+    def get_stress(
+        self, eps: t.Union[float, ArrayLike]
+    ) -> t.Union[float, ArrayLike]:
+        """Return the stress given strain."""
+        stress = self._wrapped_law.get_stress(eps + self._initial_strain)
+        if not self._strain_compatibility:
+            # If strain compatibility is enforced, return initial stress
+            return np.ones_like(stress) * self._initial_stress
+        return stress
+
+    def get_tangent(
+        self, eps: t.Union[float, ArrayLike]
+    ) -> t.Union[float, ArrayLike]:
+        """Return the tangent for given strain."""
+        if not self._strain_compatibility:
+            return self._wrapped_law.get_tangent(0) * 1e-6
+        return self._wrapped_law.get_tangent(eps + self._initial_strain)
+
+    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)]
+        """
+        return self._wrapped_law.__marin__(
+            strain=[strain[0] + self._initial_strain, strain[1]]
+        )
+
+    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)]
+        """
+        return self._wrapped_law.__marin_tangent__(
+            strain=[strain[0] + self._initial_strain, strain[1]]
+        )
+
+    def get_ultimate_strain(
+        self, yielding: bool = False
+    ) -> t.Tuple[float, float]:
+        """Return the ultimate strain (negative and positive)."""
+        ult_strain = self._wrapped_law.get_ultimate_strain(yielding=yielding)
+        return (
+            ult_strain[0] - self._initial_strain,
+            ult_strain[1] - self._initial_strain,
+        )

structuralcodes/materials/reinforcement/__init__.py

@@ -33,6 +33,7 @@ def create_reinforcement(
     name: t.Optional[str] = None,
     density: float = 7850,
     design_code: t.Optional[str] = None,
+    **kwargs,
 ) -> t.Optional[Reinforcement]:
     """A factory function to create the correct type of reinforcement based on
     the desired design code.
@@ -50,6 +51,10 @@ def create_reinforcement(
             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.
+        **kwargs: Other valid keyword arguments that are collected and passed
+            to the specific reinforcement material. Please inspect the
+            documentation of the other reinforcement materials to see valid
+            arguments.
 
     Raises:
         ValueError: If the design code is not valid or does not cover
@@ -80,5 +85,6 @@ def create_reinforcement(
             ftk=ftk,
             epsuk=epsuk,
             gamma_s=gamma_s,
+            **kwargs,
         )
     return None

structuralcodes/materials/reinforcement/_reinforcement.py

@@ -24,10 +24,19 @@ class Reinforcement(Material):
         epsuk: float,
         gamma_s: t.Optional[float] = None,
         name: t.Optional[str] = None,
+        initial_strain: t.Optional[float] = None,
+        initial_stress: t.Optional[float] = None,
+        strain_compatibility: t.Optional[bool] = None,
     ) -> None:
         """Initializes an abstract reinforcement material."""
         name = name if name is not None else 'Reinforcement'
-        super().__init__(density, name)
+        super().__init__(
+            density=density,
+            initial_strain=initial_strain,
+            initial_stress=initial_stress,
+            strain_compatibility=strain_compatibility,
+            name=name,
+        )
 
         self._fyk = abs(fyk)
         self._Es = abs(Es)

structuralcodes/materials/reinforcement/_reinforcementEC2_2004.py

@@ -31,6 +31,9 @@ class ReinforcementEC2_2004(Reinforcement):  # noqa: N801
                 ConstitutiveLaw,
             ]
         ] = 'elasticplastic',
+        initial_strain: t.Optional[float] = None,
+        initial_stress: t.Optional[float] = None,
+        strain_compatibility: t.Optional[bool] = None,
     ):
         """Initializes a new instance of Reinforcement for EC2 2004.
 
@@ -53,6 +56,13 @@ class ReinforcementEC2_2004(Reinforcement):  # noqa: N801
                 constitutive law type for reinforcement. (valid options for
                 string: 'elastic', 'elasticplastic', or
                 'elasticperfectlyplastic').
+            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
+                initial_strain or initial_stress are different from zero. If
+                True, the material deforms with the geometry. If False, the
+                stress in the material upon loading is kept constant
+                corresponding to the initial strain.
 
         Raises:
             ValueError: If the constitutive law name is not available for the
@@ -71,6 +81,9 @@ class ReinforcementEC2_2004(Reinforcement):  # noqa: N801
             ftk=ftk,
             epsuk=epsuk,
             gamma_s=gamma_s,
+            initial_strain=initial_strain,
+            initial_stress=initial_stress,
+            strain_compatibility=strain_compatibility,
         )
         self._gamma_eps = gamma_eps
         self._constitutive_law = (
@@ -84,6 +97,7 @@ class ReinforcementEC2_2004(Reinforcement):  # noqa: N801
             raise ValueError(
                 'The provided constitutive law is not valid for reinforcement.'
             )
+        self._apply_initial_strain()
 
     def fyd(self) -> float:
         """The design yield strength."""
@@ -129,7 +143,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

@@ -30,6 +30,9 @@ class ReinforcementEC2_2023(Reinforcement):  # noqa: N801
                 ConstitutiveLaw,
             ]
         ] = 'elasticplastic',
+        initial_strain: t.Optional[float] = None,
+        initial_stress: t.Optional[float] = None,
+        strain_compatibility: t.Optional[bool] = None,
     ):
         """Initializes a new instance of Reinforcement for EC2 2023.
 
@@ -50,6 +53,13 @@ class ReinforcementEC2_2023(Reinforcement):  # noqa: N801
                 constitutive law type for reinforcement. (valid options for
                 string: 'elastic', 'elasticplastic', or
                 'elasticperfectlyplastic').
+            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
+                initial_strain or initial_stress are different from zero. If
+                True, the material deforms with the geometry. If False, the
+                stress in the material upon loading is kept constant
+                corresponding to the initial strain.
 
         Raises:
             ValueError: If the constitutive law name is not available for the
@@ -67,6 +77,9 @@ class ReinforcementEC2_2023(Reinforcement):  # noqa: N801
             ftk=ftk,
             epsuk=epsuk,
             gamma_s=gamma_s,
+            initial_strain=initial_strain,
+            initial_stress=initial_stress,
+            strain_compatibility=strain_compatibility,
         )
         self._constitutive_law = (
             constitutive_law
@@ -79,6 +92,7 @@ class ReinforcementEC2_2023(Reinforcement):  # noqa: N801
             raise ValueError(
                 'The provided constitutive law is not valid for reinforcement.'
             )
+        self._apply_initial_strain()
 
     def fyd(self) -> float:
         """The design yield strength."""
@@ -117,7 +131,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

@@ -31,6 +31,9 @@ class ReinforcementMC2010(Reinforcement):
                 ConstitutiveLaw,
             ]
         ] = 'elasticplastic',
+        initial_strain: t.Optional[float] = None,
+        initial_stress: t.Optional[float] = None,
+        strain_compatibility: t.Optional[bool] = None,
     ):
         """Initializes a new instance of Reinforcement for MC2010.
 
@@ -53,6 +56,13 @@ class ReinforcementMC2010(Reinforcement):
                 constitutive law type for reinforcement. (valid options for
                 string: 'elastic', 'elasticplastic', or
                 'elasticperfectlyplastic').
+            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
+                initial_strain or initial_stress are different from zero. If
+                True, the material deforms with the geometry. If False, the
+                stress in the material upon loading is kept constant
+                corresponding to the initial strain.
 
         Raises:
             ValueError: If the constitutive law name is not available for the
@@ -71,6 +81,9 @@ class ReinforcementMC2010(Reinforcement):
             ftk=ftk,
             epsuk=epsuk,
             gamma_s=gamma_s,
+            initial_strain=initial_strain,
+            initial_stress=initial_stress,
+            strain_compatibility=strain_compatibility,
         )
         self._gamma_eps = gamma_eps
         self._constitutive_law = (
@@ -84,6 +97,7 @@ class ReinforcementMC2010(Reinforcement):
             raise ValueError(
                 'The provided constitutive law is not valid for reinforcement.'
             )
+        self._apply_initial_strain()
 
     def fyd(self) -> float:
         """The design yield strength."""
@@ -125,7 +139,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(),