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

structuralcodes/materials/concrete/_concreteEC2_2023.py

@@ -5,17 +5,15 @@ import warnings
 
 from structuralcodes.codes import ec2_2023
 
+from ..constitutive_laws import ConstitutiveLaw, create_constitutive_law
 from ._concrete import Concrete
 
 
 class ConcreteEC2_2023(Concrete):  # noqa: N801
     """Concrete implementation for EC2 2023 Concrete."""
 
-    # Inherent concrete properties
     _kE: t.Optional[float] = None  # noqa: N815
     _strength_dev_class: t.Optional[str] = None
-
-    # Computed attributes
     _fcm: t.Optional[float] = None
     _fctm: t.Optional[float] = None
     _Ecm: t.Optional[float] = None
@@ -38,7 +36,29 @@ class ConcreteEC2_2023(Concrete):  # noqa: N801
             'CS', 'CN', 'CR', 'slow', 'normal', 'rapid'
         ] = 'CN',
         gamma_c: t.Optional[float] = None,
-        existing: bool = False,
+        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,
         **kwargs,
     ):
         """Initializes a new instance of Concrete for EC2 2023.
@@ -55,84 +75,185 @@ class ConcreteEC2_2023(Concrete):  # noqa: N801
                 CS, CN, CR, slow, normal or rapid.
             gamma_c (float, optional): Partial factor of concrete (default is
                 1.5).
-            existing (bool, optional): The material is of an existing structure
-                (default: False).
+            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.
+
+        Raises:
+            ValueError: If the provided strength development class is invalid.
+            ValueError: If gamma_c is less than zero.
+            ValueError: If fcm is less 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.
+            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.
         """
         del kwargs
         if name is None:
             name = f'C{round(fck):d}'
 
-        # Check if strength_dev_class is valid
-        strength_dev_class = strength_dev_class.strip()
-        valid_dev_classes = ('cs', 'cn', 'cr', 'slow', 'normal', 'rapid')
-        if strength_dev_class.lower() not in valid_dev_classes:
-            raise ValueError(
-                'strength_dev_class not valid. '
-                + f'{strength_dev_class} not {valid_dev_classes}'
-            )
-
-        # Check for valid security coeff
-        if gamma_c is not None and gamma_c <= 0:
-            raise ValueError(
-                f'gamma_c cannot be less than zero. Current: {gamma_c}'
-            )
-
         super().__init__(
             fck=fck,
             name=name,
             density=density,
-            existing=existing,
+            existing=False,
             gamma_c=gamma_c,
         )
         self._kE = kE
-        self._strength_dev_class = strength_dev_class
-
-    def _reset_attributes(self):
-        """Reset computed properties."""
-        # We only need to reset computed properties
-        self._fcm = None
-        self._fctm = None
-        self._Ecm = None
-        self._fctk_5 = None
-        self._fctk_95 = 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._strength_dev_class = strength_dev_class.strip().lower()
+        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
+        )
 
-    @property
-    def fcm(self) -> float:
-        """Returns the mean strength of concrete.
+        self.__post_init__()
 
-        Returns:
-            float: The mean compressive strength in MPa.
-        """
-        self._fcm = self._fcm or ec2_2023.fcm(self.fck)
-        return self._fcm
+        # 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.'
+            )
 
-    @fcm.setter
-    def fcm(self, value: float):
-        """Sets a user defined value for the mean strength of concrete.
+    def __post_init__(self):
+        """Validator for the attributes that are set in the constructor."""
+        # Check if strength_dev_class is valid
+        valid_dev_classes = ('cs', 'cn', 'cr', 'slow', 'normal', 'rapid')
+        if self._strength_dev_class not in valid_dev_classes:
+            raise ValueError(
+                'strength_dev_class not valid. '
+                + f'{self._strength_dev_class} not {valid_dev_classes}'
+            )
 
-        Arguments:
-            value (float): the value of the mean strength of concrete in MPa.
+        # Check for valid partial factor
+        if self._gamma_c is not None and self._gamma_c <= 0:
+            raise ValueError(
+                f'gamma_c cannot be less than zero. Current: {self._gamma_c}'
+            )
 
-        Raises:
-            ValueError: If value is less or equal than the value of fck.
-        """
-        if abs(value) <= self._fck:
+        # Check the mean compressive strength
+        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 = {value}',
+                    f'Current value: value = {self._fcm}',
                 )
             )
-        self._fcm = value
+
+        # 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).'
+            )
+
+        # Check 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).'
+            )
+
+        # Check 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)'
+            )
+
+        # Check 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).'
+            )
+
+        # Check 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).'
+            )
+
+        # Check 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 eps_cu2 that should be a pure'
+                ' number without units. Please check '
+                f'({self._n_parabolic_rectangular} given).'
+            )
+
+    @property
+    def fcm(self) -> float:
+        """Returns the mean strength of concrete.
+
+        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:
+            return ec2_2023.fcm(self.fck)
+        return self._fcm
 
     @property
     def fctm(self) -> None:
@@ -140,38 +261,43 @@ class ConcreteEC2_2023(Concrete):  # noqa: N801
 
         Returns:
             float: The mean concrete tensile strength.
-        """
-        self._fctm = self._fctm or ec2_2023.fctm(self.fck)
-        return self._fctm
 
-    @fctm.setter
-    def fctm(self, value: float):
-        """Sets a custom user defined value for the concrete tensile strength
-        for the concrete.
-
-        Arguments:
-            value (float): The new value for fctm in MPa.
+        Note:
+            The returned value is derived from fck if fctm is not manually
+            provided when initializing the object.
         """
-        self._fctm = value
+        if self._fctm is None:
+            return ec2_2023.fctm(self.fck)
+        return self._fctm
 
     @property
     def fctk_5(self) -> float:
-        """Returns the 5% mean concrete tensile strength fractile.
+        """Returns the 5% fractile for the concrete tensile strength.
 
         Returns:
-            float: The 5% mean concrete tensile strength fractile in MPa.
+            float: The 5% fractile for the concrete tensile strength in MPa.
+
+        Note:
+            The returned value is derived from fctm if fctk_5 is not manually
+            provided when initializing the object.
         """
-        self._fctk_5 = self._fctk_5 or ec2_2023.fctk_5(self.fctm)
+        if self._fctk_5 is None:
+            return ec2_2023.fctk_5(self.fctm)
         return self._fctk_5
 
     @property
     def fctk_95(self) -> float:
-        """Returns the 95% mean concrete tensile strength fractile.
+        """Returns the 95% fractile for the concrete tensile strength.
 
         Returns:
-            float: The 5% mean concrete tensile strength fractile in MPa.
+            float: The 5% fractile for the concrete tensile strength in MPa.
+
+        Note:
+            The returned value is derived from fctm if fctk_95 is not manually
+            provided when initializing the object.
         """
-        self._fctk_95 = self._fctk_95 or ec2_2023.fctk_95(self.fctm)
+        if self._fctk_95 is None:
+            return ec2_2023.fctk_95(self.fctm)
         return self._fctk_95
 
     @property
@@ -180,18 +306,14 @@ class ConcreteEC2_2023(Concrete):  # noqa: N801
 
         Returns:
             float: The secant concrete modulus in MPa.
-        """
-        self._Ecm = self._Ecm or ec2_2023.Ecm(self.fcm, self._kE)
-        return self._Ecm
-
-    @Ecm.setter
-    def Ecm(self, value: float) -> None:
-        """Sets the secant modulus.
 
-        Arguments:
-            float: The secand modulus value in MPa.
+        Note:
+            The returned value is derived from fcm and kE if Ecm is not
+            manually provided when initializing the object.
         """
-        self._Ecm = value
+        if self._Ecm is None:
+            return ec2_2023.Ecm(self.fcm, self._kE)
+        return self._Ecm
 
     def fcd(
         self, t_ref: float = 28, t0: float = 91, fck_ref: float = 40
@@ -242,24 +364,14 @@ class ConcreteEC2_2023(Concrete):  # noqa: N801
 
         Returns:
             float: The strain at maximum compressive strength of concrete.
-        """
-        self._eps_c1 = self._eps_c1 or ec2_2023.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_2023.eps_c1(self.fcm)
+        return self._eps_c1
 
     @property
     def eps_cu1(self) -> float:
@@ -267,23 +379,14 @@ class ConcreteEC2_2023(Concrete):  # noqa: N801
 
         Returns:
             float: The maximum strength at failure of concrete.
-        """
-        self._eps_cu1 = self._eps_cu1 or ec2_2023.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_2023.eps_cu1(self.fcm)
+        return self._eps_cu1
 
     @property
     def k_sargin(self) -> float:
@@ -291,27 +394,18 @@ class ConcreteEC2_2023(Concrete):  # noqa: N801
 
         Returns:
             float: k coefficient for Sargin constitutive law.
-        """
-        self._k_sargin = self._k_sargin or ec2_2023.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_2023.k_sargin(
+                Ecm=self.Ecm,
+                fcm=self.fcm,
+                eps_c1=self.eps_c1,
+            )
+        return self._k_sargin
 
     @property
     def eps_c2(self) -> float:
@@ -320,24 +414,14 @@ class ConcreteEC2_2023(Concrete):  # noqa: N801
 
         Returns:
             float: The strain at maximum compressive strength of concrete.
-        """
-        self._eps_c2 = self._eps_c2 or ec2_2023.eps_c2()
-        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 the default value in the design code if 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_2023.eps_c2()
+        return self._eps_c2
 
     @property
     def eps_cu2(self) -> float:
@@ -346,24 +430,14 @@ class ConcreteEC2_2023(Concrete):  # noqa: N801
 
         Returns:
             float: The maximum strain at failure of concrete.
-        """
-        self._eps_cu2 = self._eps_cu2 or ec2_2023.eps_cu2()
-        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 the default value in the design code if 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_2023.eps_cu2()
+        return self._eps_cu2
 
     @property
     def n_parabolic_rectangular(self) -> float:
@@ -371,30 +445,14 @@ class ConcreteEC2_2023(Concrete):  # noqa: N801
 
         Returns:
             float: The exponent for Parabola-recangle law.
-        """
-        self._n_parabolic_rectangular = (
-            self._n_parabolic_rectangular or ec2_2023.n_parabolic_rectangular()
-        )
-        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 the default value in the design code if 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_2023.n_parabolic_rectangular()
+        return self._n_parabolic_rectangular
 
     @property
     def gamma_c(self) -> float: