Nonlinear Structural Analysis

Using OpenSees

Suiwen Wu

CEE 721
12:00 -1:15
03/30/2021
Email: suiwenw#@unr.edu
 Outline

• Download, installation and running of OpenSees

• Tcl syntax to develop an OpenSees model
• Workflow to develop a model
• Example 1: A cantilever beam
• Example 2: A cantilever beam w/ geometric nonlinearity
• Steel building models
 Download and installation
1. Download
Go to the OpenSees website:
http://opensees.berkeley.edu/OpenSees/user/download.php
Input your email address. If no account, register first.

Based on the system of your computer, download the corresponding OpenSees.exe

file and tcl/tk executable.

OpenSees
 Download and installation

2. Installation
• There is no need to install the tcl/tk version 8.6.10 for the OpenSees version 3.2.2
• Install the Nodepad++ to compile the model. https://notepad-plus-
plus.org/downloads/

Note that Nodepad++ is the platform to compile OpenSees model.

 Run OpenSees’ model in windows
Method 1:
▪ Place the model file to under the same folder of the OpenSee.exe (.tcl).
▪ Double click the opensees.exe and then type command: source filename.tcl

▪ After the analysis, remember to type “exit”, unless no results will show up in the
record file.
Method 2:
▪ Set Path Environment Variable

▪ Type “cmd” in the search (bottom left corner)

▪ Type the command OpenSees filename.tcl, or type OpenSees first and then run the
command source filename.tcl.
Comment: this method can work only if you set the path environment
variable
 Run OpenSees’ model in windows
▪ Download an OpenSess example by searching:
▪ OpenSees examples→Basic Examples Manual→1. Truss Example.
▪ Or http://opensees.berkeley.edu/wiki/index.php/Basic_Truss_Example
Method 1:

Place the model (.tcl file) under the

same folder (“bin”) as “OpenSees.exe”)
 Method 2: Set Path Environment
Variable - Windows system
Method 2: Set Path Environment Variable - Windows system
▪ Click “Search Windows” (lower left corner of the screen), type env, and choose
“Edit the system environment variables”;
▪ Click on the “Environment variables...” button in the dialog window;

▪ Find the “Path” under “System Variables in the Variable column”;

▪ Click “edit” and then “New” and “browse” to get the path of your OpenSees.exe
(this will be something like: C:\Users\suiwenwu\Desktop\OpenSees3.2.2-
x64.exe\bin);
▪ Click OK in every dialog to close them and save your changes.
 Run OpenSees’ model in windows
Method 2: Set Path Environment Variable - Windows system

Directory of the “OpenSees.exe”

 Run OpenSees’ model in windows
Method 2: Switch to the folder
that contains the
OpenSees model

If installed correctly,
OpenSees’ information
will pop out

Run Truss example

Edit Path Environment Variable - MacOS
▪ Place OpenSees in a dir called bin in your home directory
▪ Edit file .bashrc file in home directory adding line
export PATH=$HOME/bin:$PATH
▪ Type “source .bashrc” in terminal window to make sure you have not
messed things up
 Test It

Open terminal or cmd window and type OpenSees

… and you should see something like
 Tcl Syntax Rules
Rules that define combinations that give a correctly structured
program
▪ A Tcl Script is a sequence of Tcl Commands

▪ Commands in script are separated by newlines or ;

▪ All defined variables are called out using “$” sign before them

▪ A command has the following format

commandName $arg1 $arg2 $arg3

▪ The first word is the command name

▪ The remaining words are the command arguments

▪ The arguments of a command are separated by white spaces

▪ The number of arguments depends on the command

 Examples of Tcl syntax
•Comments •expression evaluation •procedures & control structures
># this is a comment >expr 2 + 3 > for {set i 1} {$i < 10} {incr i 1}
5 puts “i equals $i”
•Variables >set b[expr 2 + $b] }
3 > set sum 0
>set a 1 foreach value {1 2 3 4} {
1 •lists set sum [expr $sum + $value]
>set b a >set a {1 2 three} }
a 1 2 three >puts $sum
>set b $a >set la [llength $a] 10
1 3 >proc guess {value} {
>set start [lindex $a 0] global sum
•file manipulation if {$value < $sum} {
1
>set fileId [open tmp w] puts “too low”
>lappend a four
?? } else {
1 2 three four
>puts $fileId “hello” if {$value > $sum} {
>close $fileID •associative arrays puts “too high”
>type tmp } else { puts “you got it!”}
>array set a {one 1 three 3}
hello }
>set $a(fifty) blah
}
•Load other files >array get a fifty
> guess 9
fifty blah
>source Example1.tcl too low
 Workflow to build a model
• Launch Nodepad++ and start to compile OpenSees model
• Save the file as “.tcl” format.
 Workflow to build a model

Model builder Model builder: specifies # of dimensions and # of DOFs

model BasicBuilder –ndm $ndm – ndf $ndf
For example: for truss member
Node
model BasicBuilder –ndm 2– ndf 2
Node: Define node tag, and its corresponding
Material & Section coordinates and mass.
node $nodeTag (ndm $coords) <-mass (ndf $mass
Values)>
Boundary condition For example:
node 1 0.0 0.0 0.0 –mass 0.0 1.0 0.0 0.0 0.0 0.0
Element Define node 1 at coordinates (0.0 0.0 0.0) and assign
mass my=1.0.
Note that the command with “< >” means optional. The
Recorder users can determine whether they need to specify it or
not.
Analysis OpenSees manual:
http://opensees.berkeley.edu/wiki/index.php/Modeling_Commands
 Workflow to build a model

Material
Boundary condition

Uniaxial nD Section
fix $nodeTag (ndf $constrValues)
By default, all degrees of freedom are free
(unconstrained). The fix command is used
Elastic Elastic
ElasticPP Elastic Fiber
to provide fixity in translational or rotational
Hardening J2 DOFs at a given node (1=fixed, 0=free).
Concrete DruckerPrager
Steel TemplateElasto-Plasto For example: fix 1 1 1 1 0 0 0;
Hysteretic FluidSolidPorous
PY-TZ-QZ
Fix node 1 at ux, uy, uz.
PressureMultiYield(dependent,
Parallel independent) equalDOF $rNodeTag $cNodeTag $dof1
Series
Gap
$dof2 ...
Fatigue For example: equalDOF 1 2 3 4
Impose the displacement at dof’s 3 and 4 of
(over 250 material classes)
node 2 to be the same as those of 2.
 Workflow to build a model

GeomTransformation Element

element eleType arg1? …

Linear Geometric nonlinearity

Pdelta Truss
is specified, [T]
Corotational ZeroLength
ElasticBeamColumn
Element in Global System
NonlinearBeamColumn(force,
displacement)
BeamWithHinges
U P Quad(std, bbar, enhanced, u-p)
Geometric Transformation Shell
Brick(std, bbar, 20node, u-p, u-p-
v U)
q Joint
GenericClient

Element in Basic System (>100 element classes)

 Workflow to build a model

Recorder

ElementRecorder DataOutputHandler
NodeRecorder
EnvelopeNodeRecorder
EnvelopElementRecorder
DatabaseRecorder StandardStream
FileStream
XML_FileStream
TCP_Stream Database
DatabaseHandler
Two good sources for output of OpenSees

• http://opensees.berkeley.edu/wiki/images/c/c8/OpenSees%26Output. File
pdf MySQL
• https://www.youtube.com/watch?v=Tx8QszkpmpY Oracle
 Workflow to build a model
Analysis
AnalysisModel
StaticAnalysis
TransientAnalysis

CHandler Numberer CTest SolnAlgorithm Integrator SystemOfEqn

Plain Plain NormDispIncr EquiSolnAlgo StaticIntegrator BandGeneral

Penalty RCM NormUnbalance Linear LoadControl BandSPD
Lagrange AMD NormEnergy NewtonRaphson DispControl ProfileSPD
ArcLength
Transformation RelativeNormDispIncr ModifiedNewton SparseGeneral
…
RelativeNormUnbalance Broyden SparseSymmetric
TransientIntegrator
RelativeNormEnergy BFGS
CentralDifference
KrylovNewton
Newmark
NewtonLineSearch
HHT
…
GeneralizedAlhpa
(25 classes)
NewmarkExplicit
TRBDF2
(35 classes)
 Workflow to build a model

Load control and displacement control integrator in static analysis

Unconverged
Load-displacement curve Load-displacement curve
80 80
70 70
60 60
50 50
Fi+1
Force F (kips)

Force F (kips)
40 40
30
Fi 30
20 20
10 10
0 Δi Δi+1
0
0 5 10 15 20 25 30 0 5 10 15 20 25 30
Displacement (in) Displacement (in)

Load control: increase force Displacement control: increase

step by step displacement step by step
 Workflow to build a model
Scripts for eigenvalue analysis
set f [open mode.out a+]; ## Open mode.out file
#### statement line
puts $f " Period Frequency"
puts $f " T/sec Hz"
set lambda [eigen 30]
for {set i 0} {$i<30} {incr i 1} {
set lambdaa [lindex $lambda $i]
set omega [expr pow($lambdaa,0.5)]
set Tperiod [expr 2*3.14/$omega]
set Freq [expr 1/$Tperiod]
# period (sec.) and frequency
puts $f "$Tperiod\t $Freq“ }
close $f
puts "Eigenvalue Analysis finishes"
 Workflow to build a model
Pushover analysis using displacement control
system BandGeneral ;
constraints Transformation ;
numberer RCM ;
test RelativeNormUnbalance 1.0e-6 2000 1; ## Define convergence test
algorithm Newton ; ## Define algorithm
set nodeTag $ControlPoint; ## Define the control point
set dofTag 1; ## Define DOF of the control point to be monitored
set dU 0.1; ## Define displacement increment of each step
integrator DisplacementControl $nodeTag $dofTag $dU; ## Define displacement contro
analysis Static
analyze 288; ## Define total step to run
 Workflow to build a model
Compute Rayleigh damping coefficients 𝐜 = a0 𝑴 + a1 𝑲
set xDamp 0.03; # damping ratio 2𝜔𝑖 𝜔𝑗
set MpropSwitch 1.0; a0 = ζ
set KcurrSwitch 0.0;
𝜔𝑖 + 𝜔𝑗
set KcommSwitch 0.0; 2
set KinitSwitch 1.0; a1 = ζ
𝜔𝑖 + 𝜔𝑗
set nEigenI 1; # mode 1
set nEigenJ 5; # mode 5
set lambdaN [eigen [expr $nEigenJ]]; # eigenvalue analysis for nEigenJ modes
set lambdaI [lindex $lambdaN [expr $nEigenI-1]]; # eigenvalue mode i
set lambdaJ [lindex $lambdaN [expr $nEigenJ-1]]; # eigenvalue mode j
set omegaI [expr pow($lambdaI,0.5)];
set omegaJ [expr pow($lambdaJ,0.5)];
set alphaM [expr $MpropSwitch*$xDamp*(2*$omegaI*$omegaJ)/($omegaI+$omegaJ)]; # M-prop. damping; D = alphaM*M
set betaKcurr [expr $KcurrSwitch*2.*$xDamp/($omegaI+$omegaJ)]; # current-K; +beatKcurr*KCurrent
set betaKcomm [expr $KcommSwitch*2.*$xDamp/($omegaI+$omegaJ)]; # last-committed K; +betaKcomm*KlastCommitt
set betaKinit [expr $KinitSwitch*2.*$xDamp/($omegaI+$omegaJ)]; # initial-K; +beatKinit*Kini
puts "$alphaM $betaKcurr $betaKinit $betaKcomm"
 Workflow to build a model
Transient analysis
set tFinal 15.0;
constraints Transformation
numberer RCM
system BandGeneral
test NormUnbalance 1.0e-1 6 2
algorithm Newton
integrator Newmark 0.5 0.25
analysis Transient
set ok 0
set currentTime 0.0
while {$ok == 0 && $currentTime < $tFinal} {
set ok [analyze 1 0.01]
if {$ok != 0} {
test NormUnbalance 1.0e-1 1000 1
algorithm ModifiedNewton –initial
set ok [analyze 1 0.01]
test NormUnbalance 1.0e-1 6 2
algorithm Newton
}
set currentTime [getTime]
}
 OpenSees Resources
http://opensees.berkeley.edu

• Message Board - look for answers, post questions and ANSWERS

http://opensees.berkely.edu/community/index.php
• Getting Started Manual - basic how to for getting started
http://opensees.berkeley.edu/wiki/index.php/Getting_Started
• User Documentation - command documentation & theory!
http://opensees.berkeley.edu/wiki/index.php/Command_Manual
• User Examples
http://opensees.berkeley.edu/wiki/index.php/OpenSees_User
http://opensees.berkeley.edu/wiki/index.php/Examples_Manual
• Developers
http://opensees.berkeley.edu/wiki/index.php/OpenSees_Developer
http://opensees.berkeley.edu/cgi-bin/cvsweb2.cgi/OpenSees/SRC/
 Example 1. A cantilever beam

A cantilever beam is subjected to cyclic static load

• Displacement beam column element
• 6 nodes
• 5 elements
• Planar problem, 2D and 3DOFs
• Nonlinear material
• Nonlinear static analysis
y

x
 Example 1. A cantilever beam

Material modeling
• Fy=36.0 ksi, E=29,000 ksi, and strain hardening ratio = 0.2;
• Steel01 material model was used to define the material properties.

uniaxialMaterial Steel01 1 36.0 29000.0 0.2;

Strain hardening ratio is: ratio

between post-yield tangent and
initial elastic tangent.
 Example 1. A cantilever beam

Fiber section definition

Command format:
section Fiber $secTag <-GJ $GJ> {
patch rect $matTag $numSubdivY $numSubdivZ $yI $zI $yJ $zJ
}

$secTag: tag of previously defined material Rectangular patch

$GJ torsional stiffness of the section
$matTag material tag
$numSubdivIJ number of subdivisions (fibers) in the along y direction
$numSubdivJK number of subdivisions (fibers) in the along z direction
$yI $zI y & z-coordinates of vertex I (local coordinate system)
$yJ $zJ y & z-coordinates of vertex J (local coordinate system)
• Note: y and z axes are local axes.
• Node I is located at -y and -z.
• How to determine the local y and z axes?
 Example 1. A cantilever beam

Fiber section definition

How to determine the local coordinate system of an element in a 2-D model?
• First, the local x axis is always defined as the axis direction of the element
starting from i end to j end.
• Second, the local y axis is located in the same plane of the model and is
perpendicular to the local x axis.
y

x x
1 2

Pay attention to the orientation of the section!

 Example 1. A cantilever beam

Fiber discretization of the W14x159

• 3 rectangular zones
• Define each zone by rectangular patch command
 Example 1. A cantilever beam

Geometric transformation
Three options
• Linear Transformation: infinitesimal deformation, equilibrium equations are
developed based on the undeformed shape, constant T in transferring the
stiffness matrix/forces from local system to global system.
• PDelta Transformation: linear geometric in transferring stiffness matrix/forces
from local system to global system. But second-order P-Delta effect is
considered in the element stiffness matrix=[K+Kg], where Kg is geometric
stiffness caused by axis load.

• Corotational Transformation: large-

deformation, equilibrium equations are
developed based on deformed shape.
Geometric transformation matrix T is
not constant.
 Example 1. input file
# Create ModelBuilder #### Define coordinate transformation (geometry nonlinearity)
model basic -ndm 2 -ndf 3 geomTransf Linear 1; ##linear, no geometric nonlinearity
#### Define elements
######### Define nodes for {set i 1} {$i<[expr 6]} {incr i 1} {
for {set i 1} {$i<[expr 7]} {incr i 1} { element dispBeamColumn $i [expr $i] [expr $i+1] 4 1 1
node $i [expr ($i-1)*24.0] 0.0;} -integration Lobatto; }

###Define output
##### Define boundary conditions # Record the nodal displacements at node 6
fix 1 1 1 1 recorder Node -file disp.out -time -node 6 -dof 2 disp;

### Define material properties

# uniaxialMaterial Elastic matTag $Fy $E0 $b
uniaxialMaterial Steel01 1 36.0 29000.0 0.2

### Define section

set bf 15.6; set df 1.19; set tw 0.745;
set d 15.0; set n1 10; set n2 10;
section Fiber 1 {
patch rect 1 1 $n1 [expr -$d/2.0] [expr -$bf/2.0] [expr -($d/2.0-$df)] [expr $bf/2.0];
patch rect 1 $n2 1 [expr -($d/2.0-$df)] [expr -$tw/2.0] [expr ($d/2.0-$df)] [expr $tw/2.0];
patch rect 1 1 $n1 [expr ($d/2.0-$df)] [expr -$bf/2.0] [expr $d/2.0] [expr $bf/2.0];
}
 Example 1. input file
#### Define analysis
### Create a Plain load pattern with a linear TimeSeries:
### pattern Plain $tag Linear { $loads }
pattern Plain 1 Linear {
#### Create the nodal load - command: load nodeID xForce yForce M
load 6 0.0 1.0 0.0; ### “1.0” could be any number since we are using displacement control
}
system BandGeneral ; #### Create the system of equation
numberer RCM ; #### Create the DOF numberer
constraints Transformation ; #### Create the constraint handler
##### Define the convergence check #############
test NormDispIncr 1.0e-6 2000 0;
algorithm Newton ; ### define algorithm
##### Define the parameters for displacement control
set nodeTag 6; set dofTag 2; set dU 0.1;
integrator DisplacementControl $nodeTag $dofTag $dU; ####Load from 0 to 6in=0.1x60steps
analysis Static
analyze 60;
integrator DisplacementControl $nodeTag $dofTag -$dU; ####unLoad from 6in to -6in
analysis Static
analyze 120;
integrator DisplacementControl $nodeTag $dofTag $dU; ####reLoad from -6 to 6in
analysis Static
analyze 120;
 Example 1. A cantilever beam

Analysis results
• disp.out
Load-displacement curve
250
Force Displacement 200
150
Force (kips) 100
50
0
-7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7
-50
-100
-150
-200
-250
Displacement (in)
Example 2. A cantilever beam w/ geometric nonlinearity

A cantilever beam under a constant

axial load and lateral pushover load F
• Displacement beam column element
• 6 nodes P=2100 kips
• 5 elements
• Planar problem, 2D and 3DOFs
• Nonlinear material
• Nonlinear static analysis

x P=2100 kips
Example 2. A cantilever beam w/ geometric nonlinearity

Analysis cases
• Case 1: Linear material (LM) & linear transformation
• Case 2: Nonlinear material (NLM) & linear transformation
• Case 3: Nonlinear material (NLM) & PDelta transformation
• Case 4: Nonlinear material (NLM) & corotational transformation
 Example 2. Input file
#### Define coordinate transformation (geometry nonlinearity)
# Create ModelBuilder # geomTransf Linear 1; ##linear, case 1 and 2
model basic -ndm 2 -ndf 3 # geomTransf PDelta 1; ## Pdelta, case 3
geomTransf Corotational 1; ##Corotational, case 4
######### Define nodes
for {set i 1} {$i<[expr 7]} {incr i 1} { #### Define elements
node $i [expr ($i-1)*24.0] 0.0;} set numIntgrPts 4; ##Define the integration points for element
set intType Lobatto; ##Define the integration type for element
for {set i 1} {$i<[expr 6]} {incr i 1} {
##### Define boundary conditions element dispBeamColumn $i [expr $i] [expr $i+1]
fix 1 1 1 1 $numIntgrPts 1 1 -integration $intType; }

### Define material properties

Geometric nonlinearity
# uniaxialMaterial Elastic matTag $Fy $E0 $b
# uniaxialMaterial Elastic 1 29000.0；##Linear material, case 1
uniaxialMaterial Steel01 1 36.0 29000.0 0.2；##Nonlinear material, cases 2, 3, 4 Material nonlinearity

### Define section

set bf 15.6; set df 1.19; set tw 0.745;
set d 15.0; set n1 10; set n2 10;
section Fiber 1 {
patch rect 1 1 $n1 [expr -$d/2.0] [expr -$bf/2.0] [expr -($d/2.0-$df)] [expr $bf/2.0];
patch rect 1 $n2 1 [expr -($d/2.0-$df)] [expr -$tw/2.0] [expr ($d/2.0-$df)] [expr $tw/2.0];
patch rect 1 1 $n1 [expr ($d/2.0-$df)] [expr -$bf/2.0] [expr $d/2.0] [expr $bf/2.0];
}
 Example 2. Input file

Define analysis test NormDispIncr 1.0e-6 2000 0;

algorithm Newton ; ### define algorithm
###Define output
set nodeTag 6; set dofTag 2; set dU 0.1;
# Record the nodal displacements at node 6
####Load from 0 to 50in=0.1x500steps
recorder Node -file disp.out -time -node 6 -dof 2 disp;
integrator DisplacementControl $nodeTag $dofTag $dU;
analysis Static
###Define analysis for axial load first: step 1.
analyze 500;
pattern Plain 1 Linear {
load 6 -2100.0 0.0 0.0;}
system BandGeneral ; Displacement control integrator to apply the
numberer RCM ; lateral pushover load=apply displacement
constraints Transformation ;
test NormDispIncr 1.0e-6 2000 0; increment step-by-step
algorithm Newton ; ### define algorithm
integrator LoadControl 1; Load control integrator to apply the axial
analysis Static
analyze 1; ###analyze only one step load=apply load increment step-by-step
### set load constants and reset time to 0 s.
LoadConst -time 0.0;
1 is a factor to 2100 at each step
###Define analysis for lateral pushover analysis: step 2
pattern Plain 2 Linear {
load 6 0.0 1.0 0.0;}
system BandGeneral ;
numberer RCM ;
constraints Transformation ;
 Example 2. Results

Analysis results

Load-displacement curve Load-displacement curve

1200 90
80
1000 70
800 60

Force F (kips)
Force F (kips)

50
600
LM_linear transf. 40
400 NLM_Linear Transf. 30
NLM_Pelta transf. 20 NLM_Pelta transf.
200
NLM_Corotational transf. 10 NLM_Corotational transf.
0 0
0 5 10 15 20 25 30 35 40 45 50 0 5 10 15 20 25 30 35 40 45 50
Displacement (in) Displacement (in)
 Typical Steel Building models

Workflow to develop the building models

• Model builder
• Node
• Boundary
• Material
• Fiber section
• Geometric transformation
• Element
• Model display on the screen
• Recorder
• Diagnostics
• Analysis
 Typical steel building models

• Four canonical building frames of 3-,

9-, 20-, and 40-story
• 2-D Models of 3-, 9-, and 20- story
frames in OpenSees, and they can be
accessed and downloaded from the
following link:
• https://nevada.box.com/s/317jcs1mh
5ey29qt0tecpflwc9lztjse
• Detailed information of the numerical 3-story 9-story 20-story
models are described in the report.

Wu, S., Miah, M., and McCallen, D. (2018). “Four canonical steel moment frame buildings and
inter-code comparisons of nonlinear building response.” Report No. CCEER 19-05, Center for
Civil Engineering Earthquake Research, Department of Civil and Environmental Engineering,
University of Nevada, Reno, NV.
 Building information

• 3-story frame model

• Note that Q1, and Q2 are

significantly larger than P1, P2
 Workflow to build a model

Define parameters
set Length [expr 30.0*12.0]; ## define bay width (unit: in) ##
set H [expr 13.0*12.0]; ## story height ##
set L [expr 30.0*12.0]; ## bay width ##
set N1 4; ## number of column elements at each story ##
set N2 [expr $N1]; ## number of beam elements at each bay ####
set L1 [expr $H/$N1]; ## define element length in column unit: in ###
set L2 [expr $L/$N2]; ## define element length in beam unit: in ###
• Model builder
model basic -ndm 2 -ndf 3 ; (planar model, will have ux, uy, and θ).
• Node
Step 1: define global coordinate system: lower left corner
Step 2: for columns, start from the lower left corner with node #1 and define
nodes using for loops. For example, for the first column, node 1 is defined at the
bottom of the column, while the top of the column is node (3*$N1+1).
Step 3: for beams, start from the left to right, and second to fourth floors.
• Boundary conditions
Fix all of the base nodes
fix $NodeTag 1 1 1
 Workflow to build a model

Material
The building frame was made of steel with elastic-plastic properties.
For columns: Fy=65.0 ksi, E=29,000 ksi, and strain hardening ratio = 1/400;
For beams: Fy=50.0 ksi, E=29,000 ksi, and strain hardening ratio = 1/400;
Steel01 material model was used to define the material properties.
uniaxialMaterial Steel01 1 65.0
29000.0 [expr 1.0/400.0]; # for column
uniaxialMaterial Steel01 2 50.0
29000.0 [expr 1.0/400.0]; # for beam
 Workflow to build a model

Fiber section definition

The cross-section of each column/beam was discretized into 32 fibers, with 1 layer of
11 fibers to represent each flange, and 1 layer of 10 fibers for the web;
Define parameters
set d 29.0; #depth
set d1 12.73; set tw 0.98;
set bf 14.3; set GJ 716540.0;
set n1 11; set n2 1; set n3 1; set n4 10

section Fiber 1 -GJ $GJ1 {

patch rect 1 n2 n1 [expr -$d/2.0] [expr -$bf/2.0] [expr -$d1] [expr $bf/2.0];
patch rect 1 n4 n3 [expr -$d1] [expr -$tw/2.0] [expr $d1] [expr $tw/2.0];
patch rect 1 n2 n1 [expr $d1] [expr -$bf/2.0] [expr $d/2.0] [expr $bf/2.0];
}
 Workflow to build a model

Geometric transformation
• Corotational Transformation: large-deformation, equilibrium equations are
developed based on deformed shape. Geometric transformation matrix T is not
constant.

Element
• Displacement-based beam elements with fiber sections
• each beam/bay and each column/story were both discretized into 4 elements
• A Gauss-Lobotto integration scheme with 3-point integration
• All mass was converted to line mass
 Workflow to build a model

Display the model on the screen

• Details about how to display the model on the screen are in
https://opensees.berkeley.edu/wiki/images/c/c8/OpenSees&Output.pdf
recorder display 3storyframe 10 10 1083 1000 -wipe
prp 50 50 1
vup 0 1 0 Amplification factor for
vpn 0 0 1 deformed shape
display 1 10 2;
vwait state

Wait for
something to
happen
• if -$i, show the ith
• If>=0, size of node
modal shape.
• If<0, show node number
• If positive, show the
transient deformed
shape
 Workflow to build a model

Recorder
Also refer to
https://opensees.berkeley.edu/wiki/images/c/c8/OpenSees&Output.pdf
Recorder the displacement
recorder Node -file $dataDir/disp($N1-4ele-Lobatto-$numIntgrPts).out -time -
node $centerTag -dof 1 disp;

Recorder the element force

recorder Element -file $dataDir/element($N1-4ele-Lobatto-$numIntgrPts).out -
time -ele 1 [expr 3*$N1+1] [expr 6*$N1+1] [expr 9*$N1+1] [expr 12*$N1+1]
globalForce;
 Diagonostics

Diagnostics of a model can be performed by:

1. Eigenvalue analysis: check mode shape and periods to verify mass and stiffness
modeling
2. Nonlinear static pushover analysis: check pushover curve and deformed shape
to verify the boundary and stiffness modeling
3. Transient analysis: Check the analysis result, such as waveform and amplitude.
 Diagonostics : eigenvalue analysis

Eigenvalue analysis
Check mode shapes
recorder display 3storyframe 10 10 1083 1000 -wipe
prp 50 50 1
vup 0 1 0 To show mode shape, the eigenvalue analysis should be run
vpn 0 0 1 first before the display commands
display -1 0 200;
vwait state Freeze the state

Mode 1
 Diagonostics: eigenvalue analysis

Mode shapes

Mode 1 Mode 2 Mode 3

Mode 1 Mode 2 Mode 3

 Diagonostics: eigenvalue analysis

Eigenvalue analysis
Check mode periods
Could compare with hand-calculation solution
 Diagonostics: pushover analysis

Pushover analysis

Reasonable pushover curve can indicate

that the stiffness of the building system
is correct.
 Diagonostics: dynamic analysis

Compute Rayleigh damping coefficients

set xDamp 0.03; # damping ratio
set MpropSwitch 1.0; 𝐜 = a0 𝑴 + a1 𝑲
set KcurrSwitch 0.0;
2𝜔𝑖 𝜔𝑗
set KcommSwitch 0.0; a0 = ζ
set KinitSwitch 1.0; Why use modes 𝜔𝑖 + 𝜔𝑗
set nEigenI 1; # mode 1 1 and 16? 2
set nEigenJ 16; # mode 16 a1 = ζ
𝜔𝑖 + 𝜔𝑗
set lambdaN [eigen [expr $nEigenJ]]; # eigenvalue analysis for nEigenJ modes
set lambdaI [lindex $lambdaN [expr $nEigenI-1]]; # eigenvalue mode i
set lambdaJ [lindex $lambdaN [expr $nEigenJ-1]]; # eigenvalue mode j
set omegaI [expr pow($lambdaI,0.5)];
set omegaJ [expr pow($lambdaJ,0.5)];
set alphaM [expr $MpropSwitch*$xDamp*(2*$omegaI*$omegaJ)/($omegaI+$omegaJ)]; # M-prop. damping; D = alphaM*M
set betaKcurr [expr $KcurrSwitch*2.*$xDamp/($omegaI+$omegaJ)]; # current-K; +beatKcurr*KCurrent
set betaKcomm [expr $KcommSwitch*2.*$xDamp/($omegaI+$omegaJ)]; # last-committed K; +betaKcomm*KlastCommitt
set betaKinit [expr $KinitSwitch*2.*$xDamp/($omegaI+$omegaJ)]; # initial-K; +beatKinit*Kini
puts "$alphaM $betaKcurr $betaKinit $betaKcomm" Need to choose which
stiffness to use
Use two most important modes, modes 1 and 16.
 Diagonostics: dynamic analysis

Define gravity load analysis first and hold the internal force constant when
running the dynamic analysis.
Only P1, P2, w1, and w2
###Initialize gravity cause gravity load
set g 386.4
timeSeries Constant 2 -factor [expr 0.183891003*$g];
pattern UniformExcitation 2 2 -accel 2; #Define uniform excitation load pattern #2, in vertical
direction, using timeseries #2.
system BandGeneral
numberer Plain
constraints Plain
test NormUnbalance 1.0e-6 2000 0
algorithm Newton
integrator LoadControl 1
analysis Static
analyze 1
loadConst; ## Hold the internal force caused by gravity load when running dynamic analysis
 Diagonostics: dynamic analysis

Define dynamic analysis

system SparseGeneral
constraints Plain
numberer RCM
set nint 2000;
set tolerance 1.0e-2;
test RelativeNormUnbalance $tolerance $nint
algorithm Newton
set dt 0.005; ## Time step size
set motion Taiwan052NS.txt; ## Motion file name
set N 14000; ##Total number of analysis steps
set F [expr 2*386.4]; ##Scale factor for input motion
set Gaccel1 "Series -dt $dt -filePath $motion -factor $F";
pattern UniformExcitation 100 1 -accel $Gaccel1;
rayleigh $alphaM $betaKcurr $betaKinit $betaKcomm; #Define Rayleigh damping
integrator Newmark 0.5 0.25
analysis Transient Define motion
analyze $N $dt input in x direction
 Diagonostics: dynamic analysis
0.5
0.4
0.3
Acceleration (g)

0.2
0.1
0
0 20 40 60 80
-0.1
-0.2
-0.3
-0.4
Time (s)

Input motion:
Taiwan052NS motion

Comparison of roof displacement of the 3-

story frame under 2x Taiwan052NS
motion.