Slim-Floor beam with small hat profile

Units: Millimeter [mm], Newton [N]

Geometries and materials

The code below creates the cross_section of a slim-floor beam with the following parts:

• UPE 200 steel profile with \(f_\mathrm{y}\) = 293 N/mm² and \(f_\mathrm{u}\) = 443 N/mm²

• bottom steel flange with 400x10 with \(f_\mathrm{y}\) = 313 N/mm² and \(f_\mathrm{u}\) = 460 N/mm²

• concrete slab with concrete compressive strength \(f_\mathrm{cm} = 29.5\) N/mm²

• top-rebar-layer 10/100, \(c_\mathrm{nom}\) = 10 mm, with \(c_\mathrm{nom} = 10\) mm from the top-edge of the concrete-slab

• bottom-rebar-layer 12/100, \(c_\mathrm{nom}\) = 12 mm, with \(c_\mathrm{nom} = 10\) mm from the bottom-edge of the concrete-slab

The UPE 200 profile is positioned on top of the bottom-flange. In reality the UPE-profile is welded on top of the bottom-flange steel-plate, what is assumed by the m_n_kappa by default.

This steel girder is integrated into the concrete slab. Therefore, the concrete slab is situated around the steel-beam, what is done by splitting the concrete slab in appropriate pieces.

Geometry: UPE 200 - slim-floor beam

Material: Bi-linear stress-strain-relationship with hardening of steel

Material: Concrete non-linear stress-strain-relationship in compression acc. EN 1992-1-1 [1]

Material: Stress-strain-relationship of concrete in tension

Slim-Floor cross-section

>>> from m_n_kappa import Rectangle, Steel, UPEProfile, Concrete, RebarLayer, Reinforcement
>>> plate_geometry = Rectangle(top_edge=220.0, bottom_edge=220.0+10., width=400.0)
>>> bottom_flange_material = Steel(f_y=313, f_u=460, failure_strain=0.15)
>>> bottom_flange = plate_geometry + bottom_flange_material
>>> upe200_geometry = UPEProfile(top_edge=144, t_f=5.2, b_f=76, t_w=9.0, h=200)
>>> upe200_material = Steel(f_y=293, f_u=443, failure_strain=0.15)
>>> upe200 = upe200_geometry + upe200_material
>>> concrete_left = Rectangle(top_edge=0.00, bottom_edge=220.00, width=1650.00, left_edge=-1750.00, right_edge=-100.00)
>>> concrete_middle = Rectangle(top_edge=0.00, bottom_edge=144.00, width=200.00, left_edge=-100.00, right_edge=100.00)
>>> concrete_right = Rectangle(top_edge=0.00, bottom_edge=220.00, width=1650.00, left_edge=100.00, right_edge=1750.00)
>>> concrete_geometry = concrete_left + concrete_middle + concrete_right
>>> concrete_material = Concrete(
...     f_cm=29.5,
...     f_ctm=2.8,
...     compression_stress_strain_type='Nonlinear',
...     tension_stress_strain_type='consider opening behaviour')
>>> concrete_slab = concrete_geometry + concrete_material
>>> rebar_top_layer_geometry = RebarLayer(rebar_diameter=12., centroid_z=10.0, width=3500, rebar_horizontal_distance=100.)
>>> rebar_bottom_layer_left_geometry = RebarLayer(
...        rebar_diameter=10., centroid_z=220-10, width=1650.0, rebar_horizontal_distance=100., left_edge=-1740.,)
>>> rebar_bottom_layer_right_geometry = RebarLayer(
...        rebar_diameter=10., centroid_z=220-10, width=1650.0, rebar_horizontal_distance=100., right_edge=1740.,)
>>> rebar10_material = Reinforcement(f_s=594, f_su=685, failure_strain=0.25, E_s=200000)
>>> rebar12_material = Reinforcement(f_s=558, f_su=643, failure_strain=0.25, E_s=200000)
>>> rebar_top_layer = rebar_top_layer_geometry + rebar12_material
>>> rebar_bottom_layer_left = rebar_bottom_layer_left_geometry + rebar10_material
>>> rebar_bottom_layer_right = rebar_bottom_layer_right_geometry + rebar10_material
>>> rebar_layer = rebar_top_layer + rebar_bottom_layer_left + rebar_bottom_layer_right
>>> cross_section = bottom_flange + upe200 + concrete_slab + rebar_layer

Computation

The cross_section you created above is the basis to do a variety of computations:

Curvature

In case you want to compute a single curvature-value from a given strain at a given position, you first have to define strain and its position using StrainPosition strain_position is the boundary-condition, that is passed to MKappaByStrainPosition that is computing the curvature.

>>> from m_n_kappa import StrainPosition, MKappaByStrainPosition
>>> strain_position = StrainPosition(strain=-0.002, position=0.0, material="")
>>> computation = MKappaByStrainPosition(
...     cross_section=cross_section,
...     strain_position = strain_position,
...     positive_curvature=True)

After computation you can extract the results as follows:

• m_n_kappa.MKappaByStrainPosition.successful: if True equilibrium of horizontal forces has been achieved during computation

• m_n_kappa.MKappaByStrainPosition.axial_force: computed axial forces that should be near zero as this is what the computation is aimed at

• m_n_kappa.MKappaByStrainPosition.moment: computed moment

• m_n_kappa.MKappaByStrainPosition.curvature: computed curvature

• m_n_kappa.MKappaByStrainPosition.neutral_axis: vertical position of the neutral axis (strain \(\varepsilon=0\))

See also

Moment-Curvature-Curve: further explanations regarding computation of a single moment-curvature-point

M-\(\kappa\)-curve

The \(M\)-\(\kappa\)-curve is easily computed by passing the created cross_section to MKappaCurve. You only have to decide if you want only the positive moment-curvature-points, the negative moment-curvature-points or both.

>>> from m_n_kappa import MKappaCurve
>>> positive_m_kappa = MKappaCurve(cross_section=cross_section)
>>> negative_m_kappa = MKappaCurve(
...     cross_section=cross_section,
...     include_positive_curvature=False,
...     include_negative_curvature=True)
>>> full_m_kappa = MKappaCurve(
...     cross_section=cross_section,
...     include_positive_curvature=True,
...     include_negative_curvature=True)

The computed points are then stored in the attribute m_kappa_points that returns MKappaCurvePoints-object.

See also

Moment-Curvature-Curve : further explanation regarding computation of the Moment- Curvature-Curve

Beam-Deformation

For computation of the \(M\)-\(\kappa\)-curves in a beam you need the loading-scenario beside your cross_section. And you should decide in how many elements the beam shall be split into (see element_number). In case you also want to consider the effective widths you may set consider_widths=True.

>>> from m_n_kappa import SingleSpanUniformLoad, Beam
>>> loading = SingleSpanUniformLoad(length=8000, load=1.0)
>>> beam = Beam(cross_section=cross_section, element_number=10, load=loading)
>>> beam_consider_widths = Beam(
...     cross_section=cross_section,
...     element_number=10,
...     load=loading,
...     consider_widths=True)

The computed beams allow you to do a number of analysis, like:

• m_n_kappa.Beam.deformation_over_beam_length(): computes the deformation at each node along the beam under the given load

• m_n_kappa.Beam.deformations(): computes the deformation at the given position for the relevant load-steps

• m_n_kappa.Beam.deformations_at_maximum_deformation_position(): same like m_n_kappa.Beam.deformations() but at the position of the beam where the maximum deformation occurred under the given loading.

See also

Loading: further explanation of loading scenarios

Deformation : further explanation regarding computation of beam-deformation

References

[1]

EN 1992-1-1: Eurocode 2: Design of concrete structures - Part 1-1: General rules and rules for buildings, European Committee of Standardization (CEN), 2004