OPEN SEES - Manejo - Edy Galvis

PONTIFICIA UNIVERSIDAD JAVERIANA
PROYECTO ESPECIAL
USO DEL PROGRAMA OPEN SEES
ING. JESUS VILLALBA
EDY JOSE GALVIS CAMPILLO
BOGOTÁ D.C.
27 De Mayo De 2014
1
TABLA DE CONTENIDO
1. DESCARGA ........................................................................................................... 3
2. INSTALACION...................................................................................................... 4
3. MANEJO DEL PROGRAMA ................................................................................. 5
3.1. INTERACTIVO ....................................................................................................... 5
3.2. EJECUTAR ARCHIVO DE ENTRADA EN EL INDICADOR OPENSEES ............ 5
4. ALGUNOS COMANDOS DE ENTRADA............................................................... 5
4.1. CREACIÓN DEL MODELO ................................................................................... 5
4.2. NODOS .................................................................................................................... 5
4.3. MATERIALES ......................................................................................................... 7
4.4. SECCIONES .......................................................................................................... 10
4.5. ELEMENTOS ........................................................................................................ 11
4.6. GRABADORES...................................................................................................... 12
4.7. CARGAS ................................................................................................................ 12
4.7.1. PATRONES DE CARGA .................................................................................................... 12
4.7.2. ANÁLISIS Y DEFINICIÓN DE FUNCIONES ................................................................. 13
4.7.3. EJECUCIÓN DE ANÁLISIS .............................................................................................. 14
4.7.4. CARGAS LATERALES ...................................................................................................... 15
5. EJEMPLOS ......................................................................................................... 16
5.1. EJEMPLO 1 ........................................................................................................... 16
5.2. EJEMPLO 2 ........................................................................................................... 19
5.3. EJEMPLO 3 ........................................................................................................... 26
5.4. EJEMPLO 4 ........................................................................................................... 31
6. REFERENCIAS................................................................................................... 34
2
OPEN SEES
1. DESCARGA
Para descargar e instalar OpenSees se requiere que el usuario descargue tanto los OpenSees
y paquetes Tcl / Tk. Los OpenSees y paquetes Tcl / Tk ambos pueden ser descargados de los
OpenSees binarios página del http://opensees.berkeley.edu, allí encontraras el enlace
Download, al dar clic te llevara a la siguiente pagina
Imagen 1: Registro o ingreso a la opción de descarga de Open Sees
Si no estás registrado, lo puedes hacer totalmente gratis dando clic en registration.

Sigues las indicaciones y al final confirmas que tu usuario este registrado. Ingresas tu correo
electrónico, con el cual te registraste, en el campo disponible y encontrara los siguientes
enlaces:
3
Imagen 2: Opciones de descarga de Open Sees
Debe descargar tanto el OpenSees2.4.3.exe como el archivo tcl/tk 8.5.14 según la versión de
su ordenador.
2. INSTALACION
El primer paso es instalar el Tcl/Tk, hacer es doble clic en su icono y seguir las instrucciones.
Cuando pregunte al usuario la ruta de instalación, se debe cambiar C:\tcl la cual aparece por
defecto por C:\Program Files\Tcl ya que esa es la recomendación directa de la página
http://opensees.berkeley.edu
Luego de haber instalado el Tcl/Tk, basta con abrir el ejecutable de Open Sees y se podrá
empezar a trabajar.
4
3. MANEJO DEL PROGRAMA
Existen diferentes formas para el manejo del programa.

3.1. INTERACTIVO
Los comandos se pueden introducir directamente en la pantalla que aparece al iniciar el

Programa OpenSees.
3.2. EJECUTAR ARCHIVO DE ENTRADA EN EL INDICADOR OPENSEES
Este método es el más comúnmente utilizado. Un archivo externo que contiene los comandos
de entrada se puede invocar en el programa (inputFile.tcl) y se ejecutará en OpenSees usando
el comando source.
4. ALGUNOS COMANDOS DE ENTRADA
4.1. CREACIÓN DEL MODELO
Comando [wipe].- Este comando es usado para limpiar la memoria antes de empezar a
generar un nuevo modelo. Es una práctica correcta colocarlo al inicio de cada aplicación.
Comando [set].- Este comando es usado para asignar un valor a una variable. Por ejemplo,
si se quiere asignar el valor de 5 a la variable “altura”, se debe escribir: set altura 5
Comando [expr].- Este comando es usado para evaluar una expresión aritmética. Por
ejemplo, si se quiere sumar la variable altura más 2, se debe escribir: expr $altura + 2
Comando [Basic Model Builder]. - Hasta la fecha, sólo hay un generador de modelos
disponibles, constructor modelo básico. El modelo de constructor define el número de
dimensiones (NDM) y grados de libertad por nodo (NDF):
model BasicBuilder -ndm $ndm <-ndf $ndf>

Para un problema de 2-D, se necesita realmente solamente tres grados de libertad en cada
nodo, las dos traducciones en el plano y la rotación sobre el plano de la normalidad:
model basic -ndm 2 -ndf 3
4.2. NODOS
En este punto, se debe decidir qué unidades se utilizarán, ya que Open Sees no las define, en
todo momento el usuario del programa debe verificar que los datos ingresados al programa
estén en las unidades en las cuales se desea trabajar. Para cada uno de los nodos se le debe
5
asignar un número, al igual que a los elementos, de esta forma Open Sees reconocerá el
modelo en general.
Un ejemplo de la asignación de números de nodo y elemento se define en la siguiente figura:
Figura 1: Pórtico simple con nodos y elementos enumerados1
Comando [node] - Este comando es usado para construir un nudo. Este asigna las
coordenadas y las masas al nudo. En un problema 2D sólo las coordenadas x e y deben ser
definidos con el comando node.
node $nodeTag (ndm $coords) <-mass (ndf $MassValues)>

Donde:
$nodeTag: etiqueta que identifica al nudo
$coords: coordenadas nodales
$MassValues: masas nodales correspondientes a cada GDL (opcional)
Para el caso de la figura anterior si suponemos una altura de 4 metros y una luz de 5 metros,
la asignación se haría de la siguiente manera:
node 1 0 0
node 2 5 0
node 3 0 4
node 4 5 4
1
Imagen Extraída de: http://opensees.berkeley.edu/wiki/index.php/Getting_Started_with_OpenSees_--_Nodes
6
Comando [mass].- Este comando es usado para asignar la masa a un nudo. Masas nodales
pueden o bien ser definidos dentro del comando de nodo, o la pueden añadir con el comando
de masas.
mass $nodeTag (ndf $MassValues)

Donde:
$MassValues: masas nodales correspondientes a cada GDL
Comando [fix].- Este comando es usado para definir las restricciones en los nudos
correspondientes a los apoyos.
fix $nodeTag (ndf $ConstrValues)

Donde:
$ConstrValues: tipo de restricción. Se establece restringido (1) y no restringido (0)
Retomando el ejemplo de la figura anterior, limitados con tres grados de libertad por nodo:
fix 1 1 1 1
fix 2 1 1 1
fix 3 0 0 0
fix 4 0 0 0
4.3. MATERIALES
Los modelos de materiales disponibles en OpenSees se utilizan para construir un objeto

uniaxial el cual representa relaciones uniaxiales fuerza-deformación. A continuación se
presentan alguno de ellos.
 Concrete01: Este material asume que el concreto no posee resistencia a la tensión.
Es un modelo propuesto por Kent-Scott-Park (1971) con degradación lineal de rigidez
carga-descarga de acuerdo con el trabajo de Karsan-Jirsa (Karsan and Jirsa 1969).
 Concrete02: Este material uniaxial asume que el concreto posee resistencia a la

tensión, considera un suavizado lineal en la zona de tensión.
 Concrete03: Es un modelo de material que considera al concreto con resistencia a

tensión y suavizado no lineal en la zona de tensión del diagrama esfuerzo-
deformación.
7
 Concrete04: Este modelo es usado para construir un material uniaxial con
degradación lineal de rigidez carga-descarga de acuerdo con el trabajo de Karsan-
Jirsa. Este material considera además un esfuerzo a tensión con un descenso
exponencial.
 Steel01: Este tipo de material representa acero con propiedades esfuerzo-

deformación que siguen un diagrama bilineal con endurecimiento cinemático y
endurecimiento isotrópico opcional escrito por una ecuación no lineal.
 Steel02: Con este modelo se obtiene un material de acero uniaxial con

endurecimiento de deformación isotrópico, además provee control sobre la transición
de la región elástica a la plástica. Los efectos de endurecimiento de deformación son
opcionales y pueden ser especificados en compresión o tensión.
Se presenta a continuación las instrucciones que permiten definir los materiales más usados:
Material Elástico [Elastic Material].- Este comando es usado para construir un material
elástico uniaxial.
uniaxialMaterial Elastic $matTag $E <$eta>
Donde:
$matTag: etiqueta que identifica al material
$E: Módulo Elasticidad
$eta: Tangente amortiguamiento (opcional, por defecto 0).
Material Elástico Perfectamente Plástico [Elastic-Perfectly Plastic Material].- Este

comando es usado para construir un material uniaxial elástico perfectamente plástico.
uniaxialMaterial ElasticPP $matTag $E $spsyP <$epsyN $eps0>
Donde:
$E: Módulo Elasticidad
$epsyP: Deformación en la cual el material alcanza el estado plástico en tensión.
$espyN: Deformación en la cual el material alcanza el estado plástico en compresión.
$eps0: Deformación inicial
Comando [Concrete01].- Este comando es usado para construir un material uniaxial
Concreto con degradación lineal de rigidez carga – descarga acorde con el trabajo de Karsan
y Jirsa, no soporta esfuerzos de tensión
uniaxialMaterial Concrete01 $matTag $fpc $epsc0 $fpcu $epsU
8
Donde:
$fpc: Resistencia a la compresión a los 28 días (compresión es negativa).
$epsc0: Deformación del concreto en el esfuerzo máximo
$fpcu: Esfuerzo de fractura del concreto
$epsU: Deformación del concreto al esfuerzo de fractura
Comando [Concrete02].- Este comando es usado para construir un material uniaxial de
Concreto con esfuerzo de tensión, considera un suavizado lineal en la zona de tensión.
uniaxialMaterial Concrete02 $matTag $fpc $epsc0 $fpcu $epscu $lambda $ft $Ets
Donde:
$fpc: Resistencia a la compresión a los 28 días.
$epsc0: Deformación del concreto en la resistencia a la compresión.
$fpcu: Esfuerzo de fractura del concreto
$epscu: Deformación del concreto al esfuerzo de fractura
$lambda: coeficiente entre la pendiente descarga al $epscu y la pendiente inicial del esfuerzo
de tensión.
$ft: Esfuerzo de tensión
$Ets: Resistencia a tensión (pendiente de la rama lineal de tensión).
Es importante resaltar que los parámetros de resistencia y deformación a compresión deben
ser definidos como negativos; mientras los parámetros de resistencia y deformación a tensión
del concreto son considerados positivos.
Comando [Steel01].- Este comando es usado para construir un material uniaxial bilineal de
Acero con endurecimiento cinemático y endurecimiento isotrópico opcional descrito por una
ecuación no lineal.
uniaxialMaterial Steel01 $matTag $Fy $E0 $b <$a1 $a2 $a3 $a4>

Donde:
$Fy: Esfuerzo de fluencia
$E0: Rigidez elástica inicial
$b: coeficiente endurecimiento - deformación (entre la rigidez post fluencia y la rigidez
elástica inicial)
$a1, $a2, $a3: Parámetros de endurecimiento isotrópico.
9
4.4. SECCIONES
A continuación se describen los comandos más utilizados para la creación de secciones, se

definen los tipos que pueden crearse en OpenSEES.
Sección Elástica [section Elastic].- Este comando es usado para construir una sección
elástica.
section Elastic $secTag $E $A $Iz <$Iy $G $J>

Donde:
$secTag: etiqueta que identifica a la sección.
$E: Módulo de Young
$A: Área de la sección transversal
$Iz: Momento de inercia del área con respecto al eje Z
$Iy: Momento de inercia del área con respecto al eje Y (opcional, usado en análisis 3D).
$G: Módulo de Corte (opcional, usado en análisis 3D).
$J: Momento de inercia torsional (opcional, usado en análisis 3D).
Sección Fibra [Fiber Section].- Este comando es usado para construir una sección tipo fibra.
Esta herramienta es muy útil, con ella se puede definir secciones como las de concreto
reforzado, ya que esta sección se puede definir por medio de diferentes capas, concreto
confinado, concreto no confinado y acero de refuerzo.
section Fiber $secTag{

fiber <fiber arguments>
patch <patch arguments>
layer <layer arguments>
}
Existen varias opciones para definir las secciones tipo fibra, a continuación se describe
brevemente algunas de ellas.
 patch quad: Permite construir una sección (parche) en forma de cuadrilátero, por lo
tanto será necesario definir los cuatro vértices de la sección.
 patch rect: Permite construir una sección (parche) de forma rectangular, para esta
instrucción se necesita definir las coordenadas de dos vértices opuestos.
 patch circ: Permite construir una sección (parche) de forma circular.
 layer straight: Esta instrucción es utilizada para construir las capas de refuerzo de
acero.
10
Presentamos el Ejemplo de los más utilizados:
patch rect $matTag $numSubdiviIJ $numSubdivJK $yI $zI $yJ $zJ

Donde:
$matTag: etiqueta que identifica al material definido previamente.
$numSubdivIJ: Número de subdivisiones (fibras) en dirección z.
$numSubdivJK: Número de subdivisiones (fibras) en dirección y
$yI $zI: Coordenadas de un vértice.
$yJ $zJ: Coordenadas del vértice opuesto.
layer straight $matTag $numBars $areaBar $yStart $zStart $yEnd $zEnd

Donde:
$matTag: etiqueta que identifica al material definido previamente.
$numBars: Número de barras de refuerzo en la capa definida.
$areaBar: Área individual de las barras de refuerzo.
$yStart $zStart: Coordenadas (y, z) del punto inicial de la capa de refuerzo.
$yEnd $zEnd: Coordenadas (y, z) del punto final de la capa de refuerzo.
4.5. ELEMENTOS
Comando [transformación].- define el modo en el elemento coordina correlacionar con las

coordenadas de los modelos globales. En un problema 2D, no necesita orientación los
elementos a considerar, y puede ser el mismo para todos los elementos. La transformación
lineal se utiliza en esta demostración:
geomTransf Linear $transfTag <-jntOffset $dXi $dYi $dXj $dYj>
geomTransf Linear 1
Comando [elasticBeamColumn].- Este comando es usado para construir un elemento Viga

Columna elástico, los argumento necesarios para construir el elemento depende de la
dimensión del problema.
element elasticBeamColumn $eleTag $iNode $jNode $A $E $Iz $transfTag

Donde:
$eleTag: etiqueta que identifica al elemento
$iNode $jNode: Nudos extremos
$A: Área transversal del elemento
$E: Módulo de Young.
$Iz: Inercia de la sección respecto al eje local z
11
$transfTag: Identificador para la transformación de coordenadas
4.6. GRABADORES
El comando grabadora se utiliza para definir la salida análisis.

La grabadora de nodo se utiliza para dar salida a los desplazamientos horizontales y verticales
en el nodo 3 en un archivo denominado Node3.out:
recorder Node <-file $fileName> <-time> <-node ($node1 $node2 ...)> <-nodeRange
$startNode $endNode> <-region $RegionTag> <-node all> -dof ($dof1 $dof2 ...) $respType
recorder Node -file Node3.out -time -node 3 -dof 1 2 disp
La grabadora elemento se utiliza para la producción de elementos de las fuerzas. Fuerzas de

elemento para el elemento 1 se emitirán en el archivo Element1.out:
recorder Element <-file $fileName> <-time> <-ele ($ele1 $ele2 ...)> <-eleRange $startEle
$endEle> <-region $regTag> <-ele all> ($arg1 $arg2 ...)
recorder Element -file Element1.out -time -ele 1 force
4.7. CARGAS
En OpenSees aplican cargas es un proceso de tres pasos:

 Primero debe definir las cargas en un patrón de carga
 A continuación, debe definir el análisis y sus características
 Las cargas se aplican luego al ejecutar el análisis
4.7.1. PATRONES DE CARGA
Los patrones de carga son definidos usando el comando pattern. Tres tipos de patrón de carga
están disponibles actualmente:
a. Pattern plain: este patrón se utiliza para definir la siguiente:
i. cargas nodales, como cargas de gravedad y las cargas laterales (o
desplazamientos nodales de carga controlada)
ii. limitaciones de un solo punto, como el control de desplazamiento en un
nodo (normalmente utilizados para un desplazamiento constante a un nodo)
12
iii. cargas de elementos, tales como cargas de gravedad distribuidas a lo largo
del elemento (esta es una nueva opción, que todavía necesita la
documentación).
b. UniformExcitation Pattern: este tipo de patrón impone un registro de aceleración
definida por el usuario a todos los nodos fijos, en una dirección específica.
c. MultipleSupport Pattern: este tipo de patrón impone un registro definido por el
usuario de desplazamiento en los nodos especificados, en una dirección especificada,
o un registro de movimiento de tierra.
4.7.2. ANÁLISIS Y DEFINICIÓN DE FUNCIONES
En la parte correspondiente al análisis, OpenSEES permite hacer uso de diferentes

herramientas disponibles para análisis lineal y no lineal. Para cada análisis se deben definir
los siguientes ítems, y de acuerdo a la recomendación del manual de usuario, preferentemente
deberán ser definidos en el orden mostrado:
Comando [constraints]: Este comando es usado para construir un objeto gestor de las
restricciones. El gestor determina como las ecuaciones de las restricciones son aplicadas en
el análisis. Las ecuaciones de las restricciones aplican un valor específico para un GDL, o
una relación entre los grados de libertad.
 Plain
 Lagrange
 Transformation
 Penalty
Comando [numberer]: Esta instrucción construye un objeto para numeración de los grados
de libertad. Éste determina la asignación entre el número de ecuaciones y los grados de
libertad, como los grados de libertad son numerados. Para ello se tienen dos opciones:
 Plain: Usa la numeración dada por el usuario.
 RCM: Vuelve a numerar los grados de libertad para minimizar el ancho de banda de
la matriz usando el algoritmo reverso de Cuthill-McKee
Comando [system]: Este comando es usado para construir un Sistema de Ecuaciones lineal
y un objeto de solución lineal.
Comando [test]: Este comando es usado para construir un objeto para prueba de
convergencia. Algunos algoritmos de solución requieren pruebas de convergencia para
determinar si la convergencia ha sido alcanzada al final de un paso de iteración.
13
Comando [algorithm]: Este comando es usado para construir un objeto para determinar el
algoritmo de solución, el cual determina la secuencia de pasos tomados para resolver la
ecuación no lineal.
 Linear: Usa la solución de la primera iteración y continúa.
 Newton: Usa la tangente en la iteración actual para iterar la convergencia.
 Modified Newton: Usa la tangente a la primera iteración para iterar la convergencia
Comando [integrator]: Este comando se usa para construir un objeto Integrador. Éste
determina el significado de los términos en el sistema de ecuaciones.
 Newmark: Método desarrollado por Newmark, es necesario definir los parámetros α
y β.
 HHT: Método de Hilbert-Hughes-Taylor.
 Central Difference: Aproxima la velocidad y la aceleración centrando diferencias
finitas de desplazamiento.
Comando [analysis]: Este comando es usado para construir un objeto de Análisis, el cual
define el tipo de análisis que será realizado, los cuales pueden ser:
 Análisis Estático: Resuelve el problema Q=K*q, sin matrices de masa o
amortiguamiento.
 Análisis Transient: Resuelve un análisis dependiente del tiempo. El paso de tiempo
en este análisis en constante.
 Análisis Transient Variable: Resuelve el análisis dependiente del tiempo. El paso de
tiempo en este análisis es variable.
4.7.3. EJECUCIÓN DE ANÁLISIS
Una de las formas de establecer una carga se presenta en el siguiente comando
pattern Plain $patternTag (TimeSeriesType arguments) {

load $nodeTag (ndf $LoadValues)
}
Si se pretende establecer una carga de gravedad de 8 y 10 toneladas en los nodos 3 y 4

respectivamente de la figura 1, se asigna de la siguiente manera:
pattern Plain 1 Linear {
load 3 0.0 -8 0.0

load 4 0.0 -10 0.0
}
14
El análisis se ejecuta con el comando analyze. Este comando mueve el análisis presentado
por el número especificado de pasos.
4.7.4. CARGAS LATERALES
En este análisis, se impone un desplazamiento lateral de aumento de la amplitud en los nodos

libres (3 y 4) de la figura 1. Los desplazamientos impuestos se aplican usando un integrador
de control de desplazamiento, donde los factores de carga se escalan para llegar a la de
desplazamiento deseado (en comparación con un análisis del tipo de desplazamiento
impuesto). Este método es el más eficaz cuando se tiene un sistema que no es de fuerza
degradante.
El primer paso es definir el modelo de carga. Para ello, creamos un nuevo modelo de carga
(etiqueta de ID 2) para las cargas laterales
Mientras que la gravedad se aplica como una carga, usando el integrador LoadControl, el
integrador DisplacementControl se utiliza en Pushover:
integrator DisplacementControl $nodeTag $dofTag $dU1 <$Jd $minDu $maxDu>

Si se desea aplicar la carga al nodo 3, en la dirección de DOF 1, con un incremento de
desplazamiento de 0,1
integrator DisplacementControl 3 1 0.1
Si se quiere generar un desplazamiento de 1 unidad se debe aplicar, por lo tanto, 10 pasos:
analyze 10
15
5. EJEMPLOS
5.1. EJEMPLO 1
Se presenta el siguiente modelo:
2 3 3
1 2
1 4
Figura 2. Pórtico simple con nodos y elementos enumerados
Columnas:
Son cuadradas de 50 cm y 3 m de altura.
Vigas:
Tienen una altura de 60 cm, ancho de 50 cm y una longitud de 4 metros.
Para este modelo se pide:
1) Analizar el periodo de la estructura considerando únicamente el peso propio de la
estructura
2) Luego de aplicar una carga lateral de 5 toneladas, identificar la reacción en X del
nodo 1 y los desplazamientos de la cubierta.
Datos necesarios.
En la carpeta anexa con el nombre de Ejemplo 1, se presenta con detalle los cálculos de los
datos necesarios para la solución del problema, tales como:
Masa en cada nodo: 0.238532 ton*s2/m
Área Viga: 0.3 m4
Área Columna: 0.25 m4
Inercia Viga: 0.0090 m4
Inercia Columna: 0.00521
16
A continuación se presenta el código empleado, el cual se encuentra guardado en la carpeta
anexa a este ejemplo en formato tcl para usar en Open Sees
Nota: las líneas que comienzan con # son líneas de comentarios.
# Unidades: ton, m, sec

# Limpiar modelo existente
wipe
# Crear Modelo (con 2 dimensiones y 3 DOF/node)
model BasicBuilder -ndm 2 -ndf 3
# Crear nodos & añadir masas -
# comando: node nodeId xCrd yCrd <-mass $massX $massY $massRz>
node 1 0.0 0.0
node 2 0.0 3.0 -mass 0.2385 0.0 0.0
node 3 4.0 3.0 -mass 0.2385 0.0 0.0
node 4 4.0 0.0
# Definir condiciones de frontera - comando: fix nodeID xResrnt? yRestrnt? rZRestrnt?
fix 1 1 1 1
fix 4 1 1 1
# Definir Transformación de coordenadas para elementos viga-columna
geomTransf Linear 1; # beams
geomTransf PDelta 2; # columns
# Definir Elementos
# Crear elementos elásticos -
# comando: element elasticBeamColumn eleID node1 node2 A E Iz geomTransfTag
# Columnas
element elasticBeamColumn 1 1 2 0.25 2534563.6 0.00521 2;
# Viga
record
timeSeries Linear 1
#por definición dejamos las siguientes condiciones de análisis
# Create the system of equation
system BandSPD
# Create the DOF numberer, the reverse Cuthill-McKee algorithm

numberer RCM
# Create the constraint handler, a Plain handler is used as homo constraints
17
constraints Plain
# Create the integration scheme, the LoadControl scheme using steps of 1.0
integrator LoadControl 1.0
# Create the solution algorithm, a Linear algorithm is created

algorithm Linear
# create the analysis object

analysis Static
#Analizamos en un solo paso

analyze 1;
#Obtenemos los valores propios con eigen
set eigenValues [eigen 1]
#Con lindex extraemos el valor propio 0 (primer valor)
set eigenValue [lindex $eigenValues 0]
#Calculamos el periodo y mostramos con puts
puts "T[expr 0+1] = [expr 2*3.1416/sqrt($eigenValue)]"
#Con print mostramos algunas características de un elemento en específico
print ele 1
#Guardamos los desplazamientos de los nodos 1,2,3 y 4
recorder Node -file eigenvector.out -nodeRange 1 4 -dof 1 2 3 disp;
record
#Carga Constante de Gravedad
loadConst -time 0.0
#Aplicamos carga lateral
timeSeries Linear 2
pattern Plain 2 2 {
load 2 5.0 0.0 0.0
}
#Guardamos las fuerzas del elemento 1 (Fx Fy M, en el pto inicial y final)
recorder Element -file Elementos.out -ele 1 forces
analyze 1
print ele 1
#Invocamos las reacciones, con nodeReaction pedimos las reacciones de un nodo en
especifico
reactions
set Reaccion1 [nodeReaction 1]
set Reaccion4 [nodeReaction 4]
#Con lindex llamamos solo la reacción en x del nodo 1
18
set Reaccion1x [expr [lindex $Reaccion1 0]]
puts "El valor de la reacción en X es:"
puts "$Reaccion1x"
Para fines académicos realizamos el anterior ejercicio en el programa Sap 2000, para
comparar que tanto varían los resultados, y se encontró que la aproximación en las respuestas
es por muy poca diferencia.
Los resultados del análisis realizado en Sap 2000 se encuentran en la carpeta anexa Ejemplo
1.
5.2. EJEMPLO 2
El siguiente ejemplo fue tomado directo de la página de Open Sees, éste ejemplo fue
analizado y se tomó como objeto de estudio para poder realizar el ejemplo 1.
El modelo se puede ver en la siguiente figura:
Figura 3. Pórtico simple con nodos y elementos enumerados2
2
Imagen Tomada de: http://opensees.berkeley.edu/wiki/index.php/Elastic_Frame_Example
19
El código de programación se puede ver en la carpeta anexa Ejemplo 2 con el nombre de
ElasticFrame.tcl, o se puede descargar directamente de la página de Open Sees.
# OpenSees -- Open System for Earthquake Engineering Simulation

# Pacific Earthquake Engineering Research Center
# http://opensees.berkeley.edu/
#
# Basic Elastic Frame
# ----------------------
# 2d Elastic Beam Column Elements
# Distributed Load & Pushover Analysis
#
# Example Objectives
# -----------------
# Simple Introduction to OpenSees
#
# Units: kips, in, sec
# Written: fmk
# Date: January 2011
#
# set some parameter
#
set PI [expr 2.0 * asin(1.0)]
set g 386.4
set ft 12.0
set Load1 1185.0;
set Load2 1185.0;
set Load3 970.0;
# set floor masses

set m1 [expr $Load1/(4*$g)]; # 4 nodes per floor
set m2 [expr $Load2/(4*$g)]
set m3 [expr $Load3/(4*$g)]
# set floor distributed loads

set w1 [expr $Load1/(90*$ft)]; # frame 90 ft long
set w2 [expr $Load2/(90*$ft)]
20
set w3 [expr $Load3/(90*$ft)]
# ------------------------------
# Start of model generation
# ------------------------------
# Remove existing model

wipe
# Create ModelBuilder (with two-dimensions and 2 DOF/node)

# Create nodes
# ------------
# Create nodes & add to Domain - command: node nodeId xCrd yCrd <-mass $massX
$massY $massRz>
# NOTE: mass in optional
node 1 0.0 0.0
node 2 360.0 0.0
node 3 720.0 0.0
node 4 1080.0 0.0
node 5 0.0 162.0 -mass $m1 $m1 0.0
node 6 360.0 162.0 -mass $m1 $m1 0.0
node 7 720.0 162.0 -mass $m1 $m1 0.0
node 8 1080.0 162.0 -mass $m1 $m1 0.0
node 9 0.0 324.0 -mass $m2 $m2 0.0
node 10 360.0 324.0 -mass $m2 $m2 0.0
node 11 720.0 324.0 -mass $m2 $m2 0.0
node 12 1080.0 324.0 -mass $m2 $m2 0.0
node 13 0.0 486.0 -mass $m3 $m3 0.0
node 14 360.0 486.0 -mass $m3 $m3 0.0
node 15 720.0 486.0 -mass $m3 $m3 0.0
node 16 1080.0 486.0 -mass $m3 $m3 0.0
# Set the boundary conditions - command: fix nodeID xResrnt? yRestrnt? rZRestrnt?
fix 1 1 1 1
fix 2 1 1 1
fix 3 1 1 1
fix 4 1 1 1
21
# Define geometric transformations for beam-column elements
# Define elements
# Create elastic beam-column - command: element elasticBeamColumn eleID node1 node2
A E Iz geomTransfTag
# Define the Columns

element elasticBeamColumn 1 1 5 75.6 29000.0 3400.0 2; # W14X257
# Define the Beams

# Define loads for Gravity Analysis

# ---------------------------------
#create a Linear TimeSeries (load factor varies linearly with time): command timeSeries
Linear $tag
timeSeries Linear 1
22
# Create a Plain load pattern with a linear TimeSeries:
# command pattern Plain $tag $timeSeriesTag { $loads }
pattern Plain 1 1 {
eleLoad -ele 13 14 15 -type -beamUniform -$w1
}
# ---------------------------------
# Create Analysis for Gravity Loads
# ---------------------------------
# Create the system of equation, a SPD using a band storage scheme

system BandSPD

numberer RCM

constraints Plain

test NormDispIncr 1.0e-10 6
algorithm Newton

analysis Static
# ---------------------------------
# Perform Gravity Analysis
# ---------------------------------
analyze 1
# ---------------------------------
23
# Check Equilibrium
# ---------------------------------
# invoke command to determine nodal reactions

reactions
set node1Rxn [nodeReaction 1]; # nodeReaction command returns nodal reactions for
specified node in a list
set node2Rxn [nodeReaction 2]
set inputedFy [expr -$Load1-$Load2-$Load3]; # loads added negative Fy diren to ele

set computedFx [expr [lindex $node1Rxn 0]+[lindex $node2Rxn 0]+[lindex $node3Rxn
0]+[lindex $node4Rxn 0]]
set computedFy [expr [lindex $node1Rxn 1]+[lindex $node2Rxn 1]+[lindex $node3Rxn
puts "\nEqilibrium Check After Gravity:"

puts "SumX: Inputed: 0.0 + Computed: $computedFx = [expr 0.0+$computedFx]"
puts "SumY: Inputed: $inputedFy + Computed: $computedFy = [expr
$inputedFy+$computedFy]"
# ---------------------------------
# Lateral Load
# ---------------------------------
# set gravity loads constant and time in domain to e 0.0

loadConst -time 0.0
timeSeries Linear 2
pattern Plain 2 2 {
load 13 220.0 0.0 0.0
load 9 180.0 0.0 0.0
load 5 90.0 0.0 0.0
}
# ---------------------------------
# Create Recorder
# ---------------------------------
24
recorder Element -file EleForces.out -ele 1 4 7 10 forces
# ---------------------------------
# Perform Lateral Analysis
# ---------------------------------
analyze 1
# ---------------------------------
# Check Equilibrium
# ---------------------------------
reactions
set node1Rxn [nodeReaction 1]; # nodeReaction command returns nodal reactions for
specified node in a list
set inputedFx [expr 220.0+180.0+90.0]

set computedFx [expr [lindex $node1Rxn 0]+[lindex $node2Rxn 0]+[lindex $node3Rxn
set computedFy [expr [lindex $node1Rxn 1]+[lindex $node2Rxn 1]+[lindex $node3Rxn
puts "\nEqilibrium Check After Lateral Loads:"

puts "SumX: Inputed: $inputedFx + Computed: $computedFx = [expr
$inputedFx+$computedFx]"
puts "SumY: Inputed: $inputedFy + Computed: $computedFy = [expr
$inputedFy+$computedFy]"
# print ele information for columns at base

print ele 1 4 7 10
# ---------------------------------
# Check Eigenvalues
# ---------------------------------
25
puts "\nEigenvalues:"
puts "T[expr 0+1] = [expr 2*$PI/sqrt($eigenValue)]"
recorder Node -file eigenvector.out -nodeRange 5 16 -dof 1 2 3 eigen 0

record
5.3. EJEMPLO 3
Tomado de la Clase de Dinámica Estructural – Ingeniero Daniel Ruiz
Columna:
Cuadrada de 0.5 m de lado, longitud de 6 m, refuerzo principal con 16 barras de 25 mm
de diámetro (véase la Figura 4), recubrimiento (hasta el eje de las barras de refuerzo
principal) de 0.05 m, Concreto de 28 MPa de esfuerzo resistente a la compresión, acero
de refuerzo con esfuerzo de fluencia de 420 MPa (esfuerzo de rotura de 560 MPa y con
deformación de rotura de 14%), zonas de confinamiento con estribos tipo “Hoop” (como
los definidos en XTRACT) de 10 mm de diámetro cada 11 cm.
Figura 4. Esquema general de las columnas
1. Establecer el diagrama Momento-Curvatura de la Columna.
El código programado para resolver este problema es el siguiente:
26
#Unidades Kg, cm y segundos
proc MomentCurvature {secTag axialLoad maxK {numIncr 100} } {
# Definir 2 nodos (0,0)
node 1 0.0 0.0
node 2 0.0 0.0
# Fijar
fix 1 1 1 1
fix 2 0 1 0
# Definir elementos (Elemento de Longitud 0)

# tag ndI ndJ secTag
element zeroLengthSection 1 1 2 $secTag
# Crear grabadora
recorder Node -file section$secTag.out -time -node 2 -dof 3 disp
# Definir Carga Axial

pattern Plain 1 "Constant" {
load 2 $axialLoad 0.0 0.0
}
# Definir parametros de analisis

system SparseGeneral -piv;
test NormUnbalance 1.0e-9 10
numberer Plain
constraints Plain
algorithm Newton
analysis Static
# Hacer analisis de la carga axial constante

analyze 1
# Definir momento de inicio

pattern Plain 2 "Linear" {
load 2 0.0 0.0 1.0
}
# Calcular valor minimo de curvatura

set dK [expr $maxK/$numIncr]
27
# Utilice el control de los desplazamientos en el nodo 2 para el análisis de la sección
integrator DisplacementControl 2 3 $dK 1 $dK $dK
# Hacer el análisis de la sección

analyze $numIncr
}
# Crear el modelo
# --------------------
model basic -ndm 2 -ndf 3
# Definir los materiales

# ------------------------------------------
# CONCRETO tag f'c ec0 f'cu ecu
# Concreto Confinado
uniaxialMaterial Concrete01 1 -280 -0.003 -210 -0.014
# Concreto de Recubrimiento (Inconfinado)

uniaxialMaterial Concrete01 2 -210 -0.003 0.0 -0.006
# ACERO
set fy 4200; # Esfuerzo de Fluencia
set E 2100000.0; # Modulo de Elasticidad
# tag fy E0 b
uniaxialMaterial Steel01 3 $fy $E 0.01
# Secciones de la Columna
# ------------------------------------------
# Parametros
set colWidth 50
set colDepth 50
set cover 5
set As 5.07; # area de Barra No. 8
# Algunas variables de ayuda

set y1 [expr $colDepth/2.0]
set z1 [expr $colWidth/2.0]
28
section Fiber 1 {
# Concreto confinado
patch rect 1 10 1 [expr $cover-$y1] [expr $cover-$z1] [expr $y1-$cover] [expr $z1-
$cover]
# concreto no confinado (top, bottom, left, right)

patch rect 2 10 1 [expr -$y1] [expr $z1-$cover] $y1 $z1
patch rect 2 10 1 [expr -$y1] [expr -$z1] $y1 [expr $cover-$z1]
patch rect 2 2 1 [expr -$y1] [expr $cover-$z1] [expr $cover-$y1] [expr $z1-$cover]
patch rect 2 2 1 [expr $y1-$cover] [expr $cover-$z1] $y1 [expr $z1-$cover]
# Acero de Refuerzo
layer straight 3 5 $As [expr $y1-$cover] [expr $z1-$cover] [expr $y1-$cover] [expr
$cover-$z1]
layer straight 3 2 $As [expr ($y1-$cover)/2.0] [expr $z1-$cover] [expr ($y1-$cover)/2.0]
[expr $cover-$z1]
layer straight 3 2 $As 0.0 [expr $z1-$cover] 0.0 [expr $cover-$z1]
layer straight 3 2 $As [expr ($cover-$y1)/2.0] [expr $z1-$cover] [expr ($cover-$y1)/2.0]
[expr $cover-$z1]
layer straight 3 5 $As [expr $cover-$y1] [expr $z1-$cover] [expr $cover-$y1] [expr
$cover-$z1]
}
# Estimate yield curvature

# (Assuming no axial load and only top and bottom steel)
set d [expr $colDepth-$cover]; # d de la columna
set epsy [expr $fy/$E] ; # steel yield strain
set Ky [expr $epsy/(0.7*$d)]
# Print estimate to standard output

puts "Estimated yield curvature: $Ky"
# Set axial load

set P -500
set mu 250; # Target ductility for analysis

set numIncr 100; # Number of analysis increments
# Call the section analysis procedure

MomentCurvature 1 $P [expr $Ky*$mu] $numIncr
29
Este código se encuentra disponible en el archivo MCurvatura.tcl que se encuentra en la
carpeta anexa Ejemplo 3.
Por motivos académicos hallamos el resultado de realizar el mismo análisis en el programa

Xtract y los resultados fueron los siguientes:
M-FI Open Sees

80
70
60
50
M (Ton-m)
40
30
20
10
0
0.0000 0.0200 0.0400 0.0600 0.0800 0.1000 0.1200 0.1400 0.1600 0.1800
Curvatura 1/m
M-Fi Xtract
70
60
50
M (ton-m)
40
30
20
10
0
0 0.02 0.04 0.06 0.08 0.1 0.12 0.14 0.16 0.18
Curvatura 1/m
Podemos notar que los resultados son aproximadamente iguales.
30
5.4. EJEMPLO 4
Tomando la figura 2 y los datos del ejemplo número 1, se desea Inducir una señal sísmica en
el pórtico.
La señal escogida corresponde al sismo del Centro, la cual se encuentra anexa en la carpeta
de los ejemplos.
Primero calculamos las variables necesarias para el cálculo de la respuesta sísmica, tales
como la masa, entre otros.
El código desarrollado es el siguiente:
# Unidades: ton, m, sec

# Limpiar modelo existente
wipe
# Crear Modelo (con 2 dimensiones y 3 DOF/node)
# Crear nodos & añadir masas -
# comando: node nodeId xCrd yCrd <-mass $massX $massY $massRz>
node 1 0.0 0.0
node 2 0.0 3.0 -mass 2.2772 0.0 0.0
node 3 4.0 3.0 -mass 2.2772 0.0 0.0
node 4 4.0 0.0
# Definir condiciones de frontera - comando: fix nodeID xResrnt? yRestrnt? rZRestrnt?
fix 1 1 1 1
fix 4 1 1 1
# Definir Tranformacion de coordenadas para elementos viga-columna
# Definir Elementos
# Crear elementos elasticos -
# comando: element elasticBeamColumn eleID node1 node2 A E Iz geomTransfTag
# Columnas
# Viga
#Crear los Grabadores
recorder Node -file Desp3.out -time -node 3 -dof 1 2 3 disp;
recorder Node -file Reacciones.out -time -node 1 4 -dof 1 2 3 reaction;
31
#timeSeries Linear 1;
set W 10;
pattern Plain 1 Linear {
eleLoad -ele 3 -type -beamUniform -$W;
}
#por definicion dejamos las sigueintes condiciones de analisis
# Create the system of equation
system BandGeneral;
#test NormDisplncr 1.0e-2 10;

numberer Plain

constraints Plain
integrator LoadControl 0.1; #Aplico 10% de carga en cada paso

algorithm Linear

analysis Static
#Analizamos en un 1 paso
analyze 10;
loadConst -time 0.0; #Reinicia el tiempo y congela Cargas
#Obtenemos los valores propios con eigen
#Con lindex extraemos el valor propio 0 (primer valor)
#Calculamos el periodo y mostramos con puts
puts "T[expr 0+1] = [expr 2*3.1416/sqrt($eigenValue)]"
#Analsis Dinamico
#Creamos el patron de carga
set accelSeries "Series -dt 0.02 -filePath CENTRO1.prn -factor 1";
pattern UniformExcitation 2 1 -accel $accelSeries;
set xdamp 0.05
32
rayleigh 0. 0. 0. [expr 2*$xdamp/pow([eigen 1],0.5)]; #Amortiguamiento
#Definimos Nuevos Parametros de Analisis

wipeAnalysis;
constraints Plain;
numberer Plain;
system BandGeneral;
#test NormDisplncr 1.0e-8 10;
algorithm Linear;
integrator Newmark 0.5 0.25;
analysis Transient; #depende del tiempo
analyze 7000 0.0075; #7000 intervalos de 0.0075
Los resultados obtenidos en el nodo 3, fueron los siguientes:
Desplazamiento Nodo 3
3.00E-04
2.00E-04
1.00E-04
Desplazamiento (m)
0.00E+00
-1.00E-04
-2.00E-04
-3.00E-04
-4.00E-04
-5.00E-04
Tiempo (s)
33
6. REFERENCIAS
 OPEN SEES página web, http://opensees.berkeley.edu/OpenSees/user/index.php
 Maual de Comandos OPEN SEES, pagina web,

http://opensees.berkeley.edu/wiki/index.php/Command_Manual
 Examples OPEN SEES, pagina web,

http://opensees.berkeley.edu/wiki/index.php/Examples
 USO DE OPEN SEES, Capítulo V, extraído de:

http://repositorio.espe.edu.ec/bitstream/21000/2043/6/T-ESPE-020940-5.pdf
34

OPEN SEES - Manejo - Edy Galvis

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

OPEN SEES - Manejo - Edy Galvis

Încărcat de

Drepturi de autor:

Formate disponibile

PONTIFICIA UNIVERSIDAD JAVERIANA

USO DEL PROGRAMA OPEN SEES

ING. JESUS VILLALBA

EDY JOSE GALVIS CAMPILLO

Imagen 1: Registro o ingreso a la opción de descarga de Open Sees

Si no estás registrado, lo puedes hacer totalmente gratis dando clic en registration.

Existen diferentes formas para el manejo del programa.

Los comandos se pueden introducir directamente en la pantalla que aparece al iniciar el

4. ALGUNOS COMANDOS DE ENTRADA

4.1. CREACIÓN DEL MODELO

model BasicBuilder -ndm $ndm <-ndf $ndf>

model basic -ndm 2 -ndf 3

Figura 1: Pórtico simple con nodos y elementos enumerados1

node $nodeTag (ndm $coords) <-mass (ndf $MassValues)>

mass $nodeTag (ndf $MassValues)

fix $nodeTag (ndf $ConstrValues)

Los modelos de materiales disponibles en OpenSees se utilizan para construir un objeto

 Concrete02: Este material uniaxial asume que el concreto posee resistencia a la

 Concrete03: Es un modelo de material que considera al concreto con resistencia a

 Steel01: Este tipo de material representa acero con propiedades esfuerzo-

 Steel02: Con este modelo se obtiene un material de acero uniaxial con

Material Elástico Perfectamente Plástico [Elastic-Perfectly Plastic Material].- Este

uniaxialMaterial Steel01 $matTag $Fy $E0 $b <$a1 $a2 $a3 $a4>

A continuación se describen los comandos más utilizados para la creación de secciones, se

section Elastic $secTag $E $A $Iz <$Iy $G $J>

section Fiber $secTag{

 patch circ: Permite construir una sección (parche) de forma circular.

patch rect $matTag $numSubdiviIJ $numSubdivJK $yI $zI $yJ $zJ

layer straight $matTag $numBars $areaBar $yStart $zStart $yEnd $zEnd

Comando [transformación].- define el modo en el elemento coordina correlacionar con las

geomTransf Linear $transfTag <-jntOffset $dXi $dYi $dXj $dYj>

Comando [elasticBeamColumn].- Este comando es usado para construir un elemento Viga

element elasticBeamColumn $eleTag $iNode $jNode $A $E $Iz $transfTag

El comando grabadora se utiliza para definir la salida análisis.

recorder Node -file Node3.out -time -node 3 -dof 1 2 disp

La grabadora elemento se utiliza para la producción de elementos de las fuerzas. Fuerzas de

recorder Element -file Element1.out -time -ele 1 force

En OpenSees aplican cargas es un proceso de tres pasos:

4.7.1. PATRONES DE CARGA

4.7.2. ANÁLISIS Y DEFINICIÓN DE FUNCIONES

En la parte correspondiente al análisis, OpenSEES permite hacer uso de diferentes

4.7.3. EJECUCIÓN DE ANÁLISIS

Una de las formas de establecer una carga se presenta en el siguiente comando

pattern Plain $patternTag (TimeSeriesType arguments) {

Si se pretende establecer una carga de gravedad de 8 y 10 toneladas en los nodos 3 y 4

pattern Plain 1 Linear {

load 3 0.0 -8 0.0

4.7.4. CARGAS LATERALES

En este análisis, se impone un desplazamiento lateral de aumento de la amplitud en los nodos

integrator DisplacementControl $nodeTag $dofTag $dU1 <$Jd $minDu $maxDu>

integrator DisplacementControl 3 1 0.1

Si se quiere generar un desplazamiento de 1 unidad se debe aplicar, por lo tanto, 10 pasos:

Se presenta el siguiente modelo:

Figura 2. Pórtico simple con nodos y elementos enumerados

# Unidades: ton, m, sec

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

# Create the constraint handler, a Plain handler is used as homo constraints

# Create the solution algorithm, a Linear algorithm is created

# create the analysis object

#Analizamos en un solo paso

Figura 3. Pórtico simple con nodos y elementos enumerados2

# OpenSees -- Open System for Earthquake Engineering Simulation

# set floor masses

# set floor distributed loads