Reinforced Concrete Frame Example: Difference between revisions

From OpenSeesWiki
Jump to navigation Jump to search
No edit summary
No edit summary
 
(One intermediate revision by the same user not shown)
Line 1: Line 1:
__NOTOC__
__NOTOC__


This next example covers the nonlinear analysis of a reinforced concrete frame. The force based beam-column element with a fiber
This next set of examples covers the nonlinear analysis of a reinforced concrete frame. We look at the gravity load analysis of the frame in the first example, a pushover analysis of this gravity frame in the second, and an earthquake analysis in the third example.
discretization is used in the model. The example is contained in three separate files:
#[[Reinforced Concrete Frame Gravity Analysis | Reinforced Concrete Portal Gravity Analysis]]
#[[#RCFrame Gravity | RCFrameGravity.tcl]] - Defines the model and performs a gravity load analysis on the model
#[[Reinforced Concrete Frame Pushover Analysis | Reinforced Concrete Portal Pushover Analysis]]
#[[#RCFrame Pushover | RCFramePushover.tcl]] - Subjects the portal frame of RCFrameGravity to a pushover analysis.
#[[Reinforced Concrete Frame Earthquake Analysis | Reinforced Concrete Portal Earthquake Analysis]]
#RCFrameUniformExcitation.tcl - Subjects the portal frame of RCFrameGravity to a uniform excitation.
 
In addition to the opensees modelling, these examples demonstrate Tcl language features such as variables, command substitution, expression evaluation, the if-then-else control structure, the use of procedures and the source command.
 
----
=== RCFrame Gravity ===
 
This example subjects the reinforced concrete portal frame, shown below, to gravity loads.
 
Here is the file: [[Media:RCFrameGravity.tcl | RCFrameGravity.tcl]]
 
==== Model ====
 
A nonlinear model of the portal frame is created, The model consists of four nodes, two force beam column elements to model the columns and an elastic beam (3) to model the beam. For the column elements, a section, identical to the one use in the previous example, is created using steel and concrete fibers. The bottom two nodes are fixed and a single load pattern with a Linear time series is created. Two vertical loads acting at node 3 and 4 are added to this pattern.
 
[[Image:RCFrame.png|link=RC Frame]]
 
<pre>
# Create ModelBuilder (with two-dimensions and 3 DOF/node)
model basic -ndm 2 -ndf 3
 
# Create nodes
# ------------
 
# Set parameters for overall model geometry
set width    360
set height  144
 
# Create nodes
#    tag        X      Y
node  1      0.0    0.0
node  2    $width    0.0
node  3      0.0 $height
node  4    $width $height
 
 
# Fix supports at base of columns
#    tag  DX  DY  RZ
fix  1    1    1    1
fix  2    1    1    1
 
# Define materials for nonlinear columns# ------------------------------------------
# CONCRETE                  tag  f'c    ec0    f'cu      ecu
# Core concrete (confined)
uniaxialMaterial Concrete01  1  -6.0  -0.004  -5.0    -0.014
 
# Cover concrete (unconfined)
uniaxialMaterial Concrete01  2  -5.0  -0.002    0.0    -0.006
 
# STEEL
# Reinforcing steel
#                        tag  fy  E0    b
uniaxialMaterial Steel01  3  60.0 3000.0 0.01
 
# Define cross-section for nonlinear columns
# ------------------------------------------
 
# set some paramaters
set colWidth 15
set colDepth 24
 
set cover  1.5
 
set As    0.60;    # area of no. 7 bars
 
# some variables derived from the parameters
set y1 [expr $colDepth/2.0]
set z1 [expr $colWidth/2.0]
 
section Fiber 1 {
 
    # Create the concrete core fibers
    patch rect 1 10 1 [expr $cover-$y1] [expr $cover-$z1] [expr $y1-$cover] [expr $z1-$cover]
 
    # Create the concrete cover fibers (top, bottom, left, right)
    patch rect 2 10 1  [expr -$y1] [expr $z1-$cover] $y1 $z1
    patch rect 2 10 1  [expr -$y1] [expr -$z1] $y1 [expr $cover-$z1]
    patch rect 2  2 1  [expr -$y1] [expr $cover-$z1] [expr $cover-$y1] [expr $z1-$cover]
    patch rect 2  2 1  [expr $y1-$cover] [expr $cover-$z1] $y1 [expr $z1-$cover]
 
    # Create the reinforcing fibers (left, middle, right)
    layer straight 3 3 $As [expr $y1-$cover] [expr $z1-$cover] [expr $y1-$cover] [expr $cover-$z1]
    layer straight 3 2 $As 0.0 [expr $z1-$cover] 0.0 [expr $cover-$z1]
    layer straight 3 3 $As [expr $cover-$y1] [expr $z1-$cover] [expr $cover-$y1] [expr $cover-$z1]
 
}   
 
# Define column elements
# ----------------------
 
# Geometry of column elements
#                tag
geomTransf Linear 1 
 
# Number of integration points along length of element
set np 5
 
set eleType forceBeamColumn; # forceBeamColumn od dispBeamColumn will work
 
# Create the coulumns using Beam-column elements
#                tag ndI ndJ nsecs secID transfTag
element $eleType  1  1  3  $np    1      1
element $eleType  2  2  4  $np    1      1
 
# Define beam elment
# -----------------------------
 
# Geometry of column elements
#                tag
geomTransf Linear 2 
 
# Create the beam element
#                          tag ndI ndJ    A      E    Iz  transfTag
element elasticBeamColumn  3  3  4    360    4030  8640    2
 
 
# Define gravity loads
# --------------------
 
# Set a parameter for the axial load
set P 180;                # 10% of axial capacity of columns
 
# Create a Plain load pattern with a Linear TimeSeries
timeSeries Linear 1
pattern Plain 1 1 {
 
        # Create nodal loads at nodes 3 & 4
#    nd    FX          FY  MZ
load  3  0.0  [expr -$P] 0.0
load  4  0.0  [expr -$P] 0.0
}
</pre>
 
==== Analysis ====
 
This model contains material non-linearities, so a nonlinear solution algorithm of type Newton is used. The solution algorithm requires a convergence test to determine if convergence at each trial step has been achieved. For this example we will use the norm of the displacement increment vector. Also for this nonlinear example, we will apply the loads gradually in 0.1 incremental steps using a LoadControl strategy until the full load is applied. The eauations will be stored and solved using a banded general storae scheme and solver. To minimise the band of this solver, a reverse Cuthill-McKee (RCM) numbering scheme will be used. The constrains are enforced using the Plain constraint handler.
 
Once the static analysis is created, 10 analysis steps are needed to bring the full gravity load to bear on the model. (10 * 0.1 = 1.0)
<pre>
# Create the system of equation, a sparse solver with partial pivoting
system BandGeneral
 
# Create the constraint handler, the transformation method
constraints Transformation
 
# Create the DOF numberer, the reverse Cuthill-McKee algorithm
numberer RCM
 
# 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 3
 
# Create the solution algorithm, a Newton-Raphson algorithm
algorithm Newton
 
# Create the integration scheme, the LoadControl scheme using steps of 0.1
integrator LoadControl 0.1
 
# Create the analysis object
analysis Static
 
# Perform the analysis
analyze 10
</pre>
 
 
==== Output ====
 
For output, we will look at the displacements at nodes 3 and 4 and the state of element 1.
 
<pre>
# Print out the state of nodes 3 and 4
print node 3 4
 
# Print out the state of element 1
print ele 1
</pre>
 
==== Running the Script ====
 
When the script is run the following will appear.
 
[[Image:RCFrameRun.png|link=RC Frame Results]]
 
----
=== #RCFrame Pushover ===
 
In this example the reinforced concrete portal frame which has undergone the gravity load analysis will now be subjected to a pushover analysis.
 
Files Required:
#[[Media:RCFrameGravity.tcl | RCFrameGravity.tcl]]
#[[Media:RCFramePushover.tcl | RCFramePushover.tcl]]
 
==== 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 [= 10 * 0.1 load steps]. The existing loasd in the model are now set to constant and the time is reset to 0.0. A new load pattern with a linear time series and horizontal loads acting at nodes 3 and 4 is then added to the model.
 
<pre>
# Do operations of Example3.1 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 reference lateral loads for Pushover Analysis
# ----------------------------------------------------
 
# Set some parameters
set H 10.0; # Reference lateral load
 
# Set lateral load pattern with a Linear TimeSeries
pattern Plain 2 "Linear" {
 
        # Create nodal loads at nodes 3 & 4
#    nd    FX  FY  MZ
        load 3 $H 0.0 0.0
        load 4 $H 0.0 0.0
}
</pre>
 
==== 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 6.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.
 
<pre>
set maxU 15.0;         # Max displacement
 
# Perform the analysis
set ok 0
set currentDisp 0.0
while {$ok == 0 && $currentDisp < $maxU} {
 
  set ok [analyze 1]
 
  # 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  1000
      algorithm ModifiedNewton -initial
      set ok [analyze 1]
      if {$ok == 0} {puts "that worked .. back to regular newton"}
  test NormDispIncr 1.0e-12  10
  algorithm Newton
      }
    }
}
</pre>

Latest revision as of 21:58, 13 May 2011


This next set of examples covers the nonlinear analysis of a reinforced concrete frame. We look at the gravity load analysis of the frame in the first example, a pushover analysis of this gravity frame in the second, and an earthquake analysis in the third example.

  1. Reinforced Concrete Portal Gravity Analysis
  2. Reinforced Concrete Portal Pushover Analysis
  3. Reinforced Concrete Portal Earthquake Analysis
Retrieved from "https://opensees.ist.berkeley.edu/wiki/index.php?title=Reinforced_Concrete_Frame_Example&oldid=8688"