Modeling a Simply Supported Reinforced Concrete Beam with Fiber Sections in OpenSeesPy

This article presents a comprehensive, step-by-step tutorial on modeling a reinforced concrete beam using OpenSeesPy. Focusing on a simply supported beam with a 600‑inch span and a 24‑inch depth, the tutorial covers everything from establishing a basic two-dimensional model and defining nodes and support conditions to assigning nonlinear material properties for both concrete and reinforcing steel. Special emphasis is placed on constructing a detailed fiber section model—which discretizes the beam's cross-section into concrete patches and steel layers—to capture the nonlinear moment–curvature behavior accurately. Finally, the guide explains how to apply loads, run a static analysis using a force-based beam–column element, and post-process the results by extracting the mid-span displacement. Whether you're a practicing engineer or a student in structural analysis, this tutorial provides a clear pathway to using OpenSeesPy for advanced reinforced concrete modeling

from openseespy.opensees import *

# ---------------------------

# 1. Model Setup

# ---------------------------

# Create a basic 2D model with 3 DOF per node

model('basic', '-ndm', 2, '-ndf', 3)

# ---------------------------

# 2. Geometry & Nodes

# ---------------------------

# Let’s assume we have a simply supported RC beam:

L = 600.0 # Beam length in inches

beam_depth = 24.0 # Overall beam depth in inches

# Create nodes:

# Node 1: Left support at (0,0)

# Node 2: Right support at (L,0)

# Node 3: Mid-span (used here for applying a concentrated load)

node(1, 0.0, 0.0)

node(2, L, 0.0)

node(3, L/2, 0.0) # mid-span node on the bottom fiber

# For a typical beam analysis, the top fiber may be modeled within the section definition.

# Here, we assume supports at nodes 1 and 2 are fully fixed in all directions:

fix(1, 1, 1, 1)

fix(2, 1, 1, 1)

# ---------------------------

# 3. Material Definitions

# ---------------------------

# Define a concrete material using Concrete01:

# Parameters: tag, f'c (ksi), ec0, f'cu, ecu

uniaxialMaterial('Concrete01', 1, -5.0, -0.002, -3.0, -0.006)

# Define a reinforcing steel material using Steel01:

# Parameters: tag, fy (ksi), E (ksi), b (strain hardening ratio)

uniaxialMaterial('Steel01', 2, 60.0, 30000.0, 0.01)

# ---------------------------

# 4. Section Definition (Fiber Section)

# ---------------------------

# For a rectangular beam, let’s assume:

width = 12.0 # beam width in inches

depth = beam_depth # overall depth (24 in)

cover = 1.5 # cover thickness in inches

# Derived geometric parameters

half_width = width / 2.0

# Create the fiber section (tag = 1)

section('Fiber', 1)

# --- Concrete Fibers ---

# The concrete is discretized into fibers using the patch command.

# Here we first define the concrete core (region away from the cover):

patch('rect', 1, 10, 1,

cover, -half_width + cover,

depth - cover, half_width - cover)

# Next, add patches for the cover regions.

# Top cover:

patch('rect', 1, 10, 1,

depth - cover, -half_width,

depth, half_width)

# Bottom cover:

patch('rect', 1, 10, 1,

0.0, -half_width,

cover, half_width)

# Left cover:

patch('rect', 1, 10, 1,

0.0, -half_width,

depth, -half_width + cover)

# Right cover:

patch('rect', 1, 10, 1,

0.0, half_width - cover,

depth, half_width)

# --- Steel Fibers ---

# Reinforcement is added as layers at the top and bottom of the beam.

# For simplicity, assume two layers with 4 bars each of area 0.5 in².

numBars = 4

barArea = 0.5

# Top reinforcement: placed at a distance of cover from the top fiber

y_top = depth - cover - 0.5 # slight offset for fiber center

layer('straight', 2, numBars, barArea,

y_top, -half_width + cover,

y_top, half_width - cover)

# Bottom reinforcement: placed at a distance of cover from the bottom fiber

y_bot = cover + 0.5 # slight offset from bottom

layer('straight', 2, numBars, barArea,

y_bot, -half_width + cover,

y_bot, half_width - cover)

# ---------------------------

# 5. Element Definition

# ---------------------------

# Define a geometry transformation for beam elements (here, a linear transformation)

geomTransf('Linear', 1)

# Define the numerical integration for the beam element.

# We use Lobatto integration with 5 points.

beamIntegration('Lobatto', 1, 1, 5)

# Create the beam element using the force-based beam-column formulation.

# Here, element 1 connects nodes 1 and 2 with section tag 1 and integration tag 1.

element('forceBeamColumn', 1, 1, 2, 1, 1)

# ---------------------------

# 6. Loading & Analysis Setup

# ---------------------------

# Define a load pattern (e.g., a concentrated vertical load at mid-span)

timeSeries('Linear', 2)

pattern('Plain', 2, 2)

# Apply a vertical load (e.g., -10 kip) at node 3 (mid-span)

# Note: In a more refined beam model, loads might be distributed or applied as equivalent nodal loads.

load(3, 0.0, -10.0, 0.0)

# ---------------------------

# 7. Analysis Commands

# ---------------------------

system('BandGeneral')

constraints('Transformation')

numberer('RCM')

test('NormDispIncr', 1e-6, 10)

algorithm('Newton')

integrator('LoadControl', 0.1)

analysis('Static')

# Perform the static analysis (10 load steps)

analyze(10)

# ---------------------------

# 8. Post-Processing

# ---------------------------

# Retrieve and print the vertical displacement at node 3

disp_mid = nodeDisp(3, 2)

print("Vertical displacement at mid-span (node 3):", disp_mid)

wipe() # Clean up the model

Model Setup:

We start by initializing a basic two-dimensional model with three degrees of freedom per node. This setup is standard for beam–column problems where each node has horizontal, vertical, and rotational DOFs.

Geometry & Nodes:

In this example, we consider a simply supported beam with a span of 600 inches. Two support nodes (nodes 1 and 2) are fixed in all DOFs. A third node (node 3) is defined at mid-span and will be used for applying a vertical load. (In a more refined analysis the beam’s cross-section is captured in the fiber section rather than modeling a discrete “top” node.)

Material Definitions:

We define two uniaxial materials:

Concrete: Using the Concrete01 model, we input the compressive strength (–5 ksi) along with key strain parameters (the strain at peak stress and ultimate strain).
Steel: The reinforcing steel is defined using Steel01 with a yield stress of 60 ksi, a modulus of 30000 ksi, and a small hardening ratio

Section Definition (Fiber Section):

Fiber sections allow us to model the nonlinear behavior of reinforced concrete members by discretizing the cross-section into fibers.

Concrete Fibers: The cross-section is broken into patches. First, the concrete core (the interior region that is not in the cover zone) is defined. Then, additional patches represent the concrete cover on the top, bottom, and sides.
Steel Fibers: Reinforcement is modeled as layers (using the layer command). In this example, we add a top layer and a bottom layer, each with four reinforcing bars. The bars are positioned near the extreme fibers (with a slight offset) to capture tension and compression behavior.

Element Definition:

We define a linear geometry transformation for the beam element and choose the Lobatto integration scheme with five integration points. The forceBeamColumn element is then created between nodes 1 and 2, which will internally use the fiber section (tag 1) for moment–curvature response

Loading & Analysis Setup:

A load pattern is applied using a linear time series. A concentrated vertical load (–10 kip) is applied at the mid-span node (node 3). In a more detailed model, a distributed load might be converted into equivalent nodal loads.

Analysis Commands:

Standard commands are issued to set up the system (using a banded solver), constraints, DOF numbering (RCM for efficiency), convergence test, solution algorithm (Newton–Raphson), and load control integrator. We then run a static analysis over 10 incremental steps

Post-Processing:

Finally, we extract the vertical displacement at node 3. This displacement is the response of the beam under the applied load and is printed to the screen.

Each command is based on the OpenSeesPy command set and is chosen to reflect the physical behavior of reinforced concrete beams. For example, the fiber section discretization provides a way to capture material nonlinearity and reinforcement behavior, while the choice of integration (Lobatto) is common for beam–column elements. The load pattern and analysis commands are standard for static pushover or gravity load analyses.

This example is a starting point. In practice, you might refine the mesh, use more realistic load distributions, or incorporate additional effects such as shear deformations and bond-slip if needed.