Homogenized cross-section

[DanielGMorenaFhecor]

Currently, it is not possible to compute the inertia of a homogenized cross-section. It would be useful to access these homogenized properties for further calculations.

[talledodiego]

We did not implemented yet something specific because I feel that the concept of homogenized section is not as useful as former times and because there are some difficulties like dealing with many concretes (you should decide on what homogenize); dealing with generic section that may be even without concrete.
Anyhow we can think about it an implement something in the future.

Actually it is possible with the current framework in a super flexible way compute homogenized sections. See for instance the following code (the whole notebook is available here):

Example

Definite the section

# imports
from shapely import Polygon
from structuralcodes.materials.concrete import ConcreteEC2_2004
from structuralcodes.materials.reinforcement import ReinforcementEC2_2004
from structuralcodes.geometry import SurfaceGeometry
from structuralcodes.sections._reinforcement import add_reinforcement_line
from structuralcodes.sections import GenericSection

# Materials
concrete = ConcreteEC2_2004(25)
reinforcement = ReinforcementEC2_2004(fyk=500, Es=206000, density=7850, ftk=550, epsuk=0.07) 

# Create section
poly = Polygon(((0, 0), (350, 0), (350, 500), (0, 500)))
geo = SurfaceGeometry(poly, concrete)
geo = add_reinforcement_line(geo, (50, 450), (300, 450), 12, reinforcement, n=3)
geo = add_reinforcement_line(geo, (50, 50), (300, 50), 20, reinforcement, n=6)
geo

Suppose we want to homogeneize the section to concrete. Let's use some different approaches to achieve this. We can use the axial rigidity dividing by the elastic modulus.

1. Let's see a first application example using the default parabola rectangle law (take in mind that for parabola rectangle law the initial tangent is equal to 2 * fc / eps_0)
   With this law and a design strength for concrete is fcd = 16.666 MPa, so the initial modulus is 16666 MPa. The design strength of steel is 434.78 MPa and the initial modulus is 206000 MPa. Therefore the homogeneization factor in this case is n = Es / Ec = 12.3

# Initialize the section
sec = GenericSection(geo, integrator='marin')
area = sec.gross_properties.area * 1e-2
area_reinf = sec.gross_properties.area_reinforcement * 1e-2

# Calculate homogenized properties
ea = sec.gross_properties.ea

et_concrete = concrete.constitutive_law.get_tangent(0)[0]
et_reinf = reinforcement.constitutive_law.get_tangent(0)[0]

area_hom = ea / et_concrete * 1e-2
n_hom = et_reinf / et_concrete

# Print results
print(f"Area = {round(area)} cm2")
print(f"Area_reinforcement = {round(area_reinf)} cm2")
print(f"EA = {ea * 1e-6:.1f} MN")
print(f"Area_hom (E={et_concrete:.0f} MPa) = {area_hom:.1f} cm2 (n = {n_hom:.2f})")

The output is:

Area = 1750 cm2
Area_reinforcement = 22 cm2
EA = 3374.9 MN
Area_hom (E=16667 MPa) = 2024.9 cm2 (n = 12.36)

2. If we use another constitutive law like Mander/Popovics the initial elastic modulus of concrete is equal to Ecm = 31476 MPa. Therefore the homogeneization factor in this case is n = Es / Ec = 6.5. Let's note that this is a typical value for homogeneization factor (6-7) even if in the codes a typical value adopted was of 15, for taking into account long-term effects.

# Change constitutive law
concrete.constitutive_law = 'popovics'

# Re-create the section.
# This is necessary because the constitutive laws are copied from the material objects
geo = SurfaceGeometry(poly, concrete)
geo = add_reinforcement_line(geo, (50, 450), (300, 450), 12, reinforcement, n=3)
geo = add_reinforcement_line(geo, (50, 50), (300, 50), 20, reinforcement, n=6)
sec = GenericSection(geo, integrator='marin')

# Calculate homogenized properties
ea = sec.gross_properties.ea

et_concrete = concrete.constitutive_law.get_tangent(0)[0]
et_reinf = reinforcement.constitutive_law.get_tangent(0)[0]

area_hom = ea / et_concrete * 1e-2
n_hom = et_reinf / et_concrete

# Print results
print(f"Area = {round(area)} cm2")
print(f"Area_reinforcement = {round(area_reinf)} cm2")
print(f"EA = {ea * 1e-6:.1f} MN")
print(f"Area_hom (E={et_concrete:.0f} MPa) = {area_hom:.1f} cm2 (n = {n_hom:.2f})")

which returns:

Area = 1750 cm2
Area_reinforcement = 22 cm2
EA = 5966.5 MN
Area_hom (E=31476 MPa) = 1895.6 cm2 (n = 6.54)

3. A further possibility is to change manually the elastic modulus (for instance reducing it for accounting for long terms effect) of concrete. Here we take a coefficient fi_inf = 2, but we can compute it more correctly with the code equations. So the nice thing of this approach is that we can use code equations and time effects in the computation.

# Modify elastic modulus
fi_inf = 2.0
Ec_eff = concrete.Ecm / (1 + fi_inf)
concrete.Ecm = Ec_eff

# Change constitutive law
concrete.constitutive_law = 'popovics'

# Re-create the section
geo = SurfaceGeometry(poly, concrete)
geo = add_reinforcement_line(geo, (50, 450), (300, 450), 12, reinforcement, n=3)
geo = add_reinforcement_line(geo, (50, 50), (300, 50), 20, reinforcement, n=6)
sec = GenericSection(geo, integrator='marin')

# Calculate homogenized properties
ea = sec.gross_properties.ea

et_concrete = concrete.constitutive_law.get_tangent(0)[0]
et_reinf = reinforcement.constitutive_law.get_tangent(0)[0]

area_hom = ea / et_concrete * 1e-2
n_hom = et_reinf / et_concrete

# Print results
print(f"Area = {round(area)} cm2")
print(f"Area_reinforcement = {round(area_reinf)} cm2")
print(f"EA = {ea * 1e-6:.1f} N")
print(f"Area_hom (E={et_concrete:.0f} MPa) = {area_hom:.1f} cm2 (n = {n_hom:.2f})")

Which returns:

Area = 1750 cm2
Area_reinforcement = 22 cm2
EA = 2294.3 N
Area_hom (E=10492 MPa) = 2186.7 cm2 (n = 19.63)

4. A further possibility is to manually calculate the elastic modulus of concrete as in 3) and define the materials as linear elastic. This method should yield the same results as 3).

# Change constitutive law
# Note that we keep the elastic modulus as in 3)
concrete.constitutive_law = 'elastic'
reinforcement.constitutive_law = 'elastic'

# Re-create the section
geo = SurfaceGeometry(poly, concrete)
geo = add_reinforcement_line(geo, (50, 450), (300, 450), 12, reinforcement, n=3)
geo = add_reinforcement_line(geo, (50, 50), (300, 50), 20, reinforcement, n=6)
sec = GenericSection(geo, integrator='marin')

# Calculate homogenized properties
ea = sec.gross_properties.ea

et_concrete = concrete.constitutive_law.get_tangent(0)[0]
et_reinf = reinforcement.constitutive_law.get_tangent(0)[0]

area_hom = ea / et_concrete * 1e-2
n_hom = et_reinf / et_concrete

# Print results
print(f"Area = {round(area)} cm2")
print(f"Area_reinforcement = {round(area_reinf)} cm2")
print(f"EA = {ea * 1e-6:.1f} N")
print(f"Area_hom (E={et_concrete:.0f} MPa) = {area_hom:.1f} cm2 (n = {n_hom:.2f})")

Yielding the following result:

Area = 1750 cm2
Area_reinforcement = 22 cm2
EA = 2294.3 N
Area_hom (E=10492 MPa) = 2186.7 cm2 (n = 19.63)

[MestreCarlos]

As I have commonly worked, I use the Ecm of the concrete as the reference modulus for homogenized sections and not the tangent modulus at the origin, as you suggest above.

I think it would be useful for the code to have the possibility to request the "gross_properties" from the section by passing an optional parameter for the reference modulus "E", allowing the user to choose the one they consider appropriate. If not specified, it should return the results as it currently does.

Having a homogenized inertia can be useful because in some parts of the codes it is required to follow the formulas.

[talledodiego]

Even if you pass a reference modulus E you have in a section a compound of surface and point geometries. Each one has its own elastic modulus. So you should provide a reference E for each material?
This is actually already possible with approach 4 above.
I think the current design is flexible enough to permit computing those properties as needed, even if it is not a single call. I don't think this is an important issue since this is a back-end so even if we need some more calls for setting manually a dummy material and computing the properties it is not a big deal I think, especially when considering the flexibility permitted by the proposed approach that consent to deal with the standard case of homogenizing using Ecm but also permit to explore other approaches like accounting for long-term effects.

Of course in a future front-end we can always do those calls with a simple press of a button for making it more user-friendly.

@mortenengen what is your opinion on this?

Another note: related to #135, even if we still should discuss deeper it, if we create some functions in the API to update the constitutive law of SurfaceGeometries or PointGeometries in a section, this computation of homogenized properties would become even easier without the need of recreating a new section object, like for instance:

# Change constitutive law
# Note that we keep the elastic modulus as in 3)
concrete.constitutive_law = 'elastic'
reinforcement.constitutive_law = 'elastic'

# update the section laws
sec.geometries.get_by_name('concrete').set_material(concrete)
sec.geometries.get_by_name('steel').set_material(reinforcement)

# Calculate homogenized properties
ea = sec.gross_properties.ea

et_concrete = concrete.constitutive_law.get_tangent(0)[0]
et_reinf = reinforcement.constitutive_law.get_tangent(0)[0]

area_hom = ea / et_concrete * 1e-2
n_hom = et_reinf / et_concrete

# Print results
print(f"Area = {round(area)} cm2")
print(f"Area_reinforcement = {round(area_reinf)} cm2")
print(f"EA = {ea * 1e-6:.1f} N")
print(f"Area_hom (E={et_concrete:.0f} MPa) = {area_hom:.1f} cm2 (n = {n_hom:.2f})")