UNIVERSIDAD MAYOR DE SAN ANDRES
Facultad de Ciencias Puras y Naturales
Postgrado en Informática
MODELO ORIENTADO A OBJETOS INDEPENDIENTE DE LA PLATAFORMA PARA EL ANALISIS DE ESTRUCTURAS PLANAS
MEDIANTE EL METODO DE LOS ELEMENTOS FINITOS
Tesis de Postgrado Presentado para Optar el Título de
MAGISTER SCIENTIARUM EN INGENIERIA DEL SOFTWARE
Por:
Ing. Roger Gustavo Saravia Aramayo
Tutor:
M. Sc. Ing. Christian Javier Daza Mier
La Paz – Bolivia
Marzo de 2013
i
Resumen
Ésta investigación se extiende en el área del análisis y diseño orientado a objetos (OO) de las ciencias
de computación con campo de aplicación en la ingeniería estructural; específicamente, en el análisis de
marcos rígidos planos mediante el método de los elementos finitos (MEF). Entre los resultados útiles
del análisis de una estructura, están las fuerzas internas de los elementos que sirven para verificar y
mejorar el diseño de la estructura sea de madera, hormigón armado, y otros. Por razones de
simplificación que se daban antiguamente para ahorrar memoria y tiempo de máquina, el software
comercial de análisis estructural ha venido produciendo los resultados del análisis referidos a un solo
sistema de ejes de coordenadas locales para ambos extremos de los elementos de una estructura
dejando a la interpretación del ingeniero los valores para el otro extremo del elemento lo cual conlleva
a ambigüedades y errores. Esta investigación propone la implementación de un programa de cálculo
estructural que produce resultados de las fuerzas internas para cada extremo de los elementos de una
estructura. Dicha implementación se basa en un nuevo modelo OO para el análisis mediante el MEF –
elemento viga doblemente empotrada sistema de ejes locales Kardestuncer.
Palabras Clave
Abstracción, Agiles, Algoritmo, Análisis, Apoyos, Asd, Cargas, Cascada, Cercha, Clase, Colaboración,
Componentes, Composición, Deformada, Distribución, Ecuaciones, Ejes, Elasticidad, Elemento,
Encapsulación, Estados, Estructuras, Finito, Fuerzas, Getters, Herencia, Implementación, Inercia,
Interfaz, Java, Jerarquía, Kardestuncer, Lenguajes, Marcos, Matricial, Mef, Metodologías, Modelo,
Objeto, Persistencia, Polimorfismo, Pórtico, Programación, Prototipo, Reacciones, Requerimientos,
Rigidez, Rup, Secuencia, Setters, Sistema, Subclase, Superclase, Uml, Viga, Young
ii
Abstract
This research applies object-oriented (OO) analysis and design to structural engineering; specifically,
analysis of rigid plane frames using the finite element method (FEM). Among the useful results of the
structural analysis, we have the internal forces of the elements that are necessary to verify and improve
the design of a given structure. Due to simplification reasons in order to save memory and time
machine, the commercial software of structural analysis has been producing the results of the analysis
using a single local coordinates system for both ends of the elements of a structure allowing to the
engineer's interpretation the values for the other end of the element; which leads to ambiguities and
errors. This article proposes the implementation of a program for structural analysis capable to
produce results of the internal forces for each end of the elements of a structure. This implementation
is based on a new OO model for the structural analysis using FEM - beam element with rigid joints and
Kardestuncer local coordinates system.
Keywords
Abstraction, Agile, Algorithm, Analysis, Asd, Axes, Beam, Cascade, Class, Collaboration,
Components, Composition, Deformed, Development, Distribution, Elasticity, Element, Encapsulation,
Equations, Fem, Finite, Frames, Getters, Hierarchy, Implementation, Inertia, Inheritance, Interface,
Java, Kardestuncer, Languages, Loads, Matrix, Model, Object, Persistence, Polymorphism,
Programming, Prototype, Reactions, Requirements, Rigidity, Rup, Sequence, Setters, States,
Structures, Superclasses, Supports, System, Truss, Uml, Young
1
Índice
PARTE 1 – MARCO REFERENCIAL ....................................................................................................................... 6
1.1 INTRODUCCIÓN ....................................................................................................................................... 6
1.1.1 ¿QUÉ ES EL ANÁLISIS ESTRUCTURAL Y PARA QUÉ SIRVE? ..................................................................................... 6 1.1.2 ¿QUÉ ES EL MÉTODO DE LOS ELEMENTOS FINITOS Y PARA QUÉ SIRVE? ................................................................... 7 1.1.3 ¿QUÉ ES EL MÉTODO MATRICIAL DE LA RIGIDEZ Y PARA QUÉ SIRVE? .................................................................... 10 1.1.4 ¿QUÉ ES UN OBJETO Y PARA QUÉ SIRVE? ....................................................................................................... 11
1.2 DEFINICIÓN DEL PROBLEMA .................................................................................................................. 12
1.2.1 FORMULACIÓN DEL PROBLEMA ................................................................................................................... 12
1.3 OBJETIVOS ............................................................................................................................................. 12
13.1 GENERAL ................................................................................................................................................ 12 1.3.2 ESPECÍFICOS ............................................................................................................................................ 13
1.4 HIPÓTESIS .............................................................................................................................................. 13
1.5 JUSTIFICACIÓN ....................................................................................................................................... 14
1.6 ALCANCES Y LIMITACIONES ................................................................................................................... 14
PARTE 2 – MARCO TEÓRICO ............................................................................................................................ 16
2.1 ESTRUCTURAS DE INGENIERÍA ............................................................................................................... 16
2.1.1 ANÁLISIS ESTRUCTURAL ............................................................................................................................. 17 2.1.2 MÉTODO DE LOS ELEMENTOS FINITOS (MEF) ................................................................................................ 21 2.1.3 MÉTODO MATRICIAL DE LA RIGIDEZ DE KARDESTUNCER ................................................................................... 24 2.1.4 ANÁLISIS DE MARCOS RÍGIDOS PLANOS ........................................................................................................ 25
2.2 ANÁLISIS Y DISEÑO ORIENTADO A OBJETOS ADOO ................................................................................... 28
2.2.1 ¿QUÉ ES UN OBJETO? ............................................................................................................................... 29 2.2.2 ¿QUÉ ES UNA CLASE? ............................................................................................................................... 29 2.2.3 ENCAPSULACIÓN ...................................................................................................................................... 29 2.2.4 INTERFAZ ................................................................................................................................................ 30 2.2.5 HERENCIA ............................................................................................................................................... 30 2.2.6 SUPERCLASES Y SUBCLASES ......................................................................................................................... 31 2.2.7 ABSTRACCIÓN .......................................................................................................................................... 31 2.2.8 POLIMORFISMO ....................................................................................................................................... 31 2.2.9 COMPOSICIÓN ......................................................................................................................................... 32 2.2.10 PERSISTENCIA ..................................................................................................................................... 33 2.2.11 CLASES ABSTRACTAS ............................................................................................................................ 33 2.2.12 INTERFACE JAVA .................................................................................................................................. 33
2.3 LENGUAJE UNIFICADO DE MODELADO (UNIFIED MODELING LANGUAGE UML) ..................................... 34
2.3.1 DIAGRAMAS DE UML ............................................................................................................................... 34
2.4 METODOLOGÍAS DE DESARROLLO ......................................................................................................... 38
2.4.1 PROCESO RACIONAL UNIFICADO (RUP) ........................................................................................................ 39 2.4.2 MÉTODOS AGILES .................................................................................................................................... 40
2.5 PROGRAMACIÓN ORIENTADA A OBJETOS ............................................................................................. 42
2
2.5.1 CLASIFICACIÓN DE LENGUAJES ..................................................................................................................... 43
2.6 ESTADO DEL ARTE .................................................................................................................................. 43
2.6.1 ANTECEDENTES Y TRABAJOS PREVIOS ........................................................................................................... 44
PARTE 3 ‐ DESARROLLO TEÓRICO PRÁCTICO ................................................................................................... 49
3.1 DECLARACIÓN DE TRABAJO ................................................................................................................... 49
3.2 REQUERIMIENTOS ....................................................................................................................... 51
3.2.1 FUNC IONALES ................................................................................................................................. 51 3.2.2 NO FUNCIONALES .......................................................................................................................... 53
3.3 MODELO DE CASOS DE USO ...................................................................................................... 53
3.4 MODELO DE CLASES ............................................................................................................................... 58
3.5 VISTA DINÁMICA – DIAGRAMAS DE COMPORTAMIENTO ...................................................................... 61
3.6 DIAGRAMAS DE COMPONENTES Y DE DESPLIEGUE................................................................................ 69
3.7 IMPLEMENTACIÓN – GENERALIDADES ................................................................................................... 70
3.8 CASOS DE ESTUDIO ................................................................................................................................ 72
3.8.1 CERCHA TIPO TORRE ................................................................................................................................. 72 3.8.2 MARCO RÍGIDO PLANO: EDIFICIO DE 8 PLANTAS ............................................................................................ 82 3.8.3 OTRAS CONSIDERACIONES .......................................................................................................................... 95
PARTE 4 – CONCLUSIONES Y RECOMENDACIONES ......................................................................................... 104
REFERENCIAS ................................................................................................................................................. 107
APÉNDICE A – LISTADO DE CÓDIGO FUENTE .................................................................................................. 109
APÉNDICE B – INSTALACIÓN DEL SOFTWARE ................................................................................................. 135
APÉNDICE C – CASO DE ESTUDIO DE APLICACIÓN PRÁCTICA A LA REALIDAD LOCAL ...................................... 136
C.1 EDIFICIO “EL ALCÁZAR” .................................................................................................................... 136
3
Lista de Figuras
FIGURA 1. EJEMPLO DE ESTRUCTURA ............................................................................................................... 6
FIGURA 2. EL FIN ES DISEÑAR UNA ESTRUCTURA .............................................................................................. 7
FIGURA 3. DEFORMADA DEL PÓRTICO DE UN EDIFICIO ..................................................................................... 7
FIGURA 4A. ESTRUCTURA DE CONCRETO PRETENSADO .................................................................................... 8
FIGURA 4B. MODELO DE ELEMENTOS FINITOS .................................................................................................. 8
FIGURA 5. SISTEMA ESTRUCTURAL PLANO ....................................................................................................... 9
FIGURA 6. ELEMENTO FINITO 3D ...................................................................................................................... 9
FIGURA 7. SISTEMAS DE EJES LOCALES .............................................................................................................. 9
FIGURA 8. MODELO COMPLETO DE LA MATRIZ DE RIGIDEZ GLOBAL ............................................................... 10
FIGURA 9. EL CONCEPTO DE ENCAPSULACIÓN ................................................................................................ 11
FIGURA 11. LA SECUENCIA DE UN PROYECTO ESTRUCTURAL. [KARDESTUNCER 1974] .................................... 20
FIGURA 11B. ALGORITMO DEL MEF ................................................................................................................ 22
FIGURA 12. APLICACIÓN DEL MODELO DE ELEMENTOS FINITOS EN DIVERSAS ESTRUCTURAS. ...................... 23
FIGURA 13A. PÓRTICO O MARCO RÍGIDO 2D .................................................................................................. 24
FIGURA 13B. FUERZAS INTERNAS .................................................................................................................... 24
FIGURA 14A. EL SISTEMA DE ECUACIONES FINAL ............................................................................................ 25
FIGURA 14B. UNA ESTRUCTURA GENERALIZADA ............................................................................................ 25
FIGURA 15A. CERCHA O ARMADURA 2D ......................................................................................................... 26
FIGURA 15B. MARCO RÍGIDO PLANO 2D ......................................................................................................... 26
FIGURA 16. ELEMENTO FINITO VIGA ............................................................................................................... 27
FIGURA 17. OBJETO: ESTRUCTURA .................................................................................................................. 29
FIGURA 18. EJEMPLO: CLASE AUTOMÓVIL. ..................................................................................................... 29
FIGURA 19. EJEMPLO DE INTERFAZ E IMPLEMENTACIÓN. .............................................................................. 30
FIGURA 20. EJEMPLO DE HERENCIA ................................................................................................................ 31
FIGURA 21. LA JERARQUÍA FIGURA. ............................................................................................................... 32
FIGURA 23. EL PROCESO DE ANÁLISIS EN LA INGENIERÍA DEL SOFTWARE. ...................................................... 34
FIGURA 24. DIAGRAMA DE CASOS DE USO. .................................................................................................... 35
FIGURA 25. DIAGRAMA DE COLABORACIÓN ................................................................................................... 36
FIGURA 26. DIAGRAMA DE SECUENCIA ........................................................................................................... 36
FIGURA 27. DIAGRAMA DE ESTADOS .............................................................................................................. 37
FIGURA 29. DIAGRAMA DE COMPONENTES. ................................................................................................... 38
FIGURA 30. DIAGRAMA DE DISTRIBUCIÓN. ..................................................................................................... 38
FIGURA 31. METODOLOGÍA EN CASCADA. ...................................................................................................... 39
4
FIGURA 32. METODOLOGÍA RUP ..................................................................................................................... 40
FIGURA 34. MODELO ORIENTADO A OBJETOS PROPUESTO POR ARCHER. ...................................................... 44
FIGURA 35. MODELO OO SEGÚN FOLEY .......................................................................................................... 46
FIGURA 36A. MODELO DE ELEMENTOS FINITOS .............................................................................................. 47
FIGURA 36B. RENDERIZACIÓN DEL MODELO DE ELEMENTOS FINITOS ............................................................ 47
FIGURA 37. SECCIÓN CAJÓN DE UN PUENTE ................................................................................................... 48
FIGURA 38. UNA ESTRUCTURA 2D .................................................................................................................. 50
FIGURA 39. CASO DE USO – ACTOR “EL USUARIO” .......................................................................................... 54
FIGURA 40. INCLUSIÓN DE CASO DE USO “INTRODUCIR CONDICIONES DE CONTORNO”. ............................... 54
FIGURA 41. CASO DE USO – ACTOR “EL SISTEMA”. ......................................................................................... 55
FIGURA 41A. INCLUSIÓN DE CASO DE USO “INTRODUCIR LAS COORDENADAS DE LOS NUDOS”. .................... 55
FIGURA 41B. INCLUSIÓN DE CASO DE USO “INTRODUCIR LAS PROPIEDADES DE LOS ELEMENTOS” ................ 56
FIGURA 41D. INCLUSIÓN DE CASO DE USO “INTRODUCIR LAS CARGAS SOBRE LOS ELEMENTOS”. .................. 57
FIGURA 41F. INCLUSIÓN Y EXTENSIÓN DEL CASO DE USO “ACCEDER A LOS RESULTADOS NUMÉRICOS DEL ANÁLISIS”. ...................................................................................................................................................... 58
FIGURA 42. MODELO DE CLASES. .................................................................................................................... 60
FIGURA 43. DIAGRAMA DE SECUENCIA PARA PROCESO “ENSAMBLAR EL SISTEMA DE ECUACIONES”. ........... 62
FIGURA 43A. DIAGRAMA DE ACTIVIDADES PARA EL PROCESO “ENSAMBLAR EL SISTEMA .............................. 63
FIGURA 43B. DIAGRAMA DE COLABORACIÓN PARA EL PROCESO “ENSAMBLAR SISTEMA” ............................ 63
FIGURA 43C. DIAGRAMA DE SECUENCIA PARA EL PROCESO “RESOLVER SISTEMA DE ECUACIONES” DE LA ESTRUCTURA. ................................................................................................................................................. 64
FIGURA 43D. DIAGRAMA DE ACTIVIDADES DEL PROCESO “RESOLVER SISTEMA DE ECUACIONES DE LA ESTRUCTURA”. ................. 65
FIGURA 43E. DIAGRAMA DE COLABORACIÓN DEL PROCESO “RESOLVER SISTEMA DE ECUACIONES DE LA ESTRUCTURA”. ................................................................................................................................................ 65
FIGURA 43F. DIAGRAMA DE SECUENCIA PARA EL PROCESO “CALCULAR FUERZAS INTERNAS”. ...................... 66
FIGURA 43G. DIAGRAMA DE ACTIVIDADES PARA EL PROCESO “CALCULAR FUERZAS INTERNAS”. .................. 66
FIGURA 43H. DIAGRAMA DE SECUENCIA PARA EL PROCESO “CALCULAR REACCIONES”. ............................... 67
FIGURA 43I. DIAGRAMA DE ACTIVIDADES PARA EL PROCESO “CALCULAR REACCIONES”. ............................. 67
FIGURA 43J. DIAGRAMA DE COLABORACIÓN PARA EL PROCESO “CALCULAR FUERZAS INTERNAS”. ............... 68
FIGURA 43K. DIAGRAMA DE COLABORACIÓN PARA EL PROCESO “CALCULAR REACCIONES”. ......................... 68
FIGURA 43L. DIAGRAMA DE ESTADOS PARA EL PROCESO GLOBAL “ANALIZAR ESTRUCTURA”. ...................... 69
FIGURA 43M. DIAGRAMA DE COMPONENTES. ............................................................................................... 70
FIGURA 43N. DIAGRAMA DE DESPLIEGUE. ...................................................................................................... 70
FIGURA 44. IMPLEMENTACIÓN EN JAVA DE LA CLASE ABSTRACTA “CARGAELE00”. ........................................ 71
FIGURA 45. PROTOTIPO PARA LA INTERFAZ DE USUARIO. .............................................................................. 72
FIGURA 46 – CASO DE ESTUDIO ...................................................................................................................... 73
FIGURA 47. ENTRADA DE LA ESTRUCTURA. ..................................................................................................... 76
5
FIGURA 48. GEOMETRÍA DE LA ESTRUCTURA .................................................................................................. 77
FIGURA 49. DEFORMADA DE LA ESTRUCTURA ................................................................................................ 77
FIGURA 50. FUERZAS INTERNAS ..................................................................................................................... 80
FIGURA 51. GEOMETRÍA Y NUMERACIÓN DE LOS 36 NUDOS DEL PÓRTICO. ................................................... 84
FIGURA 52. VISTA EN PERSPECTIVA DE LA ASIGNACIÓN DE CARGAS PUNTUALES Y DISTRIBUIDAS DEL PÓRTICO. ........................................................................................................................................................ 84
FIGURA 53. CÓDIGOS PARA TIPOS DE CARGAS. .............................................................................................. 85
FIGURA 54. VERIFICACIÓN GEOMÉTRICA DEL PÓRTICO SEGÚN LA APLICACIÓN DESARROLLADA EN ÉSTA INVESTIGACIÓN. ............................................................................................................................................. 87
FIGURA 55. VERIFICACIÓN GEOMÉTRICA DEL PÓRTICO SEGÚN LA APLICACIÓN SAP2000. .............................. 87
FIGURA 56. DEFORMADA DEL PÓRTICO LUEGO DEL ANÁLISIS MEDIANTE LA APLICACIÓN DE ÉSTA INVESTIGACIÓN. ............................................................................................................................................. 90
FIGURA 57. DEFORMADA DEL PÓRTICO LUEGO DEL ANÁLISIS MEDIANTE LA APLICACIÓN SAP2000. .............. 90
FIGURA 58. FUERZAS INTERNAS POR EL PROGRAMA PROPUESTO. ................................................................. 91
FIGURA 59. F. INTERNAS PRODUCIDAS POR EL SAP2000. ................................................................................ 91
FIGURA 60. FUERZAS INTERNAS DE LA COLUMNA 37 SEGÚN EL SAP2000. ...................................................... 92
FIGURA 61. FUERZAS INTERNAS DE LA COLUMNA 37 SEGÚN EL MODELO PROPUESTO. ................................. 92
FIGURA 62. REACCIONES EN LOS APOYOS CALCULADAS POR LA APLICACIÓN PROPUESTA. ............................ 93
FIGURA 63. REACCIONES EN LOS APOYOS CALCULADAS POR EL PROGRAMA SAP2000. ................................. 93
FIGURA 64. CÓDIGO FORTRAN. ....................................................................................................................... 96
FIGURA 65. CÓDIGO JAVA. .............................................................................................................................. 96
FIGURA 66. CÓDIGO JAVASCRIPT .................................................................................................................... 97
FIGURA 67. CÓDIGO JAVA. .............................................................................................................................. 97
FIGURA 66A. CÓDIGO JSCRIPT. ....................................................................................................................... 98
FIGURA 67A. CÓDIGO JAVA. ........................................................................................................................... 98
FIGURA 68. COMPLEJIDAD DEL ALGORITMO PROCEDIMENTAL PROGRAMADO EN RPL. ................................ 102
FIGURA 69. COMPLEJIDAD DEL ALGORITMO RESULTANTE DEL MODELO OO DE LA APLICACIÓN EN JAVA. .... 102
FIGURA 70. PÓRTICOS DE VARIOS PISOS EMPLEADOS PARA EL CÁLCULO DEL ORDEN DE COMPLEJIDAD. ..... 103
FIGURA C1. VISTA POSTERIOR DEL EDIFICIO “EL ALCÁZAR”. ........................................................................... 136
FIGURA C2. EL PILAR COLAPSADO DE LA TORRE CÓRDOBA DEL EDIFICIO EL ALCÁZAR. .................................. 139
FIGURA C3. LA UNIÓN DE LOS 2 ELEMENTOS VIGA NO FUERON CONSTRUIDOS SOBRE EL CENTRO DE LA COLUMNA. ..................................................................................................................................................... 140
FIGURA C4. EFECTOS DEL COLAPSO: EL TRAUMA SOCIAL. .............................................................................. 141
FIGURA C5. GEOMETRÍA ANTES Y DESPUÉS DEL ANÁLISIS DEL SISTEMA ESTRUCTURAL INTACTO (TORRE CÓRDOBA). .................................................................................................................................................... 143
FIGURA C6. GEOMETRÍA ANTES Y DESPUÉS DEL ANÁLISIS DEL SISTEMA ESTRUCTURAL AFECTADO (TORRE CÓRDOBA). .................................................................................................................................................... 143
6
Parte1–MarcoReferencial
1.1 Introducción
Las estructuras materializadas en obras civiles, herramientas mecánicas, medios de transporte
terrestres, aeroespaciales, navales, etc. juegan un rol de servicio a diario muy importante para la
humanidad. Las estructuras se presentan en todo el Mundo a diversas escalas y complejidades de
diseño como ser: cimentaciones, edificaciones, puentes, muros, carreteras, torres de transmisión,
presas, canales, vehículos, aviones, barcos, máquinas, reactores nucleares, etc.
Figura 1. Ejemplo de estructura de transporte
El fuselaje del avión Boeing 747 es un ejemplo de
estructura de transporte aéreo que fue analizado y
diseñado mediante el método de los elementos finitos.
Su cálculo involucró un sistema de ecuaciones de más
de 7000 incógnitas. [Gallagher 1975]
1.1.1 ¿Quéeselanálisisestructuralyparaquésirve?
El análisis estructural es una rama de las ciencias físicas que trata sobre el comportamiento de las
estructuras bajo ciertas condiciones de diseño. Las estructuras son sistemas que soportan carga y el
comportamiento se entiende como su tendencia a deformarse, vibrar, pandearse o fluir dependiendo a
las condiciones a las cuales estén sometidas. Los resultados del análisis se usan para determinar la
deformación de la estructura y verificar si son adecuadas para las cargas para las cuales se las ha
diseñado. El resultado es único y depende solamente de las condiciones iniciales. Véase figuras 2 y 3.
7
Figura 2. El fin es
diseñar una estructura y
el análisis estructural es
una de las herramientas
para alcanzar tal fin.
[Kardestuncer 1974]
Figura 3. Deformada del pórtico de un edificio sometido a cargas laterales.
1.1.2 ¿Quéeselmétododeloselementosfinitosyparaquésirve?
El método de los elementos finitos (MEF) es la manera más extendida para simular sistemas de
ingeniería en computadoras. El MEF ha sido usado para predecir el comportamiento de sistemas
estructurales, mecánicos, térmicos, de flujo de fluidos, eléctricos y químicos. El MEF ha sido aplicado
tanto a sistemas lineales o no lineales sean o no tiempo dependientes. El MEF se aplica a sistemas
formados por cualquier material y geometría. En el Mundo se emplea anualmente más de un billón de
dólares en gastos concernientes al uso del MEF. El MEF ha sido desarrollado por Jon Turner,
ingeniero líder de la compañía BOEING, entre 1956 y 1962 con el fin de lograr un mejor cálculo para
la rigidez de las alas de un avión destinado a vuelo supersónico. [Baran 1987]
8
La tecnología MEF consiste básicamente en: una librería de elementos modelo básicos,
un proceso para combinar todos estos modelos en un modelo matemático global del
sistema de ingeniería en cuestión y un algoritmo para la resolución numérica de las
ecuaciones del sistema. Por ejemplo, los requisitos de seguridad en una estructura tipo
reactor nuclear solo pueden lograr un alto grado de confiabilidad mediante un diseño
por el MEF. Véase las figuras 4a y 4b.
Figura 4a. Estructura de concreto pretensado de un
reactor nuclear vessel.
Figura 4b. Modelo de elementos finitos de un
octante de la estructura. Elemento básico:
tetraedro.
Esta investigación está orientada a sistemas estructurales planos; es decir, a pórticos o
marcos rígidos que soportan cargas en el mismo plano de los elementos (figura 5). Se
usará el elemento finito viga doblemente empotrada con sistema de ejes locales
Kardestuncer. Y se aplicará el método matricial de la rigidez como proceso para
obtener el modelo matemático global de la estructura.
9
Figura 5. Sistema estructural
plano: un pórtico o marco rígido
de 20 nudos, 28 elementos viga y
4 apoyos fijos.
En la figura 6 se tiene un elemento finito viga doblemente empotrado 3D. Se usará un elemento finito viga 2D en el plano xy.
Conforme se puede corroborar en el estado del arte a la fecha, todos los trabajos así como los programas realizados, por
cuestiones de simplificación, han empleado ampliamente un mismo sistema de ejes locales en ambos extremos del elemento
(figura 7a). Entonces, cuando se llega a los resultados del análisis, hay que hacer una serie de interpretaciones para llegar a las
fuerzas internas reales porque el uso de un mismo sistema de ejes en ambos extremos genera ciertas ambigüedades como ser:
¿en qué extremo el eje local x indica la dirección de la tensión? algunos suponen que va de izquierda a derecha pero queda el
interrogante de cuál es el extremo izquierdo y así. Para evitar cualquier ambigüedad, en esta investigación se propone un
sistema de ejes locales independiente para cada extremo del elemento según la teoría estructural de Kardestuncer (figura 7b).
Figura 6. Elemento finito 3D viga doblemente
empotrado.
Figura 7. Sistemas de ejes locales: (a) tradicional
(b) Kardestuncer.
10
1.1.3 ¿Quéeselmétodomatricialdelarigidezyparaquésirve?
El método matricial de la rigidez es un proceso universalmente aceptado para el análisis estructural en
computadoras que proporciona un algoritmo rápido y preciso para el análisis de estructuras complejas.
El objetivo del método de la rigidez es establecer la relación entre las cargas externas y los
desplazamientos en los nudos de la estructura. El método directo de la rigidez sustituye la actual
estructura continua por un modelo equivalente compuesto por elementos discretos (i.e. finitos) cuyas
propiedades elásticas e inerciales están expresadas matricialmente. Estas matrices conocidas como
matrices de rigidez de los elementos constituyen los bloques constructivos básicos que al ser
combinados en conjunto de acuerdo a una serie de reglas derivadas de la teoría de la elasticidad
conforman la matriz de rigidez global que representa a las propiedades estáticas y dinámicas del
sistema estructural. Los principios fundamentales sobre los cuales se sustenta el método matricial de la
rigidez son: los principios de los desplazamientos y fuerzas virtuales, los teoremas de Castigliano, el
teorema de la mínima energía, el teorema de la mínima energía complementaria y los teoremas del
desplazamiento y carga unitarios(as). [Kardestuncer 1974]
Por ejemplo, el ensamblado de la matriz de rigidez global del marco plano de la figura 8 (izq.) está
compuesto a su vez por las matrices de rigidez de cada elemento de la estructura. Cada componente Kij
de la matriz global K es una matriz 3x3 correspondiente a la viga o elemento que está entre los nudos i
y j. En consecuencia la matriz de rigidez global para esta estructura es de orden 21. Cada sub-matriz
Kii de la diagonal principal representa la rigidez del nudo i o sea la sumatoria de todas las matrices de
rigideces de los elementos que parten del nudo i. La matriz global K siempre es simétrica. Si no
existen elementos entre los nudos i y j entonces Kij es cero
Figura 8. Modelo completo de la matriz de rigidez global (der.) de un determinado marco rígido plano
(izq.)
11
1.1.4 ¿Quéesunobjetoyparaquésirve?
Un objeto se define en dos términos: atributos y comportamiento. Un objeto es una entidad que
contiene ambos: datos y comportamiento. Los objetos son los bloques constructivos básicos de un
programa orientado a objetos (OO). Un software que usa el paradigma OO consiste básicamente en una
colección de objetos. En la programación procedimental tanto el código como los datos están
localizados de manera separada. En un diseño OO, los atributos y el comportamiento están contenidos
en un solo objeto. Por consiguiente, como en la programación procedimental los datos están separados
de los procedimientos, muchas veces los datos están a nivel de contexto global de tal manera que
pueden ser modificados por cualquier subrutina o función implicando que el acceso a los datos pueda
ser incontrolado e impredecible. Entonces, como uno no tiene el control de que subrutinas podrían
haber accedido a los datos, las pruebas y depuración del software son muy difíciles. Los objetos
resuelven todos estos problemas al combinar datos y comportamiento en un paquete completo. La
combinación de datos y comportamiento (métodos) en una misma entidad se denomina encapsulación
(figura 9). Otros conceptos adicionales del paradigma OO son: herencia, polimorfismo, composición,
abstracción, dependencia, etc.
Figura 9. El concepto de encapsulación en un objeto. [Y. Caballero 2007]
Como el análisis y diseño orientado a objetos (OO) permite la creación y utilización de nuevas
estructuras de datos, ha sido exitosamente empleado en todo tipo de aplicaciones. Las tecnologías OO
llevan a reutilizar componentes de software lo que conlleva a un desarrollo de software más rápido y de
mejor calidad. El software OO es más fácil de mantener debido a que su estructura es inherentemente
poco acoplada. Esto lleva a menores efectos colaterales cuando se deben hacer cambios. Los sistemas
OO son más fáciles de adaptar y fácilmente escalables (pueden crearse grandes sistemas ensamblando
subsistemas reutilizables).
ATRIBUTOS
COMPORTAMIENTO
12
En el contexto de esta investigación, dado que los elementos finitos de un pórtico o marco rígido plano
poseen propiedades y comportamiento, y comparten muchas propiedades entre ellos y con la estructura
misma, éstos pueden implementarse ventajosamente en soluciones basadas en modelos OO.
1.2 DefinicióndelProblema
Programar tópicos como el análisis de estructuras mediante el MEF en lenguajes estructurales o basados en procedimientos, implica
una gran extensión de código distribuido en subrutinas y funciones. Puesto que el análisis estructural involucra operaciones
matriciales que incluyen a todas las propiedades del elemento, éstas deben implementarse mediante ciclos explícitos. En ingeniería
del software, se denomina “complejidad ciclomática” al grado de profundidad de las anidaciones. Otras operaciones como las
asignaciones vectoriales también deben programarse dimensión a dimensión generando así ineficiencia. Además, debe reservarse
considerable cantidad de variables para almacenar -por ejemplo- la configuración geométrica, las propiedades de los materiales y las
cargas aplicadas en la estructura; esto, debido a una falta de tipos de datos específicos que permitan un alto nivel de abstracción. Así,
el código resultante es difícil de leer, escribir y depurar; y se aleja en forma del formulismo de la teoría estructural. Además, su
mantenimiento y extensión requieren de un alto grado de conocimiento del programa entero reflejado en el esfuerzo horas-hombre y
siendo un obstáculo para futuros ingenieros e investigadores.
1.2.1 FormulacióndelProblema
¿Existe un modelo conceptual orientado a objetos que pueda abstraer y simplificar la complicada
codificación del cálculo estructural matricial de pórticos planos mediante MEF que a su vez sea capaz
de producir resultados completos según la teoría de ejes locales de Kardestuncer?
1.3 Objetivos
13.1 General
El objetivo de ésta investigación es proveer y probar una nueva arquitectura orientada a
objetos para que el software de análisis estructural de pórticos planos mediante
elementos finitos – elemento viga y sistema de ejes locales Kardestuncer, sea fácil de
entender, implementar, extender y modificar.
13
1.3.2 Específicos
Diseñar el modelo orientado a objetos usando el lenguaje unificado de modelado
UML.
Implementar el modelo orientado a objetos en el lenguaje de programación Java.
Resolver un caso de estudio y compararlos con resultados mediante herramientas
tradicionales.
1.4 Hipótesis
El diseño de un modelo para la codificación de un programa para el análisis estructural
de pórticos planos a partir del paradigma orientado a objetos mediante elementos
finitos – elemento viga y sistema de ejes locales Kardestuncer, involucra una mayor
claridad de código, minimiza la cantidad de ciclos anidados explícitos de cálculo,
incrementa la eficiencia de cómputo y mejora los resultados de las fuerzas internas que
sufren los elementos de una estructura objeto de análisis; además de permitir su
escalabilidad.
Independiente Moderante Dependiente
El diseño de un modelo para la
codificación de un programa
para el análisis estructural de
pórticos planos a partir del
paradigma orientado a objetos
mediante elementos finitos –
elemento viga y sistema de ejes
locales Kardestuncer
Mejora Claridad del código.
Minimiza La cantidad de ciclos anidados
explícitos de cálculo.
Incrementa La eficiencia de cómputo.
Mejora Los resultados de las fuerzas internas
que sufren los elementos.
Permite Escalabilidad.
14
Nota
La claridad del código puede medirse según la cantidad de líneas de programación necesarias para
ensamblar, por ejemplo, una ecuación matricial de la teoría estructural bajo el paradigma OO y
comparándola con la correspondiente al código basado en otros paradigmas (e. g. estructural,
procedimental).
1.5 Justificación
La justificación es teórica porque con un modelo OO se pretende aportar y desarrollar un aspecto
específico de la ingeniería estructural como el modelado del análisis de estructuras por elementos
finitos – elemento viga y ejes locales Kardestuncer para su implementación en lenguajes de
programación OO.
La justificación tiene impacto social porque con ésta investigación se pretende dejar a disposición de
estudiantes avanzados, profesionales e investigadores de ingeniería civil, estructural y mecánica, una
técnica (materializada en una herramienta) para un análisis más eficiente y real de estructuras planas;
las mismas que, tienen alta relevancia en la sociedad por estar involucradas en obras civiles de servicio
a la sociedad. (e.g. edificaciones, puentes, torres, etc.)
La justificación es tecnológica porque con éste modelo se pretende aplicar y aprovechar la
disponibilidad de lenguajes de programación de última generación orientado a objetos robustos y
extensibles como el lenguaje Java que se combina inclusive con la tecnología Web actual.
1.6 AlcancesyLimitaciones
El alcance de ésta investigación es de carácter exploratorio porque se pretende indagar el tema desde
una nueva perspectiva y porque se desea ampliar una área existente.
El modelo orientado a objetos que llegue a diseñarse se limitará al análisis estático lineal de estructuras
en dos dimensiones, elemento viga doblemente empotrada, cargas puntuales en los nudos, cargas
distribuidas sobre los elementos y apoyos fijos.
La implementación de la aplicación resultante del modelo OO será de carácter inicial y estará limitada
a computadoras de escritorio o portátiles con el complemento de la máquina virtual de Java instalado.
15
Soportará solamente entrada y salida de datos mediante archivos separados por comas extensión CSV.
Ofrecerá una gráfica básica tanto de la geometría de la estructura como su deformada resultante. La
aplicación estará destinada a usuarios avanzados, profesionales o investigadores de ingeniería civil,
estructural y mecánica.
16
Parte2–MarcoTeorico
2.1 EstructurasdeIngeniería
Para el ingeniero es muy importante el proyecto de puentes, edificios, torres y otras
estructuras fijas. Tales estructuras están compuestas por elementos unidos entre sí y
sustentados de modo que puedan soportar en equilibrio estático las fuerzas externas
aplicadas. Pero una estructura también debe estar en equilibrio con las fuerzas de la
gravedad que le son aplicadas como consecuencia de su propio peso. Por ejemplo,
sobre una torre de línea de transmisión actúan su propio peso, las cargas de viento y
hielo aplicadas directamente a la torre y las fuerzas aplicadas a ella por los cables que
soporta. Debe entonces calcularse los elementos de la torre de modo que puedan
soportar las cargas en equilibrio estático y transferir así sus efectos a la cimentación.
Además de las ya mencionadas, hay muchas otras estructuras: presas, muelles, losas de
pavimento de aeropuertos y carreteras, tuberías a presión, depósitos reguladores
(estanques), viaductos, etc. Pero no solo hay estructuras de importancia para el
ingeniero civil: la estructura de un avión es importante para el ingeniero aeronáutico,
la de un barco para el ingeniero naval, recipientes de alta presión y otro equipo
industrial para el ingeniero químico, partes de máquinas y soportes de adecuada
resistencia estructural serán tema del ingeniero mecánico y el ingeniero eléctrico estará
ocupado con el equipo eléctrico y sus bastidores.
El análisis de todas estas estructuras está basado en los mismos principios
fundamentales. En ésta investigación, los ejemplos que se usan para mostrar la
aplicación de dichos principios casi siempre tratan de estructuras de ingeniería civil
pero los métodos de análisis descritos pueden usarse para estructuras que tengan
aplicación en otras ramas de la ingeniería (véase figura 10).
Una estructura se proyecta para que cumpla con una misión determinada para lo cual
debe tener la suficiente resistencia y rigidez. Otros aspectos de gran importancia son la
economía y el buen aspecto.
17
El proyecto completo de una estructura comprende 5 etapas:
1) Determinar los requisitos funcionales de la estructura
2) Considerar varias soluciones que satisfagan estos requisitos
3) Proyecto estructural preliminar de las posibles soluciones
4) Elegir la solución más satisfactoria considerando la economía, la funcionalidad y la estética
5) Detallar el proyecto de la solución elegida
2.1.1 AnálisisEstructural
La historia del análisis estructural comienza mucho antes de la era de los egipcios,
romanos y griegos. Las ruinas actuales indican que ciertos principios de la estática del
análisis estructural fueron conocidos por sus constructores. Arquímedes (287-212
A.C.) introdujo el concepto de centro de gravedad y llevo a su más simple expresión
los principios fundamentales de la estática y equilibrio.
(10a) Puente metálico.
(10b) Cimentación: zapata de concreto.
18
(c) Modelo de elementos finitos de una presa de
concreto.
(d) Muro de contención de hormigón
armado.
(e) Vehículo aerodinámico.
(f) Aeronave delta.
Figura 10. Estructuras de diversas ramas de la ingeniería.
19
La era de los maestros: Leonardo Da Vinci (1452-1519), Galileo Galilei (1564-1642), Fontana (1543-
1607) y Minar Sinan (1490-1588) de Estambul. Todos ellos tuvieron gran sentido acerca de las
estructuras y sus éxitos se basaron en sus talentos innatos.
La era de los matemáticos: Hooke (1635-1703), Johann Bernoulli (1667-1748), Daniel Bernoulli
(1700-1782), Euler (1707-1783) y Lagrange (1736-1813). Todos ellos establecieron los principios
fundamentales de los conceptos de energía, la relación entre esfuerzos y deformaciones, las ecuaciones
diferenciales de deformaciones y sus soluciones. Su interés fue más bien la teoría matemática de la
elasticidad en pro de la teoría de estructuras.
La era de los ingenieros: Navier (1785-1836), Saint-Venant (1797-1886), Clapeyron (1799-1864), Airy
(1801-1892), Maxwell (1831-1879), Castigliano (1847-1884), Mohr (1835-1918) y Muller-Breslau
(1851-1925). Todos ellos emplearon exitosamente las formulas desarrolladas en la era anterior para
resolver estructuras. Sus descubrimientos y teoremas fueron la base para el desarrollo de la teoría
estructural. Esta era es la edad de oro de la ingeniería estructural.
La era moderna: A comienzos del siglo XX hombres como Maney, Cross, Southwell y Kani,
introdujeron métodos prácticos manuales para analizar estructuras complejas. Ellos introdujeron,
respectivamente, los métodos de la deflexión de la pendiente, distribución de momentos, relajación y
distribución de esfuerzo cortante. Estos métodos llegaron a ser muy empleados en consultoras de
ingeniería debido a su simplicidad para el cálculo manual.
Galileo
Hooke
Castigliano
Cross
La era contemporánea: Hacia la mitad del siglo XX fueron desarrolladas las computadoras y los
ingenieros fueron impulsados a establecer métodos que requieran menos implicaciones logrando
mejores resultados. Fue introducido el método matricial de análisis estructural que se aplica en la
presente investigación.
20
Considerando que la deformada total (figura 3) es la suma de las deformaciones unitarias
y la fluencia se debe al exceso de esfuerzo y además que el esfuerzo y la deformación
están relacionadas entre sí por el módulo de elasticidad E (i. e. módulo de Young), el
análisis de estructuras se reduce en sí al cálculo del estado de deformación y esfuerzo a
través de la estructura. Puesto que los esfuerzos son los valores que limitan las fuerzas
internas, solo queda calcular las fuerzas internas del sistema.
La ingeniería de estructuras trata principalmente sobre tres temas básicos: el análisis
estructural, el análisis de esfuerzos y el diseño estructural. Todos a pesar de estar
interrelacionados, son tan distintos que se estudian independientemente. Su secuencia en
un proyecto estructural se ilustra en la figura 11.
Mientras que el análisis estructural se basa sobre los principios de la estática, el análisis
de esfuerzos se trata en materias como resistencia y la mecánica de materiales y la teoría
de la elasticidad. El diseño de estructuras asegura que en ningún lugar de un elemento se
presenten esfuerzos que exceden sus límites permitidos. Para lograr esto, si es necesario
se modifica el diseño haciendo que el análisis se repita nuevamente; el ciclo de la figura
11 continúa hasta que no se requiera modificación alguna.
Figura 11. La secuencia de un proyecto estructural. [Kardestuncer 1974]
Los resultados del análisis estructural consisten en los desplazamientos de ciertos puntos (nudos), las
fuerzas internas en los extremos de los elementos o ambos. El conocimiento de uno de ellos conduce
al otro sin mayor complicación.
21
2.1.2 MétododelosElementosFinitos(MEF)
[Reddy 1984] La idea de representar un determinado dominio como una colección de elementos
discretos no es nueva. Antiguos matemáticos estimaron el valor de pi (π) mediante el perímetro de un
polígono inscrito en un círculo. Predijeron al menos 40 dígitos de π representando el círculo con un
polígono de gran número finito de lados. A mitades del siglo XX el método de los elementos finitos
emerge del análisis estructural de una aeronave en la cual las alas y el fuselaje fueron modeladas a
partir de elementos tipo paneles (véase figura 10f). La presentación formal del MEF se atribuye a
Argyris y Kelsey (1960), y a Turner, Clough, Martin y Topp (1956). El término “método de los
elementos finitos” se atribuye a Clough en 1960.
En general, el objetivo del MEF es calcular con suficiente grado de precisión los valores de las
incógnitas de las ecuaciones diferenciales que gobiernan ciertos puntos del dominio de un sistema o
estructura continua. Se crea un modelo matemático del sistema físico o estructura dividido en nudos y
elementos finitos. A este modelo se aplican las ecuaciones que gobiernan el sistema. Se resuelve el
sistema de ecuaciones hallando así los resultados para cada nudo. Los pasos que involucra el MEF son:
1 El usuario crea el modelo de elementos finitos
a. Define la geometría, los nudos y elementos.
b. Especifica las propiedades de los materiales, las condiciones de carga y las condiciones de
contorno.
2 El software o programa de elementos finitos ejecuta el análisis
a. Formula el sistema de ecuaciones
b. Resuelve el sistema de ecuaciones
3 El programa de elementos finitos reporta los resultados
a. Calcula valores para los nudos y elementos (desplazamientos, fuerzas internas, reacciones,
etc.)
b. Procesa adicionalmente los resultados (gráficas, etc.)
Es importante recalcar que el modelo de los elementos finitos es una simulación matemática de la
estructura o sistema físico al cual representa.
22
La precisión del modelo de elementos finitos se mejora incrementando el número de nudos; no
obstante, se requiere mayor tiempo de máquina para calcular la solución. Se considera una pérdida de
tiempo crear modelos con una precisión mayor a la de los datos de entrada del análisis.
Figura 11b. Algoritmo del MEF
Antes de realizar un análisis de elementos finitos, es esencial conocer y entender bien el problema
físico. Sin una idea inicial de cómo se comportará una determinada estructura bajo sus condiciones de
carga, es muy difícil elaborar con precisión su modelo de elementos finitos. Si el objetivo es
determinar las fuerzas internas en una estructura, uno debe concentrarse en entender qué partes de la
estructura soportarán los mayores esfuerzos. La regla principal para los modelos de elementos finitos
es arrancar con un modelo inicial simple. Los resultados del análisis de éste modelo inicial indicarán la
necesidad o no de un refinamiento adicional para ganar mayor precisión si se requiere. O bien, éstos
mismos resultados iniciales, podrían indicar que la estructura está sobre-esforzada y lo que requiere es
un re-diseño de la misma en vez de crear un modelo más refinado.
Inicio
Leer nudos, elementos, cargas y condiciones de contorno
Ensamblar la matriz global de rigidez de la estructura
Ensamblar el vector generalizado de carga
Aplicar las condiciones de contorno
Calcular los desplazamientos de los nudos resolviendo el sistema de ecuaciones de la estructura
Calcular las fuerzas internas y reacciones
Fin
23
Figura 12a. Placa.
Figura 12b. Presa de tierra
(c) Torre de transmisión
(d) Puente colgante
(e) Armadura de un barco
(f) Aeronave comercial
Figura 12. Aplicación del modelo de elementos finitos en diversas estructuras.
24
2.1.3 MétodoMatricialdelaRigidezdeKardestuncer
Para calcular estructuras mediante el método de elementos finitos debe aplicarse un proceso de análisis
estructural: el método matricial de la rigidez conocido también como el método de los desplazamientos
o como el método del equilibrio (porque llega a producir una ecuación matricial de equilibrio de la
estructura).
El método de la matriz de rigidez determina primero los desplazamientos en ciertos puntos (nudos) y
luego las fuerzas internas en los elementos (figura 13b). Para calcular los desplazamientos de una
determinada estructura bajo ciertas condiciones de carga, se debe hallar la rigidez de la estructura a
partir de sus elementos. Las rigideces individuales de los elementos se combinan mediante un
procedimiento matricial produciendo finalmente una ecuación matricial que relaciona las cargas
aplicadas con los desplazamientos de los nudos correspondientes (ecuación 1). La principal
suposición del método de la rigidez es que, la estructura pueda ser satisfactoriamente representada por
un ensamblado de elementos discretos (i. e. finitos) interconectados que representan a la estructura
continua.
Figura 13a. Pórtico o marco rígido 2D (4
nudos, 3 elementos viga y carga puntual)
Figura 13b. Fuerzas internas que sufren los elementos.
En la ecuación 1, P es el vector fuerza generalizado que representa a las cargas aplicadas en los nudos
de una estructura. K es la matriz de rigidez de toda la estructura (véase la figura 8). Y Δ (delta) es el
vector generalizado de los desplazamientos de los nudos de la estructura. Véase también la figura 14.
P K∆ (1)
25
Figura 14a. El sistema de ecuaciones final para
la solución de la figura 14b. Nótese que es de
la forma de la ecuación 1.
Figura 14b. Una estructura generalizada y su
deformada en línea segmentada. Nótese que cada
derivada parcial representa a la rigidez del nudo
correspondiente.
El método matricial de la rigidez se basa en la aplicación de tres principios básicos:
(1) Ley de Hooke. Las fuerzas internas de los elementos y los desplazamientos en sus extremos
deben guardar una relación elástica lineal.
(2) Compatibilidad. Los desplazamientos en los extremos de los elementos deben ser iguales a los
desplazamientos de los nudos.
(3) Equilibrio. Las cargas externas aplicadas y las fuerzas en los miembros deben estar en
equilibrio.
2.1.4 AnálisisdeMarcosRígidosPlanos
Los marcos rígidos planos o pórticos son estructuras bidimensionales cuyas cargas externas están en el
mismo plano de la estructura (figura 15b). Tienen uniones (nudos) perfectamente rígidos y los ángulos
entre los elementos no cambian. Un nudo puede rotar siempre y cuando roten también los elementos
asociados al nudo. La deformada de un pórtico debido a una condición de carga induce momentos
flectores, fuerzas axiales y cortantes.
26
Figura 15a. Cercha o armadura 2D con cargas en los nudos
superiores que bien podría ser el modelo de elementos
finitos de un techo de una edificación o galpón.
Figura 15b. Marco rígido plano 2D que
representa el modelo de elementos
finitos de una edificación.
Nota.- Las cerchas o armaduras son también estructuras planas cuyas cargas comparten el
mismo plano de la estructura (figura 15a). La diferencia con los marcos planos radica en
que los nudos de las cerchas son articulados (pueden rotar) y las cargas externas solo se
aplican en los nudos. Se pueden modelar y calcular cerchas con procedimientos y
software para marcos planos siempre y cuando se use el artificio de manejar un valor del
momento de inercia sumamente pequeño o casi cero (e. g. 0.0000000001).
El objetivo del análisis es establecer la relación entre las cargas externas y los
desplazamientos en los nudos de la estructura. Las cargas externas son normalmente
dadas (o pueden ser expresadas) y referidas al sistema general de coordenadas XY de la
estructura (figura 16). De esta manera el vector fuerza P (véase ecuación 1) no es
problema ya que representa una lista en secuencia (Px, Py, M) de las fuerzas externas
desde el primer hasta el último nudo. El vector desplazamiento sigue la misma secuencia
o sea (Δx, Δy, θ) para cada nudo de la estructura. El principal problema es ensamblar la
matriz de rigidez K de la estructura. Para esto, lo primero que debe hacerse es calcular
la matriz de rigidez k de cada elemento en el sistema local de coordenadas tipo
Kardestuncer. Las sub-matrices de las rigideces para un elemento finito viga doblemente
empotrada se muestran en la ecuación 2. Nota: i y j son los nudos de los extremos del
elemento; E es el módulo de Young; A el área de la sección, L la longitud e I el momento
de inercia de la sección del elemento.
27
Figura 16. Elemento finito viga en el plano XY de la estructura entre los nudos i y j. Nótese el sistema
de ejes locales Kardestuncer en cada extremo del elemento.
k/ 0 00 12 / 6 /0 6 / 4 /
/ 0 00 12 / 6 /0 6 / 2 /
(2)
El siguiente paso será transformar las matrices de la ecuación (2) de coordenadas locales
a coordenadas generales. Para esto es necesario el cálculo de la matriz de rotación R
entre estos sistemas de coordenadas. Si Rij es la matriz de rotación para rotar un vector
de coordenadas generales a locales (véase ecuación 3), entonces la inversa de R hace la
transformación inversa. Ya que ambos, el sistema general y el sistema local de
coordenadas, son ortogonales, la inversa de R es igual a su transpuesta.
R00
0 0 1 (3)
En resumen, los pasos del análisis estructural de marcos rígidos planos mediante el método de los
elementos finitos elemento viga doblemente empotrada (figuras 6 y 16) sistema de ejes locales
Kardestuncer (figuras 7 y 16), son los siguientes:
1 Establecer cualquier sistema general de coordenadas XY en el plano de la estructura.
2 Asignar un número a cada nudo de la estructura (incluyendo los apoyos).
28
3 Registrar las coordenadas generales (Xi, Yi) de cada nudo.
4 Para i < j, calcular K R k R y localizaren la fila i columna j de la matriz K de la
estructura.
5 Calcular K R k R y sumar a la sub-matriz existente en la fila i columna i de la
matriz K de la estructura.
6 Repetir los pasos 4 y 5 para cada elemento de la estructura.
7 Aplicar las condiciones de contorno eliminando las correspondientes filas y columnas de la
matriz K de la estructura.
8 Listar todas las cargas externas aplicadas en los nudos en secuencia (Px, Py, M) para
formar el vector fuerza generalizado P.
9 Resolver la ecuación matricial resultante que será de la forma de la ecuación 1. Los
resultados serán los desplazamientos de los nudos o sea el vector generalizado Δ en la
secuencia (Δx, Δy, θ) para cada nudo.
10 Calcular las fuerzas internas en los extremos de los elementos en coordenadas locales
usando la ecuación p k R ∆ k R ∆
11 Calcular las reacciones en los apoyos a partir de los resultados del paso 10 sumando las
fuerzas externas en los extremos de los elementos que concurren a los apoyos.
2.2AnálisisyDiseñoOrientadoaObjetosADOO
La primera vez que se propuso un enfoque orientado a objetos para el desarrollo de
software fue a finales de los años 60. Sin embargo, las tecnologías de objetos han
necesitado casi 20 años para llegar a ser ampliamente usadas.
El propósito del ADOO es definir todas las clases que son relevantes al problema que se
va a resolver, las operaciones y atributos asociados, las relaciones y comportamientos
asociados con ellos. El diseño orientado a objetos transforma el modelo de análisis
creado usando análisis orientado a objetos, en un modelo de diseño que sirve como
anteproyecto para la construcción de software.
29
2.2.1 ¿QuéesunObjeto?
Un objeto es la representación de una entidad. Un objeto puede representar algo concreto como una
estructura, etc. Un objeto es una abstracción. Un objeto tiene estado y comportamiento. Véase figura
17. ESTADO: El estado cambia con el tiempo y está definido por un conjunto de propiedades
(atributos). COMPORTAMIENTO: El comportamiento es todo lo que un objeto puede hacer.
Figura 17. Objeto: estructura; comportamiento: deformarse.
2.2.2 ¿QuéesunaClase?
Una clase es la plantilla de un grupo de objetos con propiedades comunes (atributos) y
comportamientos comunes (operaciones). Cada objeto es la instancia de una clase (véase figura 18).
Los mensajes son los mecanismos de comunicación entre objetos.
Figura 18. Ejemplo: clase automóvil.
2.2.3 Encapsulación
Encapsular datos y comportamiento en un simple objeto es de vital importancia en el desarrollo OO. La encapsulación
garantiza que los usuarios de un objeto no puedan modificar su estado sin usar su interfaz (métodos accesibles por otros
objetos). La ventaja de la encapsulación radica en que si se modifica algo de un módulo interno sin alterar su interfaz, dicho
cambio no implicaría ninguna modificación en el sistema. Véase la figura 9.
30
2.2.4 Interfaz
La interfaz es el medio fundamental de comunicación entre objetos. Cada clase deberá especificar sus
interfaces para una adecuada instanciación y operación de los objetos.
Implementación
Solo los atributos y métodos públicos son considerados interfaces. El usuario de un objeto debería interactuar con el mismo
únicamente por medio de las interfaces y no debería poder ver nada de la implementación. Véase figura 19.
Figura 19. Ejemplo de interfaz e implementación. Un objeto como una computadora puede tomar energía
eléctrica conectándose al enchufe (interfaz). La planta de generación de energía eléctrica (der.) es la implementación. Esta
planta puede ser hidroeléctrica o nuclear lo cual no importa mientras se dé energía eléctrica a la computadora.
2.2.5 Herencia
Consiste en compartir atributos y operaciones entre clases con base en una relación jerárquica. Una
clase padre (superclase) puede ser refinada en sucesivas subclases más definidas. La herencia es uno
de los mecanismos más poderosos de la orientación a objetos porque permite la re-utilización de
código.
Herencia Múltiple
Recurso que permite la definición de una subclase con más de una superclase. Esto permite la
combinación de dos o más orígenes.
31
2.2.6 SuperclasesySubclases
La superclase (o clase padre) contiene todos los atributos y comportamientos que son comunes a las
clases que heredan de ella. Estas clases que heredan de ella se denominan subclases. Véase figura 20.
2.2.7 Abstracción
En la tecnología OO las clases son la abstracción fundamental. Mediante la abstracción se parte de algunos casos concretos
de entidades (objetos) y se generan clases. La abstracción consiste en estudiar los conceptos fundamentales del dominio de
estudio obviando temporalmente las decisiones de diseño e implementación.
Relación “es un tipo de”
Supóngase por ejemplo que, el círculo, el cuadrado y el triángulo son clases que se heredan directamente de una
superclase llamada “figura”. Esta relación es muchas veces referida como una relación “es un tipo de” puesto que un
círculo es una figura o un cuadrado es una figura. Entonces, el círculo, el cuadrado y el triángulo son extensiones de una
figura. Véase figura 20.
Figura 20. Ejemplo de herencia: jerarquía de figuras.
2.2.8 Polimorfismo
Mecanismo que permite a la subclase implementar la misma operación (método) con un procedimiento diferente. La
misma operación puede actuar de modos diversos en clases diferentes. Al definir clases para figuras geométricas (rectas,
32
circunferencias, elipses y polígonos), la operación fundamental del cálculo del área se brinda al polimorfismo. Véase
figura 21.
Figura 21. La jerarquía Figura.
2.2.9 Composición
Cuando los objetos están compuestos a partir de otros objetos, esto se denomina composición. Es natural pensar que los
objetos siempre contienen otros objetos. Por ejemplo, un carro tiene un motor, tiene suspensión y tiene transmisión. Véase la
figura 22.
Relación “tiene un”
Aunque la relación de herencia es considerada una relación “es un tipo de” por razones discutidas
anteriormente, una composición es referida como una relación “tiene un”.
Figura 22. La jerarquía de la clase Carro.
+calcArea() : double
‐area : double
Figura
+calcArea() : double
‐largo : double‐ancho : double
Rectangulo
+calcArea() : double
‐radio : double
Circulo
33
2.2.10 Persistencia
La persistencia de un objeto se refiere al concepto de guardar el estado del mismo
para que pueda ser restaurado y usado posteriormente. Por ejemplo, el estado de un
objeto podría ser guardado en una base de datos.
2.2.11 ClasesAbstractas
Una clase abstracta es una clase que contiene uno o más métodos sin ninguna
implementación. Por ejemplo, la superclase “figura” es una clase abstracta porque
no se la puede instanciar. El concepto de “figura” es abstracto. Véase figura 21.
2.2.12 InterfaceJava
Una interface Java, a diferencia de una clase abstracta, no contiene absolutamente
ninguna implementación. Cualquier clase que implemente una interface Java deberá
proveer la implementación para todos los métodos de la interface.
Otras Consideraciones
Cuando se diseñan modelos de clases y objetos es de vital importancia entender
como los objetos están relacionados entre sí . Los conceptos primarios para la
construcción de objetos son: la herencia, las interfaces y la composición. Aplicando
bien estos conceptos se puede diseñar modelos sólidos de clases y objetos.
En ingeniería del software, el proceso de análisis es según el diagrama conceptual
de la figura 23.
34
Figura 23. El proceso de análisis en la ingeniería del software.
2.3 LenguajeUnificadodeModelado(UnifiedModelingLanguageUML)
El UML es un lenguaje para el modelado orientado a objetos. El UML permite a los
creadores de sistemas generar diseños que capturan sus ideas en forma convencional y
fácil de comprender para comunicarlas a otras personas. Esto se lleva a cabo mediante un
conjunto de símbolos y diagramas. Un modelo UML describe lo que supuestamente hará
el sistema pero no dice cómo implementar dicho sistema. El UML está compuesto por
diversos elementos gráficos que se combinan para conformar diagramas.
El UML es la creación de Grady Booch, James Rumbaugh e Ivar Jaacobson. En 1997 se
produjo la versión 1.0 del UML. El UML ha llegado a ser el estándar de facto en la
industria del software y su evolución continúa. Actualmente ya se ha superado la versión
2 del UML.
2.3.1 DiagramasdeUML
Se trata de herramientas para modelar las diferentes vistas de un sistema OO. Cada diagrama tiene
fines distintos dentro del proceso de desarrollo.
35
Diagrama de Casos de Uso
Un caso de uso es una descripción de las acciones de un sistema desde el punto de vista del usuario.
Véase la figura 24.
Figura 24. Diagrama de casos de uso.
Diagramas de Clases
Un diagrama de clases está formado por varios rectángulos conectados por líneas que muestran como
las clases se relacionan entre sí. Véase figuras 21 y 22.
Diagramas de Colaboración
Describe cómo los elementos de un sistema trabajan en conjunto para cumplir con los objetivos del
sistema. La figura 25 muestra parte del diagrama de colaboración para el caso de uso “calcular pórtico”
de una aplicación de análisis estructural.
Diagramas de Secuencia
El diagrama de secuencia muestra la mecánica de la interacción entre objetos con base en el tiempo.
La figura 26 muestra el diagrama de secuencia para el caso de uso “calcular pórtico” de una aplicación
de análisis estructural.
36
Figura 25. Diagrama de colaboración (diagrama de comportamiento).
Figura 26. Diagrama de secuencia (diagrama de comportamiento).
Diagramas de Estado
En un momento dado, un objeto se encuentra en un estado en particular. La figura 27 muestra el estado
de una estructura (objeto) durante el proceso de aplicación de carga de servicio.
37
Diagrama de Actividades
Describe las actividades que ocurren dentro un caso de uso o dentro del comportamiento de un objeto.
Las actividades normalmente se dan en secuencia. La figura 28 ejemplifica el diagrama de actividades
para el proceso “aplicar condiciones de contorno” para el análisis de una estructura dada.
Figura 27. Diagrama de estados
(diagrama de comportamiento).
Figura 28. Diagrama de actividades (diagrama de comportamiento).
Diagramas de Componentes
El moderno desarrollo de software se realiza mediante componentes lo cual es
importante en los procesos de desarrollo en equipo. Los componentes pueden ser
reutilizados. La figura 29 representa un posible diagrama de componentes para una
aplicación de cálculo de estructuras.
Diagramas de Distribución
Muestran la arquitectura física de un sistema informático. La figura 30 muestra una arquitectura
cliente-servidor.
38
Figura 29. Diagrama de componentes.
Figura 30. Diagrama de distribución.
2.4 MetodologíasdeDesarrollo
La estructura y naturaleza de los pasos en un esfuerzo de desarrollo es lo que se entiende
como metodología. Antes del desarrollo de un programa, se debe comprender con
claridad el problema lo cual requiere un análisis de requerimientos. Luego, dicho análisis
tiene que convertirse en diseño. De ésta manera se puede comenzar a producir el código
a partir del diseño. Véase también la figura 23.
Las metodologías de desarrollo iniciales como el método en cascada establece que el
análisis, diseño, codificación y distribución van uno después de otro. Esta metodología
antigua tiene la desventaja de tender a la realización de tareas individuales. Existe la
posibilidad de que el analista, el diseñador y el desarrollador rara vez trabajen juntos
para compartir puntos importantes.
Métodos recientes
En contraste con el método en cascada, la ingeniería del software tiende a la
colaboración entre las fases de desarrollo. La ventaja es que conforme crece la
comprensión, el equipo incorpora nuevas ideas y genera un sistema más confiable.
39
Figura 31. Metodología en cascada.
2.4.1 ProcesoRacionalUnificado(RUP)
RUP es un proceso de desarrollo de software para asegurar la producción de software de calidad dentro
de plazos y presupuestos predecibles. Dirigido por casos de uso, centrado en la arquitectura, iterativo e
incremental (versiones). RUP es una guía de cómo usar UML de la forma más efectiva. UML es la
base del modelamiento visual de RUP.
RUP divide el proceso de desarrollo en ciclos teniendo un producto al final de cada ciclo. Cada ciclo se
divide en cuatro Fases: 1) Inicio 2) Elaboración 3) Construcción 4) Transición. Cada fase concluye con
un hito bien definido donde deben tomarse ciertas decisiones. Véase figura 32.
En la fase inicio se producen requerimientos generales del proyecto, características principales,
restricciones y un modelo inicial de casos de uso.
En la fase de elaboración se tienen como objetivos: analizar el dominio del problema, establecer una
arquitectura base sólida y desarrollar un plan de proyecto. Es la parte más crítica del proceso.
En la fase construcción todas las componentes restantes se desarrollan e incorporan al producto. Todo
es probado en profundidad. El énfasis está en la producción eficiente y no en la creación intelectual.
El objetivo de la fase transición es traspasar el software desarrollado a la comunidad de usuarios. Una
vez instalado surgirán nuevos elementos que implicarán nuevos desarrollos (ciclos).
40
Figura 32. Metodología RUP
2.4.2 MétodosAgiles
Las metodologías ágiles imponen un proceso disciplinado sobre el desarrollo de software
con el fin de hacerlo más eficiente. Los métodos ágiles son adaptables en lugar de
predictivos. Los métodos ágiles son orientados a la gente y no orientados al proceso.
Están a favor de la naturaleza humana y enfatizan que el desarrollo de software debe ser
una actividad agradable.
Desarrollo Adaptable de Software (ASD)
Esta metodología se adapta al cambio en lugar de luchar contra él. Se basa en la
adaptación continua a circunstancias cambiantes. En ella no hay un ciclo de
planificación-diseño-construcción del software. En el corazón de ASD hay tres fases
solapadas no lineales: especulación, colaboración, y aprendizaje. ASD es un método
iterativo, orientado a componentes de software, tolerante a cambios, guiado por riesgos
donde la revisión de los componentes sirve para aprender de los errores y volver a iniciar
el ciclo de desarrollo. Véase figura 33.
41
Figura 33. El ciclo de la metodología ASD.
Scrum
Scrum ha estado en los círculos orientados a objetos. Scrum divide un proyecto en
iteraciones (carreras cortas) de 30 días. Antes de que comience una carrera, se define la
funcionalidad requerida para esa carrera y entonces se deja al equipo para que la
entregue. El punto es estabilizar los requisitos durante la carrera. Todos los días el
equipo sostiene una junta corta (quince minutos) llamada scrum, dónde el equipo discute
lo que hará al día siguiente. Scrum se enfoca principalmente en la planeación iterativa y
el seguimiento del proceso.
XP (Programación Extrema)
XP empieza con cuatro valores: comunicación, retroalimentación, simplicidad y coraje.
Construye sobre ellos una docena de prácticas que los proyectos XP deben seguir.
Muchas de estas prácticas son técnicas antiguas, tratadas y probadas. Además de
resucitar estas técnicas, la XP las teje en un todo sinérgico dónde cada una refuerza a las
demás. Una de las más llamativas y atractivas es su fuerte énfasis en las pruebas. La XP
pone la comprobación como fundamento del desarrollo con cada programador
escribiendo pruebas cuando escriben su código de producción. Todo el diseño se centra
en la iteración actual y no se hace nada para necesidades futuras. El resultado es un
proceso de diseño disciplinado.
42
La Familia de Cristal de Cockburn
Se trata de una familia de metodologías basada en el fundamento de que tipos diferentes de proyectos
requieren tipos diferentes de metodologías. Se considera esta variación a lo largo de dos ejes: el
número de personas en el proyecto y las consecuencias de los errores. Cada metodología encaja en una
parte diferente. Un proyecto de 40 personas tiene una metodología diferente a la de un proyecto de 6
personas. Los Cristales comparten con la XP la orientación humana aunque de manera algo diferente.
Se pone mucho peso en las revisiones al final de la iteración animando al proceso a ser auto-mejorable.
Se fundamenta en que el desarrollo iterativo está para encontrar los problemas temprano y poder
corregirlos. Esto pone más énfasis en la gente supervisando su proceso y afinándolo conforme
desarrollan.
Desarrollo Manejado por Rasgos (FDD)
El Desarrollo Manejado por Rasgos (FDD por sus siglas en inglés), como las otras metodologías
adaptables, se enfoca en iteraciones cortas que entregan funcionalidad tangible.
En el caso del FDD las iteraciones duran solo dos semanas. El FDD tiene cinco procesos según se lista
a continuación. Los primeros tres se hacen al principio del proyecto. Los últimos dos se hacen en cada
iteración. Cada proceso se divide en tareas y se da un criterio de comprobación.
1) Desarrollar un modelo global
2) Construir una lista de los rasgos
3) Planear por rasgo
4) Diseñar por rasgo
5) Construir por rasgo
2.5 ProgramaciónOrientadaaObjetos
De la exposición anterior, se deduce que, la programación orientada a objetos es una filosofía de la que
surge una cultura nueva que incorpora técnicas y metodologías diferentes. En ella el universo
computacional está poblado por objetos, cada uno responsable de sí mismo, y comunicándose con los
demás por medio de mensajes. Cada objeto representa una instancia de alguna clase, y estas clases son
43
miembros de una jerarquía de clases unidas vía relaciones de herencia. La diferencia entre un objeto y
una clase es que un objeto es una entidad concreta que existe en el tiempo y espacio, mientras que una
clase representa una abstracción, la esencia de un objeto.
En la programación procedimental van separados los datos y las subrutinas que manipulan los datos.
La ventaja fundamental de la programación orientada a objetos es que, los datos y las operaciones
(código) que manipulan los datos, ambos van encapsulados en un objeto.
2.5.1 ClasificacióndeLenguajes
Lenguajes imperativos: Son aquellos basados en sentencias, ya sean procedurales, orientados a objetos
puros o mixtos. Entre ellos se cuentan Pascal, C, C++, Java, Fortran, Perl y Python.
Lenguajes procedurales: Son lenguajes imperativos basados en procedimientos (o rutinas) y funciones.
Entre ellos podemos nombrar a C, Fortran, Pascal (estándar) y Basic.
Lenguajes orientados a objetos: Son lenguajes imperativos basados en clases (algunos, llamados mixtos
soportan también el modelo procedural). Entre los lenguajes orientados a objetos puros podemos
nombrar a Smalltalk, Eiffel y Java. Entre los mixtos se encuentran C++ y Python.
Lenguajes funcionales: Son aquellos basados en funciones matemáticas (y no en comandos o
sentencias). Podemos nombrar aquí a ML, Haskell y Lisp.
2.6 EstadodelArte
Debido a la revolución de las computadoras, durante los últimos 40 años, el método de los elementos
finitos MEF ha sido ampliamente aceptado como herramienta para el modelado y simulación de
estructuras en la ingeniería.
Los programas de MEF siempre han consistido en miles de líneas de código mayormente escritos en
lenguajes basados en procedimientos como FORTRAN y C. Todas las herramientas conocidas hasta la
fecha producen los resultados del cálculo estructural (las fuerzas internas) usando un solo sistema de
ejes locales para ambos extremos de los elementos (elemento viga) dejando al ingeniero la
interpretación y modificación del resultados. En ésta investigación se pretende llegar a la
implementación de un modelo MEF que produzca resultados exactos para ambos extremos de los
elementos.
44
2.6.1 AntecedentesyTrabajosPrevios
[Archer 2000] diseñó e implementó un sistema para el MEF. Su diseño describe la
abstracción para cada clase y especifica su interfaz para tal abstracción. Se verifica que la
implementación de cada clase y la interacción entre objetos cumplan con la interfaz definida.
Además reconoce que el desarrollo de elementos infinitos involucra la adición de nuevos
elementos, nuevas estrategias de solución o nuevos esquemas de almacenamiento
matriciales; razón por la cual, presta especial cuidado a hacer las interfaces lo más flexibles
posibles.
La transformación entre sistemas de coordenadas es muy tomada en cuenta. Véase la figura
34. Recuerde que DOF se traduce como grados de libertad (degrees of freedom en inglés).
Archer planteó un modelo OO generalizado para elementos finitos. En ésta investigación se
propone un modelo OO específico - elemento viga con un sistema de ejes locales
Kardestuncer.
Figura 34. Modelo orientado a objetos propuesto por Archer.
45
[Jun Lu 2000] investigó, diseñó, implementó y demostró una aplicación OO
denominada FE++ como soporte para la construcción de una amplia variedad de
programas sobre análisis por elementos finitos.
Su objetivo principal apuntó a una amplia investigación en el dominio del análisis por
elementos finitos proveyendo una arquitectura OO y un conjunto de abstracciones para
permitir un rápido desarrollo de una variedad de aplicaciones sobre elementos finitos.
Dicha arquitectura OO está dirigida a aplicaciones de análisis lineal elástico o análisis
no lineal.
Jun Lu desarrolló una plataforma OO universal para el análisis estructural por
elementos finitos. En ésta investigación se desarrollará una plataforma OO específica
para el análisis estático de pórticos 2D por elementos finitos – elemento viga y ejes
locales Kardestuncer.
[Al Vermeulen 2000] describió las ventajas de los lenguajes OO como el C++ con
relación a los lenguajes de programación basados en procedimientos como el
FORTRAN. Expuso el código desarrollado en su investigación basado en un elemento
finito de curva cúbica de deformación. Ejemplificó el método de los elementos finitos
explicando los esfuerzos y deformaciones que sufre la rueda de una bicicleta. A raíz de
que el elemento finito de curva cúbica de deformación conduce a ecuaciones complejas,
concluyó que la programación OO es la más recomendable para lidiar mejor con ésta
complejidad.
Al Vermeulen implementó en C++ un modelo OO para elementos finitos de curva
cúbica de deformación. En ésta investigación se implementará en Java un modelo OO
para elementos finitos de deformación lineal - elemento viga y ejes locales
Kardestuncer.
[Foley 2003] propuso un algoritmo de computación evolutiva para el diseño de pórticos
de acero, parcial o totalmente restringidos. Aplicó un análisis avanzado de diseño
estructural usando un modelo inelástico basado en el comportamiento plástico
distribuido. La automatización del proceso de diseño estructural es implementada
usando un algoritmo evolutivo OO. Empleó la orientación a objetos OO para modelar
los componentes del pórtico y las operaciones de reproducción de dicho algoritmo
evolutivo. Demostró su propuesta diseñando pórticos de ejemplo de diversa topología
y discutió el rendimiento resultante de su algoritmo evolutivo OO.
46
Foley propuso un algoritmo evolutivo OO para el diseño de pórticos de acero. En ésta
investigación se propone un modelo OO para el análisis de pórticos por elementos
finitos.
Figura 35. Modelo OO según Foley para el diseño de estructuras de acero.
[Bittencourt et al 2001] desarrolló en C++ un software OO interactivo para el análisis y optimización
estructural en dos dimensiones. La principal característica de dicho software es la integración de varias
herramientas de cálculo en una interfaz gráfica de usuario. Ésta interfaz simplifica la introducción de
datos para la simulación y optimización de problemas elásticos lineales de dos dimensiones. La
implementación fue realizada para el sistema operativo Windows-NT.
Bittencourt desarrolló en C++ una aplicación para el análisis y optimización estructural 2D. En ésta
investigación se desarrollará en Java una aplicación solo para el análisis estructural 2D – elemento viga
y ejes locales Kardestuncer.
[McKenna 2000] diseñó un modelo OO para una variedad métodos de análisis por elementos finitos
usando computación secuencial y paralela. En un diseño tradicional OO se crea un objeto único para
realizar el análisis. Pero el diseño de McKenna propone una variedad de subclases para una clase
“Análisis” que modela distintos análisis como ser: Integrator, ConstraintHandler, DOF_Numberer,
AnalysisAlgorithm y otros. Este enfoque ofrece una gran flexibilidad al permitir elegir el análisis
47
mediante el tipo de objeto pasado al constructor de clase. El modelo fue implementado en C++ y
comparado con un código en un lenguaje basado en procedimientos.
McKenna diseñó un modelo OO con una clase “Análisis” segmentada en subclases para
varios tipos de análisis por elementos finitos. En ésta investigación se diseñará un
modelo OO que involucra una clase “Análisis” no-segmentada y específica para el
análisis estructural estático de pórticos 2D.
[Patzak 2001] creó un código gratuito de arquitectura OO para la solución de
problemas de mecánica, transporte y fluidos; ejecutable en varias plataformas. Su
objetivo fue desarrollar una herramienta eficiente y robusta para el MEF, y proveer de
un ambiente modular y extensible para desarrollos posteriores. El código incluye un
módulo para el balance dinámico de carga de trabajo en ambientes de computación
paralela. Véase figuras 36a y 36b.
Patzak desarrolló un código OO para resolver problemas de mecánica, transporte y
fluidos mediante elementos finitos. En ésta investigación se desarrollará un código OO
para resolver problemas de mecánica; específicamente, para el análisis de pórticos 2D
por elementos finitos – elemento viga y ejes locales Kardestuncer.
Figura 36a. Modelo de elementos finitos de la
carrocería de un vehículo.
Figura 36b. Renderización del modelo de
elementos finitos de la carrocería de un vehículo.
48
[Biniaris 2004] desarrolló una aplicación OO para resolver problemas 3D por el MEF aplicando
computación distribuida. La implementó en una red de estaciones de trabajo. La solución del sistema
de ecuaciones resultantes se la lleva acabo de forma distribuida por el método de la gradiente
conjugada. La implementación fue en Java y la computación distribuida se logró mediante el uso de la
tecnología agente móvil.
El punto principal de dicha investigación está dedicado a una descripción de la implementación del
modelo OO distribuido. Presentó resultados numéricos que prueban la ventaja de la técnica. Véase
figura 37.
Biniaris desarrolló en Java un modelo OO para la solución de problemas 3D por elementos finitos
aplicando computación distribuida. En ésta investigación se desarrollará un modelo OO para la
solución de problemas estructurales 2D por elementos finitos aplicando computación secuencial.
Figura 37. Sección cajón de un puente. La parte sombreada representa al estado de esfuerzos en la
estructura luego del cálculo del modelo de elementos finitos.
[Vector_Space Programming 2008] desarrolló en C++ una librería matemática con un conjunto de objetos matemáticamente
integrables y diferenciables. La librería es una herramienta para desarrollar rápidamente aplicaciones de cálculo. La librería
está dirigida a aplicaciones OO para el FEM que involucren análisis numérico avanzado, programación lineal, optimización,
métodos de las diferencias finitas y métodos variacionales.
Se trata de una librería en C++ para programas OO sobre el FEM que además dispone de métodos numéricos avanzados. En
ésta investigación se implementará en Java una librería OO específica para problemas estructurales mediante elementos
finitos. No se programarán métodos numéricos avanzados.
49
Parte3‐DesarrolloTeoricoPractico
El desarrollo teórico práctico que se presenta en éste artículo corresponde al avance actual de ésta
investigación. El estado actual de ésta investigación es más que inicial y completamente funcional.
3.1 DeclaracióndeTrabajo
Una estructura se compone de nudos y elementos (elemento viga doblemente
empotrada). Cada elemento parte de un solo nudo y termina en un solo nudo. Puede
haber varios elementos que parten de un mismo nudo o que terminan en un mismo
nudo. Un elemento puede tener solo un conjunto de propiedades de la sección (módulo
de elasticidad, área y momento de inercia). Puede haber varios elementos que tengan
las mismas propiedades de la sección. Un elemento puede tener solo un conjunto de
fuerzas internas (fuerza axial, fuerza cortante y momento flector). Un conjunto de
fuerzas internas puede pertenecer a más de un elemento. Un elemento puede tener
varias condiciones de carga puntual y/o distribuida en común con otros elementos; sin
embargo, una condición de carga debe pertenecer solo a un elemento.
Un nudo puede tener solo un conjunto de coordenadas planas (X, Y). Y un conjunto de
coordenadas planas puede pertenecer únicamente a un nudo. Un nudo puede tener
varias solicitaciones de carga puntual en común con otros nudos pero una condición de
carga puntual debe pertenecer solo a un nudo.
Cada nudo puede tener solo un conjunto de condiciones de borde o de frontera. Un
conjunto de condiciones de borde pueden tener en común varios nudos. Un nudo puede
tener solo un conjunto de desplazamientos. Un conjunto de desplazamientos pueden
tener en común más de un nudo. Un nudo restringido (apoyo) puede tener solo un
conjunto de reacciones. Y un conjunto de reacciones pueden tener en común varios
nudos.
50
Figura 38. Una estructura 2D de 3 nudos, 2 elementos, 3 cargas puntuales, 2 cargas distribuidas y 2
apoyos fijos.
La información inicial de entrada de una estructura consiste en: una descripción
li teral de la estructura, un lis tado de las coordenadas globales (X, Y) de sus nudos,
un listado de las incidencias de sus elementos, un lis tado de las cargas puntuales
sobre sus nudos, un l istado de las cargas puntuales y/o distribuidas sobre sus
elementos, y un lis tado de las condiciones de contorno (restr icciones o apoyos).
La información que se requiere luego del cálculo de una estructura consiste en: la
matriz global de r igidez, el vector generalizado de fuerza, el vector generalizado de
desplazamiento, las fuerzas internas en los extremos de los elementos según el
s istema de ejes locales Kardestuncer, las reacciones en los apoyos y una gráfica de
la deformada de la estructura.
El cálculo de una estructura deberá l levarse a cabo por medio del método de los
elementos fini tos empleado en ingeniería estructural conforme el extenso desarrollo
de la sección “marco teórico” de éste informe.
51
3.2 Requerimientos
3.2.1 Funcionales
Los requisitos funcionales definen qué debe hacer un sistema.
1. Al usuario se le deberá proveer de un formato de archivo estándar que permita
la introducción de manera tabulada de la información de entrada de la estructura.
2. Al usuario se le deberá proveer un campo que permita la introducción de la
descripción li teral de la estructura.
3. Al usuario se le deberá proveer de un campo que permita la introducción de las
coordenadas (X, Y) de los nudos de la estructura.
4. Al usuario se le deberá proveer de un campo que permita la introducción de las
incidencias, de las propiedades geométricas y de las propiedades inerciales de
los elementos de la estructura.
5. Al usuario se le deberá proveer de campo que permita la introducción de las
cargas puntuales aplicadas en los nudos de la estructura.
6. Al usuario se le deberá proveer de un campo que permita la introducción de las
cargas puntuales y /o distr ibuidas que actúan sobre los elementos de la
estructura.
7. Al usuario se le deberá proveer de un campo que permita la introducción de las
condiciones de borde (apoyos) de la estructura.
8. Al usuario se le deberá proveer una interfaz para la verificación gráfica de la
geometría de la estructura.
9. Al usuario se le deberá proveer una interfaz para solici tar el anális is de la
estructura.
10. Al usuario se le deberá proveer archivos de un formato estándar que permita
acceder de manera tabulada a los resultados numéricos del anális is de la
estructura.
11. Al usuario se le deberá proveer de un archivo para acceder a los resultados
numéricos de la matriz global de r igidez de la estructura.
52
12. Al usuario se le deberá proveer de un archivo para acceder a los resultados
numéricos del vector general izado de fuerza de la estructura.
13. Al usuario se le deberá proveer de un archivo para acceder a los resultados
numéricos del vector general izado de desplazamiento de la estructura.
14. Al usuario se le deberá proveer de un archivo para acceder a los resultados
numéricos de las fuerzas internas en los extremos de los elementos de la
estructura.
15. Al usuario se le deberá proveer de un archivo para acceder a los resultados
numéricos de las reacciones en los apoyos (i . e . nudos restringidos mediante las
condiciones de contorno) de la estructura.
16. Al usuario se le deberá proveer de una interfaz gráfica para verificar la
deformada resultante del análisis de la estructura.
17. Al sistema se le deberá proveer la implementación de un modelo que permita el
análisis de la estructura mediante el método de los elementos finitos - elemento
viga doblemente empotrada sistema de ejes locales Kardestuncer según el
extenso desarrol lo de la sección “marco teórico” de éste documento.
18. Al sistema se le deberá proveer una rutina para abrir la información de entrada
de la estructura.
19. Al sistema se le deberá proveer una rutina para graficar la geometr ía de la
estructura.
20. Al sistema se le deberá proveer una rutina para ensamblar el vector generalizado
de fuerza de la estructura.
21. Al sistema se le deberá proveer una rutina para ensamblar la matriz global de
r igidez la estructura.
22. Al sistema se le deberá proveer una rutina para aplicar las condiciones de
contorno de la estructura.
23. Al sistema se le deberá proveer una rutina para resolver el s is tema de ecuaciones
de la estructura.
24. Al sistema se le deberá proveer una rutina para calcular las fuerzas internas en
los extremos de los elementos de la estructura.
53
25. Al sistema se le deberá proveer una rutina para calcular las reacciones de los
apoyos de la estructura.
26. Al sistema se le deberá proveer una rutina para guardar los resultados numéricos
del análisis de la estructura.
27. Al sistema se le deberá proveer una rutina para graficar la deformada de la
estructura.
3.2.2 No Funcionales
Los requisitos no funcionales definen cómo debe ser el sis tema.
1. La aplicación debe ser desarrollada util izando Java para permitir que en el futuro
usuarios famil iarizados con este lenguaje puedan añadir más funcionalidades y
mantenerlo.
2. El sistema debe accederse a través de la máquina virtual de Java.
3. Periféricos disponibles para la usabilidad: teclado y ratón.
4. El sis tema debe ser de fácil usabilidad.
5. El sistema deberá proveer un medio independiente para la instalación del mismo.
3.3 Modelo de Casos de Uso
Los actores que se distinguen del anál isis de requerimientos son “el usuario” y “el
s istema” conforme se muestran en los casos de uso de las f iguras 39 a la 41. En
general, es posible detal lar con mayor profundidad la mayoría de los casos uso. En
la f igura 41 se detalla el caso de uso “introducir condiciones de contorno”. A este
concepto se conoce como “inclusión de caso de uso”.
54
Figura 39. Caso de uso – actor “el usuario”
Figura 40. Inclusión de caso de uso “introducir condiciones de contorno”.
Usuario
Introducir lascondiciones de frontera
Introducir códigode nudo
Introducir restricciónal desplazamiento
horizontal
Introducir restricciónal desplazamiento
vertical
« incluir »
« incluir »
« incluir »
Introducirrestricción al giro
« incluir »
55
Figura 41. Caso de uso – actor “el sistema”.
Las figuras 41a a 41d detallan mediante inclusión el caso de uso generalizado de la figura 39. Nótese
que se desglosa la introducción de la estructura por parte del actor usuario.
Figura 41a. Inclusión de caso de uso “Introducir las coordenadas de los nudos”.
Usuario
Introducir lascoordenadas de los nudos
Introducircoordenada X
« incluir »
Introducircoordenada Y
« incluir »
56
Figura 41b. Inclusión de caso de uso “Introducir las propiedades de los elementos”. Nótese que la
numeración de los elementos deberá ser automática según el orden de introducción de los mismos.
Figura 41c. Inclusión de caso de uso “Introducir las cargas puntuales en los nudos”.
Usuario
Introducir laspropiedades de los elementos
Introducir módulo deelasticidad (E)« incluir »
Introducir momentode inercia (I)
« incluir »
Introducir área dela sección (A)
« incluir »
Introducir código denudo de partida
« incluir »Introducir código de
nudo de llegada
« incluir »
Usuario
Introducir las cargaspuntuales en los nudos
Introducir códigode nudo
Introducir lacomponente horizontal
Introducir lacomponente vertical
« incluir »
« incluir »
« incluir »
Introducir elmomento flector
« incluir »
57
Figura 41d. Inclusión de caso de uso “Introducir las cargas sobre los elementos”. Nótese que la
inclusión de “introducir carga puntual” puede desglosarse según la figura 41c.
Figura 41e. Inclusión de caso de uso “solicitar el cálculo estructural”.
Usuario
Introducir las cargassobre los elementos
Introducir códigode elemento
Introducir tipo decarga
Introducir cargapuntual
« incluir »
« incluir »
« incluir »
Introducir iniciode aplicación« incluir »
Introducir longitudde aplicación
« incluir »
Usuario
Solicitar elcálculo estructural
Verificargráficamente la estructura
Autorizar elanálisis estructural
« incluir »
« incluir »
58
Figura 41f. Inclusión y extensión del caso de uso “Acceder a los resultados numéricos del análisis”. La
extensión de un caso de uso es una extensión del original. Se trata de la creación de un caso de uso
agregándole pasos a uno existente.
3.4 ModelodeClases
Del análisis de requerimientos, en general, las clases se corresponden con los sustantivos que a su vez
son objetos: estructura, elementos, nudos, cargas, etc. Por otra parte, los verbos casi siempre se
correlacionan con las responsabilidades (operaciones) de los objetos como ser: ensamblar sistema de
ecuaciones, aplicar condiciones de contorno, resolver sistema de ecuaciones, calcular fuerzas internas,
calcular reacciones y otros.
Luego de una serie de revisiones, se ha llegado a un diseño de clases robusto (véase figura 42) basado
en encapsulación, herencia, abstracción, polimorfismo, composición, clases abstractas, interface java y
otros conceptos OO. En cada clase se aplica la encapsulación ocultando las propiedades y permitiendo
el acceso a las mismas mediante métodos y su interfaz. Se emplea la herencia para especializar las
clases abstractas y crear clases que se puedan instanciar para resolver casos específicos. Gracias a un
adecuado conocimiento del dominio se ha llegado a un alto grado de abstracción del modelo dando
lugar a futura escalabilidad (e. g. estructuras 3D). El polimorfismo es un concepto muy empleado
sobre todo en las subclases del modelo. Se emplea la composición por agregación pero ésta puede
distinguirse en la zona “propiedades” de cada clase. Se emplea el concepto de interface java como
Usuario
Acceder a losresultados numéricos del
análisis
Ver los desplazamientosde los nudos de la
estructura.
Ver las fuerzasinternas en los elementos.
Ver las reaccionesen los apoyos.
« incluir »
« incluir »
« extender »
Acceder a losresultados gráficos del análisis
« incluir »
59
artificio para proveer de herencia múltiple al modelo ya que en el lenguaje Java no se ofrece herencia
múltiple.
La interface java interface01 se emplea más que todo para que cada clase del modelo esté
obligada a implementar un método de identificación para cualquier objeto. Nótese que las
clases que “realizan” a la interface java “interface01” deben ser clases abstractas.
La clase abstracta estructura00 contiene todas las propiedades y métodos fundamentales de
una estructura en general o sea ésta superclase podría aplicarse sin ningún inconveniente
inclusive a estructuras tridimensionales. Nótese que muchas de las operaciones de ésta
superclase tienen que ver directamente con el análisis estructural mediante elementos finitos.
La clase abstracta nudo00 contiene todas las propiedades y métodos fundamentales de un nudo
en general; sin embargo, de ésta superclase podría heredarse otros tipos de nudos como nudos
con apoyos elásticos u otros.
La clase abstracta elemento00 abstrae las propiedades y métodos para un elemento estructural
en general; es decir, ésta superclase podría aplicarse inclusive como base de elementos
tridimensionales. Para el caso de las estructuras planas como los marcos planos, es necesario
heredar una nueva subclase como elemento01 que permita la especialización en cuanto a la
matriz de rigidez, matriz de rotación, matriz de coeficientes de fuerza y otros para elementos
viga de dichas estructuras. La subclase elemento02 es un adelanto de prueba del modelo; se
trata de la especialización para elementos de otras estructuras planas como parrillas muy
utilizadas en losas, puentes y otros.
La clase abstracta cargaele00 abstrae las propiedades y métodos para el tema de cargas
puntuales o distribuidas aplicadas sobre los elementos de una estructura. Se ha heredado,
especializado y llegado a una subclase cargaele01 para el caso de cargas puntuales aplicadas
sobre un elemento. La subclase cargaele02 es una herencia y especialización de cargaele00
para el caso de cargas distribuidas rectangulares aplicadas sobre el elemento. Para la siguiente
revisión de ésta investigación se va a incluir una subclase especializada cargaele03 para cargas
distribuidas triangulares aplicadas sobre un elemento (véase figura 38).
60
Figura 42. Modelo de clases.
61
Finalmente, las subclases estructura01 y nudo01 son clases heredadas que permiten instanciarse para la
aplicación práctica de sus correspondientes clases abstractas. Las subclases estructura01 y nudo01
también tienen la función de la inicialización de las propiedades heredadas y de la identificación que
exige la realización de la interface java interface01.
3.5 VistaDinámica–DiagramasdeComportamiento
Basado en el algoritmo del método de los elementos finitos para el análisis de estructuras (véase figura 12), se ha
diseñado la comunicación entre los objetos del modelo en función del tiempo según se muestra en el diagrama de
secuencia para el caso de uso “ensamblar sistema de ecuaciones de la estructura” cuyo actor es “el sistema” (véase
figura 43). El algoritmo exige el ensamblado de la matriz global de rigidez de la estructura para cuyo efecto se calculan
primero las rigideces locales y globales de los elementos. El MEF también exige el ensamblado del vector
generalizado de fuerza de la estructura para lo cual se consideran las cargas sobre los elementos y las cargas sobre los
nudos que pueda haber. En el diagrama se pueden verificar que todos los mensajes entre objetos son sincrónicos.
En la figura 43a se muestra el diagrama de actividades para el proceso “ensamblar sistema”. Ha sido diseñado para
mostrar una visión simplificada del proceso. Muestra los pasos (actividades) así como los puntos de decisión y
bifurcación.
La figura 43b es el diagrama de colaboración para éste mismo proceso; muestra cómo los objetos se colaboran entre sí
tal como sucede en el correspondiente diagrama de secuencias (figura 43).
Los diagramas de colaboración son semánticamente equivalentes a los diagramas de secuencia. Destacan la sucesión
de interacciones. Destacan el contexto y organización general de los objetos que interactúan.
Para resolver el sistema de ecuaciones de la estructura, primero deben eliminarse las filas y columnas de la ecuación
matricial de la estructura (i.e. vector fuerza, matriz de rigidez, vector desplazamiento) según las componentes de los
nudos restringidos (e. g. apoyos). A esto se denomina “aplicar las condiciones de contorno”. Luego, haciendo uso de
un método numérico incluido en la librería JAMA, se resuelve el sistema de ecuaciones reducido de la estructura.
Finalmente, se actualizan los desplazamientos de los nudos de la estructura haciendo uso de la solución del sistema (i.e.
vector desplazamiento generalizado). Los diagramas UML de secuencia, actividades y colaboración, de éste proceso,
se muestran en las figuras 43c-43e.
62
Figura 43. Diagrama de secuencia para proceso “ensamblar el sistema de ecuaciones”.
Seguidamente, el algoritmo del MEF exige que, para el cálculo de las fuerzas internas en los extremos de los
elementos, deben considerarse, evaluarse y sumarse las fuerzas internas de empotramiento debido a cargas puntuales,
distribuidas, etc. que los elementos puedan tener. Los diagramas UML de secuencia, actividades y colaboración de
este proceso se muestran en las figuras 43f, 43g y 43j.
63
Figura 43a. Diagrama de actividades para el proceso “ensamblar el sistema”.
Figura 43b. Diagrama de colaboración para el proceso “ensamblar sistema”.
64
Figura 43c. Diagrama de secuencia para el proceso “resolver sistema de ecuaciones” de la estructura.
Para calcular las reacciones en los apoyos de la estructura deben considerarse los nudos restringidos o
apoyos. Nótese que, una vez resuelto el sistema de ecuaciones de la estructura, el vector fuerza
generalizado de la ecuación matricial de la estructura (i.e. vector P) puede calcularse para contener las
reacciones entre sus componentes. Los diagramas de secuencia, actividades y colaboración para éste
proceso se muestran en las figuras 43h, 43i y 43k.
65
Figura 43d. Diagrama de actividades del proceso “resolver sistema de ecuaciones de la estructura”.
Figura 43e. Diagrama de colaboración del proceso “resolver sistema de ecuaciones de la estructura”.
66
Figura 43f. Diagrama de secuencia para el proceso “calcular fuerzas internas”.
Figura 43g. Diagrama de actividades para el proceso “calcular fuerzas internas”.
67
Figura 43h. Diagrama de secuencia para el proceso “calcular reacciones”.
Figura 43i. Diagrama de actividades para el proceso “calcular reacciones”.
68
Figura 43j. Diagrama de colaboración para el proceso “calcular fuerzas internas”.
Figura 43k. Diagrama de colaboración para el proceso “calcular reacciones”.
El diagrama de estados de la figura 43L refleja el progreso de la ecuación matricial
de la es tructura durante el proceso global “analizar estructura”. Nótese que refleja
también los cambios que sufren los arreglos de las fuerzas internas en los extremos
de los elementos y las reacciones en los apoyos. Recuerde que la parte inferior
contiene las actividades entrada (qué sucede cuando el sistema entra al estado),
hacer (qué sucede cuando el sistema está en el estado) y salida (qué sucede cuando
el sistema sale del estado).
69
Figura 43L. Diagrama de estados para el proceso global “analizar estructura”.
3.6 DiagramasdeComponentesydeDespliegue
Además del paquete maestro de clases para el análisis de estructuras mediante el MEF que se propone
como punto central de ésta investigación y que se denomina “Estructural” en el diagrama de
componentes de la figura 43m, también intervienen otras clases como herramientas o utilitarios para
que la aplicación resultante pueda cumplir cabalmente con la lista de requerimientos. Es el caso del
paquete JAMA de distribución gratuita que viene con un modelo OO para la mayoría de las
operaciones del álgebra matricial incluyendo métodos de factorización que se necesitan para la
resolución de ecuaciones matriciales como las que se forman con las estructuras.
Un sistema puede abarcar diversos tipos de plataformas en ubicaciones dispersas. Un diseño sólido de
distribución de hardware es básico para el diseño del sistema. El diagrama de distribución se presenta
en la figura 43n y muestra un elemento primordial de hardware como el nudo PC o computadora
personal. Se tienen componentes en el nudo como la aplicación desarrollada en ésta investigación, la
cual depende de la máquina virtual de Java y la cual a su vez depende del sistema operativo. Se exige
70
un software editor de archivos CSV para acceder a la información tabulada de entrada y salida
procesada por la aplicación.
Figura 43m. Diagrama de componentes. Figura 43n. Diagrama de
despliegue.
3.7 Implementación–Generalidades
La implementación del modelo de clases de la figura 42 se la ha llevado a cabo en lenguaje Java según el paquete
“Estructural” de la figura 43m. Todas las clases han sido implementadas con base a la ventaja fundamental de la
programación orientada a objetos: la encapsulación. El ocultamiento de las propiedades y los métodos ha sido aplicado a
todas las clases. El concepto de los “getters” y “setters” para proveer acceso controlado a los datos de un objeto ha sido
completamente aplicado en todos los casos en virtud de evitar que haya manipulación directa de datos (atributos) entre
objetos. Véase la figura 44.
Con el fin de que la aplicación pueda tener acceso a la lectura y escritura de archivos de formato tabulado conforme la lista de
requerimientos, se ha incorporado un paquete de clases de distribución gratuita para la manipulación de archivos de valores
separados por comas extensión CSV (comma separated values). Estos archivos pueden ser editados fácilmente por cualquier
software comercial de hoja de cálculo.
Como se mencionó anteriormente, se ha incluido un paquete de clases de distribución gratuita denominado JAMA que
provee del álgebra matricial al modelo (véase figura 43j).
71
Figura 44. Implementación en Java de la clase abstracta “cargaele00”.
El prototipo de la interfaz de usuario de la aplicación se muestra en la figura 45. El prototipo
proporcionará información valiosa que ayudará a mejorar la aplicación durante las iteraciones del
proceso de diseño. “Para el usuario del sistema, la interfaz de usuario es el sistema.
72
Figura 45. Prototipo para la interfaz de usuario.
3.8 CasosDeEstudio
En ésta parte se va a emplear el programa para analizar estructuras de función real. Y con el fin de comprobar el modelo, se va a
verificar manualmente el equilibrio de cada estructura primero entre las fuerzas internas que concurren en un nudo elegido al azar;
luego, entre fuerzas externas y reacciones en los apoyos.
3.8.1 CerchaTipoTorre
Fuente Bibliográfica
BEER FERDINAND Y JOHNSTON E. RUSELL (1993). “Mecánica Vectorial para Ingenieros”.
Editorial McGraw-Hill. México. Páginas 243 y 469.
Problema 6.40
Determínese la fuerza en el miembro (I-K) de la cercha plana que se muestra en la figura. (Úsese la
sección a-a).
73
Figura 46 – Caso de estudio
Solución
Se crea el archivo de entrada con un software para planillas electrónicas como Microsoft Excel.
Primero, se introduce un metadato de campo DESCRIPCION DE LA ESTRUCTURA y luego un título
para la estructura como ser “BEER Y JOHNSTON Páginas 243 y 469 Problema 6.40”.
Segundo, se introduce un metadato COORDENADAS DE LOS NUDOS; luego, se elige un origen
para el sistema global de coordenadas XY de la estructura como ser en el nudo J de la figura 46. A
continuación se introducen las coordenadas X e Y de los nudos A (nudo 1) hasta la J (nudo 11).
Tercero, se introduce un metadato ELEMENTOS TIPO y abajo se coloca “portico” para indicar que
los elementos de la estructura se corresponden con un pórtico (marco plano). La estructura de la figura
46 es una cercha que puede tratarse como un pórtico de elementos de inercia cero.
Cuarto, se ingresa un metadato PROPIEDADES DE LOS ELEMENTOS; seguidamente, se introducen
las incidencias de los elementos, el módulo de elasticidad, el momento de inercia y el área de la
sección según se muestra en la tabla guía de a continuación.
74
Elemento Nudo inicial i Nudo final j E I A
1 1 2 1 1E-9 1
2 1 4 1 1E-9 1
3 2 3 1 1E-9 1
4 2 4 1 1E-9 1
5 2 6 1 1E-9 1
6 3 6 1 1E-9 1
7 4 5 1 1E-9 1
8 4 7 1 1E-9 1
9 5 6 1 1E-9 1
10 5 7 1 1E-9 1
11 5 9 1 1E-9 1
12 6 9 1 1E-9 1
13 7 8 1 1E-9 1
14 7 10 1 1E-9 1
15 8 9 1 1E-9 1
16 8 10 1 1E-9 1
17 8 11 1 1E-9 1
18 9 11 1 1E-9 1
19 10 11 1 1E-9 1
Quinto, se ingresa un metadato CARGAS EN LOS NUDOS y se introducen las cargas
puntuales aplicadas en los nudos A (nudo 1), D (nudo 4) y G (nudo 7) de la figura 46.
Nótese que siempre se introduce primero la componente horizontal de la carga, luego la
vertical y finalmente la carga de momento flector.
75
Sexto, colóquese un metadato CARGAS EN LOS ELEMENTOS para cumplir con la
integridad del formato de archivo exigido por el programa ya que la estructura que se
está ingresando no tiene cargas sobre elementos.
Séptimo, ingrese un metadato APOYOS para describir las condiciones de contorno de
la estructura. Abajo colóquese primero el número de nudo que corresponde al apoyo,
luego la restricción al desplazamiento horizontal del nudo, al desplazamiento vertical y
finalmente la restricción al giro. Cuando exista restricción en alguna dirección solo se
coloca 1 (uno) y 0 (cero) cuando no. Nótese que para el problema en cuestión, los
nudos J (nudo 10) y K (nudo 11) están parcialmente restringidos.
La figura 47 muestra cómo debiera quedar la introducción de la estructura.
Finalmente, guárdese la hoja electrónica en formato de archivo de valores separados
por comas o CSV (comma separated values). Elíjase un nombre descriptivo que
represente bien a la estructura porque luego los nombres de los archivos de salida CSV
resultantes del análisis estructural se basarán en el nombre del archivo de entrada. La
información de entrada de la estructura de la figura 46 ha sido guardada como
“beerjohnsp243269p640.CSV”.
Análisis y Resultados
Al ejecutar la aplicación, ésta primero recupera el archivo CSV de entrada de la
estructura y en caso de que la información haya sido correctamente ingresada, se
muestra inmediatamente una gráfica para la verificación -por parte del usuario- de la
geometría de la estructura. Una captura de pantalla se muestra en la figura 48.
A continuación, la aplicación realiza el análisis de la estructura y se van guardando
archivos CSV de resultados numéricos importantes a medida del progreso del proceso.
Los nombres de los archivos de salida CSV empiezan con el nombre del archivo de
entrada y llevan un sufijo según el contenido que almacenan.
76
Figura 47. Entrada de la estructura.
Cuando concluye el análisis estructural aparece una ventana con una gráfica exagerada
de la deformada de la estructura. Esto se muestra en la figura 49. Nótese que la
deformada coincide con la tendencia de desplazamiento de la estructura bajo las
condiciones de carga puntual horizontal aplicada.
77
Sufijo de nombre de archivo Contenido del archivo CSV de salida
(K) Matriz de rigidez de la estructura.
(P) Vector generalizado de fuerza.
(D) Vector generalizado de desplazamientos.
(fint) Fuerzas internas en los extremos de los elementos.
(reacciones) Reacciones en los apoyos de la estructura.
( )r Matriz o vector reducida(o).
Nota.- Una matriz o vector reducido(a) es una matriz o vector luego de la aplicación de las condiciones
de contorno.
Figura 48. Geometría de la estructura antes del
análisis.
Figura 49. Deformada de la estructura luego del
análisis.
Es importante recordar que, cada ecuación del sistema de ecuaciones simultáneas de una
estructura, corresponde a cada grado de libertad de la misma. Esta estructura tiene 11 nudos
y cada nudo tiene 3 grados de libertad (i. e. desplazamiento horizontal, vertical y rotacional)
por lo tanto su sistema es de 33 ecuaciones.
78
La matriz global de rigidez de ésta estructura se muestra en la página siguiente. Como se
dijo anteriormente, éstos resultados y otros pueden encontrarse en los archivos CSV de
salida. Como puede comprobarse, la matriz global de rigidez K es cuadrada, tiene 33 filas,
33 columnas y además es simétrica conforme dicta una de sus propiedades. Todo indica que
ha sido ensamblada correctamente por el sistema.
Como se expuso en el marco teórico, el fin es diseñar una estructura y el análisis estructural
es una herramienta para alcanzar tal fin. Los resultados más importantes del análisis son: las
fuerzas internas en los extremos en los elementos y las reacciones en los apoyos.
Información útil también para verificar manualmente el análisis de la estructura.
A razón de que el modelo OO implementado en éste programa está dirigido a mejorar los
resultados del análisis estructural por medio de un elemento finito viga sistema de ejes
locales Kardestuncer, se tienen valores de las fuerzas internas para ambos extremos de los
elementos según se ve en la figura 50.
El hecho de que las fuerzas internas solo se manifiesten en el eje local axial x (Px) coincide
perfectamente con el comportamiento de una cercha como la del problema en cuestión.
Véase figura 50.
Según la figura 50, las fuerzas internas en los extremos i y j del elemento entre los nudos I-
K (nudos 9-11) o sea elemento no. 18 son:
Extremo i
00.0
00.0
64.28
F11-9
Extremo j
00.0
00.0
64.28
F9-11
79
0.23
10.
029
0.00
0-0
.222
0.00
00.
000
0.00
00.
000
0.00
0-0
.009
-0.0
290.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
029
0.09
80.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
-0.0
29-0
.098
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
0-0
.222
0.00
00.
000
0.51
20.
000
0.00
0-0
.222
0.00
00.
000
-0.0
34-0
.042
0.00
00.
000
0.00
00.
000
-0.0
340.
042
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.10
60.
000
0.00
00.
000
0.00
0-0
.042
-0.0
530.
000
0.00
00.
000
0.00
00.
042
-0.0
530.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
0-0
.222
0.00
00.
000
0.23
1-0
.029
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
0-0
.009
0.02
90.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
0-0
.029
0.09
80.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.02
9-0
.098
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
0-0
.009
-0.0
290.
000
-0.0
34-0
.042
0.00
00.
000
0.00
00.
000
0.19
00.
100
0.00
0-0
.140
0.00
00.
000
0.00
00.
000
0.00
0-0
.009
-0.0
290.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
-0.0
29-0
.098
0.00
0-0
.042
-0.0
530.
000
0.00
00.
000
0.00
00.
100
0.24
90.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
-0.0
29-0
.098
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
0-0
.140
0.00
00.
000
0.36
10.
000
0.00
0-0
.140
0.00
00.
000
-0.0
41-0
.037
0.00
00.
000
0.00
00.
000
-0.0
410.
037
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.06
80.
000
0.00
00.
000
0.00
0-0
.037
-0.0
340.
000
0.00
00.
000
0.00
00.
037
-0.0
340.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
-0.0
340.
042
0.00
0-0
.009
0.02
90.
000
0.00
00.
000
0.00
0-0
.140
0.00
00.
000
0.19
0-0
.100
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
0-0
.009
0.02
90.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
042
-0.0
530.
000
0.02
9-0
.098
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
0-0
.100
0.24
90.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.02
9-0
.098
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
0-0
.009
-0.0
290.
000
-0.0
41-0
.037
0.00
00.
000
0.00
00.
000
0.16
00.
095
0.00
0-0
.102
0.00
00.
000
0.00
00.
000
0.00
0-0
.009
-0.0
290.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
-0.0
29-0
.098
0.00
0-0
.037
-0.0
340.
000
0.00
00.
000
0.00
00.
095
0.23
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
-0.0
29-0
.098
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
0-0
.102
0.00
00.
000
0.28
90.
000
0.00
0-0
.102
0.00
00.
000
-0.0
43-0
.031
0.00
0-0
.043
0.03
10.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.04
40.
000
0.00
00.
000
0.00
0-0
.031
-0.0
220.
000
0.03
1-0
.022
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
-0.0
410.
037
0.00
0-0
.009
0.02
90.
000
0.00
00.
000
0.00
0-0
.102
0.00
00.
000
0.16
0-0
.095
0.00
00.
000
0.00
00.
000
-0.0
090.
029
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
037
-0.0
340.
000
0.02
9-0
.098
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
0-0
.095
0.23
00.
000
0.00
00.
000
0.00
00.
029
-0.0
980.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
0-0
.009
-0.0
290.
000
-0.0
43-0
.031
0.00
00.
000
0.00
00.
000
0.09
10.
060
0.00
0-0
.040
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
-0.0
29-0
.098
0.00
0-0
.031
-0.0
220.
000
0.00
00.
000
0.00
00.
060
0.12
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
0-0
.043
0.03
10.
000
-0.0
090.
029
0.00
0-0
.040
0.00
00.
000
0.09
1-0
.060
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.03
1-0
.022
0.00
00.
029
-0.0
980.
000
0.00
00.
000
0.00
0-0
.060
0.12
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
00.
000
0.00
0
MAT
RIZ
GLO
BAL
DE R
IGID
EZ K
PAR
A LA
EST
RUCT
URA
TIPO
CER
CHA
DEL
CASO
DE
ESTU
DIO
80
Figura 50. Fuerzas internas en los extremos de los elementos.
Un signo negativo indica compresión axial en el extremo del elemento conforme el sistema de ejes
locales de Kardestuncer (véase figura 7b).
La respuesta textual de la fuente bibliográfica del problema (no. 6.40), es:
La C indica compresión. Entonces la respuesta del programa es correcta.
Los resultados para las reacciones en los apoyos son:
Nótese que, la sumatoria de componentes verticales (Ry) da 0 (cero) lo cual indica que no existe
componente vertical de carga externa aplicada o sea es correcto.
Elemento Pxi Pyi Mzi Pxj Pyj Mzj
1.00 ‐20.00 0.00 0.00 ‐20.00 0.00 0.00
2.00 0.00 0.00 0.00 0.00 0.00 0.00
3.00 0.00 0.00 0.00 0.00 0.00 0.00
4.00 16.05 0.00 0.00 16.05 0.00 0.00
5.00 ‐16.05 0.00 0.00 ‐16.05 0.00 0.00
6.00 0.00 0.00 0.00 0.00 0.00 0.00
7.00 ‐26.28 0.00 0.00 ‐26.28 0.00 0.00
8.00 13.10 0.00 0.00 13.10 0.00 0.00
9.00 6.28 0.00 0.00 6.28 0.00 0.00
10.00 22.07 0.00 0.00 22.07 0.00 0.00
11.00 ‐22.07 0.00 0.00 ‐22.07 0.00 0.00
12.00 ‐13.10 0.00 0.00 ‐13.10 0.00 0.00
13.00 ‐31.86 0.00 0.00 ‐31.86 0.00 0.00
14.00 28.64 0.00 0.00 28.64 0.00 0.00
15.00 11.86 0.00 0.00 11.86 0.00 0.00
16.00 26.94 0.00 0.00 26.94 0.00 0.00
17.00 ‐26.94 0.00 0.00 ‐26.94 0.00 0.00
18.00 ‐28.64 0.00 0.00 ‐28.64 0.00 0.00
19.00 30.00 0.00 0.00 30.00 0.00 0.00
Apoyo Rx Ry Mz
10.00 ‐60.00 ‐43.20 0.00
11.00 0.00 43.20 0.00
81
Verificación Manual de Resultados
La verificación manual del análisis estructural consiste en: 1) Elegir un nudo al azar
y realizar la comprobación de equil ibrio de las fuerzas internas/externas que
concurren al nudo. 2) Realizar la sumatoria de las fuerzas externas aplicadas
incluyendo las reacciones. Para verificar el equilibrio la suma debe dar 0 (cero).
Por motivos de i lustración procedimental , el nudo elegido para comprobar el
equil ibrio puede ser el nudo D (nudo 4). Se puede usar una tabla para recopilar ,
ordenar, descomponer y sumar las fuerzas que concurren al nudo D:
Concurren al nudo D Valor en el nudo Horizontal Vertical
Elemento AD (2) 0.00 0.00 0.00
Elemento BD (4) +16.05 +10.00 +12.56
Elemento ED (7) -26.28 -26.28 0.00
Elemento DG (8) -13.10 -3.72 -12.56
Carga externa + 20.00 +20.00 0.00
Sumatoria 0.00 0.00
Se ha verificado exitosamente el equilibrio en el nudo D de la estructura lo cual
indica que el modelo y su implementación ( i . e. el programa) están produciendo
resultados correctos con relación a las fuerzas internas en los extremos de los
elementos.
Ahora bien, la tabla para la verif icación del equilibrio de las fuerzas externas y
reacciones que actúan en la estructura es la s iguiente:
Descripción Horizontal Vertical
Carga externa nudo A +20.00 0.00
Carga externa nudo D +20.00 0.00
82
Carga externa nudo G +20.00 0.00
Reacción apoyo J -60.00 -43.20
Reacción apoyo K 0.00 +43.20
Sumatoria 0.00 0.00
Se verifica exitosamente el equilibrio de las cargas externas y reacciones aplicadas
en los nudos de la estructura. Con lo que se rat ifica que la implementación del
modelo OO para el análisis estructural mediante elementos fini tos – elemento viga
sistema de ejes locales Kardestuncer, está produciendo resultados correctos.
3.8.2 MarcoRígidoPlano:Edificiode8Plantas
Con el fin de probar las ventajas del modelo OO propuesto en esta investigación, se
va a analizar un pórt ico plano que modela un edificio de 8 plantas. Dicha estructura
será resuelta primero mediante la aplicación desarrollada en ésta investigación y
luego empleando una aplicación de calibre industrial y fama mundial como el
SAP2000 (Structural Analysis Program) versión 15 – 2011 de CSi (Computers and
Structures, Inc.) USA. Los resultados del análisis serán objeto de comparación para
resaltar las mejoras propuestas en ésta investigación.
Nota.- No se va a detallar el manejo del programa de análisis estructural SAP2000
porque los pormenores de la operación de dicha aplicación caen fuera del contexto
de ésta investigación.
Problema
Realizar el análisis estructural de un pórtico plano de 8 plantas y 3 vanos. Los pilares tienen una
altura de 3 m y los vanos de las vigas portantes tienen una longitud de 4 m. Para todos los
elementos, el módulo de elasticidad es de 1000 Kgf/m2; el momento de inercia es 100 m4 y el
área de la sección es 1 m2. Asígnese una carga puntual horizontal de izquierda a derecha de 100
Kgf a todos los nudos de la cara lateral izquierda (a excepción del apoyo) del pórtico. Asígnese
83
una carga rectangular distribuida de 150 Kgf/m en dirección de la gravedad a todas las vigas
pórtico. Asígnese un apoyo empotrado a cada nudo inferior de la planta baja de la estructura.
Solución
Se debe crear un archivo de entrada con un software para hojas electrónicas CSV como
Microsoft Excel.
Primero, se introduce un metadato de campo DESCRIPCION DE LA ESTRUCTURA y luego
un título para la estructura como ser “edificacion 8 plantas”.
Segundo, se introduce un metadato COORDENADAS DE LOS NUDOS; luego, se elige un
origen para el sistema global de coordenadas XY de la estructura como ser en el nudo 1 de la
figura 51. A continuación se introducen las coordenadas X e Y de los nudos 1 a 36.
Tercero, se introduce un metadato ELEMENTOS TIPO y abajo se coloca “portico” para
indicar que los elementos de la estructura se corresponden con un pórtico (marco rígido
plano).
Cuarto, se ingresa un metadato PROPIEDADES DE LOS ELEMENTOS; seguidamente, se
introducen las incidencias para los 56 elementos: nudo inicial, nudo final, módulo de
elasticidad, momento de inercia y área de la sección. Se introducen los elementos en un
orden de abajo hacia arriba empezando por las vigas y continuando con las columnas. Véase
las figuras 51 y 52.
Nota.- La forma en la cual se numeran los nudos y crean los elementos tiene repercusión en
la dispersión de los valores de la matriz de rigidez de la estructura. Se ha recomendado
siempre realizar la numeración de nudos e incidencias de los elementos de tal manera que se
forme una banda centrada en la diagonal de la matriz de rigidez de la estructura.
Antiguamente, debido a limitaciones en capacidad de cómputo, era requisito cuidar la
numeración de nudos e incidencias durante el modelado de la estructura. Actualmente,
puede considerarse un factor de elegancia.
Quinto, se ingresa un metadato CARGAS EN LOS NUDOS y se introducen las cargas
puntuales aplicadas en los nudos: 5, 9, 13, 17, 21, 25, 29 y 33. Ver figura 52. Recuerde que,
se introduce primero la componente horizontal de la carga, luego la vertical y finalmente la
carga de momento flector.
84
Figura 51. Geometría y numeración de los 36
nudos del pórtico.
Figura 52. Vista en perspectiva de la asignación
de cargas puntuales y distribuidas del pórtico.
Sexto, colóquese un metadato CARGAS EN LOS ELEMENTOS e introdúzcase las cargas distribuidas
sobre las vigas en éste orden: número de elemento, tipo de carga, inicio de aplicación de carga (a),
longitud de aplicación de carga (b), componente horizontal de carga, componente vertical de carga y
momento flector. La figura 53 muestra los códigos para los diversos tipos de carga que pueden
soportar los elementos. En éste trabajo de investigación la aplicación desarrollada soporta cargas
puntuales y cargas distribuidas rectangulares (1 y 2). La inclusión de los tipos de carga 3 a 6 es factible
gracias a que el modelo OO propuesto se brinda a ésta extensibilidad.
Séptimo, ingrese un metadato APOYOS para describir las condiciones de contorno de la estructura.
Abajo colóquese primero el número de nudo que corresponde al apoyo, luego la restricción al
desplazamiento horizontal del nudo, al desplazamiento vertical y finalmente la restricción al giro.
85
Cuando exista restricción en alguna dirección solo se coloca 1 (uno) y 0 (cero) cuando no. Nótese que
para el problema en cuestión, los nudos 1 al 4 están completamente restringidos.
Finalmente, guárdese la hoja electrónica en formato de archivo de valores separados por comas o CSV
(comma separated values). Elíjase un nombre descriptivo que represente bien a la estructura porque los
archivos CSV resultantes del análisis se basarán en el nombre del archivo de entrada.
La información de entrada de la estructura de la figura 51 ha sido guardada como “edificio08”. La
siguiente página muestra cómo debiera quedar la hoja electrónica de introducción de la estructura.
Con relación a la introducción del pórtico en cuestión en el programa SAP2000, se sigue el mismo
procedimiento y orden aunque todo puede llevarse a cabo por medio de una interfaz gráfica muy
elaborada.
1
2
3
5
6
Figura 53. Códigos para tipos de cargas.
86
87
Análisis y Resultados
Al ejecutar la aplicación, ésta primero recupera el archivo CSV de entrada de la
estructura y en caso de que la información haya sido correctamente ingresada, se
muestra una gráfica para la verif icación de la geometría de la es tructura. Las
figuras 54 y 55 comparan las capturas de pantalla de la verif icación geométrica en
uno y otro programa.
Figura 54. Verificación geométrica del pórtico
según la aplicación desarrollada en ésta
investigación.
Figura 55. Verificación geométrica del pórtico
según la aplicación SAP2000.
A continuación, la aplicación calcula la estructura y va guardando archivos CSV de
resultados numéricos a medida del progreso del proceso. Los nombres de los
archivos de sal ida CSV empiezan con el nombre del archivo de entrada y llevan un
sufi jo según el contenido que almacenan.
88
Sufijo de nombre de archivo Contenido del archivo CSV de salida
(K) Matriz de rigidez de la estructura.
(P) Vector generalizado de fuerza.
(D) Vector generalizado de desplazamientos.
(fint) Fuerzas internas en los extremos de los elementos.
(reacciones) Reacciones en los apoyos de la estructura.
( )r Matriz o vector reducida(o).
Nota.- Una matriz o vector reducido(a) es una matriz o vector luego de la aplicación de las condiciones
de contorno.
Recuerde que, cada ecuación del sistema de ecuaciones simultáneas de una estructura, corresponde a
cada grado de libertad de la misma. Esta estructura tiene 36 nudos y cada nudo tiene 3 grados de
libertad (i. e. desplazamiento horizontal, vertical y rotacional) por lo tanto su sistema es de 108
ecuaciones.
Parte de la matriz global de rigidez de ésta estructura se muestra en la página anterior. La matriz
global de rigidez K es cuadrada, tiene 108 filas, 108 columnas, y es simétrica conforme dicta una de
sus propiedades. Estos resultados intermedios y otros pueden encontrarse en los archivos CSV de
salida.
Cuando concluye el análisis estructural aparece una ventana con una gráfica de la deformada de la
estructura. Esto se muestra en las figuras 56 y 57. Nótese que, la gráfica de la deformada de la figura
56 es más exagerada que la figura 57; no obstante, ambas reflejan un mismo comportamiento de la
estructura bajo las condiciones de carga.
Los resultados más importantes del análisis son: las fuerzas internas en los extremos de los elementos y
las reacciones en los apoyos. Esta información también es útil para verificar manualmente el equilibrio
de la estructura.
89
4444
4.4
0.0
-666
66.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-444
44.4
0.0
-666
66.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
333.
30.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
0-3
33.3
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-666
66.7
0.0
1333
33.3
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
6666
6.7
0.0
6666
6.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
4444
4.4
0.0
-666
66.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-444
44.4
0.0
-666
66.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
333.
30.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
0-3
33.3
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-666
66.7
0.0
1333
33.3
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
6666
6.7
0.0
6666
6.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
4444
4.4
0.0
-666
66.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-444
44.4
0.0
-666
66.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
333.
30.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
0-3
33.3
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-666
66.7
0.0
1333
33.3
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
6666
6.7
0.0
6666
6.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
4444
4.4
0.0
-666
66.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-444
44.4
0.0
-666
66.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
333.
30.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
0-3
33.3
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-666
66.7
0.0
1333
33.3
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
6666
6.7
0.0
6666
6.7
0.0
0.0
0.0
-444
44.4
0.0
6666
6.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
8913
8.9
0.0
0.0
-250
.00.
00.
00.
00.
00.
00.
00.
00.
0-4
4444
.40.
0-6
6666
.70.
0-3
33.3
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
1941
6.7
3750
0.0
0.0
-187
50.0
3750
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-333
.30.
0-6
6666
.70.
066
666.
70.
00.
00.
00.
00.
00.
00.
00.
00.
00.
037
500.
036
6666
.70.
0-3
7500
.050
000.
00.
00.
00.
00.
00.
00.
066
666.
70.
066
666.
70.
00.
00.
0-4
4444
.40.
066
666.
70.
00.
00.
00.
00.
00.
0-2
50.0
0.0
0.0
8938
8.9
0.0
0.0
-250
.00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
0-3
33.3
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-187
50.0
-375
00.0
0.0
3816
6.7
0.0
0.0
-187
50.0
3750
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-666
66.7
0.0
6666
6.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
3750
0.0
5000
0.0
0.0
0.0
4666
66.7
0.0
-375
00.0
5000
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-444
44.4
0.0
6666
6.7
0.0
0.0
0.0
0.0
0.0
0.0
-250
.00.
00.
089
388.
90.
00.
0-2
50.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-333
.30.
00.
00.
00.
00.
00.
00.
00.
0-1
8750
.0-3
7500
.00.
038
166.
70.
00.
0-1
8750
.037
500.
00.
00.
00.
00.
00.
00.
00.
00.
00.
0-6
6666
.70.
066
666.
70.
00.
00.
00.
00.
00.
00.
037
500.
050
000.
00.
00.
046
6666
.70.
0-3
7500
.050
000.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
0-4
4444
.40.
066
666.
70.
00.
00.
00.
00.
00.
0-2
50.0
0.0
0.0
8913
8.9
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-333
.30.
00.
00.
00.
00.
00.
00.
00.
0-1
8750
.0-3
7500
.00.
019
416.
7-3
7500
.00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
0-6
6666
.70.
066
666.
70.
00.
00.
00.
00.
00.
00.
037
500.
050
000.
00.
0-3
7500
.036
6666
.70.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
0-4
4444
.40.
066
666.
70.
00.
00.
00.
00.
00.
00.
00.
00.
089
138.
90.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
0-3
33.3
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
1941
6.7
3750
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-666
66.7
0.0
6666
6.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
3750
0.0
3666
66.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-444
44.4
0.0
6666
6.7
0.0
0.0
0.0
0.0
0.0
0.0
-250
.00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
0-3
33.3
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-187
50.0
-375
00.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-666
66.7
0.0
6666
6.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
3750
0.0
5000
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-444
44.4
0.0
6666
6.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-333
.30.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
0-6
6666
.70.
066
666.
70.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
0-4
4444
.40.
066
666.
70.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
0-3
33.3
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-666
66.7
0.0
6666
6.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-444
44.4
0.0
6666
6.7
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
-333
.30.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
0-6
6666
.70.
066
666.
70.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
00.
0
MAT
RIZ
GLO
BAL
DE
RIG
IDEZ
K P
ARA
LA E
STR
UC
TUR
A PO
RTI
CO
DE
8 PL
ANTA
S D
EL C
ASO
DE
ESTU
DIO
- F
ILAS
1 A
54
- CO
LUM
NAS
1 A
27
90
Figura 56. Deformada del pórtico luego del análisis
mediante la aplicación de ésta investigación.
Figura 57. Deformada del pórtico luego del
análisis mediante la aplicación SAP2000.
Como puede apreciarse en las figuras 58 y 59, los resultados de las fuerzas internas en los extremos de
los elementos producidos por la aplicación de ésta investigación, son en valor absoluto exactamente
iguales a aquellos correspondientes producidos por el SAP2000. La diferencia radica precisamente en
la mejora que propone el modelo de ésta investigación: corregir la dirección para cada componente de
las fuerzas internas.
Los resultados de las fuerzas internas del programa SAP2000 versión 15 (año 2011) y de muchos otros
programas de calibre profesional siempre se han basado, como se dijo, en un sistema de ejes locales del
tipo tradicional (véase la figura 7) para ambos extremos de los elementos. La desventaja de este
enfoque simplificado consiste en que la dirección de las componentes de las fuerzas internas puede
muchas veces no coincidir con la concepción correcta de las solicitaciones de tensión y compresión a
las cuales están sometidos los elementos. Esto, a su vez, sin la adecuada interpretación y modificación
del ingeniero, puede implicar un diseño incorrecto de las dimensiones o refuerzos de los elementos de
una estructura; lo cual a su vez, puede derivar en sistemas estructurales de dudoso factor de seguridad o
de diseño contrario al lado de la seguridad.
91
Figura 58. Fuerzas internas por el programa propuesto. Figura 59. F. internas producidas por el SAP2000.
E. Pxi Pyi Mzi Pxj Pyj Mzj1 -7.73 -418.30 25.37 -7.73 181.70 447.812 -3.58 -266.58 -148.93 -3.58 333.42 15.253 -1.69 -129.70 -265.55 -1.69 470.30 -415.644 -22.50 -423.99 -54.15 -22.50 176.01 550.095 -13.37 -268.36 -277.95 -13.37 331.64 151.406 -6.39 -128.08 -345.25 -6.39 471.92 -342.427 -38.03 -428.75 -30.85 -38.03 171.25 545.868 -25.89 -272.60 -319.88 -25.89 327.40 210.299 -12.86 -130.10 -382.67 -12.86 469.90 -296.94
10 -52.52 -433.11 15.40 -52.52 166.89 517.0211 -39.48 -277.41 -330.66 -39.48 322.59 240.2912 -20.34 -133.06 -402.03 -20.34 466.94 -265.7513 -65.79 -437.14 54.40 -65.79 162.86 494.1414 -53.71 -282.38 -340.91 -53.71 317.62 270.4215 -28.54 -136.50 -418.51 -28.54 463.50 -235.4916 -78.25 -440.89 76.68 -78.25 159.11 486.8617 -68.82 -287.38 -364.37 -68.82 312.62 313.9118 -37.55 -140.26 -439.80 -37.55 459.74 -199.1819 -90.42 -444.30 83.13 -90.42 155.70 494.0620 -85.27 -292.36 -401.57 -85.27 307.64 371.0121 -47.54 -144.32 -465.61 -47.54 455.68 -157.1022 -102.68 -447.08 81.62 -102.68 152.92 506.7023 -103.28 -297.12 -437.61 -103.28 302.88 426.1024 -58.53 -148.76 -485.82 -58.53 451.24 -119.1425 -3473.54 -342.09 3162.57 -3473.54 -342.09 -2136.3126 -3055.24 -249.82 2110.93 -3055.24 -249.82 -1361.4827 -2631.26 -172.31 1415.63 -2631.26 -172.31 -898.6928 -2202.50 -110.35 929.54 -2202.50 -110.35 -598.5029 -1769.40 -62.87 583.10 -1769.40 -62.87 -394.4930 -1332.26 -28.66 340.09 -1332.26 -28.66 -254.1131 -891.37 -6.91 177.43 -891.37 -6.91 -156.7132 -447.08 2.68 73.59 -447.08 2.68 -81.6233 -3570.65 -64.49 2197.89 -3570.65 -64.49 -2004.4134 -3122.37 -60.35 1705.52 -3122.37 -60.35 -1524.4835 -2677.99 -51.22 1252.34 -2677.99 -51.22 -1098.6836 -2234.14 -39.08 872.70 -2234.14 -39.08 -755.4637 -1789.85 -26.04 569.10 -1789.85 -26.04 -490.9938 -1344.61 -13.96 337.76 -1344.61 -13.96 -295.8639 -898.11 -4.54 173.38 -898.11 -4.54 -159.7540 -450.04 0.61 67.26 -450.04 0.61 -69.0841 -3646.58 -179.98 1995.00 -3646.58 -179.98 -1455.0542 -3183.46 -178.09 1705.35 -3183.46 -178.09 -1171.1043 -2723.74 -171.11 1364.95 -2723.74 -171.11 -851.6344 -2266.25 -158.08 1024.01 -2266.25 -158.08 -549.7845 -1810.60 -138.93 711.52 -1810.60 -138.93 -294.7346 -1356.47 -113.76 442.82 -1356.47 -113.76 -101.5447 -903.60 -82.49 227.43 -903.60 -82.49 20.0448 -451.64 -44.76 74.56 -451.64 -44.76 59.7249 -3709.22 -213.44 1878.57 -3709.22 -213.44 -1238.2650 -3238.93 -211.75 1653.90 -3238.93 -211.75 -1018.6551 -2767.01 -205.36 1361.07 -2767.01 -205.36 -744.9952 -2297.10 -192.50 1041.94 -2297.10 -192.50 -464.4553 -1830.16 -172.16 730.20 -1830.16 -172.16 -213.7254 -1366.66 -143.62 449.20 -1366.66 -143.62 -18.3555 -906.92 -106.06 217.53 -906.92 -106.06 100.6656 -451.24 -58.53 56.43 -451.24 -58.53 119.14
Element Forces - FramesP V2 M3
Kgf Kgf Kgf-m1 -7.73 -418.3 -25.371 -7.73 181.7 447.812 -3.58 -266.58 148.932 -3.58 333.42 15.253 -1.69 -129.7 265.553 -1.69 470.3 -415.644 -22.5 -423.99 54.154 -22.5 176.01 550.095 -13.37 -268.36 277.955 -13.37 331.64 151.46 -6.39 -128.08 345.256 -6.39 471.92 -342.427 -38.03 -428.75 30.857 -38.03 171.25 545.868 -25.89 -272.6 319.888 -25.89 327.4 210.299 -12.86 -130.1 382.679 -12.86 469.9 -296.9410 -52.52 -433.11 -15.410 -52.52 166.89 517.0211 -39.48 -277.41 330.6611 -39.48 322.59 240.2912 -20.34 -133.06 402.0312 -20.34 466.94 -265.7513 -65.79 -437.14 -54.413 -65.79 162.86 494.1414 -53.71 -282.38 340.9114 -53.71 317.62 270.4215 -28.54 -136.5 418.5115 -28.54 463.5 -235.4916 -78.25 -440.89 -76.6816 -78.25 159.11 486.8617 -68.82 -287.38 364.3717 -68.82 312.62 313.9118 -37.55 -140.26 439.818 -37.55 459.74 -199.1819 -90.42 -444.3 -83.1319 -90.42 155.7 494.0620 -85.27 -292.36 401.5720 -85.27 307.64 371.0121 -47.54 -144.32 465.6121 -47.54 455.68 -157.122 -102.68 -447.08 -81.6222 -102.68 152.92 506.723 -103.28 -297.12 437.6123 -103.28 302.88 426.124 -58.53 -148.76 485.8224 -58.53 451.24 -119.1425 -3473.54 342.09 3162.5725 -3473.54 342.09 2136.3126 -3055.24 249.82 2110.9326 -3055.24 249.82 1361.4827 -2631.26 172.31 1415.6327 -2631.26 172.31 898.6928 -2202.5 110.35 929.5428 -2202.5 110.35 598.5
Element Forces - FramesP V2 M3
Kgf Kgf Kgf-m29 -1769.4 62.87 583.129 -1769.4 62.87 394.4930 -1332.26 28.66 340.0930 -1332.26 28.66 254.1131 -891.37 6.91 177.4331 -891.37 6.91 156.7132 -447.08 -2.68 73.5932 -447.08 -2.68 81.6233 -3570.65 64.49 2197.8933 -3570.65 64.49 2004.4134 -3122.37 60.35 1705.5234 -3122.37 60.35 1524.4835 -2677.99 51.22 1252.3435 -2677.99 51.22 1098.6836 -2234.14 39.08 872.736 -2234.14 39.08 755.4637 -1789.85 26.04 569.137 -1789.85 26.04 490.9938 -1344.61 13.96 337.7638 -1344.61 13.96 295.8639 -898.11 4.54 173.3839 -898.11 4.54 159.7540 -450.04 -0.61 67.2640 -450.04 -0.61 69.0841 -3646.58 179.98 199541 -3646.58 179.98 1455.0542 -3183.46 178.09 1705.3542 -3183.46 178.09 1171.143 -2723.74 171.11 1364.9543 -2723.74 171.11 851.6344 -2266.25 158.08 1024.0144 -2266.25 158.08 549.7845 -1810.6 138.93 711.5245 -1810.6 138.93 294.7346 -1356.47 113.76 442.8246 -1356.47 113.76 101.5447 -903.6 82.49 227.4347 -903.6 82.49 -20.0448 -451.64 44.76 74.5648 -451.64 44.76 -59.7249 -3709.22 213.44 1878.5749 -3709.22 213.44 1238.2650 -3238.93 211.75 1653.950 -3238.93 211.75 1018.6551 -2767.01 205.36 1361.0751 -2767.01 205.36 744.9952 -2297.1 192.5 1041.9452 -2297.1 192.5 464.4553 -1830.16 172.16 730.253 -1830.16 172.16 213.7254 -1366.66 143.62 449.254 -1366.66 143.62 18.3555 -906.92 106.06 217.5355 -906.92 106.06 -100.6656 -451.24 58.53 56.4356 -451.24 58.53 -119.14
92
Por ejemplo, el elemento central localizado entre los nudos 18 y 22 viene a ser la columna 37 que de
acuerdo a las figuras 60 y 61 sufre las siguientes fuerzas internas en sus extremos:
Figura 7. Sistemas de ejes locales: (a)
tradicional (b) Kardestuncer.
Figura 60. Fuerzas
internas de la columna 37
según el SAP2000.
Figura 61. Fuerzas
internas de la columna
37 según el modelo
propuesto.
Los resultados del SAP2000 se pueden representar como en la figura 60 ya que el SAP2000 está
basado en la teoría estructural correspondiente al sistema tradicional de ejes locales de la figura 7a.
Nótese que el sistema de fuerzas ni siquiera aparenta estar en equilibrio. Además, según los resultados
numéricos de la figura 59, las solicitaciones axiales en ambos extremos del elemento son de
compresión; sin embargo, según la representación de la figura 60, el extremo j (inferior) aparenta estar
en tensión. Por todo esto, los resultados basados en un solo sistema de ejes locales para ambos
extremos de los elementos, pueden ser confusos y requerir casi siempre una adecuada interpretación y
modificación de la dirección de las fuerzas.
Los resultados producidos por la aplicación basada en el modelo OO de ésta investigación se grafican
en la figura 61 ya que están basados en el sistema de ejes locales Kardestuncer (véase figura 7b).
Nótese que el sistema de fuerzas se fundamenta por sí mismo demostrando estar en equilibrio. Además
ambos extremos del elemento claramente se ven sufriendo compresión tal cual dictan los resultados
numéricos del análisis. En fin, las fuerzas axiales, cortantes y momentos flectores en ambos extremos
del elemento, se manifiestan en la dirección correcta y no dan lugar a ninguna confusión ni requieren
569 Kgf*m
1790 Kgf
1790 Kgf
491 Kgf*m
26 Kgf
26 Kgf
569 Kgf*m
1790 Kgf
1790 Kgf
491 Kgf*m
26 Kgf
26 Kgf
93
modificación alguna. La figura 61 demuestra el aporte del modelo OO propuesto en ésta
investigación.
Los resultados de las reacciones en los apoyos de la estructura se muestran en las figuras 62 y 63.
Figura 62. Reacciones en los apoyos
calculadas por la aplicación propuesta.
Figura 63. Reacciones en los apoyos calculadas
por el programa SAP2000.
Las reacciones en los apoyos siempre se referencian al sistema de ejes de coordenadas
generales. Junto a los valores de las reacciones se muestra el sistema de ejes generales
XYZ sobre el cual ha sido referenciado el pórtico en cuestión en cada aplicación.
Nótese que, al tomar en cuenta el sistema de ejes correspondiente, los valores de
momento flector son exactamente los mismos para ambos casos.
Verificación Manual de Resultados
El hecho de que ambos programas hayan producido los mismos resultados (cada uno
según su sistema de coordenadas global y local) aparentemente debería bastar para
confirmar que el análisis estructural fue llevado a cabo correctamente; no obstante, es
recomendable siempre realizar una verificación manual de los resultados.
Recuerde que la verificación manual del análisis estructural consiste en: 1) Elegir un
nudo al azar y realizar la comprobación de equilibrio de las fuerzas internas/externas
que concurren al nudo. 2) Realizar la sumatoria de las fuerzas externas aplicadas
incluyendo las reacciones. Para verificar el equilibrio la suma debe ser igual a 0
(cero).
Nudo Rx Ry Mz1 -342.09 3473.54 3162.572 -64.49 3570.65 2197.893 -179.98 3646.58 1995.004 -213.44 3709.22 1878.57
X
Y
Z
TABLE: Joint Reactions
Joint F1 F3 M2
Text Kgf Kgf Kgf‐m
1 ‐342.09 3473.54 ‐3162.57
2 ‐64.49 3570.65 ‐2197.89
3 ‐179.98 3646.58 ‐1995
4 ‐213.44 3709.22 ‐1878.57
X
Z
Y
94
El nudo elegido para comprobar el equilibrio es el nudo 22. Se usa una tabla para
recopilar, ordenar, descomponer y sumar las fuerzas que concurren al nudo 22:
Concurren al nudo 22 Horizontal Vertical
Elemento 13 -65.79 +162.86
Elemento 14 +53.71 +282.38
Elemento 37 +26.04 -1789.85
Elemento 38 -13.96 +1344.61
Suma 0.00 0.00
Se ha verif icado exitosamente el equil ibrio en el nudo 22 de la estructura lo cual
indica que el modelo y su implementación ( i . e. el programa) están produciendo
resultados correctos con relación a las fuerzas internas en los extremos de los
elementos.
Ahora bien, la tabla para la verificación del equilibrio de las componentes
horizontal y vertical de las fuerzas externas y reacciones que actúan en la estructura
es la siguiente:
Descripción Horizontal Vertical
Carga externa nudo 5 a 13 +800.00 0.00
Carga externa elementos 1 a 24 0.00 -14400.00
Reacción apoyo 1 -342.09 +3473.54
Reacción apoyo 2 -64.49 +3570.65
Reacción apoyo 3 -179.98 +3646.58
Reacción apoyo 4 -213.44 +3709.22
Sumatoria 0.00 0.00
95
3.8.3 OtrasConsideraciones
Las figuras 64 y 65 comparan el código para el cálculo de las reacciones en los apoyos escrito en
FORTRAN y Java, respectivamente.
Aunque el FORTRAN se caracteriza por su potencia en los cálculos matemáticos, el orden de
instrucciones debe ser secuencial; es decir, la programación del algoritmo debe ser lineal. Para
producir cualquier alteración del orden de la lógica, se usa la instrucción GOTO. Sigue un modelo de
programación procedimental de contexto global.
En el paradigma OO un módulo cohesivo ejecuta una tarea sencilla y requiere poca interacción con
procedimientos que ejecutan otras partes del programa.
Interesa un cohesión alta y un acoplamiento bajo. El acoplamiento es la medida de la interconexión
entre módulos de un programa.
La independencia funcional se adquiere desarrollando módulos con una clara función evitando una
excesiva interacción con otros módulos. Este concepto está derivado de la abstracción y el
ocultamiento de información.
En Java la unidad fundamental de programación es la clase. Nótese que el código Java de la figura 65
se distinguen objetos y conceptos OO como ser: clases, abstracción, ocultamiento, polimorfismo,
constructores, métodos, etc.
Los sistemas OO son más fáciles de adaptar y escalar (pueden crearse grandes sistemas ensamblando
sistemas reutilizables).
Complejidad Ciclomática
La complejidad ciclomática determina la complejidad de un código estructurado (cíclico). Cuántos
más caminos el código pueda tomar (ya sea por medio de condiciones o bucles), mayor es la cantidad
de pruebas necesarias.
Por ejemplo, en programación estructurada, el código para ensamblar la matriz de rigidez de la
estructura, bien podría estar representado según se muestra en la figura 66.
96
Figura 64. Código FORTRAN.
Figura 65. Código Java.
97
Figura 66. Código JavaScript
Mientras que, en programación OO, el código para ensamblar la matriz de rigidez de la estructura se
muestra en la figura 67.
Figura 67. Código Java.
Nótese que, en programación estructurada se requieren de 3 ciclos anidados explícitos
para ensamblar la matriz de rigidez de una estructura; mientras que, en la programación
OO del modelo propuesto en ésta investigación, se requiere de un solo bucle explícito
de cálculo. Lo mismo sucede con el ensamblado del vector fuerza generalizado y con
el vector desplazamiento generalizado de la estructura. Por consiguiente, el modelo OO
propuesto en ésta investigación minimiza la cantidad de ciclos anidados explícitos de
cálculo.
En lo que respecta al cálculo de los resultados del análisis estructural como el cálculo
de las fuerzas internas en los extremos de los elementos, en un lenguaje estructurado
como el JSCRIPT se necesitan 5 bucles anidados para hallar el vector de las fuerzas
internas en el extremo i del elemento ij (véase figura 66a).
98
Figura 66a. Código JSCRIPT.
En el lenguaje Java a partir de la implementación del modelo OO propuesto, el cálculo de las fuerzas
internas en ambos extremos de los elementos necesita tan solo de un bucle (véase figura 67a).
Figura 67a. Código Java.
Comparación de Tiempo de Cómputo
Para comparar el tiempo de cómputo resultante de la implementación del modelo OO
propuesto, se ha comparado los tiempos de análisis estructural de estructuras
representativas empleando la aplicación de ésta investigación versus una aplicación
basada en la misma teoría estructural pero programada en el lenguaje científico
estructurado RPL (Reverse Polish Language) por el mismo autor de ésta investigación.
99
Plataforma Hardware
Máquina: Dell Optiplex 380 X86-Based PC
Procesador: Intel Core 2 Quad @ 2.66 GHZ
RAM / HDD: 4 GB / 500 GB (SATA)
Plataforma Software
Sistema Operativo: MS Windows 7 Pro
Máquina Virtual Java: v. 6
Lenguaje RPL: HP48-R v. 1.41
La geometría de las estructuras que fueron objeto para la comparación de tiempo de cómputo
se muestran en la parte superior de la siguiente tabla. Los tiempos mostrados son tiempos
promedios calculados de un conjunto de tiempos tomados durante el análisis.
Reticulado o grilla Pórtico o marco plano Cercha o armadura
Nudos 4 5 11
Elementos 3 4 19
Ecuaciones 12 15 33
Tiempo
RPL
421 ms 527 ms 2069 ms
Tiempo
Java
16 ms 15 ms 53 ms
IEC(*) 96% 97% 97%
(*) Incremento en la eficiencia de cómputo.
El tiempo consumido por la aplicación programada en lenguaje estructurado como el RPL es
notoriamente mayor al tiempo consumido por la aplicación programada bajo el modelo OO
de ésta investigación. Además la complejidad ciclomática de la aplicación RPL hace que el
100
tiempo para el análisis de estructuras más complejas como la cercha sea exponencialmente
mayor. Ahora bien, los tiempos consumidos para estructuras simples empleando la
aplicación OO de ésta investigación, son casi iguales en el rango de los milisegundos; sin
embargo para estructuras más complejas como la cercha el tiempo es mayor pero no
exponencialmente mayor. La complejidad ciclomática que involucra ciclos anidados
explícitos de cálculo eleva notoriamente los tiempos consumidos en lenguaje estructurado.
Complejidad de Algoritmos
¿Cuándo proporciona un algoritmo una solución satisfactoria a un problema? Primero, debe
producir siempre la respuesta correcta. Segundo, deberá ser eficiente.
¿Cómo se puede analizar la eficiencia de los algoritmos? Una medida de eficiencia es el
tiempo que requiere un ordenador para resolver un problema utilizando un algoritmo para
valores de entrada de un tamaño específico.
Un análisis del tiempo requerido para resolver un problema de un tamaño particular está
relacionado con la complejidad en tiempo del algoritmo y un análisis de la memoria de
ordenador requerida involucra la complejidad en espacio del algoritmo. Obviamente, es
importante saber si un algoritmo producirá su respuesta en un milisegundo, en un minuto o
en un millón de años y de manera similar debemos tener suficiente memoria disponible para
poder resolver el problema.
La complejidad del algoritmo se denota según la notación Big-O.
Por ejemplo, O(n) significa que el algoritmo tiene una complejidad lineal. En otras palabras,
toma 10 veces más tiempo en operar un set de 100 datos que en hacerlo con un set de 10
ítems. Si la complejidad fuera O(n2) entonces tomaría 100 veces más tiempo en operar 100
ítems que en hacerlo con 10.
Complejidad Terminología
O(1) Complejidad constante
O(log n) Complejidad logarítmica
O(n) Complejidad lineal
101
O(n log n) Complejidad n log n
O(n^b) Complejidad polinómica
O(b^n) Complejidad exponencial
O(n!) Complejidad factorial
El enfoque empleado para medir la complejidad de un algoritmo será un enfoque
empírico o a posteriori: 1) Se ejecutará el programa con entradas de tamaño y
composición variadas. 2) Se usará un comando para obtener una medida exacta del
t iempo de ejecución real . 3) Se trazarán los resultados
El estudio a posteriori permite hacer una evaluación experimental de los recursos
consumidos que no es posible en un estudio a priori .
Interesa el comportamiento de un algoritmo para tal las relativamente grandes:
complej idades asintóticas. Se ha comparado los t iempos de ejecución del análisis
estructural de pórticos de edificios de varios pisos (véase figura 70). El hardware y
software empleados son los mismos que en el anterior apartado. N es la tal la o bien
la medida del tamaño del problema y ha sido asociada al número de elementos
estructurales que componen cada pórt ico. El t iempo de ejecución es T(N). Los
resultados se muestran a continuación. La aplicación RPL ha quedado sin memoria
para un pórtico de 7 pisos.
* T(N) medida en milisegundos
Plantas Nudos Elementos (N) T1(N) T2(N) T3(N) T(N) Medio T1(N) T2(N) T3(N) T(N) Medio
1 8 7 913 912 924 916 30 29 27 292 12 14 1905 1980 1898 1928 51 49 47 493 16 21 3070 3047 3107 3075 60 62 64 624 20 28 4416 4493 4512 4474 75 74 74 745 24 35 6037 6018 6016 6024 90 90 92 916 28 42 8024 8070 8036 8043 105 102 103 1037 32 49 126 120 123 123
Aplicación RPL Aplicación Java
102
Para apreciar gráficamente la tendencia de la complejidad temporal de cada algoritmo, se ha graficado
los resultados en las curvas de a continuación:
Figura 68. Complejidad del algoritmo
procedimental programado en RPL.
Figura 69. Complejidad del algoritmo resultante del
modelo OO de la aplicación en Java.
De las curvas, se puede deducir que, las estructuras pueden resolverse con distintos grados de
eficiencia.
Se ha realizado el ajuste de curvas para determinar las ecuaciones que gobiernan ambas curvas. Las
ecuaciones resultantes y el coeficiente de relación se muestran a continuación:
Para la curva de la figura 68: Para la curva de la figura 69:
Ecuación: 83.9871 . Ecuación: 15.8095
2.1446
Correlación: 0.9979 Correlación: 0.9977
Orden de
complejidad:
potencial Orden de
complejidad:
lineal
0
1000
2000
3000
4000
5000
6000
7000
8000
9000
0 20 40 60
T(N
) m
ilis
eg
un
do
s
N elementos
0
20
40
60
80
100
120
140
0 20 40 60
T(N
) m
ilis
eg
un
do
s
N elementos
103
Dado que un orden de complejidad lineal implica un algoritmo más eficiente que uno potencial, se
prueba la hipótesis de la mejora de eficiencia de cómputo con el modelo OO propuesto en ésta
investigación.
Hay que elegir siempre algoritmos con el menor orden de complejidad.
Figura 70. Pórticos de varios pisos empleados para el cálculo del orden de complejidad.
104
Parte4–ConclusionesyRecomendaciones
Las estructuras de ingeniería tienen un rol de servicio importante en el Mundo. Una estructura debe
cumplir su misión con resistencia y rigidez.
El análisis estructural se usa para diseñar estructuras. El análisis determina la deformada de la
estructura para verificar si es adecuada para sus cargas de diseño.
El método de los elementos finitos MEF es para simular sistemas de ingeniería en computadora. El
MEF consiste en: elegir un elemento para el modelado, aplicar un proceso para lograr un modelo
global y resolver el sistema de ecuaciones de la estructura.
El método de la matriz de rigidez es el proceso que requiere el MEF al tratar con estructuras. El
método de la rigidez establece la relación entre las cargas externas y los desplazamientos de una
estructura.
Los marcos rígidos planos o pórticos son estructuras 2D cuyas cargas externas están en el mismo
plano. Las cerchas pueden modelarse como marcos planos manteniendo la inercia de sus elementos
casi cero.
Un solo sistema de ejes locales para ambos extremos de un elemento estructural es una opción
simplificada que se ha usado siempre pero que no conviene porque puede inducir a ambigüedades en
la interpretación de los resultados del análisis. El sistema de ejes locales Kardestuncer es mejor porque
provee un sistema de ejes locales para cada extremo de los elementos de una estructura.
Los objetos resuelven los problemas de la programación procedimental al combinar datos y
comportamiento en un solo paquete encapsulado.
Los objetos son estructuras de datos que permiten la reutilización que conduce a un desarrollo rápido
de software.
El análisis y diseño orientado a objetos OO está basado en conceptos como: clases, encapsulación,
ocultamiento, interfaz, implementación, herencia, superclases, subclases, abstracción, polimorfismo,
composición, persistencia, clases abstractas, interfaces java, etc.
El objetivo del análisis OO es producir las clases relevantes al problema que se va a resolver. El
diseño OO transforma el modelo del análisis en un modelo que sirve para el desarrollo de software.
105
El UML es un lenguaje para el modelado OO consistente en diagramas que proporcionan diferente
vistas del modelo OO. El UML es una herramienta para generar y comunicar diseños entre creadores
de sistemas.
Las metodologías de desarrollo consisten en pasos estructurados y de distinta naturaleza. Todas son
una mejora de la interacción entre las etapas: análisis, diseño, codificación y distribución.
Debido a las computadoras el MEF ha sido ampliamente como herramienta de modelado y simulación
de sistemas en ingeniería. Los programas tradicionales siempre han consistido en miles de líneas de
código dificultoso de leer, escribir y mantener en lenguajes procedimentales...
El estado del arte revela nuevos tipos de elementos finitos, esquemas matriciales, modelos generales
OO, aplicaciones de análisis no-lineal, algoritmos de computación evolutiva de diseño estructural con
modelos OO para análisis plástico no-lineal, optimización estructural, plataformas OO para MEF
multipropósito, modelos OO para problemas MEF 3D mediante computación distribuida, librerías
matemáticas para aplicaciones OO de MEF, etc.
El diseño del modelo OO propuesto en ésta investigación emerge de una declaración de trabajo a partir
de la cual se realiza un análisis de requerimientos para poder diseñar las distintas vistas del modelo OO
usando UML.
En los casos de uso se distinguen dos actores: el sistema y el usuario. Del análisis de requerimientos,
los sustantivos se convierten en clases y los verbos en operaciones de los objetos. El modelo OO
resultante está basado en conceptos OO puros como: clases, encapsulación, herencia, superclases,
subclases, abstracción, polimorfismo, composición, clases abstractas, interfaces java, etc. Lo cual
prueba que la naturaleza del análisis estructural mediante el MEF - elemento viga sistema ejes locales
Kardestuncer, es absolutamente orientada a objetos.
El diseño del modelo OO propuesto permite el desarrollo de una aplicación robusta, eficiente y
escalable. La implementación debe cumplir con conceptos fundamentales de la programación OO
como los getters y setters que administran el ocultamiento en una clase. La implementación se la
realizó en Java; sin embargo, el modelo puede programarse en otro lenguaje de objetos como:
Smalltalk, Eiffel, C++, Python, etc.
Los casos de estudio probaron la factibilidad y las ventajas del modelo OO propuesto en cuanto a
concepto y resultados. En cuanto a conceptos porque el modelo mejora las fuerzas internas en los
extremos de los elementos conforme Kardestuncer. En cuanto a resultados porque las verificaciones
manuales basadas en conceptos fundamentales de equilibrio estructural, prueban la exactitud del
modelo y su implementación.
106
Finalmente, hay mejoras que realizar en el modelo OO como la inclusión de cargas distribuidas
triangulares sobre los elementos, apoyos elásticos, etc., en virtud de probar la escalabilidad y extender
su funcionalidad.
107
Referencias
BEER FERDINAND Y JOHNSTON E. RUSELL (1993) “Mecánica Vectorial para Ingenieros”.
Editorial McGraw-Hill. México.
BOREK PATZAK (2008) “Object Oriented Finite Element Solver”. USA.
BRAY, CROXTON AND MARTIN (1976) “Matrix Analysis of Structures”. Editorial Edward
Arnold. England.
CHRISTOS G. BINIARIS (2004) “A Three-Dimensional Object-Oriented Distributed Finite
Element Solver Based on Mobile Agent Technology”. USA.
FRANK MCKENNA (2000) “A New Design for Object-Oriented Finite Element Software”.
USA.
GRAHAM CHARLES ARCHER (1996) “Object-Oriented Finite Element Analysis”. University
of California at Berkeley. USA.
H. ADELI & KAMAL (1993) “Parallel Processing in Structural Engineering”. Editorial Elsevier
Science. England.
H. KARDESTUNCER (1975) "Introducción al Análisis Estructural con Matrices". McGraw-Hill.
USA.
HORSTMANN Y CORNELL (2001) “Core Java 2 Volume II Advanced Features”. Editorial
Prentice-Hall. USA.
JOSEPH SCHMULLER (2002) “Aprendiendo UML en 24 Horas”. Editorial Prentice Hall.
USA.
JUN LU (1994) “An Object-Oriented Application Framework for Finite Element Analysis in
Structural Engineering”. USA.
KEPA RÍOS ALDAY (2008) “Estructura de Datos”. Ingeniería en Informática. Universidad
Carlos III de Madrid. España.
KLAUS-JURGEN BATHE (1996) “Finite Element Procedures”. Editorial Prentice-Hall. USA.
MARTIN AND CAREY (1973) “Introduction to Finite Element Analysis”. Editorial McGraw-
Hill. USA.
108
MARTY HALL (2008) “Java 2D Drawing”. USA.
MATT WEISFELD (2004) “The Object-Oriented Thought Process”. Segunda edición. Editorial
Sams. USA.
MOSHE RUBINSTEIN (1966) “Matrix Analysis of Structures”. Editorial Prentice-Hall. USA.
NELSON TERRAZAS (2007) “Introducción Práctica a UML”. IDELOGIX. LP-BOL.
NICHOLAS BARAN (1988) “Finite Element on Microcomputers”. Editorial McGraw-Hill.
USA.
NORRIS Y WILBUR (1969) “Análisis Elemental De Estructuras”. Editorial McGraw-Hill.
México.
PRZEMIENIECKI (1968) “Theory of Matrix Structural Analysis”. Editorial McGraw-Hill.
USA.
RICHARD GALLAGHER (1975) “Finite Element Analysis”. Editorial Prentice-Hall. USA.
ROBERT MELOSH (1990) “Structural Engineering Analysis by Finite Elements”. Editorial
Prentice-Hall. USA.
ROBERT W. HORNBECK (1975) “Numerical Methods”. Primera Edición. Editorial Quantum
Publishers, Inc. New York, USA.
SAUL J. ESCALERA (1992) “Manual de Tesis de Grado”. Primera Edición. Universidad Mayor
de San Simón. Cochabamba, Bolivia.
TEDDY CUELLAR MULLER (1980) “Cálculo de Placas por el Método de Elementos Finitos
R16”. UMSA. La Paz, Bolivia
YAILE CABALLERO (2007) "Análisis y Diseño Orientado a Objetos". Postgrado en
Informática. Universidad de Camagüey. Cuba.
109
ApendiceA–ListadodeCodigoFuente
La figura A.1 muestra la organización mediante paquetes del código fuente escri to
en Java para la aplicación desarrollada en ésta investigación con el fin de demostrar
el modelo OO propuesto.
El paquete “Jama” que viene de “Java Matrix” contiene una serie de clases que
proveen a la aplicación de herramientas para el álgebra matricial, tal como se
expuso en la parte 3 de éste informe. Jama ha sido elaborado por terceros y es
considerado uno de los mejores productos de distr ibución gratuita para el álgebra de
matrices.
El paquete “com.csvreader” consiste en dos clases para la lectura y escritura de
archivos que contienen valores separados por comas extensión CSV (comma
separated values) . Dicho paquete ha sido elaborado por terceros y es una de las
mejores propuestas que se distr ibuye gratuitamente.
El paquete “estructural” contiene todas las clases para el modelo OO desarrollado
extensamente en éste trabajo.
El paquete “kar07” contiene la clase principal de la aplicación ( i .e. Main) que sirve
como punto de entrada para la ejecución. Y la clase “elegirest01” proporciona el
formulario inicial que permite elegir la estructura a resolver.
El paquete “util01” contiene tres clases util i tar ias importantes: “entsal” para la
lectura y escritura de los archivos de entrada y salida del anális is de la estructura,
respectivamente; “graficar01” para graficar la geometría y la deformada de la
estructura; y “otros01” que facil i ta subrutinas de conversión entre reales, cadenas y
arreglos.
Los paquetes es tructural, kar07 y uti l01 han sido escritos desde cero para ésta
investigación. A continuación se desglosa el l istado de código fuente para todas las
clases de éstos tres paquetes.
110
Figura A.1. Organización del código fuente de la aplicación de análisis estructural.
111
/* * clase abstracta para carga sobre elemento */ package estructural; import Jama.Matrix; /** * rsaravia 2012 */ public abstract class cargaele00 implements interface01 { String id; double a, b, L; double[] c = new double[5]; Matrix F; public void setid(String s) { id = s; } public String getid() { return id; } // inicio de aplicacion de carga public void seta(double v) { a = v; } public double geta() { return a; } // longitud de aplicacion de carga public void setb(double v) {
b = v; } public double getb() { return b; } // longitud del elemento public void setL(double v) { L = v; } public double getL() { return L; } // vector carga en coordenadas generales public void setF(Matrix m) { F = m; } public Matrix getF() { return F; } // coeficientes de empotramiento public abstract double[] getC(int s); } /* * subclase para carga puntual sobre elemento */ package estructural; /** * rsaravia 2012
112
*/ public class cargaele01 extends cargaele00 { // constructor public cargaele01() { id = "puntual"; } // implementacion del calculo de coeficientes de empotramiento public double[] getC(int s) { double a1; if (s > 0) { a1 = a; } else { a1 = L - a; } c[0] = (L - a1) / L; c[1] = Math.pow(L - a1, 2) * (L + 2 * a1) / Math.pow(L, 3); c[2] = a1 * Math.pow(L - a1, 2) / Math.pow(L, 2); return c; } } /* * subclase para carga rectangular distribuida sobre elemento */ package estructural; /** * rsaravia 2012 */ public class cargaele02 extends cargaele00 {
double a1; // constructor public cargaele02() { id = "rectangular"; } // implementacion del calculo de coeficientes de empotramiento public double[] getC(int s) { if (s > 0) { a1 = a; } else { a1 = L - a - b; } c[0] = b * (L - a1 - b / 2) / L; c[1] = (2 * b * L - 2 * f(3) / L + f(4) / Math.pow(L, 2)) / (2 * L); c[2] = (6 * Math.pow(L, 2) * f(2) - 8 * L * f(3) + 3 * f(4)) / (12 * Math.pow(L, 2)); return c; } private double f(double n) { return Math.pow(a1 + b, n) - Math.pow(a1, n); } } /* * clase abstracta para elementos viga * puede usarse para elementos 2D o 3D */ package estructural; import java.util.ArrayList;
113
import Jama.Matrix; /** * rsaravia 2012 */ public abstract class elemento00 implements interface01 { String id; nudo00 ni, nj; double[] pro, d, cosdir, t; ArrayList cargas; double L; int dim2; // dimension de las matrices del elemento public static int calcdim2(int d) { return 3 * (d - 1); } public void setid(String s) { id = s; } public String getid() { return id; } // nudo inicial i public void setni(nudo00 n) { ni = n; } public nudo00 getni() { return ni; }
// nudo final j public void setnj(nudo00 n) { nj = n; } public nudo00 getnj() { return nj; } // propiedades geometricas e inerciales public void setpro(double[] v) { pro = v; } public double[] getpro() { return pro; } // longitud del elemento public double getL() { return L; } // para cargas q actuan sobre el elemento public void setcargas(cargaele00 carga) { cargas.add(carga); } public ArrayList getcargas() { return cargas; } // inicializa valores basicos de calculo public void ini(int v) { dim2 = v; cargas = new ArrayList();
114
calcdelta(); calcL(); calccosdir(); calct(); } // matriz de rotacion de coordenadas Rij // matriz de rigidez directa local kiij, kjji // matriz de rigidez cruzada local kij, kji // matriz de coeficientes de empotramiento Cij public abstract Matrix getRij(int s); public abstract Matrix getkiij(); public abstract Matrix getkij(); public abstract Matrix getkjji(); public abstract Matrix getCij(double[] v); // matriz de rigidez directa global public Matrix getKGiij() { return (getRij(1).transpose()).times(getkiij().times(getRij(1))); } // matriz de rigidez directa global public Matrix getKGjji() { return (getRij(-1).transpose()).times(getkjji().times(getRij(-1))); } // matriz de rigidez cruzada global public Matrix getKGij() { return (getRij(1).transpose()).times(getkij().times(getRij(-1))); } // fuerza de empotramiento
public Matrix getpije(int s) { Matrix pije = new Matrix(dim2, 1); for (int i1 = 0; i1 < cargas.size(); i1++) { cargaele00 carga = (cargaele00) cargas.get(i1); Matrix Cr = getCij(carga.getC(s)); Matrix Fr = carga.getF(); pije.plusEquals(Cr.times(getRij(s).times(Fr))); } return pije; } // carga puntual debido a fuerzas de empotramiento public Matrix getPie(int s) { return getRij(s).transpose().times(getpije(s)).times(-1); } // fuerza interna extremo i public Matrix getpij() { Matrix p1 = getkiij().times(getRij(1).times(ni.getD())); Matrix p2 = getkij().times(getRij(-1).times(nj.getD())); return p1.plus(p2.plus(getpije(1))); } // fuerza interna extremo j public Matrix getpji() { Matrix p1 = getkjji().times(getRij(-1).times(nj.getD())); Matrix p2 = getkij().transpose().times(getRij(1).times(ni.getD())); return p1.plus(p2.plus(getpije(-1))); } // diferencia de coordenadas entre extremos private void calcdelta() { double[] c1 = ni.getcoor(); double[] c2 = nj.getcoor(); d = new double[c1.length];
115
for (int i1 = 0; i1 < d.length; i1++) { d[i1] = c1[i1] - c2[i1]; } } // longitud del elemento private void calcL() { for (int i0 = 0; i0 < d.length; i0++) { L += Math.pow(d[i0], 2); } L = Math.sqrt(L); } // cosenos directores private void calccosdir() { cosdir = new double[d.length]; for (int i0 = 0; i0 < cosdir.length; i0++) { cosdir[i0] = d[i0] / L; } } // valores base de matriz de rigidez local abstract void calct(); } /* * subclase para elementos 2D biempotrados * solo para marcos rigidos planos */ package estructural; import Jama.Matrix; /** * rsaravia 2012 */
public class elemento01 extends elemento00 { // constructor public elemento01(String s1) { id = s1; } // matriz de rotacion de coordenadas Rij public Matrix getRij(int s) { Matrix R = new Matrix(dim2, dim2); R.set(0, 0, cosdir[0] * s); R.set(0, 1, cosdir[1] * s); R.set(1, 0, -cosdir[1] * s); R.set(1, 1, cosdir[0] * s); R.set(2, 2, 1); return R; } // matriz de rigidez directa local kiij public Matrix getkiij() { Matrix k = new Matrix(dim2, dim2); k.set(0, 0, t[0]); k.set(1, 1, t[1]); k.set(1, 2, t[2]); k.set(2, 1, t[2]); k.set(2, 2, 2 * t[3]); return k; } // matriz de rigidez cruzada local kij public Matrix getkij() { Matrix k = new Matrix(dim2, dim2); k.set(0, 0, t[0]); k.set(1, 1, t[1]); k.set(1, 2, t[2]); k.set(2, 1, t[2]);
116
k.set(2, 2, t[3]); return k; } // matriz de rigidez directa local kjji public Matrix getkjji() { return getkiij(); } // matriz de coeficientes de empotramiento Cij public Matrix getCij(double[] v) { Matrix C = new Matrix(dim2, dim2); C.set(0, 0, -v[0]); C.set(1, 1, -v[1]); C.set(1, 2, v[3]); C.set(2, 1, v[2]); C.set(2, 2, -v[4]); return C; } // valores base de matriz de rigidez local void calct() { t = new double[4]; t[0] = pro[0] * pro[2] / L; t[1] = 12 * pro[0] * pro[1] / Math.pow(L, 3); t[2] = -6 * pro[0] * pro[1] / Math.pow(L, 2); t[3] = 2 * pro[0] * pro[1] / L; } } /* * subclase para elementos 2D biempotrados * solo para grillas o parrillas */ package estructural;
import Jama.Matrix; /** * rsaravia 2012 */ public class elemento02 extends elemento00 { // constructor public elemento02(String s1) { id = s1; } // matriz de rotacion de coordenadas Rij public Matrix getRij(int s) { Matrix R = new Matrix(dim2, dim2); R.set(1, 1, cosdir[0] * s); R.set(1, 2, cosdir[1] * s); R.set(2, 1, -cosdir[1] * s); R.set(2, 2, cosdir[0] * s); R.set(0, 0, 1); return R; } // matriz de rigidez directa local kiij public Matrix getkiij() { Matrix k = new Matrix(dim2, dim2); k.set(0, 0, t[0]); k.set(0, 2, t[1]); k.set(1, 1, t[2]); k.set(2, 0, t[1]); k.set(2, 2, 2 * t[3]); return k; } // matriz de rigidez cruzada local kij
117
public Matrix getkij() { Matrix k = new Matrix(dim2, dim2); k.set(0, 0, -t[0]); k.set(0, 2, -t[1]); k.set(1, 1, t[2]); k.set(2, 0, -t[1]); k.set(2, 2, -t[3]); return k; } // matriz de rigidez directa local kjji public Matrix getkjji() { return getkiij(); } // matriz de coeficientes de empotramiento Cij public Matrix getCij(double[] v) { Matrix C = new Matrix(dim2, dim2); C.set(0, 0, -v[1]); C.set(0, 2, -v[3]); C.set(1, 1, -v[0]); C.set(2, 0, -v[2]); C.set(2, 2, -v[4]); return C; } // valores base de matriz de rigidez local void calct() { t = new double[4]; t[0] = 12 * pro[0] * pro[1] / Math.pow(L, 3); t[1] = 6 * pro[0] * pro[1] / Math.pow(L, 2); t[2] = pro[2] / L; t[3] = 2 * pro[0] * pro[1] / L; } }
/* * clase abstracta para sistemas estructurales * puede usarse para estructuras 2D y 3D */ package estructural; import java.util.ArrayList; import Jama.Matrix; import util01.*; /** * rsaravia 2012 */ public abstract class estructura00 implements interface01 { String id, archivo, tipo; int dim1, dim2, dim3, nr; ArrayList nudos, elementos; Matrix P, K, D; public void setid(String s) { id = s; } public String getid() { return id; } // nombre base para los archivos de la estructura public void setarchivo(String s) { archivo = s; } public String getarchivo() { return archivo;
118
} // tipo de estructura public void settipo(String s) { tipo = s; } public String gettipo() { return tipo; } // numero de dimensiones de la estructura public void setdim1(int d) { dim1 = d; } public int getdim1() { return dim1; } // agregar nudo a la estructura public void setnudos(nudo00 nu) { nudos.add(nu); } public ArrayList getnudos() { return nudos; } // agregar elemento a la estructura public void setelementos(elemento00 ele, int i, int j) { ele.setni((nudo00) nudos.get(i - 1)); ele.setnj((nudo00) nudos.get(j - 1)); ele.ini(elemento00.calcdim2(dim1)); elementos.add(ele); }
public ArrayList getelementos() { return elementos; } // getter matriz de rigidez de la estructura public Matrix getK() { return K; } // getter vector fuerza de la estructura public Matrix getP() { return P; } // agregar cargas puntuales en los nudos public void inscarganu(int i, Matrix P) { nudo00 nu = (nudo00) nudos.get(i - 1); nu.setP(P); } // agregar cargas en los elementos public void inscargaele(int i, cargaele00 cargaele) { elemento00 ele = (elemento00) elementos.get(i - 1); cargaele.setL(ele.getL()); ele.setcargas(cargaele); } // insertar restricciones en los nudos (apoyos) public void insres(int i, boolean[] b) { nudo00 nu = (nudo00) nudos.get(i - 1); nu.setid(nu.getid() + "r"); nu.setres(b); } // dimension de las matrices y vectores de la estructura
119
public static int calcdim3(int d, int n) { return elemento00.calcdim2(d) * n; } // ensamblar sistema de ecuaciones de la estructura public void ensamblarsis() { dim2 = elemento00.calcdim2(dim1); dim3 = estructura00.calcdim3(dim1, nudos.size()); P = new Matrix(dim3, 1); K = new Matrix(dim3, dim3); D = new Matrix(dim3, 1); for (int n = 0; n < elementos.size(); n++) { elemento00 ele = (elemento00) elementos.get(n); int i1 = otros01.getindex(ele.getni().getn(), dim2); int j1 = otros01.getindex(ele.getnj().getn(), dim2); otros01.inssumando(K, ele.getKGiij(), i1, i1); otros01.inssumando(K, ele.getKGjji(), j1, j1); Matrix KGij = ele.getKGij(); K.setMatrix(i1, i1 + dim2 - 1, j1, j1 + dim2 - 1, KGij); K.setMatrix(j1, j1 + dim2 - 1, i1, i1 + dim2 - 1, KGij.transpose()); otros01.inssumando(P, ele.getPie(1), i1, 0); otros01.inssumando(P, ele.getPie(-1), j1, 0); } for (int i = 0; i < nudos.size(); i++) { nudo00 nu = (nudo00) nudos.get(i); int i1 = otros01.getindex(nu.getn(), dim2); Matrix Pi = P.getMatrix(i1, i1 + dim2 - 1, 0, 0); ArrayList Pn = nu.getP();
for (int j = 0; j < Pn.size(); j++) { Pi.plusEquals((Matrix) Pn.get(j)); } if (nu.getres().size() > 0) { nu.setP(null); nu.setP(P.getMatrix(i1, i1 + dim2 - 1, 0, 0).times(-1)); } P.setMatrix(i1, i1 + dim2 - 1, 0, 0, Pi); } } // resolver el sistema de ecuaciones de la estructura public void resolversistema() { boolean[] f = new boolean[dim3]; int dim4 = dim3; for (int c = 0; c < nudos.size(); c++) { nudo00 nu = (nudo00) nudos.get(c); ArrayList res = nu.getres(); for (int i = 0; i < res.size(); i++) { boolean[] r = (boolean[]) res.get(i); int i1 = otros01.getindex(nu.getn(), dim2); for (int j = 0; j < r.length; j++) { if (r[j]) { f[i1 + j] = r[j]; dim4--; } } } } entsal.guardarmatsis(archivo + "(K)", K, f); K = null;
120
Matrix Pr = new Matrix(dim4, 1); int o = 0; for (int c = 0; c < f.length; c++) { if (!f[c]) { Pr.set(c - o, 0, P.get(c, 0)); } else { o++; } } P = null; Matrix Kr = entsal.abrirmatsis(archivo + "(K)r", dim4, dim4); Matrix Dr = Kr.solve(Pr); Kr = null; Pr = null; o = 0; for (int c = 0; c < f.length; c++) { if (!f[c]) { D.set(c, 0, Dr.get(c - o, 0)); } else { o++; } } Dr = null; K = entsal.abrirmatsis(archivo + "(K)", dim3, dim3); P = K.times(D); K = null; entsal.guardarmatsis(archivo + "(P)", P, f); entsal.guardarmatsis(archivo + "(D)", D, f); nr = 0; for (int k = 0; k < nudos.size(); k++) { nudo00 nu = (nudo00) nudos.get(k);
int i1 = otros01.getindex(k + 1, dim2); Matrix Di = D.getMatrix(i1, i1 + dim2 - 1, 0, 0); nu.setD(Di); if (nu.getres().size() > 0) { nu.setP(P.getMatrix(i1, i1 + dim2 - 1, 0, 0)); nr++; } } P = null; D = null; } // calcular las fuerzas internas de los elementos de la estructura public void calcfinternas() { Matrix fint = new Matrix(elementos.size(), dim2 * 2); for (int k = 0; k < elementos.size(); k++) { elemento00 ele = (elemento00) elementos.get(k); Matrix pij = ele.getpij().transpose(); Matrix pji = ele.getpji().transpose(); fint.setMatrix(k, k, 0, dim2 - 1, pij); fint.setMatrix(k, k, dim2, 2 * dim2 - 1, pji); } entsal.guardarmat(archivo + "(fint)", fint); } // calcular las reacciones en los apoyos de la estructura public void calcreacciones() { int x = -1; Matrix re = new Matrix(nr, dim2); for (int i = 0; i < nudos.size(); i++) { nudo00 nu = (nudo00) nudos.get(i); if (nu.getres().size() > 0) { x++; ArrayList Pn = nu.getP();
121
Matrix R = new Matrix(dim2, 1); for (int j = Pn.size() - 1; j > -1; j--) { if (!(Pn.get(j) == null)) { R.plusEquals((Matrix) Pn.get(j)); } else { break; } } re.setMatrix(x, x, 0, dim2 - 1, R.transpose()); } } entsal.guardarmat(archivo + "(reacciones)", re); } } /* * subclase para sistemas estructurales * puede usarse para estructuras 2D y 3D */ package estructural; import java.util.ArrayList; /** * rsaravia 2012 */ public class estructura01 extends estructura00 { // constructor public estructura01(String s1) { id = s1; nudos = new ArrayList(); elementos = new ArrayList(); } }
/* * clase abstracta para los nudos de la estructura * se puede usar en estructuras 2D o 3D */ package estructural; import java.util.ArrayList; import Jama.Matrix; /** * rsaravia 2012 */ public abstract class nudo00 implements interface01 { String id; int n; double[] coor; ArrayList P, res; Matrix D; public void setid(String s) { id = s; } public String getid() { return id; } // numero de nudo public void setn(int i) { n = i; } public int getn() { return n;
122
} // coordenadas del nudo public void setcoor(double[] c) { coor = c; } public double[] getcoor() { return coor; } // agregar carga puntual aplicada en el nudo public void setP(Matrix m) { P.add(m); } public ArrayList getP() { return P; } // restringir grado de libertad del nudo public void setres(boolean[] v) { res.add(v); } public ArrayList getres() { return res; } // desplazamiento del nudo public void setD(Matrix m) { D = m; } public Matrix getD() { return D;
} } /* * subclase para los nudos de la estructura * se puede usar en estructuras 2D o 3D */ package estructural; import java.util.ArrayList; /** * rsaravia 2012 */ public class nudo01 extends nudo00 { // constructor public nudo01(String s1) { id = s1; P = new ArrayList(); res = new ArrayList(); } } /* * interface java para dotar de identificacion * se puede usar para cualquier objeto */ package estructural; /** * rsaravia 2012 */ public interface interface01 { // asignar identificacion
123
public void setid(String s); // getter identificacion public String getid(); } /* * clase para lectura y escritura de archivos * puede usarse para formato csv */ package util01; import java.io.FileNotFoundException; import java.io.IOException; import Jama.Matrix; import com.csvreader.*; import estructural.*; /** * rsaravia 2012 */ public class entsal { final static String ext = ".csv"; private static String dir = ""; // carpeta de trabajo public static void setdir(String d) { dir = d; } public static String getdir() { return dir; }
// extension de archivo por defecto public static String getext() { return ext; } // abrir archivo csv de entrada de la estructura public static estructura01 abrirestructura(String archivo) { String campo[] = { "DESCRIPCION DE LA ESTRUCTURA", "COORDENADAS DE LOS NUDOS", "ELEMENTOS TIPO", "PROPIEDADES DE LOS ELEMENTOS", "CARGAS EN LOS NUDOS", "CARGAS EN LOS ELEMENTOS", "APOYOS", "*" }; String ti[] = {"portico", "parrilla"}; estructura01 estructura = null; try { int i1 = -1, i3 = 0, t = 0; String s1; CsvReader csv = new CsvReader(dir + archivo + ext); while (csv.readRecord()) { s1 = csv.get(0); if (!s1.equals("")) { if (s1.equals(campo[i1 + 1])) { i1++; i3 = 0;
124
} else { switch (i1) { case 0: { estructura = new estructura01(s1); estructura.setarchivo(archivo); break; } case 1: { i3++; String id = "Nudo " + Integer.toString(i3); double[] v = otros01.strarray2double(csv.getValues(), 0); nudo00 nudo = new nudo01(id); nudo.setn(i3); nudo.setcoor(v); estructura.setnudos(nudo); if (i3 == 1) { estructura.setdim1(v.length); } break; } case 2: { for (int i2 = 0; i2 < ti.length; i2++) { if (ti[i2].equals(s1)) { t = i2; estructura.settipo(s1); break; } } break; } case 3: { i3++; String id = "Elemento " + Integer.toString(i3); elemento00 ele = null;
switch (t) { case 0: { ele = new elemento01(id); break; } case 1: { ele = new elemento02(id); break; } } ele.setpro(otros01.strarray2double(csv.getValues(), 2)); estructura.setelementos(ele, Integer.valueOf(s1), Integer.valueOf(csv.get(1))); break; } case 4: { int i = Integer.valueOf(s1); double[] v = otros01.strarray2double(csv.getValues(), 1); estructura.inscarganu(i, otros01.doublearray2matrix(v, 0)); break; } case 5: { int i = Integer.valueOf(s1); cargaele00 cargaele = null; switch (Integer.valueOf(csv.get(1))) { case 1: { cargaele = new cargaele01(); break; } case 2: { cargaele = new cargaele02(); break; }
125
} cargaele.seta(Double.valueOf(csv.get(2))); cargaele.setb(Double.valueOf(csv.get(3))); double[] v = otros01.strarray2double(csv.getValues(), 4); cargaele.setF(otros01.doublearray2matrix(v, 0)); estructura.inscargaele(i, cargaele); break; } case 6: { double[] v = otros01.strarray2double(csv.getValues(), 1); boolean[] b = new boolean[v.length]; for (int i4 = 0; i4 < v.length; i4++) { b[i4] = (v[i4] == 1); } estructura.insres(Integer.valueOf(s1), b); } } } } } csv.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } estructura.setarchivo("_" + archivo); return estructura; } // guardar matrices de la estructura en formato csv
public static void guardarmatsis(String archivo, Matrix m, boolean[] x) { try { CsvWriter csv = new CsvWriter(dir + archivo + ext); CsvWriter csv2 = new CsvWriter(dir + archivo + "r" + ext); int r = m.getRowDimension(); int c = m.getColumnDimension(); for (int i = 0; i < r; i++) { boolean b = false; for (int j = 0; j < c; j++) { String s = Double.toString(m.get(i, j)); csv.write(s); if (((!x[i]) && ((c == 1) || (!x[j])))) { csv2.write(s); b = true; } } if (b) { csv2.endRecord(); } csv.endRecord(); } csv2.close(); csv.close(); } catch (IOException e) { e.printStackTrace(); } } // abrir archivos csv de matrices de la estructura
126
public static Matrix abrirmatsis(String archivo, int r, int c) { Matrix a = new Matrix(r, c); try { CsvReader csv = new CsvReader(dir + archivo + ext); for (int m = 0; m < r; m++) { csv.readRecord(); for (int n = 0; n < c; n++) { a.set(m, n, Double.valueOf(csv.get(n))); } } csv.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } return a; } // guarda matrices en general en formato csv public static void guardarmat(String archivo, Matrix m) { try { CsvWriter csv = new CsvWriter(dir + archivo + ext); int r = m.getRowDimension(); int c = m.getColumnDimension(); for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) { String s = Double.toString(m.get(i, j)); csv.write(s); } csv.endRecord(); } csv.close(); } catch (IOException e) { e.printStackTrace(); } } } /* * clase para graficar la geometria y la deformada de la estructura * */ package util01; import java.awt.*; // For Graphics, etc. import java.awt.geom.*; // For Ellipse2D, etc. import java.util.ArrayList; import estructural.*; // rsaravia 2012 public class graficar01 extends javax.swing.JFrame { final double fd = 0.2; private ArrayList ele01, nu01; private boolean f; private double ancho, largo, an2, lar2; private double fdx = 0, fdy = 0, ax = 0, ay = 0;
127
// constructor public graficar01(ArrayList ele, ArrayList nu, boolean b, double v1, double v2) { ele01 = ele; nu01 = nu; f = b; an2 = v1; lar2 = v2; calcancholargo(); initComponents(); } // implementacion del metodo de graficado del formulario @Override public void paint(Graphics g) { super.paint(g); Graphics2D g2d = (Graphics2D) g; double mx = g2d.getClipBounds().getMinX() + 5; double my = g2d.getClipBounds().getMinY(); double w = g2d.getClipBounds().getWidth(); double h = g2d.getClipBounds().getHeight(); double fx = 1.1 * ancho / w; double fy = 1.1 * largo / h; g2d.setBackground(Color.white); g2d.setColor(Color.black); g2d.setStroke(new BasicStroke(3)); for (int i1 = 0; i1 < ele01.size(); i1++) { double xi = ((elemento00) ele01.get(i1)).getni().getcoor()[0]; double yi = ((elemento00) ele01.get(i1)).getni().getcoor()[1]; double xj = ((elemento00) ele01.get(i1)).getnj().getcoor()[0]; double yj = ((elemento00) ele01.get(i1)).getnj().getcoor()[1]; if (f) {
xi += ((elemento00) ele01.get(i1)).getni().getD().get(0, 0) / fdx; yi += ((elemento00) ele01.get(i1)).getni().getD().get(1, 0) / fdy; xj += ((elemento00) ele01.get(i1)).getnj().getD().get(0, 0) / fdx; yj += ((elemento00) ele01.get(i1)).getnj().getD().get(1, 0) / fdy; } xi = (mx + (xi + ax) / fx); yi = (my + h - (yi + ay) / fy); xj = (mx + (xj + ax) / fx); yj = (my + h - (yj + ay) / fy); Line2D.Double li = new Line2D.Double(xi, yi, xj, yj); g2d.draw(li); } } // ancho de la gráfica public double getancho() { return ancho; } // largo de la gráfica public double getlargo() { return largo; } // calcular el ancho y largo a partir de la geometria de la estructura private void calcancholargo() { double x0 = 0, y0 = 0, x1 = 0, y1 = 0, dx1 = 0, dy1 = 0; if (f) { dx1 = Math.abs(((nudo00) nu01.get(0)).getD().get(0, 0)); dy1 = Math.abs(((nudo00) nu01.get(0)).getD().get(1, 0));
128
for (int i1 = 0; i1 < nu01.size(); i1++) { double dx = Math.abs(((nudo00) nu01.get(i1)).getD().get(0, 0)); double dy = Math.abs(((nudo00) nu01.get(i1)).getD().get(1, 0)); if (dx > dx1) { dx1 = dx; } if (dy > dy1) { dy1 = dy; } } fdx = dx1 / (fd * an2); fdy = dy1 / (fd * lar2); } x0 = ((nudo00) nu01.get(0)).getcoor()[0]; y0 = ((nudo00) nu01.get(0)).getcoor()[1]; if (f) { x0 += ((nudo00) nu01.get(0)).getD().get(0, 0) / fdx; y0 += ((nudo00) nu01.get(0)).getD().get(1, 0) / fdy; } x1 = x0; y1 = y0; for (int i1 = 0; i1 < nu01.size(); i1++) { double xi = ((nudo00) nu01.get(i1)).getcoor()[0]; double yi = ((nudo00) nu01.get(i1)).getcoor()[1]; if (f) { xi += ((nudo00) nu01.get(i1)).getD().get(0, 0) / fdx; yi += ((nudo00) nu01.get(i1)).getD().get(1, 0) / fdy; } if (xi < x0) { x0 = xi; } if (xi > x1) { x1 = xi; }
if (yi < y0) { y0 = yi; } if (yi > y1) { y1 = yi; } } ancho = x1 - x0; largo = y1 - y0; ax = -x0; ay = -y0; } /** This method is called from within the constructor to * initialize the form. * WARNING: Do NOT modify this code. The content of this method is * always regenerated by the Form Editor. */ @SuppressWarnings("unchecked") // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents private void initComponents() { setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane()); getContentPane().setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
129
.addGap(0, 400, Short.MAX_VALUE) ); layout.setVerticalGroup( layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGap(0, 300, Short.MAX_VALUE) ); pack(); }// </editor-fold>//GEN-END:initComponents /** * punto de entrada de la clase */ public static void main(String args[]) { java.awt.EventQueue.invokeLater(new Runnable() { public void run() { new graficar01(null, null, false, 0, 0).setVisible(true); } }); } // Variables declaration - do not modify//GEN-BEGIN:variables // End of variables declaration//GEN-END:variables } /* * clase de utilitarios */ package util01; import Jama.Matrix; /** * rsaravia 2012
*/ public class otros01 { // de cadena a arreglo numerico de doble precision public static double[] strarray2double(String[] s, int i) { int i2 = s.length; for (int i1 = s.length; i1 > i; i1--) { if (s[i1 - 1].equals("")) { i2--; } else { break; } } double[] v = new double[i2 - i]; for (int i1 = i; i1 < i2; i1++) { v[i1 - i] = Double.valueOf(s[i1]); } return v; } // de arreglo doble precision a matriz public static Matrix doublearray2matrix(double[] a, int s) { int d = a.length - s; Matrix m = new Matrix(d, 1); for (int i1 = 0; i1 < d; i1++) { m.set(i1, 0, a[i1 + s]); } return m; } // de la numeracion de la estructura a indice interno del programa public static int getindex(int n, int d) {
130
return (n - 1) * d; } // inserta sumando una submatriz s en una matriz m public static void inssumando(Matrix m, Matrix s, int i, int j) { int p = i + s.getRowDimension() - 1; int q = j + s.getColumnDimension() - 1; m.setMatrix(i, p, j, q, m.getMatrix(i, p, j, q).plusEquals(s)); } } /* * To change this template, choose Tools | Templates * and open the template in the editor. */ /* * elegirest01.java * * Created on 27-09-2012, 09:06:48 PM */ package kar07; import java.io.File; import java.io.IOException; import java.util.logging.Level; import java.util.logging.Logger; /** * * @author admin02 */ public class elegirest01 extends javax.swing.JFrame { /** Creates new form elegirest01 */
public elegirest01() { initComponents(); } /** This method is called from within the constructor to * initialize the form. * WARNING: Do NOT modify this code. The content of this method is * always regenerated by the Form Editor. */ @SuppressWarnings("unchecked") // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents private void initComponents() { jLabel1 = new javax.swing.JLabel(); jLabel2 = new javax.swing.JLabel(); jLabel3 = new javax.swing.JLabel(); jFileChooser1 = new javax.swing.JFileChooser(); jLabel4 = new javax.swing.JLabel(); setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); setResizable(false); jLabel1.setText("Universidad Mayor de San Andrés - Facultad de Ciencias Puras y Naturales - Postgrado en Informática"); jLabel2.setText("\"Modelo OO Independiente de la Plataforma para el Análisis de Estructuras Planas Mediante el MEF\""); jLabel3.setText("Maestrante: Ing. Roger Saravia Aramayo - Tutor: M. Sc. Ing. Christian Daza Mier");
131
jFileChooser1.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { jFileChooser1ActionPerformed(evt); } }); jLabel4.setForeground(new java.awt.Color(0, 0, 204)); jLabel4.setText("Implementación del Modelo - Por favor elija el archivo CSV de la estructura a analizar:"); javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane()); getContentPane().setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(layout.createSequentialGroup() .addContainerGap() .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.CENTER) .addComponent(jLabel1) .addComponent(jLabel2) .addComponent(jLabel3) .addComponent(jLabel4) .addComponent(jFileChooser1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)) );
layout.setVerticalGroup( layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(layout.createSequentialGroup() .addContainerGap() .addComponent(jLabel1) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addComponent(jLabel2) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addComponent(jLabel3) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED) .addComponent(jLabel4) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addComponent(jFileChooser1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)) ); pack(); }// </editor-fold>//GEN-END:initComponents
132
private void jFileChooser1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jFileChooser1ActionPerformed // TODO add your handling code here: String s1 = evt.getActionCommand(); if (s1.equals("CancelSelection")) { this.dispose(); } else if (s1.equals("ApproveSelection")) { File f1 = jFileChooser1.getSelectedFile(); String s2 = f1.getParent() + File.separator; String s3 = f1.getName(); String s4 = ""; char ch; for (int j = 0; j < s3.length(); j++) { ch = s3.charAt(j); if (!(ch == '.')) { s4 += ch; } else { break; } } this.dispose(); Main.analizar(s2, s4); } }//GEN-LAST:event_jFileChooser1ActionPerformed /** * @param args the command line arguments */ public static void main(String args[]) { java.awt.EventQueue.invokeLater(new Runnable() { public void run() { new elegirest01().setVisible(true); } }); }
// Variables declaration - do not modify//GEN-BEGIN:variables private javax.swing.JFileChooser jFileChooser1; private javax.swing.JLabel jLabel1; private javax.swing.JLabel jLabel2; private javax.swing.JLabel jLabel3; private javax.swing.JLabel jLabel4; // End of variables declaration//GEN-END:variables } /* * clase principal de la aplicaciion * punto de entrada de la ejecución */ package kar07; import java.util.ArrayList; import Jama.Matrix; import estructural.*; import util01.*; /** * rsaravia 2012 */ public class Main { // apertura de la estructura public static void main(String[] args) { elegirest01 est01 = new elegirest01(); est01.setLocation(50, 50); est01.setVisible(true); } // analisis de la estructura public static void analizar(String c1, String c2) {
133
final String s = " "; entsal.setdir(c1); estructura00 estructura = entsal.abrirestructura(c2); System.out.println("archivo: " + estructura.getarchivo()); System.out.println("id: " + estructura.getid()); System.out.println("dim: " + estructura.getdim1()); System.out.println("tipo: " + estructura.gettipo()); System.out.println(); ArrayList nudos = estructura.getnudos(); for (int i1 = 0; i1 < nudos.size(); i1++) { nudo00 nudo = (nudo00) nudos.get(i1); double[] coor = nudo.getcoor(); System.out.print(nudo.getid() + s); for (int i2 = 0; i2 < coor.length; i2++) { System.out.print(coor[i2] + s); } System.out.println(); } System.out.println(); ArrayList elementos = estructura.getelementos(); for (int i1 = 0; i1 < elementos.size(); i1++) { elemento00 ele = (elemento00) elementos.get(i1); double[] p = ele.getpro(); System.out.print(ele.getid() + s); System.out.print(ele.getni().getid() + s + ele.getnj().getid() + s); for (int i2 = 0; i2 < p.length; i2++) { System.out.print(p[i2] + s); } System.out.println(); } System.out.println();
for (int i1 = 0; i1 < nudos.size(); i1++) { nudo00 nudo = (nudo00) nudos.get(i1); ArrayList cargas = nudo.getP(); for (int i2 = 0; i2 < cargas.size(); i2++) { System.out.print(nudo.getid() + s); Matrix P = (Matrix) cargas.get(i2); for (int i3 = 0; i3 < P.getRowDimension(); i3++) { System.out.print(P.get(i3, 0) + s); } System.out.println(); } } System.out.println(); for (int i1 = 0; i1 < elementos.size(); i1++) { elemento00 ele = (elemento00) estructura.getelementos().get(i1); ArrayList cargas = ele.getcargas(); for (int i2 = 0; i2 < cargas.size(); i2++) { cargaele00 carga = (cargaele00) cargas.get(i2); System.out.print(ele.getid() + s); System.out.print(carga.getid() + s); System.out.print(carga.geta() + s); System.out.print(carga.getb() + s); Matrix F = carga.getF(); for (int i3 = 0; i3 < F.getRowDimension(); i3++) { System.out.print(F.get(i3, 0) + s); } System.out.println(); } } System.out.println(); for (int i1 = 0; i1 < nudos.size(); i1++) { nudo00 nudo = (nudo00) nudos.get(i1);
134
ArrayList res = nudo.getres(); for (int i2 = 0; i2 < res.size(); i2++) { System.out.print(nudo.getid() + s); boolean[] b = (boolean[]) res.get(i2); for (int i3 = 0; i3 < b.length; i3++) { System.out.print(b[i3] + s); } System.out.println(); } } System.out.println(); graficar01 grafica01 = new graficar01(elementos, nudos, false, 0, 0); grafica01.setLocation(50, 50); grafica01.setTitle("estructura " + c2 + " (geometrÃa antes del análisis)"); grafica01.setVisible(true); double w = grafica01.getancho(); double h = grafica01.getlargo(); estructura.ensamblarsis(); Matrix K = estructura.getK(); for (int i1 = 0; i1 < K.getRowDimension(); i1++) { for (int i2 = 0; i2 < K.getColumnDimension(); i2++) { System.out.print(K.get(i1, i2) + s); } System.out.println(); } System.out.println(); Matrix P = estructura.getP(); for (int i1 = 0; i1 < P.getRowDimension(); i1++) { System.out.print(P.get(i1, 0) + s); }
System.out.println(); estructura.resolversistema(); estructura.calcfinternas(); estructura.calcreacciones(); graficar01 grafica02 = new graficar01(elementos, nudos, true, w, h); grafica02.setLocation(grafica01.getX() + grafica01.getWidth() + 10, grafica01.getY()); grafica02.setTitle("estructura " + c2 + " (deformada luego del análisis)"); grafica02.setVisible(true); } }
135
ApendiceB–InstalaciondelSoftware
1) Asegúrese que su computadora tiene instalada la máquina virtual de Java. (JVM).
2) Inserte el CD y haga doble clic en el archivo instalar.
3) Elija un folder para instalar la aplicación de análisis estructural y presione el botón
Unzip (desempacar). Luego, cierre la(s) ventana(s) del instalador.
4) Se ha creado un folder denominado estructuras dentro del folder que Ud. eligió
para la instalación.
5) Vaya al folder estructuras y haga doble clic en el acceso directo aplicación para
ejecutar la aplicación de análisis estructural.
6) Se abre un cuadro de diálogo pidiéndole que elija una estructura para resolver.
Vaya al folder estructuras y elija un archivo CSV de cualquier estructura como
por ejemplo edificio12.csv
7) Posteriormente, se resuelve la estructura y luego del análisis aparecen dos
ventanas: la geometría y la deformada de la estructura, respectivamente. Cuando
haya concluido de apreciarlas, cierre cualquiera de las ventanas.
8) Vaya al folder estructuras y abra con MS Excel (u otro) cualquier archivo de
resultados del análisis estructural como por ejemplo _edificio12(K).csv que
contiene la matriz de rigidez K de la estructura.
Nota.- Los archivos de resultados del análisis estructural tienen como prefijo el guion
bajo _.
136
ApendiceC–CasodeEstudiodeAplicacionPracticaalaRealidadLocal
C.1 Edificio“ElAlcázar”
Figura C1. Vista posterior del Edificio “El Alcázar”.
137
La noche del lunes 17 de diciembre de 2012 al promediar las 17.30 un pilar del cuarto nivel de los
parqueos del edificio, situado debajo de una de las dos torres del edificio (Córdoba), colapsó. La
estructura tiene 18 pisos, 2 niveles de oficinas, 4 niveles subterráneos de estacionamientos y un
semisótano. La construcción tiene 16 años y fue construida por la Sociedad de Comercio (SADECO
SA) más conocida como Ormachea.
FICHA TÉCNICA
Nombre: “El Alcázar” (nombre anterior: “Milenio II”)
Dirección: C. Federico Zuazo entre B. Colorados y Tiwanaku (paralela a El Prado)
Torres: 2 – Córdoba (lado norte) y Granada (lado sur)
Antigüedad: 16 años
Planos aprobados: No
Constructora: SADECO (Ormachea)
Representantes: Diego Francisco Ormachea Pacheco, Carlos Ormachea Zalles
Pisos: 18 Dptos.: 172
Pent-house: 2 Parqueos: 168
Bauleras: 155 Depósitos: 16
Sub-sótanos para garajes: 4 Oficinas y locales comerciales: 91
Mezannines: 2 Semisótanos: 1
Número de familias: 174
Representante de copropietarios: Luis Monroy
Elemento colapsado: Pilar 4to nivel parqueo torre Córdoba (Bloque C)
Tipo de falla: Abrupta y total - aplastamiento del hormigón y pandeo del acero de refuerzo
Causas del colapso: diseño, cálculo, construcción, falta de mantenimiento y filtración.
Pilares comprometidos: 6
138
Número de inmuebles aledaños evacuados: mínimo 5
Soluciones propuestas: encamisado y hormigonado
Tiempo de ejecución de soluciones propuestas: de 15 a 90 días
Garantía de la solución: no presenta verificación
ANTECEDENTES
Según la Alcaldía, los documentos de la construcción datan de 1996, cuando se entregó una
autorización provisional para levantar el edificio Milenio II. La autorización edil era para construir un
edificio más chico. Mientras era construido, de “Milenio II” pasó a llamarse “El Alcázar”. Se debieron
edificar 160 dptos. pero se construyeron 172 entre otros cambios. Esto implica una carga adicional de
peso muerto.
El alcalde explico que el hecho de que un edificio termine siendo otro se debe a que este proceso
pasaba por tres etapas: En una primera instancia, la Alcaldía aprobaba los planos a base de leyes
nacionales vigentes desde 1963 y del reglamento de Uso de Suelos y Patrones de Asentamiento
(USPA) de 1993. Ambas normas permitían la aprobación inmediata. Aquí se aprueba la construcción
del “Milenio II”. Luego se hacía una segunda aprobación que permitía la comercialización o venta de
los departamentos. Aquí el edificio pasó a denominarse El Alcázar. Esto permitió a varios
copropietarios obtener títulos de propiedad, pagar impuestos y seguir otros trámites.
Pero además la norma obligaba a la empresa constructora a presentar los planos finales una vez
terminado el edificio. En el 90 se permitían las modificaciones previa presentación de un nuevo
cálculo estructural del edificio que justifique los cambios que hubieran producido. El alcalde
reconoció que éste último paso de la aprobación definitiva nunca se efectuó con “El Alcázar”. Se
presume por dos hipótesis: 1) por los cambios detallados con anterioridad; 2) o que los funcionarios de
hace 16 años no hubieran aceptado las modificaciones.
EL COLAPSO
La noche del lunes el colapso de un pilar del cuarto nivel de parqueos del edificio El Alcázar debajo de
la torre Córdoba obligó a evacuar a las 174 familias que habitaban la infraestructura y a las personas
139
que trabajaban en 91 locales comerciales u oficinas. Adicionalmente se restringió el ingreso de
personas particulares en un área de dos cuadras alrededor del edificio y se solicitó la evacuación de por
lo menos 5 inmuebles contiguos.
Un pilar principal que sostiene el bloque C de El Alcázar de la calle Federico Zuazo de La Paz colapsó
el lunes 17 de diciembre de 2012. El hecho ocurrió al promediar las 17.30. Los habitantes dieron la
voz de alarma a las 16.00 luego de escuchar un estruendo en el edificio que hizo que la gente saliera en
pánico a la calle.
La gigante infraestructura tembló a eso de las 17.30 de ayer y los vecinos del lugar creyeron que se
trató de un movimiento sísmico. La alerta llegó minutos después al identificar problemas en la columna
principal del bloque C.
Figura C2. El pilar colapsado de la torre Córdoba del Edificio El Alcázar.
CAUSAS DEL COLAPSO
El ingeniero especialista en estructuras de la Sociedad de Ingenieros de Bolivia (SIB), Rolando Grandi, explicó que el
colapso de la columna se debió a tres factores: la mala construcción, el mal diseño de la obra y la humedad. Según la SIB,
el colapso de la columna se debe a 3 posibles causas: error de diseño (que tiene que ver con las dimensiones de los
140
pilares), de construcción (mala precisión de ejes, etc.) y de mantenimiento (una fuga de la tubería que bajaba al lado del
pilar colapsado pudo penetrar y oxidar su armadura).
El diagnóstico de la SIB fue demoledor. Hay fallas de construcción, fallas de cálculo y desorden estructural. Un verdadero
caos y una total falta de previsión al colocar bajantes de agua junto a las columnas lo que ocasionó humedad y oxidación
de los refuerzos de acero del hormigón. Estas fallas se suman a la alteración de los planos de construcción detectada por la
Alcaldía que prueban que la constructora edificó adicionalmente sin autorización 12 departamentos, 39 locales y 1
semisótano.
Grandi de la SIB manifestó que la estructura del edificio no es uniforme, simétrica y bien acomodada; es una estructura
deficiente. Una viga grande descansa sobre otra pequeña; no llegan cargas de forma directa a la columna lo que produce
problemas. También cuestionó la desordenación en la instalación del sistema de agua y alcantarillado y observó que por la
columna dañada pasaban las tuberías de agua y alcantarillado que al dañarse remojaron el hormigón armado.
Figura C3. La unión de los 2 elementos viga no fueron construidos sobre el centro de la columna.
EFECTOS DEL COLAPSO: EL TRAUMA SOCIAL
La alcaldía notificó con la orden de evacuación a 5 predios contiguos al edificio “El Alcázar” amenazado de
colapso. “Actualmente cualquier vibración mínima puede generar problemas. Es un área de alto riesgo” dijo un
funcionario municipal. Todos esos predios deberán permanecer evacuados posiblemente durante 3 meses. Además
se instruyó iniciar el empacamiento de aproximadamente 11 mil reliquias del Museo Nacional de Arqueología.
141
“Nadie va a volver a vivir aquí en éste edificio. Sería una irresponsabilidad de nosotros, de la empresa constructora
y de la Alcaldía; ya da miedo vivir aquí” dijo una afectada que no dio su nombre (Diario La Razón 20/dic/2012)
“Todo se ha sentido muy fuerte. Cuando pasó, en la planta baja donde trabajo todo se ha sentido bastante fuerte
todo se ha movido. Temo perder mis pertenencias. Es una pena.” dijo Virginia Parrada, peluquera.
“Nos quedamos sin generar dinero sin trabajar. Soy de la parte comercial en éste edificio y hay deberes con el
Estado que cumplir...” dijo la propietaria de un negocio.
“Con mi nieto he escapado. Luego de que se ha sentido esto y supimos de todo, no hemos podido recoger nuestros
productos de la feria. He tenido que irme rápido con mi nieto en los brazos” dijo Virginia Mamani de la feria
navideña.
“La gente lo va a pensar dos veces antes de comprar un departamento y se están construyendo dos edificios cerca de
éste inmueble” dijo Roberto Jordán de una inmobiliaria.
“Por el momento nadie va a querer comprar un departamento por la zona donde se encuentra el edificio...” dijo el
gerente de una inmobiliaria.
“Nadie nos garantiza que el edificio va a estar estable. El reforzamiento no es una garantía” dijo un copropietario del
edificio.
Con parecidos argumentos 30 copropietarios del edificio El Alcázar demandaron la devolución de su inversión.
Además los inquilinos quedaron a su suerte: “Los contratos de alquiler o anticrético entre los copropietarios del
edificio El Alcázar y terceros es un problema particular entre privados. No intervendrá la Alcaldía” se dijo.
Figura C4. Efectos del colapso: el trauma social.
142
¿HA QUEDADO INCLINADA LA ESTRUCTURA?
Se va a aplicar el modelo OO propuesto en esta investigación para que por medio del programa se
pueda calcular y determinar la deformada de la estructura antes y después del colapso de la columna.
Primero, se ha ingresado las propiedades geométricas e inerciales del sistema estructural
correspondiente a la torre Córdoba del edificio El Alcázar. Luego, se ha realizado el análisis estructural
del edificio intacto. Seguidamente, se ha quitado la columna colapsada del modelo y se ha realizado de
nuevo el análisis estructural.
Como puede apreciarse en la figura C5 (derecha), la deformada exagerada del sistema estructural del
edificio es simétrica y hacia el centro. Esto ocurre cuando el edificio trabaja bajo condiciones
normales de carga.
En la figura C6 (derecha), la deformada exagerada del sistema estructural afectado del edificio
corrobora la inclinación del mismo luego del colapso de la columna del segundo nivel. Nótese que, en
el modelo de elementos finitos, la ausencia de un elemento puede bien representar a la columna
colapsada (figura C6).
La figura C2 muestra la columna colapsada y evidencia el desplazamiento del nudo superior de dicho
elemento; lo cual, confirma el desplazamiento del sistema estructural. Nótese también que, todos los
elementos finitos del sistema estructural afectado sufren algún desplazamiento en mayor o menor
magnitud (figura C6 derecha).
Por consiguiente, luego del colapso de la columna de la torre Córdoba del edificio El Alcázar, la
estructura sí queda inclinada hacia el lado de la columna afectada.
Finalmente, con el propósito de comparar y corroborar los resultados del modelo y el programa de ésta
investigación, se ha elaborado un modelo 3D de elementos finitos en el software SAP2000 V.15 y
según se muestra en las figuras de a continuación los resultados son los mismos (conceptualmente
equivalentes).
143
Pórtico de El Alcázar antes del análisis.
Deformada de El Alcázar luego del análisis:
Figura C5. Geometría antes y después del análisis del sistema estructural intacto (torre Córdoba).
Pórtico de El Alcázar antes del análisis.
Deformada de El Alcázar luego del análisis.
Figura C6. Geometría antes y después del análisis del sistema estructural afectado (torre Córdoba).
144
Figura C7. Deformada del modelo 3D del edificio El Alcázar (torre Córdoba) – Sistema estructural
intacto.
Figura C8. Deformada del modelo 3D del edificio El Alcázar (torre Córdoba) – Sistema estructural
afectado.