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

structuralcodes/core/base.py

@@ -29,7 +29,7 @@ class Material(abc.ABC):
         self._name = name if name is not None else 'Material'
 
     @property
-    def constitutive_law(self):
+    def constitutive_law(self) -> ConstitutiveLaw:
         """Returns the ConstitutiveLaw of the object."""
         return self._constitutive_law
 

structuralcodes/geometry/_circular.py

@@ -12,7 +12,7 @@ import numpy as np
 from numpy.typing import ArrayLike
 from shapely import Polygon
 
-from structuralcodes.core.base import ConstitutiveLaw, Material
+from structuralcodes.core.base import Material
 
 from ._geometry import SurfaceGeometry
 
@@ -37,9 +37,8 @@ class CircularGeometry(SurfaceGeometry):
     def __init__(
         self,
         diameter: float,
-        material: t.Union[Material, ConstitutiveLaw],
+        material: Material,
         n_points: int = 20,
-        density: t.Optional[float] = None,
         concrete: bool = False,
         origin: t.Optional[ArrayLike] = None,
         name: t.Optional[str] = None,
@@ -49,14 +48,9 @@ class CircularGeometry(SurfaceGeometry):
 
         Arguments:
             diameter (float): The diameter of the geometry.
-            material (Union(Material, ConstitutiveLaw)): A Material or
-                ConsitutiveLaw class applied to the geometry.
+            material (Material): A Material 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.
@@ -84,7 +78,6 @@ class CircularGeometry(SurfaceGeometry):
         super().__init__(
             poly=polygon,
             material=material,
-            density=density,
             concrete=concrete,
             name=name,
             group_label=group_label,

structuralcodes/geometry/_geometry.py

@@ -18,9 +18,9 @@ from shapely.geometry import (
 )
 from shapely.ops import split
 
-from structuralcodes.core.base import ConstitutiveLaw, Material
+from structuralcodes.core.base import Material
+from structuralcodes.materials.basic import ElasticMaterial
 from structuralcodes.materials.concrete import Concrete
-from structuralcodes.materials.constitutive_laws import Elastic
 
 
 class Geometry:
@@ -72,7 +72,7 @@ class Geometry:
     @staticmethod
     def from_geometry(
         geo: Geometry,
-        new_material: t.Optional[t.Union[Material, ConstitutiveLaw]] = None,
+        new_material: t.Optional[Material] = None,
     ) -> Geometry:
         """Create a new geometry with a different material."""
         raise NotImplementedError(
@@ -91,8 +91,7 @@ class PointGeometry(Geometry):
         self,
         point: t.Union[Point, ArrayLike],
         diameter: float,
-        material: t.Union[Material, ConstitutiveLaw],
-        density: t.Optional[float] = None,
+        material: Material,
         name: t.Optional[str] = None,
         group_label: t.Optional[str] = None,
     ):
@@ -105,12 +104,7 @@ class PointGeometry(Geometry):
             point (Union(Point, ArrayLike)): A couple of coordinates or a
                 shapely Point object.
             diameter (float): The diameter of the point.
-            material (Union(Material, ConstitutiveLaw)): The material for the
-                point (this can be a Material or a ConstitutiveLaw).
-            density (Optional(float)): When a ConstitutiveLaw is passed as
-                material, the density can be providen by this argument. When
-                the material is a Material object the density is taken from the
-                material.
+            material (Material): The material for the point.
             name (Optional(str)): The name to be given to the object.
             group_label (Optional(str)): A label for grouping several objects
                 (default is None).
@@ -131,22 +125,12 @@ class PointGeometry(Geometry):
                 warn_str += ' discarded'
                 warnings.warn(warn_str)
             point = Point(coords)
-        if not isinstance(material, Material) and not isinstance(
-            material, ConstitutiveLaw
-        ):
+        if not isinstance(material, Material):
             raise TypeError(
-                f'mat should be a valid structuralcodes.base.Material \
-                or structuralcodes.base.ConstitutiveLaw object. \
+                f'mat should be a valid structuralcodes.base.Material object. \
                 {repr(material)}'
             )
-        # Pass a constitutive law to the PointGeometry
-        self._density = density
-        if isinstance(material, Material):
-            self._density = material.density
-            self._material = material.constitutive_law
-        elif isinstance(material, ConstitutiveLaw):
-            self._material = material
-
+        self._material = material
         self._point = point
         self._diameter = diameter
         self._area = np.pi * diameter**2 / 4.0
@@ -162,14 +146,14 @@ class PointGeometry(Geometry):
         return self._area
 
     @property
-    def material(self) -> ConstitutiveLaw:
+    def material(self) -> Material:
         """Returns the point material."""
         return self._material
 
     @property
     def density(self) -> float:
         """Returns the density."""
-        return self._density
+        return self.material.density
 
     @property
     def x(self) -> float:
@@ -204,7 +188,6 @@ class PointGeometry(Geometry):
             point=affinity.translate(self._point, dx, dy),
             diameter=self._diameter,
             material=self._material,
-            density=self._density,
             name=self._name,
             group_label=self._group_label,
         )
@@ -231,7 +214,6 @@ class PointGeometry(Geometry):
             ),
             diameter=self._diameter,
             material=self._material,
-            density=self._density,
             name=self._name,
             group_label=self._group_label,
         )
@@ -239,16 +221,15 @@ class PointGeometry(Geometry):
     @staticmethod
     def from_geometry(
         geo: PointGeometry,
-        new_material: t.Optional[t.Union[Material, ConstitutiveLaw]] = None,
+        new_material: t.Optional[Material] = None,
     ) -> PointGeometry:
         """Create a new PointGeometry with a different material.
 
         Arguments:
             geo (PointGeometry): The geometry.
-            new_material (Optional(Union(Material, ConstitutiveLaw))): A new
-                material to be applied to the geometry. If new_material is
-                None an Elastic material with same stiffness as the original
-                material is created.
+            new_material (Optional(Material)): A new material to be applied to
+                the geometry. If new_material is None an Elastic material with
+                same stiffness as the original material is created.
 
         Returns:
             PointGeometry: The new PointGeometry.
@@ -261,24 +242,21 @@ class PointGeometry(Geometry):
             raise TypeError('geo should be a PointGeometry')
         if new_material is not None:
             # provided a new_material
-            if not isinstance(new_material, Material) and not isinstance(
-                new_material, ConstitutiveLaw
-            ):
+            if not isinstance(new_material, Material):
                 raise TypeError(
                     f'new_material should be a valid structuralcodes.base.\
-                    Material or structuralcodes.base.ConstitutiveLaw object. \
+                    Material object. \
                     {repr(new_material)}'
                 )
         else:
             # new_material not provided, assume elastic material with same
             # elastic modulus
-            new_material = Elastic(E=geo.material.get_tangent(eps=0))
+            new_material = ElasticMaterial.from_material(geo.material)
 
         return PointGeometry(
             point=geo._point,
             diameter=geo._diameter,
             material=new_material,
-            density=geo._density,
             name=geo._name,
             group_label=geo._group_label,
         )
@@ -331,13 +309,12 @@ class SurfaceGeometry(Geometry):
     holes.
     """
 
-    _material: ConstitutiveLaw
+    _material: Material
 
     def __init__(
         self,
         poly: Polygon,
-        material: t.Union[Material, ConstitutiveLaw],
-        density: t.Optional[float] = None,
+        material: Material,
         concrete: bool = False,
         name: t.Optional[str] = None,
         group_label: t.Optional[str] = None,
@@ -346,11 +323,7 @@ class SurfaceGeometry(Geometry):
 
         Arguments:
             poly (shapely.Polygon): A Shapely polygon.
-            material (Union(Material, ConstitutiveLaw)): A Material or
-                ConsitutiveLaw class applied to the geometry.
-            density (Optional(float)): When a ConstitutiveLaw is passed as mat,
-                the density can be provided by this argument. When mat is a
-                Material object the density is taken from the material.
+            material (Material): A Material applied to the geometry.
             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.
@@ -362,24 +335,15 @@ class SurfaceGeometry(Geometry):
                 f'poly need to be a valid shapely.geometry.Polygon object. \
                 {repr(poly)}'
             )
-        if not isinstance(material, Material) and not isinstance(
-            material, ConstitutiveLaw
-        ):
+        if not isinstance(material, Material):
             raise TypeError(
-                f'mat should be a valid structuralcodes.base.Material \
-                or structuralcodes.base.ConstitutiveLaw object. \
+                f'mat should be a valid structuralcodes.base.Material object. \
                 {repr(material)}'
             )
         self._polygon = poly
-        # Pass a constitutive law to the SurfaceGeometry
-        self._density = density
-        if isinstance(material, Material):
-            self._density = material.density
-            if isinstance(material, Concrete):
-                concrete = True
-            material = material.constitutive_law
-
         self._material = material
+        if isinstance(material, Concrete):
+            concrete = True
         self._concrete = concrete
 
     @property
@@ -403,11 +367,11 @@ class SurfaceGeometry(Geometry):
     @property
     def density(self) -> float:
         """Returns the density."""
-        return self._density
+        return self.material.density
 
     @property
-    def material(self) -> ConstitutiveLaw:
-        """Returns the Constitutive law."""
+    def material(self) -> Material:
+        """Returns the material."""
         return self._material
 
     @property
@@ -527,7 +491,6 @@ class SurfaceGeometry(Geometry):
             SurfaceGeometry: The resulting SurfaceGeometry.
         """
         material = self.material
-        density = self._density
 
         # if we subtract a point from a surface we obtain the same surface
         sub_polygon = self.polygon
@@ -540,9 +503,7 @@ class SurfaceGeometry(Geometry):
             for g in other.geometries:
                 sub_polygon = sub_polygon - g.polygon
 
-        return SurfaceGeometry(
-            poly=sub_polygon, material=material, density=density
-        )
+        return SurfaceGeometry(poly=sub_polygon, material=material)
 
     def _repr_svg_(self) -> str:
         """Returns the svg representation."""
@@ -561,7 +522,6 @@ class SurfaceGeometry(Geometry):
         return SurfaceGeometry(
             poly=affinity.translate(self.polygon, dx, dy),
             material=self.material,
-            density=self._density,
             concrete=self.concrete,
         )
 
@@ -589,23 +549,21 @@ class SurfaceGeometry(Geometry):
                 self.polygon, angle, origin=point, use_radians=use_radians
             ),
             material=self.material,
-            density=self._density,
             concrete=self.concrete,
         )
 
     @staticmethod
     def from_geometry(
         geo: SurfaceGeometry,
-        new_material: t.Optional[t.Union[Material, ConstitutiveLaw]] = None,
+        new_material: t.Optional[Material] = None,
     ) -> SurfaceGeometry:
         """Create a new SurfaceGeometry with a different material.
 
         Arguments:
             geo (SurfaceGeometry): The geometry.
-            new_material: (Optional(Union(Material, ConstitutiveLaw))): A new
-                material to be applied to the geometry. If new_material is None
-                an Elastic material with same stiffness of the original
-                material is created.
+            new_material: (Optional(Material)): A new material to be applied to
+                the geometry. If new_material is None an Elastic material with
+                same stiffness of the original material is created.
 
         Returns:
             SurfaceGeometry: The new SurfaceGeometry.
@@ -618,22 +576,18 @@ class SurfaceGeometry(Geometry):
             raise TypeError('geo should be a SurfaceGeometry')
         if new_material is not None:
             # provided a new_material
-            if not isinstance(new_material, Material) and not isinstance(
-                new_material, ConstitutiveLaw
-            ):
+            if not isinstance(new_material, Material):
                 raise TypeError(
                     f'new_material should be a valid structuralcodes.base.\
-                    Material or structuralcodes.base.ConstitutiveLaw object. \
+                    Material object. \
                     {repr(new_material)}'
                 )
         else:
             # new_material not provided, assume elastic material with same
             # elastic modulus
-            new_material = Elastic(E=geo.material.get_tangent(eps=0))
+            new_material = ElasticMaterial.from_material(geo.material)
 
-        return SurfaceGeometry(
-            poly=geo.polygon, material=new_material, density=geo._density
-        )
+        return SurfaceGeometry(poly=geo.polygon, material=new_material)
 
     # here we can also add static methods like:
     # from_points
@@ -648,14 +602,12 @@ class SurfaceGeometry(Geometry):
 
 def _process_geometries_multipolygon(
     geometries: MultiPolygon,
-    materials: t.Optional[
-        t.Union[t.List[Material], Material, ConstitutiveLaw]
-    ],
+    materials: t.Optional[t.Union[t.List[Material], Material]],
 ) -> list[Geometry]:
     """Process geometries for initialization."""
     checked_geometries = []
     # a MultiPolygon is provided
-    if isinstance(materials, (ConstitutiveLaw, Material)):
+    if isinstance(materials, Material):
         for g in geometries.geoms:
             checked_geometries.append(
                 SurfaceGeometry(poly=g, material=materials)
@@ -698,20 +650,23 @@ class CompoundGeometry(Geometry):
     properties.
     """
 
-    geometries: t.List[Geometry]
+    geometries: t.List[t.Union[SurfaceGeometry, PointGeometry]]
 
     def __init__(
         self,
-        geometries: t.Union[t.List[Geometry], MultiPolygon],
+        geometries: t.Union[
+            t.List[t.Union[SurfaceGeometry, PointGeometry, CompoundGeometry]],
+            MultiPolygon,
+        ],
         materials: t.Optional[t.Union[t.List[Material], Material]] = None,
     ) -> None:
         """Creates a compound geometry.
 
         Arguments:
             geometries (Union(List(Geometry), MultiPolygon)): A list of
-                Geometry objects (i.e. PointGeometry or SurfaceGeometry) or a
-                shapely MultiPolygon object (in this latter case also a list of
-                materials should be given).
+                Geometry objects (i.e. PointGeometry, SurfaceGeometry or
+                CompoundGeometry) or a shapely MultiPolygon object (in this
+                latter case also a list of materials should be given).
             materials (Optional(List(Material), Material)): A material (applied
                 to all polygons) or a list of materials. In this case the
                 number of polygons should match the number of materials.
@@ -868,7 +823,7 @@ class CompoundGeometry(Geometry):
     @staticmethod
     def from_geometry(
         geo: CompoundGeometry,
-        new_material: t.Optional[t.Union[Material, ConstitutiveLaw]] = None,
+        new_material: t.Optional[Material] = None,
     ) -> CompoundGeometry:
         """Create a new CompoundGeometry with a different material.
 

structuralcodes/geometry/_rectangular.py

@@ -11,7 +11,7 @@ import typing as t
 from numpy.typing import ArrayLike
 from shapely import Polygon
 
-from structuralcodes.core.base import ConstitutiveLaw, Material
+from structuralcodes.core.base import Material
 
 from ._geometry import SurfaceGeometry
 
@@ -28,8 +28,7 @@ class RectangularGeometry(SurfaceGeometry):
         self,
         width: float,
         height: float,
-        material: t.Union[Material, ConstitutiveLaw],
-        density: t.Optional[float] = None,
+        material: Material,
         concrete: bool = False,
         origin: t.Optional[ArrayLike] = None,
         name: t.Optional[str] = None,
@@ -40,12 +39,7 @@ class RectangularGeometry(SurfaceGeometry):
         Arguments:
             width (float): The width of the geometry.
             height (float): The height of the geometry.
-            material (Union(Material, ConstitutiveLaw)): A Material or
-                ConsitutiveLaw class applied to the geometry.
-            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.
+            material (Material): A Material class applied to the geometry.
             concrete (bool): Flag to indicate if the geometry is concrete. When
                 passing a Material as material, this is automatically inferred.
             origin (Optional(ArrayLike)): The center point of the rectangle.
@@ -84,7 +78,6 @@ class RectangularGeometry(SurfaceGeometry):
         super().__init__(
             poly=polygon,
             material=material,
-            density=density,
             concrete=concrete,
             name=name,
             group_label=group_label,

structuralcodes/geometry/_reinforcement.py

@@ -6,7 +6,7 @@ import typing as t
 import numpy as np
 from shapely import Point
 
-from structuralcodes.core.base import ConstitutiveLaw, Material
+from structuralcodes.core.base import Material
 
 from ._geometry import CompoundGeometry, PointGeometry, SurfaceGeometry
 
@@ -15,7 +15,7 @@ def add_reinforcement(
     geo: t.Union[SurfaceGeometry, CompoundGeometry],
     coords: t.Tuple[float, float],
     diameter: float,
-    material: t.Union[Material, ConstitutiveLaw],
+    material: Material,
     group_label: t.Optional[str] = None,
 ) -> CompoundGeometry:
     """Add a single bar given coordinate.
@@ -25,8 +25,7 @@ def add_reinforcement(
             reinforcement.
         coords (Tuple(float, float)): A tuple with cordinates of bar.
         diameter (float): The diameter of the reinforcement.
-        material (Union(Material, ConstitutiveLaw)): A material or a
-            constitutive law for the behavior of the reinforcement.
+        material (Material): A material for the reinforcement.
         group_label (Optional(str)): A label for grouping several objects
             (default is None).
 
@@ -45,7 +44,7 @@ def add_reinforcement_line(
     coords_i: t.Tuple[float, float],
     coords_j: t.Tuple[float, float],
     diameter: float,
-    material: t.Union[Material, ConstitutiveLaw],
+    material: Material,
     n: int = 0,
     s: float = 0.0,
     first: bool = True,
@@ -60,9 +59,8 @@ def add_reinforcement_line(
         coords_i (Tuple(float, float)): Coordinates of the initial point of
             line.
         coords_j (Tuple(float, float)): Coordinates of the final point of line.
-        diamter (float): The diameter of the bars.
-        material (Union(Material, ConstitutiveLaw)): A valid material or
-            constitutive law.
+        diameter (float): The diameter of the bars.
+        material (Material): A material for the reinforcement.
         n (int): The number of bars to be distributed inside the line (default
             = 0).
         s (float): The distance between the bars (default = 0).
@@ -130,7 +128,7 @@ def add_reinforcement_circle(
     center: t.Tuple[float, float],
     radius: float,
     diameter: float,
-    material: t.Union[Material, ConstitutiveLaw],
+    material: Material,
     n: int = 0,
     s: float = 0.0,
     first: bool = True,
@@ -152,8 +150,7 @@ def add_reinforcement_circle(
         radius (float): Radius of the circle line where reinforcement will be
             added.
         diameter (float): The diameter of the bars.
-        material (Union(Material, ConstitutiveLaw)): A valid material or
-            constitutive law.
+        material (Material): A material for the reinforcement.
         n (int): The number of bars to be distributed inside the line (default
             = 0).
         s (float): The distance between the bars (default = 0).

structuralcodes/materials/__init__.py

@@ -1,9 +1,10 @@
 """Main entry point for materials."""
 
-from . import concrete, constitutive_laws, reinforcement
+from . import basic, concrete, constitutive_laws, reinforcement
 
 __all__ = [
     'concrete',
     'constitutive_laws',
     'reinforcement',
+    'basic',
 ]

structuralcodes/materials/basic/__init__.py

@@ -0,0 +1,11 @@
+"""A collection of basic material classes."""
+
+from ._elastic import ElasticMaterial
+from ._elasticplastic import ElasticPlasticMaterial
+from ._generic import GenericMaterial
+
+__all__ = [
+    'ElasticMaterial',
+    'ElasticPlasticMaterial',
+    'GenericMaterial',
+]

structuralcodes/materials/basic/_elastic.py

@@ -0,0 +1,52 @@
+"""A material class with elastic properties."""
+
+import typing as t
+
+from ...core.base import Material
+from ..constitutive_laws import create_constitutive_law
+
+
+class ElasticMaterial(Material):
+    """A material class with elastic properties."""
+
+    _E: float
+
+    def __init__(
+        self,
+        E: float,
+        density: float,
+        name: t.Optional[str] = None,
+    ):
+        """Initialize a material with an elastic plastic constitutive law.
+
+        Arguments:
+            E (float): The Young's modulus.
+            density (float): The density.
+            name (str, optional): The name of the material, default value None.
+        """
+        super().__init__(density=density, name=name)
+        self._E = E
+        self._constitutive_law = create_constitutive_law('elastic', self)
+
+    @property
+    def E(self) -> float:
+        """Returns the Young's modulus."""
+        return self._E
+
+    def __elastic__(self) -> dict:
+        """Returns kwargs for creating an elastic constitutive law."""
+        return {'E': self.E}
+
+    @classmethod
+    def from_material(cls, other_material: Material):
+        """Create an elastic material based on another material."""
+        # Create name of elastic material
+        name = other_material.name
+        if name is not None:
+            name += '_elastic'
+
+        return cls(
+            E=other_material.constitutive_law.get_tangent(eps=0),
+            density=other_material.density,
+            name=name,
+        )

structuralcodes/materials/basic/_elasticplastic.py

@@ -0,0 +1,75 @@
+"""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,
+        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.
+            name (str, optional): The name of the material, default value None.
+        """
+        super().__init__(density=density, name=name)
+        self._E = E
+        self._fy = fy
+        self._Eh = Eh
+        self._eps_su = eps_su
+
+        self._constitutive_law = create_constitutive_law(
+            'elasticplastic', self
+        )
+
+    @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,
+        }