structuralcodes 0.0.2__tar.gz → 0.1.0__tar.gz

{structuralcodes-0.0.2 → structuralcodes-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: structuralcodes
-Version: 0.0.2
+Version: 0.1.0
 Summary: A Python package that contains models from structural design codes.
 Author-email: fib - International Federation for Structural Concrete <info@fib-international.org>
 Requires-Python: >=3.8
@@ -17,11 +17,15 @@ Project-URL: source, https://github.com/fib-international/structuralcodes
 
 *A Python library for structural engineering calculations.*
 
-[![Build](https://github.com/fib-international/structuralcodes/actions/workflows/build.yaml/badge.svg)](https://github.com/fib-international/structuralcodes/actions/workflows/build.yaml)
+[![PyPI version](https://badge.fury.io/py/structuralcodes.svg)](https://badge.fury.io/py/structuralcodes)
 [![Code style: Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/format.json)](https://github.com/charliermarsh/ruff)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/charliermarsh/ruff)
 [![Docs](https://img.shields.io/badge/%F0%9F%93%9A%20docs-fib--international.github.io%2Fstructuralcodes%2F-orange)](https://fib-international.github.io/structuralcodes/)
 
+[![Tests](https://github.com/fib-international/structuralcodes/actions/workflows/build.yaml/badge.svg)](https://github.com/fib-international/structuralcodes/actions/workflows/build.yaml)
+[![Publish](https://github.com/fib-international/structuralcodes/actions/workflows/create-release.yml/badge.svg)](https://github.com/fib-international/structuralcodes/actions/workflows/create-release.yml)
+[![Docs](https://github.com/fib-international/structuralcodes/actions/workflows/sphinx.yml/badge.svg)](https://github.com/fib-international/structuralcodes/actions/workflows/sphinx.yml)
+
 ## How to install
 
 StructuralCodes is available on PyPI and can be installed using `pip`:
@@ -38,3 +42,7 @@ Read the [quickstart guide](https://fib-international.github.io/structuralcodes/
 
 Check out our docs for how to get started [contributing](https://fib-international.github.io/structuralcodes/contributing/) to StructuralCodes.
 
+## Versioning
+
+Check out our docs to see how we handle [versioning](https://fib-international.github.io/structuralcodes/versioning/).
+

{structuralcodes-0.0.2 → structuralcodes-0.1.0}/README.md

@@ -2,11 +2,15 @@
 
 *A Python library for structural engineering calculations.*
 
-[![Build](https://github.com/fib-international/structuralcodes/actions/workflows/build.yaml/badge.svg)](https://github.com/fib-international/structuralcodes/actions/workflows/build.yaml)
+[![PyPI version](https://badge.fury.io/py/structuralcodes.svg)](https://badge.fury.io/py/structuralcodes)
 [![Code style: Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/format.json)](https://github.com/charliermarsh/ruff)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/charliermarsh/ruff)
 [![Docs](https://img.shields.io/badge/%F0%9F%93%9A%20docs-fib--international.github.io%2Fstructuralcodes%2F-orange)](https://fib-international.github.io/structuralcodes/)
 
+[![Tests](https://github.com/fib-international/structuralcodes/actions/workflows/build.yaml/badge.svg)](https://github.com/fib-international/structuralcodes/actions/workflows/build.yaml)
+[![Publish](https://github.com/fib-international/structuralcodes/actions/workflows/create-release.yml/badge.svg)](https://github.com/fib-international/structuralcodes/actions/workflows/create-release.yml)
+[![Docs](https://github.com/fib-international/structuralcodes/actions/workflows/sphinx.yml/badge.svg)](https://github.com/fib-international/structuralcodes/actions/workflows/sphinx.yml)
+
 ## How to install
 
 StructuralCodes is available on PyPI and can be installed using `pip`:
@@ -22,3 +26,7 @@ Read the [quickstart guide](https://fib-international.github.io/structuralcodes/
 ## Contribution guidelines
 
 Check out our docs for how to get started [contributing](https://fib-international.github.io/structuralcodes/contributing/) to StructuralCodes.
+
+## Versioning
+
+Check out our docs to see how we handle [versioning](https://fib-international.github.io/structuralcodes/versioning/).

{structuralcodes-0.0.2 → structuralcodes-0.1.0}/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.0.2'
+__version__ = '0.1.0'
 
 __all__ = [
     'set_design_code',

{structuralcodes-0.0.2 → structuralcodes-0.1.0}/structuralcodes/codes/__init__.py

@@ -3,10 +3,11 @@
 import types
 import typing as t
 
-from . import ec2_2004, ec2_2023, mc2010
+from . import ec2_2004, ec2_2023, mc2010, mc2020
 
 __all__ = [
     'mc2010',
+    'mc2020',
     'ec2_2023',
     'ec2_2004',
     'set_design_code',
@@ -23,25 +24,43 @@ _NATIONAL_ANNEX: t.Optional[str] = None
 # Design code registry
 _DESIGN_CODES = {
     'mc2010': mc2010,
+    'mc2020': mc2020,
     'ec2_2004': ec2_2004,
     'ec2_2023': ec2_2023,
 }
 
 
-def set_design_code(design_code: t.Optional[str] = None) -> None:
+def set_design_code(
+    design_code: t.Optional[t.Union[str, types.ModuleType]] = None,
+) -> None:
     """Set the current design code globally.
 
     Args:
-        design_code (str): The abbreviation of the code.
+        design_code (Union[str, Moduletype]): The abbreviation of the code
+            (str), or a module that represents the code (ModuleType).
 
     Note:
         Call get_design_codes() to get a list of the available codes.
     """
     global _CODE  # pylint: disable=W0603
-    if design_code is not None:
+    if design_code is None:
+        # Reset to None
+        _CODE = None
+    elif isinstance(design_code, str) and design_code.lower() in _DESIGN_CODES:
+        # The design code abbreviation is valid
         _CODE = _DESIGN_CODES.get(design_code.lower())
+    elif isinstance(design_code, types.ModuleType) and all(
+        name in dir(design_code)
+        for name in ('__title__', '__year__', '__materials__')
+    ):
+        # The module is a valid design code
+        _CODE = design_code
     else:
-        _CODE = None
+        raise ValueError(
+            f'{design_code} is not a valid abbreviation for a design code, or'
+            ' a valid module representing a design code.\nType '
+            'get_design_codes() to list the available design codes.'
+        )
 
 
 def get_design_codes() -> t.List[str]:
@@ -75,5 +94,9 @@ def _use_design_code(
         Call get_design_codes() to get a list of the available codes.
     """
     if design_code is None:
+        # Returned the globally set design code
         return _CODE
-    return _DESIGN_CODES.get(design_code.lower())
+
+    # Set design code before returning
+    set_design_code(design_code)
+    return _CODE

structuralcodes-0.1.0/structuralcodes/codes/mc2020/__init__.py

@@ -0,0 +1,7 @@
+"""The fib Model Code 2020."""
+
+import typing as t
+
+__title__: str = 'fib Model Code 2020'
+__year__: str = '2024'
+__materials__: t.Tuple[str] = ('concrete', 'reinforcement')

{structuralcodes-0.0.2 → structuralcodes-0.1.0}/structuralcodes/core/_section_results.py

@@ -175,37 +175,87 @@ class UltimateBendingMomentResults:
 
 
 @dataclass
-class NMMInteractionDomain:
+class InteractionDomain:
+    """Class for storing common data on all interaction domain results.
+
+    Attributes:
+        strains (numpy.Array): A numpy array with shape (n, 3) containing ea,
+            ky and kz.
+        forces (numpy.Array): A numpy array with shape (n, 3) containing n, my
+            and mz.
+        field_num (numpy.Array): a numpy array with shape (n,) containing a
+            number between 1 and 6 indicating the failure field.
+    """
+
+    # array with shape (n,3) containing ea, ky, kz:
+    strains: ArrayLike = None
+    # array with shape(n,3) containing N, My, Mz
+    forces: ArrayLike = None
+    # array with shape(n,) containing the field number from 1 to 6
+    field_num: ArrayLike = None
+
+    @property
+    def n(self):
+        """Return axial force."""
+        if self.forces is None:
+            return None
+        return self.forces[:, 0]
+
+    @property
+    def m_y(self):
+        """Return my."""
+        if self.forces is None:
+            return None
+        return self.forces[:, 1]
+
+    @property
+    def m_z(self):
+        """Return mz."""
+        if self.forces is None:
+            return None
+        return self.forces[:, 2]
+
+    @property
+    def e_a(self):
+        """Return ea."""
+        if self.strains is None:
+            return None
+        return self.strains[:, 0]
+
+    @property
+    def k_y(self):
+        """Return ky."""
+        if self.strains is None:
+            return None
+        return self.strains[:, 1]
+
+    @property
+    def k_z(self):
+        """Return kz."""
+        if self.strains is None:
+            return None
+        return self.strains[:, 2]
+
+
+@dataclass
+class NMMInteractionDomain(InteractionDomain):
     """Class for storing the NMM interaction domain results."""
 
     num_theta: int = 0  # number of discretizations along the angle
     num_axial: int = 0  # number of discretizations along axial load axis
 
-    strains: ArrayLike = None  # array with shape (n,3) containing strains
-    forces: ArrayLike = None  # array with shape(n,3) containing N, My, Mz
-
 
 @dataclass
-class NMInteractionDomain:
+class NMInteractionDomain(InteractionDomain):
     """Class for storing the NM interaction domain results."""
 
     theta: float = 0  # the inclination of n.a.
     num_axial: float = 0  # number of discretizations along axial load axis
 
-    n: ArrayLike = None  # Axial loads
-    m_y: ArrayLike = None  # Moments My
-    m_z: ArrayLike = None  # Moments Mz
-
-    strains: ArrayLike = None
-
 
 @dataclass
-class MMInteractionDomain:
+class MMInteractionDomain(InteractionDomain):
     """Class for storing the MM interaction domain results."""
 
     num_theta: float = 0  # number of discretizations along the angle
-    n: float = 0  # axial load
-
-    theta: ArrayLike = None  # Angle theta respect axis Y
-    m_y: ArrayLike = None  # Moments My
-    m_z: ArrayLike = None  # Moments Mz
+    theta: ArrayLike = None  # Array with shape (n,) containing the angle of NA

{structuralcodes-0.0.2 → structuralcodes-0.1.0}/structuralcodes/core/base.py

@@ -101,7 +101,7 @@ class ConstitutiveLaw(abc.ABC):
     @abc.abstractmethod
     def get_ultimate_strain(self) -> t.Tuple[float, float]:
         """Each constitutive law should provide a method to return the
-        ultimate strain (positive and negative).
+        ultimate strain (negative and positive).
         """
 
     def preprocess_strains_with_limits(self, eps: ArrayLike) -> ArrayLike:
@@ -109,7 +109,7 @@ class ConstitutiveLaw(abc.ABC):
         near to ultimate strain limits to exactly ultimate strain limit.
         """
         eps = np.atleast_1d(np.asarray(eps))
-        eps_max, eps_min = self.get_ultimate_strain()
+        eps_min, eps_max = self.get_ultimate_strain()
 
         idxs = np.isclose(eps, np.zeros_like(eps) + eps_max, atol=1e-6)
         eps[idxs] = eps_max
@@ -138,7 +138,7 @@ class ConstitutiveLaw(abc.ABC):
             # All values are zero for x > 0
             return None
 
-        eps_max, eps_min = self.get_ultimate_strain()
+        eps_min, eps_max = self.get_ultimate_strain()
         eps_max = min(eps_max, 1)
         # Analise positive branch
         eps = np.linspace(0, eps_max, 10000)

{structuralcodes-0.0.2 → structuralcodes-0.1.0}/structuralcodes/geometry/__init__.py

@@ -7,6 +7,7 @@ from ._geometry import (
     SurfaceGeometry,
     create_line_point_angle,
 )
+from ._reinforcement import add_reinforcement, add_reinforcement_line
 from ._steel_sections import HE, IPE, IPN, UB, UBP, UC, UPN
 
 __all__ = [
@@ -22,4 +23,6 @@ __all__ = [
     'UBP',
     'IPN',
     'UPN',
+    'add_reinforcement',
+    'add_reinforcement_line',
 ]

{structuralcodes-0.0.2 → structuralcodes-0.1.0}/structuralcodes/geometry/_geometry.py

@@ -22,17 +22,6 @@ from structuralcodes.core.base import ConstitutiveLaw, Material
 from structuralcodes.materials.concrete import Concrete
 from structuralcodes.materials.constitutive_laws import Elastic
 
-# Useful classes and functions: where to put?????? (core?
-# utility folder in sections? here in this file?)
-# Polygons, LineStrings, Points, MultiLyneStrings, MultiPolygons etc.
-
-# to think: dataclass or class?
-# Note that some things are already computed (like area) by shapely
-# like: polygon.area, polygon.centroid, etc.
-
-# For now dataclass, if we need convert to regular class,
-# init commented for now
-
 
 class Geometry:
     """Base class for a geometry object."""
@@ -154,11 +143,12 @@ class PointGeometry(Geometry):
         self._density = density
         if isinstance(material, Material):
             self._density = material.density
-            material = material.constitutive_law
+            self._material = material.constitutive_law
+        elif isinstance(material, ConstitutiveLaw):
+            self._material = material
 
         self._point = point
         self._diameter = diameter
-        self._material = material
         self._area = np.pi * diameter**2 / 4.0
 
     @property
@@ -172,7 +162,7 @@ class PointGeometry(Geometry):
         return self._area
 
     @property
-    def material(self) -> Material:
+    def material(self) -> ConstitutiveLaw:
         """Returns the point material."""
         return self._material
 
@@ -341,10 +331,12 @@ class SurfaceGeometry:
     holes.
     """
 
+    _material: ConstitutiveLaw
+
     def __init__(
         self,
         poly: Polygon,
-        mat: t.Union[Material, ConstitutiveLaw],
+        material: t.Union[Material, ConstitutiveLaw],
         density: t.Optional[float] = None,
         concrete: bool = False,
     ) -> None:
@@ -352,7 +344,7 @@ class SurfaceGeometry:
 
         Arguments:
             poly (shapely.Polygon): A Shapely polygon.
-            mat (Union(Material, ConstitutiveLaw)): A Material or
+            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
@@ -365,25 +357,25 @@ class SurfaceGeometry:
                 f'poly need to be a valid shapely.geometry.Polygon object. \
                 {repr(poly)}'
             )
-        if not isinstance(mat, Material) and not isinstance(
-            mat, ConstitutiveLaw
+        if not isinstance(material, Material) and not isinstance(
+            material, ConstitutiveLaw
         ):
             raise TypeError(
                 f'mat should be a valid structuralcodes.base.Material \
                 or structuralcodes.base.ConstitutiveLaw object. \
-                {repr(mat)}'
+                {repr(material)}'
             )
-        self.polygon = poly
+        self._polygon = poly
         # Pass a constitutive law to the SurfaceGeometry
         self._density = density
-        if isinstance(mat, Material):
-            self._density = mat.density
-            if isinstance(mat, Concrete):
+        if isinstance(material, Material):
+            self._density = material.density
+            if isinstance(material, Concrete):
                 concrete = True
-            mat = mat.constitutive_law
+            material = material.constitutive_law
 
-        self.material = mat
-        self.concrete = concrete
+        self._material = material
+        self._concrete = concrete
 
     @property
     def area(self) -> float:
@@ -408,6 +400,21 @@ class SurfaceGeometry:
         """Returns the density."""
         return self._density
 
+    @property
+    def material(self) -> ConstitutiveLaw:
+        """Returns the Constitutive law."""
+        return self._material
+
+    @property
+    def concrete(self) -> bool:
+        """Returns true if the geometry material is Concrete."""
+        return self._concrete
+
+    @property
+    def polygon(self) -> Polygon:
+        """Returns the Shapely Polygon."""
+        return self._polygon
+
     def calculate_extents(self) -> t.Tuple[float, float, float, float]:
         """Calculate extents of SurfaceGeometry.
 
@@ -528,7 +535,9 @@ class SurfaceGeometry:
             for g in other.geometries:
                 sub_polygon = sub_polygon - g.polygon
 
-        return SurfaceGeometry(poly=sub_polygon, mat=material, density=density)
+        return SurfaceGeometry(
+            poly=sub_polygon, material=material, density=density
+        )
 
     def _repr_svg_(self) -> str:
         """Returns the svg representation."""
@@ -546,7 +555,7 @@ class SurfaceGeometry:
         """
         return SurfaceGeometry(
             poly=affinity.translate(self.polygon, dx, dy),
-            mat=self.material,
+            material=self.material,
             density=self._density,
         )
 
@@ -573,7 +582,7 @@ class SurfaceGeometry:
             poly=affinity.rotate(
                 self.polygon, angle, origin=point, use_radians=use_radians
             ),
-            mat=self.material,
+            material=self.material,
             density=self._density,
         )
 
@@ -616,7 +625,7 @@ class SurfaceGeometry:
             new_material = Elastic(E=geo.material.get_tangent(eps=0)[0])
 
         return SurfaceGeometry(
-            poly=geo.polygon, mat=new_material, density=geo._density
+            poly=geo.polygon, material=new_material, density=geo._density
         )
 
     # here we can also add static methods like:
@@ -635,13 +644,15 @@ def _process_geometries_multipolygon(
     materials: t.Optional[
         t.Union[t.List[Material], Material, ConstitutiveLaw]
     ],
-) -> list:
+) -> list[Geometry]:
     """Process geometries for initialization."""
     checked_geometries = []
     # a MultiPolygon is provided
     if isinstance(materials, (ConstitutiveLaw, Material)):
         for g in geometries.geoms:
-            checked_geometries.append(SurfaceGeometry(poly=g, mat=materials))
+            checked_geometries.append(
+                SurfaceGeometry(poly=g, material=materials)
+            )
     elif isinstance(materials, list):
         # the list of materials is provided, one for each polygon
         if len(geometries.geoms) != len(materials):
@@ -649,13 +660,13 @@ def _process_geometries_multipolygon(
                 'geometries and materials should have the same length'
             )
         for g, m in zip(geometries.geoms, materials):
-            checked_geometries.append(SurfaceGeometry(poly=g, mat=m))
+            checked_geometries.append(SurfaceGeometry(poly=g, material=m))
     return checked_geometries
 
 
 def _process_geometries_list(
     geometries: t.List[Geometry],
-) -> t.Tuple[list, list]:
+) -> t.Tuple[list[SurfaceGeometry], list[PointGeometry]]:
     """Process geometries for initialization."""
     # a list of SurfaceGeometry is provided
     checked_geometries = []
@@ -680,6 +691,8 @@ class CompoundGeometry(Geometry):
     properties.
     """
 
+    geometries: t.List[Geometry]
+
     def __init__(
         self,
         geometries: t.Union[t.List[Geometry], MultiPolygon],
@@ -689,8 +702,9 @@ class CompoundGeometry(Geometry):
 
         Arguments:
             geometries (Union(List(Geometry), MultiPolygon)): A list of
-                SurfaceGeometry objects or a shapely MultiPolygon object
-                (in this case also a list of materials should be given).
+                Geometry objects (i.e. PointGeometry or SurfaceGeometry) 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.
@@ -712,7 +726,7 @@ class CompoundGeometry(Geometry):
             # useful for representation in svg
             geoms_representation = [g.polygon for g in self.geometries]
             geoms_representation += [
-                pg._point.buffer(pg._diameter / 2)
+                pg.point.buffer(pg.diameter / 2)
                 for pg in self.point_geometries
             ]
             self.geom = MultiPolygon(geoms_representation)

{structuralcodes-0.0.2 → structuralcodes-0.1.0}/structuralcodes/geometry/_steel_sections.py

@@ -228,8 +228,8 @@ class BaseProfile:
         xmax = max(abs(bounds[0]), bounds[2])
         ymax = max(abs(bounds[1]), bounds[3])
         # Then compute section modulus
-        self._Wely = self._Iy / ymax
-        self._Welz = self._Iz / xmax
+        self._Wely = self.Iy / ymax
+        self._Welz = self.Iz / xmax
 
     @property
     def Wely(self) -> float:

{structuralcodes-0.0.2 → structuralcodes-0.1.0}/structuralcodes/materials/constitutive_laws.py

@@ -64,11 +64,11 @@ class Elastic(ConstitutiveLaw):
         return strains, coeff
 
     def get_ultimate_strain(self, **kwargs) -> t.Tuple[float, float]:
-        """Return the ultimate strain (positive and negative)."""
+        """Return the ultimate strain (negative and positive)."""
         # There is no real strain limit, so set it to very large values
         # unlesse specified by the user differently
         del kwargs
-        return self._eps_su or (100, -100)
+        return self._eps_su or (-100, 100)
 
     def set_ultimate_strain(
         self, eps_su=t.Union[float, t.Tuple[float, float]]
@@ -76,19 +76,20 @@ class Elastic(ConstitutiveLaw):
         """Set ultimate strains for Elastic Material if needed.
 
         Arguments:
-            eps_su (float or (float, float)): Defining ultimate strain if a
-                single value is provided the same is adopted for both positive
-                and negative strains.
+            eps_su (float or (float, float)): Defining ultimate strain. If a
+                single value is provided the same is adopted for both negative
+                and positive strains. If a tuple is provided, it should be
+                given as (negative, positive).
         """
         if isinstance(eps_su, float):
-            self._eps_su = (abs(eps_su), -abs(eps_su))
+            self._eps_su = (-abs(eps_su), abs(eps_su))
         elif isinstance(eps_su, tuple):
             if len(eps_su) < 2:
                 raise ValueError(
                     'Two values need to be provided when setting the tuple'
                 )
-            eps_su_p = eps_su[0]
-            eps_su_n = eps_su[1]
+            eps_su_n = eps_su[0]
+            eps_su_p = eps_su[1]
             if eps_su_p < eps_su_n:
                 eps_su_p, eps_su_n = eps_su_n, eps_su_p
             if eps_su_p < 0:
@@ -99,7 +100,7 @@ class Elastic(ConstitutiveLaw):
                 raise ValueError(
                     'Negative utimate strain should be non-positive'
                 )
-            self._eps_su = (eps_su_p, eps_su_n)
+            self._eps_su = (eps_su_n, eps_su_p)
         else:
             raise ValueError(
                 'set_ultimate_strain requires a single value or a tuple \
@@ -185,8 +186,8 @@ class ElasticPlastic(ConstitutiveLaw):
         """
         strains = []
         coeff = []
-        eps_sy_p, eps_sy_n = self.get_ultimate_strain(yielding=True)
-        eps_su_p, eps_su_n = self.get_ultimate_strain()
+        eps_sy_n, eps_sy_p = self.get_ultimate_strain(yielding=True)
+        eps_su_n, eps_su_p = self.get_ultimate_strain()
         if strain[1] == 0:
             # Uniform strain equal to strain[0]
             # Understand in which branch are we
@@ -233,13 +234,13 @@ class ElasticPlastic(ConstitutiveLaw):
     def get_ultimate_strain(
         self, yielding: bool = False
     ) -> t.Tuple[float, float]:
-        """Return the ultimate strain (positive and negative)."""
+        """Return the ultimate strain (negative and positive)."""
         if yielding:
-            return (self._eps_sy, -self._eps_sy)
+            return (-self._eps_sy, self._eps_sy)
         # If not specified eps
         if self._eps_su is None:
-            return (self._eps_sy * 2, -self._eps_sy * 2)
-        return (self._eps_su, -self._eps_su)
+            return (-self._eps_sy * 2, self._eps_sy * 2)
+        return (-self._eps_su, self._eps_su)
 
 
 class ParabolaRectangle(ConstitutiveLaw):
@@ -399,10 +400,10 @@ class ParabolaRectangle(ConstitutiveLaw):
     def get_ultimate_strain(
         self, yielding: bool = False
     ) -> t.Tuple[float, float]:
-        """Return the ultimate strain (positive and negative)."""
+        """Return the ultimate strain (negative and positive)."""
         if yielding:
-            return (100, self._eps_0)
-        return (100, self._eps_u)
+            return (self._eps_0, 100)
+        return (self._eps_u, 100)
 
 
 class BilinearCompression(ConstitutiveLaw):
@@ -509,10 +510,10 @@ class BilinearCompression(ConstitutiveLaw):
     def get_ultimate_strain(
         self, yielding: bool = False
     ) -> t.Tuple[float, float]:
-        """Return the ultimate strain (positive and negative)."""
+        """Return the ultimate strain (negative and positive)."""
         if yielding:
-            return (100, self._eps_c)
-        return (100, self._eps_cu)
+            return (self._eps_c, 100)
+        return (self._eps_cu, 100)
 
 
 class Sargin(ConstitutiveLaw):
@@ -602,10 +603,10 @@ class Sargin(ConstitutiveLaw):
     def get_ultimate_strain(
         self, yielding: bool = False
     ) -> t.Tuple[float, float]:
-        """Return the ultimate strain (positive and negative)."""
+        """Return the ultimate strain (negative and positive)."""
         if yielding:
-            return (100, self._eps_c1)
-        return (100, self._eps_cu1)
+            return (self._eps_c1, 100)
+        return (self._eps_cu1, 100)
 
 
 class Popovics(ConstitutiveLaw):
@@ -713,10 +714,10 @@ class Popovics(ConstitutiveLaw):
     def get_ultimate_strain(
         self, yielding: bool = False
     ) -> t.Tuple[float, float]:
-        """Return the ultimate strain (positive and negative)."""
+        """Return the ultimate strain (negative and positive)."""
         if yielding:
-            return (100, self._eps_c)
-        return (100, self._eps_cu)
+            return (self._eps_c, 100)
+        return (self._eps_cu, 100)
 
 
 class UserDefined(ConstitutiveLaw):
@@ -875,9 +876,9 @@ class UserDefined(ConstitutiveLaw):
         return strains, coeff
 
     def get_ultimate_strain(self, **kwargs) -> t.Tuple[float, float]:
-        """Return the ultimate strain (positive and negative)."""
+        """Return the ultimate strain (negative and positive)."""
         del kwargs
-        return (self._ultimate_strain_p, self._ultimate_strain_n)
+        return (self._ultimate_strain_n, self._ultimate_strain_p)
 
     def set_ultimate_strain(
         self, eps_su=t.Union[float, t.Tuple[float, float]]
@@ -885,9 +886,10 @@ class UserDefined(ConstitutiveLaw):
         """Set ultimate strains for Elastic Material if needed.
 
         Arguments:
-            eps_su (float or (float, float)): Defining ultimate strain if a
-                single value is provided the same is adopted for both positive
-                and negative strains.
+            eps_su (float or (float, float)): Defining ultimate strain. If a
+                single value is provided the same is adopted for both negative
+                and positive strains. If a tuple is provided, it should be
+                given as (negative, positive).
         """
         if isinstance(eps_su, float):
             self._ultimate_strain_p = abs(eps_su)
@@ -897,8 +899,8 @@ class UserDefined(ConstitutiveLaw):
                 raise ValueError(
                     'Two values need to be provided when setting the tuple'
                 )
-            eps_su_p = eps_su[0]
-            eps_su_n = eps_su[1]
+            eps_su_n = eps_su[0]
+            eps_su_p = eps_su[1]
             if eps_su_p < eps_su_n:
                 eps_su_p, eps_su_n = eps_su_n, eps_su_p
             if eps_su_p < 0:

{structuralcodes-0.0.2 → structuralcodes-0.1.0}/structuralcodes/sections/__init__.py

@@ -1,7 +1,6 @@
 """Main entry point for sections."""
 
 from ._generic import GenericSection, GenericSectionCalculator
-from ._reinforcement import add_reinforcement, add_reinforcement_line
 from .section_integrators import (
     FiberIntegrator,
     MarinIntegrator,
@@ -13,8 +12,6 @@ from .section_integrators import (
 __all__ = [
     'GenericSection',
     'GenericSectionCalculator',
-    'add_reinforcement',
-    'add_reinforcement_line',
     'SectionIntegrator',
     'FiberIntegrator',
     'MarinIntegrator',

{structuralcodes-0.0.2 → structuralcodes-0.1.0}/structuralcodes/sections/_generic.py

@@ -291,14 +291,14 @@ class GenericSectionCalculator(SectionCalculator):
         for g in geom.geometries + geom.point_geometries:
             for other_g in geom.geometries + geom.point_geometries:
                 # if g != other_g:
-                eps_p = g.material.get_ultimate_strain(yielding=yielding)[0]
+                eps_p = g.material.get_ultimate_strain(yielding=yielding)[1]
                 if isinstance(g, SurfaceGeometry):
                     y_p = g.polygon.bounds[1]
                 elif isinstance(g, PointGeometry):
                     y_p = g._point.coords[0][1]
                 eps_n = other_g.material.get_ultimate_strain(
                     yielding=yielding
-                )[1]
+                )[0]
                 if isinstance(other_g, SurfaceGeometry):
                     y_n = other_g.polygon.bounds[3]
                 elif isinstance(other_g, PointGeometry):
@@ -610,8 +610,8 @@ class GenericSectionCalculator(SectionCalculator):
         axial load.
 
         Arguments:
-            theta (float): Inclination of n.a. respect to section y axis,
-                default = 0.
+            theta (float): Inclination of n.a. respect to section y axis in
+                radians, default = 0.
             n (float): Axial load applied to the section (+: tension, -:
                 compression), default = 0.
 
@@ -667,7 +667,8 @@ class GenericSectionCalculator(SectionCalculator):
         n.a. and axial load.
 
         Arguments:
-            theta (float): Inclination of n.a. respect to y axis, default = 0.
+            theta (float): Inclination of n.a. respect to y axis in radians,
+                default = 0.
             n (float): Axial load applied to the section (+: tension, -:
                 compression), default = 0.
             chi_first (float): The first value of the curvature, default =
@@ -866,7 +867,7 @@ class GenericSectionCalculator(SectionCalculator):
         """Calculate the NM interaction domain.
 
         Arguments:
-            theta (float): Inclination of n.a. respect to y axis
+            theta (float): Inclination of n.a. respect to y axis in radians
                 (Optional, default = 0).
             num_1 (int): Number of strain profiles in field 1
                 (Optional, default = 1).
@@ -913,7 +914,7 @@ class GenericSectionCalculator(SectionCalculator):
             )
 
         # Get ultimate strain profiles for theta angle
-        strains = self._compute_ultimate_strain_profiles(
+        strains, field_num = self._compute_ultimate_strain_profiles(
             theta=theta,
             num_1=num_1,
             num_2=num_2,
@@ -948,9 +949,8 @@ class GenericSectionCalculator(SectionCalculator):
 
         # Save to results
         res.strains = strains
-        res.m_z = forces[:, 2]
-        res.m_y = forces[:, 1]
-        res.n = forces[:, 0]
+        res.forces = forces
+        res.field_num = field_num
 
         return res
 
@@ -1047,6 +1047,9 @@ class GenericSectionCalculator(SectionCalculator):
             raise ValueError(f'Type of spacing not known: {type}')
 
         # For generation of fields 1 and 2 pivot on positive strain
+        field_num = np.repeat(
+            [1, 2, 3, 4, 5, 6], [num_1, num_2, num_3, num_4, num_5, num_6]
+        )
         # Field 1: pivot on positive strain
         eps_n = _np_space(eps_p_b, 0, num_1, type_1, endpoint=False)
         eps_p = np.zeros_like(eps_n) + eps_p_b
@@ -1098,16 +1101,15 @@ class GenericSectionCalculator(SectionCalculator):
         eps_n = np.append(eps_n, eps_n_6)
         eps_p = np.append(eps_p, eps_p_6)
 
-        # rotate them
+        # compute strain components
         kappa_y = (eps_n - eps_p) / (y_n - y_p)
         eps_a = eps_n - kappa_y * y_n
-        kappa_z = np.zeros_like(kappa_y)
 
         # rotate back components to work in section CRS
         T = np.array([[cos(theta), -sin(theta)], [sin(theta), cos(theta)]])
-        components = np.vstack((kappa_y, kappa_z))
+        components = np.vstack((kappa_y, np.zeros_like(kappa_y)))
         rotated_components = T @ components
-        return np.column_stack((eps_a, rotated_components.T))
+        return np.column_stack((eps_a, rotated_components.T)), field_num
 
     def calculate_nmm_interaction_domain(
         self,
@@ -1180,7 +1182,7 @@ class GenericSectionCalculator(SectionCalculator):
         strains = np.empty((0, 3))
         for theta in thetas:
             # Get ultimate strain profiles for theta angle
-            strain = self._compute_ultimate_strain_profiles(
+            strain, field_num = self._compute_ultimate_strain_profiles(
                 theta=theta,
                 num_1=num_1,
                 num_2=num_2,
@@ -1216,6 +1218,7 @@ class GenericSectionCalculator(SectionCalculator):
         # Save to results
         res.strains = strains
         res.forces = forces
+        res.field_num = field_num
 
         return res
 
@@ -1234,16 +1237,21 @@ class GenericSectionCalculator(SectionCalculator):
         # Prepare the results
         res = s_res.MMInteractionDomain()
         res.num_theta = num_theta
-        res.n = n
         # Create array of thetas
         res.theta = np.linspace(0, np.pi * 2, num_theta)
         # Initialize the result's arrays
-        res.m_y = np.zeros_like(res.theta)
-        res.m_z = np.zeros_like(res.theta)
+        res.forces = np.zeros((num_theta, 3))
+        res.strains = np.zeros((num_theta, 3))
         # Compute strength for given angle of NA
         for i, th in enumerate(res.theta):
             res_bend_strength = self.calculate_bending_strength(theta=th, n=n)
-            res.m_y[i] = res_bend_strength.m_y
-            res.m_z[i] = res_bend_strength.m_z
+            # Save forces
+            res.forces[i, 0] = n
+            res.forces[i, 1] = res_bend_strength.m_y
+            res.forces[i, 2] = res_bend_strength.m_z
+            # Save strains
+            res.strains[i, 0] = res_bend_strength.eps_a
+            res.strains[i, 1] = res_bend_strength.chi_y
+            res.strains[i, 2] = res_bend_strength.chi_z
 
         return res