Introduccinalanalisisestructuralcon Open Sees

See discussions, stats, and author profiles for this publication at: https://www.researchgate.
net/publication/357575931
Introducción al análisis estructural con OpenSees
Book · April 2020
CITATIONS READS
3 4,494
2 authors:
Luis Velasco Hector Guerrero

UNAM and UPV Universidad Nacional Autónoma de México
11 PUBLICATIONS 22 CITATIONS 44 PUBLICATIONS 366 CITATIONS
SEE PROFILE SEE PROFILE
All content following this page was uploaded by Luis Velasco on 05 January 2022.
The user has requested enhancement of the downloaded file.

Las Series del Instituto de Ingeniería describen los resultados de algunas de las
investigaciones más relevantes de esta institución. Con frecuencia son trabajos in
extenso de artículos que se publican en revistas especializadas, memorias de
congresos, etc.
Cada número de estas Series se edita con la aprobación técnica del Comité
Editorial del Instituto, basada en la evaluación de árbitros competentes en el tema,
adscritos a instituciones del país y/o el extranjero.
Actualmente hay tres diferentes Series del Instituto de Ingeniería:
SERIE INVESTIGACIÓN Y DESARROLLO

Incluye trabajos originales sobre investigación y/o desarrollo tecnológico. Es conti-
Introducción

nuación de la Serie Azul u Ordinaria, publicada por el Instituto de Ingeniería desde
1956, la cual actualmente tiene nueva presentación y admite textos en español
e inglés. al análisis estructural
SERIE DOCENCIA
Está dedicada a temas especializados de cursos universitarios para facilitar a
con OpenSees
estudiantes y profesores una mejor comprensión de ciertos temas importantes de ISBN: 978-607-30-3085-4
los programas de estudio.
SERIE MANUALES
Abarca manuales útiles para resolver problemas asociados con la práctica profe-
sional o textos que describen y explican el estado del arte o el estado de la
práctica en ciertos temas. Incluye normas, manuales de diseño y de laboratorio,
reglamentos, comentarios a normas y bases de datos.
Las Series del Instituto de Ingeniería pueden consultarse gratuitamente

desde la dirección electrónica del Instituto http://www.ii.unam.mx
(http://aplicaciones.iingen.unam.mx/ConsultasSPII/Buscarpublicacion.aspx)
y pueden grabarse o imprimirse en formato PDF desde cualquier computadora.
Luis Ivan Velasco Enriquez

Héctor Guerrero Bobadilla
Serie
SD 61 / 2020
SD 61
Docencia ABRIL, 2020
Publicación arbitrada
Serie
DOCENCIA
Las Series del Instituto de Ingeniería describen los resultados de algunas de las
investigaciones más relevantes de esta institución. Con frecuencia son trabajos
in extenso de artículos que se publican en revistas especializadas, memorias de
congresos, etc.
Cada número de estas Series se edita con la aprobación técnica del Comité Editorial
del Instituto, basada en la evaluación de árbitros competentes en el tema, adscritos
a instituciones del país y/o el extranjero. INTRODUCCIÓN AL ANÁLISIS

Actualmente hay tres diferentes Series del Instituto de Ingeniería:
SERIE INVESTIGACIÓN Y DESARROLLO

ESTRUCTURAL CON OPENSEES
Incluye trabajos originales sobre investigación y/o desarrollo tecnológico. Es
continuación de la Serie Azul u Ordinaria, publicada por el Instituto de Ingeniería ISBN: 978-607-30-3085-4
desde 1956, la cual actualmente tiene nueva presentación y admite textos en
español e inglés.
SERIE DOCENCIA
Está dedicada a temas especializados de cursos universitarios para facilitar a
estudiantes y profesores una mejor comprensión de ciertos temas importantes de
los programas de estudio.
SERIE MANUALES
Abarca manuales útiles para resolver problemas asociados con la práctica
profesional o textos que describen y explican el estado del arte o el estado de la
práctica en ciertos temas. Incluye normas, manuales de diseño y de laboratorio,
reglamentos, comentarios a normas y bases de datos.
Las Series del Instituto de Ingeniería pueden consultarse gratuitamente

desde la dirección electrónica del Instituto (II UNAM), http://www.ii.unam.
mx (http://aplicaciones.iingen.unam.mx/ConsultasSPII/Buscarpublicacion.
aspx) y pueden grabarse o imprimirse en formato PDF desde cualquier
computadora.
LUIS IVAN VELASCO ENRIQUEZ
HÉCTOR GUERRERO BOBADILLA
SD 61 / 2020
SD-61
ABRIL, 2020
ISBN 978-607-30-3085-4
INTRODUCCIÓN AL ANÁLISIS
ESTRUCTURAL CON OPENSEES
Luis Ivan Velasco Enriquez1

IIUNAM
lvelascoe@iingen.unam.mx
Héctor Guerrero Bobadilla2

IIUNAM
hguerrerob@iingen.unam.mx
Serie Docencia 61
Abril 2020
1
Estudiante
2
Investigador Asociado
Primera edición, Abril de 2020
Serie Docencia 61
D.R.© 2020 Universidad Nacional Autónoma de México
Instituto de Ingeniería, UNAM

Ciudad Universitaria, CP 04510, Ciudad de México
ISBN 978-607-30-3085-4
La obra fue editada por el Instituto de Ingeniería, de la Universidad Autónoma de

México (IIUNAM). El cuidado de la edición estuvo a cargo de la Unidad de
Promoción y Comunicación del IIUNAM. Esta obra está gratuitamente disponible
para consulta e impresión, en archivo PDF de 2.4 MB, en la sección de
Publicaciones del portal electrónico del IIUNAM, http://www.iingen.unam.mx, desde
que se terminó de editar.
iii
Dedicatoria
A Aldo, Diana y Kalef

Luis Ivan Velasco Enriquez
A mi familia y amigos
v
Prefacio
El objetivo principal de este libro es brindar a estudiantes, académicos y profesionales

de la Ingeniería Estructural una explicación amigable y clara sobre el programa OpenSees
(2018). A lo largo del libro, el lector encontrará diferentes ejemplos de estructuras analizadas
con OpenSees. Cada ejemplo cuenta con una descripción de la estructura, del código que
construye al modelo y de los comandos que se emplean en el ejemplo. De manera adicional,
se anexan los códigos de cada modelo, de tal manera que el lector podrá realizar los ejemplos
en su propia computadora.
Al finalizar la lectura de este documento, el lector conocerá los comandos
fundamentales para evaluar expresiones matemáticas, establecer variables y definir
estructuras condicionales básicas en el lenguaje de programación TCL, esencial para el
manejo de OpenSees. También, estará familiarizado con la metodología y los comandos
necesarios para crear y analizar modelos estructurales bajo cargas estáticas y dinámicas en
OpenSees y podrá analizar de manera no lineal estructuras metálicas y de concreto.
Ciudad Universitaria, Cd Mx
Febrero 2020
Luis Ivan Velasco Enriquez y
vi
Agradecimientos
Los autores gradecen el apoyo del Instituto de Ingeniería de la Universidad Nacional

Autónoma de México por brindar la infraestructura necesaria; sin ella no hubiera sido posible
publicar este libro.
vii
Resumen
Este libro presenta una introducción al análisis estructural usando el programa Opensees.
Este programa ha cobrado mucha popularidad en la comunidad internacional por su
eficiencia para realizar simulaciones sísmicas. El documento inicia con una introducción al
lenguaje TCL, que es el lenguaje usado por el programa Opensees. Después se realizan
algunos ejemplos de estructuras sujetas a cargas estáticas y dinámicas. Se incluyen también
ejemplos con comportamiento elástico e inelástico. Por último, el libro explica cómo modelar
estructuras equipadas con disipadores de energía sísmica.
Palabras clave: OpenSees, análisis estructural, comportamiento inelástico,

simulaciones sísmicas, modelado de disipadores
viii
Abstract
This book presents an introduction to structural analysis using OpenSees. This program has
taken great popularity in international community due to its efficiency for carrying out
seismic simulations. The document starts explaining simple commands in TCL language,
which is the programing language used by OpenSees. Afterwards, some examples of
structures are analyzed under static and dynamic loads. Examples that consider elastic and
inelastic behavior are included as well. Finally, the book explains modelling of structures
equipped with seismic energy dissipaters.
Keywords: OpenSees, structural analysis, inelastic behavior, seismic simulations,

modeling of dissipaters
ix
Índice
1. Introducción .............................................................................................................. 1
2. OpenSees y lenguaje TCL......................................................................................... 3
2.1 Orígenes de OpenSees ......................................................................................... 3
2.2 Ambiente de OpenSees ........................................................................................ 4
2.3 Interfaz de OpenSees ........................................................................................... 4
2.4 Descarga de OpenSees ......................................................................................... 5
2.5 Conocimientos básicos del lenguaje Tcl ............................................................... 6
2.6 Procedimientos .................................................................................................. 10
2.7 Introducción de comandos en OpenSees............................................................. 10
2.8 Visualización del modelo 1.08 ........................................................................... 11
2.9 Ayudas disponibles en línea ............................................................................... 12
2.10 Organización del documento .............................................................................. 13
3. Modelado y análisis estático de una armadura ...................................................... 15
3.1 Descripción del modelo ..................................................................................... 15
3.2 Descripción del código....................................................................................... 16
3.3 Comandos adicionales empleados ...................................................................... 19
4. Determinación de los modos y frecuencias de un marco de concreto ................... 23
5. Análisis dinámico lineal de una columna ............................................................... 31
x

6. Análisis estático no lineal de un marco conformado por perfiles metálicos ......... 41
7. Análisis dinámico no lineal de un marco de concreto reforzado ........................... 53
8. Análisis dinámico de un marco reforzado con amortiguador viscoso................... 67
9. Análisis dinámico de un marco reforzado con un contraventeo restringido al
pandeo ............................................................................................................................ 77
10. Análisis dinámico de un marco reforzado con un contraventeo convencional ..... 87
10.1 Descripción del modelo .................................................................................. 87
10.2 Descripción del código ................................................................................... 88
10.3 Comandos adicionales empleados................................................................... 91
11. Análisis dinámico incremental (ADI) ..................................................................... 95
11.1 Descripción del modelo .................................................................................. 95
11.2 Descripción del código ................................................................................... 95
12. Conclusiones .......................................................................................................... 101
Referencias ................................................................................................................... 103
1
1. Introducción
Este libro se escribe con la finalidad de introducir a los nuevos usuarios de OpenSees
en el modelado y análisis de estructuras por medio de esta herramienta. Debido a que el
manual está dirigido a nuevos usuarios, el contenido aquí presentado resulta ser básico y se
recomienda consultar el manual en línea del programa para aclaraciones y discusiones más
profundas sobre las posibilidades y limitaciones de éste. Es importante indicar que algunos
de los ejemplos discutidos en este documento son procedentes de la página en línea.
Este documento inicia con una introducción a OpenSees y al lenguaje Tcl. Se presenta
el ambiente de OpenSees explicando sus características y ventajas. Se indica la manera de
evaluar expresiones matemáticas, de establecer variables y de definir estructuras de control
básicas en lenguaje Tcl. Esta sección permite al lector familiarizarse con el modelado en
OpenSees y brinda los conocimientos elementales para el manejo del lenguaje Tcl.
En el Capítulo 2 se presenta un ejemplo de modelado y análisis estático de una

armadura en 2D. La estructura se modela y analiza linealmente bajo cargas estáticas. El
objetivo de este ejemplo es brindar una introducción al modelado y análisis de estructuras en
OpenSees a través de un ejemplo sencillo conformado por elementos con secciones
generales.
En el Capítulo 3 se presenta un ejemplo de determinación de los modos y frecuencias

de un marco de concreto. Pare ello, se modela un marco de concreto de dos niveles y una
crujía. Posteriormente, se determinan las frecuencias naturales y modos de vibrar de la
estructura. A través de este ejemplo se aprende a definir materiales y se conoce el proceso
para establecer secciones de concreto en OpenSees. De manera adicional, se aprende a definir
masas y a determinar las frecuencias naturales de una estructura.
2
En el Capítulo 4 se realiza un análisis dinámico lineal de una columna; en donde se

modela un elemento con una sección transversal general y una masa actuante en la parte
superior. Se realiza un análisis dinámico de la estructura sometiéndola a un registro de
aceleraciones en su base. Este ejemplo permite conocer el procedimiento para realizar un
análisis en el tiempo de una estructura sencilla, mostrando además la manera de simular
movimientos sísmicos en OpenSees.
En el Capítulo 5 se realiza un análisis estático no lineal (también conocido como

pushover) de un marco de tres niveles y dos crujías en 2D conformado por perfiles metálicos.
A través de este ejemplo se aprende la forma de definir secciones metálicas en cajón y doble
T en Opensees. Se indica la manera de crear elementos con articulaciones plásticas y se
describe el proceso para realizar un análisis estático no lineal.
En el Capítulo 6 se presenta el análisis dinámico no lineal de un marco de concreto

reforzado. La estructura, que consta de tres niveles y tres crujías, es sometida a un un
movimiento sísmico en la base. El ejemplo ilustra el manejo de comandos de control para el
modelado de estructuras, describe la manera de definir el amortiguamiento estructural y
permite dar una introducción al daño estructural.
En los capítulos 7, 8 y 9 se presentan análisis dinámicos de un marco equipado con

un amortiguador viscoso, un contraventeo restringido al pandeo, y un contraventeo
convencional, respectivamente. El marco de concreto reforzado consta de un nivel y una
crujía. En cada capítulo se realizan análisis dinámicos y se discutirán los resultados
obtenidos. A través de estos ejemplos se aprende la manera de modelar disipadores viscosos,
contraventeos restringidos al pandeo y contraventeos convencionales en OpenSees.
Finalmente, en el Capítulo 10 se describe una manera de realizar un Análisis

Dinámico Incremental (ADI) en OpenSees. A través de este ejemplo se muestra una de las
grandes ventajas de OpenSees, que es su capacidad de realizar múltiples análisis a un mismo
modelo de manera automatizada.
3
2. OpenSees y lenguaje TCL
2.1 Orígenes de OpenSees

OpenSees (del inglés Open System for Earthquake Engineering Simulation) es un
programa de licencia libre que permite analizar estructuras y modelos geotécnicos bajo
cargas gravitacionales y dinámicas. Esta herramienta tiene sus orígenes en la tesis doctoral
de Francis McKenna (Mackenna, 1997). Hoy en día, gracias a las aportaciones de
investigadores de diferentes universidades y al patrocinio y desarrollo de la misma por parte
del Pacific Earthquake Engineering Research Center de los Estados Unidos de
Norteamérica, OpenSees cuenta con un gran abanico de comandos para definir materiales,
elementos y procedimientos de análisis.
A pesar que el código de OpenSees fue definido originalmente en lenguaje C++, los
usuarios deben de combinar el uso de comandos preestablecidos, los cuales llaman
procedimientos para la definición y análisis del modelo, con instrucciones en TCL (del inglés
Tool Command Language) para el uso del programa. Por este motivo, es necesario contar
con un conocimiento fundamental del lenguaje TCL para un manejo básico de OpenSees.
Al ser OpenSees un programa de licencia libre, éste se encuentra en continuo

desarrollo y algunas de las estructuras de sus comandos pueden variar con el paso del tiempo.
Sin embargo, en la página en internet (OpenSees, 2018) del programa es posible encontrar
información actualizada sobre las modificaciones que han tenido lugar en el manejo de
OpenSees. Debido a lo anterior, se recomienda recurrir a dicha página oficial de manera
frecuente.
4
2.2 Ambiente de OpenSees

Para modelar y analizar un sistema estructural, el usuario debe definir tres diferentes
conjuntos de elementos a OpenSees. Estos conjuntos son: ModelBuilder, Analysis y
Recorder, siendo estos comunicados por el objeto Domain. La Figura 2.1 muestra un
esquema simplificado de estos elementos.
ModelBuilder Domain Analysis
Recorder
Figura 2.1 Ambiente de OpenSees
ModelBuilder. Es la parte del programa donde se definen los elementos para construir
el modelo, es decir, define nodos, restricciones, masas, materiales, secciones, elementos,
patrones de carga, etc. Una vez creado, el modelo se almacena en el objeto Domain y éste, a
su vez, lo provee a los objetos Analysis y Recorder.
Analysis. Determina el estado del modelo para cada instante de tiempo, t. Este se
compone por diferentes objetos que definen el tipo de análisis que realizará el programa.
Recorder. Este objeto crea y guarda el registro de los diferentes estados del modelo
durante su análisis.
2.3 Interfaz de OpenSees

En la Figura 2.2 muestra la interfaz del programa. Como ya se mencionó, OpenSees
es un programa que utiliza líneas de código para la creación y análisis de los modelos a
estudiar. Esta característica hace que el programa se apoye fuertemente en editores de texto.
Desde la página oficial de OpenSees es posible descargar de manera gratuita programas como
5
CypressEditor (Shojaie, 2018), que es un editor de texto especialmente diseñado para ser
utilizado con OpenSees.
Figura 2.2 Interfaz de OpenSees
A pesar de que es posible generar ventanas para la visualización de modelos

desarrollados, el programa no cuenta con una interfaz gráfica propia que apoye al usuario en
el trazado de sus modelos; facilidad con la que sí cuentan algunos programas comerciales.
Debido a esto, un nuevo usuario del programa encontrará diversas problemáticas al momento
de elaborar sus primeros modelos. Para subsanar esta dificultad, actualmente es posible
descargar programas adicionales que actúan como interfaces gráficas, por ejemplo: OpenSees
Navigator (OpenSees, 2010) o GID+OpenSees (Papanikolaou, et al., 2017).
2.4 Descarga de OpenSees

OpenSees es un programa de licencia libre; por lo que es posible instalarlo y
compartirlo sin algún inconveniente. Para descargar el programa es necesario recurrir a su
página en línea (OpenSees, 2010): http://opensees.berkeley.edu/
Una vez que el usuario se registra en el sitio, éste podrá descargar dos archivos
necesarios para la instalación y operación de OpenSees. El primero contiene el ejecutable del
6
programa y el segundo las librerías de Tcl. La descripción completa del proceso de descarga
junto con sus consideraciones se encuentra en la página en línea (OpenSees, 2010).
2.5 Conocimientos básicos del lenguaje Tcl

El lenguaje Tcl es utilizado en OpenSees para ejecutar los comandos del programa y
crear el modelo a analizar. Debido a su estructura simple y facilidad de manejo, este lenguaje
es utilizado para el desarrollo rápido de aplicaciones. Las principales funciones que se
utilizan de este lenguaje, al modelar sistemas estructurales en OpenSees, son el
almacenamiento de valores en variables, evaluación de expresiones matemáticas, manejo de
vectores, uso de estructuras de control (if, for, foreach, while) y edición de archivos. A
continuación se describen las funciones antes enlistadas y se brinda un breve ejemplo de cada
una de ellas. Se recomienda insertar los comandos directamente en el cursor del programa
para observar su funcionamiento.
Comentarios. Para introducir un comentario en el modelo basta con escribir el

símbolo “#”. Todo el texto de la fila que se encuentre posterior al símbolo será considerado
como comentario. A pesar de que estas líneas de código son ignoradas por el programa, se
recomienda a los usuarios emplearlos de manera regular para describir el funcionamiento de
su modelo y así facilitar su posterior revisión.
# Este texto es un comentario.
Introducción de texto en la interfaz. Es posible mostrar líneas de texto en la interfaz

de OpenSees. Estas líneas de texto son de utilidad cuando se requiere verificar la información
introducida al modelo y para indicarle al usuario el proceso en ejecución por el programa.
Para mostrar las líneas de texto se emplea el comando puts.
# Para usar este comando, la línea de texto debe encontrarse entre

comillas.
puts "Curso OpenSees"
7
Almacenar líneas de texto. Las líneas de texto también pueden ser almacenadas en
variables. Para almacenar texto o valores numéricos se utiliza el comando set. Esta función
es especialmente útil ya que puede ser utilizada para almacenar, por ejemplo, rutas a
diferentes carpetas de la computadora, en las que se podrían almacenar el modelo a analizar
o la información procedente de los análisis.
# El texto que se encuentra entre las comillas se guarda en la variable

Titulo.
set Titulo "Curso de OpenSees"
Almacenar valores numéricos. Como se mencionó antes, el comando set también

permite almacenar valores numéricos. En este caso, en el valor a guardar no se coloca entre
comillas.
# EL valor 2 (flotante) se guarda en la variable a.

set a 2.0
Llamar líneas de texto y valores almacenados. Para obtener el contenido de una

variable, sin importar si este es texto o un valor numérico, se coloca el símbolo “$” seguido
por la variable de interés.
puts "La variable a contiene el valor: $a"

puts "La variable Titulo contiene el texto: $Titulo"
Evaluación de expresiones matemáticas. Para evaluar expresiones matemáticas se

utiliza el comando expr seguido por la operación a realizar.
# El símbolo ";" le indican al programa que pase a la siguiente línea.

expr 2.0 + 3.0; # Suma.
# Es posible evaluar expresiones llamando variables.

expr $a - 3.0; # Resta.
expr $a*3.0; # Multiplicación.
expr $a/3.0; # División.
expr $a**2.0; # Elevar al cuadrado.
expr $a**0.5; # Raíz cuadrada.
8
# Se puede definir una variable usando el comando set, en este caso se

necesita colocar la expresión a evaluar entre corchetes.
set b [expr $a + 3.0]
Manejo de vectores. Para definir un vector se utiliza el comando list seguido por los
valores que componen al vector. Al igual que con el comando expr, para guardar la lista en
una variable, es necesario definir el vector entre corchetes.
# Se define un vector en la variable x.

set x [list 100 200 300]
Para obtener valores de un vector se utiliza el comando lindex seguido por el vector
de interés y la posición del valor deseado. Es importante indicar que los elementos del vector
se enumeran empezando desde el 0.
puts "[lindex $x 1]"; # Se llamará el valor el segundo valor (200) del

vector x.
puts "[lindex $x 0]"; # Se llamará el valor primer valor (100) del
vector x.
El comando lappend nos permite agregar un elemento adicional a un vector ya

existente. Es este caso no es necesario emplear al símbolo “$” de manera conjunta con el
nombre del vector.
# Se agrega el valor 175 al vector x.

lappend x 175
También es posible llamar valores de un vector previamente definido y guardarlos en

una variable.
# Se llamará el cuarto valor del vector x, el cual corresponde al número

175 que acabamos de agregar, y se almacenará en la variable c.
set c [lindex $x 3]
Ciclo for. Para definir un ciclo for es necesario definir la variable de control con el
valor inicial del ciclo. Posteriormente, se establece la condicionante del ciclo y su
9
incremento. Los comandos a realizar en cada ciclo deberán están contenidos entre llaves
dentro del ciclo for.
# for {Var. Control} {Condición} {Incremento (sumar dos al finalizar cada

ciclo)} {Instrucciones del ciclo}
for {set i 1} {$i < 10} {incr i 2} {
puts "$i"
}
# Nota: al omitir el valor del incremento, se considera que la variable

de control aumenta en una unidad.
for {set i 1} {$i < 10} {incr i} {
puts "$i"
}
Es importante dejar un espacio de separación entre las llaves que delimitan los
elementos del ciclo for.
If. Para definir un condicional if, sólo es necesario definir la condicionante seguida
de los comandos a realizar. Ambos elementos, condicionante y comando, deberán estar
delimitados por llaves y con un espacio de separación entre estas.
# if {Condición} {Instrucciones}
Creación y edición de archivos de texto. Para crear un archivo de texto de utiliza el

comando open seguido del nombre del archivo y su respectiva extensión. El comando puts
permite introducir datos en el archivo. El comando close permite cerrar el archivo creado.
# La variable definida al crear el archivo (“file1"), sirve para indicarle

al programa que archivo será afectado con los posteriores comandos puts y close.
set file1 [open Archivo.out w]

puts $file1 "Números del 1 al 10"
for {set i 1} {$i <= 10} {incr i} {
if {$i == 5} {
puts $file1 "Vamos a la mitad $i"
} else {
puts $file1 "$i"
}
}
close $file1
10
2.6 Procedimientos
Otra de las grandes ventas de OpenSees es el uso de procedimientos, que son un
bloque de comandos agrupados para realizar una tarea específica. Como ejemplo, en las
siguientes líneas se presenta la definición de un procedimiento y su llamado. Se inicia con la
palabra reservada proc, seguida del nombre del procedimiento (en este caso “Periodo”) y los
parámetros que usa en su tarea (en este caso “m” y “k”). Después se define un bloque de
instrucciones que son ejecutadas cuando se llama a la última línea, es decir: “Periodo 1 1”.
proc Periodo {m k} {
if {$m <= 0} {
puts "La masa debe ser mayor que cero.";
} elseif {$k<=0} {
puts "La rigidez debe ser mayor que cero.";
} else {
set T [expr 2*3.1416*($m/$k)**0.5];
return $T;
}
}
# cerrar las llaves de los proc para indicar a Opensees el fin de éste.
Periodo 1 1
2.7 Introducción de comandos en OpenSees

Existen dos formas de introducir comandos en OpenSees. La primera consiste en
escribir línea por línea los comandos que componen al modelo. Claramente esta manera es
ineficiente y desaprovecha muchas de las ventajas que ofrece el programa. La segunda
manera, que resulta más conveniente, consiste en crear un archivo de texto y llamarlo desde
la interfaz del programa. Con esto el proceso de análisis se vuelve mucho más eficiente y
resulta posible, con unas cuantas líneas de código adicionales, realizar diversos análisis al
modelo estructural de manera automatizada.
Para llamar un archivo de texto con los comandos que componen al modelo es
necesario utilizar el comando source seguido de la ruta que contiene el archivo de texto y el
nombre del archivo con su respectiva extensión. Es importante indicar que la extensión del
archivo de texto deberá ser .tcl, de otra manera el programa no lo reconocerá.
# source RutaCarpeta/NombreArchivo.tcl
11
2.8 Visualización del modelo

A través del comando recorder display es posible generar una ventana con la
representación gráfica del modelo construido. Este comando cuenta con diferentes
elementos, mismos que se describen abajo. La Figura 2.3 muestra un esquema con los
elementos de una proyección.
(x,y)
u
n
Figura 2.3 Elementos de una proyección, adaptada de (Bell, 2018)
A continuación, se presenta un ejemplo del uso del comando recorder display. El

primer elemento indica el nombre de la ventana generada, en este caso, la ventana se llamará
“Modelo”. Siempre deberá ir entre comillas. Los siguientes dos números, 10 y 10, brindan
las coordenadas de la esquina superior izquierda de la ventana, siendo estas relativas al borde
de la pantalla. Los últimos dos números, 600 y 600, indican el ancho y la altura de la ventana
en pixeles.
Existes otros sub-comandos que se deben definir:
 prp (de Projection Reference Point) define el centro y dirección de la proyección. En

este caso, en dirección del eje n.
 vup es un vector que indica el eje vertical de la proyección. En este caso, en dirección
del eje v.
12
 vpn es el vector normal del plano de la proyección.

 display recibe el número de modo del modelo, el factor de escala de nodos, y el factor
de escala de la respuesta.
 ViewScale es un factor de escala que se debe de ajustar en función de cada modelo.
Nótese que, no es necesario este comando si no se desea escalar la vista. Es suficiente
definir los tres comandos anteriores.
recorder display "Modelo" 10 10 600 600 -wipe;
prp 0 0 50;
vup 0 1 0;
vpn 0 0 1;
display 1 2 10;
set ViewScale 5;
La Figura 2.4 muestra una captura de pantalla del resultado que se obtiene al utilizar
el comando recorder display. Se recomienda probar diferentes valores en los sub-comandos
descritos para tener un mejor entendimiento de sus funciones.
Figura 2.4 Representación gráfica de un modelo generado por el comando recorder display
2.9 Ayudas disponibles en línea

En la página oficial de OpenSees (OpenSees, 2010) es posible encontrar materiales
de apoyo para orientar a los usuarios en el uso del programa.
Las ayudas más relevantes son:

13
- Manual de inicio de OpenSees (Getting Started Manual). Esta ayuda describe el

proceso de descarga e instalación de OpenSees y explica los conceptos más
elementales del programa.
- Manual de los comandos de OpenSees (Command Manual). En esta sección de la
página web es posible encontrar la descripción de cada uno de los comandos que se
emplean en OpenSees. Indica cómo usar los comandos para crear el modelo, las
características de cada uno de los objetos que pueden conforman el análisis y cómo
obtener los resultados.
- Lista de ejemplos (Examples). Para ayudar a los nuevos usuarios de OpenSees, en
esta sección es posible encontrar ejemplos de una gran variedad de estructuras siendo
analizadas bajo diferentes tipos de solicitaciones.
2.10 Organización del documento

En este documento se discuten nueve ejemplos diferentes de análisis realizados en
OpenSees a diversas estructuras. En estos ejemplos primero se presenta el modelo a analizar;
posteriormente, se describe el código del modelo que se localiza al final del ejemplo.
También se proporciona una lista de los comandos que se presentan en el ejemplo. En la lista
de comandos se incluyen, entre corchetes, los parámetros que cada comando necesita para
ser ejecutado.
Adicionalmente, se pone a disposición de los lectores archivos complementarios

que incluyen los códigos de los modelos en extensión .tcl y un registro sísmico para emplear
en los análisis dinámicos. Este contenido puede ser descargado de manera libre en el vínculo
ya señalado o desde la página web de Búsqueda de Series del Instituto de Ingeniería de la
UNAM: http://aplicaciones.iingen.unam.mx/ConsultasSPII/Buscarpublicacion.aspx.
15
3. Modelado y análisis estático de una armadura
3.1 Descripción del modelo

En este ejemplo se realiza el análisis estático de una armadura compuesta por
elementos se sección general (Figura 3.1). No se considera ningún efecto no lineal. Las
unidades del modelo son N y m.
El modelo a analizar es una armadura con dos apoyos fijos y uno móvil. La sección
transversal de las barras de la cuerda inferior (en color gris) cuenta con un área de 10 cm2 ; el
área del resto de las barras (en color negro) es igual a 5 cm2. En la armadura actúan dos cargas
en el Nodo 7, una vertical de 20 kN y una horizontal de 10 kN.
4 6
2
8 9
4 10 5 11 6 7 3m
1 2 3 7
1 10 kN
3 5
20 kN
4m 4m 4m
Figura 3.1 Esquema de la armadura analizada en el ejemplo.

16
3.2 Descripción del código

Al final de esta sección se muestra el código tcl de la armadura. Se recomienda
seguirlo mientras se lee este ejemplo. El punto y coma se usa para inidicar la terminación de
los comandos, de tal manera que Opensees lo interpreta como una instrucción completa.
Nótese (línea 6 del código) que al inicio de cada modelo se inserta el comando wipe
para borrar todo elemento que se encuentre almacenado en la memoria de OpenSees.
Para iniciar un modelo en OpenSees es necesario utilizar el comando model

BasicBuilder (línea 7). En este caso, por tratarse de un modelo en 2D, se indican dos
dimensiones (X, Y) y dos grados de libertad para cada nodo. Esto último debido a que es una
armadura y no se consideran giros en los nodos; sólo desplazamientos en X y Y.
De la línea 11 a 17 se definen los nodos de la armadura, para hacer esto se ha

empleado el comando node, seguido por la etiqueta o nombre del nodo que se desea definir,
la coordenada del nodo en X y la coordenada del nodo en Y.
El comando fix, presente en las líneas 24 a 26, define los apoyos de la armadura. De
la Figura 3.1 se observa que ésta tiene tres apoyos, dos fijos y uno móvil. Al usar el comando
fix se debe de indicar la etiqueta del nodo que tendrá la restricción seguida por los grados de
libertad restringidos (X, Y y Giro). Este comando considera un valor igual a 0 como libre y
un valor igual a 1 como fijo. Como sólo se indicaron dos grados de libertad por nodo, se
brindan los estados (libre o restringido) únicamente de los desplazamientos horizontales y
verticales.
En la línea 31 del código se define el material del cual estarán conformadas las barras
de la armadura. Como se indicó antes, no se consideran no linealidades mecánicas en la
armadura; por lo que se utiliza el comando uniaxialMaterial Elastic, el cual sólo requiere de
dos parámetros: 1) la etiqueta con la cual se guarda el material, y 2) su módulo de elasticidad.
Para este caso se utiliza un módulo de elasticidad igual a 200 GN/m2 = 200 x 109 N/m2.
En las líneas 37 a 51 se definen los elementos de la armadura. En este caso se utiliza

el comando element truss para todas las barras de la armadura. Dicho comando requiere la
17
etiqueta del elemento que se está definiendo, sus nodos inicial y final, el área transversal de
la sección y la etiqueta del material (ya existente) que lo compone.
Hasta este punto, la geometría del modelo ya ha sido completamente definida. A

continuación, se procede a definir las cargas actuantes sobre la armadura.
En la línea 54 se define el objeto timeSeries que indica al programa la forma en que

se debe de aplicar la carga durante el análisis. En este modelo se utilizó el comando
timeSeries Linear que únicamente requiere la etiqueta que tendrá el objeto timeSeries
definido. En la Figura 3.2 se muestra la manera en que el comando timeSeries Linear aplica
la carga durante el análisis. Como el nombre del comando indica, la carga se aplica de manera
lineal a lo largo del tiempo en el Domain, por lo que las fuerzas actuantes que están ligadas
a este objeto se incrementan de manera gradual durante el análisis hasta alcanzar los valores
definidos por el usuario. Los nuevos usuarios deben prestar especial atención a este comando,
ya que su omisión en el código es un error común cuando se comienza a modelar en
OpenSees1.
Factor
cFactor
Tiempo
Figura 3.2 Variación del factor de carga en función del tiempo considerada por el comando
timeSeries Linear, adaptada de (OpenSees, 2018)
Una vez definido el objeto timeSeries, se procede a definir las cargas actuantes sobre
la armadura, para esto se utiliza el comando pattern Plain. Para definir este comando se
1
Debido a su estructura tan sencilla es fácil pasarlo por alto, sin embargo, sin este objeto, el programa no será
capaz de realizar ningún análisis al modelo construido ya que desconocerá cómo aplicar las cargas.
18
requiere indicar al programa la etiqueta con la que se identifica al patrón de cargas seguido
de la etiqueta del objeto timeSeries previamente definido. Este comando requiere de manera
adicional el definir, entre llaves, las cargas asociadas a él. Las cargas pueden ser puntuales o
distribuidas. En este caso, al tener cargas puntuales actuando en el Nodo 7 de la armadura,
se emplea el comando load; mismo que requiere la etiqueta del nodo donde actúan las cargas,
seguido por los valores de las cargas actuantes.
En las líneas 61 a 67 se encuentran los comandos que generan la ventana con la

representación gráfica de la armadura. Estos comandos ya han sido explicados en el capítulo
introductorio.
En las líneas 71 y 72 se definen los archivos de salida. En este caso para el Nodo 7 y
el Elemento 3.
Al contar ahora con el modelo y las cargas actuantes sobre él, se pude proceder a
definir el análisis estático. En OpenSees, un análisis se conforma por diferentes elementos
que son definidos por el usuario. Estos elementos son: System, Numberer, Contraints, Test,
Integrator, Algorithm, Analysis y Analyze. A continuación, se ofrece una breve descripción
de la función de estos elementos. Para una descripción más detallada se recomienda consultar
la guía en línea del programa (OpenSees, 2018).
El objeto system le indica al programa como construir y resolver el sistema de

ecuaciones del modelo. En este caso se empleó el comando system BandGeneral.
El objeto numberer enumera los grados de libertad del modelo. En este caso se empleó
el comando numberer RCM.
El objeto constraints define la manera en la que se consideran las condiciones de

frontera y/o los desplazamientos impuestos. En este caso se empleó el comando constraints
Plain.
El objeto test indica la tolerancia de convergencia que se le solicita al programa al

momento de realizar el análisis. En este caso se empleó el comando test NormDispIncr; el
19
cual requiere la tolerancia que debe alcanzar el programa seguido por el número de
iteraciones máximas para alcanzar dicha tolerancia.
El objeto integrator define el siguiente instante de tiempo t para el cual el programa

determina el estado de la estructura. En este caso se empleó el comando integrator
LoadControl el cual sólo requiere el factor de incremento de carga para ser definido. En este
caso se eligió 0.1.
El objeto algorithm define los pasos a seguir para resolver las ecuaciones no lineales
durante el análisis. En este caso se empleó el comando algorithm Newton.
El objeto analysis define el tipo de análisis a realizar. En este caso se empleó el

comando analysis Static.
Finalmente, el objeto analyze da la instrucción de realizar el análisis con los

elementos previamente definidos. El comando analyze requiere el número de pasos en los
que el análisis será realizado. En este caso se eligieron 10 pasos.
3.3 Comandos adicionales empleados

Iniciales:
- wipe
- model BasicBuilder -ndm [dimensiones del modelo] -ndf [grados de libertad por
nodo]
Nodos:
- node [Etiqueta del nodo] [Coor X] [Coor Y]

- fix [Etiqueta nodo existente] [Fx] [Fy] [M]
Materiales:
- uniaxialMaterial Elastic [Etiqueta del material] [Módulo de elasticidad]

20
Elemento:
- element truss [Etiqueta del elemento] [Nodo i] [Nodo f] [Área transversal]

[Etiqueta material existente]
Cargas:
- timeSeries Linear [Etiqueta del timeSeries]

- pattern Plain [Etiqueta del patron de carga] [Etiqueta timeSeries existente]
- load [Etiqueta nodo existente] [Carga en X] [Carga en Y] [Momento]
Archivos de salida:
- recorder Node [-file Archivo -time -node $nodo -dof $DOFs $ tipoResp.]
- recorder Element [-file Archivo -time -ele $elemento $tipoRespuesta]
Análisis:
- system BandGeneral
- numberer RCM
- constraints Plain
- test NormDispIncr [Tolerancia] [Máximo número de iteraciones]
- integrator LoadControl [Factor incremento de carga]
- algorithm Newton
- analysis Static
- analyze [Pasos totales del análisis]
21
1 #-------------------------------------------------------------------------
2 # Modelado y análisis estático de una armadura.
3 # Unidades del modelo: [N,m]
4 #-------------------------------------------------------------------------
5
6 wipe;
7 model BasicBuilder -ndm 2 -ndf 2;
8
9 # Se establecen los nodos del modelo y sus respectivas restricciones.
10 # Solo se brindan dos coordenadas ya que el modelo es en 2D.(ID nodo, X, Y)
11 node 1 0.0 0.0
12 node 2 0.0 3.0
13 node 3 4.0 0.0
14 node 4 4.0 3.0
15 node 5 8.0 0.0
16 node 6 8.0 3.0
17 node 7 12.0 0.0
18
19 # Se definen los apoyos de la estructura, observe que existen dos apoyos
20 # diferentes, dos fijos en los nodos 1 y 3, y uno móvil en el nodo 5.
21 # 1 - Grado de libertad restringido.
22 # 0 - Grado de libertad no restringido.
23 # (Fx, Fy, M)
24 fix 1 1 1
25 fix 3 1 1
26 fix 5 0 1
27
28
29 # Se define el material de los elementos de la armadura.
30 set TagMaterial 1
31 uniaxialMaterial Elastic $TagMaterial 200e9
32
33
34 # Se definen los elementos de la armadura.
35 # Barras del tirante inferior.
36 # Área del elemento = 0.001 m2 = 10 cm2
37 element truss 1 1 3 0.001 $TagMaterial
40
41
42 # Resto de los elementos de la armadura.
43 # Área del elemento = 0.0005 m2 = 5 cm2
22
52 # Se definen las cargas actuantes sobre la armadura.

53 set timeLinear 1
54 timeSeries Linear $timeLinear
55 pattern Plain 1 $timeLinear {
56 # Carga de aprox 1 ton actuando en X y 2 ton actuando en Y
57 load 7 10000 -20000
58 }
59
60 # Se define la ventana que permitirá visualizar el modelo.
61 recorder display "Armadura" 10 10 600 600 -wipe
62 prp 0 0 50
63 vup 0 1 0
64 vpn 0 0 1
65 display 1 2 10
66
67 set ViewScale 5;
68
69
70 # Se definen registros de salida
71 recorder Node -file SalidaNodo7.txt -time -node 7 -dof 1 2 disp
72 recorder Element -file SalidaElem3.txt -time -ele 3 basicForces
73
74
75 # Se definen los parámetros del análisis estático.
76 system BandGeneral
77 numberer RCM
78 constraints Plain
79 test NormDispIncr 1.0e-6 10;
80 integrator LoadControl 0.1
81 algorithm Newton
82 analysis Static
83 analyze 10
23
4. Determinación de los modos y frecuencias de un

marco de concreto

En este ejemplo se realiza el análisis modal de un marco de cortante de concreto. Las
unidades del modelo son N y m. Este ejemplo se adapta a los resultados del libro "Dynamics
of Structures. Theory and application to earthquake engineering" de Anil K. Chopra
(Chopra, 1995) y consiste en determinar las frecuencias y modos de vibrar del marco
mostrado en la Figura 4.1. En este caso, la masa (m) fue considerada igual a 4,500 kg, la
altura de entrepiso es igual a 4 m. Para las columnas se consideró una sección transversal de
0.3 m x 0.3 m con un módulo de elasticidad para el concreto igual a 20 GN/m 2 = 20 x 109
N/m2.
m
5 6
6
4m
EIc 2 4 EIc
2m
3 4
5
4m
2EIc 1 3 2EIc
1 2
8m
Figura 4.1 Esquema del marco analizado en el ejemplo, adaptada de (Chopra, 1995)
24

El código de este ejemplo se muestra al final de esta sección. Se recomienda
ampliamente seguir el código mientras se lee esta sección. Para comenzar con el modelo,
primero se definen tanto su número de dimensiones como el número de grados de libertad
por cada nodo (ver línea 8). Al tratarse de un marco se consideran tres grados de libertad por
nodo.
En las líneas 12 a 21 se definen parámetros que serán de utilidad durante la

construcción del modelo. Estos también facilitan la modificación del mismo de manera
posterior.
Los nodos del modelo y sus respectivas restricciones se definen en las líneas 25 a 34.
Obsérvese que en este caso los nodos 1 y 2 se encuentran empotrados, por lo que sus tres
grados de libertad se encuentran restringidos.
De la línea 39 a la 42 se definen las masas actuantes en el modelo. Éstas fueron

colocadas en las uniones trabe-columna.
En este modelo se utilizan elementos elásticos para las trabes y columnas. Para crear
estos elementos es necesario primero definir su transformada geométrica, la cual establece la
relación entre el sistema de coordenadas del elemento con el sistema de coordenadas global
del modelo. En este caso se utilizó el comando geomTransf Linear1, misma que no considera
efectos P–Delta ni grandes deformaciones en el análisis. Este comando se encuentra en la
línea 46 del código. En la Figura 4.2 se muestra la forma en que difieren las coordenadas
locales de diferentes elementos con respecto al sistema de coordenadas globales.
Los elementos del modelo se definen en las líneas 51 a 58 por medio del comando
element elasticBeamColumn. Éste requiere, además de la etiqueta del elemento y los nodos
inicial y final, el área de la sección transversal del elemento, seguido del módulo de
1
Otro error es común olvidarse del objeto geomTransf, por su estructura simple. Pero de manera similar al
objeto timeSeries, éste cumple una función esencial en algunos modelos.
25
elasticidad del material que lo conforma, el momento de inercia de la sección y la

transformada geométrica a la que está ligado.
z z
y
x y
Coordenadas
x locales
z
y Y
X
Z
Coordenadas
globales
Figura 4.2 Coordenadas locales y globales, adaptada de (OpenSees, 2018)
Es importante mencionar que no se tienen cargas actuantes sobre el modelo, pues para
realizar un análisis modal, sólo es necesario definir su geometría y sus masas actuantes.
Para realizar el análisis modal, se ejecuta el comando eigen. Este comando requiere
el número de eigenvalores a calcular (en este caso se solicitan dos). Los eigenvalores del
modelo (𝜔𝑖2 ) son guardados en un vector. Esto se realiza en la línea 63 del código. En la
línea 66 se crea un vector denominado “T”. En éste se almacenan los periodos de la estructura
de manera posterior.
En las líneas 68 a 86 se encuentran los comandos que crean y modifican el archivo de

texto que almacenan los periodos de la estructura. En este caso el archivo de texto se llamó
“Modal.out”. Para escribir los periodos del marco en el archivo se emplea un ciclo for que
llama a cada uno de los eigenvalores y, por medio de la relación mostrada en la ecuación
(4.1), se obtienen los periodos de la estructura (ver línea 83).
2𝜋
𝑇𝑖 = (4.1)
√(𝜔𝑖2 )
26
Los valores de los vectores característicos de los modos de vibrar de la estructura se

definen en las líneas 90 a 93. Para obtener dichos valores se emplea el comando
nodeEigenvector que requiere la etiqueta del nodo del cual se obtiene el eigevector (o forma
modal), el modo de vibrar que produce el eigenvector y el número de grado de libertad. Las
líneas 95 y 96 escriben las formas modales normalizadas en la consola de OpenSees. En las
líneas 100 a 111 se encuentran los comandos que crean las ventanas con las representaciones
gráficas de los modos de vibrar de la estructura. En esto caso, para definir el modo de vibrar
a mostrar se utiliza, después del comando display (líneas 104 y 111), el valor -1 para el primer
modo de vibrar de la estructura y -2 para el segundo. En la Figura 4.3 se muestra una vista
de los dos modos de vibrar calculador por el programa.
Forma del modo 1 Forma del modo 2

T1 = 0.266 s T2 = 0.133 s
Figura 4.3 Modos de vibrar del marco analizado

Nodos:
- mass [Etiqueta nodo existente] [Masa en X] [Masa en Y] [Masa alrededor de Z]

27
Elementos:
- geomTransf Linear [Etiqueta de la transformada geométrica]

- element elasticBeamColumn [Etiqueta del elemento] [Nodo i] [Nodo f] [Área]
[Módulo de elasticidad] [Momento inercia] [Etiqueta geomTransf existente]
Análisis:
- eigen -[solver (opcional)] [Número de valores solicitados]

- nodeEigenvector [Etiqueta nodo existente] [Modo de vibrar] [Grado de libertad del
vector]
28
1 #---------------------------------------------------------------------
2 # Modos de marco de cortante.
3 # Problema tomado del libro Dynamics of Structures de Anil K. Chopra.
4 # Unidades del modelo: [N,m]
5 #---------------------------------------------------------------------
6
7 wipe;
8 model BasicBuilder -ndm 2 -ndf 3; # Se indican 3 grados de libertad para
9 cada nodo.
10
11 # Se definen valores del modelo.
12 set m 4500.0; # Masa actuante en el modelo.
13 set h 4.0; # Altura de entrepiso.
14 set A 0.09; # Área transversal de la columna.
15 set Ic 0.000675; # Inercia de la sección de la columna.
16 set Iv 10e12; # Inercia de la sección de la viga. Se asigna un valor
17 # alto para considerarla rígida.
18 set E [expr 20e9]; # Módulo de elasticidad del material del elemento.
19 set NumModos 2; # Se define el número de modos de vibrar a obtener.
20 set pi 3.1416;
21 set carpeta Resultados; # Se define el nombre de la carpeta donde se
22 guardarán los resultados.
23
24 # Se definen los nodos de la estructura. (ID nodo, X, Y)
25 node 1 0.0 0.0
26 node 2 [expr 2*$h] 0.0
27 node 3 0.0 $h
28 node 4 [expr 2*$h] $h
29 node 5 0.0 [expr 2*$h]
30 node 6 [expr 2*$h] [expr 2*$h]
31
32 # Se definen los apoyos de la estructura.
33 fix 1 1 1 1; # Las columnas del marco se encuentran empotradas.
34 fix 2 1 1 1
35
36 # Se definen las masas actuantes en los niveles del marco.
37 # (ID nodo, Masa actuante en X, Masa actuante en Y, Masa actuante alrededor
38 del eje Z).
39 mass 3 [expr $m] 0.0 0.0
40 mass 4 [expr $m] 0.0 0.0
41 mass 5 [expr $m/2] 0.0 0.0
42 mass 6 [expr $m/2] 0.0 0.0
43
44 # Se define la transformación de coordenadas.
45 set geomLinear 1
46 geomTransf Linear $geomLinear
47
48 # Se definen los elementos del marco. Se consideran elementos con propiedades
49 mecánicas generales.
50 # Elementos columna.
51 element elasticBeamColumn 1 1 3 $A $E [expr 2*$Ic] $geomLinear
29
52 element elasticBeamColumn 2 3 5 $A $E $Ic $geomLinear

53 element elasticBeamColumn 3 2 4 $A $E [expr 2*$Ic] $geomLinear
54 element elasticBeamColumn 4 4 6 $A $E $Ic $geomLinear
55
56 # Elementos Viga.
57 element elasticBeamColumn 5 3 4 $A $E $Iv $geomLinear
58 element elasticBeamColumn 6 5 6 $A $E $Iv $geomLinear
59
60 # Se determinan los eigenvectores y los periodos de la estructura.
61 # El comando "eigen" brinda los eigen valores del modelo, estos valores se
62 almacenan en la variable "eigenvalores".
63 set eigenvalores [eigen $NumModos]
64
65 # Se crea el vector "T" el cual almacenara los periodos de la estructura.
66 set T {}
67
68 file mkdir $carpeta; # Se crea la carpeta donde se
69 almacenarán los resultados.
70 set file1 [open $carpeta/Modal.out w]; # Se abre el archivo donde se
71 almacenarán los resultados.
72 puts $file1 "Los periodos de la estructura son:"; # Línea del archivo.
73
74 puts "Los periodos de la estructura son:"; # Línea de la interfaz
75
76 for {set i 0} {$i <= [expr $NumModos - 1]} {incr i} {
77 # Al vector "T", hasta ahora vacío, se le agregan los periodos de la
78 estructura por medio del comando lappend.
79 # El comando lindex llama el valor localizado en la posición $i del vector
80 "eigenvalores".
81 set T [lappend T [expr 2*$pi/([lindex $eigenvalores $i]**0.5)]]
82
83 puts $file1 "T[expr $i+1]: [lindex $T $i]"
84 puts "T[expr $i+1]: [lindex $T $i]"
85 }
86 close $file1
87
88 # El comando nodeEigenvector brinda los valores del vector característico.
89 # (ID nodo, Vector característico, Grado de libertad)
90 set f11 [nodeEigenvector 3 1 1]
94
95 puts "eigenvector 1: [list [expr {$f11/$f21}] [expr {$f21/$f21}] ]"
96 puts "eigenvector 2: [list [expr {$f12/$f22}] [expr {$f22/$f22}] ]"
97
98 # Se definen las ventanas que permitirán visualizar la estructura deformada.
99 recorder display "Forma del modo 1" 10 10 350 350 -wipe
100 prp 5 5 50;
101 vup 0 1 0;
102 vpn 0 0 1;
30
103 viewWindow -6 6 -6 6;
104 display -1 2 100;
105
106 recorder display "Forma del modo 2" 10 360 350 350 -wipe
107 prp 5 5 50;
108 vup 0 1 0;
109 vpn 0 0 1;
110 viewWindow -6 6 -6 6
111 display -2 2 100
31
5. Análisis dinámico lineal de una columna

En este ejemplo se realiza el análisis dinámico de una columna de concreto. No se
considera ningún efecto no lineal. Nótese que el ejemplo es muy sencillo, pues sólo es un
pretexto para aprender a realizar análisis dinámico en OpenSees. Las unidades del modelo
son N, m y s. El modelo a analizar consta de una columna de concreto empotrada en la base
de altura igual a 12 m (Figura 5.1). La sección transversal de la columna es rectangular con
medidas de 1 m x 1 m. En la parte superior actúa una masa de 50 ton, misma que también
genera una carga vertical. La columna es sometida al movimiento sísmico, registrado en la
estación SCT (Instituto de Ingeniería, 2018) componente Este-Oeste, del terremoto del
19/sept/1985 de Michoacán, México.
P=m∙g
2 m
1 h
Figura 5.1 Esquema de la columna analizada en el ejemplo.

32

Se comienza borrando cualquier objeto construido con anterioridad en OpenSees
(comando wipe) y se define el número de dimensiones del modelo y de grados de libertad
por nodo (línea 7).
Los parámetros definidos entre las líneas 10 a 18 se utilizan para construir el modelo
más adelante. Debido a que en este ejemplo se crean diversos archivos de resultados, se
define una variable llamada “carpeta”, la cual contiene el nombre de la carpeta donde se
almacenarán los archivos de resultados.
De manera similar a los ejemplos anteriores, se comienza por definir los nodos del
modelo (líneas 21 y 22). En este caso sólo dos son necesarios. El Nodo 1 corresponde al
empotramiento y el Nodo 2 al extremo libre de la columna. Adicionalmente, la masa actuante
en la parte superior de la columna se define al momento de crear el nodo 2 por medio de la
adición del comando –mass. En la línea 25 se ejecuta el comando fix para empotrar el nodo
inferior de la columna.
Al no considerarse no linealidades geométricas ni mecánicas, se crea la transformada

geométrica “Linear” (línea 29) y se emplea el comando element elasticBeamColumn para
construir el elemento columna con su área, módulo de elasticidad y momento de inercia
correspondiente (línea 32).
En la línea 35 se usa el comando file mkdir para crear la carpeta de archivos de

resultados. En las líneas 38, 40, 43 y 46 se definen los archivos de resultados solicitados al
programa. Es importante indicar que OpenSees no generará ningún archivo de resultados no
solicitado por el usuario, y los que sí sean creados sólo mostrarán su información una vez
que el programa sea cerrado o bien se ejecute el comando wipe.
Nótese que se utilizan tres modalidades del comando recorder, es decir: recorder
Node, recorder Element y recorder Drift. Los primeros dos, como su nombre lo indica,
generan el registro de datos relacionados con los nodos y los elementos especificados. En
este ejemplo se solicitaron los desplazamientos en el extremo libre de la columna y las
33
reacciones en la base. Para el caso del “recorder Element”, se indicó al programa que
registrara las fuerzas actuantes sobre el elemento columna. Por último, el registro drift guarda
la distorsión de entrepiso de la columna, siendo este parámetro igual a la diferencia de los
desplazamientos relativos existentes entre el Nodo 2 y el Nodo 1, dividido por la distancia
vertical que los separa. Nótese que existen más registros posibles que los cuatro aquí
mostrados, por lo que se recomienda recurrir a la manual del programa para consultar otros
registros de interés. 1
Entre las líneas 49 a 54 se crea el patrón de carga. En OpenSees primero es necesario

realizar el análisis estático antes que el dinámico por lo que en este caso sólo se considera
una carga vertical generada por la masa en el extremo libre.
Después de generar la ventana con la representación gráfica del modelo (líneas 57 a

63), se procede a realizar el análisis estático. Esto ocurre de la línea 65 a la 72. En la línea 78
se emplea el comando loadConst que indica al programa que conserve las cargas aplicadas
hasta el momento en análisis posteriores. El adicionar el comando –time permite fijar el
tiempo del programa en el valor indicado, en este caso se reinicia el tiempo del programa a
cero.
De la línea 80 a la 85 se definen parámetros que se emplearan en el análisis dinámico.

Éstos son: a) un factor de conversión de unidades, en este caso 0.01 para pasar de cm/s 2 a
m/s2; b) el paso de tiempo; c) los puntos que se considerarán del registro de aceleraciones; d)
el nombre del archivo que contiene el registro de aceleraciones; y e) la dirección en que se
aplicarán las aceleraciones.
Posteriormente, se crea el patrón de cargas por medio del comando pattern

UniformExcitation. Dicho comando requiere la etiqueta que tendrá el patrón de cargas,
seguido de la dirección en la cual se aplicará y, al agregar el comando –accel, se procede a
indicar el diferencial de tiempo y el nombre del archivo del registro de aceleraciones. Por
último, se aplica el comando –factor, el cual es opcional, permitiendo éste escalar los datos
1
También es posible guardar los archivos en formato “.xml”. Los archivos “.xml” presentan líneas de texto con
información del contenido del registro.
34
del registro de aceleraciones de una forma práctica. El comando pattern UniformaExcitation

también puede ser utilizado para imponer al modelo un registro de velocidades.
Antes de realizar el análisis dinámico, las líneas 92 a 94 definen el amortiguamiento

de la estructura. Esto se realiza por medio del comando rayleigh el cual asigna un
amortiguamiento de Rayleigh a todos los elementos construidos anteriormente. Es
importante recordar que dicho amortiguamiento es proporcional a la rigidez y a la masa de
la estructura. Nótese que OpenSees tiene la posibilidad de usar tres diferentes matrices de
rigidez: la “actualizada” la cual es la matriz de rigidez en cada iteración de una unidad de
tiempo; la “inicial” que corresponde a la matriz de rigidez original del modelo, sin considerar
degradación; y la “comprometida” que es la matriz resultante del último paso del análisis que
comprometió la matriz de rigidez. En este ejemplo, se considera únicamente la matriz de
rigidez comprometida para definir el amortiguamiento de Rayleigh. Para este caso, realmente
no es importante que matriz de rigidez usar para definir el amortiguamiento ya que, al ser un
análisis lineal, la matriz de rigidez no cambia durante el análisis.
Para finalizar el ejemplo se procede a realizar el análisis dinámico. Los comandos que
componen dicho análisis se encuentran entre las líneas 99 a 106. En la línea 105 se utiliza el
comando analysis Transient para indicar que el análisis a realizar es dinámico y en la 106 se
emplea el comando analyze seguido del número de puntos a considerar y el paso de tiempo.
En la Figura 5.2 se muestra el registro de desplazamientos laterales de la parte

superior de la columna; obtenidos del archivo de salida “DespTop.out” (ver línea 38). En esta
gráfica, el eje horizontal indica el tiempo, en segundos, mientras que el eje vertical muestra
el desplazamiento lateral del nodo 2, en metros. En este caso, el desplazamiento máximo
obtenido durante el análisis dinámico de la columna fue igual a 3 cm. Se recomienda al lector
variar el valor de la masa o de las dimensiones de la sección transversal de la columna para
observar cómo estos parámetros afectan la respuesta máxima de la estructura.
35
0.04
0.03
Desplazamiento, m
0.02
0.01
0
-0.01
-0.02
-0.03
-0.04
0 20 40 60 80 100 120 140 160
Tiempo, s
Figura 5.2 Desplazamientos laterales del nodo superior de la columna

Cargas:
- loadConst –time[Tiempo]
- pattern UniformExcitation [Etiqueta del patrón] [Dirección en la que se aplicará] –
accel {Series –dt [diferencial de tiempo] –filePath [Nombre del archivo]} –factor
[Factor de escala o de conversión].
Archivos de salida:
- Recorder Node –file [Nombre del archivo] –node [Etiqueta nodo existente] –dof
[Grados de libertad a considerar] [Tipo de registro solicitado]
- Recorder Element –file [Nombre del archivo] –ele [Etiqueta elemento existente]
[Tipo de registro solicitado]
- Recorder Drift –file [Nombre del archivo] –iNode [Nodos i] –jNode [Nodos j] –
dof [Grado de libertad de los desplazamientos relativos] –perpDirn [Dirección que
se utilizara para calcular separación entre nodos i y j]
Amortiguamiento:
36
- rayleigh [AlphaMasa] [BetaRigidezActual] [BetaKInicial] [BetaKComprometida]
Análisis:
- eigen –fullGenLapack
- system UmfPack
- numberer RCM
- constraints Plain
- integrator Newmark [Gamma] [Beta]
- algorithm Newton
- analysis Transient
- analyze [Pasos totales del análisis] [paso de tiempo]
37
1 #---------------------------------------------------------------------
2 # Análisis dinámico lineal de una columna.
3 # Unidades del modelo [N,m,s]
4 #---------------------------------------------------------------------
5
6 wipe;
8
9 # Se definen valores del modelo.
10 set h 12.0; # Altura de la columna.
11 set m 50000; # Masa actuante en la estructura.
12 set A 1.0; # Área transversal de la columna.
13 set I 0.0833; # Inercia de la sección de la columna.
14 set E 20e9; # Módulo de elasticidad del material de la columna.
15 set carpeta ResultadosEx3; # Se define el nombre de la carpeta donde se
17 set pi 3.1416
18 set g 9.81; # Aceleración de la gravedad.
19
20 # Se definen los nodos de la columna.
21 node 1 0.0 0.0
22 node 2 0.0 $h -mass $m 0.0 0.0
23
24 # Se define el empotramiento de la columna.
25 fix 1 1 1 1
26
27 # Se define la transformación de coordenadas.
28 set geomLinear 1
29 geomTransf Linear $geomLinear
30
31 # Se define el elemento columna.
32 element elasticBeamColumn 1 1 2 $A $E $I $geomLinear
33
34 # Se definen los registros del análisis.
35 file mkdir $carpeta; # Carpeta donde se almacenarán los resultados.
36
37 # Desplazamiento del nodo superior.
38 recorder Node -file $carpeta/DespTop.out -time -node 2 -dof 1 2 3 disp;
39 # Reacciones de la base.
40 recorder Node -file $carpeta/ReaccionBase.out -time -node 1 -dof 1 2
41 3 reaction;
42 # Distorsión de entrepiso.
43 recorder Drift -file $carpeta/Drift.out -time -iNode 1 -jNode 2 -dof 1 -
44 perpDirn 2 ;
45 # Fuerzas en la columna.
46 recorder Element -file $carpeta/SolicitacionesCol.out -time -ele 1 force;
47
48 # Se define las cargas actuantes sobre la estructura.
49 set timeLinear 1
50 timeSeries Linear $timeLinear
51 pattern Plain 1 $timeLinear {
38
52 # Fuerza aplicada en nodo 2 = masa actuante por gravedad.

53 load 2 0.0 [expr -1*$m*$g] 0.0
54 }
55
57 recorder display "Columna" 10 10 600 600 -wipe
58 prp 0 0 50
59 vup 0 1 0
60 vpn 0 0 1
61 display 1 2 10
62
63 set ViewScale 5;
64
66 system BandGeneral
67 numberer RCM
69 test NormDispIncr 1.0e-6 10;
71 algorithm Newton
72 analysis Static
73 analyze 10
74
75 puts "Análisis estático finalizado."
76
77 # Se define los valores para el análisis dinámico.
78 loadConst -time 0.0
79
80 set Factor 0.01; # El registro de aceleraciones se encuentra en
81 cm/s2, este factor lo convierte a m/s2.
82 set dt 0.01; # Diferencial de tiempo del acelerograma.
83 set Npuntos 15000; # Número de puntos del acelerograma.
84 set AccelDataFile "SCT18509.txt"; # Se indica el registro a utilizar.
85 set DirX 1; # Dirección en la que se aplicarán las aceleraciones.
86
87 # Se define el patrón de aceleraciones.
88 set accelSeries "Series -dt $dt -filePath $AccelDataFile -factor $Factor";
89 pattern UniformExcitation 2 $DirX -accel $accelSeries
90
91 # Se define el amortiguamiento de la estructura.
92 set freq [expr ([eigen -fullGenLapack 1]**0.5)/(2.0*$pi)]
93 set dampRatio 0.05
94 rayleigh 0. 0. 0. [expr 2*$dampRatio/$freq]
95
96 puts "Periodo: [expr 1.0/$freq] segundos"
97
99 system UmfPack
100 numberer RCM
102 test NormDispIncr 1.0e-8 10
39
103 integrator Newmark 0.5 0.25

104 algorithm Newton
105 analysis Transient
106 analyze $Npuntos $dt
107
108 puts "Análisis Dinámico finalizado."
41
6. Análisis estático no lineal de un marco

conformado por perfiles metálicos

En este ejemplo se realiza el análisis estático no lineal (también conocido como
pushover) a un marco de acero en 2D.
El marco estará compuesto por perfiles en cajón para las columnas y perfiles “I” para
las vigas. En este ejemplo sí se consideran efectos no lineales. Las unidades del modelo son
t (toneladas fuerza) y cm.
El modelo a analizar consta de un marco de acero de tres niveles y dos crujías. Las
crujías tienen 7 m de ancho cada una. La altura de entrepiso del modelo es igual a 3.5 m. Para
las columnas del primer nivel se emplean perfiles en cajón cuadrados de 35 cm por lado y un
espesor de placa de 5/8”. Para las columnas del segundo nivel se utilizan perfiles en cajón de
las mismas dimensiones, pero con un espesor de placa de 1/2”. Las vigas del modelo están
conformadas por perfiles W16x57. Se considera una carga distribuida de 1.03 y 1.17 t/m para
el entrepiso y la azotea, respectivamente. En la Figura 6.1 se muestra el marco analizado en
este ejemplo.
OpenSees permite realizar los análisis estáticos no lineales de dos maneras:

controlando los desplazamientos de un nodo especificado por el usuario y controlando las
cargas laterales aplicadas a la estructura. En este ejemplo se indicará como realizar ambos
procedimientos.
42
42
41 43
5 6
31 32 33 350 cm
32
31 33
3 4
21 22 23 350 cm
22
21 23
1 2
11 12 13 350 cm
11 12 13
700 cm 700 cm
Figura 6.1 Esquema del marco analizado en el ejemplo

Se comienza a construir el modelo borrando los objetos definidos con anterioridad
por medio del comando wipe (línea 5), posteriormente se indican el número de dimensiones
del modelo y número de grados de libertad por nodo (línea 6).
Entre las líneas 9 a 12 se definen parámetros que facilitan la creación del modelo y su
posterior modificación en caso de ser necesario.
Los nodos con sus respectivas restricciones se definen de la línea 16 a la 32. Para
simular comportamiento de diafragmas rígidos en los niveles, se utiliza el comando
equalDOF que impone desplazamientos iguales de un nodo (nodo maestro) a otro (nodo
esclavo). Para usar este comando se indica al programa la etiqueta del nodo maestro seguido
43
aquella del nodo esclavo y, por último, el grado de libertad sobre el cual los desplazamientos
de ambos nodos serán iguales. Esto se hace en las líneas 36 a 41.
Debido a que en este ejemplo se consideran efectos no lineales es necesario definir

materiales con comportamientos histeréticos. En este ejemplo se utiliza el comando
uniaxialMaterial Steel02 para definir el material de los perfiles metálicos del modelo. Para
usar dicho comando se requiere definir la etiqueta que tendrá el material, seguido del su
esfuerzo de fluencia, su módulo de elasticidad y la relación entre la tangente post-fluencia y
la tangente inicial elástica de la curva esfuerzo – deformación del material. Adicionalmente,
es necesario definir siete valores adicionales (R0, CR1, CR2, a1, a2, a3 y a4) que definen el
comportamiento de la curva esfuerzo – deformación una vez que se ha sobrepasado el
esfuerzo de fluencia. Los valores utilizados en el ejemplo para los parámetros adicionales
fueron tomados de recomendaciones de la guía en línea de OpenSees (OpenSees, 2018). Los
materiales utilizados en este ejemplo se definen entre la línea 46 a 49. La Figura 6.2 muestra
esquemáticamente la curva esfuerzo – deformación de un material definido por medio del
comando uniaxialMaterial Steel02.
Ep
Esfuerzo
E
Deformación
Figura 6.2 Curva esfuerzo – deformación de un material definido con el comando uniaxialMaterial
Steel02, adaptada de (OpenSees, 2018)
Una vez que los materiales han sido definidos, se procede a construir las secciones de
los elementos del modelo. Para hacer esto se utiliza el comando section Fiber el cual permite
crear las secciones de elementos por medio de fibras. Las fibras son elementos finitos,
44
conformados por un material previamente definido, que trabajan de manera axial. En la

Figura 6.3 se muestra un esquema de las secciones empeladas en este modelo. Estas secciones
son definidas entre la línea 58 a la 99.
t
1.82
35 41.66
1.09
35 18.08
OR 35 x 35 x t IPE 16
Figura 6.3 Esquema de secciones (medidas en cm)
Para construir las secciones mostradas en la Figura 6.3 se utilizan los comandos patch
quad, patch circ y patch rect; los cuales crean regiones de elementos fibra. Es importante
indicar que estos comandos deben ser definidos entre el espacio delimitado por las llaves del
comando section Fiber para relacionar las figuras que forman con la sección que se está
construyendo. De manera general estos comandos requieren que se especifique el material
que compondrá a las fibras y el número de éstas. En lo particular, el comando patch quad
permite definir un área poligonal especificando las coordenadas de cada uno de sus vértices;
por otra parte, el comando patch circ construye segmentos circulares; y por último, el
comando patch rect define áreas rectangulares especificando únicamente las coordenadas de
dos vértices opuestos. Para conocer más a detalle el funcionamiento de dichos comandos se
recomienda recurrir al manual en línea del programa (OpenSees, 2018).
Una vez definidas las secciones, es posible proceder a la definición de los elementos
estructurales que integran el modelo. En este ejemplo se utilizó el comando element
forceBeamColumn; que requiere la etiqueta del elemento, las etiquetas de sus nodos inicial y
final, el número de subdivisiones que tendrá el elemento, la etiqueta de su sección transversal,
45
y la etiqueta de su transformada geométrica. En este ejemplo se empleó la transformada

geométrica denominada Corotational, que toma en cuenta efectos no lineales debidos a
deformaciones grandes. Los elementos se definen de la línea 106 a la 126.
Antes de realizar el análisis estático no lineal (pushover) se realiza un análisis estático

por cargas gravitacionales. Entre las líneas 129 a la 139 se define el patrón de cargas
gravitacionales; mismas que se muestran en la Tabla 1.
De la línea 142 a la 176 se genera la carpeta y archivos de resultados (recorders), se

genera la ventana con la representación gráfica del modelo y se realiza el análisis de cargas
gravitacionales. Para fijar las cargas gravitacionales como constantes en el análisis estático
no lineal (pushover) se utiliza el comando loadConst.
Por otra parte, para el análisis estático no lineal es necesario crear un patrón de cargas
laterales. Esto se hace entre las líneas 181 a la 185. Los valores de las cargas laterales se
pueden definir a partir de una distribución triangular, una distribución relativa a las masas, o
proporcional al modo fundamental de vibrar.
Tabla 6.1 Solicitaciones en los nodos de la estructura.
𝒘𝒍 𝒘𝒍𝟐
Etiqueta 𝑽= 𝑴=
𝟐 𝟏𝟐
nodo
[t] [t ∙ cm]
21 -14.42 -420.58
22 -28.84 0.0
Entre-pisos
23 -14.42 420.58
31 -14.42 -420.58
32 -28.84 0.0
33 -14.42 420.58
41 -16.38 -477.75
Azotea
42 -32.76 0.0
43 -16.37 477.75
46
El análisis estático no lineal puede ser realizado por medio de dos diferentes métodos,
el primero consiste en utilizar el comando integrator DisplacementControl, mientras que en
el segundo se emplea el comando integrator LoadControl. El primer comando busca crear
un desplazamiento determinado en un nodo de control definido por el usuario a través de la
aplicación sucesiva de las cargas laterales creadas con anterioridad. El segundo no considera
el desplazamiento lateral de la estructura y sólo aplica las cargas laterales un número N de
veces, siendo N un valor definido por el usuario. En este ejemplo se utilizó el comando
integrator DisplacementControl; indicando al programa que debe aplicar un desplazamiento
en el nodo 41 igual a 75 cm. En la Figura 6.4 se muestra la curva cortante basal –
desplazamiento obtenida del análisis. De las líneas 205 a 216 se muestran, en comentarios,
cuáles serían las líneas a ejecutar para un análisis controlado por carga (LoadControl).
40
35
30
Cortante basal, t
25
20
15
10
5
0
0 20 40 60 80
Desplazamiento nodo superior, cm
Figura 6.4 Curva cortante basal – desplazamiento

Nodos:
- equalDOF [Etiqueta nodo maestro] [Etiqueta nodo esclavo] [Grado de libertad

restringido]
47
Materiales:
- uniaxialMaterial Steel02 [Etiqueta del material] [Fy] [Módulo de elasticidad inicial]

[Relación entre la tangente post fluencia y la tangente inicial elástica] [R0] [CR1]
[CR2] [a1] [a2] [a3] [a4]
Secciones:
- section Fiber [Etiqueta de la sección] { }

- patch quad [Etiqueta material existente] [Número de fibras en Z] [Número de fibras
en Y] [yI] [zI] [yJ] [zJ] [yL] [zL] [yK] [zK]
- patch circ [Etiqueta material existente] [Número de fibras en la circunferencia]
[Número de fibras en la dirección radial] [yCentro] [zCentro] [Radio interior] [Radio
Exterior] [Ángulo de inicio] [Ángulo final]
- patch rect [Etiqueta material existente] [Número de fibras en Z] [Número de fibras
en Y] [yI] [zI] [yJ] [zJ]
Elementos:
- geomTransf Corotational [Etiqueta de la transformada geométrica]

- element forceBeamColumn [Etiqueta del elemento] [Nodo i] [Nodo f] [Divisiones
del elemento] [Etiqueta sección existente] [Etiqueta transformada geométrica
existente]
Análisis:
- system UmfPack
- numberer RCM
- constraints Plain
- integrator LoadControl [Factor de incremento] [Iteraciones] [Mínimo factor de
incremento] [Máximo factor de incremento]
- integrator DisplacementControl [Node de control] [Grado de libertad del
desplazamiento controlado] [Incremento del desplazamiento] [Iteraciones]
- algorithm Newton
- analysis Static
- analyze [Veces que se aplicarán las cargas laterales]
48
1 #-------------------------------------------------------------------------
2 # Análisis pushover de un marco compuesto por perfiles metálicos.
3 # Unidades del modelo: [ton,cm,s]
4 #-------------------------------------------------------------------------
5 wipe;
7
8 # Introducción de variables.
9 set E 2038.9; # Módulo de elasticidad del acero
10 set Li 700.0; # Ancho de crujía.
11 set hi 350.0; # Altura de entrepiso.
14
15 # Se definen los nodos de la estructura.
16 node 11 0.0 0.0
17 node 12 $Li 0.0
18 node 13 [expr 2.0*$Li] 0.0
19 node 21 0.0 $hi
20 node 22 $Li $hi
21 node 23 [expr 2*$Li] $hi
22 node 31 0.0 [expr 2*$hi]
23 node 32 $Li [expr 2*$hi]
24 node 33 [expr 2*$Li] [expr 2*$hi]
25 node 41 0.0 [expr 3*$hi]
26 node 42 $Li [expr 3*$hi]
27 node 43 [expr 2*$Li] [expr 3*$hi]
28
30 fix 11 1 1 1
31 fix 12 1 1 1
32 fix 13 1 1 1
33
34 # Se simulan diafragmas rígidos por medio de nodos esclavos.
35 # NodTag NodTag Dof
36 equalDOF 21 22 1
37 equalDOF 22 23 1
38 equalDOF 31 32 1
39 equalDOF 32 33 1
40 equalDOF 41 42 1
41 equalDOF 42 43 1
42
43 # Se definen los materiales del modelo
44 # Comando Material Tag Fy E b R0 cR1 cR2 a1 a2 a3
45 a4
46 uniaxialMaterial Steel02 3600 2.530 $E 1e-9 20 0.925 0.15 0.0001 0.0001
47 0.0001 0.0001
48 uniaxialMaterial Steel02 5000 3.515 $E 1e-9 20 0.925 0.15 0.0001 0.0001
49 0.0001 0.0001
50
51
49
52 # b pendiente curva esfuerzo deformacipón posterior a la fluencia.

53 # R´s son valores recomendados.
54 # a parametros de endurecimiento del material posterior a la fluencia,
55 opcionales.
56
57 # Se definen los etiquetas de las secciones.
58 set OR1 1011
59 set OR2 1021
60 set IPE16 1031
61
62 # Se definen los elementos de la estructura.
63 # Columnas OR 35 x 35 x 5/8 Planta Baja
64 section Fiber $OR1 {
65 # Iy Iz Jy Jz Ky Kz Ly Lz
66 patch quad 5000 5 5 -14.34 -17.5 14.34 -17.5 14.34 -15.92 -14.34 -15.92
67 patch quad 5000 5 5 15.92 -14.34 17.5 -14.34 17.5 14.34 15.92 14.34
68 patch quad 5000 5 5 -14.34 15.92 14.34 15.92 14.34 17.5 -14.34 17.5
69 patch quad 5000 5 5 -17.5 -14.34 -15.92 -14.34 -15.92 14.34 -17.5 14.34
70
71 # CenY CenZ Rint Rext Start Ang End Ang
72 patch circ 5000 5 5 -14.34 -14.34 1.58 3.16 180 270
73 patch circ 5000 5 5 14.34 -14.34 1.58 3.16 270 360
74 patch circ 5000 5 5 14.34 14.34 1.58 3.16 0 90
75 patch circ 5000 5 5 -14.34 14.34 1.58 3.16 90 180
76 }
77
78 # Columnas OR 35 x 35 x 1/2 Segundo Nivel.
79 section Fiber $OR2 {
80 # Iy Iz Jy Jz Ky Kz Ly Lz
81 patch quad 5000 5 5 16.23 -14.96 17.5 -14.96 17.5 14.96 16.23 14.96
82 patch quad 5000 5 5 -14.96 -17.5 14.96 -17.5 14.96 -16.23 -14.96 -16.23
83 patch quad 5000 5 5 -17.5 -14.96 -16.23 -14.96 -16.23 14.96 -17.5 14.96
84 patch quad 5000 5 5 -14.96 16.23 14.96 16.23 14.96 17.5 -14.96 17.5
85
86 # CenY CenZ Rint Rext Start Ang End Ang
87 patch circ 5000 4 5 -14.96 -14.96 1.27 2.54 180 270
88 patch circ 5000 4 5 14.96 -14.96 1.27 2.54 270 360
89 patch circ 5000 4 5 14.96 14.96 1.27 2.54 0 90
90 patch circ 5000 4 5 -14.96 14.96 1.27 2.54 90 180
91 }
92
93 # Vigas IR 16 in
94 section Fiber $IPE16 {
95 # Mat Fx Fy X1 Y1 X2 Y2
96 patch rect 3600 10 4 -9.04 19.01 9.04 20.83
97 patch rect 3600 2 4 -0.545 -19.01 0.545 19.01
98 patch rect 3600 10 4 -9.04 -19.01 9.04 -20.83
99 }
100
101 # Se define la transformación geométrica.
102 set Tcorot 1
50
103 geomTransf Corotational $Tcorot

104
105 # Se definen los elementos columna del primer nivel.
106 element forceBeamColumn 11 11 21 5 $OR1 $Tcorot
109
110 # Se definen los elementos columna del segundo nivel.
114
115 # Se definen los elementos columna del tercer nivel.
119
120 # Se definen los elementos viga del marco.
121 element forceBeamColumn 1 21 22 5 $IPE16 $Tcorot
127
128 # Se definen las cargas gravitaciones actuantes sobre la estructura
129 pattern Plain 1 Linear {
130 load 21 0.0 -3.605 -420.58
131 load 22 0.0 -7.21 0.0
132 load 23 0.0 -3.605 420.58
133 load 31 0.0 -3.605 -420.58
134 load 32 0.0 -7.21 0.0
135 load 33 0.0 -3.605 420.58
136 load 41 0.0 -4.095 -477.75
137 load 42 0.0 -8.19 0.0
138 load 43 0.0 -4.095 477.75
139 }
140
141 # Se definen los registros del análisis.
142 file mkdir $carpeta; # Se crea la carpeta donde se almacenarán los
143 resultados.
144
145 # Desplazamiento del nodo de control.
146 recorder Node -file $carpeta/DespTop.out -time -node 41 -dof 1 disp;
147
148 # Reacciones en la base.
149 recorder Node -file $carpeta/ReaccionBase.out -time -node 11 12 13 -dof 1 2
150 3 reaction;
151
152
153
51
154 # Distorsiones de entrepiso.

155 recorder Drift -file $carpeta/Drift.out -time -iNode 11 21 31 -jNode 21 31
156 41 -dof 1 -perpDirn 2;
157
159 recorder display "Pushover" 10 10 600 600 -wipe
160 prp 0 0 50
161 vup 0 1 0
162 vpn 0 0 1
163 display 1 2 10
164
165 set ViewScale 5;
167 system UmfPack
168 numberer RCM
170 test NormDispIncr 1.0e-5 10 0;
173 analysis Static
174 analyze 10
175
178
179 # Se realiza el análisis Pushover.
180 # Se define el patrón de carga.
181 pattern Plain 2 Linear {
182 load 21 0.88 0.0 0.0
183 load 31 0.88 0.0 0.0
184 load 41 1.0 0.0 0.0
185 }
186
187 # se define el análisis controlado por deformación
188 set IDctrlNode 41
189 set DmaxPush 75.0
190 set DxPush 0.1
191 set Nsteps [expr int($DmaxPush/$DxPush)]
192
193 constraints Plain;
194 numberer RCM;
195 system UmfPack;
197 algorithm Newton;
198 integrator DisplacementControl $IDctrlNode 1 $DxPush
199 analysis Static
200 analyze $Nsteps;
201
202 puts "Análisis Pushover realizado"
203
204
52
205 # set loadSteps 34; Debe ser entero para ingresarlo en el comando analyze.
206
207 # constraints Plain;
208 # numberer RCM;
209 # system UmfPack;
210 # test NormDispIncr 1.0e-3 500 0;
211 # algorithm Newton;
212 # integrator LoadControl 0.1 2 0.1 1;
213 # analysis Static
214 # analyze $loadSteps;
215
216 # puts "Análisis Pushover realizado"
53
7. Análisis dinámico no lineal de un marco de

concreto reforzado

En este ejemplo se realiza un análisis dinámico a un marco de concreto reforzado en
2D. El marco está compuesto por columnas cuadradas de 30 x 30 cm y trabes de 30 x 20 cm.
En este ejemplo se consideran efectos no lineales. Las unidades del modelo son N, m y s.
El marco consta de tres niveles y tres crujías. La altura de entrepiso del modelo es
igual a 3.5 m. El ancho de las crujías es de 8m. Las columnas del marco tienen 12 varillas
del #8, estribos del #3 a cada 15 cm y recubrimiento de 6 cm. Las trabes tienen 4 varillas del
#8, estribos del #2 a cada 15 cm y un recubrimiento de 6 cm. Para la azotea se considera una
carga linealmente distribuida 𝜔𝑎 = 11 𝑘𝑁/𝑚 y para los entrepisos 𝜔𝑒 = 9 𝑘𝑁/𝑚. El
concreto tiene un 𝑓´𝑐 = 35 𝑀𝑃𝑎. El marco será sometido a la componente Este-Oeste del
movimiento sísmico del terremoto de Michoacán, México, del 19/sept/1985, registrado en la
estación SCT (Instituto de Ingeniería, 2018). En la Figura 7.1 se muestra el esquema del
marco analizado en este ejemplo.
Una de las principales ventajas de utilizar comandos para definir la geometría y

condiciones de carga del modelo, como lo hace OpenSees, es que es posible automatizar
diferentes partes de estos procesos. En este ejemplo, se mostrará cómo el uso de funciones
iterativas puede facilitar la construcción de los modelos estructurales en OpenSees.
54
31 32
30 33
312 322 332
3.5
311 321 331 341
m
21 22
20 23
212 222 232
3.5
211 221 231 241
m
11 12
10 13
112 122 132
3.5
111 121 131 141
m
0 1 2 3
8m 8m 8m

Se comienza a construir el modelo borrando objetos definidos con anterioridad por
medio del comando wipe (línea 6). Posteriormente, se indican el número de dimensiones del
modelo y número de grados de libertad por nodo con el comando BasicBuilder (línea 7).
Entre las líneas 10 a 23 se definen parámetros que facilitarán la creación del modelo.
Se aclara que este modelo permite definir el número de crujías y niveles que tendrá marco,
además de sus respectivas dimensiones. A pesar de que se permite definir las dimensiones de
las columnas y trabes, es necesario ingresar datos adicionales para la correcta definición de
los elementos.
Las masas actuantes se definen a partir de las cargas linealmente distribuidas

actuantes en cada nivel. Como se ha hecho anteriormente, las masas se ubican en las
55
conexiones viga – columna. De la línea 30 a 50 se crean los nodos que compondrán el marco.
Las etiquetas de los nodos del marco, con excepción de los de la base, se nombran de acuerdo
a la siguiente nomenclatura $i$j, donde $i y $j son el nivel y la crujía donde se ubica el nodo,
respectivamente.
Los nodos de la base se enumeran considerando únicamente el número de la crujía a

la que pertenecen. Para empotrar a estos nodos se utiliza el comando fixY, el cual sirve para
definir las restricciones de todos los nodos que se encuentren en una coordenada Y (vertical)
establecida por el usuario. Esto se hace en la línea 53.
De la línea 56 a la 62 se definen diafragmas rígidos de cada nivel por medio del

comando equalDOF.
Para crear las secciones de concreto de este ejemplo es necesario definir primero los
materiales que las compondrán. El acero de las varillas longitudinales se define entre las
líneas 72 a 75. Nótese que el comando unialxialMaterial MinMax establece las
deformaciones límite que una fibra de acero puede soportar antes de fallar. Al ser necesario
considerar el incremento de resistencia del concreto debido al confinamiento brindado por
los estribos, tres tipos distintos de concretos deben ser definidos: 1) el concreto sin confinar
exterior a los estribos, 2) el concreto confinado de las columnas, y 3) el concreto confinado
de las vigas. Las propiedades mecánicas del concreto confinado se pueden determinar
utilizando el modelo de Mander (Mander, et al., 1988). Los tres diferentes tipos de concreto
se crean utilizando el comando uniaxialMaterial Concrete02. Los cuatro materiales
mencionados anteriormente se definen entre las líneas 72 a 97. La Figura 7.2 muestra
esquemáticamente el comportamiento mecánico de un material Concrete02.
56
Figura 7.2 Relación esfuerzo–deformación de Concrete 02, adaptada de (OpenSees, 2018)
Las secciones de los elementos de concreto se definen entre las líneas 100 a 218 por
medio del comando section fiberSec. Dichas secciones se crean definiendo el núcleo de
concreto con el material de concreto confinado, posteriormente, utilizando el material del
concreto sin confinar, se define el recubrimiento de la sección, ambos elementos de la sección
se construyen utilizando el comando patch rect. Por último, se empela el comando fiber para
definir cada una de las varillas que conforman el refuerzo de longitudinal de las secciones.
La Figura 7.3 muestra un esquema de las secciones utilizadas en este ejemplo.
30 30
30 20
COLUMNAS TRABES
E#3@15 cm, E#2@15 cm,
12#8 4#8
Rec. 6 cm Rec. 6 cm
Figura 7.3 Esquema de las secciones transversales de los elementos (dimensiones en cm)
57
En este ejemplo se consideran las deformaciones producidas por esfuerzos cortantes

en sección. Para realizar esto es necesario crear un material adicional (en este caso se usa
Steel01 por su simplicidad) con las propiedades determinadas de acuerdo lo establecido en
la referencia (California Department of Transportation, 2013). Posteriormente, utilizando el
comando section Aggregator se conjugan las propiedades de la sección adicional con
aquellas definidas con anterioridad. En otras palabras, la relación esfuerzo cortante –
deformación del material Steel01 se agrega a las secciones hechas a base de fibras. Es
importante indicar que este comando no considera una interacción entre las respuestas de los
diferentes grados de libertad.
Los elementos que conforman al modelo se definen de la línea 226 a la 241. Las
etiquetas de los elementos se definen de la siguiente manera $i$j$e, donde $i y $j son el nivel
y la crujía donde se encuentra el elemento, respectivamente, y $e es el valor para diferenciar
columnas de vigas. Se usa 1 para columnas y 2 para vigas.
De la línea 244 a 255 se genera la ventana con la representación gráfica del modelo y
se determina el periodo de la estructura. En este caso se obtuvo un periodo fundamental 𝑇 =
0.86 𝑠. Este valor podría considerarse alto para un marco de tres niveles, pero se decidió
mantener con la finalidad de obtener demandas significativas en la estructura durante el
análisis dinámico.
Las cargas gravitacionales y los archivos de resultados que se generan de los análisis
se definen de la línea 258 a 285. El análisis estático por cargas gravitacionales se define y se
realiza entre las líneas 299 a 306, al finalizar éste análisis se utiliza el comando loadConst
para establecer las cargas existentes como constantes en los análisis posteriores.
Antes de realizar el análisis dinámico es necesario definir el amortiguamiento de la

estructura (se considera 2%). En este ejemplo no se recomienda utilizar la matriz de rigidez
inicial para definir el amortiguamiento estructural ya que, al considerarse efectos mecánicos
no lineales, el no tomar en cuenta la degradación de la rigidez de la estructura puede conducir
a resultados desviados. También, en este ejemplo se decidió escalar la intensidad del registro
sísmico al 300%; esto para provocar un daño perceptible en la estructura.
58
Obsérvese que en este modelo se empleó un número considerable de líneas de código

para su elaboración. Cuando esto ocurre puede ser recomendable separar el modelo en
diferentes archivos de texto los cuales podrán ser llamados posteriormente desde un único
archivo raíz. Al utilizar este método es posible facilitar la revisión y modificación de modelos
de gran tamaño en OpenSees.
En la Figura 7.4 se muestra el registro de desplazamientos laterales calculados en el

Nodo 33 del marco.
0.30
0.20
Desplazamiento, m
0.10
0.00
-0.10
-0.20
-0.30
0 20 40 60 80 100 120 140 160 180 200 220
Tiempo, s
Figura 7.4 Registro de desplazamiento laterales de la azotea del marco

Nodos:
- fixY [Coordenada Y] [Grados de libertad restringidos de los nodos existentes en el

coordenada Y]
Materiales:
59
- uniaxialMaterial MinMax [Etiqueta material] [Etiqueta material existente] –min

[Mínimo valor de deformación (Compresión)] -max [Máximo valor de deformación
(Tensión)]
- uniaxialMaterial Concrete02 [Etiqueta material] [f’c] [Deformación a f´c]
[Esfuerzo último] [Deformación última] [lambda] [Resistencia tensión] [Ets]
- uniaxialMaterial Steel01 [Etiqueta material] [Fy] [Módulo de elasticidad] [Rigidez
posterior a la fluencia.
Secciones:
- fiber [Coordenada Y local] [Coordenada Z local] [Área de la fibra] [Etiqueta material

existente]
- section Aggregator [Etiqueta sección] [Etiqueta material existente] [Solicitación
relacionada a la deformación] –section [Etiqueta sección existente]
Elementos:
- geomTransf Corotational [Etiqueta de la transformada geométrica]

- element forceBeamColumn [Etiqueta del elemento] [Nodo i] [Nodo f] [Divisiones
del elemento] [Etiqueta sección existente] [Etiqueta transformada geométrica
existente]
60
1 # ------------------------------------------------------------------------
2 # Análisis dinámico no lineal de un marco de concreto.
3 # Unidades del modelo: [N,m,s]
4 # ------------------------------------------------------------------------
5
6 wipe;
8
9 # Se definen valores para crear el modelo.
10 set Nniveles 3;
11 set Ncrujias 3;
12 set L 8.0; # Ancho de crujía
13 set H 3.5; # Altura de entrepiso.
14 set wa 11000; # Carga azotea [N/m]
15 set we 9000; # Carga entrepiso [N/m]
16 set hcol 0.30; # Altura columna.
17 set bcol 0.30; # Base columna.
18 set hviga 0.30; # Altura viga.
19 set bviga 0.20; # Base viga.
22 set g 9.81; # Aceleración de la gravedad.
23 set pi 3.1416;
24
25 # Se definen las masas de cada nodo.
26 set ma [expr $wa*$L/$g/2.0]; # Masa nodo exterior azotea.
27 set me [expr $we*$L/$g/2.0]; # Masa nodo exterior entrepiso.
28
29 # Se definen los nodos de la estructura.
30 for {set i 0} {$i <= $Nniveles} {incr i} {
31 for {set j 0} {$j <= $Ncrujias} {incr j} {
32 if {$i == 0} {
33 node $j [expr $j*$L] 0.0;
34 } else {
35 if {$i == $Nniveles} {
36 if {$j == 0 || $j == $Ncrujias} {
37 node $i$j [expr $j*$L] [expr $i*$H] -mass $ma 0.0 0.0
38 } else {
39 node $i$j [expr $j*$L] [expr $i*$H] -mass [expr 2.0*$ma] 0.0 0.0
40 }
41 } else {
42 if {$j == 0 || $j == $Ncrujias} {
43 node $i$j [expr $j*$L] [expr $i*$H] -mass $me 0.0 0.0
44 } else {
45 node $i$j [expr $j*$L] [expr $i*$H] -mass [expr 2.0*$me] 0.0 0.0
46 }
47 }; # Segundo else.
48 }; # Primer else.
49 }; # Segundo for.
50 }; # Primer for.
51
61

53 fixY 0.0 1 1 1
54
55 # Se crean los diafragmas rígidos entre los niveles.
56 for {set i 1} {$i <= $Nniveles} {incr i 1} {
57 for {set j 0} {$j <= [expr $Ncrujias-1]} {incr j 1} {
58 set a [expr $j + 1];
59 set b 0
60 equalDOF $i$b $i$a 1
61 }
62 }
63
64 # Se definen los materiales de las secciones.
65 # Tags de los materiales.
66 set AceroTag 1
67 set cover35 3
68 set NucCol 4
69 set NucViga 5
70
71 # Se definen las propiedades del acero longitudinal.
72 set fy [expr 420e6]; # Esfuerzo de fluencia.
73 set Es [expr 200e9]; # Módulo elástico.
74 uniaxialMaterial Steel02 [expr $AceroTag+1] $fy $Es 0.025 18.0 0.925 0.15;
75 uniaxialMaterial MinMax $AceroTag [expr $AceroTag+1] -min -0.05 -max 0.05
76
77 # Recubrimiento, concreto no confinado.
78 set fc [expr 35e6]; # f´c.
79 set epss 0.005; # Deformación última.
80 set Ec [expr 14000.*sqrt($fc/9.81*100./1e6)*9.81/100*1e6]; # Módulo elástico
81 (fórmula de RCDF).
82 uniaxialMaterial Concrete02 $cover35 -$fc [expr -2.0*$fc/$Ec] 0.0 -$epss 0.1
83 [expr 0.04*$fc] [expr 0.04*$fc/(2.0*$fc/$Ec)] ; # Concreto sin confinar.
84
85 # Concreto Columna.
86 set fcc1 [expr 37.695e6]; # Máxima resistencia (Mander)
87 set eu1 [expr 0.024413]; # Deformación última (Mander)
88 set fcu1 [expr 7.1035e6]; # Resistencia última (Mander)
89 uniaxialMaterial Concrete02 $NucCol -$fcc1 [expr -2.0*$fcc1/$Ec] -$fcu1 -$eu1 0.1
90 [expr 0.04*$fcc1] [expr 0.04*$fcc1/(2.0*$fcc1/$Ec)]; #Concreto confinado.
91
92 # Concreto Viga.
93 set fcc2 [expr 35.876e6]; # Máxima resistencia (Mander)
94 set eu2 [expr 0.020034]; # Deformación última (Mander)
95 set fcu2 [expr 2.835e6]; # Resistencia última (Mander)
96 uniaxialMaterial Concrete02 $NucViga -$fcc2 [expr -2.0*$fcc2/$Ec] -$fcu2 -$eu2 0.1
97 [expr 0.04*$fcc2] [expr 0.04*$fcc2/(2.0*$fcc2/$Ec)]; # Concreto confinado.
98
99 # Se definen las secciones de los elementos.
100 set ColTag 3
101 set VigTag 4
102
62
103 # Áreas de las barras longitudinales.

104 set db8 [expr 8.0*0.0254/8.0];
105 set barArea8 [expr $db8*$db8*$pi/4.0];
106
107 # Dimensiones del núcleo por Mandel y cortante por Caltrans.
108 set doz [list [expr $bcol/2] [expr $bviga/2]]; # Mitad de las secciones.
109 set doy [list [expr $hcol/2] [expr $hviga/2]];
110 set diz [list 0.07839 0.02605]; # Distancia al borde el
111 concreto confinado.
112 set diy [list 0.07839 0.07605];
113
114 # Capacidad de cortante, modelo de Caltrans.
115 set Vn [list 155637.32 79884.06];
116 set Kst [list 7.296E+08 4.864E+08];
117
118 set nFibrasY 8;
119 set nFibrasZ 8;
120 set FibraRec 2;
121
122 #Elemento columna tag 1.
123 set dozc [lindex $doz 0];
124 set doyc [lindex $doy 0];
125 set dizc [lindex $diz 0];
126 set diyc [lindex $diy 0];
127 set Vnc [lindex $Vn 0];
128 set Kstc [lindex $Kst 0];
129 set RecC 0.06; #Recubrimiento de la sección.
130
131 section fiberSec 1 {
132 # Se define el núcleo -h/2 -b/2 h/2 b/2
133 patch rect $NucCol $nFibrasY $nFibrasZ -$diyc -$dizc $diyc $dizc
134
135 # Se define el recubrimiento.
136 patch rect $cover35 $nFibrasY $FibraRec -$doyc -$dozc $doyc -$dizc
137 patch rect $cover35 $nFibrasY $FibraRec -$doyc $dizc $doyc $dozc
138 patch rect $cover35 $FibraRec $nFibrasZ -$doyc -$dizc -$diyc $dizc
139 patch rect $cover35 $FibraRec $nFibrasZ $diyc -$dizc $doyc $dizc
140
141 # Se define el acero longitudinal.
142 # Refuerzo superior.
143 set sep1c [expr (2*$doyc-2*$RecC-$db8)/3.0]
144 fiber [expr $doyc-$RecC-$db8/2.0] [expr -$dozc+$RecC+$db8/2.0+0*$sep1c]
145 $barArea8 $AceroTag
152
153
63
154 # Refuerzo inferior.

155 fiber [expr -$doyc+$RecC+$db8/2.0] [expr -$dozc+$RecC+$db8/2.0+0*$sep1c]
163
164 # Refuerzo lateral.
165 fiber [expr -$doyc+$RecC+$db8/2.0+1*$sep1c] [expr -$dozc+$RecC+$db8/2.0]
167 fiber [expr -$doyc+$RecC+$db8/2.0+1*$sep1c] [expr $dozc-$RecC-$db8/2.0]
169
170 fiber [expr -$doyc+$RecC+$db8/2.0+2*$sep1c] [expr -$dozc+$RecC+$db8/2.0]
172 fiber [expr -$doyc+$RecC+$db8/2.0+2*$sep1c] [expr $dozc-$RecC-$db8/2.0]
174 }; # Se terminó de definir la sección.
175
176 # Elemento viga tag 2.
177 set dozv [lindex $doz 1];
178 set doyv [lindex $doy 1];
179 set dizv [lindex $diz 1];
180 set diyv [lindex $diy 1];
181 set Vnv [lindex $Vn 1];
182 set Kstv [lindex $Kst 1];
183 set RecV 0.06; #Recubrimiento de la sección.
184
185 section fiberSec 2 {
186 # Se define el núcleo. -h/2 -b/2 h/2 b/2
187 patch rect $NucViga $nFibrasY $nFibrasZ -$diyv -$dizv $diyv $dizv
188
189 # Se define el recubrimiento.
190 patch rect $cover35 $nFibrasY $FibraRec -$doyv -$dozv $doyv -$dizv
191 patch rect $cover35 $nFibrasY $FibraRec -$doyv $dizv $doyv $dozv
192 patch rect $cover35 $FibraRec $nFibrasZ -$doyv -$dizv -$diyv $dizv
193 patch rect $cover35 $FibraRec $nFibrasZ $diyv -$dizv $doyv $dizv
194
195 # Se define el acero longitudinal
196 # Refuerzo superior.
197 set sep1v [expr (2*$dozv-2*$RecV-$db8)]
198 fiber [expr $doyv-$RecV-$db8/2.0] [expr -$dozv+$RecV+$db8/2.0+0*$sep1v]
200 fiber [expr $doyv-$RecV-$db8/2.0] [expr -$dozv+$RecV+$db8/2.0+1*$sep1v]
202
203 # Refuerzo inferior.
204 set sep2v [expr (2*$dozv-2*$RecV-$db8)]
64
205 fiber [expr -$doyv+$RecV+$db8/2.0] [expr -$dozv+$RecV+$db8/2.0+0*$sep2v]

207 fiber [expr -$doyv+$RecV+$db8/2.0] [expr -$dozv+$RecV+$db8/2.0+1*$sep2v]
209 }; # Se terminó de definir la sección.
210
211 # Se define la relación cortante - deformación.
212 set CortanteCol 6
213 uniaxialMaterial Steel01 $CortanteCol $Vnc $Kstc 1.0e-3
214 section Aggregator $ColTag $CortanteCol Vy -section 1
215
216 set CortanteVig 7
217 uniaxialMaterial Steel01 $CortanteVig $Vnv $Kstv 1.0e-3
218 section Aggregator $VigTag $CortanteVig Vy -section 2
219
220
221 # Se define la transformación geométrica.
222 set Tcorot 1
223 geomTransf Corotational $Tcorot
224
225 # Se definen los elementos del modelo.
226 set nPts 5
228 set y [expr $i - 1];
229
230 for {set j 1} {$j <= [expr $Ncrujias + 1]} {incr j} {
231 set x [expr $j - 1];
232 set c 1; # Tag columnas $i$j$c.
233 set v 2; # Tag vigas $i$j$v.
234 set t 3;
235
236 element forceBeamColumn $i$j$c $y$x $i$x $nPts $ColTag $Tcorot
237 if {$j <= $Ncrujias} {
238 element forceBeamColumn $i$j$v $i$x $i$j $nPts $VigTag $Tcorot
239 }
241 }; # Primer for.
242
244 recorder display "Marco 3 Niveles" 10 10 600 600 -wipe
245 prp 0 0 50
246 vup 0 1 0
247 vpn 0 0 1
248 display 1 2 10
249
250 set ViewScale 5;
251
252 # Se determina el periodo fundamental de la estructura.
253 set eigenvalues [eigen 1];
254 set T [expr 2*$pi/($eigenvalues**0.5)];
255 puts "T1 = $T";
65
256 # Se definen las cargas actuantes en la estructura.

257 set Grav 1
258 pattern Plain $Grav Linear {
260 for {set j 0} {$j <= $Ncrujias} {incr j} {
261
262 if {$i == $Nniveles} {
263 if {$j == 0 || $j == $Ncrujias} {
264 if {$j == 0} {
265 load $i$j 0.0 [expr -$wa*$L/2.0] [expr -$wa*$L**2/12.0]
266 } else {
267 load $i$j 0.0 [expr -$wa*$L/2.0] [expr $wa*$L**2/12.0]
268 }
269 } else {
270 load $i$j 0.0 [expr -2*$wa*$L/2.0] 0.0
271 }
272 } else {
273 if {$j == 0 || $j == $Ncrujias} {
274 if {$j == 0} {
275 load $i$j 0.0 [expr -$we*$L/2.0] [expr -$we*$L**2/12.0]
276 } else {
277 load $i$j 0.0 [expr -$we*$L/2.0] [expr $we*$L**2/12.0]
278 }
279 } else {
280 load $i$j 0.0 [expr -2*$we*$L/2.0] 0.0
281 }
282 }; # Segundo else.
284 }; # Primer for.
285 }; # Patter.
286
287
288 # Se definen los registros.
289 file mkdir $carpeta; # Se crea la carpeta donde se almacenarán los resultados.
290
291 recorder Node -file $carpeta/DespTop.out -time -node 33 -dof 1 disp;
292 recorder Node -file $carpeta/ReaccionBase.out -time -node 0 1 2 3 -dof 1 2
293 3 reaction;
294 recorder Drift -file $carpeta/Drift.out -time -iNode 3 13 23 -jNode 13 23 33
295 -dof 1 -perpDirn 2 ;
296
297
299 system UmfPack
300 numberer RCM
305 analysis Static
306 analyze 10
66

309
311 set freq [expr [eigen 1]**0.5]
312 set damp 0.02;
313 rayleigh 0. 0. 0. [expr 2*$damp*$freq]
314
315 # Se crea el patrón de aceleraciones.
316 set Factor 0.03; # Registro de aceleraciones esta en cm/s2, el factor lo
317 convierte a m/s2 y triplica la intensidad sísmica
322
325
326 # Se realiza el análisis dinámico.
327 system UmfPack
328 numberer RCM
330 test NormDispIncr 1.0e-8 10
331 integrator Newmark 0.5 0.25
333 analysis Transient
334 analyze $Npuntos $dt
335
336 puts "Análisis Dinámico finalizado."
67
8. Análisis dinámico de un marco reforzado con

amortiguador viscoso

En este ejemplo se realiza un análisis dinámico a un marco reforzado con un
amortiguador viscoso. No se consideran efectos no lineales en trabe y columnas, sólo en el
disipador. Este ejemplo se encuentra disponible en la página oficial del OpenSees (OpenSees,
2010). Las unidades del modelo son kN, mm y s.
El modelo a analizar, mostrado en la Figura 8.1, consta de un marco de un nivel y una

sola crujía, donde L = 5 m y h = 3 m. Se considera una carga actuante sobre el marco de 1,000
KN. Para definir los elementos estructurales se parte de las consideraciones de que la viga es
un elemento infinitamente rígido y que el marco posee un periodo fundamental igual a 0.7 s.
Basándose en estos datos se determina el momento de inercia de las columnas y se procede
a crear los elementos viga y columna correspondiente. El amortiguador viscoso (Elemento
4) posee una rigidez axial 𝐾𝑑 = 25 𝑘𝑁/𝑚𝑚, un coeficiente de amortiguamiento 𝐶𝑑 =
20.74 𝑘𝑁(𝑠/𝑚𝑚)𝛼 y un exponente de velocidad α = 0.35. El marco es sometido a la
componente Este-Oeste de movimiento sísmico del terremoto de Michoacán, México, del
19/sept/1985 registrado en la estación SCT (Instituto de Ingeniería, 2018).
Para mostrar los efectos de la adición del amortiguador viscoso en la respuesta

dinámica del marco, al final del ejemplo se muestran los desplazamientos laterales del marco
con y sin amortiguador.
68
3 4
3
1 2 h
1 2

por medio del comando wipe, (línea 8). Posteriormente, se indican el número de dimensiones
Entre las líneas 12 a 26 se definen parámetros que facilitan la creación del modelo y
su posterior modificación en caso de ser necesario.
Entre las líneas 30 a 44 se crean los nodos de la estructura, sus respectivas

restricciones y la masa actuante, siendo ésta última distribuida entre las dos conexiones viga
– columna de la estructura.
Ahora, al conocer la masa y el periodo de la estructura, es posible determinar su

rigidez lateral (K) por medio de la ecuación (8.1):
𝑚
𝑇 = 2𝜋√ 𝐾 (8.1)
69
donde:
𝑇 es el periodo de la estructura.
𝑚 es la masa actuante.
𝐾 es la rigidez lateral.
En este ejemplo se considera que la viga es un elemento infinitamente rígido. Bajo

esta suposición, y para un marco de este tipo, la rigidez lateral de la estructura es igual a
(Chopra, 1995):
12𝐸𝐼𝑐 𝐸𝐼𝑐
𝐾= ∑ 3
= 24 3 (8.2)
ℎ ℎ
𝑐𝑜𝑙𝑢𝑚𝑛𝑎𝑠
donde:
𝐸 es el módulo de elasticidad.
𝐼𝑐 es el momento de inercia de la columna.
ℎ es la altura del marco.
Como se puede observar en la ecuación (8.2), es posible despejar el momento de

inercia de la columna (𝐼𝑐). Dicho valor se utiliza para definir los elementos columna del
marco. Si en cambio, la suposición hubiera sido que el elemento viga carece de rigidez, la
rigidez lateral del marco podría calcularse con la ecuación (8.3):
3𝐸𝐼𝑐 𝐸𝐼𝑐
𝐾= ∑ 3
=6 3 (8.3)
ℎ ℎ
𝑐𝑜𝑙𝑢𝑚𝑛𝑎𝑠
Claramente, entre estos dos extremos existen una infinidad de valores de rigidez para
la viga del marco. Para esos casos, la rigidez lateral del marco se calcula de la siguiente
forma:
70
24𝐸𝐼𝑐 12𝜌 + 1
𝐾= (8.4)
ℎ3 12𝜌 + 4
Donde ρ es la relación de rigidez entre la viga y la columna, que se calcula con la

ecuación (8.5):
𝐼𝑏
𝜌= (8.5)
4𝐼𝑐
Siendo 𝐼𝑏 el módulo de inercia de la viga. En la Figura 8.2 se muestra la variación

rigidez lateral en función del parámetro ρ.
24
18
K/( EIc /h 3 )
12
6
0
0.001 0.01 0.1 1 10 100
ρ
Figura 8.2 Rigidez lateral del marco en función de 𝜌, adaptada de (Chopra, 1995)
La definición de las propiedades y posterior creación de los elementos que conforman

el marco se realiza entre las líneas 47 a 71. Obsérvese que para modelar el amortiguador
viscoso se comenzó definiendo un material con el comando uniaxialMaterial
ViscousDamper; el cual representa el comportamiento de un resorte lineal y un amortiguador
no lineal en serie. A manera de ejemplo, en la Figura 8.3 se muestra la respuesta típica de
un disipador viscoso no lineal.
71
100
Fuerza axial, kN
50
-50
-100
-20 -10 0 10 20
Desplazamiento, mm
Figura 8.3 Respuesta típica de un disipador viscoso no lineal
Una vez que el material que compondrá al amortiguador viscoso es definido, se

procede a crear el elemento por medio del comando element twoNodeLink; el cual construye,
en este caso, un elemento de longitud cero con una respuesta axial definida por las
propiedades del material ViscousDamper.
De las líneas 73 a 81 se definen los archivos de resultados que se desean generar del
análisis. Posteriormente, de la línea 84 a 88, se define el amortiguamiento de la estructura,
indicando al programa que sólo tome en cuenta la matriz de masa del modelo para determinar
el amortiguamiento de Rayleigh.
El ejemplo se finaliza realizando el análisis dinámico. Esto ocurre entre las líneas 91
a 117. Para observar los efectos producidos por el amortiguador viscoso en la respuesta
dinámica del marco, se realizaron dos análisis, uno del marco sin reforzar y otro del marco
reforzado con el amortiguador viscoso. La Figura 8.4 muestra la comparación del registro de
desplazamientos del Nodo 4 de los dos análisis realizados. Obsérvese que la adición del
amortiguador viscoso mejora el desempeño estructural del marco, lográndose una reducción
en la respuesta máxima de más del 60% en comparación con el caso sin refuerzo.
72
80
Desplazamiento laterla, mm
Sin refuerzo
60
Con refuerzo
40
20
0
-20
-40
-60
-80
0 20 40 60 80 100
Tiempo, s
Figura 8.4 Comparación de desplazamientos laterales: marco sin y reforzado con amortiguador
viscoso.

Materiales:
- uniaxialMaterial ViscousDamper [Etiqueta material] [Rigidez axial Kd]

[Coeficiente de amortiguamiento] [Alfa o exponente de velocidad]
Elementos:
- element twoNodeLink [Etiqueta del elemento] [Nodo i] [Nodo f] [Etiqueta material

existente] [Dirección del material]
73
1 #--------------------------------------------------------------------------
2 # Análisis dinámico de un marco reforzado con amortiguador viscoso.
3 #
4 # Problema creado por: Sarven Akcelyan & Dimitrios G. Lignos
5 # Unidades del modelo [KN,mm,s]
6 #--------------------------------------------------------------------------
7
8 wipe;
10
11 # Se crea la carpeta que almacenará los resultados.
12 set Output ResultadosEx6;
13 file mkdir $Output;
14
15 # Parámetros del marco.
16 set L 5000.; # Ancho de crujía.
17 set h 3000.; # Altura del marco.
18 set W 1000.; # Peso actuante, para definir la masa.
19 set g 9810.; # Gravedad en mm/s2.
20 set m [expr $W/$g]; # Se define la masa actuante.
21 set Tn 0.7; # Periodo de la estructura.
22 set pi [expr acos(-1.0)];
23 # Propiedades del amortiguador
24 set Kd 25.; # Rigidez axial.
25 set Cd 20.7452; # Coeficiente de amortiguamiento.
26 set ad 0.35; # Exponente a
27
28
29 # Se definen los nodos del modelo.
30 node 1 0. 0. ;
31 node 2 $L 0. ;
32 node 3 0. $h ;
33 node 4 $L $h ;
34
35 # Se definen las condiciones de apoyo.
36 fix 1 1 1 1;
37 fix 2 1 1 1;
38
39 # Se restringen los nodos de la viga
40 equalDOF 3 4 1 ; # GDL .
41
42 # Se asignan las masas.
43 mass 3 [expr 0.5*$m] 0. 0. ;
44 mass 4 [expr 0.5*$m] 0. 0. ;
45
46 # Se definen las propiedades de las columnas y la viga.
47 set K [expr pow(2*$pi/$Tn,2)*$m];
48 set E 200.0;
49 set Ic [expr $K*pow($h,3)/(24*$E)]; # (K=24EIc/h^3)
50 set Ib [expr 1e12*$Ic];
51 set A [expr 1e12];
74
52 # Se define el material ViscousDamper

53 uniaxialMaterial ViscousDamper 1 $Kd $Cd $ad
54 # Se crea la transformada geometrica.
55 set TransfTag 1;
56 geomTransf Linear $TransfTag;
57
58 # Se definen los elementos.
59 # Columna
60 element elasticBeamColumn 1 1 3 $A $E $Ic $TransfTag;
62
63 # Viga
64 element elasticBeamColumn 3 3 4 $A $E $Ib $TransfTag;
65
66 # Amortiguador
67 #element twoNodeLink $eleTag $iNode $jNode -mat $matTags -dir $dirs
68 element twoNodeLink 4 1 4 -mat 1 -dir 1
69
70 puts "Modelo construido"
71
72 # Se definen los registros del modelo
73 recorder Node -file $Output/Disp.out -time -node 4 -dof 1 disp;
74 recorder Node -file $Output/Acc.out -time -node 4 -dof 1 accel;
75 recorder Node -file $Output/Base.out -time -node 1 2 -dof 1 reaction;
76 recorder Node -file $Output/NBase.out -time -node 1 2 -dof 2 reaction;
77
78 recorder Element -file $Output/Damperdisp.out -time -ele 4 deformations ;
79 recorder Element -file $Output/Damperforce.out -time -ele 4 localForce ;
80 recorder Element -file $Output/Dampergbforce.out -time -ele 4 -dof 1 force;
81 recorder Element -file $Output/Frameforce.out -time -ele 1 2 -dof 1 force;
82
84 set freq [expr ([eigen -fullGenLapack 1])**0.5]
85 set period [expr 2*$pi/$freq]
86 puts "T = $period"
87 set damp 0.02;
88 rayleigh [expr 2*$damp*$freq] 0. 0. 0.
89
91 set Factor 10.0; # El registro de aceleraciones se encuentra en
92 cm/s2, este factor lo convierte a mm/s2.
97
100
102 recorder display "Marco con VD" 10 10 500 500 -wipe
75
103 prp 200. 50. 1;

104 vup 0 1 0;
105 vpn 0 0 1;
106 display 1 5 40
107
108 # Se crea el análisis dinámico.
109 wipeAnalysis;
110 constraints Transformation;
111 numberer RCM;
112 system UmfPack;
113 test EnergyIncr 1.0e-10 100;
114 algorithm KrylovNewton;
115 integrator Newmark 0.5 0.25 ;
116 analysis Transient;
117 analyze $Npuntos $dt;
118
119 puts "Análisis dinámico finalizado"
77
9. Análisis dinámico de un marco reforzado con un

contraventeo restringido al pandeo

En este ejemplo se realiza un análisis dinámico a un marco reforzado con un
contraventeo restringido al pandeo (CRP). Los CPR son dispositivos que disipan energía
sísmica por medio de comportamiento plástico de su núcleo, por lo que durante este análisis
se considerarán efectos no lineales en el CRP. Información adicional sobre los CRP se puede
encontrar en (Merrit, et al., 2003), (Black, et al., 2004), (Tremblay, et al., 2006), (Teran-
Gilmore & Virto, 2009), (Guerrero, et al., 2017), entre otros. Este ejemplo se basa en el
ejemplo del Capítulo 7, sólo se ha sustituido el disipador viscoso por un CRP. Las unidades
del modelo son kN, mm y s.
El modelo consta de un marco de un nivel (de 3 m de altura) y una crujía (de 5 m de

ancho). Se considera una carga actuante sobre el marco de 1,000 KN. Al igual que en el
Capítulo 7, para definir los elementos estructurales se parte de la suposición de que la viga
es un elemento infinitamente rígido y el marco posee un periodo fundamental igual a 0.7 s.
Basándose en estos datos se determina el momento de inercia de las columnas y se procede
a crear los elementos viga y columna correspondientes. El material que conforma al núcleo
del CRP es acero ASTM A36 (𝑓𝑦 = 250 𝑀𝑃𝑎). En la Figura 9.1 se muestra un diagrama del
dispositivo empleado en este ejemplo.
Como se puede apreciar, los CRPs cuentan con dos diferentes secciones transversales.
En los extremos se encuentran las secciones elásticas que actúan como conexiones. El área
transversal de estas secciones es mayor que el área central del núcleo para garantizar que
siempre trabajen en su intervalo elástico. La relación entre el área del núcleo y el área de las
conexiones es de 1 a 4 para este ejemplo. Esto significa que las conexiones del CPR tendrán
78
un área transversal cuatro veces más grande que el área de su núcleo. De la misma figura se
observa que, en este ejemplo, la longitud del núcleo será igual a un tercio de la longitud total
del disipador. Para definir las conexiones del CRP con el marco se definen dos nodos
adicionales; los cuales se considerarán articulados.
Sección elástica Carcasa rellena

(A = 4 Anúcleo ) Núcleo con compor-
B tamiento inelástico de mortero Carcasa
Núcleo
Mortero
Material
B’ antiadherente
L/3 L/3 L/3 Corte B – B´
Figura 9.1 Esquema de un contravente restringido al pandeo
Al igual que en el Capítulo 7, el marco de será sometido al registro sísmico SCT

19/Sep/1985 (Instituto de Ingeniería, 2018). El marco analizado en este ejemplo se muestra
en la Figura 9.2.
3 4
3
24
43
23
1 2 h
22 42
21 41
1 2

79

por medio del comando wipe (línea 8). Posteriormente, se indican el número de dimensiones
Entre las líneas 12 a 28 se definen los valores que facilitarán la creación del modelo
y su posterior modificación en caso de ser necesario. Entre estos valores también se define la
relación de áreas y longitudes del CRP, además del área transversal de su núcleo, en cm2.

– columna de la estructura. Debido a que el CRP se conforma por dos diferentes secciones
transversales, es necesario crear dos nodos adicionales a lo largo del elemento los cuales
definen donde inician y terminan las secciones elásticas del disipador. Adicionalmente se
crean dos nodos en las mismas coordenadas que los nodos 1 y 4. Éstos son los nodos 21 y
24. Los desplazamientos laterales y verticales de los nodos 1 y 21, y 4 y 24 son vinculados
para modelar una conexión articulada entre el marco y el CRP (líneas 47 y 48). Nótese que
sólo los grados de libertad 1 y 2 son vinculados mientras que la rotación (grado de libertad
3) no se vincula.
En este ejemplo es necesario definir el material que compone al núcleo del disipador.
Como se mencionó antes, el esfuerzo de fluencia del acero es 𝑓𝑦 = 250 𝑀𝑃𝑎. Entre las líneas
55 a 58 se crea el material del disipador con los comandos uniaxialMaterial Steel02 y
uniaxialMaterial MinMax. Entre las líneas 61 a 65 se definen las propiedades de las columnas
y la viga del marco. Para modelar el CRP es necesario construir las secciones transversales
de las conexiones y del núcleo. Esto ocurre entre las líneas 68 a 87. Los elementos que
conforman el modelo se crean entre las líneas 96 a 106. Obsérvese que se utilizan elementos
elasticBeamColumn para las columnas y la viga, mientras que para crear el núcleo y las
conexiones del CRP se utilizan elementos forceBeamColumn. Este último tipo de elemento
considera comportamiento inelástico.
80
Una vez que el modelo ha sido construido se procede a definir los diferentes archivos
de resultados que se generarán durante el análisis. Esto ocurre entre las líneas 111 y 124.
Por último, se define el amortiguamiento de la estructura (líneas 127 a 131), se genera

el pattern de la solicitación sísmica (líneas 134 a 142), se genera la ventana con la
representación gráfica del modelo (líneas 145 a 149) y se realiza el análisis dinámico (líneas
152 a 160). En la Figura 9.3 se comparan los desplazamientos del Nodo 4 de la estructura
reforzada con el CRP y sin reforzar. Se puede ver que el CRP reduce significativamente la
respuesta sísmica de la estructura analizada.
80
Sin refuerzo
Desplazamiento lateral, mm
60
Con refuerzo
40
20
0
-20
-40
-60
-80
0 20 40 60 80 100
Tiempo, s
Figura 9.3 Comparación de desplazamientos laterales: marco sin refuerzo y reforzado con CRP
Adicionalmente, la curva fuerza axial – desplazamiento del CRP utilizado en este

ejemplo se muestra en la Figura 9.4. Se aprecia que el CRP fluye tanto a tensión como a
compresión, lo cual le brinda ciclos histeréticos estables. En el siguiente ejemplo se analizará
un marco reforzado con un contraventeo convencional, es decir, uno no restringido al pandeo.
En ese ejemplo, se observará que el contraventeo convencional presenta una menor
resistencia a compresión que a tensión, esto último debido a que se considerará el problema
del pandeo lateral.
81
40
30
20
Fuerza axial, kN
10
0
-10
-20
-30
-40
-10 -5 0 5 10
Desplazamiento, mm
Figura 9.4 Respuesta del contraventeo restringido al pandeo

82
1 #--------------------------------------------------------------------------
2 # Análisis dinámico de un marco reforzado con contraventeo restringido al pandeo.
3 #
4 # Ejemplo basado en el problema creado por Sarven Akcelyan & Dimitrios G. Lignos.
6 #--------------------------------------------------------------------------
7
8 wipe;
10
14
23
24 # Propiedades del contraventeo restringido.
25 set Lratio [expr 1.0/3.0]; # Relación longitud núcleo / longitud total del
26 disipador < 1.0
27 set Aratio 0.25; # Relación área del núcleo / área conexiones
28 set fa [expr 1.0]; # Área del núcleo del disipador, en cm2.
29
31 node 1 0. 0. ;
32 node 2 $L 0. ;
33 node 3 0. $h -mass [expr 0.5*$m] 0. 0. ;
34 node 4 $L $h -mass [expr 0.5*$m] 0. 0. ;
35
37 fix 1 1 1 1;
38 fix 2 1 1 1;
39
40 # Se definen los nodos del contraventeo restringido.
41 node 21 0.0 0.0
42 node 22 [expr $L*(1-$Lratio)/2.0] [expr $h*(1-$Lratio)/2.0]
43 node 23 [expr $L*(1+$Lratio)/2.0] [expr $h*(1+$Lratio)/2.0]
44 node 24 $L $h
45
46 # Se crea una articulación en los nodos que conectan con el marco.
47 equalDOF 1 21 1 2;
48 equalDOF 4 24 1 2;
49
50 # Se define el material del disipador.
51 set steelTagBRBs 1000
83
52 set fyBRB 0.25;

53 set EsBRB 200.0;
54
55 uniaxialMaterial Steel02 [expr $steelTagBRBs+1] $fyBRB $EsBRB 0.02 25.0
56 0.925 0.15 0.05 1.0 0.05 1.0 0.0;
57 uniaxialMaterial MinMax $steelTagBRBs [expr $steelTagBRBs+1] -min -
58 0.20 -max 0.20
59
62 set E 200.0;
64 set Ib [expr 1e12*$Ic];
65 set A [expr 1e12];
66
67 # Se crean las secciones que conforman el disipador.
68 set BRBsec 1001;
69 set BRBend 1002;
70
71 set secFactorBRB [expr $fa*(1e2)]; # Área del núcleo en mm2.
72 set secFactorEND [expr (1.0/$Aratio)*$fa*(1e2)]; # Áreas conexiones en mm2.
73 set by [expr ($secFactorBRB)**0.5];
74 set byEND [expr ($secFactorEND)**0.5];
75
76 # Se define la sección del núcleo del disipador.
77 set nFibers 6;
78 section fiberSec $BRBsec {
79 patch rect $steelTagBRBs $nFibers $nFibers [expr -1.*$by/2.] [expr -
80 1.*$by/2.] [expr $by/2.] [expr $by/2.]
81 }
82
83 # Se define la sección de las conexiones del disipador.
84 section fiberSec $BRBend {
85 patch rect $steelTagBRBs $nFibers $nFibers [expr -1.*$byEND/2.] [expr -
86 1.*$byEND/2.] [expr $byEND/2.] [expr $byEND/2.]
87 }
88
89 # Se crea la transformada geométrica.
90 set TransfTag 1;
91 geomTransf Linear $TransfTag ;
92
94 set nIP 3;
95 # Columna.
98
99 # Viga.
100 element elasticBeamColumn 3 3 4 $A $E $Ib $TransfTag;
101
102
84
103 # Contraventeo restringido.

104 element forceBeamColumn 41 21 22 $nIP $BRBend $TransfTag
105 element forceBeamColumn 42 22 23 $nIP $BRBsec $TransfTag
106 element forceBeamColumn 43 23 24 $nIP $BRBend $TransfTag
107
109
110 # Se definen los registros del marco.
116
117 # Se definen los registros del contraventeo restringido al pandeo.
118 recorder Node -file $Output/ReactionsDOF1BRBs.out -node 21 -dof 1 reaction;
121 recorder Element -xml "$Output/BRB_basicForce.out" -time -ele 41 42 43
122 basicForce
123 recorder Element -xml "$Output/BRB_basicDef.out" -time -ele 41 42 43
124 basicDeformation
125
127 set freq [expr [eigen -fullGenLapack 1]**0.5]
128 set period [expr 2*$pi/$freq]
130 set damp 0.02;
132
134 set Factor 10; # El registro de aceleraciones se encuentra en
140
141 timeSeries Path 1 -dt $dt -filePath $AccelDataFile -factor $Factor;
142 pattern UniformExcitation 1 $DirX -accel 1;
143
145 recorder display "Marco con contraventeo restringido" 10 10 500 500 -wipe
146 prp 200. 50. 1;
147 vup 0 1 0;
148 vpn 0 0 1;
149 display 1 5 40
150
152 wipeAnalysis;
85
154 numberer RCM;

155 system UmfPack;
161
87
10. Análisis dinámico de un marco reforzado

con un contraventeo convencional

Se realiza un análisis dinámico a un marco reforzado con un contraventeo
convencional (Figura 10.1). Debido a que los contraventeos convencionales tienden a
presentar problemas de inestabilidad al ser sometidos a cargas de compresión, durante este
análisis se considerarán efectos no lineales. Este ejemplo se basa en aquel del Capítulo 7.
Las unidades del modelo son kN, mm y s.
3 4
3
23
42
22
1 2 h
21 41
1 2
Como se observa en la Figura 10.1, modelo a analizar consta de un marco de un nivel

y una sola crujía. El ancho de la crujía es de 5 m y el alto de 3 m. Se considera una carga
actuante sobre el marco de 1,000 KN. Para definir los elementos estructurales se parte de la
suposición de que la viga es un elemento infinitamente rígido. Se considera que el marco
88
tiene un periodo fundamental igual a 1.5 s. Basándose en estos datos se determina el momento
de inercia de las columnas.
El contraventeo está conformado por un elemento con sección en cajón de 10 cm por

lado y un espesor de placa de 3 mm. El material que conformará el contraventeo es acero
A572 Gr. 50 con un esfuerzo de fluencia 𝑓𝑦 = 345 𝑀𝑃𝑎. Siguiendo las recomendaciones
presentadas en la referencia (Tapia, et al., 2016), para reproducir los efectos de inestabilidad
producidos por cargas de compresión, se considera un pandeo inicial en el elemento con una
flecha igual a 0.008𝐿𝑐 , donde 𝐿𝑐 es la longitud del contraventeo. El marco de será sometido
al registro sísmico SCT 19/sep/1985 (Instituto de Ingeniería, 2018).

por medio del comando wipe (línea 8). Posteriormente se indican el número de dimensiones
Entre las líneas 12 a 28 se definen los valores que facilitarán la creación del modelo
y su posterior modificación en caso de ser necesario. Entre estos valores también se define el
área transversal del contraventeo, su longitud y su flecha inicial.

– columna de la estructura. Para modelar una imperfección geométrica en el contraventeo se
crea un nodo intermedio en el elemento. Dicho nodo tendrá una posición que considere el
pandeo inicial recomendado por la referencia (Tapia, et al., 2016). En la Figura 10.2 muestra
una representación del nodo intermedio, además se indican los ángulos alfa y beta definidos
en las líneas 26 y 27, respectivamente.
Adicionalmente, se crean dos nodos en las mismas coordenadas que los nodos 1 y 4.
Los desplazamientos laterales y verticales de los nodos creados (41 y 43) son vinculados para
modelar una conexión articulada entre el marco y el contraventeo (líneas 46 y 47).
89
En este ejemplo es necesario definir el material que conforma el contraventeo. Se

utiliza un acero con un esfuerzo de fluencia 𝑓𝑦 = 345 𝑀𝑃𝑎. Entre las líneas 50 a 57 se crea
el material del disipador por medio de los comandos uniaxialMaterial Steel02,
uniaxialMaterial MinMax y uniaxialMaterial Fatigue. El último material empleado se utiliza
para considerar el daño acumulado (o fatiga) en el contraventeo debido a los ciclos de carga.
3 0.008Lc
22
100
β α
Lc
100
Sección transversal
del CPR
Figura 10.2 Posición del Nodo 22 considerando pandeo inicial del contraventeo (cotas de la sección
en mm)
Entre las líneas 60 a 64 se definen las propiedades de las columnas y la viga del marco.
Por simplicidad en la modelación de este ejemplo, se decidió considerar un contraventeo con
una sección transversal en cajón cuadrada uniforme a todo lo largo del elemento. La creación
de dicha sección transversal se realiza entre las líneas 70 a 76. Los elementos que conforman
el modelo se crean entre las líneas 89 a 97. Obsérvese que se utilizan elementos
elasticBeamColumn para las columnas y la viga, mientras que para crear el contraventeo se
utilizan elementos forceBeamColumn. Siguiendo las recomendaciones de la referencia [12],
se utiliza una transformada geométrica corrotacional para el contraventeo y se le indica al
programa que considere ocho subdivisiones en el elemento.
Una vez que el modelo ha sido construido se definen los diferentes archivos de
resultados que se generarán durante el análisis, esto ocurre entre las líneas 102 y 115.
Por último, se define el amortiguamiento de la estructura (líneas 118 a 122), se genera

el pattern de la solicitación sísmica (líneas 125 a 133), se genera la ventana con la
90
representación gráfica del modelo (líneas 136 a 140) y se realiza el análisis dinámico (líneas
143 a 151).
Para fines comparativos, en la Figura 10.3 se muestran los registros de

desplazamientos del Nodo 4 de la estructura reforzada con el contraventeo y sin él. Se aprecia
que el contraventeo ayuda a reducir la respuesta de la estructura.
400
Sin refuerzo
300
Desplazamiento laterla, mm
Con refuerzo
200
100
0
-100
-200
-300
-400
0 20 40 60 80 100
Tiempo, s
Figura 10.3 Comparación de desplazamientos laterales del marco con y sin refuerzo con contraventeo
convencional.
De manera adicional, en la Figura 10.4 se muestra la gráfica fuerza axial –

desplazamiento del contraventeo convencional. Se puede observar que, debido a que en este
análisis se considera el fenómeno del pandeo lateral, el elemento no solo tiene menos
capacidad a compresión sino que además su curva presenta ciclos histeréticos inestables.
91
500
400
Fuerza axial, kN
300
200
100
0
-100
-100 -50 0 50 100
Desplazamiento, mm
Figura 10.4 Respuesta del contraventeo convencional

Materiales:
- uniaxialMaterial Fatigue [Etiqueta material] [Etiqueta material existente]

92
1 #--------------------------------------------------------------------------
2 # Análisis dinámico de un marco reforzado con un contraventeo convencional.
3 #
4 # Ejemplo basado en el problema creado por Sarven Akcelyan & Dimitrios G. Lignos.
6 #--------------------------------------------------------------------------
7
8 wipe;
10
14
23
24 # Propiedades del contraventeo convencional.
25 set Lc [expr ($L**2+$h**2)**0.5]; # Longitud contraventeo convencional.
26 set alfa [expr atan($h/$L)]; # Ángulo de la diagonal.
27 set beta [expr $pi/2.0 - $alfa]; # Ángulo complementario.
28 set pandeo [expr 0.008*$Lc]; # Pandeo inicial.
29
31 node 1 0. 0. ;
32 node 2 $L 0. ;
33 node 3 0. $h -mass [expr 0.5*$m] 0.01 0. ;
34 node 4 $L $h -mass [expr 0.5*$m] 0.01 0. ;
35
37 fix 1 1 1 1;
38 fix 2 1 1 1;
39
40 # Se definen los nodos del contraventeo convencional.
41 node 21 0.0 0.0
42 node 22 [expr $L/2.0-$pandeo*cos($beta)] [expr $h/2.0+$pandeo*sin($beta)]
43 node 23 $L $h
44
45 # Se crea una articulación en los nodos que conectan con el marco.
46 equalDOF 1 21 1 2;
47 equalDOF 4 23 1 2;
48
49 # Se define el material del contraventeo.
50 set steelTag 1000
51 set fy 0.345;
93
52 set Es 200.0;
53 uniaxialMaterial Steel02 [expr $steelTag+1] $fy $Es 0.003 25.0 0.925 0.15
54 0.05 1.0 0.05 1.0 0.0;
55 uniaxialMaterial MinMax [expr $steelTag+2] [expr $steelTag+1] -min -
56 0.05 -max 0.05
57 uniaxialMaterial Fatigue $steelTag [expr $steelTag+2]
58
61 set E 200.0;
63 set Ib [expr 1.0e6*$Ic];
64 set A [expr 1.0e6];
65
66 # Se crean las secciones que conforman el contraventeo.
67 set Contraventeo 1001;
68
69 # Se define la sección del núcleo del contraventeo.
70 set nFibers 6;
71 section fiberSec $Contraventeo {
72 patch rect $steelTag 10 4 -50.00 -50.00 -47.00 50.00
73 patch rect $steelTag 4 10 -47.00 47.00 47.00 50.00
74 patch rect $steelTag 10 4 -50.00 47.00 50.00 50.00
75 patch rect $steelTag 4 10 -47.00 -50.00 47.00 -47.00
76 }
77
78 # Se crea la transformada geométrica.
79 set TransfLin 1;
80 set TransfCor 2;
81
82 geomTransf Linear $TransfLin;
83 geomTransf Corotational $TransfCor;
84
86 set nPC 8;
87
88 # Columna.
89 element elasticBeamColumn 1 1 3 $A $E $Ic $TransfLin;
90 element elasticBeamColumn 2 2 4 $A $E $Ic $TransfLin;
91
92 # Viga.
93 element elasticBeamColumn 3 3 4 $A $E $Ib $TransfLin;
94
95 # Contraventeo convencional.
96 element forceBeamColumn 41 21 22 $nPC $Contraventeo $TransfCor;
97 element forceBeamColumn 42 22 23 $nPC $Contraventeo $TransfCor;
98
100
101 # Se definen los registros del marco.
94

107
108 # Se definen los registros del contraventeo.
109 recorder Node -file $Output/ReactionsDOF1Conts.out -node 21 -dof 1 reaction;
112 recorder Element -xml "$Output/Cont_basicForce.out" -time -ele 41 42
113 basicForce
114 recorder Element -xml "$Output/Cont_basicDef.out" -time -ele 41 42
115 basicDeformation
116
118 set freq [expr [eigen 1]**0.5]
119 set period [expr 2.0*$pi/$freq]
121 set damp 0.02;
123
125 set Factor [expr 10.0]; # El registro de aceleraciones se encuentra en
131
132 timeSeries Path 1 -dt $dt -filePath $AccelDataFile -factor $Factor;
133 pattern UniformExcitation 1 $DirX -accel 1;
134
136 recorder display "Marco con contraventeo convencional" 10 10 500 500 -wipe
137 prp 200. 50. 1;
138 vup 0 1 0;
139 vpn 0 0 1;
140 display 1 5 10
141
143 wipeAnalysis;
145 numberer RCM;
146 system UmfPack;
152
95
11. Análisis dinámico incremental (ADI)

Se muestra una de las principales ventajas que tiene OpenSees: la posibilidad de
realizar una gran cantidad de análisis a la misma estructura con unas pocas líneas de código.
El código que se desarrolla permite al usuario realizar varios análisis dinámicos
incrementales. En este tipo de análisis, una estructura es sometida a múltiples registros
sísmicos; los cuales tienen una intensidad determinada que puede ser incrementada
sucesivamente. Por medio de los incrementos sucesivos de la intensidad sísmica, es posible
trazar, por ejemplo, curvas de fragilidad de una estructura dada. Una curva de fragilidad
muestra la probabilidad que la estructura estudiada tenga una falla en función de la intensidad
sísmica. Se aclara que el código aquí presentado sólo ilustra una manera posible (de varias)
de realizar análisis dinámico incremental (ADI), propuesto originalmengte por Vamvatsikos
y Cornell (Vamvatsikos & Cornell, 2002).

Antes de comenzar con el ciclo for que permitirá realizar el análisis dinámico
incremental es necesario definir una serie de variables relacionadas con el almacenamiento
de resultados, los datos de los registros sísmicos y algunos parámetros de los análisis
dinámicos.
El primer paso es indicar al programa las direcciones de las carpetas que contienen el
modelo a analizar y dónde los datos obtenidos serán almacenados. Esto ocurre entre las líneas
6 a 11.
96
De manera posterior se definen el número de registros y una serie de listas que

contendrán los nombres de los archivos que contienen los registros, sus diferenciales de
tiempo y el número de puntos que contiene cada uno. Dichos valores y listas se definen de la
línea 15 a la 23.
Por último, es necesario definir el número de intensidades a utilizar y dos listas

adicionales, una con los factores de escala que darán lugar a las diferentes intensidades
sísmicas a evaluar y otra con el amortiguamiento que se utilizará para cada intensidad
sísmica. Esto último sólo si se desea variar el amortiguamiento con la intensidad.
Para realizar el análisis dinámico incremental se utilizan dos ciclos for para llamar a
cada uno de los datos de las listas antes mencionadas y así crear las carpetas donde se
guardarán los resultados y realizar los análisis correspondientes. La Figura 11.1 se muestra
el diagrama de flujo del ciclo utilizado en este ejemplo para realizar el análisis dinámico
incremental.
97
i=0
No Si Definir registro i
i <= N registros
Cont = 1
No Si
Cont = 1
No Si
i=i+1 j <= N intensidades
Definir intensidad
y análisis j
Realizar análisis
Terminar
ciclo
Almacenar datos
No Si
j=j+1 ¿Hay fallo? Cont = 0
Figura 11.1 Diagrama de flujo del código utilizado para realizar el análisis dinámico incremental
98
1 #--------------------------------------------------------------------------
2 # Análisis Dinámico Incremental (IDA).
3 # Unidades del modelo: Sin unidades.
4 #--------------------------------------------------------------------------
5
6 set dir "IDA"; # En esta variables se indica la dirección
7 del modelo a analizar. Utilizar "/" para
8 indicar la ruta.
9 set Resultados "Resultados"; # En esta variable se indica la dirección
10 donde se guardaran los resultados.
11 set Carpetas [list "SCT"]; # Lista con los nombres de las carpetas donde
12 se almacenarán los resultados de los
13 análisis, una carpeta por registro sísmico.
14
15 set nRegistros 1; # Se da el número de registros sísmicos a
16 utilizar.
17 set Registros [list "SCT18509.txt"]; # Se crea una lista con los nombres de
18 los archivos de los registros de
19 aceleraciones.
20 set dts [list 0.01]; # Lista con los diferenciales de tiempo de los
21 registros de aceleraciones, respetando el
22 orden dado en la lista files.
23 set nPuntos [list 15000]; # Se crea una lista con el número de puntos
24 que tiene cada registro de aceleraciones.
25
26 set nFactores 10; # Se indica el número de intensidades sísmicas
27 que se considerarán en el análisis.
28 set factores [list 0.25 0.5 0.75 1.0 1.25 1.5 1.75 2.0 2.25 2.5];
29 # Se crea una lista de los factores con los que se escalarán los registros
30 de aceleraciones para obtener las intensidades sísmicas deseadas. Ingresar
31 factores de menor a mayor intensidad sísmica.
32
33 set dampings [list 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.10 0.10];
34 # Se crea una lista con los porcentajes de amortiguamiento que se considerará
35 para cada intensidad sísmica.
36
37 for {set ir 0} {$ir <= [expr $nRegistros-1]} {incr ir} {
38 # Este ciclo "for" llama los datos del registro de aceleraciones empleado en
39 el análisis.
40
41 set AccelDataFile [lindex $Registros $ir];
42 # Se llama al primer registro de aceleraciones y se almacena en la variable
43 "AccelDataFile". Esta variable deberá utilizarse en el archivo del análisis
44 dinámico para indicar qué registro de aceleraciones usar en el análisis.
45 set dt [lindex $dts $ir]; # Se llama el diferencial de tiempo
46 del registro.
47 set Npuntos [lindex $nPuntos $ir]; # Se llama el número de puntos del
48 registro.
49
50 set cont 1; # Esta variable funciona como un fusil, mientras su valor
51 sea igual a 1, OpenSees realizará el análisis dinámico con el registro actual,
99
52 al finalizar incrementará la intensidad sísmica y volverá a analizar el

53 modelo con el mismo registro pero con una mayor intensidad sísmica.
54 # Este ciclo continuará hasta que finalice con todas las intensidades
55 deseadas o el modelo falle durante un análisis, en cuyo caso no será necesario
56 seguir incrementando las intensidades sísmicas.
57
58 for {set jf 0} {$jf <= [expr $nFactores-1]} {incr jf} {
59 # Este ciclo "for" llama los datos correspondientes a la intensidad
60 sísmica empleada en el análisis.
61 if {$cont == 1} {
62 set Carpeta "[lindex $Carpetas $ir]";
63 # Se llama el nombre de la carpeta designada para guardar los resultados
64 obtenidos del registro de aceleraciones actual.
65
66 set Intensidad "[lindex $factores $jf]";
67 # Se crea carpeta cuyo nombre es el mismo al de la intensidad sísmica actual.
68
69 set pgaFactor [lindex $factores $jf];
70 # Se llama el valor para escalar el registro de aceleraciones y obtener la
71 intensidad sísmica deseada en este análisis.
72
73 set damp [lindex $dampings $jf];
74 # Se llama el valor del amortiguamiento correspondiente a la intensidad
75 sísmica empleada en el análisis actual.
76
77 file mkdir $dir/$Resultados/$Carpeta/$Intensidad; # Se crean
78 las carpetas para guardar los resultados obtenidos.
79
80 puts "$dir/$Resultados/$Carpeta/$Intensidad";
81 puts "Modelo: MarcoConcreto";
82 puts "Procesando... ";
83 puts "Secuencia: [lindex $Carpetas $ir]; pgaFactor: [lindex
84 $factores $jf]";
85
86 source E8_MarcoCV.tcl; # Se llama el modelo a analizar.
87
88 set t [getTime];
89 puts "Análisis Dinámico Finalizado. Tiempo: $t";
90 if {$t < [expr 0.9*$dt*$Npuntos]} {
91 set cont 0;
92 # Si el análisis falla durante el análisis, la variable "cont" se redefinirá
93 con un valor igual a 0. Esto finalizará con el primer ciclo "for" y se
94 procederá a analizar el modelo con el siguiente registro de aceleraciones.
95
96 }
97 }
98 }
99 }
101
12. Conclusiones
Los ejemplos mostrados en este libro dan a los lectores los conocimientos básicos
para analizar estructuras por medio del programa OpenSees. Sin embargo, la información
aquí brindada no garantiza un correcto manejo del programa. Como se observó a lo largo de
este libro, la estructura de OpenSees permite a los usuarios poseer un profundo control sobre
los parámetros de los análisis que se realizan. Esta característica es de gran ayuda para los
investigadores, lamentablemente, también representa un inconveniente para los usuarios con
menor experiencia en el área de estructuras. Por lo anterior, se recomienda a los usuarios del
programa estar muy bien informados sobre los procesos mecánicos que toman lugar en la
estructura analizada, de tal manera que puedan tomarlos en cuenta y así garantizar que sus
modelos proporcionan resultados confiables.
103
Referencias
Bell, J. “Viewpoint Projections and Specifications.” Último acceso enero 2019.

https://www.cs.uic.edu/~jbell/CourseNotes/ComputerGraphics/Projections_Viewpoints.
html.
Black, C. J., Makris, N., y Aiken, ID. "Component testing, seismic evaluation and
characterization of buckling-restrained braces." Journal of Structural Engineering - ASCE
130 (2004): 880–894.
California Department of Transportation. “Seismic desing criteria.” Publicaciones técnicas
del estado de California, 2013.
Chopra, A. Dynamics of Structures. Theory and application to earthquake engineering. New
Jersey: Prentice - Hall, 1995.
Guerrero-Bobadilla, H., Ji, T., y Escobar-Sanchez, J. A. "Experimental studies of a steel
frame model with and without buckling-restrained braces." Ingeniería Sísmica 95, 2017,
33-52.
Instituto de Ingeniería. Red Acelerográfica del Instituto de Ingeniería. México: Universidad
Nacional Autónoma de México, 2018.
Mackenna, F. “Object-Oriented Finite Element Programming: Frameworks for Analysis,
Algorithms and Parallel Computing.” PhD diss. Universidad de California, 1997.
Merrit, S., Uang, C-M., y Benzoni, G. Subassemblage testing of Corebrace Buckling-
Restrained Braces. La Jolla, California: University of California, San Diego, 2003.
OpenSees. “Command Manual.” 2019. Último acceso febrero 2019.
http://opensees.berkeley.edu/wiki/index.php/Command_Manual.
Pacific Earthquake Engineering Research Center. “OpenSees Navigator.” 2015. Universidad
de California, Berkeley. Último acceso enero 2019.
http://openseesnavigator.berkeley.edu.
Pacific Earthquake Engineering Research Center. “OpenSees. Open source finite element
platform for earthquake engineering simulations.” 2006. Universidad de California,
Berkeley.Último acceso febrero 2019 http://opensees.berkeley.edu/index.php.
Papanikolaou, V. K,, Kartalis-Kaounis, T., Protopapadaki, V. K., y Papadopoulos, T.
“GiD+OpenSees Interface: An integrated Finite Element Analysis Platform.” 2017.
Aristotle University of Thessaloniki. Último acceso enero del 2019.
http://gidopensees.rclab.civil.auth.gr.
Priestley, R., Mander, J., y Park R. “Theorical stress - strain model for confined concrete.”
Journal of Structural Engineering 114 (1988): 1804-1825.
Shojaie, M. “Cyprees Editor, programme for OpenSees.” 2018. Último acceso enero 2019.
http://cypress.hrshojaie.com/en-us/default.aspx.
Tapia, E., García, J., y Del Rincón, A. “Estudio paramétrico del modelado inelástico de
contravientos de acero.” Ingeniería Sísmica 94 (2016): 49-74.
Teran-Gilmore, A., y Virto, N. "Preliminary design of low-rise buildings stiffened with
buckling restrained braces by a displacement-based approach." Earthquake Spectra 25
(2009): 185-211.
Tremblay, R., Bolduc, P., Neville, R., y DeVall, R. "Seismic testing and performance of
buckling-restrained bracing systems." Canadian Journal of Civil Engineering 33 (2006):
183-198.
Vamvatsikos, D., y Cornell, C. A. "Incremental dynamic analysis." Earthquake Engineering
& Structural Dynamics 31 (2002): 491-514.
View publication stats

Introduccinalanalisisestructuralcon Open Sees

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Introduccinalanalisisestructuralcon Open Sees

Cargado por

Copyright:

Formatos disponibles

See discussions, stats, and author profiles for this publication at: https://www.researchgate.

Introducción al análisis estructural con OpenSees

Book · April 2020

Luis Velasco Hector Guerrero

SEE PROFILE SEE PROFILE

The user has requested enhancement of the downloaded file.

Actualmente hay tres diferentes Series del Instituto de Ingeniería:

SERIE INVESTIGACIÓN Y DESARROLLO

Introducción al análisis estructural con OpenSees

Las Series del Instituto de Ingeniería pueden consultarse gratuitamente

Luis Ivan Velasco Enriquez

Introducción al análisis estructural con OpenSees

SERIE INVESTIGACIÓN Y DESARROLLO

Las Series del Instituto de Ingeniería pueden consultarse gratuitamente

Luis Ivan Velasco Enriquez1

Héctor Guerrero Bobadilla2

Primera edición, Abril de 2020

Instituto de Ingeniería, UNAM

La obra fue editada por el Instituto de Ingeniería, de la Universidad Autónoma de

A Aldo, Diana y Kalef

El objetivo principal de este libro es brindar a estudiantes, académicos y profesionales

Los autores gradecen el apoyo del Instituto de Ingeniería de la Universidad Nacional

Palabras clave: OpenSees, análisis estructural, comportamiento inelástico,

Keywords: OpenSees, structural analysis, inelastic behavior, seismic simulations,

5.2 Descripción del código....................................................................................... 32

En el Capítulo 2 se presenta un ejemplo de modelado y análisis estático de una

En el Capítulo 3 se presenta un ejemplo de determinación de los modos y frecuencias

En el Capítulo 4 se realiza un análisis dinámico lineal de una columna; en donde se

En el Capítulo 5 se realiza un análisis estático no lineal (también conocido como

En el Capítulo 6 se presenta el análisis dinámico no lineal de un marco de concreto

En los capítulos 7, 8 y 9 se presentan análisis dinámicos de un marco equipado con

Finalmente, en el Capítulo 10 se describe una manera de realizar un Análisis

2. OpenSees y lenguaje TCL

2.1 Orígenes de OpenSees

Al ser OpenSees un programa de licencia libre, éste se encuentra en continuo

2.2 Ambiente de OpenSees

ModelBuilder Domain Analysis

Figura 2.1 Ambiente de OpenSees

2.3 Interfaz de OpenSees

Figura 2.2 Interfaz de OpenSees

A pesar de que es posible generar ventanas para la visualización de modelos

2.4 Descarga de OpenSees

2.5 Conocimientos básicos del lenguaje Tcl

Comentarios. Para introducir un comentario en el modelo basta con escribir el

# Este texto es un comentario.

Introducción de texto en la interfaz. Es posible mostrar líneas de texto en la interfaz

# Para usar este comando, la línea de texto debe encontrarse entre

# El texto que se encuentra entre las comillas se guarda en la variable

Almacenar valores numéricos. Como se mencionó antes, el comando set también

# EL valor 2 (flotante) se guarda en la variable a.

Llamar líneas de texto y valores almacenados. Para obtener el contenido de una

puts "La variable a contiene el valor: $a"

Evaluación de expresiones matemáticas. Para evaluar expresiones matemáticas se

# El símbolo ";" le indican al programa que pase a la siguiente línea.

# Es posible evaluar expresiones llamando variables.

# Se puede definir una variable usando el comando set, en este caso se

# Se define un vector en la variable x.

puts "[lindex $x 1]"; # Se llamará el valor el segundo valor (200) del

El comando lappend nos permite agregar un elemento adicional a un vector ya

# Se agrega el valor 175 al vector x.

También es posible llamar valores de un vector previamente definido y guardarlos en

# Se llamará el cuarto valor del vector x, el cual corresponde al número

# for {Var. Control} {Condición} {Incremento (sumar dos al finalizar cada