modelo orientado a objetos para el análisis de estructuras planas mediante... by roger gustavo saravia aramayo

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

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

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

Índice PARTE 1 – MARCO REFERENCIAL ....................................................................................................................... 6 1.1 INTRODUCCIÓN ....................................................................................................................................... 6 1.1.1 1.1.2 1.1.3 1.1.4

¿QUÉ ES EL ANÁLISIS ESTRUCTURAL Y PARA QUÉ SIRVE? ..................................................................................... 6 ¿QUÉ ES EL MÉTODO DE LOS ELEMENTOS FINITOS Y PARA QUÉ SIRVE? ................................................................... 7 ¿QUÉ ES EL MÉTODO MATRICIAL DE LA RIGIDEZ Y PARA QUÉ SIRVE? .................................................................... 10 ¿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 1.3.2

GENERAL ................................................................................................................................................ 12 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 2.1.2 2.1.3 2.1.4

ANÁLISIS ESTRUCTURAL ............................................................................................................................. 17 MÉTODO DE LOS ELEMENTOS FINITOS (MEF) ................................................................................................ 21 MÉTODO MATRICIAL DE LA RIGIDEZ DE KARDESTUNCER ................................................................................... 24 ANÁLISIS DE MARCOS RÍGIDOS PLANOS ........................................................................................................ 25

2.2 ANÁLISIS Y DISEÑO ORIENTADO A OBJETOS ADOO ................................................................................... 28 2.2.1 2.2.2 2.2.3 2.2.4 2.2.5 2.2.6 2.2.7 2.2.8 2.2.9 2.2.10 2.2.11 2.2.12

¿QUÉ ES UN OBJETO? ............................................................................................................................... 29 ¿QUÉ ES UNA CLASE? ............................................................................................................................... 29 ENCAPSULACIÓN ...................................................................................................................................... 29 INTERFAZ ................................................................................................................................................ 30 HERENCIA ............................................................................................................................................... 30 SUPERCLASES Y SUBCLASES ......................................................................................................................... 31 ABSTRACCIÓN .......................................................................................................................................... 31 POLIMORFISMO ....................................................................................................................................... 31 COMPOSICIÓN ......................................................................................................................................... 32 PERSISTENCIA ..................................................................................................................................... 33 CLASES ABSTRACTAS ............................................................................................................................ 33 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 2.4.2

PROCESO RACIONAL UNIFICADO (RUP) ........................................................................................................ 39 MÉTODOS AGILES .................................................................................................................................... 40

2.5 PROGRAMACIÓN ORIENTADA A OBJETOS ............................................................................................. 42

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

RE QU ER IM IEN TOS ....................................................................................................................... 51

3.2. 1 3.2. 2 3. 3

F U N C I O N A L E S ................................................................................................................................. 51 N O F U N C I O N A L E S .......................................................................................................................... 53

MODELO D E C AS OS D E 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 3.8.2 3.8.3

CERCHA TIPO TORRE ................................................................................................................................. 72 MARCO RÍGIDO PLANO: EDIFICIO DE 8 PLANTAS ............................................................................................ 82 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

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

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

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

Parte 1 – Marco Referencial 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é es el análisis estructural y para qué 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.

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é es el método de los elementos finitos y para qué 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]

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 Figura 4b. Modelo de elementos finitos de un reactor nuclear vessel.

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 Kardestuncer.

sistema de ejes locales

Y se aplicará el método matricial de la rigidez como proceso para

obtener el modelo matemático global de la estructura.

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

Figura 7. Sistemas de ejes locales: (a) tradicional

empotrado.

(b) Kardestuncer.

1.1.3 ¿Qué es el método matricial de la rigidez y para qué 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.)

1.1.4 ¿Qué es un objeto y para qué 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.

ATRIBUTOS

COMPORTAMIENTO

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).

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ón del Problema 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ón del Problema ¿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.

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

Mejora

Claridad del código.

Minimiza

La cantidad de ciclos anidados

codificación de un programa para el análisis estructural de

explícitos de cálculo.

pórticos planos a partir del paradigma orientado a objetos mediante elementos finitos –

Incrementa

La eficiencia de cómputo.

Mejora

Los resultados de las fuerzas internas

elemento viga y sistema de ejes

que sufren los elementos.

locales Kardestuncer Permite

Escalabilidad.

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 Alcances y Limitaciones 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.

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.

Parte 2 – Marco Teó rico 2.1 Estructuras de Ingenierí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.

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álisis Estructural 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.

concreto.

armado.

(e) Vehículo aerodinámico. (f) Aeronave delta.

Figura 10. Estructuras de diversas ramas de la ingeniería.

La era de los maestros: Leonardo Da Vinci (1452-1519), Galileo Galilei (1564-1642), Fontana (15431607) 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.

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.

2.1.2 Método de los Elementos Finitos (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.

El software o programa de elementos finitos ejecuta el análisis a. Formula el sistema de ecuaciones b. Resuelve el sistema de ecuaciones

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.

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.

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

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.

Figura 12b. Presa de tierra

Figura 12a. Placa.

(d) Puente colgante (c) Torre de transmisiรณn

(f) Aeronave comercial

(e) Armadura de un barco

Figura 12. Aplicaciรณn del modelo de elementos finitos en diversas estructuras.

2.1.3 Método Matricial de la Rigidez de Kardestuncer 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

Figura 13b. Fuerzas internas que sufren los elementos.

nudos, 3 elementos viga y carga puntual)

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)

Figura 14a. El sistema de ecuaciones final para

Figura 14b. Una estructura generalizada y su

la solución de la figura 14b. Nótese que es de

deformada en línea segmentada. Nótese que cada

la forma de la ecuación 1.

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álisis de Marcos Rígidos Planos 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.

Figura 15a. Cercha o armadura 2D con cargas en los nudos superiores que bien podría ser el modelo de elementos Figura 15b. Marco rígido plano 2D que representa el modelo de elementos

finitos de un techo de una edificación o galpón.

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.

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.

/ 0 0

0 12 / 6 /

0 6 / 4 /

/ 0 0

0 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.

R 0

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:

Establecer cualquier sistema general de coordenadas XY en el plano de la estructura.

Asignar un número a cada nudo de la estructura (incluyendo los apoyos).

Registrar las coordenadas generales (Xi, Yi) de cada nudo.

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.

Aplicar las condiciones de contorno eliminando las correspondientes filas y columnas de la matriz K de la estructura.

Listar todas las cargas externas aplicadas en los nudos en secuencia (Px, Py, M) para formar el vector fuerza generalizado P.

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.

Calcular las fuerzas internas en los extremos de los elementos en coordenadas locales usando la ecuación p

k R ∆

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.2 Análisis y Diseño Orientado a Objetos ADOO 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.

2.2.1 ¿Qué es un Objeto? 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é es una Clase? 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.

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.

2.2.6 Superclases y Subclases 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,

circunferencias, elipses y polígonos), la operación fundamental del cálculo del área se brinda al polimorfismo. Véase figura 21. Figura ‐area : double +calcArea() : double

Rectangulo ‐largo : double ‐ancho : double +calcArea() : double

Circulo ‐radio : double +calcArea() : double

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.

2.2.10

Persistencia

La persiste ncia 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

Clases Abstractas

Una clase abstracta es una clase que contiene uno o más métodos sin ninguna imp lementación. Por ejemp lo, 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

Interface Java

Una interface Java, a diferencia de una clase abstracta, no contiene absoluta mente ninguna implementac ión. Cualquier clase que implemente una interface Java deberá proveer la imp le mentació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 co mo 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 co nceptual de la figura 23.

Figura 23. El proceso de análisis en la ingeniería del software.

2.3 Lenguaje Unificado de Modelado (Unified Modeling Language UML) 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 Diagramas de UML Se trata de herramientas para modelar las diferentes vistas de un sistema OO. Cada diagrama tiene fines distintos dentro del proceso de desarrollo.

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.

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.

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.

Figura 29. Diagrama de componentes.

Figura 30. Diagrama de distribución.

2.4 Metodologías de Desarrollo 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.

Figura 31. Metodología en cascada.

2.4.1 Proceso Racional Unificado (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).

Figura 32. Metodología RUP

2.4.2 Métodos Agiles 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.

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.

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ón Orientada a Objetos 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

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ón de Lenguajes 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 Estado del Arte 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.

2.6.1 Antecedentes y Trabajos Previos [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.

[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.

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

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.

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.

[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.

Parte 3 ‐ Desarrollo Teó rico Prá ctico 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ón de Trabajo 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). fuerzas internas puede pertenecer a más de un elemento.

Un conjunto de

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.

conjunto de condiciones de borde pueden tener en común varios nudos. Un nudo puede tener solo un conjunto de desplazamientos. tener en común más de un nudo. conjunto de reacciones.

Un conjunto de desplazamientos pueden

Un nudo restringido (apoyo) puede tener solo un

Y un conjunto de reacciones pueden tener en común varios

nudos.

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 literal de la estructura, un listado de las coordenadas globales (X, Y) de sus nudos, un listado de las incidencias de sus elementos, un listado de las cargas puntuales sobre sus nudos, un listado de las cargas puntuales y /o distribuidas sobre sus ele mentos, y un listado de las condiciones de contorno (restricciones o apoyos). La información que se requiere luego del cálculo de una estructura consiste en: la matriz glo bal de rigidez, el vector generalizado de fuerza, el vector generalizado de desplazamiento, las fuerzas internas en los extremos de los elementos según el siste ma de ejes locales Kardestuncer, las reacciones en los apoy os y una gráfica de la deforma da de la estructura. El cálculo de una estructura deberá llevarse a cabo por medio del método de los ele mentos finitos e mp leado en ingeniería estructural confor me el extenso desarrollo de la sección “marco teórico” de éste informe.

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 camp o que permita la introducción de la descripción literal 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 ele mentos 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 distribuidas 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 (apoy os) de la estructura. 8. Al usuario se le deberá proveer una interfaz para la verificac ión gráfica de la geometría de la estructura. 9. Al usuario se le deberá proveer una interfaz para solicitar el análisis de la estructura. 10. Al usuario se le deberá proveer archivos de un formato estándar que permita acceder de manera tabulad a a los resultados nu méricos del análisis 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 rigidez de la estructura.

12. Al usuario se le deberá proveer de un archivo para acceder a los resultados numéricos del vector generalizado de fuerza de la estructura. 13. Al usuario se le deberá proveer de un archivo para acceder a los resultados numéricos del vector generalizado 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 ele mentos 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 apoy os (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 siste ma se le deberá proveer la imp lementación de un modelo que permita el análisis de la estructura mediante el método de los elementos finitos - elemento viga doblemente e mpotrada sistema de ejes locales Kardestuncer según el extenso desarrollo de la sección “ marco teórico” de éste documen to. 18. Al sistema se le deberá proveer una rutina para abrir la informa ción de entrada de la estructura. 19. Al sistema se le deberá proveer una rutina para graficar la geo metría de la estructura. 20. Al siste ma se le deberá proveer una rutina para ensamb lar el vector generalizado de fuerza de la estructura. 21. Al siste ma se le deberá proveer una rutina para ensamblar la ma triz global de rigidez 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 sistema de ecuaciones de la estructura. 24. Al siste ma se le deberá proveer una rutina para calcular las fuerzas internas en los extremos de los elementos de la estructura.

25. Al siste ma se le deberá proveer una rutina para calcular las reacciones de los apoy os de la estructura. 26. Al siste ma se le deberá proveer una rutina para guardar los resultados numéricos del análisis de la estructura. 27. Al siste ma se le deberá proveer una rutina para graficar la defor mada de la estructura.

3.2.2 No Funcionales Los requisitos no funcionales definen cómo debe ser el sistema. 1. La aplicación debe ser desarrollada utilizando Java para permitir que en el futuro usuarios familiarizados 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: te clado y ratón. 4. El sistema debe ser de fácil usabilidad. 5. El sistema deberá proveer un me dio independiente para la instalación del mismo.

3.3 Modelo de Casos de Uso Los actores que se distinguen del análisis de requerimientos son “el usuario” y “el siste ma” confor me se muestran en los casos de uso de las figuras 39 a la 41.

general, es posible detallar con may or profundidad la may oría de los casos uso. En la figura 41 se detalla el caso de uso “introducir condiciones de contorno”. A este concepto se conoce co mo “inclusión de caso de uso”.

Figura 39. Caso de uso – actor “el usuario” Introducir código de nudo

« incluir » « incluir »

Introducir las condiciones de frontera

« incluir » « incluir »

Introducir restricción al desplazamiento horizontal

Introducir restricción al desplazamiento vertical

Usuario Introducir restricción al giro

Figura 40. Inclusión de caso de uso “introducir condiciones de contorno”.

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. Introducir coordenada X « incluir » Introducir las coordenadas de los nudos

« incluir »

Introducir coordenada Y

Usuario

Figura 41a. Inclusión de caso de uso “Introducir las coordenadas de los nudos”.

Introducir código de nudo de partida

« incluir »

Introducir código de nudo de llegada

« incluir » Introducir las propiedades de los elementos

« incluir »

Introducir módulo de elasticidad (E)

« incluir » Usuario « incluir »

Introducir momento de inercia (I)

Introducir área de la sección (A)

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.

Introducir código de nudo

« incluir » « incluir »

Introducir las cargas puntuales en los nudos

Introducir la componente horizontal

« incluir » « incluir »

Introducir la componente vertical

Usuario Introducir el momento flector

Figura 41c. Inclusión de caso de uso “Introducir las cargas puntuales en los nudos”.

Introducir código de elemento

« incluir »

Introducir tipo de carga

« incluir » Introducir las cargas sobre los elementos

« incluir »

Introducir inicio de aplicación

« incluir » « incluir »

Usuario

Introducir longitud de aplicación

Introducir carga puntual

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.

« incluir »

Solicitar el cálculo estructural

« incluir »

Verificar gráficamente la estructura

Autorizar el análisis estructural

Usuario

Figura 41e. Inclusión de caso de uso “solicitar el cálculo estructural”.

« incluir »

Acceder a los resultados numéricos del análisis

Ver los desplazamientos de los nudos de la estructura.

« incluir »

« extender »

« incluir »

Ver las fuerzas internas en los elementos.

Usuario Acceder a los resultados gráficos del análisis

Ver las reacciones en los apoyos.

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 Modelo de Clases 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

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).

Figura 42. Modelo de clases.

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 Vista Dinámica – Diagramas de Comportamiento 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.

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.

Figura 43a. Diagrama de actividades para el proceso “ensamblar el sistema”.

Figura 43b. Diagrama de colaboración para el proceso “ensamblar sistema”.

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.

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”.

Figura 43f. Diagrama de secuencia para el proceso “calcular fuerzas internas”.

Figura 43g. Diagrama de actividades para el proceso “calcular fuerzas internas”.

Figura 43h. Diagrama de secuencia para el proceso “calcular reacciones”.

Figura 43i. Diagrama de actividades para el proceso “calcular reacciones”.

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 estructura durante el proceso global “analizar estructura”. Nótese que refleja tamb ién los cambios que sufren los arreglos de las fuerzas internas en los extre mos de los elementos y las reacciones en los apoy os. 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 siste ma sale del estado).

Figura 43L. Diagrama de estados para el proceso global “analizar estructura”.

3.6 Diagramas de Componentes y de Despliegue 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

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).

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.

Figura 45. Prototipo para la interfaz de usuario.

3.8 Casos De Estudio 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 Cercha Tipo Torre 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).

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.

Elemento

Nudo inicial i

Nudo final j

1E-9

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.

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.

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.

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 Figura 49. Deformada de la estructura luego del análisis.

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.

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 IK (nudos 9-11) o sea elemento no. 18 son:

Extremo j

Extremo i

9 - 11

 28.64   0.00   0.00   

11 - 9

 28.64   0.00   0.00   

0.231 0.029 0.000 -0.222 0.000 0.000 0.000 0.000 0.000 -0.009 -0.029 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.029 0.098 0.000 0.000 0.000 0.000 0.000 0.000 0.000 -0.029 -0.098 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

-0.222 0.000 0.000 0.512 0.000 0.000 -0.222 0.000 0.000 -0.034 -0.042 0.000 0.000 0.000 0.000 -0.034 0.042 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.106 0.000 0.000 0.000 0.000 -0.042 -0.053 0.000 0.000 0.000 0.000 0.042 -0.053 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 -0.222 0.000 0.000 0.231 -0.029 0.000 0.000 0.000 0.000 0.000 0.000 0.000 -0.009 0.029 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 -0.029 0.098 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.029 -0.098 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

-0.009 -0.029 0.000 -0.034 -0.042 0.000 0.000 0.000 0.000 0.190 0.100 0.000 -0.140 0.000 0.000 0.000 0.000 0.000 -0.009 -0.029 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

-0.029 -0.098 0.000 -0.042 -0.053 0.000 0.000 0.000 0.000 0.100 0.249 0.000 0.000 0.000 0.000 0.000 0.000 0.000 -0.029 -0.098 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 -0.140 0.000 0.000 0.361 0.000 0.000 -0.140 0.000 0.000 -0.041 -0.037 0.000 0.000 0.000 0.000 -0.041 0.037 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.068 0.000 0.000 0.000 0.000 -0.037 -0.034 0.000 0.000 0.000 0.000 0.037 -0.034 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 -0.034 0.042 0.000 -0.009 0.029 0.000 0.000 0.000 0.000 -0.140 0.000 0.000 0.190 -0.100 0.000 0.000 0.000 0.000 0.000 0.000 0.000 -0.009 0.029 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.042 -0.053 0.000 0.029 -0.098 0.000 0.000 0.000 0.000 0.000 0.000 0.000 -0.100 0.249 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.029 -0.098 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 -0.009 -0.029 0.000 -0.041 -0.037 0.000 0.000 0.000 0.000 0.160 0.095 0.000 -0.102 0.000 0.000 0.000 0.000 0.000 -0.009 -0.029 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 -0.029 -0.098 0.000 -0.037 -0.034 0.000 0.000 0.000 0.000 0.095 0.230 0.000 0.000 0.000 0.000 0.000 0.000 0.000 -0.029 -0.098 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 -0.102 0.000 0.000 0.289 0.000 0.000 -0.102 0.000 0.000 -0.043 -0.031 0.000 -0.043 0.031 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.044 0.000 0.000 0.000 0.000 -0.031 -0.022 0.000 0.031 -0.022 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 -0.041 0.037 0.000 -0.009 0.029 0.000 0.000 0.000 0.000 -0.102 0.000 0.000 0.160 -0.095 0.000 0.000 0.000 0.000 -0.009 0.029 0.000

MATRIZ GLOBAL DE RIGIDEZ K PARA LA ESTRUCTURA TIPO CERCHA DEL CASO DE ESTUDIO 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.037 -0.034 0.000 0.029 -0.098 0.000 0.000 0.000 0.000 0.000 0.000 0.000 -0.095 0.230 0.000 0.000 0.000 0.000 0.029 -0.098 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 -0.009 -0.029 0.000 -0.043 -0.031 0.000 0.000 0.000 0.000 0.091 0.060 0.000 -0.040 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 -0.029 -0.098 0.000 -0.031 -0.022 0.000 0.000 0.000 0.000 0.060 0.120 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 -0.043 0.031 0.000 -0.009 0.029 0.000 -0.040 0.000 0.000 0.091 -0.060 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.031 -0.022 0.000 0.029 -0.098 0.000 0.000 0.000 0.000 -0.060 0.120 0.000

0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000

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 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:

Apoyo Rx Ry Mz 10.00 ‐60.00 ‐43.20 0.00 11.00 0.00 43.20 0.00 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.

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 equilibrio de las fuerzas internas/externas que concurren al nudo.

2) Realizar la su matoria de las fuerzas externas aplicadas

incluy endo las reacciones. Para verificar el equilibrio la suma debe dar 0 (cero). Por motivos de ilustración procedimental, el nudo elegido para comprobar el equilibrio puede ser el nudo D (nudo 4).

Se puede usar una tabla para recopilar,

ordenar, desco mponer y sumar las fuerzas que concurren al nudo D:

Concurren al nudo D

Valor en el nudo

Horizontal

Vertical

Elemento AD (2)

0.00

Elemento BD (4)

+16.05

+10.00

+12.56

Elemento ED (7)

-26.28

0.00

Elemento DG (8)

-13.10

-3.72

-12.56

+ 20.00

+20.00

0.00

Carga externa Sumatoria

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 progra ma) están produciendo resultados correctos con relación a las fuerzas internas en los extremos de los ele mentos. Ahora bien, la tabla para la verificación del equilibrio de las fuerzas externas y reacciones que actúan en la estructura es la siguiente:

Descripción

Horizontal

Vertical

Carga externa nudo A

+20.00

0.00

Carga externa nudo D

+20.00

0.00

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

Se verifica exitosamente el equilibrio de la s cargas externas y reacciones aplicadas en los nudos de la e structura. Con lo que se ratifica que la imp lementación del modelo OO para el análisis estructural mediante elementos fin itos – elemento viga siste ma de ejes locales Kardestuncer, está produciendo resultados correctos.

3.8.2 Marco Rígido Plano: Edificio de 8 Plantas Con el fin de probar las ventajas del modelo OO propuesto en esta investigación, se va a analizar un pórtico 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 co mo el SAP2000 (Structural Analy sis Program) versión 15 – 2011 de CSi (Comp uters 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

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.

Figura 51. Geometría y numeración de los 36

Figura 52. Vista en perspectiva de la asignación

nudos del pórtico.

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.

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.

Figura 53. Códigos para tipos de cargas.

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 informac ión hay a sido correctamente ingresada, se muestra u na gráfica para la verificación de la geometría de la es tructura.

Las

figuras 54 y 55 co mparan las capturas de pantalla de la verificación geométrica en uno y otro programa.

Figura 54. Verificación geométrica del pórtico

Figura 55. Verificación geométrica del pórtico

según la aplicación desarrollada en ésta

según la aplicación SAP2000.

investigación.

A continuación, la aplicac ión calcula la estructura y va guardando archivos CSV d e resultados nu méricos a medida del progreso del proceso.

Los nombres de los

archivos de salida CSV empiezan con el no mbre del archivo de entrada y llevan un sufijo según el contenido que almacenan.

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.

MATRIZ GLOBAL DE RIGIDEZ K PARA LA ESTRUCTURA PORTICO DE 8 PLANTAS DEL CASO DE ESTUDIO - FILAS 1 A 54 - COLUMNAS 1 A 27

44444.4 0.0 -66666.7 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -44444.4 0.0 -66666.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.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -333.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 -66666.7 0.0 133333.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 66666.7 0.0 66666.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 44444.4 0.0 -66666.7 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -44444.4 0.0 -66666.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.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -333.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 -66666.7 0.0 133333.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 66666.7 0.0 66666.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 44444.4 0.0 -66666.7 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -44444.4 0.0 -66666.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.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -333.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 -66666.7 0.0 133333.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 66666.7 0.0 66666.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 44444.4 0.0 -66666.7 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -44444.4 0.0 -66666.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.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -333.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 -66666.7 0.0 133333.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 66666.7 0.0 66666.7 0.0 0.0 0.0 -44444.4 0.0 66666.7 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 89138.9 0.0 0.0 -250.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -44444.4 0.0 -66666.7 0.0 -333.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 19416.7 37500.0 0.0 -18750.0 37500.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -333.3 0.0 -66666.7 0.0 66666.7 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 37500.0 366666.7 0.0 -37500.0 50000.0 0.0 0.0 0.0 0.0 0.0 0.0 66666.7 0.0 66666.7 0.0 0.0 0.0 -44444.4 0.0 66666.7 0.0 0.0 0.0 0.0 0.0 0.0 -250.0 0.0 0.0 89388.9 0.0 0.0 -250.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.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -18750.0 -37500.0 0.0 38166.7 0.0 0.0 -18750.0 37500.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -66666.7 0.0 66666.7 0.0 0.0 0.0 0.0 0.0 0.0 0.0 37500.0 50000.0 0.0 0.0 466666.7 0.0 -37500.0 50000.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 -44444.4 0.0 66666.7 0.0 0.0 0.0 0.0 0.0 0.0 -250.0 0.0 0.0 89388.9 0.0 0.0 -250.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.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -18750.0 -37500.0 0.0 38166.7 0.0 0.0 -18750.0 37500.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -66666.7 0.0 66666.7 0.0 0.0 0.0 0.0 0.0 0.0 0.0 37500.0 50000.0 0.0 0.0 466666.7 0.0 -37500.0 50000.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 -44444.4 0.0 66666.7 0.0 0.0 0.0 0.0 0.0 0.0 -250.0 0.0 0.0 89138.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.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -18750.0 -37500.0 0.0 19416.7 -37500.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 -66666.7 0.0 66666.7 0.0 0.0 0.0 0.0 0.0 0.0 0.0 37500.0 50000.0 0.0 -37500.0 366666.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 -44444.4 0.0 66666.7 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 89138.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.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 19416.7 37500.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 -66666.7 0.0 66666.7 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 37500.0 366666.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 -44444.4 0.0 66666.7 0.0 0.0 0.0 0.0 0.0 0.0 -250.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.3 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -18750.0 -37500.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 -66666.7 0.0 66666.7 0.0 0.0 0.0 0.0 0.0 0.0 0.0 37500.0 50000.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 -44444.4 0.0 66666.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.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 -66666.7 0.0 66666.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 -44444.4 0.0 66666.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.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 -66666.7 0.0 66666.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 -44444.4 0.0 66666.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.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 -66666.7 0.0 66666.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 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 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 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 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 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 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 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 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 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 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 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 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 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 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

Figura 56. Deformada del pórtico luego del análisis

Figura 57. Deformada del pórtico luego del

mediante la aplicación de ésta investigación.

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.

E. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

Pxi -7.73 -3.58 -1.69 -22.50 -13.37 -6.39 -38.03 -25.89 -12.86 -52.52 -39.48 -20.34 -65.79 -53.71 -28.54 -78.25 -68.82 -37.55 -90.42 -85.27 -47.54 -102.68 -103.28 -58.53 -3473.54 -3055.24 -2631.26 -2202.50 -1769.40 -1332.26 -891.37 -447.08 -3570.65 -3122.37 -2677.99 -2234.14 -1789.85 -1344.61 -898.11 -450.04 -3646.58 -3183.46 -2723.74 -2266.25 -1810.60 -1356.47 -903.60 -451.64 -3709.22 -3238.93 -2767.01 -2297.10 -1830.16 -1366.66 -906.92 -451.24

Pyi -418.30 -266.58 -129.70 -423.99 -268.36 -128.08 -428.75 -272.60 -130.10 -433.11 -277.41 -133.06 -437.14 -282.38 -136.50 -440.89 -287.38 -140.26 -444.30 -292.36 -144.32 -447.08 -297.12 -148.76 -342.09 -249.82 -172.31 -110.35 -62.87 -28.66 -6.91 2.68 -64.49 -60.35 -51.22 -39.08 -26.04 -13.96 -4.54 0.61 -179.98 -178.09 -171.11 -158.08 -138.93 -113.76 -82.49 -44.76 -213.44 -211.75 -205.36 -192.50 -172.16 -143.62 -106.06 -58.53

Mzi 25.37 -148.93 -265.55 -54.15 -277.95 -345.25 -30.85 -319.88 -382.67 15.40 -330.66 -402.03 54.40 -340.91 -418.51 76.68 -364.37 -439.80 83.13 -401.57 -465.61 81.62 -437.61 -485.82 3162.57 2110.93 1415.63 929.54 583.10 340.09 177.43 73.59 2197.89 1705.52 1252.34 872.70 569.10 337.76 173.38 67.26 1995.00 1705.35 1364.95 1024.01 711.52 442.82 227.43 74.56 1878.57 1653.90 1361.07 1041.94 730.20 449.20 217.53 56.43

Pxj -7.73 -3.58 -1.69 -22.50 -13.37 -6.39 -38.03 -25.89 -12.86 -52.52 -39.48 -20.34 -65.79 -53.71 -28.54 -78.25 -68.82 -37.55 -90.42 -85.27 -47.54 -102.68 -103.28 -58.53 -3473.54 -3055.24 -2631.26 -2202.50 -1769.40 -1332.26 -891.37 -447.08 -3570.65 -3122.37 -2677.99 -2234.14 -1789.85 -1344.61 -898.11 -450.04 -3646.58 -3183.46 -2723.74 -2266.25 -1810.60 -1356.47 -903.60 -451.64 -3709.22 -3238.93 -2767.01 -2297.10 -1830.16 -1366.66 -906.92 -451.24

Pyj 181.70 333.42 470.30 176.01 331.64 471.92 171.25 327.40 469.90 166.89 322.59 466.94 162.86 317.62 463.50 159.11 312.62 459.74 155.70 307.64 455.68 152.92 302.88 451.24 -342.09 -249.82 -172.31 -110.35 -62.87 -28.66 -6.91 2.68 -64.49 -60.35 -51.22 -39.08 -26.04 -13.96 -4.54 0.61 -179.98 -178.09 -171.11 -158.08 -138.93 -113.76 -82.49 -44.76 -213.44 -211.75 -205.36 -192.50 -172.16 -143.62 -106.06 -58.53

Element Forces - Frames P V2 Kgf Kgf 1 -7.73 -418.3 1 -7.73 181.7 2 -3.58 -266.58 2 -3.58 333.42 3 -1.69 -129.7 3 -1.69 470.3 4 -22.5 -423.99 4 -22.5 176.01 5 -13.37 -268.36 5 -13.37 331.64 6 -6.39 -128.08 6 -6.39 471.92 7 -38.03 -428.75 7 -38.03 171.25 8 -25.89 -272.6 8 -25.89 327.4 9 -12.86 -130.1 9 -12.86 469.9 10 -52.52 -433.11 10 -52.52 166.89 11 -39.48 -277.41 11 -39.48 322.59 12 -20.34 -133.06 12 -20.34 466.94 13 -65.79 -437.14 13 -65.79 162.86 14 -53.71 -282.38 14 -53.71 317.62 15 -28.54 -136.5 15 -28.54 463.5 16 -78.25 -440.89 16 -78.25 159.11 17 -68.82 -287.38 17 -68.82 312.62 18 -37.55 -140.26 18 -37.55 459.74 19 -90.42 -444.3 19 -90.42 155.7 20 -85.27 -292.36 20 -85.27 307.64 21 -47.54 -144.32 21 -47.54 455.68 22 -102.68 -447.08 22 -102.68 152.92 23 -103.28 -297.12 23 -103.28 302.88 24 -58.53 -148.76 24 -58.53 451.24 25 -3473.54 342.09 25 -3473.54 342.09 26 -3055.24 249.82 26 -3055.24 249.82 27 -2631.26 172.31 27 -2631.26 172.31 28 -2202.5 110.35 28 -2202.5 110.35

Mzj 447.81 15.25 -415.64 550.09 151.40 -342.42 545.86 210.29 -296.94 517.02 240.29 -265.75 494.14 270.42 -235.49 486.86 313.91 -199.18 494.06 371.01 -157.10 506.70 426.10 -119.14 -2136.31 -1361.48 -898.69 -598.50 -394.49 -254.11 -156.71 -81.62 -2004.41 -1524.48 -1098.68 -755.46 -490.99 -295.86 -159.75 -69.08 -1455.05 -1171.10 -851.63 -549.78 -294.73 -101.54 20.04 59.72 -1238.26 -1018.65 -744.99 -464.45 -213.72 -18.35 100.66 119.14

Figura 58. Fuerzas internas por el programa propuesto.

M3 Kgf-m -25.37 447.81 148.93 15.25 265.55 -415.64 54.15 550.09 277.95 151.4 345.25 -342.42 30.85 545.86 319.88 210.29 382.67 -296.94 -15.4 517.02 330.66 240.29 402.03 -265.75 -54.4 494.14 340.91 270.42 418.51 -235.49 -76.68 486.86 364.37 313.91 439.8 -199.18 -83.13 494.06 401.57 371.01 465.61 -157.1 -81.62 506.7 437.61 426.1 485.82 -119.14 3162.57 2136.31 2110.93 1361.48 1415.63 898.69 929.54 598.5

Element Forces - Frames P V2 Kgf Kgf 29 -1769.4 62.87 29 -1769.4 62.87 30 -1332.26 28.66 30 -1332.26 28.66 31 -891.37 6.91 31 -891.37 6.91 32 -447.08 -2.68 32 -447.08 -2.68 33 -3570.65 64.49 33 -3570.65 64.49 34 -3122.37 60.35 34 -3122.37 60.35 35 -2677.99 51.22 35 -2677.99 51.22 36 -2234.14 39.08 36 -2234.14 39.08 37 -1789.85 26.04 37 -1789.85 26.04 38 -1344.61 13.96 38 -1344.61 13.96 39 -898.11 4.54 39 -898.11 4.54 40 -450.04 -0.61 40 -450.04 -0.61 41 -3646.58 179.98 41 -3646.58 179.98 42 -3183.46 178.09 42 -3183.46 178.09 43 -2723.74 171.11 43 -2723.74 171.11 44 -2266.25 158.08 44 -2266.25 158.08 45 -1810.6 138.93 45 -1810.6 138.93 46 -1356.47 113.76 46 -1356.47 113.76 47 -903.6 82.49 47 -903.6 82.49 48 -451.64 44.76 48 -451.64 44.76 49 -3709.22 213.44 49 -3709.22 213.44 50 -3238.93 211.75 50 -3238.93 211.75 51 -2767.01 205.36 51 -2767.01 205.36 52 -2297.1 192.5 52 -2297.1 192.5 53 -1830.16 172.16 53 -1830.16 172.16 54 -1366.66 143.62 54 -1366.66 143.62 55 -906.92 106.06 55 -906.92 106.06 56 -451.24 58.53 56 -451.24 58.53

M3 Kgf-m 583.1 394.49 340.09 254.11 177.43 156.71 73.59 81.62 2197.89 2004.41 1705.52 1524.48 1252.34 1098.68 872.7 755.46 569.1 490.99 337.76 295.86 173.38 159.75 67.26 69.08 1995 1455.05 1705.35 1171.1 1364.95 851.63 1024.01 549.78 711.52 294.73 442.82 101.54 227.43 -20.04 74.56 -59.72 1878.57 1238.26 1653.9 1018.65 1361.07 744.99 1041.94 464.45 730.2 213.72 449.2 18.35 217.53 -100.66 56.43 -119.14

Figura 59. F. internas producidas por el SAP2000.

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:

1790 Kgf

26 Kgf

26 Kgf 569 Kgf*m

569 Kgf*m

26 Kgf

491 Kgf*m

491 Kgf*m 1790 Kgf

Figura Figura 7. Sistemas de ejes locales: (a) tradicional (b) Kardestuncer.

1790 Kgf 60.

Fuerzas Figura

61.

Fuerzas

internas de la columna 37 internas de la columna según el SAP2000.

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

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.

Nudo 1 2 3 4

Rx -342.09 -64.49 -179.98 -213.44

Ry 3473.54 3570.65 3646.58 3709.22

Mz 3162.57 2197.89 1995.00 1878.57 Z

TABLE: Joint Reactions Joint F1 F3 Text Kgf Kgf 1 ‐342.09 3473.54 X 2 ‐64.49 3570.65 3 ‐179.98 3646.58 4 ‐213.44 3709.22

M2 Kgf‐m ‐3162.57 ‐2197.89 ‐1995 Y ‐1878.57

Figura 62. Reacciones en los apoyos

Figura 63. Reacciones en los apoyos calculadas

calculadas por la aplicación propuesta.

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).

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

0.00

Suma

Se ha verificado exitosa mente el equilibrio en el nudo 22 de la estructura lo cual indica que el modelo y su implementación (i. e. el progra ma) están produciendo resultados correctos con relación a las fuerzas internas en los extremos de los ele mentos. 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

Carga externa nudo 5 a 13

Vertical

+800.00

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

0.00

Carga externa elementos 1 a 24

Sumatoria

3.8.3 Otras Consideraciones 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.

Figura 64. Cรณdigo FORTRAN.

Figura 65. Cรณdigo Java.

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).

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.

Plataforma Hardware

Plataforma Software

Máquina:

Dell Optiplex 380 X86-Based PC

Sistema Operativo:

Procesador:

Intel Core 2 Quad @ 2.66 GHZ

Máquina Virtual Java: v. 6

RAM / HDD: 4 GB / 500 GB (SATA)

Lenguaje RPL:

MS Windows 7 Pro

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

Elementos

Ecuaciones

421 ms

527 ms

2069 ms

16 ms

15 ms

53 ms

96%

97%

Tiempo RPL Tiempo Java IEC(*) (*)

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

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

100

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 emp leado para medir la co mp lejidad de un algoritmo será u n enfoque empírico o a posteriori: 1) Se ejecutará el programa con entradas de tamaño y co mposición variadas. 2) Se usará un co mando para obtener una medida exacta del tie mpo de ejecución real. 3) Se trazarán los resultados El estudio a posteriori permite hacer una evaluación experimen tal de los recursos consumidos que no es posible en un estudio a priori. Interesa el co mportamiento de un algoritmo para tallas relativamente grandes: co mplejidades asintóticas. Se ha co mparado los tiempos 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 talla o bien la medida del tamaño del proble ma y ha sido asociada al número de elementos estructurales que componen cada pórtico. El tie mpo de ejecución es T(N).

Los

resultados se muestra n a continuación. La aplicación RPL ha quedado sin me moria para un pórtico de 7 pisos.

Aplicación RPL Aplicación Java Plantas Nudos Elementos (N) T1(N) T2(N) T3(N) T(N) Medio T1(N) T2(N) T3(N) T(N) Medio 1 2 3 4 5 6 7

8 12 16 20 24 28 32

7 14 21 28 35 42 49

913 1905 3070 4416 6037 8024

912 1980 3047 4493 6018 8070

924 1898 3107 4512 6016 8036

916 1928 3075 4474 6024 8043

* T(N) medida en milisegundos

101

30 51 60 75 90 105 126

29 49 62 74 90 102 120

27 47 64 74 92 103 123

29 49 62 74 91 103 123

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:

9000

140 120

7000 T(N) milisegundos

T(N) milisegundos

8000

6000 5000 4000 3000 2000

100 80 60 40 20

1000 0

0 0

20 40 N elementos

Figura 68. Complejidad del algoritmo

Figura 69. Complejidad del algoritmo resultante del

procedimental programado en RPL.

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: 83.9871

Ecuación:

15.8095

Ecuación:

2.1446 Correlación: Orden complejidad:

0.9979 de

Correlación: potencial

Orden complejidad:

102

0.9977 de

lineal

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.

103

Parte 4 – Conclusiones y Recomendaciones 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.

104

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.

105

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.

106

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 McGrawHill. USA.

107

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.

108

Apé ndice A – Listado de Có digo Fuente La figura A.1 muestra la organización mediante paquetes del código fuente escrito en Java para la aplicación desarrollada en ésta investigación con el fin de de mostrar el modelo OO propuesto. El paquete “Jama” que viene de “Java Matrix” contiene una serie de clases que proveen a la aplicación de herra mientas para el álgebra matricial, tal co mo se expuso en la parte 3 de éste informe.

Jama ha sido elaborado por terceros y es

considerado uno de los me jores productos de distribución gratuita para el álgebra de matrices. El paquete “co m.csvreader” consiste en dos clases para la lectura y escritura de archivos que contienen valores separados por comas extensión CSV (co mma separated values).

Dicho paquete ha sido elaborado por terceros y es una de las

mejores propuestas que se distribuy e gratuita mente. El paquete “estructural” contiene todas las clases para el modelo OO desarrollado extensa me nte en éste trabajo. El paquete “kar07” contiene la clase principal de la aplicación (i.e. Main) que sirve co mo punto de entrada para la ejecución.

Y la clase “elegirest01” proporciona el

formulario inicial que permite ele gir la estructura a resolver. El paquete “util01” contiene tres clases utilitarias importantes: “entsal” para la lectura y escritura de los archivos de entrada y salida del análisis de la estructura, respectivamente; “graficar01” para graficar la geometría y la deformada de la estructura; y “otros01” que facilita subrutinas de conversión entre reales, cadenas y arreglos. Los paquetes es tructural, k ar07 y util01 han sido escritos desde cero para ésta investigación. A continuación se desglosa el listado de código fuente para todas las clases de éstos tres paquetes.

109

Figura A.1. Organizaciรณn del cรณdigo fuente de la aplicaciรณn de anรกlisis estructural.

110

b = v;

/* * clase abstracta para carga sobre elemento */ package estructural;

}

import Jama.Matrix;

public double getb() { return b; }

/** * rsaravia 2012 */ public abstract class cargaele00 implements interface01 {

// longitud del elemento public void setL(double v) { L = v; } public double getL() { return L; }

String id; double a, b, L; double[] c = new double[5]; Matrix F; public void setid(String s) { id = s; }

// vector carga en coordenadas generales public void setF(Matrix m) { F = m; }

public String getid() { return id; }

public Matrix getF() { return F; }

// inicio de aplicacion de carga public void seta(double v) { a = v; }

// coeficientes de empotramiento public abstract double[] getC(int s); }

public double geta() { return a; }

/* * subclase para carga puntual sobre elemento */ package estructural;

// longitud de aplicacion de carga public void setb(double v) {

/** * rsaravia 2012

111

double a1;

*/ public class cargaele01 extends cargaele00 {

// constructor public cargaele02() { id = "rectangular"; }

// constructor public cargaele01() { id = "puntual"; }

// implementacion del calculo de coeficientes de empotramiento public double[] getC(int s) {

// implementacion del calculo de coeficientes de empotramiento public double[] getC(int s) { double a1;

if (s > 0) { a1 = a; } else { a1 = L - a - b; }

if (s > 0) { a1 = a; } else { a1 = L - a; }

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));

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; }

private double f(double n) { return Math.pow(a1 + b, n) - Math.pow(a1, n); }

} /* * subclase para carga rectangular distribuida sobre elemento */ package estructural;

} /* * clase abstracta para elementos viga * puede usarse para elementos 2D o 3D */ package estructural;

/** * rsaravia 2012 */ public class cargaele02 extends cargaele00 {

import java.util.ArrayList;

112

// nudo final j public void setnj(nudo00 n) { nj = n; }

import Jama.Matrix; /** * rsaravia 2012 */ public abstract class elemento00 implements interface01 {

public nudo00 getnj() { return nj; }

String id; nudo00 ni, nj; double[] pro, d, cosdir, t; ArrayList cargas; double L; int dim2;

// propiedades geometricas e inerciales public void setpro(double[] v) { pro = v; } public double[] getpro() { return pro; }

// dimension de las matrices del elemento public static int calcdim2(int d) { return 3 * (d - 1); }

// longitud del elemento public double getL() { return L; }

public void setid(String s) { id = s; }

// para cargas q actuan sobre el elemento public void setcargas(cargaele00 carga) { cargas.add(carga); }

public String getid() { return id; } // nudo inicial i public void setni(nudo00 n) { ni = n; }

public ArrayList getcargas() { return cargas; } // inicializa valores basicos de calculo public void ini(int v) { dim2 = v; cargas = new ArrayList();

public nudo00 getni() { return ni; }

113

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; }

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);

// carga puntual debido a fuerzas de empotramiento public Matrix getPie(int s) { return getRij(s).transpose().times(getpije(s)).times(-1); }

public abstract Matrix getkiij(); public abstract Matrix getkij();

// 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))); }

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))); }

// 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))); }

// 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))); }

// diferencia de coordenadas entre extremos private void calcdelta() { double[] c1 = ni.getcoor(); double[] c2 = nj.getcoor(); d = new double[c1.length];

// fuerza de empotramiento

114

public class elemento01 extends elemento00 {

for (int i1 = 0; i1 < d.length; i1++) { d[i1] = c1[i1] - c2[i1]; }

// constructor public elemento01(String s1) { id = s1; }

} // longitud del elemento private void calcL() { for (int i0 = 0; i0 < d.length; i0++) { L += Math.pow(d[i0], 2); } L = Math.sqrt(L); }

// 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; }

// cosenos directores private void calccosdir() { cosdir = new double[d.length]; for (int i0 = 0; i0 < cosdir.length; i0++) { cosdir[i0] = d[i0] / L; } }

// 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; }

// valores base de matriz de rigidez local abstract void calct(); } /* * subclase para elementos 2D biempotrados * solo para marcos rigidos planos */ package estructural;

// 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]);

import Jama.Matrix; /** * rsaravia 2012 */

115

k.set(2, 2, t[3]); return k;

import Jama.Matrix;

} /** * rsaravia 2012 */ public class elemento02 extends elemento00 {

// matriz de rigidez directa local kjji public Matrix getkjji() { return getkiij();

// constructor public elemento02(String s1) { id = s1; }

} // 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; }

// 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; }

// 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; }

// 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; }

} /* * subclase para elementos 2D biempotrados * solo para grillas o parrillas */ package estructural;

// matriz de rigidez cruzada local kij

116

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; }

/* * clase abstracta para sistemas estructurales * puede usarse para estructuras 2D y 3D */ package estructural; import java.util.ArrayList; import Jama.Matrix; import util01.*;

// matriz de rigidez directa local kjji public Matrix getkjji() { return getkiij();

/** * rsaravia 2012 */ public abstract class estructura00 implements interface01 {

}

String id, archivo, tipo; int dim1, dim2, dim3, nr; ArrayList nudos, elementos; Matrix P, K, D;

// 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; }

public void setid(String s) { id = s; } public String getid() { return id; }

// 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; }

// nombre base para los archivos de la estructura public void setarchivo(String s) { archivo = s; } public String getarchivo() { return archivo;

}

117

} public ArrayList getelementos() { return elementos; }

// tipo de estructura public void settipo(String s) { tipo = s; }

// getter matriz de rigidez de la estructura public Matrix getK() { return K; }

public String gettipo() { return tipo; }

// getter vector fuerza de la estructura public Matrix getP() { return P; }

// numero de dimensiones de la estructura public void setdim1(int d) { dim1 = d; }

// agregar cargas puntuales en los nudos public void inscarganu(int i, Matrix P) { nudo00 nu = (nudo00) nudos.get(i - 1); nu.setP(P); }

public int getdim1() { return dim1; } // agregar nudo a la estructura public void setnudos(nudo00 nu) { nudos.add(nu); }

// 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); }

public ArrayList getnudos() { return nudos; }

// 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); }

// 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); }

// dimension de las matrices y vectores de la estructura

118

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);

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);

// resolver el sistema de ecuaciones de la estructura public void resolversistema() {

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);

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--; } } } }

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();

entsal.guardarmatsis(archivo + "(K)", K, f); K = null;

119

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++; }

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;

} P = null; D = null; }

Matrix Kr = entsal.abrirmatsis(archivo + "(K)r", dim4, dim4); Matrix Dr = Kr.solve(Pr); Kr = null; Pr = 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); }

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;

// calcular las reacciones en los apoyos de la estructura public void calcreacciones() {

K = entsal.abrirmatsis(archivo + "(K)", dim3, dim3); P = K.times(D); K = null;

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();

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);

120

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());

/* * 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;

} } entsal.guardarmat(archivo + "(reacciones)", re);

/** * rsaravia 2012 */ public abstract class nudo00 implements interface01 {

} }

String id; int n; double[] coor; ArrayList P, res; Matrix D;

/* * subclase para sistemas estructurales * puede usarse para estructuras 2D y 3D */ package estructural;

public void setid(String s) { id = s; }

import java.util.ArrayList; /** * rsaravia 2012 */ public class estructura01 extends estructura00 {

public String getid() { return id; } // numero de nudo public void setn(int i) { n = i; }

// constructor public estructura01(String s1) { id = s1; nudos = new ArrayList(); elementos = new ArrayList(); }

public int getn() { return n;

}

121

}

} } // coordenadas del nudo public void setcoor(double[] c) { coor = c; }

/* * subclase para los nudos de la estructura * se puede usar en estructuras 2D o 3D */ package estructural;

public double[] getcoor() { return coor; }

import java.util.ArrayList; /** * rsaravia 2012 */ public class nudo01 extends nudo00 {

// agregar carga puntual aplicada en el nudo public void setP(Matrix m) { P.add(m); }

// constructor public nudo01(String s1) { id = s1; P = new ArrayList(); res = new ArrayList(); }

public ArrayList getP() { return P; } // restringir grado de libertad del nudo public void setres(boolean[] v) { res.add(v); }

} /* * interface java para dotar de identificacion * se puede usar para cualquier objeto */ package estructural;

public ArrayList getres() { return res; } // desplazamiento del nudo public void setD(Matrix m) { D = m; }

/** * rsaravia 2012 */ public interface interface01 {

public Matrix getD() { return D;

// asignar identificacion

122

// extension de archivo por defecto public static String getext() { return ext; }

public void setid(String s); // getter identificacion public String getid(); }

// 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", "*" };

/* * 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.*;

String ti[] = {"portico", "parrilla"}; estructura01 estructura = null;

/** * rsaravia 2012 */ public class entsal {

try { int i1 = -1, i3 = 0, t = 0; String s1;

final static String ext = ".csv"; private static String dir = "";

CsvReader csv = new CsvReader(dir + archivo + ext); while (csv.readRecord()) {

// carpeta de trabajo public static void setdir(String d) { dir = d; }

s1 = csv.get(0); if (!s1.equals("")) {

public static String getdir() { return dir; }

if (s1.equals(campo[i1 + 1])) { i1++; i3 = 0;

123

switch (t) { case 0: { ele = new elemento01(id); break; } case 1: { ele = new elemento02(id); break; } }

} 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; }

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; }

case 3: { i3++; String id = "Elemento " + Integer.toString(i3); elemento00 ele = null;

124

public static void guardarmatsis(String archivo, Matrix m, boolean[] x) {

} 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;

try { CsvWriter csv = new CsvWriter(dir + archivo + ext); CsvWriter csv2 = new CsvWriter(dir + archivo + "r" + ext); int r = m.getRowDimension(); int c = m.getColumnDimension();

} 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();

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(); }

} catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } estructura.setarchivo("_" + archivo); return estructura;

csv2.close(); csv.close(); } catch (IOException e) { e.printStackTrace(); }

} } // guardar matrices de la estructura en formato csv

// abrir archivos csv de matrices de la estructura

125

for (int j = 0; j < c; j++) { String s = Double.toString(m.get(i, j)); csv.write(s); } csv.endRecord();

public static Matrix abrirmatsis(String archivo, int r, int c) { Matrix a = new Matrix(r, c); try { } CsvReader csv = new CsvReader(dir + archivo + ext);

csv.close(); 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))); } }

} catch (IOException e) { e.printStackTrace(); } } }

csv.close(); /* * clase para graficar la geometria y la deformada de la estructura * */ package util01;

} catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }

import java.awt.*; // For Graphics, etc. import java.awt.geom.*; // For Ellipse2D, etc. import java.util.ArrayList; import estructural.*;

return a; } // guarda matrices en general en formato csv public static void guardarmat(String archivo, Matrix m) {

// rsaravia 2012 public class graficar01 extends javax.swing.JFrame {

try { CsvWriter csv = new CsvWriter(dir + archivo + ext);

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;

int r = m.getRowDimension(); int c = m.getColumnDimension(); for (int i = 0; i < r; i++) {

126

xi += ((elemento00) ele01.get(i1)).getni().getD().get(0, 0) /

// 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(); }

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);

// implementacion del metodo de graficado del formulario @Override public void paint(Graphics g) { super.paint(g);

Line2D.Double li = new Line2D.Double(xi, yi, xj, yj); g2d.draw(li); } }

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;

// ancho de la grÃ¡fica public double getancho() { return ancho; } // largo de la grÃ¡fica public double getlargo() { return largo; }

g2d.setBackground(Color.white); g2d.setColor(Color.black); g2d.setStroke(new BasicStroke(3));

// 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;

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) {

if (f) { dx1 = Math.abs(((nudo00) nu01.get(0)).getD().get(0, 0)); dy1 = Math.abs(((nudo00) nu01.get(0)).getD().get(1, 0));

127

if (yi < y0) { y0 = yi; } if (yi > y1) { y1 = yi; }

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; }

} 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.LE ADING)

128

*/ public class otros01 {

.addGap(0, 400, Short.MAX_VALUE) ); layout.setVerticalGroup(

// de cadena a arreglo numerico de doble precision public static double[] strarray2double(String[] s, int i) {

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LE ADING) .addGap(0, 300, Short.MAX_VALUE) );

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];

pack(); }// </editor-fold>//GEN-END:initComponents /** * punto de entrada de la clase */ public static void main(String args[]) { java.awt.EventQueue.invokeLater(new Runnable() {

for (int i1 = i; i1 < i2; i1++) { v[i1 - i] = Double.valueOf(s[i1]); } return v;

public void run() { new graficar01(null, null, false, 0, 0).setVisible(true); } });

} // 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);

} // Variables declaration - do not modify//GEN-BEGIN:variables // End of variables declaration//GEN-END:variables }

for (int i1 = 0; i1 < d; i1++) { m.set(i1, 0, a[i1 + s]); }

/* * clase de utilitarios */ package util01;

return m; import Jama.Matrix;

}

/** * rsaravia 2012

// de la numeracion de la estructura a indice interno del programa public static int getindex(int n, int d) {

129

public elegirest01() { initComponents(); }

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)); }

/** 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() {

} /* * To change this template, choose Tools | Templates * and open the template in the editor. */

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();

/* * elegirest01.java * * Created on 27-09-2012, 09:06:48 PM */

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON _CLOSE); setResizable(false);

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 {

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");

/** Creates new form elegirest01 */

130

layout.setVerticalGroup(

jFileChooser1.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { jFileChooser1ActionPerformed(evt); } });

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LE ADING) .addGroup(layout.createSequentialGroup() .addContainerGap() .addComponent(jLabel1)

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:");

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.R ELATED) .addComponent(jLabel2)

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane()); getContentPane().setLayout(layout); layout.setHorizontalGroup(

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.R ELATED) .addComponent(jLabel3) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.U NRELATED) .addComponent(jLabel4)

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LE ADING) .addGroup(layout.createSequentialGroup() .addContainerGap()

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.R ELATED) .addComponent(jFileChooser1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Ali gnment.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)) ); pack(); }// </editor-fold>//GEN-END:initComponents

.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)) );

131

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

// 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Ă&#x192;Âłn */ package kar07; import java.util.ArrayList; import Jama.Matrix; import estructural.*; import util01.*; /** * rsaravia 2012 */ public class Main {

/** * @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); } }); }

// 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) {

132

final String s = " "; 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();

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();

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();

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();

for (int i1 = 0; i1 < nudos.size(); i1++) { nudo00 nudo = (nudo00) nudos.get(i1);

} System.out.println();

133

System.out.println();

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(); }

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);

} 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); }

134

Apé ndice B – Instalació n del Software 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 _.

135

Apé ndice C – Caso de Estudio de Aplicació n Prá ctica a la Realidad Local C.1 Edificio “El Alcázar”

Figura C1. Vista posterior del Edificio “El Alcázar”.

136

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

137

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

138

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

139

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.

140

“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.

141

¿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).

142

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).

143

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.

144