feat: Draft Add sections framework

[talledodiego]

This PR contains a first draft on sections level.
The structure given considers the section (for now only the generic section has been implemented) object that contains a combination of geometries (e.g. surfaces, points) and materials (constitutive relation). The section calculator is the object implementing the different computation algorithms. The integrator object is the one necessary for doing the integration of stresses in the section: two integrators have been implemented, Marin (default) and Fibre integration. The results are stored as proper dataclasses.
The implementation relys on shapely package.

Some limited usecase examples are reported.

1. Importing the necessary functions

from structuralcodes.materials.constitutive_laws import ElasticPlastic
from structuralcodes.materials.concrete import ConcreteMC2010
from structuralcodes.materials.reinforcement import ReinforcementMC2010
from structuralcodes.sections._generic import GenericSection
from structuralcodes.sections._geometry import add_reinforcement, add_reinforcement_line, SurfaceGeometry
from shapely import Polygon

2. Creating material objects (note: the section framework supports both constitutive laws or material classes from where the constitutive law is available)

concrete = ConcreteMC2010(30)
reinforcement = ReinforcementMC2010(410, 200000, 410, 0.0675)

3. Create a rectangular section with some reinforcement

rect = Polygon(((-100,-250),(100,-250),(100,250),(-100,250)))
geo = SurfaceGeometry(rect, concrete)
geo = add_reinforcement(geo, (-60, 210), 16, reinforcement)
geo = add_reinforcement(geo, (60, 210), 16, reinforcement)

The output is the following:

4. Different ways of adding reinforcement:
   Specifying a line and a number of reinforcements (spacing is automatically computed):

add_reinforcement_line(geo, (-60,-210), (60,-210), 16, reinforcement, n = 4)

Specifying a line and the spacing of bars (number is automatically computed):

add_reinforcement_line(geo, (-60,-210), (60,-210), 16, reinforcement, s = 30)

The function can be also nested

geo = add_reinforcement_line(
    add_reinforcement_line(geo, (-60, -210), (60, -210), 16, reinforcement, n = 2),
    (-60,-210),
    (60,-210),
    8,
    reinforcement,
    s = 20,
    first = False,
    last = False
)

Also, both spacing and number can be given:

add_reinforcement_line(
    add_reinforcement_line(geo, (60, -210), (60, 210), 12, reinforcement, n = 2, s = 100), 
    (-60, -210), 
    (-60, 210), 
    12, 
    reinforcement, 
    n = 2, 
    s = 100
)

5. Translate and other editing are included

geo = geo.translate(-100,-100)

6. Create the section (if integrator is not specified, Marin integration is used)

sec = GenericSection(geo, 'mySection', integrator = 'Fiber')

7. Compute gross properties (e.g. Area)

print(sec.gross_properties.area)

8. Compute bending strength

res = sec.section_analyzer.calculate_bending_strength(theta = 0, n = 0)
print(res.m_x)

9. Compute moment Curvature

res = sec.section_analyzer.calculate_moment_curvature(theta=0, n=0)
import matplotlib.pyplot as plt
plt.plot(res.chi, -res.my)

10. Analyze a steel section (like I-shaped)

fyk = 355
Es = 206000
Eh = 0.0
eps_su = 10.0e-2 #plastic strength
eps_su = fyk / Es #elastic strength

# H section
h = 300
b = 150
tf = 10.7
tw = 7.1
steel = ElasticPlastic(E=Es, fy=fyk, Eh=Eh, eps_su=eps_su)
# Geometry
sec_geom = Polygon(
    (
        (-b/2, -h/2),
        (b/2, -h/2),
        (b/2, -h/2+tf),
        (tw/2, -h/2+tf),
        (tw/2, h/2 - tf),
        (b/2, h/2-tf),
        (b/2, h/2),
        (-b/2, h/2),
        (-b/2, h/2 - tf),
        (-tw/2, h/2 - tf),
        (-tw/2, -h/2 + tf),
        (-b/2, -h/2 + tf),
    )
)
# Trick: create a CompundGeometry with just one SurfaceGeometry to make algorithms work
geo = CompoundGeometry([SurfaceGeometry(sec_geom, steel)])
# Section
sec = GenericSection(geo)

res_fiber = sec.section_analyzer.calculate_bending_strength(theta=0, n=0)
print(f'Mx = {res_fiber.m_x * 1e-6:.2f} kNm')
# Expected bending strength
J = 2/12 * (b * tf**3) + 2 * (tf*b) * (h/2-tf/2)**2 + 1/12 * (tw * (h-2*tf)**3)
W = J/(h/2)
print(f'Expected Mx,el = {fyk * W * 1e-6:.2f} kNm')
Wpl = 2 * (tf * b * (h/2 - tf/2) + (h/2-tf) * tw * (h/2-tf)/2)
print(f'Expected Mx,pl = {fyk * Wpl * 1e-6:.2f} kNm')

[talledodiego]

@mortenengen with 9a9d2c7 I included several tests on steel structures with I section. I have a problem: with parametrize if I un-comment more than 2-3 lines for possible testing the make test freezes.. I don't know if this a memory limit for my PC. Any suggestion?

[mortenengen]

@mortenengen with 9a9d2c7 I included several tests on steel structures with I section. I have a problem: with parametrize if I un-comment more than 2-3 lines for possible testing the make test freezes.. I don't know if this a memory limit for my PC. Any suggestion?

This was a strange one. There were tests that were either failing or freezing, and it was due to polygons that were joined through unions, but were still disconnected. Taking the union of disconnected geometries produces MultiPolygon and not Polygon, and therefore, the constructor of SurfaceGeometry raised a TypeError. I used the set_precision function from shapely to set the precision of the geometries to a very low number, and this made the tests pass 😃

[mortenengen]

In 1d64e13 I added constitutive laws to the Reinforcement class and swapped the ElasticPlastic objects with ReinforcementMC2010 in relevant tests.