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

structuralcodes/__init__.py

@@ -3,7 +3,7 @@
 from . import codes, core, geometry, materials, sections
 from .codes import get_design_codes, set_design_code, set_national_annex
 
-__version__ = '0.2.0'
+__version__ = '0.3.1'
 
 __all__ = [
     'set_design_code',

structuralcodes/codes/ec2_2004/_concrete_creep_and_shrinkage.py

@@ -62,7 +62,7 @@ def eps_cd(
     return beta_ds * k_h * eps_cd_0
 
 
-def beta_ds(t: npt.ArrayLike, t_s: float, h_0: float):
+def beta_ds(t: npt.ArrayLike, t_s: float, h_0: float) -> npt.ArrayLike:
     """Calculate the coefficient taking into account the time of drying.
 
     EN 1992-1-1:2004, Eq. (3.10).

structuralcodes/codes/mc2010/_concrete_creep_and_shrinkage.py

@@ -180,41 +180,52 @@ def _check_env_temp(T: float) -> None:
 
 
 def t_T(
-    t0: npt.ArrayLike, T_cur: npt.ArrayLike, dt: npt.ArrayLike = None
-) -> np.ndarray:
-    """Calculate the temperature corrected concrete age in days at t0.
+    T_cur: t.Union[npt.ArrayLike, float],
+    dt: t.Union[npt.ArrayLike, float],
+) -> float:
+    """Calculate the temperature corrected concrete age in days.
 
-    Defined in fib Model Code 2010 (2013). Eq. 5.1-85 (only for a single time
-    value input, as required in Eq. 5.1-73).
+    Defined in fib Model Code 2010 (2013). Eq. 5.1-85.
 
     Args:
-        t0 (np.typing.ArrayLike): The age of the concrete in days at which the
-            loading is applied.
-        T_cur (np.typing.ArrayLike): The temperature of the environment during
-            curing in degrees Celcius.
-
-    Keyword Args:
-        dt (np.typing.ArrayLike): Number of days at which T_cur prevails.
-            Required when providing a list for T_cur.
+        T_cur (Union(ArrayLike, float)): The temperature of the environment
+            during curing in degrees Celcius.
+        dt (Union(ArrayLike, float)): Number of days at which T_cur
+            prevails.
 
     Returns:
-        np.ndarray: The temperature corrected age of the concrete in days at
+        float: The temperature corrected age of the concrete in days at
         loading.
     """
-    _check_age_at_loading(t0)
-    if dt is None:
-        dt = t0
-    else:
-        T_cur = np.asarray(T_cur)
-        dt = np.asarray(dt)
-        if T_cur.size != dt.size:
-            raise ValueError('Dimensions of T_cur and dt do not match.')
-        if np.sum(dt) != t0:
-            raise ValueError(
-                f'Curing time {np.sum(dt)} and time of loading {t0} do not'
-                ' match.'
+    # Prepare the input
+    T_cur = T_cur if np.isscalar(T_cur) else np.atleast_1d(T_cur)
+    dt = dt if np.isscalar(dt) else np.atleast_1d(dt)
+
+    # Check that both are scalar or both are arrays
+    if any(np.isscalar(this_check) for this_check in (T_cur, dt)) and any(
+        not np.isscalar(this_check) for this_check in (T_cur, dt)
+    ):
+        raise ValueError(
+            (
+                f'T ({type(T_cur)}) and dt ({type(dt)}) should either both be '
+                'ArrayLike or scalars.'
             )
-    return np.sum(dt * np.exp(13.65 - (4000 / (273 + T_cur))))
+        )
+
+    # Check the shape of the input arrays
+    if (
+        not all((np.isscalar(T_cur), np.isscalar(dt)))
+        and T_cur.shape != dt.shape
+    ):
+        raise ValueError(
+            f'T_cur {T_cur.shape} and dt {dt.shape} should have the same '
+            'shape.'
+        )
+
+    # Return the sum of the temperature adjusted time increments
+    if not all((np.isscalar(T_cur), np.isscalar(dt))):
+        return float(np.sum(np.exp(13.65 - 4000 / (273 + T_cur)) * dt))
+    return np.exp(13.65 - 4000 / (273 + T_cur)) * dt
 
 
 def t0_adj(
@@ -274,25 +285,29 @@ def eps_cds0(
 
 
 def beta_ds(
-    time: npt.ArrayLike, ts: float, notional_size: float
-) -> np.ndarray:
+    time: t.Union[npt.ArrayLike, float], ts: float, notional_size: float
+) -> t.Union[npt.ArrayLike, float]:
     """Calculate the multiplication factor beta_ds.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-82.
 
     Args:
-        time (numpy.typing.ArrayLike): The different times in days at which the
-            shrinkage strain is determined.
+        time (Union(ArrayLike, float)): The different times in days at which
+            the shrinkage strain is determined.
         ts (float): Age of the concrete when exposed to the environment.
         notional_size (float): The notional size of the considered element in
             mm, defined as 2A/u.
 
     Returns:
-        numpy.ndarray: Multiplication factor used for calculating the drying
-        shrinkage as a function of time.
+        Union(ArrayLike, float): Multiplication factor used for calculating the
+        drying shrinkage as a function of time.
     """
-    time_drying = np.atleast_1d(time - ts)
-    time_drying[time_drying < 0.0] = 0.0
+    time = time if np.isscalar(time) else np.atleast_1d(time)
+    time_drying = time - ts
+    if np.isscalar(time_drying):
+        time_drying = max(time_drying, 0.0)
+    else:
+        time_drying[time_drying < 0.0] = 0.0
     return np.sqrt(time_drying / (0.035 * (notional_size) ** 2 + time_drying))
 
 
@@ -341,9 +356,9 @@ def beta_RH(rh: float, beta_s1: float) -> float:
 
 def eps_cds(
     eps_cds0: float,
-    beta_ds: npt.ArrayLike,
+    beta_ds: t.Union[npt.ArrayLike, float],
     beta_rh: float,
-) -> np.ndarray:
+) -> t.Union[npt.ArrayLike, float]:
     """Calculate the drying shrinkage of the concrete element.
 
     Defined in fib Model Code 2010 (2013), Eqs. 5.1-77.
@@ -351,15 +366,15 @@ def eps_cds(
     Args:
         eps_cds0 (float):  The notional drying shrinkage, no units, as defined
             in fib Model Code 2010 (2013), Eq. 5.1-80.
-        beta_ds (numpy.typing.ArrayLike): Multiplication factor used for
+        beta_ds (Union(ArrayLike, float)): Multiplication factor used for
             calculating the drying shrinkage as a function of time, as defined
             in fib Model Code 2010 (2013), Eq. 5.1-82.
         beta_rh (float): Multiplication factor used when calculating the
             drying shrinkage.
 
     Returns:
-        numpy.ndarray: The drying shrinkage strains for the given times, no
-        units.
+        Union(ArrayLike, float): The drying shrinkage strains for the given
+        times, no units.
     """
     return eps_cds0 * beta_rh * beta_ds
 
@@ -386,24 +401,28 @@ def eps_cbs0(
     return -ALPHA_BS[cem_class] * ((0.1 * fcm) / (6 + 0.1 * fcm)) ** 2.5 * 1e-6
 
 
-def beta_bs(time: npt.ArrayLike) -> np.ndarray:
+def beta_bs(
+    time: t.Union[npt.ArrayLike, float],
+) -> t.Union[npt.ArrayLike, float]:
     """Calculate multiplication factor beta_bs which is used to determine the
     basic shrinkage.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-79.
 
     Args:
-        time (numpy.typing.ArrayLike): The different times in days at which the
-            basic strain is determined.
+        time (Union(ArrayLike, float)): The different times in days at which
+            the basic strain is determined.
 
     Returns:
-        numpy.ndarray: Multiplication factor that is used to determine the
-        basic shrinkage.
+        Union(ArrayLike, float): Multiplication factor that is used to
+        determine the basic shrinkage.
     """
     return 1 - np.exp(-0.2 * np.sqrt(time))
 
 
-def eps_cbs(eps_cbs0: float, beta_bs: npt.ArrayLike) -> np.ndarray:
+def eps_cbs(
+    eps_cbs0: float, beta_bs: t.Union[npt.ArrayLike, float]
+) -> t.Union[npt.ArrayLike, float]:
     """Calculate the basic shrinkage.
 
     Defined in fib Model Code 2010 (2013), Eqs. 5.1-76.
@@ -411,11 +430,12 @@ def eps_cbs(eps_cbs0: float, beta_bs: npt.ArrayLike) -> np.ndarray:
     Args:
         eps_cbs0 (float): Notional basic shrinkage, as defined in fib Model
             Code 2010 (2013), Eq. 5.1-78.
-        beta_bs (numpy.typing.ArrayLike): Time function for basic shrinkage,
+        beta_bs (Union(ArrayLike, float)): Time function for basic shrinkage,
             as defined in fib Model Code 2010 (2013), Eq. 5.1-79.
 
     Returns:
-        numpy.ndarray: The basic shrinkage strains for the given times.
+        Union(ArrayLike, float): The basic shrinkage strains for the given
+        times.
     """
     return eps_cbs0 * beta_bs
 
@@ -436,15 +456,17 @@ def beta_bc_fcm(fcm: float) -> float:
     return 1.8 / fcm**0.7
 
 
-def beta_bc_t(time: npt.ArrayLike, t0: float, t0_adj: float) -> np.ndarray:
+def beta_bc_t(
+    time: t.Union[npt.ArrayLike, float], t0: float, t0_adj: float
+) -> t.Union[npt.ArrayLike, float]:
     """Calculate multiplication factor that accounts for the effect of the age
     of the of the concrete to calculate the basic creep coefficient.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-66.
 
     Args:
-        time (numpy.typing.ArrayLike): The different times in days at which the
-            basic creep coefficient is determined.
+        time (Union(ArrayLike, float)): The different times in days at which
+            the basic creep coefficient is determined.
         t0 (float): The age of the concrete in days at which the loading is
             applied.
         t0_adj (float): The temperature corrected age of the concrete when the
@@ -452,12 +474,14 @@ def beta_bc_t(time: npt.ArrayLike, t0: float, t0_adj: float) -> np.ndarray:
             (2013). Eq. 5.1-85.
 
     Returns:
-        numpy.ndarray: Multiplication factors beta_bc_t.
+        Union(ArrayLike, float): Multiplication factors beta_bc_t.
     """
     return np.log(((30 / t0_adj + 0.035) ** 2) * (time - t0) + 1)
 
 
-def phi_bc(beta_bc_fcm: float, beta_bc_t: npt.ArrayLike) -> np.ndarray:
+def phi_bc(
+    beta_bc_fcm: float, beta_bc_t: t.Union[npt.ArrayLike, float]
+) -> t.Union[npt.ArrayLike, float]:
     """Calculate the basic creep coefficient.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-64.
@@ -466,12 +490,12 @@ def phi_bc(beta_bc_fcm: float, beta_bc_t: npt.ArrayLike) -> np.ndarray:
         beta_bc_fcm (float): Multiplication factor that accounts for the
             influence of the concrete strength of the creep behaviour, as
             defined in fib Model Code 2010 (2013), Eq. 5.1-65.
-        beta_bc_t (numpy.typing.ArrayLike): Multiplication factor that
+        beta_bc_t (Union(ArrayLike, float)): Multiplication factor that
             accounts for the influence of the age of the concrete of the creep
             behaviour, as defined in fib Model Code 2010 (2013), Eq. 5.1-66.
 
     Returns:
-        numpy.ndarray: The basic creep coefficient.
+        Union(ArrayLike, float): The basic creep coefficient.
     """
     return beta_bc_fcm * beta_bc_t
 
@@ -583,16 +607,19 @@ def gamma_t0(t0_adj: float) -> float:
 
 
 def beta_dc_t(
-    time: npt.ArrayLike, t0: float, beta_h: float, gamma_t0: float
-) -> np.ndarray:
+    time: t.Union[npt.ArrayLike, float],
+    t0: float,
+    beta_h: float,
+    gamma_t0: float,
+) -> t.Union[npt.ArrayLike, float]:
     """Calculate multiplication factor that accounts for the different
     considered values of time. Used to calculate the drying creep coefficient.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-71a.
 
     Args:
-        time (numpy.typing.ArrayLike): The different times in days at which the
-            drying creep coefficient is determined.
+        time (Union(ArrayLike, float)): The different times in days at which
+            the drying creep coefficient is determined.
         t0 (float): The age of the concrete concrete when the loading is
             applied in days.
         beta_h (float): Multiplication factor that accounts for the effect of
@@ -602,8 +629,8 @@ def beta_dc_t(
             calculated by Eq. 5.1-71b.
 
     Returns:
-        numpy.ndarray: Multiplcation factor beta_dc_t for the considered values
-        of time.
+        Union(ArrayLike, float): Multiplcation factor beta_dc_t for the
+        considered values of time.
     """
     return ((time - t0) / (beta_h + (time - t0))) ** gamma_t0
 
@@ -612,8 +639,8 @@ def phi_dc(
     beta_dc_fcm: float,
     beta_dc_RH: float,
     beta_dc_t0: float,
-    beta_dc_t: npt.ArrayLike,
-) -> np.ndarray:
+    beta_dc_t: t.Union[npt.ArrayLike, float],
+) -> t.Union[npt.ArrayLike, float]:
     """Calculate drying creep coefficient.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-67.
@@ -628,12 +655,12 @@ def phi_dc(
         beta_dc_t0 (float): multiplication factor that accounts for the effect
             of the (temperature corrected) age of the concrete when loading is
             applied, as calculated by Eq. 5.1-70.
-        beta_dc_t (numpy.typing.ArrayLike): multiplication factor that
+        beta_dc_t (Union(ArrayLike, float)): multiplication factor that
             accounts for the different considered values of time, as calculated
             by Eq. 5.1-71a.
 
     Returns:
-        numpy.ndarray: Drying creep coeffcient.
+        Union(ArrayLike, float): Drying creep coeffcient.
     """
     return beta_dc_fcm * beta_dc_RH * beta_dc_t0 * beta_dc_t
 
@@ -658,8 +685,11 @@ def k_sigma(sigma: float, fcm: float) -> float:
 
 
 def phi(
-    phi_bc: npt.ArrayLike, phi_dc: npt.ArrayLike, sigma: float, fcm: float
-) -> np.ndarray:
+    phi_bc: t.Union[npt.ArrayLike, float],
+    phi_dc: t.Union[npt.ArrayLike, float],
+    sigma: float,
+    fcm: float,
+) -> t.Union[npt.ArrayLike, float]:
     """Calculate the creep coefficient distinguishing between linear and
     non-linear creep for compressive stresses sigma <= 0.4fcm, and 0.4fcm <
     sigma <= 0.6fcm, respectively.
@@ -667,16 +697,16 @@ def phi(
     Defined in fib Model Code 2010, Eqs. 5.1-63 and 5.1-74.
 
     Args:
-        phi_bc (numpy.typing.ArrayLike): Basic creep coefficient, as defined
+        phi_bc (Union(ArrayLike, float)): Basic creep coefficient, as defined
             in fib Model Code 2010 (2013), Eq. 5.1-64.
-        phi_dc (numpy.typing.ArrayLike): Drying creep coefficient, as defined
+        phi_dc (Union(ArrayLike, float)): Drying creep coefficient, as defined
             in fib Model Code 2010 (2013), Eq. 5.1-67.
         sigma (float): The compressive stress applied to the concrete at ts in
             MPa.
         fcm (float): The mean compressive strength of the concrete in MPa.
 
     Returns:
-        numpy.ndarray: The creep coefficient.
+        Union(ArrayLike, float): The creep coefficient.
     """
     # Calculate the creep coefficient (phi) (see Eq. 5.1-63)
     _phi = phi_bc + phi_dc
@@ -687,7 +717,9 @@ def phi(
     return _phi
 
 
-def calc_J(E_ci_t0: float, phi: npt.ArrayLike, E_ci: float) -> np.ndarray:
+def calc_J(
+    E_ci_t0: float, phi: t.Union[npt.ArrayLike, float], E_ci: float
+) -> t.Union[npt.ArrayLike, float]:
     """Calculate the creep compliance function.
 
     Defined in fib Model Code 2010, Eq. 5.1-61.
@@ -695,12 +727,12 @@ def calc_J(E_ci_t0: float, phi: npt.ArrayLike, E_ci: float) -> np.ndarray:
     Args:
         E_ci_t0 (float): Modulus of elasticity at time of loading t0, as
             defined in fib Model Code 2010 (2013), Eq. 5.1-56.
-        phi (numpy.typing.ArrayLike): Creep coefficient, as defined in fib
+        phi (Union(ArrayLike, float)): Creep coefficient, as defined in fib
             Model Code 2010 (2013), Eq. 5.1-63.
         E_ci (float) Modulus of elasticity of the concrete at 28 days, as
             defined in fib Model Code 2010 (2013), Eq. 5.1-21.
 
     Returns:
-        numpy.ndarray: The creep compliance function.
+        Union(ArrayLike, float): The creep compliance function.
     """
     return (1 / E_ci_t0) + (phi / E_ci)

structuralcodes/core/_section_results.py

@@ -8,8 +8,8 @@ from numpy.typing import ArrayLike
 
 
 @dataclass
-class GrossProperties:
-    """Simple dataclass for storing gross section properties."""
+class SectionProperties:
+    """Simple dataclass for storing section properties."""
 
     # section areas
     area: float = field(default=0, metadata={'description': 'Total area'})
@@ -108,7 +108,7 @@ class GrossProperties:
         Arguments:
             spec (str): The string specifying the format.
         """
-        output_string = 'Gross Concrete Section Properties:\n'
+        output_string = 'Section Properties:\n'
         for f in fields(self):
             value = getattr(self, f.name)
             description = f.metadata.get(
@@ -120,26 +120,12 @@ class GrossProperties:
         return output_string
 
     def __str__(self) -> str:
-        """Returns the informal string representation of the gross concrete
-        section properties.
+        """Returns the informal string representation of the section
+        properties.
         """
         return f'{self}'
 
 
-@dataclass
-class CrackedProperties:
-    """Simple dataclass for storing cracked section properties."""
-
-    # second moments of area
-    i_yy: float = 0
-    i_zz: float = 0
-    i_yz: float = 0
-
-    # section cracked flexural rigidity
-    ei_yy: float = 0
-    ei_zz: float = 0
-
-
 @dataclass
 class MomentCurvatureResults:
     """Class for storing moment curvature results.

structuralcodes/core/base.py

@@ -130,14 +130,8 @@ class ConstitutiveLaw(abc.ABC):
 
         return eps
 
-    def __marin__(self, **kwargs):
-        """Function for getting the strain limits and coefficients
-        for marin integration.
-
-        By default the law is discretized as a piecewise linear
-        function. Then marin coefficients are computed based on this
-        discretization.
-        """
+    def _discretize_law(self) -> ConstitutiveLaw:
+        """Discretize the law as a piecewise linear function."""
 
         # Discretize the constitutive law in a "smart way"
         def find_x_lim(x, y):
@@ -179,8 +173,29 @@ class ConstitutiveLaw(abc.ABC):
         sig = self.get_stress(eps)
         from structuralcodes.materials.constitutive_laws import UserDefined
 
-        # Return Marin coefficients for linearized version
-        return UserDefined(eps, sig).__marin__(**kwargs)
+        return UserDefined(eps, sig)
+
+    def __marin__(self, **kwargs):
+        """Function for getting the strain limits and coefficients
+        for marin integration.
+
+        By default the law is discretized as a piecewise linear
+        function. Then marin coefficients are computed based on this
+        discretization.
+        """
+        piecewise_law = self._discretize_law()
+        return piecewise_law.__marin__(**kwargs)
+
+    def __marin_tangent__(self, **kwargs):
+        """Function for getting the strain limits and coefficients
+        for marin integration of tangent modulus.
+
+        By default the law is discretized as a piecewise linear
+        function. Then marin coefficients are computed based on this
+        discretization.
+        """
+        piecewise_law = self._discretize_law()
+        return piecewise_law.__marin_tangent__(**kwargs)
 
     def get_secant(self, eps: float) -> float:
         """Method to return the
@@ -228,7 +243,7 @@ class SectionCalculator(abc.ABC):
         self.section = section
 
     @abc.abstractmethod
-    def _calculate_gross_section_properties(self) -> s_res.GrossProperties:
+    def _calculate_gross_section_properties(self) -> s_res.SectionProperties:
         """Calculates the gross section properties of the section
         This function is private and called when the section is created
         It stores the result into the result object.

structuralcodes/geometry/__init__.py

@@ -1,5 +1,6 @@
 """Main entry point for geometry."""
 
+from ._circular import CircularGeometry
 from ._geometry import (
     CompoundGeometry,
     Geometry,
@@ -7,7 +8,12 @@ from ._geometry import (
     SurfaceGeometry,
     create_line_point_angle,
 )
-from ._reinforcement import add_reinforcement, add_reinforcement_line
+from ._rectangular import RectangularGeometry
+from ._reinforcement import (
+    add_reinforcement,
+    add_reinforcement_circle,
+    add_reinforcement_line,
+)
 from ._steel_sections import HE, IPE, IPN, UB, UBP, UC, UPN
 
 __all__ = [
@@ -25,4 +31,7 @@ __all__ = [
     'UPN',
     'add_reinforcement',
     'add_reinforcement_line',
+    'CircularGeometry',
+    'add_reinforcement_circle',
+    'RectangularGeometry',
 ]

structuralcodes/geometry/_circular.py

@@ -0,0 +1,101 @@
+"""Classes for circular geometries.
+
+The class `CircularGeometry` represents a circular SurfaceGeometry with
+homogenous material.
+This class is simply a wrapper of `SurfaceGeometry` class and permits an easy
+input by the user.
+"""
+
+import typing as t
+
+import numpy as np
+from numpy.typing import ArrayLike
+from shapely import Polygon
+
+from structuralcodes.core.base import ConstitutiveLaw, Material
+
+from ._geometry import SurfaceGeometry
+
+
+def _create_circle(radius, npoints=20, origin: t.Optional[ArrayLike] = None):
+    """Create a circle with a given radius."""
+    origin = origin if origin is not None else (0.0, 0.0)
+    phi = np.linspace(0, 2 * np.pi, npoints + 1)
+    x = radius * np.cos(phi) + origin[0]
+    y = radius * np.sin(phi) + origin[1]
+    points = np.transpose(np.array([x, y]))
+    return Polygon(points)
+
+
+class CircularGeometry(SurfaceGeometry):
+    """This is a wrapper class for defining a `SurfaceGeometry` of circular
+    shape with a homogeneous material.
+    """
+
+    _radius: float
+
+    def __init__(
+        self,
+        diameter: float,
+        material: t.Union[Material, ConstitutiveLaw],
+        n_points: int = 20,
+        density: t.Optional[float] = None,
+        concrete: bool = False,
+        origin: t.Optional[ArrayLike] = None,
+        name: t.Optional[str] = None,
+        group_label: t.Optional[str] = None,
+    ) -> None:
+        """Initialize a CircularGeometry.
+
+        Arguments:
+            diameter (float): The diameter of the geometry.
+            material (Union(Material, ConstitutiveLaw)): A Material or
+                ConsitutiveLaw class applied to the geometry.
+            n_points (int): The number of points used to discretize the
+                circle as a shapely `Polygon` (default = 20).
+            density (Optional(float)): When a ConstitutiveLaw is passed as
+                material, the density can be provided by this argument. When
+                material is a Material object the density is taken from the
+                material.
+            concrete (bool): Flag to indicate if the geometry is concrete.
+            origin (Optional(ArrayLike)): The center point of the circle.
+                (0.0, 0.0) is used as default.
+            name (Optional(str)): The name to be given to the object.
+            group_label (Optional(str)): A label for grouping several objects.
+
+        Note:
+            The CircularGeometry is simply a wrapper for a SurfaceGeometry
+            object.
+        """
+        # Check that size is strictly positive
+        if diameter <= 0:
+            raise ValueError('Diameter must be a positive number.')
+        # Manage size as radius or diameter (default)
+        self._radius = diameter / 2.0
+        # Parse origin
+        if origin is not None and len(origin) != 2:
+            raise ValueError('origin must be an ArrayLike with len == 2')
+        origin = origin if origin is not None else (0.0, 0.0)
+        # Create the shapely polygon
+        polygon = _create_circle(
+            radius=self._radius, npoints=n_points, origin=origin
+        )
+        # Pass everything to the base class
+        super().__init__(
+            poly=polygon,
+            material=material,
+            density=density,
+            concrete=concrete,
+            name=name,
+            group_label=group_label,
+        )
+
+    @property
+    def radius(self):
+        """Returns the radius of the circle."""
+        return self._radius
+
+    @property
+    def diameter(self):
+        """Return diameter of the circle."""
+        return 2 * self._radius

structuralcodes/geometry/_geometry.py

@@ -323,7 +323,7 @@ def create_line_point_angle(
     return LineString([(x1, y1), (x2, y2)])
 
 
-class SurfaceGeometry:
+class SurfaceGeometry(Geometry):
     """Class for a surface geometry with material.
 
     Basically it is a wrapper for shapely polygon including the material (and
@@ -339,6 +339,8 @@ class SurfaceGeometry:
         material: t.Union[Material, ConstitutiveLaw],
         density: t.Optional[float] = None,
         concrete: bool = False,
+        name: t.Optional[str] = None,
+        group_label: t.Optional[str] = None,
     ) -> None:
         """Initializes a SurfaceGeometry object.
 
@@ -350,7 +352,10 @@ class SurfaceGeometry:
                 the density can be provided by this argument. When mat is a
                 Material object the density is taken from the material.
             concrete (bool): Flag to indicate if the geometry is concrete.
+            name (Optional(str)): The name to be given to the object.
+            group_label (Optional(str)): A label for grouping several objects.
         """
+        super().__init__(name=name, group_label=group_label)
         # Check if inputs are of the correct type, otherwise return error
         if not isinstance(poly, Polygon):
             raise TypeError(
@@ -557,7 +562,7 @@ class SurfaceGeometry:
             poly=affinity.translate(self.polygon, dx, dy),
             material=self.material,
             density=self._density,
-            concrete=self.concrete
+            concrete=self.concrete,
         )
 
     def rotate(