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

structuralcodes/materials/concrete/_concreteEC2_2004.py

@@ -5,13 +5,13 @@ import warnings
 
 from structuralcodes.codes import ec2_2004
 
+from ..constitutive_laws import ConstitutiveLaw, create_constitutive_law
 from ._concrete import Concrete
 
 
 class ConcreteEC2_2004(Concrete):  # noqa: N801
     """Concrete implementation for EC2 2004."""
 
-    # computed attributes
     _fcm: t.Optional[float] = None
     _fctm: t.Optional[float] = None
     _fctk_5: t.Optional[float] = None
@@ -34,6 +34,31 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
         density: float = 2400,
         gamma_c: t.Optional[float] = None,
         alpha_cc: t.Optional[float] = None,
+        constitutive_law: t.Optional[
+            t.Union[
+                t.Literal[
+                    'elastic',
+                    'parabolarectangle',
+                    'bilinearcompression',
+                    'sargin',
+                    'popovics',
+                ],
+                ConstitutiveLaw,
+            ]
+        ] = 'parabolarectangle',
+        fcm: t.Optional[float] = None,
+        fctm: t.Optional[float] = None,
+        fctk_5: t.Optional[float] = None,
+        fctk_95: t.Optional[float] = None,
+        Ecm: t.Optional[float] = None,
+        eps_c1: t.Optional[float] = None,
+        eps_cu1: t.Optional[float] = None,
+        k_sargin: t.Optional[float] = None,
+        eps_c2: t.Optional[float] = None,
+        eps_cu2: t.Optional[float] = None,
+        n_parabolic_rectangular: t.Optional[float] = None,
+        eps_c3: t.Optional[float] = None,
+        eps_cu3: t.Optional[float] = None,
         **kwargs,
     ) -> None:
         """Initializes a new instance of Concrete for EC2 2004.
@@ -50,6 +75,51 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
             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').
+            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.
+            fctk_95 (float, optional): The 95% fractile for the tensile
+                strength.
+            Ecm (float, optional): The mean secant Young's modulus.
+            eps_c1 (float, optional): The strain at peak stress for the Sargin
+                constitutive law.
+            eps_cu1 (float, optional): The ultimate strain for the Sargin
+                constitutive law.
+            k_sargin (float, optional): The coefficient for the Sargin
+                constitutive law.
+            eps_c2 (float, optional): The strain at peak stress for the
+                parabolic rectangular constitutive law.
+            eps_cu2 (float, optional): The ultimate strain for the parabolic
+                rectangular constitutive law.
+            n_parabolic_rectangular (float, optional): The coefficient for the
+                parabolic rectangular constitutive law.
+            eps_c3 (float, optional): The strain at peak stress for the
+                bilinear constitutive law.
+            eps_cu3 (float, optional): The ultimate strain for the bilinear
+                constitutive law.
+
+        Raises:
+            ValueError: If fcm is lower than fck.
+            ValueError: If k_sargin is negative.
+            ValueError: If n_parabolic_rectangular is negative.
+            ValueError: If the constitutive law name is not available for the
+                material.
+            ValueError: If the provided constitutive law is not valid for
+                concrete.
+            ValueError: If the constitutive law name is unknown.
+            Warning: If fctm is larger than 0.5 * fck.
+            Warning: If eps_c1 is larger than 0.1.
+            Warning: If eps_cu1 is larger than 0.1.
+            Warning: If eps_c2 is larger than 0.1.
+            Warning: If eps_cu2 is larger than 0.1.
+            Warning: If n_parabolic_rectangular is larger than 5.
+            Warning: If eps_c3 is larger than 0.1.
+            Warning: If eps_cu3 is larger than 0.1.
         """
         del kwargs
         if name is None:
@@ -62,21 +132,126 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
             gamma_c=gamma_c,
         )
         self._alpha_cc = alpha_cc
+        self._fcm = abs(fcm) if fcm is not None else None
+        self._fctm = abs(fctm) if fctm is not None else None
+        self._fctk_5 = abs(fctk_5) if fctk_5 is not None else None
+        self._fctk_95 = abs(fctk_95) if fctk_95 is not None else None
+        self._Ecm = abs(Ecm) if Ecm is not None else None
+        self._eps_c1 = abs(eps_c1) if eps_c1 is not None else None
+        self._eps_cu1 = abs(eps_cu1) if eps_cu1 is not None else None
+        self._k_sargin = k_sargin if k_sargin is not None else None
+        self._eps_c2 = abs(eps_c2) if eps_c2 is not None else None
+        self._eps_cu2 = abs(eps_cu2) if eps_cu2 is not None else None
+        self._n_parabolic_rectangular = (
+            n_parabolic_rectangular
+            if n_parabolic_rectangular is not None
+            else None
+        )
+        self._eps_c3 = abs(eps_c3) if eps_c3 is not None else None
+        self._eps_cu3 = abs(eps_cu3) if eps_cu3 is not None else None
+
+        self.__post_init__()
+
+        # The constitutive law requires valid attributes, so it should be set
+        # after validation
+        self._constitutive_law = (
+            constitutive_law
+            if isinstance(constitutive_law, ConstitutiveLaw)
+            else create_constitutive_law(
+                constitutive_law_name=constitutive_law, material=self
+            )
+        )
+        if 'concrete' not in self._constitutive_law.__materials__:
+            raise ValueError(
+                'The provided constitutive law is not valid for concrete.'
+            )
+
+    def __post_init__(self):
+        """Validator for the attributes that are set in the constructor."""
+        # fcm
+        if self._fcm is not None and self._fcm <= self._fck:
+            raise ValueError(
+                (
+                    'Mean compressive strength cannot be lower than',
+                    'characteristic strength.\n',
+                    'Current characteristing strength: ',
+                    f'fck = {self._fck}.',
+                    f'Current value: value = {self._fcm}',
+                )
+            )
+
+        # fctm
+        if self._fctm is not None and self._fctm > 0.5 * self._fck:
+            warnings.warn(
+                'A suspect value of fctm has been input. Please check.'
+            )
+
+        # eps_c1
+        if self._eps_c1 is not None and self._eps_c1 >= 0.1:
+            warnings.warn(
+                'A suspect value is input for eps_c1 that should be a pure'
+                f' number without units. Please check ({self._eps_c1} given).'
+            )
+
+        # eps_cu1
+        if self._eps_cu1 is not None and self._eps_cu1 >= 0.1:
+            warnings.warn(
+                'A suspect value is input for eps_cu1 that should be a pure'
+                f' number without units. Please check ({self._eps_cu1} given).'
+            )
+
+        # k_sargin
+        if self._k_sargin is not None and self._k_sargin < 0:
+            raise ValueError(
+                f'k_sargin should be a positive value ({self._k_sargin} given)'
+            )
+
+        # eps_c2
+        if self._eps_c2 is not None and self._eps_c2 >= 0.1:
+            warnings.warn(
+                'A suspect value is input for eps_c2 that should be a pure'
+                f' number without units. Please check ({self._eps_c2} given).'
+            )
+
+        # eps_cu2
+        if self._eps_cu2 is not None and self._eps_cu2 >= 0.1:
+            warnings.warn(
+                'A suspect value is input for eps_cu2 that should be a pure'
+                f' number without units. Please check ({self._eps_cu2} given).'
+            )
 
-    def _reset_attributes(self):
-        self._fcm = None
-        self._fctm = None
-        self._fctk_5 = None
-        self._fctk_95 = None
-        self._Ecm = None
-        self._eps_c1 = None
-        self._eps_cu1 = None
-        self._k_sargin = None
-        self._eps_c2 = None
-        self._eps_cu2 = None
-        self._n_parabolic_rectangular = None
-        self._eps_c3 = None
-        self._eps_cu3 = None
+        # n_parabolic_rectangular
+        if (
+            self._n_parabolic_rectangular is not None
+            and self._n_parabolic_rectangular < 0
+        ):
+            raise ValueError(
+                'n should be a positive value '
+                f'({self._n_parabolic_rectangular} given)'
+            )
+        if (
+            self._n_parabolic_rectangular is not None
+            and self._n_parabolic_rectangular >= 5
+        ):
+            warnings.warn(
+                'A suspect value is input for n_parabolic_rectangular that '
+                'should be a pure number without units. Please check '
+                f'({self._n_parabolic_rectangular} given).'
+            )
+
+        # eps_c3
+        if self._eps_c3 is not None and abs(self._eps_c3) >= 0.1:
+            warnings.warn(
+                'A suspect value is input for eps_c3 that should be a pure'
+                f' number without units. Please check ({self._eps_c3} given).'
+            )
+
+        # eps_cu3
+        if self._eps_cu3 is not None and abs(self._eps_cu3) >= 0.1:
+            warnings.warn(
+                'A suspect value is input for eps_cu3 that should be a pure'
+                f' number without units. Please check ({self._eps_cu3} given).'
+            )
 
     @property
     def fcm(self) -> float:
@@ -84,76 +259,44 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
 
         Returns:
             float: The mean compressive strength in MPa.
+
+        Note:
+            The returned value is derived from fck if fcm is not manually
+            provided when initializing the object.
         """
         if self._fcm is None:
-            self._fcm = ec2_2004.fcm(self._fck)
+            return ec2_2004.fcm(self._fck)
         return self._fcm
 
-    @fcm.setter
-    def fcm(self, value: float):
-        """Sets a user defined value for fcm.
-
-        Arguments:
-            value (float): The value of fcm in MPa.
-
-        Raises:
-            ValueError: If value is lower than fck.
-        """
-        if abs(value) <= self._fck:
-            raise ValueError(
-                (
-                    'Mean compressive strength cannot be lower than',
-                    'characteristic strength.\n',
-                    'Current characteristing strength: ',
-                    f'fck = {self._fck}.',
-                    f'Current value: value = {value}',
-                )
-            )
-        self._fcm = abs(value)
-
     @property
     def fctm(self) -> float:
         """Returns fctm in MPa.
 
         Returns:
             float: The mean tensile strength in MPa.
+
+        Note:
+            The returned value is derived from fck if fctm is not manually
+            provided when initializing the object.
         """
         if self._fctm is None:
-            self._fctm = ec2_2004.fctm(self._fck)
+            return ec2_2004.fctm(self._fck)
         return self._fctm
 
-    @fctm.setter
-    def fctm(self, value: float):
-        """Sets a user defined value for fctm.
-
-        Arguments:
-            value (float): The value of fctm in MPa.
-        """
-        if value > 0.5 * self._fck:
-            warnings.warn(
-                'A suspect value of fctm has been input. Please check.'
-            )
-        self._fctm = abs(value)
-
     @property
     def fctk_5(self) -> float:
         """Returns fctk_5 in MPa.
 
         Returns:
             float: The lower bound tensile strength in MPa.
-        """
-        if self._fctk_5 is not None:
-            return self._fctk_5
-        return ec2_2004.fctk_5(self.fctm)
-
-    @fctk_5.setter
-    def fctk_5(self, value: float):
-        """Sets a user defined value for fctk_5.
 
-        Arguments:
-            value (float): The value of fctk_5 in MPa.
+        Note:
+            The returned value is derived from fctm if fctk_5 is not manually
+            provided when initializing the object.
         """
-        self._fctk_5 = abs(value)
+        if self._fctk_5 is None:
+            return ec2_2004.fctk_5(self.fctm)
+        return self._fctk_5
 
     @property
     def fctk_95(self) -> float:
@@ -161,20 +304,14 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
 
         Returns:
             float: The upper bound tensile strength in MPa.
-        """
-        if self._fctk_95 is not None:
-            return self._fctk_95
-
-        return ec2_2004.fctk_95(self.fctm)
 
-    @fctk_95.setter
-    def fctk_95(self, value: float):
-        """Sets a user defined value for fctk_95.
-
-        Arguments:
-            value (float): The value of fctk_95 in MPa.
+        Note:
+            The returned value is derived from fctm if fctk_95 is not manually
+            provided when initializing the object.
         """
-        self._fctk_95 = abs(value)
+        if self._fctk_95 is None:
+            return ec2_2004.fctk_95(self.fctm)
+        return self._fctk_95
 
     @property
     def Ecm(self) -> float:
@@ -182,20 +319,14 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
 
         Returns:
             float: The upper bound tensile strength in MPa.
-        """
-        if self._Ecm is not None:
-            return self._Ecm
-
-        return ec2_2004.Ecm(self.fcm)
-
-    @Ecm.setter
-    def Ecm(self, value: float):
-        """Sets a user defined value for Ecm.
 
-        Arguments:
-            value (float): The value of Ecm in MPa.
+        Note:
+            The returned value is derived from fcm if Ecm is not manually
+            provided when initializing the object.
         """
-        self._Ecm = abs(value)
+        if self._Ecm is None:
+            return ec2_2004.Ecm(self.fcm)
+        return self._Ecm
 
     def fcd(self) -> float:
         """Return the design compressive strength in MPa.
@@ -230,24 +361,14 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
 
         Returns:
             float: The strain at maximum compressive strength of concrete.
-        """
-        self._eps_c1 = self._eps_c1 or ec2_2004.eps_c1(self.fcm)
-        return self._eps_c1
-
-    @eps_c1.setter
-    def eps_c1(self, value: float):
-        """Sets a user defined value for strain at peak strength for Sargin
-        constitutive law.
 
-        Arguments:
-            value (float): The new value for eps_c1, no units.
+        Note:
+            The returned value is derived from fcm if eps_c1 is not manually
+            provided when initializing the object.
         """
-        if abs(value) >= 0.1:
-            warnings.warn(
-                'A suspect value is input for eps_c1 that should be a pure'
-                ' number without units. Plase check ({value} given).'
-            )
-        self._eps_c1 = value
+        if self._eps_c1 is None:
+            return ec2_2004.eps_c1(self.fcm)
+        return self._eps_c1
 
     @property
     def eps_cu1(self) -> float:
@@ -255,23 +376,14 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
 
         Returns:
             float: The maximum strength at failure of concrete.
-        """
-        self._eps_cu1 = self._eps_cu1 or ec2_2004.eps_cu1(self.fcm)
-        return self._eps_cu1
-
-    @eps_cu1.setter
-    def eps_cu1(self, value: float):
-        """Sets the nominal ultimate strain for Sargin constitutive law.
 
-        Arguments:
-            value (float): The new value for eps_cu1, no units.
+        Note:
+            The returned value is derived from fcm if eps_cu1 is not manually
+            provided when initializing the object.
         """
-        if abs(value) >= 0.1:
-            warnings.warn(
-                'A suspect value is input for eps_cu1 that should be a pure'
-                ' number without units. Plase check ({value} given).'
-            )
-        self._eps_cu1 = value
+        if self._eps_cu1 is None:
+            return ec2_2004.eps_cu1(self.fcm)
+        return self._eps_cu1
 
     @property
     def k_sargin(self) -> float:
@@ -279,27 +391,18 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
 
         Returns:
             float: The plastic coefficient for Sargin law.
-        """
-        self._k_sargin = self._k_sargin or ec2_2004.k_sargin(
-            Ecm=self.Ecm,
-            fcm=self.fcm,
-            eps_c1=self.eps_c1,
-        )
-        return self._k_sargin
-
-    @k_sargin.setter
-    def k_sargin(self, value: float):
-        """Sets the the coefficient for Sargin constitutive law.
 
-        Arguments:
-            value (float): The new value for k, no units.
-
-        Raises:
-            ValueError: If value < 0.
+        Note:
+            The returned value is derived from Ecm, fcm and eps_c1 if k_sargin
+            is not manually provided when initializing the object.
         """
-        if value < 0:
-            raise ValueError(f'n should be a positive value ({value} given)')
-        self._k_sargin = value
+        if self._k_sargin is None:
+            return ec2_2004.k_sargin(
+                Ecm=self.Ecm,
+                fcm=self.fcm,
+                eps_c1=self.eps_c1,
+            )
+        return self._k_sargin
 
     @property
     def eps_c2(self) -> float:
@@ -308,24 +411,14 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
 
         Returns:
             float: The strain at maximum compressive strength of concrete.
-        """
-        self._eps_c2 = self._eps_c2 or ec2_2004.eps_c2(self.fck)
-        return self._eps_c2
-
-    @eps_c2.setter
-    def eps_c2(self, value: float):
-        """Sets the strain at maximum compressive strength of concrete (fcd)
-        for the Parabola-rectangle constitutive law.
 
-        Arguments:
-            value (float): The new value for eps_c2, no units.
+        Note:
+            The returned value is derived from fck if eps_c2 is not manually
+            provided when initializing the object.
         """
-        if abs(value) >= 0.1:
-            warnings.warn(
-                'A suspect value is input for eps_c2 that should be a pure'
-                ' number without units. Plase check ({value} given).'
-            )
-        self._eps_c2 = value
+        if self._eps_c2 is None:
+            return ec2_2004.eps_c2(self.fck)
+        return self._eps_c2
 
     @property
     def eps_cu2(self) -> float:
@@ -334,24 +427,14 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
 
         Returns:
             float: The maximum strain at failure of concrete.
-        """
-        self._eps_cu2 = self._eps_cu2 or ec2_2004.eps_cu2(self.fck)
-        return self._eps_cu2
-
-    @eps_cu2.setter
-    def eps_cu2(self, value: float):
-        """Sets the strain at concrete failure of concrete for the
-        Parabola-rectangle constitutive law.
 
-        Arguments:
-            value (float): The new value for eps_cu2, no units.
+        Note:
+            The returned value is derived from fck if eps_cu2 is not manually
+            provided when initializing the object.
         """
-        if abs(value) >= 0.1:
-            warnings.warn(
-                'A suspect value is input for eps_cu2 that should be a pure'
-                ' number without units. Plase check ({value} given).'
-            )
-        self._eps_cu2 = value
+        if self._eps_cu2 is None:
+            return ec2_2004.eps_cu2(self.fck)
+        return self._eps_cu2
 
     @property
     def n_parabolic_rectangular(self) -> float:
@@ -359,31 +442,14 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
 
         Returns:
             float: The exponent for Parabola-rectangle law.
-        """
-        self._n_parabolic_rectangular = (
-            self._n_parabolic_rectangular
-            or ec2_2004.n_parabolic_rectangular(self.fck)
-        )
-        return self._n_parabolic_rectangular
-
-    @n_parabolic_rectangular.setter
-    def n_parabolic_rectangular(self, value: float):
-        """Sets the coefficient for Parabola-rectangle constitutive law.
 
-        Arguments:
-            value (float): The new value for n, no units.
-
-        Raises:
-            ValueError: If value < 0.
+        Note:
+            The returned value is derived from fck if n_parabolic_rectangular
+            is not manually provided when initializing the object.
         """
-        if value < 0:
-            raise ValueError(f'n should be a positive value ({value} given)')
-        if value >= 5:
-            warnings.warn(
-                'A suspect value is input for eps_cu2 that should be a pure'
-                ' number without units. Plase check ({value} given).'
-            )
-        self._n_parabolic_rectangular = value
+        if self._n_parabolic_rectangular is None:
+            return ec2_2004.n_parabolic_rectangular(self.fck)
+        return self._n_parabolic_rectangular
 
     @property
     def eps_c3(self) -> float:
@@ -392,24 +458,14 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
 
         Returns:
             float: The strain at maximum compressive strength of concrete.
-        """
-        self._eps_c3 = self._eps_c3 or ec2_2004.eps_c3(self.fck)
-        return self._eps_c3
-
-    @eps_c3.setter
-    def eps_c3(self, value: float):
-        """Sets the strain at maximum compressive strength of concrete (fcd)
-        for the Bi-linear constitutive law.
 
-        Arguments:
-            value (float): The new value for eps_c3, no units.
+        Note:
+            The returned value is derived from eps_c3 if fck is not manually
+            provided when initializing the object.
         """
-        if abs(value) >= 0.1:
-            warnings.warn(
-                'A suspect value is input for eps_c3 that should be a pure'
-                ' number without units. Plase check ({value} given).'
-            )
-        self._eps_c3 = value
+        if self._eps_c3 is None:
+            return ec2_2004.eps_c3(self.fck)
+        return self._eps_c3
 
     @property
     def eps_cu3(self) -> float:
@@ -418,24 +474,14 @@ class ConcreteEC2_2004(Concrete):  # noqa: N801
 
         Returns:
             float: The maximum strain at failure of concrete.
-        """
-        self._eps_cu3 = self._eps_cu3 or ec2_2004.eps_cu3(self.fck)
-        return self._eps_cu3
-
-    @eps_cu3.setter
-    def eps_cu3(self, value: float):
-        """Sets the strain at concrete failure of concrete for the Bi-linear
-        constitutive law.
 
-        Arguments:
-            value (float): The new value for eps_cu3, no units.
+        Note:
+            The returned value is derived from fck if eps_cu3 is not manually
+            provided when initializing the object.
         """
-        if abs(value) >= 0.1:
-            warnings.warn(
-                'A suspect value is input for eps_cu3 that should be a pure'
-                ' number without units. Plase check ({value} given).'
-            )
-        self._eps_cu3 = value
+        if self._eps_cu3 is None:
+            return ec2_2004.eps_cu3(self.fck)
+        return self._eps_cu3
 
     def __elastic__(self) -> dict:
         """Returns kwargs for creating an elastic constitutive law."""