SD61

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:
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 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.
Introducción al análisis estructural con OpenSees
SERIE INVESTIGACIÓN Y DESARROLLO
Introducción
al análisis estructural
con OpenSees
ISBN: 978-607-30-3085-4
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
SD 61 / 2020
Héctor Guerrero Bobadilla
Serie
Docencia
Publicación arbitrada
SD 61
ABRIL, 2020
Serie
DOCENCIA
Publicación arbitrada
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.
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
continuació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.
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.
Introducción al análisis estructural con OpenSees
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.
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.
INTRODUCCIÓN AL ANÁLISIS
ESTRUCTURAL CON OPENSEES
ISBN: 978-607-30-3085-4
SD 61 / 2020
LUIS IVAN VELASCO ENRIQUEZ
HÉCTOR GUERRERO BOBADILLA
SD-61
ABRIL, 2020
Publicación arbitrada
ISBN 978-607-30-3085-4
INTRODUCCIÓN AL ANÁLISIS
ESTRUCTURAL CON OPENSEES
Luis Ivan Velasco Enriquez1
IIUNAM
[email protected]
Héctor Guerrero Bobadilla2
IIUNAM
[email protected]
Serie Docencia 61
Abril 2020
1
2
Estudiante
Investigador Asociado
Introducción al análisis estructural con OpenSees
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
Héctor Guerrero Bobadilla
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
Héctor Guerrero Bobadilla
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
3.
4.
5.
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
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
Determinación de los modos y frecuencias de un marco de concreto ................... 23
4.1
Descripción del modelo ..................................................................................... 23
4.2
Descripción del código....................................................................................... 24
4.3
Comandos adicionales empleados ...................................................................... 26
Análisis dinámico lineal de una columna ............................................................... 31
5.1
Descripción del modelo ..................................................................................... 31
x
6.
7.
8.
5.2
Descripción del código....................................................................................... 32
5.3
Comandos adicionales empleados ...................................................................... 35
Análisis estático no lineal de un marco conformado por perfiles metálicos ......... 41
6.1
Descripción del modelo ..................................................................................... 41
6.2
Descripción del código....................................................................................... 42
6.3
Comandos adicionales empleados ...................................................................... 46
Análisis dinámico no lineal de un marco de concreto reforzado ........................... 53
7.1
Descripción del modelo ..................................................................................... 53
7.2
Descripción del código....................................................................................... 54
7.3
Comandos adicionales empleados ...................................................................... 58
Análisis dinámico de un marco reforzado con amortiguador viscoso................... 67
8.1
Descripción del modelo ..................................................................................... 67
8.2
Descripción del código....................................................................................... 68
8.3
Comandos adicionales empleados ...................................................................... 72
9. Análisis dinámico de un marco reforzado con un contraventeo restringido al
pandeo ............................................................................................................................ 77
9.1
Descripción del modelo ..................................................................................... 77
9.2
Descripción del código....................................................................................... 79
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.
Domain
ModelBuilder
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
expr
expr
expr
expr
expr
posible evaluar expresiones llamando variables.
$a - 3.0; # Resta.
$a*3.0;
# Multiplicación.
$a/3.0;
# División.
$a**2.0;
# Elevar al cuadrado.
$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.
v
(x,y)
n
u
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
2
8
4
1
6
9
10
5
11
1
6
2
3
4m
3
5
4m
3m
7
7
10 kN
20 kN
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
1
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
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#------------------------------------------------------------------------# Modelado y análisis estático de una armadura.
# Unidades del modelo: [N,m]
#------------------------------------------------------------------------wipe;
model BasicBuilder -ndm 2 -ndf 2;
# Se establecen los nodos del modelo y sus respectivas restricciones.
# Solo se brindan dos coordenadas ya que el modelo es en 2D.(ID nodo, X, Y)
node 1 0.0 0.0
node 2 0.0 3.0
node 3 4.0 0.0
node 4 4.0 3.0
node 5 8.0 0.0
node 6 8.0 3.0
node 7 12.0 0.0
# Se definen los apoyos
# diferentes, dos fijos
# 1 - Grado de libertad
# 0 - Grado de libertad
# (Fx, Fy, M)
fix 1 1 1
fix 3 1 1
fix 5 0 1
de la estructura, observe que existen dos apoyos
en los nodos 1 y 3, y uno móvil en el nodo 5.
restringido.
no restringido.
# Se define el material de los elementos de la armadura.
set TagMaterial 1
uniaxialMaterial Elastic $TagMaterial 200e9
# Se definen los elementos de la armadura.
# Barras del tirante inferior.
# Área del elemento = 0.001 m2 = 10 cm2
element truss 1 1 3 0.001 $TagMaterial
element truss 2 3 5 0.001 $TagMaterial
element truss 3 5 7 0.001 $TagMaterial
# Resto de los elementos de la armadura.
# Área del elemento = 0.0005 m2 = 5 cm2
element truss 4 1 2 0.0005 $TagMaterial
element truss 5 3 4 0.0005 $TagMaterial
element truss 6 5 6 0.0005 $TagMaterial
element truss 7 7 6 0.0005 $TagMaterial
element truss 8 2 4 0.0005 $TagMaterial
element truss 9 4 6 0.0005 $TagMaterial
element truss 10 1 4 0.0005 $TagMaterial
element truss 11 3 6 0.0005 $TagMaterial
22
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
# Se definen las cargas actuantes sobre la armadura.
set timeLinear 1
timeSeries Linear $timeLinear
pattern Plain 1 $timeLinear {
# Carga de aprox 1 ton actuando en X y 2 ton actuando en Y
load 7 10000 -20000
}
# Se define la ventana que permitirá visualizar el modelo.
recorder display "Armadura" 10 10 600 600 -wipe
prp 0 0 50
vup 0 1 0
vpn 0 0 1
display 1 2 10
set ViewScale 5;
# Se definen registros de salida
recorder Node -file SalidaNodo7.txt -time -node 7 -dof 1 2 disp
recorder Element -file SalidaElem3.txt -time -ele 3 basicForces
# Se definen los parámetros del análisis estático.
system BandGeneral
numberer RCM
constraints Plain
test NormDispIncr 1.0e-6 10;
integrator LoadControl 0.1
algorithm Newton
analysis Static
analyze 10
23
4. Determinación de los modos y frecuencias de un
marco de concreto
4.1 Descripción del modelo
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
EIc
6
6
2
EIc
4
2m
3
4m
4
5
2EIc
1
3
1
2EIc
4m
2
8m
Figura 4.1 Esquema del marco analizado en el ejemplo, adaptada de (Chopra, 1995)
24
4.2 Descripción del código
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
y
x
x
Coordenadas
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𝜋
√(𝜔𝑖2 )
(4.1)
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
T1 = 0.266 s
Forma del modo 2
T2 = 0.133 s
Figura 4.3 Modos de vibrar del marco analizado
4.3 Comandos adicionales empleados
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
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#--------------------------------------------------------------------# Modos de marco de cortante.
# Problema tomado del libro Dynamics of Structures de Anil K. Chopra.
# Unidades del modelo: [N,m]
#--------------------------------------------------------------------wipe;
model BasicBuilder -ndm 2 -ndf 3; # Se indican 3 grados de libertad para
cada nodo.
# Se definen valores del modelo.
set m 4500.0;
# Masa actuante en el modelo.
set h 4.0;
# Altura de entrepiso.
set A 0.09;
# Área transversal de la columna.
set Ic 0.000675;
# Inercia de la sección de la columna.
set Iv 10e12;
# Inercia de la sección de la viga. Se asigna un valor
# alto para considerarla rígida.
set E [expr 20e9]; # Módulo de elasticidad del material del elemento.
set NumModos 2;
# Se define el número de modos de vibrar a obtener.
set pi 3.1416;
set carpeta Resultados; # Se define el nombre de la carpeta donde se
guardarán los resultados.
# Se
node
node
node
node
node
node
definen los nodos de la estructura. (ID nodo, X, Y)
1 0.0 0.0
2 [expr 2*$h] 0.0
3 0.0 $h
4 [expr 2*$h] $h
5 0.0 [expr 2*$h]
6 [expr 2*$h] [expr 2*$h]
# Se definen los apoyos de la estructura.
fix 1 1 1 1;
# Las columnas del marco se encuentran empotradas.
fix 2 1 1 1
# Se definen las masas actuantes en los niveles del marco.
# (ID nodo, Masa actuante en X, Masa actuante en Y, Masa actuante alrededor
del eje Z).
mass 3 [expr $m] 0.0 0.0
mass 4 [expr $m] 0.0 0.0
mass 5 [expr $m/2] 0.0 0.0
mass 6 [expr $m/2] 0.0 0.0
# Se define la transformación de coordenadas.
set geomLinear 1
geomTransf Linear $geomLinear
# Se definen los elementos del marco. Se consideran elementos con propiedades
mecánicas generales.
# Elementos columna.
element elasticBeamColumn 1 1 3 $A $E [expr 2*$Ic] $geomLinear
29
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
element elasticBeamColumn 2 3 5 $A $E $Ic
element elasticBeamColumn 3 2 4 $A $E [expr 2*$Ic]
element elasticBeamColumn 4 4 6 $A $E $Ic
$geomLinear
$geomLinear
$geomLinear
# Elementos Viga.
element elasticBeamColumn 5 3 4 $A $E $Iv $geomLinear
element elasticBeamColumn 6 5 6 $A $E $Iv $geomLinear
# Se determinan los eigenvectores y los periodos de la estructura.
# El comando "eigen" brinda los eigen valores del modelo, estos valores se
almacenan en la variable "eigenvalores".
set eigenvalores [eigen $NumModos]
# Se crea el vector "T" el cual almacenara los periodos de la estructura.
set T {}
file mkdir $carpeta;
# Se crea la carpeta donde se
almacenarán los resultados.
set file1 [open $carpeta/Modal.out w]; # Se abre el archivo donde se
almacenarán los resultados.
puts $file1 "Los periodos de la estructura son:";
# Línea del archivo.
puts "Los periodos de la estructura son:";
# Línea de la interfaz
for {set i 0} {$i <= [expr $NumModos - 1]} {incr i} {
# Al vector "T", hasta ahora vacío, se le agregan los periodos de la
estructura por medio del comando lappend.
# El comando lindex llama el valor localizado en la posición $i del vector
"eigenvalores".
set T [lappend T [expr 2*$pi/([lindex $eigenvalores $i]**0.5)]]
puts $file1 "T[expr $i+1]: [lindex $T $i]"
puts "T[expr $i+1]: [lindex $T $i]"
}
close $file1
# El comando nodeEigenvector brinda los valores del vector característico.
# (ID nodo, Vector característico, Grado de libertad)
set f11 [nodeEigenvector 3 1 1]
set f21 [nodeEigenvector 5 1 1]
set f12 [nodeEigenvector 3 2 1]
set f22 [nodeEigenvector 5 2 1]
puts "eigenvector 1: [list [expr {$f11/$f21}] [expr {$f21/$f21}] ]"
puts "eigenvector 2: [list [expr {$f12/$f22}] [expr {$f22/$f22}] ]"
# Se definen las ventanas que permitirán visualizar la estructura deformada.
recorder display "Forma del modo 1" 10 10 350 350 -wipe
prp 5 5 50;
vup 0 1 0;
vpn 0 0 1;
30
103
104
105
106
107
108
109
110
111
viewWindow -6 6 -6 6;
display -1 2 100;
recorder display "Forma del modo 2" 10 360 350 350 -wipe
prp 5 5 50;
vup 0 1 0;
vpn 0 0 1;
viewWindow -6 6 -6 6
display -2 2 100
31
5. Análisis dinámico lineal de una columna
5.1 Descripción del modelo
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
1
Figura 5.1 Esquema de la columna analizada en el ejemplo.
32
5.2 Descripción del código
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.
Desplazamiento, m
35
0.04
0.03
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
5.3 Comandos adicionales empleados
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
test NormDispIncr [Tolerancia] [Máximo número de iteraciones]
integrator Newmark [Gamma] [Beta]
algorithm Newton
analysis Transient
analyze [Pasos totales del análisis] [paso de tiempo]
37
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#--------------------------------------------------------------------# Análisis dinámico lineal de una columna.
# Unidades del modelo [N,m,s]
#--------------------------------------------------------------------wipe;
model BasicBuilder -ndm 2 -ndf 3;
# Se definen valores del modelo.
set h 12.0;
# Altura de la columna.
set m 50000;
# Masa actuante en la estructura.
set A 1.0;
# Área transversal de la columna.
set I 0.0833;
# Inercia de la sección de la columna.
set E 20e9;
# Módulo de elasticidad del material de la columna.
set carpeta ResultadosEx3; # Se define el nombre de la carpeta donde se
guardarán los resultados.
set pi 3.1416
set g 9.81;
# Aceleración de la gravedad.
# Se definen los nodos de la columna.
node 1 0.0 0.0
node 2 0.0 $h -mass $m 0.0 0.0
# Se define el empotramiento de la columna.
fix 1 1 1 1
# Se define la transformación de coordenadas.
set geomLinear 1
geomTransf Linear $geomLinear
# Se define el elemento columna.
element elasticBeamColumn 1 1 2 $A $E $I $geomLinear
# Se definen los registros del análisis.
file mkdir $carpeta;
# Carpeta donde se almacenarán los resultados.
# Desplazamiento del nodo superior.
recorder Node -file $carpeta/DespTop.out -time -node 2 -dof 1 2 3 disp;
# Reacciones de la base.
recorder Node -file $carpeta/ReaccionBase.out -time -node 1 -dof 1 2
3 reaction;
# Distorsión de entrepiso.
recorder Drift -file $carpeta/Drift.out -time -iNode 1 -jNode 2 -dof 1 perpDirn 2 ;
# Fuerzas en la columna.
recorder Element -file $carpeta/SolicitacionesCol.out -time -ele 1 force;
# Se define las cargas actuantes sobre la estructura.
set timeLinear 1
timeSeries Linear $timeLinear
pattern Plain 1 $timeLinear {
38
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
# Fuerza aplicada en nodo 2 = masa actuante por gravedad.
load 2 0.0 [expr -1*$m*$g] 0.0
}
# Se define la ventana que permitirá visualizar el modelo.
recorder display "Columna" 10 10 600 600 -wipe
prp 0 0 50
vup 0 1 0
vpn 0 0 1
display 1 2 10
set ViewScale 5;
# Se definen los parámetros del análisis estático.
system BandGeneral
numberer RCM
constraints Plain
test NormDispIncr 1.0e-6 10;
integrator LoadControl 1.0
algorithm Newton
analysis Static
analyze 10
puts "Análisis estático finalizado."
# Se define los valores para el análisis dinámico.
loadConst -time 0.0
set Factor 0.01;
set
set
set
set
# El registro de aceleraciones se encuentra en
cm/s2, este factor lo convierte a m/s2.
dt 0.01;
# Diferencial de tiempo del acelerograma.
Npuntos 15000;
# Número de puntos del acelerograma.
AccelDataFile "SCT18509.txt"; # Se indica el registro a utilizar.
DirX 1;
# Dirección en la que se aplicarán las aceleraciones.
# Se define el patrón de aceleraciones.
set accelSeries "Series -dt $dt -filePath $AccelDataFile -factor $Factor";
pattern UniformExcitation 2 $DirX -accel $accelSeries
# Se define el amortiguamiento de la estructura.
set freq [expr ([eigen -fullGenLapack 1]**0.5)/(2.0*$pi)]
set dampRatio 0.05
rayleigh 0. 0. 0. [expr 2*$dampRatio/$freq]
puts "Periodo: [expr 1.0/$freq] segundos"
# Se definen los parámetros del análisis estático.
system UmfPack
numberer RCM
constraints Plain
test NormDispIncr 1.0e-8 10
39
103
104
105
106
107
108
integrator Newmark 0.5 0.25
algorithm Newton
analysis Transient
analyze $Npuntos $dt
puts "Análisis Dinámico finalizado."
41
6. Análisis estático no lineal de un marco
conformado por perfiles metálicos
6.1 Descripción del modelo
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
5
43
6
31
32
32
31
3
33
4
21
22
23
22
21
11
12
11
13
350 cm
13
12
700 cm
350 cm
23
2
1
350 cm
33
700 cm
Figura 6.1 Esquema del marco analizado en el ejemplo
6.2 Descripción del código
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
35
OR 35 x 35 x t
41.66
1.09
18.08
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.
nodo
[t]
𝒘𝒍𝟐
𝟏𝟐
[t ∙ cm]
21
-14.42
-420.58
22
-28.84
0.0
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
42
-32.76
0.0
43
-16.37
477.75
Azotea
Entre-pisos
Etiqueta
𝑽=
𝒘𝒍
𝟐
𝑴=
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,
Cortante basal, t
cuáles serían las líneas a ejecutar para un análisis controlado por carga (LoadControl).
40
35
30
25
20
15
10
5
0
0
20
40
60
Desplazamiento nodo superior, cm
80
Figura 6.4 Curva cortante basal – desplazamiento
6.3 Comandos adicionales empleados
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
test NormDispIncr [Tolerancia] [Máximo número de iteraciones]
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
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#------------------------------------------------------------------------# Análisis pushover de un marco compuesto por perfiles metálicos.
# Unidades del modelo: [ton,cm,s]
#------------------------------------------------------------------------wipe;
model BasicBuilder -ndm 2 -ndf 3;
# Introducción de variables.
set E 2038.9;
#
set Li 700.0;
#
set hi 350.0;
#
set carpeta ResultadosEx4; #
# Se
node
node
node
node
node
node
node
node
node
node
node
node
Módulo de elasticidad del acero
Ancho de crujía.
Altura de entrepiso.
Se define el nombre de la carpeta donde se
guardarán los resultados.
definen los nodos de la estructura.
11 0.0 0.0
12 $Li 0.0
13 [expr 2.0*$Li] 0.0
21 0.0 $hi
22 $Li $hi
23 [expr 2*$Li] $hi
31 0.0 [expr 2*$hi]
32 $Li [expr 2*$hi]
33 [expr 2*$Li] [expr 2*$hi]
41 0.0 [expr 3*$hi]
42 $Li [expr 3*$hi]
43 [expr 2*$Li] [expr 3*$hi]
# Se definen los apoyos de la estructura.
fix 11 1 1 1
fix 12 1 1 1
fix 13 1 1 1
# Se simulan diafragmas rígidos por medio de nodos esclavos.
#
NodTag NodTag Dof
equalDOF 21
22
1
equalDOF 22
23
1
equalDOF 31
32
1
equalDOF 32
33
1
equalDOF 41
42
1
equalDOF 42
43
1
# Se definen los materiales del modelo
# Comando
Material Tag Fy
E
b
R0 cR1
cR2 a1
a2
a3
a4
uniaxialMaterial Steel02 3600 2.530 $E 1e-9 20 0.925 0.15 0.0001 0.0001
0.0001 0.0001
uniaxialMaterial Steel02 5000 3.515 $E 1e-9 20 0.925 0.15 0.0001 0.0001
0.0001 0.0001
49
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
# b pendiente curva esfuerzo deformacipón posterior a la fluencia.
# R´s son valores recomendados.
# a parametros de endurecimiento del material posterior a la fluencia,
opcionales.
# Se definen los etiquetas de las secciones.
set OR1 1011
set OR2 1021
set IPE16 1031
# Se definen los elementos de la estructura.
# Columnas OR 35 x 35 x 5/8 Planta Baja
section Fiber $OR1 {
#
Iy
Iz
Jy
Jz
Ky
Kz
Ly
Lz
patch quad 5000 5 5 -14.34 -17.5
14.34 -17.5
14.34 -15.92 -14.34 -15.92
patch quad 5000 5 5 15.92 -14.34 17.5 -14.34 17.5
14.34 15.92 14.34
patch quad 5000 5 5 -14.34 15.92 14.34 15.92 14.34 17.5 -14.34 17.5
patch quad 5000 5 5 -17.5 -14.34 -15.92 -14.34 -15.92 14.34 -17.5
14.34
#
patch
patch
patch
patch
}
circ
circ
circ
circ
5000
5000
5000
5000
CenY
5
5
5
5
CenZ Rint
Rext Start
5
-14.34 -14.34 1.58
5
14.34 -14.34 1.58
5
14.34 14.34 1.58
5
-14.34 14.34 1.58
Ang
3.16
3.16
3.16
3.16
End
180
270
0
90
Ang
270
360
90
180
# Columnas OR 35 x 35 x 1/2 Segundo Nivel.
section Fiber $OR2 {
#
Iy
Iz
Jy
Jz
Ky
Kz
Ly
Lz
patch quad 5000 5 5 16.23 -14.96 17.5 -14.96 17.5
14.96 16.23 14.96
patch quad 5000 5 5 -14.96 -17.5
14.96 -17.5
14.96 -16.23 -14.96 -16.23
patch quad 5000 5 5 -17.5 -14.96 -16.23 -14.96 -16.23 14.96 -17.5
14.96
patch quad 5000 5 5 -14.96 16.23 14.96
16.23 14.96 17.5 -14.96 17.5
#
patch
patch
patch
patch
}
circ
circ
circ
circ
5000
5000
5000
5000
CenY
4
4
4
4
CenZ Rint
Rext
5
-14.96 -14.96
5
14.96 -14.96
5
14.96 14.96
5
-14.96 14.96
Start
1.27
1.27
1.27
1.27
Ang
2.54
2.54
2.54
2.54
# Vigas IR 16 in
section Fiber $IPE16 {
#
Mat Fx Fy X1
Y1
X2
Y2
patch rect 3600 10 4 -9.04
19.01 9.04 20.83
patch rect 3600 2
4 -0.545 -19.01 0.545 19.01
patch rect 3600 10 4 -9.04 -19.01 9.04 -20.83
}
# Se define la transformación geométrica.
set Tcorot 1
End
180
270
0
90
Ang
270
360
90
180
50
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
geomTransf Corotational $Tcorot
# Se definen los elementos columna del primer nivel.
element forceBeamColumn 11 11 21 5 $OR1 $Tcorot
element forceBeamColumn 12 12 22 5 $OR1 $Tcorot
element forceBeamColumn 13 13 23 5 $OR1 $Tcorot
# Se definen los elementos columna del segundo nivel.
element forceBeamColumn 21 21 31 5 $OR2 $Tcorot
element forceBeamColumn 22 22 32 5 $OR2 $Tcorot
element forceBeamColumn 23 23 33 5 $OR2 $Tcorot
# Se definen los elementos columna del tercer nivel.
element forceBeamColumn 31 31 41 5 $OR2 $Tcorot
element forceBeamColumn 32 32 42 5 $OR2 $Tcorot
element forceBeamColumn 33 33 43 5 $OR2 $Tcorot
# Se definen los elementos
element forceBeamColumn 1
element forceBeamColumn 2
element forceBeamColumn 4
element forceBeamColumn 5
element forceBeamColumn 7
element forceBeamColumn 8
viga del marco.
21 22 5 $IPE16 $Tcorot
22 23 5 $IPE16 $Tcorot
31 32 5 $IPE16 $Tcorot
32 33 5 $IPE16 $Tcorot
41 42 5 $IPE16 $Tcorot
42 43 5 $IPE16 $Tcorot
# Se definen las cargas gravitaciones actuantes sobre la estructura
pattern Plain 1 Linear {
load 21 0.0 -3.605 -420.58
load 22 0.0 -7.21 0.0
load 23 0.0 -3.605 420.58
load 31 0.0 -3.605 -420.58
load 32 0.0 -7.21 0.0
load 33 0.0 -3.605 420.58
load 41 0.0 -4.095 -477.75
load 42 0.0 -8.19 0.0
load 43 0.0 -4.095 477.75
}
# Se definen los registros del análisis.
file mkdir $carpeta;
# Se crea la carpeta donde se almacenarán los
resultados.
# Desplazamiento del nodo de control.
recorder Node -file $carpeta/DespTop.out -time -node 41 -dof 1 disp;
# Reacciones en la base.
recorder Node -file $carpeta/ReaccionBase.out -time -node 11 12 13 -dof 1 2
3 reaction;
51
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
# Distorsiones de entrepiso.
recorder Drift -file $carpeta/Drift.out -time -iNode 11 21 31 -jNode 21 31
41 -dof 1 -perpDirn 2;
# Se define la ventana que permitirá visualizar el modelo.
recorder display "Pushover" 10 10 600 600 -wipe
prp 0 0 50
vup 0 1 0
vpn 0 0 1
display 1 2 10
set ViewScale 5;
# Se definen los parámetros del análisis estático.
system UmfPack
numberer RCM
constraints Plain
test NormDispIncr 1.0e-5 10 0;
integrator LoadControl 0.1
algorithm Newton
analysis Static
analyze 10
loadConst -time 0.0
puts "Análisis estático finalizado."
# Se realiza el análisis Pushover.
# Se define el patrón de carga.
pattern Plain 2 Linear {
load 21 0.88 0.0 0.0
load 31 0.88 0.0 0.0
load 41 1.0 0.0 0.0
}
# se define el análisis controlado por deformación
set IDctrlNode 41
set DmaxPush 75.0
set DxPush 0.1
set Nsteps [expr int($DmaxPush/$DxPush)]
constraints Plain;
numberer RCM;
system UmfPack;
test NormDispIncr 1.0e-3 500 0;
algorithm Newton;
integrator DisplacementControl $IDctrlNode 1 $DxPush
analysis Static
analyze $Nsteps;
puts "Análisis Pushover realizado"
52
205
206
207
208
209
210
211
212
213
214
215
216
# set loadSteps 34;
#
#
#
#
#
#
#
#
Debe ser entero para ingresarlo en el comando analyze.
constraints Plain;
numberer RCM;
system UmfPack;
test NormDispIncr 1.0e-3 500 0;
algorithm Newton;
integrator LoadControl 0.1 2 0.1 1;
analysis Static
analyze $loadSteps;
# puts "Análisis Pushover realizado"
53
7. Análisis dinámico no lineal de un marco de
concreto reforzado
7.1 Descripción del modelo
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
30
312
32
322
311
321
331
21
20
222
231
112
122
111
0
131
8m
3.5
m
141
2
1
8m
13
132
121
3.5
m
241
12
11
10
23
232
221
3.5
m
341
22
212
211
33
332
3
8m
Figura 7.1 Esquema del marco analizado en el ejemplo
7.2 Descripción del código
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
COLUMNAS
E#3@15 cm,
12#8
Rec. 6 cm
20
TRABES
E#2@15 cm,
4#8
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.
Desplazamiento, m
0.30
0.20
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
7.3 Comandos adicionales empleados
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
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#
#
#
#
-----------------------------------------------------------------------Análisis dinámico no lineal de un marco de concreto.
Unidades del modelo: [N,m,s]
------------------------------------------------------------------------
wipe;
model BasicBuilder -ndm 2 -ndf 3;
# Se definen valores para crear el modelo.
set Nniveles 3;
set Ncrujias 3;
set L 8.0;
# Ancho de crujía
set H 3.5;
# Altura de entrepiso.
set wa 11000;
# Carga azotea [N/m]
set we 9000;
# Carga entrepiso [N/m]
set hcol 0.30; # Altura columna.
set bcol 0.30; # Base columna.
set hviga 0.30; # Altura viga.
set bviga 0.20; # Base viga.
set carpeta ResultadosEx5; # Se define el nombre de la carpeta donde se
guardarán los resultados.
set g 9.81;
# Aceleración de la gravedad.
set pi 3.1416;
# Se definen las masas de cada nodo.
set ma [expr $wa*$L/$g/2.0]; # Masa nodo exterior azotea.
set me [expr $we*$L/$g/2.0]; # Masa nodo exterior entrepiso.
# Se definen los nodos de la estructura.
for {set i 0} {$i <= $Nniveles} {incr i} {
for {set j 0} {$j <= $Ncrujias} {incr j} {
if {$i == 0} {
node $j [expr $j*$L] 0.0;
} else {
if {$i == $Nniveles} {
if {$j == 0 || $j == $Ncrujias} {
node $i$j [expr $j*$L] [expr $i*$H] -mass
} else {
node $i$j [expr $j*$L] [expr $i*$H] -mass
}
} else {
if {$j == 0 || $j == $Ncrujias} {
node $i$j [expr $j*$L] [expr $i*$H] -mass
} else {
node $i$j [expr $j*$L] [expr $i*$H] -mass
}
}; # Segundo else.
}; # Primer else.
}; # Segundo for.
}; # Primer for.
$ma 0.0 0.0
[expr 2.0*$ma] 0.0 0.0
$me 0.0 0.0
[expr 2.0*$me] 0.0 0.0
61
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
# Se definen los apoyos de la estructura.
fixY 0.0 1 1 1
# Se crean los diafragmas rígidos entre los niveles.
for {set i 1} {$i <= $Nniveles} {incr i 1} {
for {set j 0} {$j <= [expr $Ncrujias-1]} {incr j 1} {
set a [expr $j + 1];
set b 0
equalDOF $i$b $i$a 1
}
}
# Se definen los materiales de las secciones.
# Tags de los materiales.
set AceroTag 1
set cover35 3
set NucCol 4
set NucViga 5
# Se definen las propiedades del acero longitudinal.
set fy [expr 420e6]; # Esfuerzo de fluencia.
set Es [expr 200e9]; # Módulo elástico.
uniaxialMaterial Steel02 [expr $AceroTag+1] $fy $Es 0.025 18.0 0.925 0.15;
uniaxialMaterial MinMax $AceroTag [expr $AceroTag+1] -min -0.05 -max 0.05
# Recubrimiento, concreto no confinado.
set fc [expr 35e6]; # f´c.
set epss 0.005; # Deformación última.
set Ec [expr 14000.*sqrt($fc/9.81*100./1e6)*9.81/100*1e6]; # Módulo elástico
(fórmula de RCDF).
uniaxialMaterial Concrete02 $cover35 -$fc [expr -2.0*$fc/$Ec] 0.0 -$epss 0.1
[expr 0.04*$fc] [expr 0.04*$fc/(2.0*$fc/$Ec)] ; # Concreto sin confinar.
# Concreto Columna.
set fcc1 [expr 37.695e6];
set eu1 [expr 0.024413];
set fcu1 [expr 7.1035e6];
# Máxima resistencia (Mander)
# Deformación última (Mander)
# Resistencia última (Mander)
uniaxialMaterial Concrete02 $NucCol -$fcc1 [expr -2.0*$fcc1/$Ec] -$fcu1 -$eu1 0.1
[expr 0.04*$fcc1] [expr 0.04*$fcc1/(2.0*$fcc1/$Ec)]; #Concreto confinado.
# Concreto Viga.
set fcc2 [expr 35.876e6];
set eu2 [expr 0.020034];
set fcu2 [expr 2.835e6];
# Máxima resistencia (Mander)
# Deformación última (Mander)
# Resistencia última (Mander)
uniaxialMaterial Concrete02 $NucViga -$fcc2 [expr -2.0*$fcc2/$Ec] -$fcu2 -$eu2 0.1
[expr 0.04*$fcc2] [expr 0.04*$fcc2/(2.0*$fcc2/$Ec)]; # Concreto confinado.
# Se definen las secciones de los elementos.
set ColTag 3
set VigTag 4
62
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
# Áreas de las barras longitudinales.
set db8 [expr 8.0*0.0254/8.0];
set barArea8 [expr $db8*$db8*$pi/4.0];
# Dimensiones del núcleo por Mandel y cortante por Caltrans.
set doz [list [expr $bcol/2] [expr $bviga/2]]; # Mitad de las secciones.
set doy [list [expr $hcol/2] [expr $hviga/2]];
set diz [list 0.07839 0.02605];
# Distancia al borde el
concreto confinado.
set diy [list 0.07839 0.07605];
# Capacidad de cortante, modelo de Caltrans.
set Vn
[list 155637.32 79884.06];
set Kst [list 7.296E+08 4.864E+08];
set nFibrasY 8;
set nFibrasZ 8;
set FibraRec 2;
#Elemento columna tag 1.
set dozc [lindex $doz 0];
set doyc [lindex $doy 0];
set dizc [lindex $diz 0];
set diyc [lindex $diy 0];
set Vnc [lindex $Vn 0];
set Kstc [lindex $Kst 0];
set RecC 0.06;
#Recubrimiento de la sección.
section fiberSec 1 {
# Se define el núcleo
-h/2 -b/2 h/2
b/2
patch rect $NucCol $nFibrasY $nFibrasZ -$diyc -$dizc $diyc $dizc
# Se define el recubrimiento.
patch rect $cover35 $nFibrasY
patch rect $cover35 $nFibrasY
patch rect $cover35 $FibraRec
patch rect $cover35 $FibraRec
$FibraRec
$FibraRec
$nFibrasZ
$nFibrasZ
-$doyc -$dozc $doyc -$dizc
-$doyc $dizc $doyc $dozc
-$doyc -$dizc -$diyc $dizc
$diyc -$dizc $doyc $dizc
# Se define el acero longitudinal.
# Refuerzo superior.
set sep1c [expr (2*$doyc-2*$RecC-$db8)/3.0]
fiber [expr $doyc-$RecC-$db8/2.0] [expr
$barArea8 $AceroTag
fiber [expr $doyc-$RecC-$db8/2.0] [expr
$barArea8 $AceroTag
fiber [expr $doyc-$RecC-$db8/2.0] [expr
$barArea8 $AceroTag
fiber [expr $doyc-$RecC-$db8/2.0] [expr
$barArea8 $AceroTag
-$dozc+$RecC+$db8/2.0+0*$sep1c]
-$dozc+$RecC+$db8/2.0+1*$sep1c]
-$dozc+$RecC+$db8/2.0+2*$sep1c]
-$dozc+$RecC+$db8/2.0+3*$sep1c]
63
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
# Refuerzo inferior.
fiber [expr -$doyc+$RecC+$db8/2.0]
$barArea8 $AceroTag
fiber [expr -$doyc+$RecC+$db8/2.0]
$barArea8 $AceroTag
fiber [expr -$doyc+$RecC+$db8/2.0]
$barArea8 $AceroTag
fiber [expr -$doyc+$RecC+$db8/2.0]
$barArea8 $AceroTag
[expr -$dozc+$RecC+$db8/2.0+0*$sep1c]
[expr -$dozc+$RecC+$db8/2.0+1*$sep1c]
[expr -$dozc+$RecC+$db8/2.0+2*$sep1c]
[expr -$dozc+$RecC+$db8/2.0+3*$sep1c]
# Refuerzo lateral.
fiber [expr -$doyc+$RecC+$db8/2.0+1*$sep1c] [expr -$dozc+$RecC+$db8/2.0]
$barArea8 $AceroTag
fiber [expr -$doyc+$RecC+$db8/2.0+1*$sep1c] [expr $dozc-$RecC-$db8/2.0]
$barArea8 $AceroTag
fiber [expr -$doyc+$RecC+$db8/2.0+2*$sep1c] [expr -$dozc+$RecC+$db8/2.0]
$barArea8 $AceroTag
fiber [expr -$doyc+$RecC+$db8/2.0+2*$sep1c] [expr $dozc-$RecC-$db8/2.0]
$barArea8 $AceroTag
}; # Se terminó de definir la sección.
# Elemento viga tag 2.
set dozv [lindex $doz 1];
set doyv [lindex $doy 1];
set dizv [lindex $diz 1];
set diyv [lindex $diy 1];
set Vnv [lindex $Vn 1];
set Kstv [lindex $Kst 1];
set RecV 0.06;
#Recubrimiento de la sección.
section fiberSec 2 {
# Se define el núcleo.
-h/2 -b/2 h/2
b/2
patch rect $NucViga $nFibrasY $nFibrasZ -$diyv -$dizv $diyv $dizv
# Se define el recubrimiento.
patch rect $cover35 $nFibrasY
patch rect $cover35 $nFibrasY
patch rect $cover35 $FibraRec
patch rect $cover35 $FibraRec
$FibraRec
$FibraRec
$nFibrasZ
$nFibrasZ
-$doyv -$dozv $doyv -$dizv
-$doyv $dizv $doyv $dozv
-$doyv -$dizv -$diyv $dizv
$diyv -$dizv $doyv $dizv
# Se define el acero longitudinal
# Refuerzo superior.
set sep1v [expr (2*$dozv-2*$RecV-$db8)]
fiber [expr $doyv-$RecV-$db8/2.0] [expr
$barArea8 $AceroTag
fiber [expr $doyv-$RecV-$db8/2.0] [expr
$barArea8 $AceroTag
# Refuerzo inferior.
set sep2v [expr (2*$dozv-2*$RecV-$db8)]
-$dozv+$RecV+$db8/2.0+0*$sep1v]
-$dozv+$RecV+$db8/2.0+1*$sep1v]
64
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
fiber [expr -$doyv+$RecV+$db8/2.0] [expr -$dozv+$RecV+$db8/2.0+0*$sep2v]
$barArea8 $AceroTag
fiber [expr -$doyv+$RecV+$db8/2.0] [expr -$dozv+$RecV+$db8/2.0+1*$sep2v]
$barArea8 $AceroTag
}; # Se terminó de definir la sección.
# Se define la relación cortante - deformación.
set CortanteCol 6
uniaxialMaterial Steel01 $CortanteCol $Vnc $Kstc 1.0e-3
section Aggregator $ColTag $CortanteCol Vy -section 1
set CortanteVig 7
uniaxialMaterial Steel01 $CortanteVig $Vnv $Kstv 1.0e-3
section Aggregator $VigTag $CortanteVig Vy -section 2
# Se define la transformación geométrica.
set Tcorot 1
geomTransf Corotational $Tcorot
# Se definen los elementos del modelo.
set nPts 5
for {set i 1} {$i <= $Nniveles} {incr i} {
set y [expr $i - 1];
for
set
set
set
set
{set j 1} {$j <= [expr $Ncrujias + 1]} {incr j} {
x [expr $j - 1];
c 1; # Tag columnas $i$j$c.
v 2; # Tag vigas $i$j$v.
t 3;
element forceBeamColumn $i$j$c $y$x $i$x $nPts $ColTag $Tcorot
if {$j <= $Ncrujias} {
element forceBeamColumn $i$j$v $i$x $i$j $nPts $VigTag $Tcorot
}
}; # Segundo for.
}; # Primer for.
# Se define la ventana que permitirá visualizar el modelo.
recorder display "Marco 3 Niveles" 10 10 600 600 -wipe
prp 0 0 50
vup 0 1 0
vpn 0 0 1
display 1 2 10
set ViewScale 5;
# Se determina el periodo fundamental de la estructura.
set eigenvalues [eigen 1];
set T [expr 2*$pi/($eigenvalues**0.5)];
puts "T1 = $T";
65
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
# Se definen las cargas actuantes en la estructura.
set Grav 1
pattern Plain $Grav Linear {
for {set i 1} {$i <= $Nniveles} {incr i} {
for {set j 0} {$j <= $Ncrujias} {incr j} {
if {$i == $Nniveles} {
if {$j == 0 || $j == $Ncrujias} {
if {$j == 0} {
load $i$j 0.0 [expr -$wa*$L/2.0] [expr
} else {
load $i$j 0.0 [expr -$wa*$L/2.0] [expr
}
} else {
load $i$j 0.0 [expr -2*$wa*$L/2.0] 0.0
}
} else {
if {$j == 0 || $j == $Ncrujias} {
if {$j == 0} {
load $i$j 0.0 [expr -$we*$L/2.0] [expr
} else {
load $i$j 0.0 [expr -$we*$L/2.0] [expr
}
} else {
load $i$j 0.0 [expr -2*$we*$L/2.0] 0.0
}
}; # Segundo else.
}; # Segundo for.
}; # Primer for.
}; # Patter.
-$wa*$L**2/12.0]
$wa*$L**2/12.0]
-$we*$L**2/12.0]
$we*$L**2/12.0]
# Se definen los registros.
file mkdir $carpeta; # Se crea la carpeta donde se almacenarán los resultados.
recorder Node -file $carpeta/DespTop.out -time -node 33 -dof 1 disp;
recorder Node -file $carpeta/ReaccionBase.out -time -node 0 1 2 3 -dof 1 2
3 reaction;
recorder Drift -file $carpeta/Drift.out -time -iNode 3 13 23 -jNode 13 23 33
-dof 1 -perpDirn 2 ;
# Se definen los parámetros del análisis estático.
system UmfPack
numberer RCM
constraints Plain
test NormDispIncr 1.0e-5 10 0;
integrator LoadControl 0.1
algorithm Newton
analysis Static
analyze 10
66
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
loadConst -time 0.0
puts "Análisis estático finalizado."
# Se define el amortiguamiento de la estructura.
set freq [expr [eigen 1]**0.5]
set damp 0.02;
rayleigh 0. 0. 0. [expr 2*$damp*$freq]
# Se crea el patrón de aceleraciones.
set Factor 0.03; # Registro de aceleraciones esta en cm/s2, el factor lo
convierte a m/s2 y triplica la intensidad sísmica
set dt 0.01; # Diferencial de tiempo del acelerograma.
set Npuntos 20000; # Número de puntos del acelerograma.
set AccelDataFile "SCT18509.txt"; # Se indica el registro a utilizar.
set DirX 1; # Dirección en la que se aplicarán las aceleraciones.
set accelSeries "Series -dt $dt -filePath $AccelDataFile -factor $Factor";
pattern UniformExcitation 2 $DirX -accel $accelSeries
# Se realiza el análisis dinámico.
system UmfPack
numberer RCM
constraints Plain
test NormDispIncr 1.0e-8 10
integrator Newmark 0.5 0.25
algorithm Newton
analysis Transient
analyze $Npuntos $dt
puts "Análisis Dinámico finalizado."
67
8. Análisis dinámico de un marco reforzado con
amortiguador viscoso
8.1 Descripción del modelo
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
4
1
2
L
Figura 8.1 Esquema del marco analizado en el ejemplo
8.2 Descripción del código
Se comienza a construir el modelo borrando los objetos definidos con anterioridad
por medio del comando wipe, (línea 8). Posteriormente, se indican el número de dimensiones
del modelo y número de grados de libertad por nodo (línea 9).
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𝐸𝐼𝑐
𝐸𝐼𝑐
= 24 3
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𝐸𝐼𝑐
𝐸𝐼𝑐
=6 3
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
ℎ3 12𝜌 + 4
(8.4)
Donde ρ es la relación de rigidez entre la viga y la columna, que se calcula con la
ecuación (8.5):
𝜌=
𝐼𝑏
4𝐼𝑐
(8.5)
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 ρ.
K/( EIc /h 3 )
24
18
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
Fuerza axial, kN
100
50
0
-50
-100
-20
-10
0
10
Desplazamiento, mm
20
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.
Desplazamiento laterla, mm
72
80
60
Sin refuerzo
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.
8.3 Comandos adicionales empleados
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
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#-------------------------------------------------------------------------# Análisis dinámico de un marco reforzado con amortiguador viscoso.
#
# Problema creado por: Sarven Akcelyan & Dimitrios G. Lignos
# Unidades del modelo [KN,mm,s]
#-------------------------------------------------------------------------wipe;
model BasicBuilder -ndm 2 -ndf 3;
# Se crea la carpeta que almacenará los resultados.
set Output ResultadosEx6;
file mkdir $Output;
# Parámetros del marco.
set L 5000.;
# Ancho de crujía.
set h 3000.;
# Altura del marco.
set W 1000.;
# Peso actuante, para definir la masa.
set g 9810.;
# Gravedad en mm/s2.
set m [expr $W/$g];
# Se define la masa actuante.
set Tn 0.7;
# Periodo de la estructura.
set pi [expr acos(-1.0)];
# Propiedades del amortiguador
set Kd 25.;
# Rigidez axial.
set Cd 20.7452;
# Coeficiente de amortiguamiento.
set ad 0.35;
# Exponente a
# Se
node
node
node
node
definen
1
0.
2
$L
3
0.
4
$L
los nodos del modelo.
0. ;
0. ;
$h ;
$h ;
# Se definen las condiciones de apoyo.
fix 1 1 1 1;
fix 2 1 1 1;
# Se restringen los nodos de la viga
equalDOF 3 4 1 ; # GDL .
# Se asignan las masas.
mass 3 [expr 0.5*$m] 0. 0. ;
mass 4 [expr 0.5*$m] 0. 0. ;
# Se definen las propiedades de las columnas y la viga.
set K [expr pow(2*$pi/$Tn,2)*$m];
set E 200.0;
set Ic [expr $K*pow($h,3)/(24*$E)]; # (K=24EIc/h^3)
set Ib [expr 1e12*$Ic];
set A [expr 1e12];
74
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
# Se define el material ViscousDamper
uniaxialMaterial ViscousDamper 1 $Kd $Cd $ad
# Se crea la transformada geometrica.
set TransfTag 1;
geomTransf Linear $TransfTag;
# Se definen los elementos.
# Columna
element elasticBeamColumn 1 1 3 $A $E $Ic $TransfTag;
element elasticBeamColumn 2 2 4 $A $E $Ic $TransfTag;
# Viga
element elasticBeamColumn 3 3 4 $A $E $Ib $TransfTag;
# Amortiguador
#element twoNodeLink $eleTag $iNode $jNode -mat $matTags -dir $dirs
element twoNodeLink
4
1
4
-mat
1
-dir 1
puts "Modelo construido"
# Se definen los registros del modelo
recorder Node -file $Output/Disp.out -time -node 4 -dof 1 disp;
recorder Node -file $Output/Acc.out -time -node 4 -dof 1 accel;
recorder Node -file $Output/Base.out -time -node 1 2 -dof 1 reaction;
recorder Node -file $Output/NBase.out -time -node 1 2 -dof 2 reaction;
recorder
recorder
recorder
recorder
Element
Element
Element
Element
-file $Output/Damperdisp.out -time -ele 4 deformations ;
-file $Output/Damperforce.out -time -ele 4 localForce ;
-file $Output/Dampergbforce.out -time -ele 4 -dof 1 force;
-file $Output/Frameforce.out -time -ele 1 2 -dof 1 force;
# Se define el amortiguamiento de la estructura.
set freq [expr ([eigen -fullGenLapack 1])**0.5]
set period [expr 2*$pi/$freq]
puts "T = $period"
set damp 0.02;
rayleigh [expr 2*$damp*$freq] 0. 0. 0.
# Se crea el patrón de aceleraciones.
set Factor 10.0;
# El registro de aceleraciones se encuentra en
cm/s2, este factor lo convierte a mm/s2.
set dt 0.01;
# Diferencial de tiempo del acelerograma.
set Npuntos 15000;
# Número de puntos del acelerograma.
set AccelDataFile "SCT18509.txt"; # Se indica el registro a utilizar.
set DirX 1;
# Dirección en la que se aplicarán las aceleraciones.
set accelSeries "Series -dt $dt -filePath $AccelDataFile -factor $Factor";
pattern UniformExcitation 1 $DirX -accel $accelSeries
# Se define la ventana que permitirá visualizar el modelo.
recorder display "Marco con VD" 10 10 500 500 -wipe
75
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
prp 200. 50. 1;
vup 0 1 0;
vpn 0 0 1;
display 1 5 40
# Se crea el análisis dinámico.
wipeAnalysis;
constraints Transformation;
numberer RCM;
system UmfPack;
test EnergyIncr 1.0e-10 100;
algorithm KrylovNewton;
integrator Newmark 0.5 0.25 ;
analysis Transient;
analyze $Npuntos $dt;
puts "Análisis dinámico finalizado"
77
9. Análisis dinámico de un marco reforzado con un
contraventeo restringido al pandeo
9.1 Descripción del modelo
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), (TeranGilmore & 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
Núcleo con compor(A = 4 Anúcleo )
B tamiento inelástico
Carcasa rellena
de mortero
Carcasa
Núcleo
Mortero
Material
antiadherente
B’
L/3
L/3
Corte B – B´
L/3
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
1
21
42
22
h
2
41
2
L
Figura 9.2 Esquema del marco analizado en el ejemplo
79
9.2 Descripción del código
Se comienza a construir el modelo borrando los objetos definidos con anterioridad
por medio del comando wipe (línea 8). Posteriormente, se indican el número de dimensiones
del modelo y número de grados de libertad por nodo (línea 9).
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.
Entre las líneas 31 a 48 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. 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.
Desplazamiento lateral, mm
80
Sin refuerzo
Con refuerzo
60
40
20
0
-20
-40
-60
-80
0
20
40
60
Tiempo, s
80
100
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.
Fuerza axial, kN
81
40
30
20
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
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#-------------------------------------------------------------------------# Análisis dinámico de un marco reforzado con contraventeo restringido al pandeo.
#
# Ejemplo basado en el problema creado por Sarven Akcelyan & Dimitrios G. Lignos.
# Unidades del modelo [KN,mm,s]
#--------------------------------------------------------------------------
wipe;
model BasicBuilder -ndm 2 -ndf 3;
# Se crea la carpeta que almacenará los resultados.
set Output ResultadosEx7;
file mkdir $Output;
# Parámetros del marco.
set L 5000.;
#
set h 3000.;
#
set W 1000.;
#
set g 9810.;
#
set m [expr $W/$g];
#
set Tn 0.7;
#
set pi [expr acos(-1.0)];
Ancho de crujía.
Altura del marco.
Peso actuante, para definir la masa.
Gravedad en mm/s2.
Se define la masa actuante.
Periodo de la estructura.
# Propiedades del contraventeo restringido.
set Lratio [expr 1.0/3.0];
# Relación longitud núcleo / longitud total del
disipador < 1.0
set Aratio 0.25;
# Relación área del núcleo / área conexiones
set fa [expr 1.0];
# Área del núcleo del disipador, en cm2.
# Se
node
node
node
node
definen
1
0.
2
$L
3
0.
4
$L
los nodos del modelo.
0. ;
0. ;
$h -mass [expr 0.5*$m] 0. 0. ;
$h -mass [expr 0.5*$m] 0. 0. ;
# Se definen las condiciones de apoyo.
fix 1 1 1 1;
fix 2 1 1 1;
# Se
node
node
node
node
definen los nodos del contraventeo restringido.
21 0.0 0.0
22 [expr $L*(1-$Lratio)/2.0] [expr $h*(1-$Lratio)/2.0]
23 [expr $L*(1+$Lratio)/2.0] [expr $h*(1+$Lratio)/2.0]
24 $L $h
# Se crea una articulación en los nodos que conectan con el marco.
equalDOF 1 21 1 2;
equalDOF 4 24 1 2;
# Se define el material del disipador.
set steelTagBRBs 1000
83
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
set fyBRB 0.25;
set EsBRB 200.0;
uniaxialMaterial Steel02
[expr $steelTagBRBs+1] $fyBRB $EsBRB 0.02 25.0
0.925 0.15 0.05 1.0 0.05 1.0 0.0;
uniaxialMaterial MinMax
$steelTagBRBs [expr $steelTagBRBs+1] -min 0.20 -max 0.20
# Se definen las propiedades de las columnas y la viga.
set K [expr pow(2*$pi/$Tn,2)*$m];
set E 200.0;
set Ic [expr $K*pow($h,3)/(24*$E)]; # (K=24EIc/h^3)
set Ib [expr 1e12*$Ic];
set A [expr 1e12];
# Se crean las secciones que conforman el disipador.
set BRBsec 1001;
set BRBend 1002;
set
set
set
set
secFactorBRB [expr $fa*(1e2)];
secFactorEND [expr (1.0/$Aratio)*$fa*(1e2)];
by [expr ($secFactorBRB)**0.5];
byEND [expr ($secFactorEND)**0.5];
# Área del núcleo en mm2.
# Áreas conexiones en mm2.
# Se define la sección del núcleo del disipador.
set nFibers 6;
section fiberSec $BRBsec {
patch rect $steelTagBRBs $nFibers $nFibers [expr -1.*$by/2.] [expr 1.*$by/2.] [expr $by/2.] [expr $by/2.]
}
# Se define la sección de las conexiones del disipador.
section fiberSec $BRBend {
patch rect $steelTagBRBs $nFibers $nFibers [expr -1.*$byEND/2.] [expr 1.*$byEND/2.] [expr $byEND/2.] [expr $byEND/2.]
}
# Se crea la transformada geométrica.
set TransfTag 1;
geomTransf Linear $TransfTag ;
# Se definen los elementos.
set nIP 3;
# Columna.
element elasticBeamColumn 1 1 3 $A $E $Ic $TransfTag;
element elasticBeamColumn 2 2 4 $A $E $Ic $TransfTag;
# Viga.
element elasticBeamColumn 3 3 4 $A $E $Ib $TransfTag;
84
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
# Contraventeo restringido.
element forceBeamColumn 41 21 22 $nIP $BRBend $TransfTag
element forceBeamColumn 42 22 23 $nIP $BRBsec $TransfTag
element forceBeamColumn 43 23 24 $nIP $BRBend $TransfTag
puts "Modelo construido"
# Se definen los registros del marco.
recorder Node -file $Output/Disp.out -time -node 4 -dof 1 disp;
recorder Node -file $Output/Acc.out -time -node 4 -dof 1 accel;
recorder Node -file $Output/Base.out -time -node 1 2 -dof 1 reaction;
recorder Node -file $Output/NBase.out -time -node 1 2 -dof 2 reaction;
recorder Element -file $Output/Frameforce.out -time -ele 1 2 -dof 1 force;
# Se definen los registros del contraventeo restringido al pandeo.
recorder Node -file $Output/ReactionsDOF1BRBs.out -node 21 -dof 1 reaction;
recorder Node -file $Output/ReactionsDOF2BRBs.out -node 21 -dof 2 reaction;
recorder Node -file $Output/ReactionsDOF3BRBs.out -node 21 -dof 3 reaction;
recorder Element -xml "$Output/BRB_basicForce.out" -time -ele 41 42 43
basicForce
recorder Element -xml "$Output/BRB_basicDef.out" -time -ele 41 42 43
basicDeformation
# Se define el amortiguamiento de la estructura.
set freq [expr [eigen -fullGenLapack 1]**0.5]
set period [expr 2*$pi/$freq]
puts "T = $period"
set damp 0.02;
rayleigh 0. 0. 0. [expr 2*$damp*$freq]
# Se crea el patrón de aceleraciones.
set Factor 10;
# El registro de aceleraciones se encuentra en
cm/s2, este factor lo convierte a mm/s2.
set dt 0.01;
# Diferencial de tiempo del acelerograma.
set Npuntos 15000;
# Número de puntos del acelerograma.
set AccelDataFile "SCT18509.txt"; # Se indica el registro a utilizar.
set DirX 1;
# Dirección en la que se aplicarán las aceleraciones.
timeSeries Path 1 -dt $dt -filePath $AccelDataFile -factor $Factor;
pattern UniformExcitation 1 $DirX -accel 1;
# Se define la ventana que permitirá visualizar el modelo.
recorder display "Marco con contraventeo restringido" 10 10 500 500 -wipe
prp 200. 50. 1;
vup 0 1 0;
vpn 0 0 1;
display 1 5 40
# Se crea el análisis dinámico.
wipeAnalysis;
constraints Transformation;
85
154
155
156
157
158
159
160
161
162
numberer RCM;
system UmfPack;
test EnergyIncr 1.0e-10 100;
algorithm KrylovNewton;
integrator Newmark 0.5 0.25 ;
analysis Transient;
analyze $Npuntos $dt;
puts "Análisis dinámico finalizado"
87
10. Análisis dinámico de un marco reforzado
con un contraventeo convencional
10.1 Descripción del modelo
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
42
23
22
21
h
2
1
41
1
2
L
Figura 10.1 Esquema del marco analizado en el ejemplo
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).
10.2 Descripción del código
Se comienza a construir el modelo borrando los objetos definidos con anterioridad
por medio del comando wipe (línea 8). Posteriormente se indican el número de dimensiones
del modelo y número de grados de libertad por nodo (línea 9).
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.
Entre las líneas 31 a 47 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. 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
100
100
22
β
α
Lc
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.
Desplazamiento laterla, mm
400
Sin refuerzo
Con refuerzo
300
200
100
0
-100
-200
-300
-400
0
20
40
60
Tiempo, s
80
100
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
Fuerza axial, kN
400
300
200
100
0
-100
-100
-50
0
50
Desplazamiento, mm
100
Figura 10.4 Respuesta del contraventeo convencional
10.3 Comandos adicionales empleados
Materiales:
- uniaxialMaterial Fatigue [Etiqueta material] [Etiqueta material existente]
92
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#-------------------------------------------------------------------------# Análisis dinámico de un marco reforzado con un contraventeo convencional.
#
# Ejemplo basado en el problema creado por Sarven Akcelyan & Dimitrios G. Lignos.
# Unidades del modelo [KN,mm,s]
#-------------------------------------------------------------------------wipe;
model BasicBuilder -ndm 2 -ndf 3;
# Se crea la carpeta que almacenará los resultados.
set Output ResultadosEx8;
file mkdir $Output;
# Parámetros del marco.
set L 5000.;
#
set h 3000.;
#
set W 10000.;
#
set g 9810.;
#
set m [expr $W/$g];
#
set Tn 2.0;
#
set pi [expr acos(-1.0)];
Ancho de crujía.
Altura del marco.
Peso actuante, para definir la masa.
Gravedad en mm/s2.
Se define la masa actuante.
Periodo de la estructura.
# Propiedades del contraventeo convencional.
set Lc [expr ($L**2+$h**2)**0.5];
# Longitud contraventeo convencional.
set alfa [expr atan($h/$L)];
# Ángulo de la diagonal.
set beta [expr $pi/2.0 - $alfa];
# Ángulo complementario.
set pandeo [expr 0.008*$Lc];
# Pandeo inicial.
# Se
node
node
node
node
definen
1
0.
2
$L
3
0.
4
$L
los nodos del modelo.
0. ;
0. ;
$h -mass [expr 0.5*$m] 0.01 0. ;
$h -mass [expr 0.5*$m] 0.01 0. ;
# Se definen las condiciones de apoyo.
fix 1 1 1 1;
fix 2 1 1 1;
# Se
node
node
node
definen los nodos del contraventeo convencional.
21 0.0 0.0
22 [expr $L/2.0-$pandeo*cos($beta)] [expr $h/2.0+$pandeo*sin($beta)]
23 $L $h
# Se crea una articulación en los nodos que conectan con el marco.
equalDOF 1 21 1 2;
equalDOF 4 23 1 2;
# Se define el material del contraventeo.
set steelTag 1000
set fy 0.345;
93
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
set Es 200.0;
uniaxialMaterial Steel02
[expr $steelTag+1] $fy $Es 0.003 25.0 0.925 0.15
0.05 1.0 0.05 1.0 0.0;
uniaxialMaterial MinMax
[expr $steelTag+2] [expr $steelTag+1] -min 0.05 -max 0.05
uniaxialMaterial Fatigue $steelTag [expr $steelTag+2]
# Se definen las propiedades de las columnas y la viga.
set K [expr pow(2*$pi/$Tn,2)*$m];
set E 200.0;
set Ic [expr $K*pow($h,3)/(24*$E)]; # (K=24EIc/h^3)
set Ib [expr 1.0e6*$Ic];
set A [expr 1.0e6];
# Se crean las secciones que conforman el contraventeo.
set Contraventeo 1001;
# Se define la sección del núcleo del contraventeo.
set nFibers 6;
section fiberSec $Contraventeo {
patch
rect
$steelTag
10 4
-50.00 -50.00
patch
rect
$steelTag
4
10 -47.00 47.00
patch
rect
$steelTag
10 4
-50.00 47.00
patch
rect
$steelTag
4
10 -47.00 -50.00
}
-47.00
47.00
50.00
47.00
50.00
50.00
50.00
-47.00
# Se crea la transformada geométrica.
set TransfLin 1;
set TransfCor 2;
geomTransf Linear $TransfLin;
geomTransf Corotational $TransfCor;
# Se definen los elementos.
set nPC 8;
# Columna.
element elasticBeamColumn 1 1 3 $A $E $Ic $TransfLin;
element elasticBeamColumn 2 2 4 $A $E $Ic $TransfLin;
# Viga.
element elasticBeamColumn 3 3 4 $A $E $Ib $TransfLin;
# Contraventeo convencional.
element forceBeamColumn 41 21 22 $nPC $Contraventeo $TransfCor;
element forceBeamColumn 42 22 23 $nPC $Contraventeo $TransfCor;
puts "Modelo construido"
# Se definen los registros del marco.
recorder Node -file $Output/Disp.out -time -node 4 -dof 1
disp;
94
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
recorder
recorder
recorder
recorder
Node -file $Output/Acc.out -time -node 4 -dof 1 accel;
Node -file $Output/Base.out -time -node 1 2 -dof 1 reaction;
Node -file $Output/NBase.out -time -node 1 2 -dof 2 reaction;
Element -file $Output/Frameforce.out -time -ele 1 2 -dof 1 force;
# Se definen los registros del contraventeo.
recorder Node -file $Output/ReactionsDOF1Conts.out -node 21 -dof 1 reaction;
recorder Node -file $Output/ReactionsDOF2Conts.out -node 21 -dof 2 reaction;
recorder Node -file $Output/ReactionsDOF3Conts.out -node 21 -dof 3 reaction;
recorder Element -xml "$Output/Cont_basicForce.out" -time -ele 41 42
basicForce
recorder Element -xml "$Output/Cont_basicDef.out" -time -ele 41 42
basicDeformation
# Se define el amortiguamiento de la estructura.
set freq [expr [eigen 1]**0.5]
set period [expr 2.0*$pi/$freq]
puts "T = $period"
set damp 0.02;
rayleigh 0. 0. 0. [expr 2*$damp*$freq]
# Se crea el patrón de aceleraciones.
set Factor [expr 10.0]; # El registro de aceleraciones se encuentra en
cm/s2, este factor lo convierte a mm/s2.
set dt 0.01;
# Diferencial de tiempo del acelerograma.
set Npuntos 15000;
# Número de puntos del acelerograma.
set AccelDataFile "SCT18509.txt"; # Se indica el registro a utilizar.
set DirX 1;
# Dirección en la que se aplicarán las aceleraciones.
timeSeries Path 1 -dt $dt -filePath $AccelDataFile -factor $Factor;
pattern UniformExcitation 1 $DirX -accel 1;
# Se define la ventana que permitirá visualizar el modelo.
recorder display "Marco con contraventeo convencional" 10 10 500 500 -wipe
prp 200. 50. 1;
vup 0 1 0;
vpn 0 0 1;
display 1 5 10
# Se crea el análisis dinámico.
wipeAnalysis;
constraints Transformation;
numberer RCM;
system UmfPack;
test EnergyIncr 1.0e-10 100;
algorithm KrylovNewton;
integrator Newmark 0.5 0.25 ;
analysis Transient;
analyze $Npuntos $dt;
puts "Análisis dinámico finalizado"
95
11.
Análisis dinámico incremental (ADI)
11.1 Descripción del modelo
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).
11.2 Descripción del código
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
i <= N registros
No
Si
Definir registro i
Cont = 1
Si
Cont = 1
No
i=i+1
Si
j <= N intensidades
Definir intensidad
y análisis j
Realizar análisis
Terminar
ciclo
Almacenar datos
j=j+1
No
¿Hay fallo?
Si
Cont = 0
Figura 11.1 Diagrama de flujo del código utilizado para realizar el análisis dinámico incremental
98
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#-------------------------------------------------------------------------# Análisis Dinámico Incremental (IDA).
# Unidades del modelo: Sin unidades.
#-------------------------------------------------------------------------set dir "IDA";
set Resultados "Resultados";
set Carpetas [list "SCT"];
# En esta variables se indica la dirección
del modelo a analizar. Utilizar "/" para
indicar la ruta.
# En esta variable se indica la dirección
donde se guardaran los resultados.
# Lista con los nombres de las carpetas donde
se almacenarán los resultados de los
análisis, una carpeta por registro sísmico.
set nRegistros 1;
# Se da el número de registros sísmicos a
utilizar.
set Registros [list "SCT18509.txt"]; # Se crea una lista con los nombres de
los archivos de los registros de
aceleraciones.
set dts [list 0.01];
# Lista con los diferenciales de tiempo de los
registros de aceleraciones, respetando el
orden dado en la lista files.
set nPuntos [list 15000];
# Se crea una lista con el número de puntos
que tiene cada registro de aceleraciones.
set nFactores 10;
# Se indica el número de intensidades sísmicas
que se considerarán en el análisis.
set factores [list 0.25 0.5 0.75 1.0 1.25 1.5 1.75 2.0 2.25 2.5];
# Se crea una lista de los factores con los que se escalarán los registros
de aceleraciones para obtener las intensidades sísmicas deseadas. Ingresar
factores de menor a mayor intensidad sísmica.
set dampings [list 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.10 0.10];
# Se crea una lista con los porcentajes de amortiguamiento que se considerará
para cada intensidad sísmica.
for {set ir 0} {$ir <= [expr $nRegistros-1]} {incr ir} {
# Este ciclo "for" llama los datos del registro de aceleraciones empleado en
el análisis.
set AccelDataFile [lindex $Registros $ir];
# Se llama al primer registro de aceleraciones y se almacena en la variable
"AccelDataFile". Esta variable deberá utilizarse en el archivo del análisis
dinámico para indicar qué registro de aceleraciones usar en el análisis.
set dt [lindex $dts $ir];
# Se llama el diferencial de tiempo
del registro.
set Npuntos [lindex $nPuntos $ir];
# Se llama el número de puntos del
registro.
set cont 1; # Esta variable funciona como un fusil, mientras su valor
sea igual a 1, OpenSees realizará el análisis dinámico con el registro actual,
99
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
al finalizar incrementará la intensidad sísmica y volverá a analizar el
modelo con el mismo registro pero con una mayor intensidad sísmica.
# Este ciclo continuará hasta que finalice con todas las intensidades
deseadas o el modelo falle durante un análisis, en cuyo caso no será necesario
seguir incrementando las intensidades sísmicas.
for {set jf 0} {$jf <= [expr $nFactores-1]} {incr jf} {
# Este ciclo "for" llama los datos correspondientes a la intensidad
sísmica empleada en el análisis.
if {$cont == 1} {
set Carpeta "[lindex $Carpetas $ir]";
# Se llama el nombre de la carpeta designada para guardar los resultados
obtenidos del registro de aceleraciones actual.
set Intensidad "[lindex $factores $jf]";
# Se crea carpeta cuyo nombre es el mismo al de la intensidad sísmica actual.
set pgaFactor [lindex $factores $jf];
# Se llama el valor para escalar el registro de aceleraciones y obtener la
intensidad sísmica deseada en este análisis.
set damp [lindex $dampings $jf];
# Se llama el valor del amortiguamiento correspondiente a la intensidad
sísmica empleada en el análisis actual.
file mkdir $dir/$Resultados/$Carpeta/$Intensidad;
las carpetas para guardar los resultados obtenidos.
puts
puts
puts
puts
$factores $jf]";
# Se crean
"$dir/$Resultados/$Carpeta/$Intensidad";
"Modelo: MarcoConcreto";
"Procesando... ";
"Secuencia: [lindex $Carpetas $ir]; pgaFactor: [lindex
source E8_MarcoCV.tcl;
# Se llama el modelo a analizar.
set t [getTime];
puts "Análisis Dinámico Finalizado. Tiempo: $t";
if {$t < [expr 0.9*$dt*$Npuntos]} {
set cont 0;
# Si el análisis falla durante el análisis, la variable "cont" se redefinirá
con un valor igual a 0. Esto finalizará con el primer ciclo "for" y se
procederá a analizar el modelo con el siguiente registro de aceleraciones.
}
}
}
}
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 BucklingRestrained Braces. La Jolla, California: University of California, San Diego, 2003.
OpenSees.
“Command
Manual.”
2019.
Último
acceso
http://opensees.berkeley.edu/wiki/index.php/Command_Manual.
febrero
2019.
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.