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

structuralcodes/core/base.py

@@ -15,21 +15,48 @@ class Material(abc.ABC):
     """Abstract base class for materials."""
 
     _constitutive_law = None
-
-    def __init__(self, density: float, name: t.Optional[str] = None) -> None:
+    _initial_strain: t.Optional[float] = None
+    _initial_stress: t.Optional[float] = None
+    _strain_compatibility: t.Optional[bool] = None
+
+    def __init__(
+        self,
+        density: float,
+        initial_strain: t.Optional[float] = None,
+        initial_stress: t.Optional[float] = None,
+        strain_compatibility: t.Optional[bool] = None,
+        name: t.Optional[str] = None,
+    ) -> None:
         """Initializes an instance of a new material.
 
         Args:
-            density (float): density of the material in kg/m3
+            density (float): Density of the material in kg/m3.
 
         Keyword Args:
+            initial_strain (Optional[float]): Initial strain of the material.
+            initial_stress (Optional[float]): Initial stress of the material.
+            strain_compatibility (Optional[bool]): Only relevant if
+                initial_strain or initial_stress are different from zero. If
+                True, the material deforms with the geometry. If False, the
+                stress in the material upon loading is kept constant
+                corresponding to the initial strain.
             name (Optional[str]): descriptive name of the material
+
+        Raise:
+            ValueError: if both initial_strain and initial_stress are provided
         """
         self._density = abs(density)
+        if initial_strain is not None and initial_stress is not None:
+            raise ValueError(
+                'Both initial_strain and initial_stress cannot be provided.'
+            )
+        self._initial_strain = initial_strain
+        self._initial_stress = initial_stress
+        self._strain_compatibility = strain_compatibility
         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
 
@@ -43,6 +70,88 @@ class Material(abc.ABC):
         """Returns the density of the material in kg/m3."""
         return self._density
 
+    @property
+    def initial_strain(self):
+        """Returns the initial strain of the material."""
+        return self._initial_strain
+
+    @property
+    def initial_stress(self):
+        """Returns the initial stress of the material."""
+        return self._initial_stress
+
+    @property
+    def strain_compatibility(self):
+        """Returns the strain compatibility of the material.
+
+        If true (default), the strain compatibility is enforced
+        haveing the same strain as in all other materials of the
+        section at the same point. If false, the strain compatibility
+        is not enforced and the initial strain is applied to the section
+        independently.
+        """
+        return self._strain_compatibility
+
+    def _apply_initial_strain(self):
+        """Wraps the current constitutive law to apply initial strain."""
+        strain_compatibility = (
+            self._strain_compatibility
+            if self._strain_compatibility is not None
+            else True
+        )
+        if self._initial_stress is not None:
+            # Specified a stress, compute the strain from it
+            self._initial_strain_from_stress()
+        if self._initial_strain is not None:
+            # Lazy import to avoid circular dependency
+            from structuralcodes.materials.constitutive_laws import (  # noqa: PLC0415
+                InitialStrain,
+            )
+
+            if self._initial_stress is None:
+                # Compute the stress from the strain
+                self._initial_stress = self._constitutive_law.get_stress(
+                    self._initial_strain
+                )
+
+            self._constitutive_law = InitialStrain(
+                self._constitutive_law,
+                self._initial_strain,
+                strain_compatibility,
+            )
+
+    def _initial_strain_from_stress(self):
+        """Computes the initial strain from the initial stress.
+
+        This function is called internally so it assumes that the
+        initial stress is not None
+        """
+        # Iteratively compute the initial strain that gives the desired
+        # initial stress. Note that the wrapped law can be nonlinear
+        tol = 1e-12
+        max_iter = 100
+        target_stress = self._initial_stress
+        strain = 0.0
+        stress = self._constitutive_law.get_stress(strain)
+        d_stress = target_stress - stress
+        num_iter = 0
+        while abs(d_stress) > tol and num_iter < max_iter:
+            tangent = self._constitutive_law.get_tangent(strain)
+            if tangent == 0:
+                raise ValueError(
+                    'Tangent modulus = 0 during initial strain computation.'
+                )
+            d_strain = d_stress / tangent
+            strain += d_strain
+            stress = self._constitutive_law.get_stress(strain)
+            d_stress = target_stress - stress
+            num_iter += 1
+
+        if abs(d_stress) > tol:
+            raise RuntimeError('Failed to converge for given initial stress.')
+
+        self._initial_strain = strain
+
 
 class ConstitutiveLaw(abc.ABC):
     """Abstract base class for constitutive laws."""
@@ -150,7 +259,9 @@ class ConstitutiveLaw(abc.ABC):
 
         eps = np.concatenate((eps_neg, eps_pos))
         sig = self.get_stress(eps)
-        from structuralcodes.materials.constitutive_laws import UserDefined
+        from structuralcodes.materials.constitutive_laws import (  # noqa: PLC0415
+            UserDefined,
+        )
 
         return UserDefined(eps, sig)
 

structuralcodes/geometry/__init__.py

@@ -1,5 +1,6 @@
 """Main entry point for geometry."""
 
+from . import profiles
 from ._circular import CircularGeometry
 from ._geometry import (
     CompoundGeometry,
@@ -14,7 +15,6 @@ from ._reinforcement import (
     add_reinforcement_circle,
     add_reinforcement_line,
 )
-from ._steel_sections import HE, IPE, IPN, UB, UBP, UC, UPN
 
 __all__ = [
     'Geometry',
@@ -22,13 +22,7 @@ __all__ = [
     'SurfaceGeometry',
     'CompoundGeometry',
     'create_line_point_angle',
-    'IPE',
-    'HE',
-    'UB',
-    'UC',
-    'UBP',
-    'IPN',
-    'UPN',
+    'profiles',
     'add_reinforcement',
     'add_reinforcement_line',
     'CircularGeometry',

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,13 +72,24 @@ 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(
             'This method should be implemented by subclasses'
         )
 
+    def __add__(self, other: Geometry) -> CompoundGeometry:
+        """Add operator "+" for geometries.
+
+        Arguments:
+            other (Geometry): The other geometry to add.
+
+        Returns:
+            CompoundGeometry: A new CompoundGeometry.
+        """
+        return CompoundGeometry([self, other])
+
 
 class PointGeometry(Geometry):
     """Class for a point geometry with material.
@@ -91,8 +102,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 +115,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 +136,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 +157,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 +199,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 +225,6 @@ class PointGeometry(Geometry):
             ),
             diameter=self._diameter,
             material=self._material,
-            density=self._density,
             name=self._name,
             group_label=self._group_label,
         )
@@ -239,16 +232,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 +253,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 +320,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 +334,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 +346,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 +378,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
@@ -506,17 +481,6 @@ class SurfaceGeometry(Geometry):
         # get the intersection
         return self.polygon.intersection(lines_polygon)
 
-    def __add__(self, other: Geometry) -> CompoundGeometry:
-        """Add operator "+" for geometries.
-
-        Arguments:
-            other (Geometry): The other geometry to add.
-
-        Returns:
-            CompoundGeometry: A new CompoundGeometry.
-        """
-        return CompoundGeometry([self, other])
-
     def __sub__(self, other: Geometry) -> SurfaceGeometry:
         """Add operator "-" for geometries.
 
@@ -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.
@@ -834,17 +789,6 @@ class CompoundGeometry(Geometry):
             processed_geoms.append(pg.rotate(angle, point, use_radians))
         return CompoundGeometry(geometries=processed_geoms)
 
-    def __add__(self, other: Geometry) -> CompoundGeometry:
-        """Add operator "+" for geometries.
-
-        Arguments:
-            other (Geometry): The other geometry to add.
-
-        Returns:
-            CompoundGeometry: A new CompoundGeometry.
-        """
-        return CompoundGeometry([self, other])
-
     def __sub__(self, other: Geometry) -> CompoundGeometry:
         """Add operator "-" for geometries.
 
@@ -868,7 +812,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,