Skip to content

Eurocode fire analysis: 500 °C isotherm — ribbed concrete slab

A YZ polygon is traced for the cross-section and extruded along X to build a 3D concrete solid:

+----------------------------------+ <- z = +120 (slab top)
| |
| slab 120 mm |
| |
+-----------+ +-----------+ <- z = 0 (slab soffit)
\ /
\ rib / trapezoidal:
\ 400 / top = RIB_WIDTH_TOP
\high/ bottom = RIB_WIDTH_BOTTOM
\ /
\/
++ <- z = -400 (rib bottom)
y=-500 -top/2 +top/2 +500

Convection + radiation with the ISO 834 fire curve are applied on the full underside profile (rib bottom + rib sides + slab soffit either side of the rib). The end caps (x = 0, x = EXTRUSION_X) and the slab top (z = +120) stay adiabatic.

After the R120 transient run, the 500 °C isotherm is reported as (a) its depth along the rib centreline (the point closest to the slab soffit at y = 0 where T crosses 500 °C), and (b) its full contour traced through the section, saved to PNG and to a text file as a polyline of (y, z) points.

The model before it is solved: parts, supports and loads

The model before it is solved: its parts, supports (red) and loads (blue).

The result: the model coloured by temperature (T [K])

The model, coloured by temperature (T [K]), in xfea’s 3D viewer.

Open in 3D turn it, cut it, pick any field: in xfea's viewer, in your browser

examples/scripts/02_core_concepts/thermal_analysis/fire_isotherm_500_ribbed_slab.py. Run it from the repository with uv run python examples/scripts/02_core_concepts/thermal_analysis/fire_isotherm_500_ribbed_slab.py, or, with xfea-examples installed, xfea-examples run 02_core_concepts/thermal_analysis/fire_isotherm_500_ribbed_slab.py.

import os
import matplotlib.pyplot as plt
import matplotlib.path as mpath
import matplotlib.tri as mtri
import numpy as np
from xfea.geometry import Polygon
from xfea.meshing import MeshingSettings
from xfea.model import (
BoundaryInterface,
Convection,
Model,
Part,
Radiation,
SolidSection,
ThermalElasticIsotropic,
)
from xfea.problem import HeatTransferStep, Problem
from xfea.results import TemperatureFieldResults
from xfea_examples import out_dir
from xfea_examples.step import prism_step
from xfea_tools import iso834, on_bbox
# Configuration
OUTPUT_DIR = out_dir("fire_isotherm_500_ribbed_slab")
STEP_PATH = os.path.join(OUTPUT_DIR, "ribbed_slab.stp")
FIRE_DURATION = 7200 # [s] R120
T_INITIAL = 293.15 # [K] 20 °C
T_ISOTHERM_K = 773.15 # [K] 500 °C
# Cross-section dimensions [mm]
SLAB_WIDTH = 1000
SLAB_THICK = 120
RIB_WIDTH_TOP = 250 # rib width at the slab soffit
RIB_WIDTH_BOTTOM = 150 # rib width at the rib bottom (symmetric trapezoidal taper)
RIB_HEIGHT = 400
EXTRUSION_X = 50 # [mm] depth of the extruded 3D solid along X
MESH_MIN = 10 # [mm]
MESH_MAX = 30 # [mm]
# Stage 1: Geometry — YZ polygon → thin extrusion in X → STEP
print("=" * 60)
print("Stage 1: Geometry + Material + Mesh")
print("=" * 60)
def _build_ribbed_slab_step(path):
"""Write the ribbed-slab section, extruded by EXTRUSION_X, to a STEP file."""
# Polygon traced clockwise in YZ (X = 0). Origin at slab soffit centreline.
# Rib is a symmetric trapezoid: wider at the top, narrower at the bottom.
pts_yz = [
(-SLAB_WIDTH / 2, 0.0), # slab soffit, far left
(-RIB_WIDTH_TOP / 2, 0.0), # rib top-left corner
(-RIB_WIDTH_BOTTOM / 2, -RIB_HEIGHT), # rib bottom-left
( RIB_WIDTH_BOTTOM / 2, -RIB_HEIGHT), # rib bottom-right
( RIB_WIDTH_TOP / 2, 0.0), # rib top-right corner
( SLAB_WIDTH / 2, 0.0), # slab soffit, far right
( SLAB_WIDTH / 2, SLAB_THICK), # slab top, far right
(-SLAB_WIDTH / 2, SLAB_THICK), # slab top, far left
]
polygon = Polygon([(0.0, y, z) for (y, z) in pts_yz])
prism_step(path, polygon.points, (EXTRUSION_X, 0.0, 0.0))
return path, polygon
step_path, polygon = _build_ribbed_slab_step(STEP_PATH)
print(f" STEP geometry: {step_path}")
# -- Concrete with EN 1992-1-2 §3.3 thermal properties --
def _ec2_conductivity(T_celsius):
T100 = T_celsius / 100.0
return max(1.36 - 0.136 * T100 + 0.0057 * T100**2, 0.5)
def _ec2_specific_heat(T_celsius):
"""EN 1992-1-2 §3.3.2 — siliceous concrete with u = 1.5 % moisture peak.
Dry curve (§3.3.2(1)): 900 → 1000 → 1100 J/(kg·K) at 100 / 200 / 400 °C.
Moisture peak (§3.3.2(2), default u = 1.5 %): rises from 900 at 100 °C to
c_p,peak = 1470 at 115 °C, then drops linearly back to the dry curve
value (1000) at 200 °C.
"""
if T_celsius <= 100:
return 900.0
if T_celsius <= 115:
return 900.0 + (1470.0 - 900.0) * (T_celsius - 100) / 15.0
if T_celsius <= 200:
return 1470.0 + (1000.0 - 1470.0) * (T_celsius - 115) / 85.0
if T_celsius <= 400:
return 1000.0 + (T_celsius - 200) / 2.0
return 1100.0
# Sample densely between 100 and 200 °C so the moisture peak at 115 °C is
# captured by the piecewise-linear table the solver interpolates from.
_temps_C = sorted(set(
list(range(20, 101, 20))
+ list(range(100, 201, 5))
+ list(range(200, 1201, 50))
))
k_table = [(_ec2_conductivity(T), T + 273.15) for T in _temps_C]
# SI-mm: c [mJ/(t·K)] = c [J/(kg·K)] × 1e6
c_table = [(_ec2_specific_heat(T) * 1e6, T + 273.15) for T in _temps_C]
mat = ThermalElasticIsotropic(
k=k_table,
c=c_table,
E=30_000, # [MPa] structural, unused in pure heat transfer
v=0.2,
density=2.3e-9, # [t/mm^3] (= 2300 kg/m^3)
)
sec = SolidSection(material=mat)
model = Model(name="fire_isotherm_500_ribbed_slab")
part = model.add_part(Part(name="ribbed_slab"))
part.base_geometry = step_path
part.mesh(settings=MeshingSettings(min=MESH_MIN, max=MESH_MAX), section=sec)
print(f" Mesh: {len(list(part.nodes))} nodes, {len(list(part.elements))} elements")
# Stage 2: Boundary conditions (fire exposure)
print(f"\n{'=' * 60}")
print("Stage 2: Boundary conditions (fire exposure)")
print("=" * 60)
fire_curve = iso834(FIRE_DURATION, dt=60, name="ISO834")
# Underside profile = boundary faces that are NOT one of:
# - the slab top (z = +120 = bbox zmax)
# - the front/back caps of the prism (x = 0/EXTRUSION_X = bbox xmin/xmax)
# - the slab end faces (y = ±SLAB_WIDTH/2 = bbox ymin/ymax) — these
# represent cuts through a continuous slab, not exposed surfaces
boundary_faces = part.find_boundary_faces()
fire_faces = boundary_faces.subgroup(
lambda f: not on_bbox(f, "zmax")
and not on_bbox(f, "xmin")
and not on_bbox(f, "xmax")
and not on_bbox(f, "ymin")
and not on_bbox(f, "ymax")
)
fire_surface = part.add_group(fire_faces)
fire_surface.name = "fire_exposed"
print(f" Fire-exposed surface: {len(list(fire_faces.faces))} faces")
# EN 1991-1-2 §3.1: h_c = 25 W/(m^2·K), eps = 0.7
convection = Convection(
h=25.0e-3, # [mW/(mm^2·K)]
temperature_value=1.0,
temperature_amplitude=fire_curve,
)
radiation = Radiation(
eps=0.7,
temperature_value=1.0,
temperature_amplitude=fire_curve,
)
model.add_interface(BoundaryInterface(master=fire_surface, behavior=convection))
model.add_interface(BoundaryInterface(master=fire_surface, behavior=radiation))
model.add_uniform_thermal_ics_field(T0=T_INITIAL, nodes=part.nodes)
# Stage 3: Transient heat transfer analysis (R120)
print(f"\n{'=' * 60}")
print("Stage 3: Transient heat transfer analysis (R120)")
print("=" * 60)
problem = model.add_problem(Problem(name="fire_R120"))
step = problem.add_step(
HeatTransferStep(
name="fire_exposure",
time=FIRE_DURATION,
initial_inc_size=2,
min_inc_size=0.1,
max_inc_size=60,
max_increments=10000,
max_temp_delta=50,
steady_state=False,
)
)
temp = TemperatureFieldResults()
step.add_field_outputs([temp])
print(" Running transient heat transfer analysis...")
problem.analyse_and_extract(path=OUTPUT_DIR, verbose=True)
min_T = temp.get_min_result("T", time=FIRE_DURATION)
max_T = temp.get_max_result("T", time=FIRE_DURATION)
print(
f"\n Final temperatures: min = {float(min_T.T):.1f} K "
f"({float(min_T.T) - 273.15:.1f} °C), "
f"max = {float(max_T.T):.1f} K ({float(max_T.T) - 273.15:.1f} °C)"
)
# 500 °C isotherm — section view (YZ projection of the 3D field)
print(f"\n{'=' * 60}")
print(f"500 °C isotherm: locating T = {T_ISOTHERM_K} K")
print("=" * 60)
# Collect nodal results. Faces at x = 0 and x = EXTRUSION_X are adiabatic so
# the 3D temperature field is x-invariant in the limit of fine x-discretisation.
# We project to YZ for the section view by binning nodes on the (y, z) plane
# and averaging T over their X copies.
final_results = temp.get_results(time=FIRE_DURATION)
y_all = np.array([r.location._y for r in final_results])
z_all = np.array([r.location._z for r in final_results])
t_all = np.array([float(r.T) - 273.15 for r in final_results]) # [°C]
bin_tol = 0.5 # [mm]
keys = np.column_stack((np.round(y_all / bin_tol),
np.round(z_all / bin_tol))).astype(np.int64)
keys_view = keys.view([("y", keys.dtype), ("z", keys.dtype)]).ravel()
unique_keys, inverse = np.unique(keys_view, return_inverse=True)
ys = np.zeros(len(unique_keys))
zs = np.zeros(len(unique_keys))
ts = np.zeros(len(unique_keys))
counts = np.zeros(len(unique_keys))
for i, idx in enumerate(inverse):
ys[idx] += y_all[i]
zs[idx] += z_all[i]
ts[idx] += t_all[i]
counts[idx] += 1
ys /= counts
zs /= counts
ts /= counts
# --- (a) depth of 500 °C isotherm along the rib centreline (y = 0) ---
centre = np.abs(ys) < bin_tol
z_centre = zs[centre]
t_centre = ts[centre]
order = np.argsort(z_centre)
z_sorted = z_centre[order]
t_sorted = t_centre[order]
# Walk from the slab top (cool) downwards toward the rib bottom (hot) until
# T crosses 500 °C. This pins the *uppermost* crossing — the deepest point
# of the 500 °C isotherm on the rib centreline.
crossing_z = None
for i in range(len(z_sorted) - 1, 0, -1):
t_hi, t_lo = t_sorted[i], t_sorted[i - 1]
if (t_hi - 500.0) * (t_lo - 500.0) <= 0.0 and t_hi != t_lo:
frac = (500.0 - t_hi) / (t_lo - t_hi)
crossing_z = z_sorted[i] + frac * (z_sorted[i - 1] - z_sorted[i])
break
if crossing_z is None:
print(" Rib centreline never crosses 500 °C.")
centreline_depth = None
else:
centreline_depth = SLAB_THICK - crossing_z # measured down from slab top
print(f" Rib centreline (y = 0):")
print(f" z at 500 °C = {crossing_z:+.1f} mm")
print(f" depth from slab top = {centreline_depth:.1f} mm")
print(f" height above rib bottom = {crossing_z + RIB_HEIGHT:.1f} mm")
# --- (b) build a triangulation masked to the section polygon ---
section_outline_y = np.array([
-SLAB_WIDTH / 2, -RIB_WIDTH_TOP / 2, -RIB_WIDTH_BOTTOM / 2,
RIB_WIDTH_BOTTOM / 2, RIB_WIDTH_TOP / 2, SLAB_WIDTH / 2,
SLAB_WIDTH / 2, -SLAB_WIDTH / 2,
])
section_outline_z = np.array([
0.0, 0.0, -RIB_HEIGHT, -RIB_HEIGHT, 0.0, 0.0,
SLAB_THICK, SLAB_THICK,
])
section_path = mpath.Path(np.column_stack((section_outline_y, section_outline_z)))
triang = mtri.Triangulation(ys, zs)
tri_centroids = np.column_stack((
ys[triang.triangles].mean(axis=1),
zs[triang.triangles].mean(axis=1),
))
mask = ~section_path.contains_points(tri_centroids)
triang.set_mask(mask)
# EN 1992-1-2 insulation-criterion threshold: ΔT ≤ 140 K above the initial
# temperature. Concrete below this threshold has effectively not been
# affected by the fire.
T_INSULATION_C = (T_INITIAL + 140.0) - 273.15 # = 160 °C with T0 = 20 °C
# --- (c) plot ---
fig, ax = plt.subplots(figsize=(10, 8))
filled = ax.tricontourf(triang, ts, levels=32, cmap="hot_r")
fig.colorbar(filled, ax=ax, label="Temperature [°C]")
contour = ax.tricontour(triang, ts, levels=[500.0], colors="cyan", linewidths=2)
# Green overlay: T ≤ T0 + 140 K (EN 1992-1-2 insulation criterion).
# Hatching ensures the region is visible against the light-yellow background
# even where the underlying colormap value is already pale.
ax.tricontourf(
triang, ts,
levels=[float(ts.min()) - 1.0, T_INSULATION_C],
colors=["limegreen"],
alpha=0.55,
hatches=["///"],
)
ax.tricontour(triang, ts, levels=[T_INSULATION_C],
colors="darkgreen", linewidths=1.8)
ax.plot(np.append(section_outline_y, section_outline_y[0]),
np.append(section_outline_z, section_outline_z[0]),
"k-", linewidth=1.2)
ax.set_xlabel("y [mm]")
ax.set_ylabel("z [mm]")
ax.set_title(
f"EN 1992-1-2 — Ribbed slab, ISO 834 R{FIRE_DURATION // 60}\n"
f"500 °C isotherm (cyan), T ≤ T₀ + 141 K (green)"
)
ax.set_aspect("equal")
ax.grid(True, alpha=0.3)
fig.tight_layout()
plot_path = os.path.join(OUTPUT_DIR, "isotherm_500_yz.png")
fig.savefig(plot_path, dpi=150)
plt.close(fig)
print(f" Plot saved: {plot_path}")
# Dump the contour polylines (one per disconnected segment) to a text file.
contour_path = os.path.join(OUTPUT_DIR, "isotherm_500_polyline.txt")
with open(contour_path, "w") as fh:
fh.write(f"# 500 C isotherm (section view) after R{FIRE_DURATION // 60} ISO 834 fire\n")
fh.write("# y[mm] z[mm] (one segment per blank-line separated block)\n")
n_segments = 0
n_vertices = 0
for path in contour.get_paths():
verts = path.vertices
if len(verts) == 0:
continue
n_segments += 1
for y, z in verts:
fh.write(f"{y:10.3f} {z:10.3f}\n")
n_vertices += 1
fh.write("\n")
print(f" Polyline saved: {contour_path} ({n_segments} segments, {n_vertices} vertices)")
# Summary
print(f"\n{'=' * 60}")
print("Summary — EN 1992-1-2 500 °C isotherm method")
print("=" * 60)
print(f" Fire curve: ISO 834")
print(f" Exposure: {FIRE_DURATION / 60:.0f} min (R{FIRE_DURATION // 60})")
print(f" Section: slab {SLAB_WIDTH} x {SLAB_THICK} mm,")
print(f" rib {RIB_WIDTH_TOP}/{RIB_WIDTH_BOTTOM} (top/bot) "
f"x {RIB_HEIGHT} mm (trapezoidal downstand)")
print(f" Extrusion (X): {EXTRUSION_X} mm")
print(f" Convection: h = 25 W/(m^2 K)")
print(f" Radiation: eps = 0.7")
print(f" Max temperature: {float(max_T.T) - 273.15:.0f} °C")
print(f" Min temperature: {float(min_T.T) - 273.15:.0f} °C")
if centreline_depth is not None:
print(f" 500 °C @ rib centreline: z = {crossing_z:+.1f} mm "
f"({centreline_depth:.1f} mm below slab top)")
print(f" Output directory: {OUTPUT_DIR}")

© 2026 Francesco Ranaudo · Text and pictures CC BY 4.0 · Code Elastic License 2.0 · how to reuse them