Structural Examples

QuakeCoRE OpenSees
Training Workshop 2016

Structural Analysis Examples
Structural Analysis Examples
The intention of this module is to work through some models that illustrate how
to perform certain tasks common to structural analysis problems.
o These examples are more complex than those in the Basic Examples
module, but will remain relatively simple.
o The primary goal is again to focus on the fundamental ingredients for
creating, running, and evaluating a structural model in OpenSees.
As before, the examples will build in complexity to demonstrate some tcl

scripting and some of the different modeling, loading, and analysis capabilities
of the OpenSees framework
o Many more structural examples are available on the OpenSees website,
either in the Basic Examples page, the Advanced Examples page, or in the
practical examples on the main Examples page.
http://opensees.berkeley.edu/wiki/index.php/Examples
1-Bay, 1-Storey Frame Pushover
100 kN 100 kN
H 2
3 4
1 3
1 2
Beams: A = 0.125 m2
Beams: E = 200 GPa
Beams: I = 0.0026 m4
Bay is 4 m high and

Bay is 3 m wide
2D problem: -ndm 2 100 kN 100 kN

2D Beam elements: -ndf 3
H 2
3 4
1 3
1 2
Beams: A = 0.125 m2
Beams: E = 200 GPa
Beams: I = 0.0026 m4
Bay is 4 m high and

Bay is 3 m wide
100 kN 100 kN
2D problem: nodes have H 2

both x and y coords
3 4
1 3
1 2
Beams: A = 0.125 m2
Beams: E = 200 GPa
Beams: I = 0.0026 m4
Bay is 4 m high and

Bay is 3 m wide
100 kN 100 kN
H 2
3 4
Need to specify fixity for all 3 DOF 1 3
We have fully fixed the base nodes
1 2
Beams: A = 0.125 m2
Beams: E = 200 GPa
Beams: I = 0.0026 m4
Bay is 4 m high and

Bay is 3 m wide
100 kN 100 kN
H 2
3 4
1 3
1 2
Beams: A = 0.125 m2
Beams: E = 200 GPa
Beams: I = 0.0026 m4
Bay is 4 m high and

Bay is 3 m wide
When we are using beam elements,
we need to create a geomTransf
object for each orientation (e.g. all
horizontal beams can use the same
geomTransf object). Then general
usage for this command (in 2D) is:
geomTransf $Type $tag <-jntOffset
$dXi $dYi $dXj $dYj>
where $Type indicates the type of
geometric transformation (more on
that in a bit), the $tag is unique, and
the optional jntOffset argument
allows for the consideration of the
differences in the deformable length
of the element compared to an
actual beam-column.
http://opensees.berkeley.edu/wiki/index.ph
p/Geometric_Transformation_Command
Transformation from local to global coordinates

In this example we are using the
Linear geomTransf object. This type
of geometric transformation assumes
small displacement theory (i.e. no
geometric nonlinearity is considered)
One geomTransf object is required

for each beam orientation in the
model. In our example we have two
vertical beams, and one horizontal,
so two geomTransf are required.
This is all we need in this command

for 2D problems, as there is only one
plane in which rotation can occur
(the third DOF). In 3D we need to
specify some further information,
but we will discuss that later.
A brief aside: In 3D specifying the
geomTransf object is a bit more
complicated because bending can
occur in more than one plane.
We need to include the orientation
of the local x-z plane for each
geomTransf object
Here are a couple of examples of

how this works.
Consider element 1: a vector that is
parallel to the local x-z plane of this
element is in the negative global
z-direction, so the command is
geomTransf Linear $tag1 0 0 -1
Consider element 2: a vector that is

parallel to the local x-z plane of this
element is in the global y-direction,
thus the command for this element is
geomTransf Linear $tag2 0 1 0
In this example, we will use the
elasticBeamColumn element. Unlike
the truss element we considered in
earlier examples, this element does
not require a material model. The
material properties are input
arguments in the element creation.
The general usage is:
element elasticBeamColumn $tag $nodeI
$nodeJ $A $E $I $gTransfTag <-mass
$rho> <-cMass>
where $gTransfTag is the tag of the
geomTransf object, the mass option
allows a density $rho to be set, and
the cMass option will create a
consistent mass matrix as opposed to
the default lumped mass matrix.
http://opensees.berkeley.edu/wiki/index.
php/Elastic_Beam_Column_Element
100 kN 100 kN
H 2
3 4
1 3
1 2
Note how the elements of this frame
have been specified in the model file.
Elements 1 and 3 are vertical, so are
assigned geomTransf 1. Note that for
this to work, the connectivity is
specified from the bottom up.
Element 2 is horizontal, so is assigned
to geomTransf 2.
100 kN 100 kN
H 2
3 4
1 3
1 2
The 100 kN vertical loads at nodes 3
and 4 are applied using a Constant
timeSeries (exactly what it sounds
like) and the Plain loadPattern that
weve used in previous examples.
Now that there are 3 DOF, we need
to specify 0.0 in the horizontal and
rotational DOF in the load command.
The rest of the model file is shown
here. We set up the analysis objects
that we want to use, and then apply
a single analysis step with the
loadControl integrator and a load
factor of 1.0.
This step applies the vertical loads to
nodes 3 and 4.
The lateral loads are applied at nodes
3 and 4 using a Linear timeSeries and
a Plain loadPattern.
Note that the tags for these objects
are not the same as the previous
timeSeries and pattern.
We will record the displacement at
node 3 in the horizontal direction.
We will also use the element
recorder to obtain information from
the beam elements. The globalForces
recorder argument will print the
elemental shear force, normal force,
and bending moments to the
specified file in the global coordinate
system.
There is also an option localForces
that does the same, but in the local
coordinate systems for each beam.
The lateral load analysis is performed
using the DisplacementControl
integrator such that in each of the
100 considered steps, the
displacement increment at node 3 in
the horizontal direction (dof 1) will
be 1 mm (0.001 m). After 100 steps,
the end displacement at node 3 will
be 10 cm (0.1 m)
Note that this is definitely not the

only way to do this, just the way that
is used here.
The displacement output that we
sent to the file disp.out in the node
recorder looks like this. When using
the DisplacementControl integrator
in a Static analysis, the time (left
column here) is the magnitude of the
force in the specified dof.
The globalForces output that we sent to the file beam.out looks like this.
It looks complicated but the layout is logical. The first column is the pseudotime.
Then for each element, there are 6 columns of information (N, V, M at each
node), thus there are 19 columns here.
Lets examine the final row of the beam.disp file, the information that was
recorded when the horizontal displacement of node 3 reached 10 cm.
element 1 element 2 element 3


node 1 node 3 node 3 node 4 node 2 node 4

2
3 4
1 3
1 2

8358.16
2 16093.6 The recorded data is
7195.21 the internal forces
3 4 and moments in the
1 3 1 global coordinate
system.
7195.21 16093.6
1 2
8358.16
1-Bay, 1-Storey Frame P-Delta
Lets make one minor change to our
model file to see how geometric
nonlinearity can be considered.
Recall that we used the Linear
geomTransf, assumes small
displacement theory (i.e. no
Lets make one minor change to our
model file to see how geometric
nonlinearity can be considered.
Recall that we used the Linear
geomTransf, assumes small
displacement theory (i.e. no
If we instead use the PDelta

geomTransf object, we can now
consider the P-delta effect in our
analysis (i.e. the additional moment
caused by the combination of the
vertical forces (P) and the
displacement of the top of the
columns (delta).
http://opensees.berkeley.edu/wiki/index.
php/PDelta_Transformation
To really see the effect, we need to
increase the final displacement,
increase the vertical forces, or both.
To accentuate the differences, these
results consider 1 m of displacement
with P = 100,000 kN at nodes 3 and 4
Using Section Models for More Realistic
Beam Cross-Sections
Section Models
Most of the time, we will want to consider nonlinear response in our structural
models via material nonlinearities, geometric nonlinearities, or both.
o The elasticBeamColumn element is great for linear elastic materials, but
isnt going to work for nonlinear material modeling.
o It is still useful to consider linear elastic material response when first
developing a model, as it is important to verify that the model is
performing as intended.
For beam-column elements, the section modeling capabilities of OpenSees

allow us to consider different cross-sectional geometries with various layouts of
different materials
o The classic structural example is a reinforced concrete beam. A section
model allows us to consider the differing constitutive response of the
steel and concrete, as well as the geometric layout of the cross-section.
http://opensees.berkeley.edu/wiki/index.php/Section_Command
Elastic Section Models
Its relatively simple to incorporate
an Elastic section into our 2D frame
model. Instead of directly including
the material and cross-sectional
properties into the element as we did
before, they are properties assigned
to the Elastic section, and this section
is then specified in the element
definitions.
The dispBeamColumn element is
shown here, but identical results are
obtained for the forceBeamColumn
element, and both of these match
the elasticBeamColumn element
results exactly.
Elastic Section Models
The advantage of using an Elastic
section and a nonlinear beamColumn
element is that it is a modular
approach. We get the same results as
with the elasticBeamColumn, but
changing to a different section
response is now much simpler.
For example, if we now wanted to

use the same model but consider a
nonlinear fiber section response, all
we need to do is remove or comment
out the Elastic section, add the lines
necessary to create the new section
model, and assign the new section
object $sTag.
Fiber Section Models
Fiber section models allow us to
consider the cross-sectional response
of the beam and how this affects the
axial-deformation, moment-
curvature, and/or shear-deformation
response of the beam or column
when loaded by external forces.
It is particularly effective for
composite cross-sections such as
those found in reinforced concrete
beams and columns. We can consider
different shapes, different layouts,
and different material responses for
the various constituents.
We will consider the reinforced
concrete cross-section shown here.
The figure at the bottom shows how
the layout of the fiber section model
we will create. The general usage is:
section Fiber $secTag {
fiber <fiber arguments>
patch <patch arguments>
layer <layer arguments>
}
A fiber considers a point entity.
o A single reinforcing bar
A patch considers an areal entity.
o An area or subarea of concrete
A layer considers a line entity.
o A row of reinforcing bars
This example is a bit more
complicated, as we will be
sourcing in some tcl procedures
from other files.
The fiber section technique uses

the 1D axial response of the cross-
section to define the unique
moment-curvature relationship for
the beam, thus we use
uniaxialMaterials for the concrete
and steel bodies.
Weve seen the Steel01 model in

previous examples, but have not
yet looked at the Concrete01
model.
The general usage for the
Concrete01 model is:
uniaxialMaterial Concrete01 $tag
$fpc $epsc $fpcu $epsu
where $fpc = fc, $epsc is the strain
at peak compressive strength,
$fpcu is the residual strength at
large strains (as defined by the
$epsu parameter).
Concrete01 considers the Kent-

Scott-Park model with considers
zero tensile strength.
http://opensees.berkeley.edu/wiki
/index.php/Concrete01_Material_-
-_Zero_Tensile_Strength
We define two Concrete01 objects
to separately consider the
different constitutive response of
the confined core and cover
concrete.
The confined core of the cross-
section is the middle portion that
is confined by the longitudinal and
shear reinforcement.
The cover concrete is the material
between the reinforcing steel and
the outer surfaces of the beam.
This will generally have a lower
peak strength and very minimal
residual strength at large strains (it
is set to zero in this case).
Some definitions for the cross-
sectional geometry are made here
We need to define the gross width

and depth of the beam section,
the cover distance (surface to
outer edge of reinforcement), and
the area of steel for the
considered reinforcing bars (No. 7
bars in this case).
Some definitions for the cross-
sectional geometry are made here
We need to define the gross width

and depth of the beam section,
the cover distance (surface to
outer edge of reinforcement), and
the area of steel for the
considered reinforcing bars (No. 7
bars in this case).
These geometric parameters are

sent to the RCsection2D procedure
along with some information on
how many bars are in each row
and to discretize the concrete
patches in the section.
Now that the fiber section model
has been defined for our
reinforced concrete section, we
can perform the moment-
curvature analysis using a
procedure defined in the file
MomentCurvature.tcl. The inputs
for this procedure are:
The section tag for the fiber
section (here it is set to 1)
The axial force on the section $P
The maximum curvature value to
apply to the section, here defined
as the product of the ductility $mu
and the estimated yield curvature
for the section $Ky
The number of iterations to
consider in the analysis
The MomentCurvature procedure
creates the nodes, boundary
conditions, element, recorder,
loadPatterns, and analysis
commands necessary to run the
moment-curvature analysis.
A zeroLengthSection element is
used (nodes 1 and 2 at same
location) and the RC fiber section
tag is input into this element.
The axial load is applied as a
Constant timeSeries
The moment-curvature analysis is
performed using the
DisplacementControl integrator
and the results are saved to a file
for plotting elsewhere.
In the recorded results, the time in the first
column is the bending moment and the curvature
values are in the second column.
Fiber section models are not constrained to

just rectangular sections, we can also define
circular sections as would be common in
structural columns, or in pile or drilled shaft
foundations, using the same essential tools.
The section Aggregator can be
used to combine several
uniaxialMaterial objects and one
section object into an aggregate
group in which each is assigned to
a different DOF.
However, there is no interaction

between the responses in the
different DOF.
An application of the Aggregator is

to add an elastic torsional
response to a beamColumn
element with a fiber section for
the axial/moment response.
Nonlinear Beam-Column Modeling
Nonlinear BeamColumn Modeling
There are essentially two options for modeling structures with nonlinear beam-
column element behaviour.
o A concentrated plasticity approach, where hinges at then ends of the
beam-columns have a elastoplastic response and the remaining length
of the elements have a linear elastic response.
o A distributed plasticity approach, where the elastoplastic response of
the beam-column can spread over the entire length of the element, and
the nonlinear material or section model applied to the element informs
the response a each integration point in the element.
Concentrated plasticity approach
This approach is achieved by using elastic beam-column

elements (or elastic sections), and then placing zero-length
elements at the ends. These zero-length elements are given
a force-displacement response desired for a plastic hinge zone.
The advantages are that this is a relatively simple technique to apply, and that it
works well for capturing interface effects such as bar pullout and shear sliding
The disadvantages are that the the properties of the springs depend on the
geometry and the moment distribution, and that the beams have elastic
behaviour in the interior (no distributed plasticity is possible)
We can modify our simple frame
example to consider concentrated
plasticity at the ends of the beams
and columns.
The addition of the hinge elements
will require some new nodes an
boundary conditions.
The new nodes are in the same
locations as the original nodes, as
zeroLength elements will be used.
Multi-point constraints, via the
equalDOF command, are used to
link the new nodes with nodes 3
and 4 in only the translational dof
http://opensees.berkeley.edu/wiki
/index.php/EqualDOF_command
We now need to create some
uniaxialMaterial objects that
define the desired hysteretic
response of the hinge elements.
If we want to have different
behaviour for beams and columns,
we will need two materials with
two tags, otherwise one is fine.
There are many options available
for this purpose. The complete list,
with discussion, can be found via
the uniaxialMaterial page at
http://opensees.berkeley.edu/wiki/index.p
hp/UniaxialMaterial_Command
Some of the available uniaxial
materials that could be used for
the hysteretic hinge response.
(list is too big to fit on one screen!)
The final changes concern the
elements. We need to change the
connectivity for the beamColumn
elements, which now join the new
interior nodes we have created.
The hinges will be modeled using
zeroLength elements. The general
usage for this command is:
element zeroLength $tag $nodeI
$nodeJ mat $matTag dir $dir
Consider element 4 to illustrate
how this works in our case. We are
linking node 1 to node 13 (these
share the same location). Because
this is a column joint, we apply the
material with the column tag. The
direction is 6 as we are concerned
with rotation about the z-axis.
Distributed plasticity approach
o This approach is achieved by using displacement or force-based

beam-column elements that permit the spread of plasticity over the
length of the element. The two corresponding elements are
dispBeamColumn and forceBeamColumn.
o The advantages are that this approach allows yield to occur at any
point along the length of the beam or column. This can be very
important with large distributed loads.
The disadvantages are that the integration weights and points are optimised for
the integration of higher-order polynomials, and do not necessarily reflect
plastic hinge locations or lengths as observed in experiments/reconnaissance.
Also, in comparison to the concentrated plasticity approach, there is some
computational efficiency lost if yield does not occur in the middle portion of the
element.
Displacement-Based Element Formulation
element dispBeamColumn $tag $nodeI $nodeJ $nIntPts $secTag $transfTag
o The displacement-based formulation is based standard finite

element procedures and the principle of virtual displacement.
o Constant axial deformation and a linear curvature field are
enforced over the length of the element. This is exact only for
prismatic linear elastic elements.
o The accuracy of the solution can be improved through mesh
refinement (h-refinement) only.
Force-Based Element Formulation
element forceBeamColumn $tag $nodeI $nodeJ $nIntPts $secTag $transfTag
o The force-based formulation is based the availability of an exact

equilibrium solution within the system of the element.
o The principle of virtual forces is used to formulate compatibility
between element and section deformations.
o The accuracy of the solution can be improved through mesh
refinement (h-refinement) OR p-refinement (increasing number of
integration points) in a single element.
Displacement-Based vs Force-Based What should I use?
o For modeling frames, the force-based formulation is often more

attractive, as increased accuracy can be achieved without the use
of additional nodes and elements (via prefinement).
o The force-based formulation is more computationally intensive
than the displacement-based element. This loss in single-element
efficiency when using the force-based element may be offset by
the ease of use and ability to use a coarser mesh, but may be
impactful for very large models.
o More information on these formulations can be found on the
OpenSees site at:
o http://opensees.berkeley.edu/wiki/index.php/Discovering_OpenSees_--
_Force-based_Element_vs._Displacement-based_Element
BeamWithHinges element a compromise between concentrated
and distributed plasticity
element beamWithHinges $tag $nodeI $nodeJ $sTagI $Li $sTagJ $Lj $E $A $Iz $transfTag
o The beamWithHinges element is somewhat of a middle ground between the

concentrated and distributed plasticity approaches. This element considers
force-based distributed plasticity over specified plastic hinge lengths near the
element ends, and is linear elastic elsewhere.
o There is also a way to do something similar with a forceBeamColumn
element, in which plastic hinges are defined, and distinct nonlinear section
models can be applied to each hinge AND to the interior of the beam.
o http://opensees.berkeley.edu/wiki/index.php/Beam_With_Hinges_Element
Dynamic MDOF Modeling of Structures
Dynamic MDOF Modeling
One of the most common modeling tasks for structural analysis problems is the
consideration of multi-storey and multi-bay structures subject to earthquake
excitation.
o We can use the fundamental tools we have developed so far to consider
these multiple degree-of-freedom (MDOF) dynamics problems.
The primary goal is to focus on the fundamental ingredients for creating,

running, and evaluating MDOF models in OpenSees.
o These examples will remain relatively simple, but will illustrate how to do
important tasks such as applying ground motions.
The simplest way to model multi-storey/multi-bay structures is to discretize the
frame into a mesh in which the nodes are located at the joints between the
beams and columns, and single elements span the lengths between the nodes.
o We will focus on 2D problems, but the same concepts can be extended
to 3D with relatively little trouble.
o In 2D, the nodes will all have 3 dof (2 translational, 1 rotational)
We use the equalDOF command to

ties the nodes at either end of each
beam together in dof 1 (axial rigidity
assumption)
Nodal masses are applied using the
mass command as opposed to the
optional argument in the node
command.
The jntOffset option in the geomTransf

command is used to account for the fact
that the columns are 0.8 m wide and the
beams are 0.7 m deep
elasticBeamColumn elements are used
for both beams and columns, and the
appropriate geomTransf objects are
assigned to each type.
The model file we have made for this structure can now be used in several
different types of analysis. We will first consider an eigenvalue analysis to get
the mode shapes and modal periods.
An eigenvalue analysis is
straightforward to apply in
OpenSees, it doesnt even require
a set of analysis commands.
We will write the eigenvectors
(mode shapes) to file using the
nodal recorder with the eigen n
argument.
An eigenvalue analysis is
straightforward to apply in
OpenSees, it doesnt even require
a set of analysis commands.
We will write the eigenvectors
(mode shapes) to file using the
nodal recorder with the eigen n
argument.
The eigen command is used to
compute the eigenvalues. Here
they are saved to a tcl list variable
$lambda
Because there is not a proper
analysis in this model (no analyze
command), we need to trigger
the recorders to get the
eigenvectors written to file using
the record command.
The final portion of this tcl file
uses some scripting to compute
the modal periods from the
eigenvalues, print these to the
screen, and then write them to a
file called Periods.txt using the
puts command for more
convenient use in post-processing
activities.
Thats all there is to the eigen

analysis of our 5-storey structure.
The recorded eigenvectors

are summarized in the table
above.
We can normalize these
such that the largest value is
1.0 to produce the plot to
the left showing the mode
shapes for the first 5 modes
of this structure.
We can also perform a dynamic time history analysis of our model structure by
first applying self-weight loads and then applying a ground motion.
To perform the self-weight analysis, we need to

create recorders that collect the output we want,
create the loadPattern and timeSeries for the self-
weight application, call the necessary analysis
commands, and analyze the model.
Here we will record the nodal displacements in all
three dof at all nodes, as well as the beamColumn
element forces (N, V, M) in both the local and
global coordinate systems.
The Plain loadPattern is used to apply the self-

weight loads. Here we are considering only the
self-weight of the beams, and use the eleLoad
command to apply uniformly distributed loads of
magnitude $wg to all 5 beam elements.
Note that the timeSeries is embedded in the
pattern command instead of explicitly called. In
this format we specify the times {0 1 100000}
where the values {0 1 1} will be applied.
A Static analysis is performed using the

LoadControl integrator with a load increment of
0.1 and the constraints, algorithm, numberer, and
system shown here.
Due to the use of 0.1 in the integrator, we need to

apply 10 steps such that the load factor is 1.0*$wg.
Due to how we defined the timeSeries, this load
will remain constant for all subsequent load steps.
The elemental force results that

we recorder can be used to
construct shear force and/or
bending moment diagrams for
the frame structure.
The bending moment diagram

for our model frame under
gravity loads alone looks
something like this.
The first task completed in
this analysis file is to create a
Rayleigh damping object. The
beamColumn elements do not
consider rate effects, so we
need to specify damping in a
different way. The usage is
rayleigh $aM $bK $bKi $bKc
where $aM is applied to the
mass matrix, $bK is applied to
the current stiffness matrix,
$bKi the initial stiffness, and
$bKc the last committed
stiffness.
The first task completed in
this analysis file is to create a
Rayleigh damping object. The
beamColumn elements do not
consider rate effects, so we
need to specify damping in a
different way. The usage is
rayleigh $aM $bK $bKi $bKc
where $aM is applied to the
mass matrix, $bK is applied to
the current stiffness matrix,
$bKi the initial stiffness, and
$bKc the last committed
stiffness.
Weve set this up such that
there is 5% damping in the
first and third modes.
The next task is to read in the
ground motion record, create
the timeSeries objects, and
then create the
UniformExcitation object that
will apply the ground motion
to the model.
The file ReadGmRecord.tcl is a
script that reads in a PEER
NGA ground motion file (with
header information), and
extracts the timestep $dt, the
number of steps $nPts, and
creates a file called
groundMotion.dat with the
header information removed
that is passed to the Path
timeSeries.
The final tasks involve

specifying the desired output
through node and element
recorders, creating the
appropriate analysis objects
for our Transient analysis, and
analyzing the model for 10000
steps (there are 9540 in the
record) .
Now that the analysis of the model is complete, we can perform post-processing
activities such as plotting various results recorded from our simulation. For
example, the plot below shows the displacement time history in the horizontal
direction at the 5th floor of the structure. We will discuss some post-processing
strategies in a later module.
Thank you!
www.quakecore.nz

Structural Examples

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Structural Examples

Uploaded by

Copyright:

Available Formats

QuakeCoRE OpenSees

Training Workshop 2016

As before, the examples will build in complexity to demonstrate some tcl

Bay is 4 m high and

2D problem: -ndm 2 100 kN 100 kN

Bay is 4 m high and

2D problem: nodes have H 2

Bay is 4 m high and

Bay is 4 m high and

Bay is 4 m high and

Transformation from local to global coordinates

One geomTransf object is required

This is all we need in this command

Here are a couple of examples of

Consider element 2: a vector that is

Note that this is definitely not the

element 1 element 2 element 3

element 1 element 2 element 3

element 1 element 2 element 3

node 1 node 3 node 3 node 4 node 2 node 4

element 1 element 2 element 3

node 1 node 3 node 3 node 4 node 2 node 4

element 1 element 2 element 3

node 1 node 3 node 3 node 4 node 2 node 4

If we instead use the PDelta

For beam-column elements, the section modeling capabilities of OpenSees

For example, if we now wanted to

The fiber section technique uses

Weve seen the Steel01 model in

Concrete01 considers the Kent-

We need to define the gross width

We need to define the gross width

These geometric parameters are

Fiber section models are not constrained to

However, there is no interaction

An application of the Aggregator is

This approach is achieved by using elastic beam-column

o This approach is achieved by using displacement or force-based

element dispBeamColumn $tag $nodeI $nodeJ $nIntPts $secTag $transfTag

o The displacement-based formulation is based standard finite

element forceBeamColumn $tag $nodeI $nodeJ $nIntPts $secTag $transfTag

o The force-based formulation is based the availability of an exact

o For modeling frames, the force-based formulation is often more

o The beamWithHinges element is somewhat of a middle ground between the

The primary goal is to focus on the fundamental ingredients for creating,

We use the equalDOF command to

The jntOffset option in the geomTransf

Thats all there is to the eigen

The recorded eigenvectors

To perform the self-weight analysis, we need to

The Plain loadPattern is used to apply the self-

A Static analysis is performed using the

Due to the use of 0.1 in the integrator, we need to

The elemental force results that

The bending moment diagram

The final tasks involve

You might also like