Reinforced Concrete Frame Earthquake Analysis

In this example the reinforced concrete portal frame which has undergone the gravity load analysis is now be subjected to a pushover analysis.

Files Required:

1. RCFrameGravity.tcl
2. RCFrameEarthquake.tcl
3. ReadRecord.tcl

NOTES:

1. This example again demonstrates the use of Tcl programming in order to perform the nonlinear analysis. When dealing with nonlinear problems, the models do not always converge for the analysis options of choice. For this reason it is sometimes

necessary to step through the analysis, checking for convergence at each step and trying different options if the analysis fails at any particular step. This script makes use of the fact that many OpenSees commands actually return values that can be used in the script.

1. The example demonstrates the use of Tcl procedures. The ReadRecord is a useful tcl procedure for parsing the PEER strong motion data base files and extracting the dt, nPts and creating a file containing just data points. The procedure is kept in a seperate file and is used in a number of the examples.

Model

The RCFrameGravity script is first run using the "source" command. The model is now under gravity and the pseudo-time in the model is 1.0. The existing loads in the model are now set to constant and the time is reset to 0.0. Mass terms are added to nodes 3 and 4.

The ReadRecord script is also sourced. This script contains the ReadRecord procedure. This procedure takes as arguments the name of the file containing the record, another file name to which the data points in the record will be written, and two variables which will be set on exit to be equal to the time interval between recorder data points and the number of points in the record.

A Path time series is then created with the name of the file containing the data points, the time interval between these points and a scaling factor to apply to the points, in this case the gravitational constant. This Path is used in the Uniform Excitation

We will also add damping to the model. We will use rayleigh damping and specify that the damping term will be based on the last committed stifness of the elements, i.e. C = ac Kcommit with ac = 0.000625.

# Do operations of RCFrameGravity by sourcing in the tcl file
source RCFrameGravity.tcl

# Set the gravity loads to be constant & reset the time in the domain
loadConst -time 0.0

# Define nodal mass in terms of axial load on columns
set g 386.4
set m [expr $P/$g];       # expr command to evaluate an expression

#    tag   MX   MY   RZ
mass  3    $m   $m    0
mass  4    $m   $m    0

# Set some parameters
set record ARL360

# Source in TCL proc to read PEER SMD record
source ReadRecord.tcl

# Permform the conversion from SMD record to OpenSees record
#              inFile     outFile dt
ReadRecord $record.at2 $record.dat dt nPts

# Set time series to be passed to uniform excitation
timeSeries Path 1 -filePath $record.dat -dt $dt -factor $g

# Create UniformExcitation load pattern
#                         tag dir 
pattern UniformExcitation  2   1  -accel 1

# set the rayleigh damping factors for nodes & elements
rayleigh 0.0 0.0 0.0 0.000625

Output Recorder

# Create a recorder to monitor nodal displacements
recorder Node -time -file disp.out -node 3 4 -dof 1 2 3 disp

# Create recorders to monitor section forces and deformations
# at the base of the left column
recorder Element -time -file ele1secForce.out -ele 1 section 1 force
recorder Element -time -file ele1secDef.out   -ele 1 section 1 deformation

Analysis

For the Pushover analysis we will use a displacement control strategy. In displacement control we specify a incremental displacement that we would like to see at a nodal dof and the strategy iterates to determine what the pseudo-time (load factor if using a linear time series) is required to impose that incremental displacement. For this example, at each new step in the analysis the integrator will determine the load increment necessary to increment the horizontal displacement at node 3 by 0.1 in. A target displacement of $maxU (15.0 inches) is sought.

As the example is nonlinear and nonlinear models do not always converge the analysis is carried out inside a while loop. The loop will either result in the model reaching it's target displacement or it will fail to do so. At each step a single analysis step is performed. If the analysis step fails using standard Newton solution algorithm, another strategy using initial stiffness iterations will be attempted.

# Delete the old analysis and all it's component objects
wipeAnalysis

# Create the system of equation, a banded general storage scheme
system BandGeneral

# Create the constraint handler, a plain handler as homogeneous boundary
constraints Plain

# Create the convergence test, the norm of the residual with a tolerance of 
# 1e-12 and a max number of iterations of 10
test NormDispIncr 1.0e-12  10 

# Create the solution algorithm, a Newton-Raphson algorithm
algorithm Newton

# Create the DOF numberer, the reverse Cuthill-McKee algorithm
numberer RCM

# Create the integration scheme, the Newmark with alpha =0.5 and beta =.25
integrator Newmark  0.5  0.25 

# Create the analysis object
analysis Transient

# Perform an eigenvalue analysis
puts "eigen values at start of transient: [eigen 2]"

# set some variables
set tFinal [expr $nPts * $dt]
set tCurrent [getTime]
set ok 0

# Perform the transient analysis
while {$ok == 0 && $tCurrent < $tFinal} {
    
    set ok [analyze 1 .01]
    
    # if the analysis fails try initial tangent iteration
    if {$ok != 0} {
	puts "regular newton failed .. lets try an initail stiffness for this step"
	test NormDispIncr 1.0e-12  100 0
	algorithm ModifiedNewton -initial
	set ok [analyze 1 .01]
	if {$ok == 0} {puts "that worked .. back to regular newton"}
	test NormDispIncr 1.0e-12  10 
	algorithm Newton
    }
    
    set tCurrent [getTime]
}

# Print a message to indicate if analysis succesfull or not
if {$ok == 0} {
   puts "Transient analysis completed SUCCESSFULLY";
} else {
   puts "Transient analysis completed FAILED";    
}

# Perform an eigenvalue analysis
puts "eigen values at end of transient: [eigen -Umfpack 2]"

# Print state of node 3
print node 3