modelo orientado a objetos para el analisis de estructuras planas mediante el metodo de los...

UNIVERSIDAD MAYOR DE SAN ANDRES

Facultad de Ciencias Puras y Naturales

Postgrado en Informática

MODELO ORIENTADO A OBJETOS INDEPENDIENTE DE LA PLATAFORMA PARA EL ANALISIS DE ESTRUCTURAS PLANAS

MEDIANTE EL METODO DE LOS ELEMENTOS FINITOS

Tesis de Postgrado Presentado para Optar el Título de

MAGISTER SCIENTIARUM EN INGENIERIA DEL SOFTWARE

Por:

Ing. Roger Gustavo Saravia Aramayo

Tutor:

M. Sc. Ing. Christian Javier Daza Mier

La Paz – Bolivia

Marzo de 2013

i

Resumen

Ésta investigación se extiende en el área del análisis y diseño orientado a objetos (OO) de las ciencias

de computación con campo de aplicación en la ingeniería estructural; específicamente, en el análisis de

marcos rígidos planos mediante el método de los elementos finitos (MEF). Entre los resultados útiles

del análisis de una estructura, están las fuerzas internas de los elementos que sirven para verificar y

mejorar el diseño de la estructura sea de madera, hormigón armado, y otros. Por razones de

simplificación que se daban antiguamente para ahorrar memoria y tiempo de máquina, el software

comercial de análisis estructural ha venido produciendo los resultados del análisis referidos a un solo

sistema de ejes de coordenadas locales para ambos extremos de los elementos de una estructura

dejando a la interpretación del ingeniero los valores para el otro extremo del elemento lo cual conlleva

a ambigüedades y errores. Esta investigación propone la implementación de un programa de cálculo

estructural que produce resultados de las fuerzas internas para cada extremo de los elementos de una

estructura. Dicha implementación se basa en un nuevo modelo OO para el análisis mediante el MEF –

elemento viga doblemente empotrada sistema de ejes locales Kardestuncer.

Palabras Clave

Abstracción, Agiles, Algoritmo, Análisis, Apoyos, Asd, Cargas, Cascada, Cercha, Clase, Colaboración,

Componentes, Composición, Deformada, Distribución, Ecuaciones, Ejes, Elasticidad, Elemento,

Encapsulación, Estados, Estructuras, Finito, Fuerzas, Getters, Herencia, Implementación, Inercia,

Interfaz, Java, Jerarquía, Kardestuncer, Lenguajes, Marcos, Matricial, Mef, Metodologías, Modelo,

Objeto, Persistencia, Polimorfismo, Pórtico, Programación, Prototipo, Reacciones, Requerimientos,

Rigidez, Rup, Secuencia, Setters, Sistema, Subclase, Superclase, Uml, Viga, Young

ii

Abstract

This research applies object-oriented (OO) analysis and design to structural engineering; specifically,

analysis of rigid plane frames using the finite element method (FEM). Among the useful results of the

structural analysis, we have the internal forces of the elements that are necessary to verify and improve

the design of a given structure. Due to simplification reasons in order to save memory and time

machine, the commercial software of structural analysis has been producing the results of the analysis

using a single local coordinates system for both ends of the elements of a structure allowing to the

engineer's interpretation the values for the other end of the element; which leads to ambiguities and

errors. This article proposes the implementation of a program for structural analysis capable to

produce results of the internal forces for each end of the elements of a structure. This implementation

is based on a new OO model for the structural analysis using FEM - beam element with rigid joints and

Kardestuncer local coordinates system.

Keywords

Abstraction, Agile, Algorithm, Analysis, Asd, Axes, Beam, Cascade, Class, Collaboration,

Components, Composition, Deformed, Development, Distribution, Elasticity, Element, Encapsulation,

Equations, Fem, Finite, Frames, Getters, Hierarchy, Implementation, Inertia, Inheritance, Interface,

Java, Kardestuncer, Languages, Loads, Matrix, Model, Object, Persistence, Polymorphism,

Programming, Prototype, Reactions, Requirements, Rigidity, Rup, Sequence, Setters, States,

Structures, Superclasses, Supports, System, Truss, Uml, Young

1

Índice

PARTE 1 – MARCO REFERENCIAL ....................................................................................................................... 6

1.1 INTRODUCCIÓN ....................................................................................................................................... 6

1.1.1 ¿QUÉ ES EL ANÁLISIS ESTRUCTURAL Y PARA QUÉ SIRVE? ..................................................................................... 6 1.1.2 ¿QUÉ ES EL MÉTODO DE LOS ELEMENTOS FINITOS Y PARA QUÉ SIRVE? ................................................................... 7 1.1.3 ¿QUÉ ES EL MÉTODO MATRICIAL DE LA RIGIDEZ Y PARA QUÉ SIRVE? .................................................................... 10 1.1.4 ¿QUÉ ES UN OBJETO Y PARA QUÉ SIRVE? ....................................................................................................... 11

1.2 DEFINICIÓN DEL PROBLEMA .................................................................................................................. 12

1.2.1 FORMULACIÓN DEL PROBLEMA ................................................................................................................... 12

1.3 OBJETIVOS ............................................................................................................................................. 12

13.1 GENERAL ................................................................................................................................................ 12 1.3.2 ESPECÍFICOS ............................................................................................................................................ 13

1.4 HIPÓTESIS .............................................................................................................................................. 13

1.5 JUSTIFICACIÓN ....................................................................................................................................... 14

1.6 ALCANCES Y LIMITACIONES ................................................................................................................... 14

PARTE 2 – MARCO TEÓRICO ............................................................................................................................ 16

2.1 ESTRUCTURAS DE INGENIERÍA ............................................................................................................... 16

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

2.2 ANÁLISIS Y DISEÑO ORIENTADO A OBJETOS ADOO ................................................................................... 28

2.2.1 ¿QUÉ ES UN OBJETO? ............................................................................................................................... 29 2.2.2 ¿QUÉ ES UNA CLASE? ............................................................................................................................... 29 2.2.3 ENCAPSULACIÓN ...................................................................................................................................... 29 2.2.4 INTERFAZ ................................................................................................................................................ 30 2.2.5 HERENCIA ............................................................................................................................................... 30 2.2.6 SUPERCLASES Y SUBCLASES ......................................................................................................................... 31 2.2.7 ABSTRACCIÓN .......................................................................................................................................... 31 2.2.8 POLIMORFISMO ....................................................................................................................................... 31 2.2.9 COMPOSICIÓN ......................................................................................................................................... 32 2.2.10 PERSISTENCIA ..................................................................................................................................... 33 2.2.11 CLASES ABSTRACTAS ............................................................................................................................ 33 2.2.12 INTERFACE JAVA .................................................................................................................................. 33

2.3 LENGUAJE UNIFICADO DE MODELADO (UNIFIED MODELING LANGUAGE UML) ..................................... 34

2.3.1 DIAGRAMAS DE UML ............................................................................................................................... 34

2.4 METODOLOGÍAS DE DESARROLLO ......................................................................................................... 38

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

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

2

2.5.1 CLASIFICACIÓN DE LENGUAJES ..................................................................................................................... 43

2.6 ESTADO DEL ARTE .................................................................................................................................. 43

2.6.1 ANTECEDENTES Y TRABAJOS PREVIOS ........................................................................................................... 44

PARTE 3 ‐ DESARROLLO TEÓRICO PRÁCTICO ................................................................................................... 49

3.1 DECLARACIÓN DE TRABAJO ................................................................................................................... 49

3.2 REQUERIMIENTOS ....................................................................................................................... 51

3.2.1 FUNC IONALES ................................................................................................................................. 51 3.2.2 NO FUNCIONALES .......................................................................................................................... 53

3.3 MODELO DE CASOS DE USO ...................................................................................................... 53

3.4 MODELO DE CLASES ............................................................................................................................... 58

3.5 VISTA DINÁMICA – DIAGRAMAS DE COMPORTAMIENTO ...................................................................... 61

3.6 DIAGRAMAS DE COMPONENTES Y DE DESPLIEGUE................................................................................ 69

3.7 IMPLEMENTACIÓN – GENERALIDADES ................................................................................................... 70

3.8 CASOS DE ESTUDIO ................................................................................................................................ 72

3.8.1 CERCHA TIPO TORRE ................................................................................................................................. 72 3.8.2 MARCO RÍGIDO PLANO: EDIFICIO DE 8 PLANTAS ............................................................................................ 82 3.8.3 OTRAS CONSIDERACIONES .......................................................................................................................... 95

PARTE 4 – CONCLUSIONES Y RECOMENDACIONES ......................................................................................... 104

REFERENCIAS ................................................................................................................................................. 107

APÉNDICE A – LISTADO DE CÓDIGO FUENTE .................................................................................................. 109

APÉNDICE B – INSTALACIÓN DEL SOFTWARE ................................................................................................. 135

APÉNDICE C – CASO DE ESTUDIO DE APLICACIÓN PRÁCTICA A LA REALIDAD LOCAL ...................................... 136

C.1 EDIFICIO “EL ALCÁZAR” .................................................................................................................... 136

3

Lista de Figuras

FIGURA 1. EJEMPLO DE ESTRUCTURA ............................................................................................................... 6

FIGURA 2. EL FIN ES DISEÑAR UNA ESTRUCTURA .............................................................................................. 7

FIGURA 3. DEFORMADA DEL PÓRTICO DE UN EDIFICIO ..................................................................................... 7

FIGURA 4A. ESTRUCTURA DE CONCRETO PRETENSADO .................................................................................... 8

FIGURA 4B. MODELO DE ELEMENTOS FINITOS .................................................................................................. 8

FIGURA 5. SISTEMA ESTRUCTURAL PLANO ....................................................................................................... 9

FIGURA 6. ELEMENTO FINITO 3D ...................................................................................................................... 9

FIGURA 7. SISTEMAS DE EJES LOCALES .............................................................................................................. 9

FIGURA 8. MODELO COMPLETO DE LA MATRIZ DE RIGIDEZ GLOBAL ............................................................... 10

FIGURA 9. EL CONCEPTO DE ENCAPSULACIÓN ................................................................................................ 11

FIGURA 11. LA SECUENCIA DE UN PROYECTO ESTRUCTURAL. [KARDESTUNCER 1974] .................................... 20

FIGURA 11B. ALGORITMO DEL MEF ................................................................................................................ 22

FIGURA 12. APLICACIÓN DEL MODELO DE ELEMENTOS FINITOS EN DIVERSAS ESTRUCTURAS. ...................... 23

FIGURA 13A. PÓRTICO O MARCO RÍGIDO 2D .................................................................................................. 24

FIGURA 13B. FUERZAS INTERNAS .................................................................................................................... 24

FIGURA 14A. EL SISTEMA DE ECUACIONES FINAL ............................................................................................ 25

FIGURA 14B. UNA ESTRUCTURA GENERALIZADA ............................................................................................ 25

FIGURA 15A. CERCHA O ARMADURA 2D ......................................................................................................... 26

FIGURA 15B. MARCO RÍGIDO PLANO 2D ......................................................................................................... 26

FIGURA 16. ELEMENTO FINITO VIGA ............................................................................................................... 27

FIGURA 17. OBJETO: ESTRUCTURA .................................................................................................................. 29

FIGURA 18. EJEMPLO: CLASE AUTOMÓVIL. ..................................................................................................... 29

FIGURA 19. EJEMPLO DE INTERFAZ E IMPLEMENTACIÓN. .............................................................................. 30

FIGURA 20. EJEMPLO DE HERENCIA ................................................................................................................ 31

FIGURA 21. LA JERARQUÍA FIGURA. ............................................................................................................... 32

FIGURA 23. EL PROCESO DE ANÁLISIS EN LA INGENIERÍA DEL SOFTWARE. ...................................................... 34

FIGURA 24. DIAGRAMA DE CASOS DE USO. .................................................................................................... 35

FIGURA 25. DIAGRAMA DE COLABORACIÓN ................................................................................................... 36

FIGURA 26. DIAGRAMA DE SECUENCIA ........................................................................................................... 36

FIGURA 27. DIAGRAMA DE ESTADOS .............................................................................................................. 37

FIGURA 29. DIAGRAMA DE COMPONENTES. ................................................................................................... 38

FIGURA 30. DIAGRAMA DE DISTRIBUCIÓN. ..................................................................................................... 38

FIGURA 31. METODOLOGÍA EN CASCADA. ...................................................................................................... 39

4

FIGURA 32. METODOLOGÍA RUP ..................................................................................................................... 40

FIGURA 34. MODELO ORIENTADO A OBJETOS PROPUESTO POR ARCHER. ...................................................... 44

FIGURA 35. MODELO OO SEGÚN FOLEY .......................................................................................................... 46

FIGURA 36A. MODELO DE ELEMENTOS FINITOS .............................................................................................. 47

FIGURA 36B. RENDERIZACIÓN DEL MODELO DE ELEMENTOS FINITOS ............................................................ 47

FIGURA 37. SECCIÓN CAJÓN DE UN PUENTE ................................................................................................... 48

FIGURA 38. UNA ESTRUCTURA 2D .................................................................................................................. 50

FIGURA 39. CASO DE USO – ACTOR “EL USUARIO” .......................................................................................... 54

FIGURA 40. INCLUSIÓN DE CASO DE USO “INTRODUCIR CONDICIONES DE CONTORNO”. ............................... 54

FIGURA 41. CASO DE USO – ACTOR “EL SISTEMA”. ......................................................................................... 55

FIGURA 41A. INCLUSIÓN DE CASO DE USO “INTRODUCIR LAS COORDENADAS DE LOS NUDOS”. .................... 55

FIGURA 41B. INCLUSIÓN DE CASO DE USO “INTRODUCIR LAS PROPIEDADES DE LOS ELEMENTOS” ................ 56

FIGURA 41D. INCLUSIÓN DE CASO DE USO “INTRODUCIR LAS CARGAS SOBRE LOS ELEMENTOS”. .................. 57

FIGURA 41F. INCLUSIÓN Y EXTENSIÓN DEL CASO DE USO “ACCEDER A LOS RESULTADOS NUMÉRICOS DEL ANÁLISIS”. ...................................................................................................................................................... 58

FIGURA 42. MODELO DE CLASES. .................................................................................................................... 60

FIGURA 43. DIAGRAMA DE SECUENCIA PARA PROCESO “ENSAMBLAR EL SISTEMA DE ECUACIONES”. ........... 62

FIGURA 43A. DIAGRAMA DE ACTIVIDADES PARA EL PROCESO “ENSAMBLAR EL SISTEMA .............................. 63

FIGURA 43B. DIAGRAMA DE COLABORACIÓN PARA EL PROCESO “ENSAMBLAR SISTEMA” ............................ 63

FIGURA 43C. DIAGRAMA DE SECUENCIA PARA EL PROCESO “RESOLVER SISTEMA DE ECUACIONES” DE LA ESTRUCTURA. ................................................................................................................................................. 64

FIGURA 43D. DIAGRAMA DE ACTIVIDADES DEL PROCESO “RESOLVER SISTEMA DE ECUACIONES DE LA ESTRUCTURA”. ................. 65

FIGURA 43E. DIAGRAMA DE COLABORACIÓN DEL PROCESO “RESOLVER SISTEMA DE ECUACIONES DE LA ESTRUCTURA”. ................................................................................................................................................ 65

FIGURA 43F. DIAGRAMA DE SECUENCIA PARA EL PROCESO “CALCULAR FUERZAS INTERNAS”. ...................... 66

FIGURA 43G. DIAGRAMA DE ACTIVIDADES PARA EL PROCESO “CALCULAR FUERZAS INTERNAS”. .................. 66

FIGURA 43H. DIAGRAMA DE SECUENCIA PARA EL PROCESO “CALCULAR REACCIONES”. ............................... 67

FIGURA 43I. DIAGRAMA DE ACTIVIDADES PARA EL PROCESO “CALCULAR REACCIONES”. ............................. 67

FIGURA 43J. DIAGRAMA DE COLABORACIÓN PARA EL PROCESO “CALCULAR FUERZAS INTERNAS”. ............... 68

FIGURA 43K. DIAGRAMA DE COLABORACIÓN PARA EL PROCESO “CALCULAR REACCIONES”. ......................... 68

FIGURA 43L. DIAGRAMA DE ESTADOS PARA EL PROCESO GLOBAL “ANALIZAR ESTRUCTURA”. ...................... 69

FIGURA 43M. DIAGRAMA DE COMPONENTES. ............................................................................................... 70

FIGURA 43N. DIAGRAMA DE DESPLIEGUE. ...................................................................................................... 70

FIGURA 44. IMPLEMENTACIÓN EN JAVA DE LA CLASE ABSTRACTA “CARGAELE00”. ........................................ 71

FIGURA 45. PROTOTIPO PARA LA INTERFAZ DE USUARIO. .............................................................................. 72

FIGURA 46 – CASO DE ESTUDIO ...................................................................................................................... 73

FIGURA 47. ENTRADA DE LA ESTRUCTURA. ..................................................................................................... 76

5

FIGURA 48. GEOMETRÍA DE LA ESTRUCTURA .................................................................................................. 77

FIGURA 49. DEFORMADA DE LA ESTRUCTURA ................................................................................................ 77

FIGURA 50. FUERZAS INTERNAS ..................................................................................................................... 80

FIGURA 51. GEOMETRÍA Y NUMERACIÓN DE LOS 36 NUDOS DEL PÓRTICO. ................................................... 84

FIGURA 52. VISTA EN PERSPECTIVA DE LA ASIGNACIÓN DE CARGAS PUNTUALES Y DISTRIBUIDAS DEL PÓRTICO. ........................................................................................................................................................ 84

FIGURA 53. CÓDIGOS PARA TIPOS DE CARGAS. .............................................................................................. 85

FIGURA 54. VERIFICACIÓN GEOMÉTRICA DEL PÓRTICO SEGÚN LA APLICACIÓN DESARROLLADA EN ÉSTA INVESTIGACIÓN. ............................................................................................................................................. 87

FIGURA 55. VERIFICACIÓN GEOMÉTRICA DEL PÓRTICO SEGÚN LA APLICACIÓN SAP2000. .............................. 87

FIGURA 56. DEFORMADA DEL PÓRTICO LUEGO DEL ANÁLISIS MEDIANTE LA APLICACIÓN DE ÉSTA INVESTIGACIÓN. ............................................................................................................................................. 90

FIGURA 57. DEFORMADA DEL PÓRTICO LUEGO DEL ANÁLISIS MEDIANTE LA APLICACIÓN SAP2000. .............. 90

FIGURA 58. FUERZAS INTERNAS POR EL PROGRAMA PROPUESTO. ................................................................. 91

FIGURA 59. F. INTERNAS PRODUCIDAS POR EL SAP2000. ................................................................................ 91

FIGURA 60. FUERZAS INTERNAS DE LA COLUMNA 37 SEGÚN EL SAP2000. ...................................................... 92

FIGURA 61. FUERZAS INTERNAS DE LA COLUMNA 37 SEGÚN EL MODELO PROPUESTO. ................................. 92

FIGURA 62. REACCIONES EN LOS APOYOS CALCULADAS POR LA APLICACIÓN PROPUESTA. ............................ 93

FIGURA 63. REACCIONES EN LOS APOYOS CALCULADAS POR EL PROGRAMA SAP2000. ................................. 93

FIGURA 64. CÓDIGO FORTRAN. ....................................................................................................................... 96

FIGURA 65. CÓDIGO JAVA. .............................................................................................................................. 96

FIGURA 66. CÓDIGO JAVASCRIPT .................................................................................................................... 97

FIGURA 67. CÓDIGO JAVA. .............................................................................................................................. 97

FIGURA 66A. CÓDIGO JSCRIPT. ....................................................................................................................... 98

FIGURA 67A. CÓDIGO JAVA. ........................................................................................................................... 98

FIGURA 68. COMPLEJIDAD DEL ALGORITMO PROCEDIMENTAL PROGRAMADO EN RPL. ................................ 102

FIGURA 69. COMPLEJIDAD DEL ALGORITMO RESULTANTE DEL MODELO OO DE LA APLICACIÓN EN JAVA. .... 102

FIGURA 70. PÓRTICOS DE VARIOS PISOS EMPLEADOS PARA EL CÁLCULO DEL ORDEN DE COMPLEJIDAD. ..... 103

FIGURA C1. VISTA POSTERIOR DEL EDIFICIO “EL ALCÁZAR”. ........................................................................... 136

FIGURA C2. EL PILAR COLAPSADO DE LA TORRE CÓRDOBA DEL EDIFICIO EL ALCÁZAR. .................................. 139

FIGURA C3. LA UNIÓN DE LOS 2 ELEMENTOS VIGA NO FUERON CONSTRUIDOS SOBRE EL CENTRO DE LA COLUMNA. ..................................................................................................................................................... 140

FIGURA C4. EFECTOS DEL COLAPSO: EL TRAUMA SOCIAL. .............................................................................. 141

FIGURA C5. GEOMETRÍA ANTES Y DESPUÉS DEL ANÁLISIS DEL SISTEMA ESTRUCTURAL INTACTO (TORRE CÓRDOBA). .................................................................................................................................................... 143

FIGURA C6. GEOMETRÍA ANTES Y DESPUÉS DEL ANÁLISIS DEL SISTEMA ESTRUCTURAL AFECTADO (TORRE CÓRDOBA). .................................................................................................................................................... 143

6

Parte1–MarcoReferencial

1.1 Introducción

Las estructuras materializadas en obras civiles, herramientas mecánicas, medios de transporte

terrestres, aeroespaciales, navales, etc. juegan un rol de servicio a diario muy importante para la

humanidad. Las estructuras se presentan en todo el Mundo a diversas escalas y complejidades de

diseño como ser: cimentaciones, edificaciones, puentes, muros, carreteras, torres de transmisión,

presas, canales, vehículos, aviones, barcos, máquinas, reactores nucleares, etc.

Figura 1. Ejemplo de estructura de transporte

El fuselaje del avión Boeing 747 es un ejemplo de

estructura de transporte aéreo que fue analizado y

diseñado mediante el método de los elementos finitos.

Su cálculo involucró un sistema de ecuaciones de más

de 7000 incógnitas. [Gallagher 1975]

1.1.1 ¿Quéeselanálisisestructuralyparaquésirve?

El análisis estructural es una rama de las ciencias físicas que trata sobre el comportamiento de las

estructuras bajo ciertas condiciones de diseño. Las estructuras son sistemas que soportan carga y el

comportamiento se entiende como su tendencia a deformarse, vibrar, pandearse o fluir dependiendo a

las condiciones a las cuales estén sometidas. Los resultados del análisis se usan para determinar la

deformación de la estructura y verificar si son adecuadas para las cargas para las cuales se las ha

diseñado. El resultado es único y depende solamente de las condiciones iniciales. Véase figuras 2 y 3.

7

Figura 2. El fin es

diseñar una estructura y

el análisis estructural es

una de las herramientas

para alcanzar tal fin.

[Kardestuncer 1974]

Figura 3. Deformada del pórtico de un edificio sometido a cargas laterales.

1.1.2 ¿Quéeselmétododeloselementosfinitosyparaquésirve?

El método de los elementos finitos (MEF) es la manera más extendida para simular sistemas de

ingeniería en computadoras. El MEF ha sido usado para predecir el comportamiento de sistemas

estructurales, mecánicos, térmicos, de flujo de fluidos, eléctricos y químicos. El MEF ha sido aplicado

tanto a sistemas lineales o no lineales sean o no tiempo dependientes. El MEF se aplica a sistemas

formados por cualquier material y geometría. En el Mundo se emplea anualmente más de un billón de

dólares en gastos concernientes al uso del MEF. El MEF ha sido desarrollado por Jon Turner,

ingeniero líder de la compañía BOEING, entre 1956 y 1962 con el fin de lograr un mejor cálculo para

la rigidez de las alas de un avión destinado a vuelo supersónico. [Baran 1987]

8

La tecnología MEF consiste básicamente en: una librería de elementos modelo básicos,

un proceso para combinar todos estos modelos en un modelo matemático global del

sistema de ingeniería en cuestión y un algoritmo para la resolución numérica de las

ecuaciones del sistema. Por ejemplo, los requisitos de seguridad en una estructura tipo

reactor nuclear solo pueden lograr un alto grado de confiabilidad mediante un diseño

por el MEF. Véase las figuras 4a y 4b.

Figura 4a. Estructura de concreto pretensado de un

reactor nuclear vessel.

Figura 4b. Modelo de elementos finitos de un

octante de la estructura. Elemento básico:

tetraedro.

Esta investigación está orientada a sistemas estructurales planos; es decir, a pórticos o

marcos rígidos que soportan cargas en el mismo plano de los elementos (figura 5). Se

usará el elemento finito viga doblemente empotrada con sistema de ejes locales

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

obtener el modelo matemático global de la estructura.

9

Figura 5. Sistema estructural

plano: un pórtico o marco rígido

de 20 nudos, 28 elementos viga y

4 apoyos fijos.

En la figura 6 se tiene un elemento finito viga doblemente empotrado 3D. Se usará un elemento finito viga 2D en el plano xy.

Conforme se puede corroborar en el estado del arte a la fecha, todos los trabajos así como los programas realizados, por

cuestiones de simplificación, han empleado ampliamente un mismo sistema de ejes locales en ambos extremos del elemento

(figura 7a). Entonces, cuando se llega a los resultados del análisis, hay que hacer una serie de interpretaciones para llegar a las

fuerzas internas reales porque el uso de un mismo sistema de ejes en ambos extremos genera ciertas ambigüedades como ser:

¿en qué extremo el eje local x indica la dirección de la tensión? algunos suponen que va de izquierda a derecha pero queda el

interrogante de cuál es el extremo izquierdo y así. Para evitar cualquier ambigüedad, en esta investigación se propone un

sistema de ejes locales independiente para cada extremo del elemento según la teoría estructural de Kardestuncer (figura 7b).

Figura 6. Elemento finito 3D viga doblemente

empotrado.

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

(b) Kardestuncer.

10

1.1.3 ¿Quéeselmétodomatricialdelarigidezyparaquésirve?

El método matricial de la rigidez es un proceso universalmente aceptado para el análisis estructural en

computadoras que proporciona un algoritmo rápido y preciso para el análisis de estructuras complejas.

El objetivo del método de la rigidez es establecer la relación entre las cargas externas y los

desplazamientos en los nudos de la estructura. El método directo de la rigidez sustituye la actual

estructura continua por un modelo equivalente compuesto por elementos discretos (i.e. finitos) cuyas

propiedades elásticas e inerciales están expresadas matricialmente. Estas matrices conocidas como

matrices de rigidez de los elementos constituyen los bloques constructivos básicos que al ser

combinados en conjunto de acuerdo a una serie de reglas derivadas de la teoría de la elasticidad

conforman la matriz de rigidez global que representa a las propiedades estáticas y dinámicas del

sistema estructural. Los principios fundamentales sobre los cuales se sustenta el método matricial de la

rigidez son: los principios de los desplazamientos y fuerzas virtuales, los teoremas de Castigliano, el

teorema de la mínima energía, el teorema de la mínima energía complementaria y los teoremas del

desplazamiento y carga unitarios(as). [Kardestuncer 1974]

Por ejemplo, el ensamblado de la matriz de rigidez global del marco plano de la figura 8 (izq.) está

compuesto a su vez por las matrices de rigidez de cada elemento de la estructura. Cada componente Kij

de la matriz global K es una matriz 3x3 correspondiente a la viga o elemento que está entre los nudos i

y j. En consecuencia la matriz de rigidez global para esta estructura es de orden 21. Cada sub-matriz

Kii de la diagonal principal representa la rigidez del nudo i o sea la sumatoria de todas las matrices de

rigideces de los elementos que parten del nudo i. La matriz global K siempre es simétrica. Si no

existen elementos entre los nudos i y j entonces Kij es cero

Figura 8. Modelo completo de la matriz de rigidez global (der.) de un determinado marco rígido plano

(izq.)

11

1.1.4 ¿Quéesunobjetoyparaquésirve?

Un objeto se define en dos términos: atributos y comportamiento. Un objeto es una entidad que

contiene ambos: datos y comportamiento. Los objetos son los bloques constructivos básicos de un

programa orientado a objetos (OO). Un software que usa el paradigma OO consiste básicamente en una

colección de objetos. En la programación procedimental tanto el código como los datos están

localizados de manera separada. En un diseño OO, los atributos y el comportamiento están contenidos

en un solo objeto. Por consiguiente, como en la programación procedimental los datos están separados

de los procedimientos, muchas veces los datos están a nivel de contexto global de tal manera que

pueden ser modificados por cualquier subrutina o función implicando que el acceso a los datos pueda

ser incontrolado e impredecible. Entonces, como uno no tiene el control de que subrutinas podrían

haber accedido a los datos, las pruebas y depuración del software son muy difíciles. Los objetos

resuelven todos estos problemas al combinar datos y comportamiento en un paquete completo. La

combinación de datos y comportamiento (métodos) en una misma entidad se denomina encapsulación

(figura 9). Otros conceptos adicionales del paradigma OO son: herencia, polimorfismo, composición,

abstracción, dependencia, etc.

Figura 9. El concepto de encapsulación en un objeto. [Y. Caballero 2007]

Como el análisis y diseño orientado a objetos (OO) permite la creación y utilización de nuevas

estructuras de datos, ha sido exitosamente empleado en todo tipo de aplicaciones. Las tecnologías OO

llevan a reutilizar componentes de software lo que conlleva a un desarrollo de software más rápido y de

mejor calidad. El software OO es más fácil de mantener debido a que su estructura es inherentemente

poco acoplada. Esto lleva a menores efectos colaterales cuando se deben hacer cambios. Los sistemas

OO son más fáciles de adaptar y fácilmente escalables (pueden crearse grandes sistemas ensamblando

subsistemas reutilizables).

ATRIBUTOS

COMPORTAMIENTO

12

En el contexto de esta investigación, dado que los elementos finitos de un pórtico o marco rígido plano

poseen propiedades y comportamiento, y comparten muchas propiedades entre ellos y con la estructura

misma, éstos pueden implementarse ventajosamente en soluciones basadas en modelos OO.

1.2 DefinicióndelProblema

Programar tópicos como el análisis de estructuras mediante el MEF en lenguajes estructurales o basados en procedimientos, implica

una gran extensión de código distribuido en subrutinas y funciones. Puesto que el análisis estructural involucra operaciones

matriciales que incluyen a todas las propiedades del elemento, éstas deben implementarse mediante ciclos explícitos. En ingeniería

del software, se denomina “complejidad ciclomática” al grado de profundidad de las anidaciones. Otras operaciones como las

asignaciones vectoriales también deben programarse dimensión a dimensión generando así ineficiencia. Además, debe reservarse

considerable cantidad de variables para almacenar -por ejemplo- la configuración geométrica, las propiedades de los materiales y las

cargas aplicadas en la estructura; esto, debido a una falta de tipos de datos específicos que permitan un alto nivel de abstracción. Así,

el código resultante es difícil de leer, escribir y depurar; y se aleja en forma del formulismo de la teoría estructural. Además, su

mantenimiento y extensión requieren de un alto grado de conocimiento del programa entero reflejado en el esfuerzo horas-hombre y

siendo un obstáculo para futuros ingenieros e investigadores.

1.2.1 FormulacióndelProblema

¿Existe un modelo conceptual orientado a objetos que pueda abstraer y simplificar la complicada

codificación del cálculo estructural matricial de pórticos planos mediante MEF que a su vez sea capaz

de producir resultados completos según la teoría de ejes locales de Kardestuncer?

1.3 Objetivos

13.1 General

El objetivo de ésta investigación es proveer y probar una nueva arquitectura orientada a

objetos para que el software de análisis estructural de pórticos planos mediante

elementos finitos – elemento viga y sistema de ejes locales Kardestuncer, sea fácil de

entender, implementar, extender y modificar.

13

1.3.2 Específicos

Diseñar el modelo orientado a objetos usando el lenguaje unificado de modelado

UML.

Implementar el modelo orientado a objetos en el lenguaje de programación Java.

Resolver un caso de estudio y compararlos con resultados mediante herramientas

tradicionales.

1.4 Hipótesis

El diseño de un modelo para la codificación de un programa para el análisis estructural

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

finitos – elemento viga y sistema de ejes locales Kardestuncer, involucra una mayor

claridad de código, minimiza la cantidad de ciclos anidados explícitos de cálculo,

incrementa la eficiencia de cómputo y mejora los resultados de las fuerzas internas que

sufren los elementos de una estructura objeto de análisis; además de permitir su

escalabilidad.

Independiente Moderante Dependiente

El diseño de un modelo para la

codificación de un programa

para el análisis estructural de

pórticos planos a partir del

paradigma orientado a objetos

mediante elementos finitos –

elemento viga y sistema de ejes

locales Kardestuncer

Mejora Claridad del código.

Minimiza La cantidad de ciclos anidados

explícitos de cálculo.

Incrementa La eficiencia de cómputo.

Mejora Los resultados de las fuerzas internas

que sufren los elementos.

Permite Escalabilidad.

14

Nota

La claridad del código puede medirse según la cantidad de líneas de programación necesarias para

ensamblar, por ejemplo, una ecuación matricial de la teoría estructural bajo el paradigma OO y

comparándola con la correspondiente al código basado en otros paradigmas (e. g. estructural,

procedimental).

1.5 Justificación

La justificación es teórica porque con un modelo OO se pretende aportar y desarrollar un aspecto

específico de la ingeniería estructural como el modelado del análisis de estructuras por elementos

finitos – elemento viga y ejes locales Kardestuncer para su implementación en lenguajes de

programación OO.

La justificación tiene impacto social porque con ésta investigación se pretende dejar a disposición de

estudiantes avanzados, profesionales e investigadores de ingeniería civil, estructural y mecánica, una

técnica (materializada en una herramienta) para un análisis más eficiente y real de estructuras planas;

las mismas que, tienen alta relevancia en la sociedad por estar involucradas en obras civiles de servicio

a la sociedad. (e.g. edificaciones, puentes, torres, etc.)

La justificación es tecnológica porque con éste modelo se pretende aplicar y aprovechar la

disponibilidad de lenguajes de programación de última generación orientado a objetos robustos y

extensibles como el lenguaje Java que se combina inclusive con la tecnología Web actual.

1.6 AlcancesyLimitaciones

El alcance de ésta investigación es de carácter exploratorio porque se pretende indagar el tema desde

una nueva perspectiva y porque se desea ampliar una área existente.

El modelo orientado a objetos que llegue a diseñarse se limitará al análisis estático lineal de estructuras

en dos dimensiones, elemento viga doblemente empotrada, cargas puntuales en los nudos, cargas

distribuidas sobre los elementos y apoyos fijos.

La implementación de la aplicación resultante del modelo OO será de carácter inicial y estará limitada

a computadoras de escritorio o portátiles con el complemento de la máquina virtual de Java instalado.

15

Soportará solamente entrada y salida de datos mediante archivos separados por comas extensión CSV.

Ofrecerá una gráfica básica tanto de la geometría de la estructura como su deformada resultante. La

aplicación estará destinada a usuarios avanzados, profesionales o investigadores de ingeniería civil,

estructural y mecánica.

16

Parte2–MarcoTeorico

2.1 EstructurasdeIngeniería

Para el ingeniero es muy importante el proyecto de puentes, edificios, torres y otras

estructuras fijas. Tales estructuras están compuestas por elementos unidos entre sí y

sustentados de modo que puedan soportar en equilibrio estático las fuerzas externas

aplicadas. Pero una estructura también debe estar en equilibrio con las fuerzas de la

gravedad que le son aplicadas como consecuencia de su propio peso. Por ejemplo,

sobre una torre de línea de transmisión actúan su propio peso, las cargas de viento y

hielo aplicadas directamente a la torre y las fuerzas aplicadas a ella por los cables que

soporta. Debe entonces calcularse los elementos de la torre de modo que puedan

soportar las cargas en equilibrio estático y transferir así sus efectos a la cimentación.

Además de las ya mencionadas, hay muchas otras estructuras: presas, muelles, losas de

pavimento de aeropuertos y carreteras, tuberías a presión, depósitos reguladores

(estanques), viaductos, etc. Pero no solo hay estructuras de importancia para el

ingeniero civil: la estructura de un avión es importante para el ingeniero aeronáutico,

la de un barco para el ingeniero naval, recipientes de alta presión y otro equipo

industrial para el ingeniero químico, partes de máquinas y soportes de adecuada

resistencia estructural serán tema del ingeniero mecánico y el ingeniero eléctrico estará

ocupado con el equipo eléctrico y sus bastidores.

El análisis de todas estas estructuras está basado en los mismos principios

fundamentales. En ésta investigación, los ejemplos que se usan para mostrar la

aplicación de dichos principios casi siempre tratan de estructuras de ingeniería civil

pero los métodos de análisis descritos pueden usarse para estructuras que tengan

aplicación en otras ramas de la ingeniería (véase figura 10).

Una estructura se proyecta para que cumpla con una misión determinada para lo cual

debe tener la suficiente resistencia y rigidez. Otros aspectos de gran importancia son la

economía y el buen aspecto.

17

El proyecto completo de una estructura comprende 5 etapas:

1) Determinar los requisitos funcionales de la estructura

2) Considerar varias soluciones que satisfagan estos requisitos

3) Proyecto estructural preliminar de las posibles soluciones

4) Elegir la solución más satisfactoria considerando la economía, la funcionalidad y la estética

5) Detallar el proyecto de la solución elegida

2.1.1 AnálisisEstructural

La historia del análisis estructural comienza mucho antes de la era de los egipcios,

romanos y griegos. Las ruinas actuales indican que ciertos principios de la estática del

análisis estructural fueron conocidos por sus constructores. Arquímedes (287-212

A.C.) introdujo el concepto de centro de gravedad y llevo a su más simple expresión

los principios fundamentales de la estática y equilibrio.

(10a) Puente metálico.

(10b) Cimentación: zapata de concreto.

18

(c) Modelo de elementos finitos de una presa de

concreto.

(d) Muro de contención de hormigón

armado.

(e) Vehículo aerodinámico.

(f) Aeronave delta.

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

19

La era de los maestros: Leonardo Da Vinci (1452-1519), Galileo Galilei (1564-1642), Fontana (1543-

1607) y Minar Sinan (1490-1588) de Estambul. Todos ellos tuvieron gran sentido acerca de las

estructuras y sus éxitos se basaron en sus talentos innatos.

La era de los matemáticos: Hooke (1635-1703), Johann Bernoulli (1667-1748), Daniel Bernoulli

(1700-1782), Euler (1707-1783) y Lagrange (1736-1813). Todos ellos establecieron los principios

fundamentales de los conceptos de energía, la relación entre esfuerzos y deformaciones, las ecuaciones

diferenciales de deformaciones y sus soluciones. Su interés fue más bien la teoría matemática de la

elasticidad en pro de la teoría de estructuras.

La era de los ingenieros: Navier (1785-1836), Saint-Venant (1797-1886), Clapeyron (1799-1864), Airy

(1801-1892), Maxwell (1831-1879), Castigliano (1847-1884), Mohr (1835-1918) y Muller-Breslau

(1851-1925). Todos ellos emplearon exitosamente las formulas desarrolladas en la era anterior para

resolver estructuras. Sus descubrimientos y teoremas fueron la base para el desarrollo de la teoría

estructural. Esta era es la edad de oro de la ingeniería estructural.

La era moderna: A comienzos del siglo XX hombres como Maney, Cross, Southwell y Kani,

introdujeron métodos prácticos manuales para analizar estructuras complejas. Ellos introdujeron,

respectivamente, los métodos de la deflexión de la pendiente, distribución de momentos, relajación y

distribución de esfuerzo cortante. Estos métodos llegaron a ser muy empleados en consultoras de

ingeniería debido a su simplicidad para el cálculo manual.

Galileo

Hooke

Castigliano

Cross

La era contemporánea: Hacia la mitad del siglo XX fueron desarrolladas las computadoras y los

ingenieros fueron impulsados a establecer métodos que requieran menos implicaciones logrando

mejores resultados. Fue introducido el método matricial de análisis estructural que se aplica en la

presente investigación.

20

Considerando que la deformada total (figura 3) es la suma de las deformaciones unitarias

y la fluencia se debe al exceso de esfuerzo y además que el esfuerzo y la deformación

están relacionadas entre sí por el módulo de elasticidad E (i. e. módulo de Young), el

análisis de estructuras se reduce en sí al cálculo del estado de deformación y esfuerzo a

través de la estructura. Puesto que los esfuerzos son los valores que limitan las fuerzas

internas, solo queda calcular las fuerzas internas del sistema.

La ingeniería de estructuras trata principalmente sobre tres temas básicos: el análisis

estructural, el análisis de esfuerzos y el diseño estructural. Todos a pesar de estar

interrelacionados, son tan distintos que se estudian independientemente. Su secuencia en

un proyecto estructural se ilustra en la figura 11.

Mientras que el análisis estructural se basa sobre los principios de la estática, el análisis

de esfuerzos se trata en materias como resistencia y la mecánica de materiales y la teoría

de la elasticidad. El diseño de estructuras asegura que en ningún lugar de un elemento se

presenten esfuerzos que exceden sus límites permitidos. Para lograr esto, si es necesario

se modifica el diseño haciendo que el análisis se repita nuevamente; el ciclo de la figura

11 continúa hasta que no se requiera modificación alguna.

Figura 11. La secuencia de un proyecto estructural. [Kardestuncer 1974]

Los resultados del análisis estructural consisten en los desplazamientos de ciertos puntos (nudos), las

fuerzas internas en los extremos de los elementos o ambos. El conocimiento de uno de ellos conduce

al otro sin mayor complicación.

21

2.1.2 MétododelosElementosFinitos(MEF)

[Reddy 1984] La idea de representar un determinado dominio como una colección de elementos

discretos no es nueva. Antiguos matemáticos estimaron el valor de pi (π) mediante el perímetro de un

polígono inscrito en un círculo. Predijeron al menos 40 dígitos de π representando el círculo con un

polígono de gran número finito de lados. A mitades del siglo XX el método de los elementos finitos

emerge del análisis estructural de una aeronave en la cual las alas y el fuselaje fueron modeladas a

partir de elementos tipo paneles (véase figura 10f). La presentación formal del MEF se atribuye a

Argyris y Kelsey (1960), y a Turner, Clough, Martin y Topp (1956). El término “método de los

elementos finitos” se atribuye a Clough en 1960.

En general, el objetivo del MEF es calcular con suficiente grado de precisión los valores de las

incógnitas de las ecuaciones diferenciales que gobiernan ciertos puntos del dominio de un sistema o

estructura continua. Se crea un modelo matemático del sistema físico o estructura dividido en nudos y

elementos finitos. A este modelo se aplican las ecuaciones que gobiernan el sistema. Se resuelve el

sistema de ecuaciones hallando así los resultados para cada nudo. Los pasos que involucra el MEF son:

1 El usuario crea el modelo de elementos finitos

a. Define la geometría, los nudos y elementos.

b. Especifica las propiedades de los materiales, las condiciones de carga y las condiciones de

contorno.

2 El software o programa de elementos finitos ejecuta el análisis

a. Formula el sistema de ecuaciones

b. Resuelve el sistema de ecuaciones

3 El programa de elementos finitos reporta los resultados

a. Calcula valores para los nudos y elementos (desplazamientos, fuerzas internas, reacciones,

etc.)

b. Procesa adicionalmente los resultados (gráficas, etc.)

Es importante recalcar que el modelo de los elementos finitos es una simulación matemática de la

estructura o sistema físico al cual representa.

22

La precisión del modelo de elementos finitos se mejora incrementando el número de nudos; no

obstante, se requiere mayor tiempo de máquina para calcular la solución. Se considera una pérdida de

tiempo crear modelos con una precisión mayor a la de los datos de entrada del análisis.

Figura 11b. Algoritmo del MEF

Antes de realizar un análisis de elementos finitos, es esencial conocer y entender bien el problema

físico. Sin una idea inicial de cómo se comportará una determinada estructura bajo sus condiciones de

carga, es muy difícil elaborar con precisión su modelo de elementos finitos. Si el objetivo es

determinar las fuerzas internas en una estructura, uno debe concentrarse en entender qué partes de la

estructura soportarán los mayores esfuerzos. La regla principal para los modelos de elementos finitos

es arrancar con un modelo inicial simple. Los resultados del análisis de éste modelo inicial indicarán la

necesidad o no de un refinamiento adicional para ganar mayor precisión si se requiere. O bien, éstos

mismos resultados iniciales, podrían indicar que la estructura está sobre-esforzada y lo que requiere es

un re-diseño de la misma en vez de crear un modelo más refinado.

Inicio

Leer nudos, elementos, cargas y condiciones de contorno

Ensamblar la matriz global de rigidez de la estructura

Ensamblar el vector generalizado de carga

Aplicar las condiciones de contorno

Calcular los desplazamientos de los nudos resolviendo el sistema de ecuaciones de la estructura

Calcular las fuerzas internas y reacciones

Fin

23

Figura 12a. Placa.

Figura 12b. Presa de tierra

(c) Torre de transmisión

(d) Puente colgante

(e) Armadura de un barco

(f) Aeronave comercial

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

24

2.1.3 MétodoMatricialdelaRigidezdeKardestuncer

Para calcular estructuras mediante el método de elementos finitos debe aplicarse un proceso de análisis

estructural: el método matricial de la rigidez conocido también como el método de los desplazamientos

o como el método del equilibrio (porque llega a producir una ecuación matricial de equilibrio de la

estructura).

El método de la matriz de rigidez determina primero los desplazamientos en ciertos puntos (nudos) y

luego las fuerzas internas en los elementos (figura 13b). Para calcular los desplazamientos de una

determinada estructura bajo ciertas condiciones de carga, se debe hallar la rigidez de la estructura a

partir de sus elementos. Las rigideces individuales de los elementos se combinan mediante un

procedimiento matricial produciendo finalmente una ecuación matricial que relaciona las cargas

aplicadas con los desplazamientos de los nudos correspondientes (ecuación 1). La principal

suposición del método de la rigidez es que, la estructura pueda ser satisfactoriamente representada por

un ensamblado de elementos discretos (i. e. finitos) interconectados que representan a la estructura

continua.

Figura 13a. Pórtico o marco rígido 2D (4

nudos, 3 elementos viga y carga puntual)

Figura 13b. Fuerzas internas que sufren los elementos.

En la ecuación 1, P es el vector fuerza generalizado que representa a las cargas aplicadas en los nudos

de una estructura. K es la matriz de rigidez de toda la estructura (véase la figura 8). Y Δ (delta) es el

vector generalizado de los desplazamientos de los nudos de la estructura. Véase también la figura 14.

P K∆ (1)

25

Figura 14a. El sistema de ecuaciones final para

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

la forma de la ecuación 1.

Figura 14b. Una estructura generalizada y su

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

derivada parcial representa a la rigidez del nudo

correspondiente.

El método matricial de la rigidez se basa en la aplicación de tres principios básicos:

(1) Ley de Hooke. Las fuerzas internas de los elementos y los desplazamientos en sus extremos

deben guardar una relación elástica lineal.

(2) Compatibilidad. Los desplazamientos en los extremos de los elementos deben ser iguales a los

desplazamientos de los nudos.

(3) Equilibrio. Las cargas externas aplicadas y las fuerzas en los miembros deben estar en

equilibrio.

2.1.4 AnálisisdeMarcosRígidosPlanos

Los marcos rígidos planos o pórticos son estructuras bidimensionales cuyas cargas externas están en el

mismo plano de la estructura (figura 15b). Tienen uniones (nudos) perfectamente rígidos y los ángulos

entre los elementos no cambian. Un nudo puede rotar siempre y cuando roten también los elementos

asociados al nudo. La deformada de un pórtico debido a una condición de carga induce momentos

flectores, fuerzas axiales y cortantes.

26

Figura 15a. Cercha o armadura 2D con cargas en los nudos

superiores que bien podría ser el modelo de elementos

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

Figura 15b. Marco rígido plano 2D que

representa el modelo de elementos

finitos de una edificación.

Nota.- Las cerchas o armaduras son también estructuras planas cuyas cargas comparten el

mismo plano de la estructura (figura 15a). La diferencia con los marcos planos radica en

que los nudos de las cerchas son articulados (pueden rotar) y las cargas externas solo se

aplican en los nudos. Se pueden modelar y calcular cerchas con procedimientos y

software para marcos planos siempre y cuando se use el artificio de manejar un valor del

momento de inercia sumamente pequeño o casi cero (e. g. 0.0000000001).

El objetivo del análisis es establecer la relación entre las cargas externas y los

desplazamientos en los nudos de la estructura. Las cargas externas son normalmente

dadas (o pueden ser expresadas) y referidas al sistema general de coordenadas XY de la

estructura (figura 16). De esta manera el vector fuerza P (véase ecuación 1) no es

problema ya que representa una lista en secuencia (Px, Py, M) de las fuerzas externas

desde el primer hasta el último nudo. El vector desplazamiento sigue la misma secuencia

o sea (Δx, Δy, θ) para cada nudo de la estructura. El principal problema es ensamblar la

matriz de rigidez K de la estructura. Para esto, lo primero que debe hacerse es calcular

la matriz de rigidez k de cada elemento en el sistema local de coordenadas tipo

Kardestuncer. Las sub-matrices de las rigideces para un elemento finito viga doblemente

empotrada se muestran en la ecuación 2. Nota: i y j son los nudos de los extremos del

elemento; E es el módulo de Young; A el área de la sección, L la longitud e I el momento

de inercia de la sección del elemento.

27

Figura 16. Elemento finito viga en el plano XY de la estructura entre los nudos i y j. Nótese el sistema

de ejes locales Kardestuncer en cada extremo del elemento.

k/ 0 00 12 / 6 /0 6 / 4 /

/ 0 00 12 / 6 /0 6 / 2 /

(2)

El siguiente paso será transformar las matrices de la ecuación (2) de coordenadas locales

a coordenadas generales. Para esto es necesario el cálculo de la matriz de rotación R

entre estos sistemas de coordenadas. Si Rij es la matriz de rotación para rotar un vector

de coordenadas generales a locales (véase ecuación 3), entonces la inversa de R hace la

transformación inversa. Ya que ambos, el sistema general y el sistema local de

coordenadas, son ortogonales, la inversa de R es igual a su transpuesta.

R00

0 0 1 (3)

En resumen, los pasos del análisis estructural de marcos rígidos planos mediante el método de los

elementos finitos elemento viga doblemente empotrada (figuras 6 y 16) sistema de ejes locales

Kardestuncer (figuras 7 y 16), son los siguientes:

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

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

28

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

4 Para i < j, calcular K R k R y localizaren la fila i columna j de la matriz K de la

estructura.

5 Calcular K R k R y sumar a la sub-matriz existente en la fila i columna i de la

matriz K de la estructura.

6 Repetir los pasos 4 y 5 para cada elemento de la estructura.

7 Aplicar las condiciones de contorno eliminando las correspondientes filas y columnas de la

matriz K de la estructura.

8 Listar todas las cargas externas aplicadas en los nudos en secuencia (Px, Py, M) para

formar el vector fuerza generalizado P.

9 Resolver la ecuación matricial resultante que será de la forma de la ecuación 1. Los

resultados serán los desplazamientos de los nudos o sea el vector generalizado Δ en la

secuencia (Δx, Δy, θ) para cada nudo.

10 Calcular las fuerzas internas en los extremos de los elementos en coordenadas locales

usando la ecuación p k R ∆ k R ∆

11 Calcular las reacciones en los apoyos a partir de los resultados del paso 10 sumando las

fuerzas externas en los extremos de los elementos que concurren a los apoyos.

2.2AnálisisyDiseñoOrientadoaObjetosADOO

La primera vez que se propuso un enfoque orientado a objetos para el desarrollo de

software fue a finales de los años 60. Sin embargo, las tecnologías de objetos han

necesitado casi 20 años para llegar a ser ampliamente usadas.

El propósito del ADOO es definir todas las clases que son relevantes al problema que se

va a resolver, las operaciones y atributos asociados, las relaciones y comportamientos

asociados con ellos. El diseño orientado a objetos transforma el modelo de análisis

creado usando análisis orientado a objetos, en un modelo de diseño que sirve como

anteproyecto para la construcción de software.

29

2.2.1 ¿QuéesunObjeto?

Un objeto es la representación de una entidad. Un objeto puede representar algo concreto como una

estructura, etc. Un objeto es una abstracción. Un objeto tiene estado y comportamiento. Véase figura

17. ESTADO: El estado cambia con el tiempo y está definido por un conjunto de propiedades

(atributos). COMPORTAMIENTO: El comportamiento es todo lo que un objeto puede hacer.

Figura 17. Objeto: estructura; comportamiento: deformarse.

2.2.2 ¿QuéesunaClase?

Una clase es la plantilla de un grupo de objetos con propiedades comunes (atributos) y

comportamientos comunes (operaciones). Cada objeto es la instancia de una clase (véase figura 18).

Los mensajes son los mecanismos de comunicación entre objetos.

Figura 18. Ejemplo: clase automóvil.

2.2.3 Encapsulación

Encapsular datos y comportamiento en un simple objeto es de vital importancia en el desarrollo OO. La encapsulación

garantiza que los usuarios de un objeto no puedan modificar su estado sin usar su interfaz (métodos accesibles por otros

objetos). La ventaja de la encapsulación radica en que si se modifica algo de un módulo interno sin alterar su interfaz, dicho

cambio no implicaría ninguna modificación en el sistema. Véase la figura 9.

30

2.2.4 Interfaz

La interfaz es el medio fundamental de comunicación entre objetos. Cada clase deberá especificar sus

interfaces para una adecuada instanciación y operación de los objetos.

Implementación

Solo los atributos y métodos públicos son considerados interfaces. El usuario de un objeto debería interactuar con el mismo

únicamente por medio de las interfaces y no debería poder ver nada de la implementación. Véase figura 19.

Figura 19. Ejemplo de interfaz e implementación. Un objeto como una computadora puede tomar energía

eléctrica conectándose al enchufe (interfaz). La planta de generación de energía eléctrica (der.) es la implementación. Esta

planta puede ser hidroeléctrica o nuclear lo cual no importa mientras se dé energía eléctrica a la computadora.

2.2.5 Herencia

Consiste en compartir atributos y operaciones entre clases con base en una relación jerárquica. Una

clase padre (superclase) puede ser refinada en sucesivas subclases más definidas. La herencia es uno

de los mecanismos más poderosos de la orientación a objetos porque permite la re-utilización de

código.

Herencia Múltiple

Recurso que permite la definición de una subclase con más de una superclase. Esto permite la

combinación de dos o más orígenes.

31

2.2.6 SuperclasesySubclases

La superclase (o clase padre) contiene todos los atributos y comportamientos que son comunes a las

clases que heredan de ella. Estas clases que heredan de ella se denominan subclases. Véase figura 20.

2.2.7 Abstracción

En la tecnología OO las clases son la abstracción fundamental. Mediante la abstracción se parte de algunos casos concretos

de entidades (objetos) y se generan clases. La abstracción consiste en estudiar los conceptos fundamentales del dominio de

estudio obviando temporalmente las decisiones de diseño e implementación.

Relación “es un tipo de”

Supóngase por ejemplo que, el círculo, el cuadrado y el triángulo son clases que se heredan directamente de una

superclase llamada “figura”. Esta relación es muchas veces referida como una relación “es un tipo de” puesto que un

círculo es una figura o un cuadrado es una figura. Entonces, el círculo, el cuadrado y el triángulo son extensiones de una

figura. Véase figura 20.

Figura 20. Ejemplo de herencia: jerarquía de figuras.

2.2.8 Polimorfismo

Mecanismo que permite a la subclase implementar la misma operación (método) con un procedimiento diferente. La

misma operación puede actuar de modos diversos en clases diferentes. Al definir clases para figuras geométricas (rectas,

32

circunferencias, elipses y polígonos), la operación fundamental del cálculo del área se brinda al polimorfismo. Véase

figura 21.

Figura 21. La jerarquía Figura.

2.2.9 Composición

Cuando los objetos están compuestos a partir de otros objetos, esto se denomina composición. Es natural pensar que los

objetos siempre contienen otros objetos. Por ejemplo, un carro tiene un motor, tiene suspensión y tiene transmisión. Véase la

figura 22.

Relación “tiene un”

Aunque la relación de herencia es considerada una relación “es un tipo de” por razones discutidas

anteriormente, una composición es referida como una relación “tiene un”.

Figura 22. La jerarquía de la clase Carro.

+calcArea() : double

‐area : double

Figura


‐largo : double‐ancho : double

Rectangulo


‐radio : double

Circulo

33

2.2.10 Persistencia

La persistencia de un objeto se refiere al concepto de guardar el estado del mismo

para que pueda ser restaurado y usado posteriormente. Por ejemplo, el estado de un

objeto podría ser guardado en una base de datos.

2.2.11 ClasesAbstractas

Una clase abstracta es una clase que contiene uno o más métodos sin ninguna

implementación. Por ejemplo, la superclase “figura” es una clase abstracta porque

no se la puede instanciar. El concepto de “figura” es abstracto. Véase figura 21.

2.2.12 InterfaceJava

Una interface Java, a diferencia de una clase abstracta, no contiene absolutamente

ninguna implementación. Cualquier clase que implemente una interface Java deberá

proveer la implementación para todos los métodos de la interface.

Otras Consideraciones

Cuando se diseñan modelos de clases y objetos es de vital importancia entender

como los objetos están relacionados entre sí . Los conceptos primarios para la

construcción de objetos son: la herencia, las interfaces y la composición. Aplicando

bien estos conceptos se puede diseñar modelos sólidos de clases y objetos.

En ingeniería del software, el proceso de análisis es según el diagrama conceptual

de la figura 23.

34

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

2.3 LenguajeUnificadodeModelado(UnifiedModelingLanguageUML)

El UML es un lenguaje para el modelado orientado a objetos. El UML permite a los

creadores de sistemas generar diseños que capturan sus ideas en forma convencional y

fácil de comprender para comunicarlas a otras personas. Esto se lleva a cabo mediante un

conjunto de símbolos y diagramas. Un modelo UML describe lo que supuestamente hará

el sistema pero no dice cómo implementar dicho sistema. El UML está compuesto por

diversos elementos gráficos que se combinan para conformar diagramas.

El UML es la creación de Grady Booch, James Rumbaugh e Ivar Jaacobson. En 1997 se

produjo la versión 1.0 del UML. El UML ha llegado a ser el estándar de facto en la

industria del software y su evolución continúa. Actualmente ya se ha superado la versión

2 del UML.

2.3.1 DiagramasdeUML

Se trata de herramientas para modelar las diferentes vistas de un sistema OO. Cada diagrama tiene

fines distintos dentro del proceso de desarrollo.

35

Diagrama de Casos de Uso

Un caso de uso es una descripción de las acciones de un sistema desde el punto de vista del usuario.

Véase la figura 24.

Figura 24. Diagrama de casos de uso.

Diagramas de Clases

Un diagrama de clases está formado por varios rectángulos conectados por líneas que muestran como

las clases se relacionan entre sí. Véase figuras 21 y 22.

Diagramas de Colaboración

Describe cómo los elementos de un sistema trabajan en conjunto para cumplir con los objetivos del

sistema. La figura 25 muestra parte del diagrama de colaboración para el caso de uso “calcular pórtico”

de una aplicación de análisis estructural.

Diagramas de Secuencia

El diagrama de secuencia muestra la mecánica de la interacción entre objetos con base en el tiempo.

La figura 26 muestra el diagrama de secuencia para el caso de uso “calcular pórtico” de una aplicación

de análisis estructural.

36

Figura 25. Diagrama de colaboración (diagrama de comportamiento).

Figura 26. Diagrama de secuencia (diagrama de comportamiento).

Diagramas de Estado

En un momento dado, un objeto se encuentra en un estado en particular. La figura 27 muestra el estado

de una estructura (objeto) durante el proceso de aplicación de carga de servicio.

37

Diagrama de Actividades

Describe las actividades que ocurren dentro un caso de uso o dentro del comportamiento de un objeto.

Las actividades normalmente se dan en secuencia. La figura 28 ejemplifica el diagrama de actividades

para el proceso “aplicar condiciones de contorno” para el análisis de una estructura dada.

Figura 27. Diagrama de estados

(diagrama de comportamiento).

Figura 28. Diagrama de actividades (diagrama de comportamiento).

Diagramas de Componentes

El moderno desarrollo de software se realiza mediante componentes lo cual es

importante en los procesos de desarrollo en equipo. Los componentes pueden ser

reutilizados. La figura 29 representa un posible diagrama de componentes para una

aplicación de cálculo de estructuras.

Diagramas de Distribución

Muestran la arquitectura física de un sistema informático. La figura 30 muestra una arquitectura

cliente-servidor.

38

Figura 29. Diagrama de componentes.

Figura 30. Diagrama de distribución.

2.4 MetodologíasdeDesarrollo

La estructura y naturaleza de los pasos en un esfuerzo de desarrollo es lo que se entiende

como metodología. Antes del desarrollo de un programa, se debe comprender con

claridad el problema lo cual requiere un análisis de requerimientos. Luego, dicho análisis

tiene que convertirse en diseño. De ésta manera se puede comenzar a producir el código

a partir del diseño. Véase también la figura 23.

Las metodologías de desarrollo iniciales como el método en cascada establece que el

análisis, diseño, codificación y distribución van uno después de otro. Esta metodología

antigua tiene la desventaja de tender a la realización de tareas individuales. Existe la

posibilidad de que el analista, el diseñador y el desarrollador rara vez trabajen juntos

para compartir puntos importantes.

Métodos recientes

En contraste con el método en cascada, la ingeniería del software tiende a la

colaboración entre las fases de desarrollo. La ventaja es que conforme crece la

comprensión, el equipo incorpora nuevas ideas y genera un sistema más confiable.

39

Figura 31. Metodología en cascada.

2.4.1 ProcesoRacionalUnificado(RUP)

RUP es un proceso de desarrollo de software para asegurar la producción de software de calidad dentro

de plazos y presupuestos predecibles. Dirigido por casos de uso, centrado en la arquitectura, iterativo e

incremental (versiones). RUP es una guía de cómo usar UML de la forma más efectiva. UML es la

base del modelamiento visual de RUP.

RUP divide el proceso de desarrollo en ciclos teniendo un producto al final de cada ciclo. Cada ciclo se

divide en cuatro Fases: 1) Inicio 2) Elaboración 3) Construcción 4) Transición. Cada fase concluye con

un hito bien definido donde deben tomarse ciertas decisiones. Véase figura 32.

En la fase inicio se producen requerimientos generales del proyecto, características principales,

restricciones y un modelo inicial de casos de uso.

En la fase de elaboración se tienen como objetivos: analizar el dominio del problema, establecer una

arquitectura base sólida y desarrollar un plan de proyecto. Es la parte más crítica del proceso.

En la fase construcción todas las componentes restantes se desarrollan e incorporan al producto. Todo

es probado en profundidad. El énfasis está en la producción eficiente y no en la creación intelectual.

El objetivo de la fase transición es traspasar el software desarrollado a la comunidad de usuarios. Una

vez instalado surgirán nuevos elementos que implicarán nuevos desarrollos (ciclos).

40

Figura 32. Metodología RUP

2.4.2 MétodosAgiles

Las metodologías ágiles imponen un proceso disciplinado sobre el desarrollo de software

con el fin de hacerlo más eficiente. Los métodos ágiles son adaptables en lugar de

predictivos. Los métodos ágiles son orientados a la gente y no orientados al proceso.

Están a favor de la naturaleza humana y enfatizan que el desarrollo de software debe ser

una actividad agradable.

Desarrollo Adaptable de Software (ASD)

Esta metodología se adapta al cambio en lugar de luchar contra él. Se basa en la

adaptación continua a circunstancias cambiantes. En ella no hay un ciclo de

planificación-diseño-construcción del software. En el corazón de ASD hay tres fases

solapadas no lineales: especulación, colaboración, y aprendizaje. ASD es un método

iterativo, orientado a componentes de software, tolerante a cambios, guiado por riesgos

donde la revisión de los componentes sirve para aprender de los errores y volver a iniciar

el ciclo de desarrollo. Véase figura 33.

41

Figura 33. El ciclo de la metodología ASD.

Scrum

Scrum ha estado en los círculos orientados a objetos. Scrum divide un proyecto en

iteraciones (carreras cortas) de 30 días. Antes de que comience una carrera, se define la

funcionalidad requerida para esa carrera y entonces se deja al equipo para que la

entregue. El punto es estabilizar los requisitos durante la carrera. Todos los días el

equipo sostiene una junta corta (quince minutos) llamada scrum, dónde el equipo discute

lo que hará al día siguiente. Scrum se enfoca principalmente en la planeación iterativa y

el seguimiento del proceso.

XP (Programación Extrema)

XP empieza con cuatro valores: comunicación, retroalimentación, simplicidad y coraje.

Construye sobre ellos una docena de prácticas que los proyectos XP deben seguir.

Muchas de estas prácticas son técnicas antiguas, tratadas y probadas. Además de

resucitar estas técnicas, la XP las teje en un todo sinérgico dónde cada una refuerza a las

demás. Una de las más llamativas y atractivas es su fuerte énfasis en las pruebas. La XP

pone la comprobación como fundamento del desarrollo con cada programador

escribiendo pruebas cuando escriben su código de producción. Todo el diseño se centra

en la iteración actual y no se hace nada para necesidades futuras. El resultado es un

proceso de diseño disciplinado.

42

La Familia de Cristal de Cockburn

Se trata de una familia de metodologías basada en el fundamento de que tipos diferentes de proyectos

requieren tipos diferentes de metodologías. Se considera esta variación a lo largo de dos ejes: el

número de personas en el proyecto y las consecuencias de los errores. Cada metodología encaja en una

parte diferente. Un proyecto de 40 personas tiene una metodología diferente a la de un proyecto de 6

personas. Los Cristales comparten con la XP la orientación humana aunque de manera algo diferente.

Se pone mucho peso en las revisiones al final de la iteración animando al proceso a ser auto-mejorable.

Se fundamenta en que el desarrollo iterativo está para encontrar los problemas temprano y poder

corregirlos. Esto pone más énfasis en la gente supervisando su proceso y afinándolo conforme

desarrollan.

Desarrollo Manejado por Rasgos (FDD)

El Desarrollo Manejado por Rasgos (FDD por sus siglas en inglés), como las otras metodologías

adaptables, se enfoca en iteraciones cortas que entregan funcionalidad tangible.

En el caso del FDD las iteraciones duran solo dos semanas. El FDD tiene cinco procesos según se lista

a continuación. Los primeros tres se hacen al principio del proyecto. Los últimos dos se hacen en cada

iteración. Cada proceso se divide en tareas y se da un criterio de comprobación.

1) Desarrollar un modelo global

2) Construir una lista de los rasgos

3) Planear por rasgo

4) Diseñar por rasgo

5) Construir por rasgo

2.5 ProgramaciónOrientadaaObjetos

De la exposición anterior, se deduce que, la programación orientada a objetos es una filosofía de la que

surge una cultura nueva que incorpora técnicas y metodologías diferentes. En ella el universo

computacional está poblado por objetos, cada uno responsable de sí mismo, y comunicándose con los

demás por medio de mensajes. Cada objeto representa una instancia de alguna clase, y estas clases son

43

miembros de una jerarquía de clases unidas vía relaciones de herencia. La diferencia entre un objeto y

una clase es que un objeto es una entidad concreta que existe en el tiempo y espacio, mientras que una

clase representa una abstracción, la esencia de un objeto.

En la programación procedimental van separados los datos y las subrutinas que manipulan los datos.

La ventaja fundamental de la programación orientada a objetos es que, los datos y las operaciones

(código) que manipulan los datos, ambos van encapsulados en un objeto.

2.5.1 ClasificacióndeLenguajes

Lenguajes imperativos: Son aquellos basados en sentencias, ya sean procedurales, orientados a objetos

puros o mixtos. Entre ellos se cuentan Pascal, C, C++, Java, Fortran, Perl y Python.

Lenguajes procedurales: Son lenguajes imperativos basados en procedimientos (o rutinas) y funciones.

Entre ellos podemos nombrar a C, Fortran, Pascal (estándar) y Basic.

Lenguajes orientados a objetos: Son lenguajes imperativos basados en clases (algunos, llamados mixtos

soportan también el modelo procedural). Entre los lenguajes orientados a objetos puros podemos

nombrar a Smalltalk, Eiffel y Java. Entre los mixtos se encuentran C++ y Python.

Lenguajes funcionales: Son aquellos basados en funciones matemáticas (y no en comandos o

sentencias). Podemos nombrar aquí a ML, Haskell y Lisp.

2.6 EstadodelArte

Debido a la revolución de las computadoras, durante los últimos 40 años, el método de los elementos

finitos MEF ha sido ampliamente aceptado como herramienta para el modelado y simulación de

estructuras en la ingeniería.

Los programas de MEF siempre han consistido en miles de líneas de código mayormente escritos en

lenguajes basados en procedimientos como FORTRAN y C. Todas las herramientas conocidas hasta la

fecha producen los resultados del cálculo estructural (las fuerzas internas) usando un solo sistema de

ejes locales para ambos extremos de los elementos (elemento viga) dejando al ingeniero la

interpretación y modificación del resultados. En ésta investigación se pretende llegar a la

implementación de un modelo MEF que produzca resultados exactos para ambos extremos de los

elementos.

44

2.6.1 AntecedentesyTrabajosPrevios

[Archer 2000] diseñó e implementó un sistema para el MEF. Su diseño describe la

abstracción para cada clase y especifica su interfaz para tal abstracción. Se verifica que la

implementación de cada clase y la interacción entre objetos cumplan con la interfaz definida.

Además reconoce que el desarrollo de elementos infinitos involucra la adición de nuevos

elementos, nuevas estrategias de solución o nuevos esquemas de almacenamiento

matriciales; razón por la cual, presta especial cuidado a hacer las interfaces lo más flexibles

posibles.

La transformación entre sistemas de coordenadas es muy tomada en cuenta. Véase la figura

34. Recuerde que DOF se traduce como grados de libertad (degrees of freedom en inglés).

Archer planteó un modelo OO generalizado para elementos finitos. En ésta investigación se

propone un modelo OO específico - elemento viga con un sistema de ejes locales

Kardestuncer.

Figura 34. Modelo orientado a objetos propuesto por Archer.

45

[Jun Lu 2000] investigó, diseñó, implementó y demostró una aplicación OO

denominada FE++ como soporte para la construcción de una amplia variedad de

programas sobre análisis por elementos finitos.

Su objetivo principal apuntó a una amplia investigación en el dominio del análisis por

elementos finitos proveyendo una arquitectura OO y un conjunto de abstracciones para

permitir un rápido desarrollo de una variedad de aplicaciones sobre elementos finitos.

Dicha arquitectura OO está dirigida a aplicaciones de análisis lineal elástico o análisis

no lineal.

Jun Lu desarrolló una plataforma OO universal para el análisis estructural por

elementos finitos. En ésta investigación se desarrollará una plataforma OO específica

para el análisis estático de pórticos 2D por elementos finitos – elemento viga y ejes

locales Kardestuncer.

[Al Vermeulen 2000] describió las ventajas de los lenguajes OO como el C++ con

relación a los lenguajes de programación basados en procedimientos como el

FORTRAN. Expuso el código desarrollado en su investigación basado en un elemento

finito de curva cúbica de deformación. Ejemplificó el método de los elementos finitos

explicando los esfuerzos y deformaciones que sufre la rueda de una bicicleta. A raíz de

que el elemento finito de curva cúbica de deformación conduce a ecuaciones complejas,

concluyó que la programación OO es la más recomendable para lidiar mejor con ésta

complejidad.

Al Vermeulen implementó en C++ un modelo OO para elementos finitos de curva

cúbica de deformación. En ésta investigación se implementará en Java un modelo OO

para elementos finitos de deformación lineal - elemento viga y ejes locales

Kardestuncer.

[Foley 2003] propuso un algoritmo de computación evolutiva para el diseño de pórticos

de acero, parcial o totalmente restringidos. Aplicó un análisis avanzado de diseño

estructural usando un modelo inelástico basado en el comportamiento plástico

distribuido. La automatización del proceso de diseño estructural es implementada

usando un algoritmo evolutivo OO. Empleó la orientación a objetos OO para modelar

los componentes del pórtico y las operaciones de reproducción de dicho algoritmo

evolutivo. Demostró su propuesta diseñando pórticos de ejemplo de diversa topología

y discutió el rendimiento resultante de su algoritmo evolutivo OO.

46

Foley propuso un algoritmo evolutivo OO para el diseño de pórticos de acero. En ésta

investigación se propone un modelo OO para el análisis de pórticos por elementos

finitos.

Figura 35. Modelo OO según Foley para el diseño de estructuras de acero.

[Bittencourt et al 2001] desarrolló en C++ un software OO interactivo para el análisis y optimización

estructural en dos dimensiones. La principal característica de dicho software es la integración de varias

herramientas de cálculo en una interfaz gráfica de usuario. Ésta interfaz simplifica la introducción de

datos para la simulación y optimización de problemas elásticos lineales de dos dimensiones. La

implementación fue realizada para el sistema operativo Windows-NT.

Bittencourt desarrolló en C++ una aplicación para el análisis y optimización estructural 2D. En ésta

investigación se desarrollará en Java una aplicación solo para el análisis estructural 2D – elemento viga

y ejes locales Kardestuncer.

[McKenna 2000] diseñó un modelo OO para una variedad métodos de análisis por elementos finitos

usando computación secuencial y paralela. En un diseño tradicional OO se crea un objeto único para

realizar el análisis. Pero el diseño de McKenna propone una variedad de subclases para una clase

“Análisis” que modela distintos análisis como ser: Integrator, ConstraintHandler, DOF_Numberer,

AnalysisAlgorithm y otros. Este enfoque ofrece una gran flexibilidad al permitir elegir el análisis

47

mediante el tipo de objeto pasado al constructor de clase. El modelo fue implementado en C++ y

comparado con un código en un lenguaje basado en procedimientos.

McKenna diseñó un modelo OO con una clase “Análisis” segmentada en subclases para

varios tipos de análisis por elementos finitos. En ésta investigación se diseñará un

modelo OO que involucra una clase “Análisis” no-segmentada y específica para el

análisis estructural estático de pórticos 2D.

[Patzak 2001] creó un código gratuito de arquitectura OO para la solución de

problemas de mecánica, transporte y fluidos; ejecutable en varias plataformas. Su

objetivo fue desarrollar una herramienta eficiente y robusta para el MEF, y proveer de

un ambiente modular y extensible para desarrollos posteriores. El código incluye un

módulo para el balance dinámico de carga de trabajo en ambientes de computación

paralela. Véase figuras 36a y 36b.

Patzak desarrolló un código OO para resolver problemas de mecánica, transporte y

fluidos mediante elementos finitos. En ésta investigación se desarrollará un código OO

para resolver problemas de mecánica; específicamente, para el análisis de pórticos 2D

por elementos finitos – elemento viga y ejes locales Kardestuncer.

Figura 36a. Modelo de elementos finitos de la

carrocería de un vehículo.

Figura 36b. Renderización del modelo de

elementos finitos de la carrocería de un vehículo.

48

[Biniaris 2004] desarrolló una aplicación OO para resolver problemas 3D por el MEF aplicando

computación distribuida. La implementó en una red de estaciones de trabajo. La solución del sistema

de ecuaciones resultantes se la lleva acabo de forma distribuida por el método de la gradiente

conjugada. La implementación fue en Java y la computación distribuida se logró mediante el uso de la

tecnología agente móvil.

El punto principal de dicha investigación está dedicado a una descripción de la implementación del

modelo OO distribuido. Presentó resultados numéricos que prueban la ventaja de la técnica. Véase

figura 37.

Biniaris desarrolló en Java un modelo OO para la solución de problemas 3D por elementos finitos

aplicando computación distribuida. En ésta investigación se desarrollará un modelo OO para la

solución de problemas estructurales 2D por elementos finitos aplicando computación secuencial.

Figura 37. Sección cajón de un puente. La parte sombreada representa al estado de esfuerzos en la

estructura luego del cálculo del modelo de elementos finitos.

[Vector_Space Programming 2008] desarrolló en C++ una librería matemática con un conjunto de objetos matemáticamente

integrables y diferenciables. La librería es una herramienta para desarrollar rápidamente aplicaciones de cálculo. La librería

está dirigida a aplicaciones OO para el FEM que involucren análisis numérico avanzado, programación lineal, optimización,

métodos de las diferencias finitas y métodos variacionales.

Se trata de una librería en C++ para programas OO sobre el FEM que además dispone de métodos numéricos avanzados. En

ésta investigación se implementará en Java una librería OO específica para problemas estructurales mediante elementos

finitos. No se programarán métodos numéricos avanzados.

49

Parte3‐DesarrolloTeoricoPractico

El desarrollo teórico práctico que se presenta en éste artículo corresponde al avance actual de ésta

investigación. El estado actual de ésta investigación es más que inicial y completamente funcional.

3.1 DeclaracióndeTrabajo

Una estructura se compone de nudos y elementos (elemento viga doblemente

empotrada). Cada elemento parte de un solo nudo y termina en un solo nudo. Puede

haber varios elementos que parten de un mismo nudo o que terminan en un mismo

nudo. Un elemento puede tener solo un conjunto de propiedades de la sección (módulo

de elasticidad, área y momento de inercia). Puede haber varios elementos que tengan

las mismas propiedades de la sección. Un elemento puede tener solo un conjunto de

fuerzas internas (fuerza axial, fuerza cortante y momento flector). Un conjunto de

fuerzas internas puede pertenecer a más de un elemento. Un elemento puede tener

varias condiciones de carga puntual y/o distribuida en común con otros elementos; sin

embargo, una condición de carga debe pertenecer solo a un elemento.

Un nudo puede tener solo un conjunto de coordenadas planas (X, Y). Y un conjunto de

coordenadas planas puede pertenecer únicamente a un nudo. Un nudo puede tener

varias solicitaciones de carga puntual en común con otros nudos pero una condición de

carga puntual debe pertenecer solo a un nudo.

Cada nudo puede tener solo un conjunto de condiciones de borde o de frontera. Un

conjunto de condiciones de borde pueden tener en común varios nudos. Un nudo puede

tener solo un conjunto de desplazamientos. Un conjunto de desplazamientos pueden

tener en común más de un nudo. Un nudo restringido (apoyo) puede tener solo un

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

nudos.

50

Figura 38. Una estructura 2D de 3 nudos, 2 elementos, 3 cargas puntuales, 2 cargas distribuidas y 2

apoyos fijos.

La información inicial de entrada de una estructura consiste en: una descripción

li teral de la estructura, un lis tado de las coordenadas globales (X, Y) de sus nudos,

un listado de las incidencias de sus elementos, un lis tado de las cargas puntuales

sobre sus nudos, un l istado de las cargas puntuales y/o distribuidas sobre sus

elementos, y un lis tado de las condiciones de contorno (restr icciones o apoyos).

La información que se requiere luego del cálculo de una estructura consiste en: la

matriz global de r igidez, el vector generalizado de fuerza, el vector generalizado de

desplazamiento, las fuerzas internas en los extremos de los elementos según el

s istema de ejes locales Kardestuncer, las reacciones en los apoyos y una gráfica de

la deformada de la estructura.

El cálculo de una estructura deberá l levarse a cabo por medio del método de los

elementos fini tos empleado en ingeniería estructural conforme el extenso desarrollo

de la sección “marco teórico” de éste informe.

51

3.2 Requerimientos

3.2.1 Funcionales

Los requisitos funcionales definen qué debe hacer un sistema.

1. Al usuario se le deberá proveer de un formato de archivo estándar que permita

la introducción de manera tabulada de la información de entrada de la estructura.

2. Al usuario se le deberá proveer un campo que permita la introducción de la

descripción li teral de la estructura.

3. Al usuario se le deberá proveer de un campo que permita la introducción de las

coordenadas (X, Y) de los nudos de la estructura.


incidencias, de las propiedades geométricas y de las propiedades inerciales de

los elementos de la estructura.

5. Al usuario se le deberá proveer de campo que permita la introducción de las

cargas puntuales aplicadas en los nudos de la estructura.


cargas puntuales y /o distr ibuidas que actúan sobre los elementos de la

estructura.


condiciones de borde (apoyos) de la estructura.

8. Al usuario se le deberá proveer una interfaz para la verificación gráfica de la

geometría de la estructura.

9. Al usuario se le deberá proveer una interfaz para solici tar el anális is de la

estructura.

10. Al usuario se le deberá proveer archivos de un formato estándar que permita

acceder de manera tabulada a los resultados numéricos del anális is de la

estructura.

11. Al usuario se le deberá proveer de un archivo para acceder a los resultados

numéricos de la matriz global de r igidez de la estructura.

52


numéricos del vector general izado de fuerza de la estructura.


numéricos del vector general izado de desplazamiento de la estructura.


numéricos de las fuerzas internas en los extremos de los elementos de la

estructura.


numéricos de las reacciones en los apoyos (i . e . nudos restringidos mediante las

condiciones de contorno) de la estructura.

16. Al usuario se le deberá proveer de una interfaz gráfica para verificar la

deformada resultante del análisis de la estructura.

17. Al sistema se le deberá proveer la implementación de un modelo que permita el

análisis de la estructura mediante el método de los elementos finitos - elemento

viga doblemente empotrada sistema de ejes locales Kardestuncer según el

extenso desarrol lo de la sección “marco teórico” de éste documento.

18. Al sistema se le deberá proveer una rutina para abrir la información de entrada

de la estructura.

19. Al sistema se le deberá proveer una rutina para graficar la geometr ía de la

estructura.

20. Al sistema se le deberá proveer una rutina para ensamblar el vector generalizado

de fuerza de la estructura.

21. Al sistema se le deberá proveer una rutina para ensamblar la matriz global de

r igidez la estructura.

22. Al sistema se le deberá proveer una rutina para aplicar las condiciones de

contorno de la estructura.

23. Al sistema se le deberá proveer una rutina para resolver el s is tema de ecuaciones

de la estructura.

24. Al sistema se le deberá proveer una rutina para calcular las fuerzas internas en

los extremos de los elementos de la estructura.

53

25. Al sistema se le deberá proveer una rutina para calcular las reacciones de los

apoyos de la estructura.

26. Al sistema se le deberá proveer una rutina para guardar los resultados numéricos

del análisis de la estructura.

27. Al sistema se le deberá proveer una rutina para graficar la deformada de la

estructura.

3.2.2 No Funcionales

Los requisitos no funcionales definen cómo debe ser el sis tema.

1. La aplicación debe ser desarrollada util izando Java para permitir que en el futuro

usuarios famil iarizados con este lenguaje puedan añadir más funcionalidades y

mantenerlo.

2. El sistema debe accederse a través de la máquina virtual de Java.

3. Periféricos disponibles para la usabilidad: teclado y ratón.

4. El sis tema debe ser de fácil usabilidad.

5. El sistema deberá proveer un medio independiente para la instalación del mismo.

3.3 Modelo de Casos de Uso

Los actores que se distinguen del anál isis de requerimientos son “el usuario” y “el

s istema” conforme se muestran en los casos de uso de las f iguras 39 a la 41. En

general, es posible detal lar con mayor profundidad la mayoría de los casos uso. En

la f igura 41 se detalla el caso de uso “introducir condiciones de contorno”. A este

concepto se conoce como “inclusión de caso de uso”.

54

Figura 39. Caso de uso – actor “el usuario”

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

Usuario

Introducir lascondiciones de frontera

Introducir códigode nudo

Introducir restricciónal desplazamiento

horizontal

Introducir restricciónal desplazamiento

vertical

« incluir »

« incluir »

« incluir »

Introducirrestricción al giro

« incluir »

55

Figura 41. Caso de uso – actor “el sistema”.

Las figuras 41a a 41d detallan mediante inclusión el caso de uso generalizado de la figura 39. Nótese

que se desglosa la introducción de la estructura por parte del actor usuario.

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

Usuario

Introducir lascoordenadas de los nudos

Introducircoordenada X

« incluir »

Introducircoordenada Y

« incluir »

56

Figura 41b. Inclusión de caso de uso “Introducir las propiedades de los elementos”. Nótese que la

numeración de los elementos deberá ser automática según el orden de introducción de los mismos.

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

Usuario

Introducir laspropiedades de los elementos

Introducir módulo deelasticidad (E)« incluir »

Introducir momentode inercia (I)

« incluir »

Introducir área dela sección (A)

« incluir »

Introducir código denudo de partida

« incluir »Introducir código de

nudo de llegada

« incluir »

Usuario

Introducir las cargaspuntuales en los nudos

Introducir códigode nudo

Introducir lacomponente horizontal

Introducir lacomponente vertical

« incluir »

« incluir »

« incluir »

Introducir elmomento flector

« incluir »

57

Figura 41d. Inclusión de caso de uso “Introducir las cargas sobre los elementos”. Nótese que la

inclusión de “introducir carga puntual” puede desglosarse según la figura 41c.

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

Usuario

Introducir las cargassobre los elementos

Introducir códigode elemento

Introducir tipo decarga

Introducir cargapuntual

« incluir »

« incluir »

« incluir »

Introducir iniciode aplicación« incluir »

Introducir longitudde aplicación

« incluir »

Usuario

Solicitar elcálculo estructural

Verificargráficamente la estructura

Autorizar elanálisis estructural

« incluir »

« incluir »

58

Figura 41f. Inclusión y extensión del caso de uso “Acceder a los resultados numéricos del análisis”. La

extensión de un caso de uso es una extensión del original. Se trata de la creación de un caso de uso

agregándole pasos a uno existente.

3.4 ModelodeClases

Del análisis de requerimientos, en general, las clases se corresponden con los sustantivos que a su vez

son objetos: estructura, elementos, nudos, cargas, etc. Por otra parte, los verbos casi siempre se

correlacionan con las responsabilidades (operaciones) de los objetos como ser: ensamblar sistema de

ecuaciones, aplicar condiciones de contorno, resolver sistema de ecuaciones, calcular fuerzas internas,

calcular reacciones y otros.

Luego de una serie de revisiones, se ha llegado a un diseño de clases robusto (véase figura 42) basado

en encapsulación, herencia, abstracción, polimorfismo, composición, clases abstractas, interface java y

otros conceptos OO. En cada clase se aplica la encapsulación ocultando las propiedades y permitiendo

el acceso a las mismas mediante métodos y su interfaz. Se emplea la herencia para especializar las

clases abstractas y crear clases que se puedan instanciar para resolver casos específicos. Gracias a un

adecuado conocimiento del dominio se ha llegado a un alto grado de abstracción del modelo dando

lugar a futura escalabilidad (e. g. estructuras 3D). El polimorfismo es un concepto muy empleado

sobre todo en las subclases del modelo. Se emplea la composición por agregación pero ésta puede

distinguirse en la zona “propiedades” de cada clase. Se emplea el concepto de interface java como

Usuario

Acceder a losresultados numéricos del

análisis

Ver los desplazamientosde los nudos de la

estructura.

Ver las fuerzasinternas en los elementos.

Ver las reaccionesen los apoyos.

« incluir »

« incluir »

« extender »

Acceder a losresultados gráficos del análisis

« incluir »

59

artificio para proveer de herencia múltiple al modelo ya que en el lenguaje Java no se ofrece herencia

múltiple.

La interface java interface01 se emplea más que todo para que cada clase del modelo esté

obligada a implementar un método de identificación para cualquier objeto. Nótese que las

clases que “realizan” a la interface java “interface01” deben ser clases abstractas.

La clase abstracta estructura00 contiene todas las propiedades y métodos fundamentales de

una estructura en general o sea ésta superclase podría aplicarse sin ningún inconveniente

inclusive a estructuras tridimensionales. Nótese que muchas de las operaciones de ésta

superclase tienen que ver directamente con el análisis estructural mediante elementos finitos.

La clase abstracta nudo00 contiene todas las propiedades y métodos fundamentales de un nudo

en general; sin embargo, de ésta superclase podría heredarse otros tipos de nudos como nudos

con apoyos elásticos u otros.

La clase abstracta elemento00 abstrae las propiedades y métodos para un elemento estructural

en general; es decir, ésta superclase podría aplicarse inclusive como base de elementos

tridimensionales. Para el caso de las estructuras planas como los marcos planos, es necesario

heredar una nueva subclase como elemento01 que permita la especialización en cuanto a la

matriz de rigidez, matriz de rotación, matriz de coeficientes de fuerza y otros para elementos

viga de dichas estructuras. La subclase elemento02 es un adelanto de prueba del modelo; se

trata de la especialización para elementos de otras estructuras planas como parrillas muy

utilizadas en losas, puentes y otros.

La clase abstracta cargaele00 abstrae las propiedades y métodos para el tema de cargas

puntuales o distribuidas aplicadas sobre los elementos de una estructura. Se ha heredado,

especializado y llegado a una subclase cargaele01 para el caso de cargas puntuales aplicadas

sobre un elemento. La subclase cargaele02 es una herencia y especialización de cargaele00

para el caso de cargas distribuidas rectangulares aplicadas sobre el elemento. Para la siguiente

revisión de ésta investigación se va a incluir una subclase especializada cargaele03 para cargas

distribuidas triangulares aplicadas sobre un elemento (véase figura 38).

60

Figura 42. Modelo de clases.

61

Finalmente, las subclases estructura01 y nudo01 son clases heredadas que permiten instanciarse para la

aplicación práctica de sus correspondientes clases abstractas. Las subclases estructura01 y nudo01

también tienen la función de la inicialización de las propiedades heredadas y de la identificación que

exige la realización de la interface java interface01.

3.5 VistaDinámica–DiagramasdeComportamiento

Basado en el algoritmo del método de los elementos finitos para el análisis de estructuras (véase figura 12), se ha

diseñado la comunicación entre los objetos del modelo en función del tiempo según se muestra en el diagrama de

secuencia para el caso de uso “ensamblar sistema de ecuaciones de la estructura” cuyo actor es “el sistema” (véase

figura 43). El algoritmo exige el ensamblado de la matriz global de rigidez de la estructura para cuyo efecto se calculan

primero las rigideces locales y globales de los elementos. El MEF también exige el ensamblado del vector

generalizado de fuerza de la estructura para lo cual se consideran las cargas sobre los elementos y las cargas sobre los

nudos que pueda haber. En el diagrama se pueden verificar que todos los mensajes entre objetos son sincrónicos.

En la figura 43a se muestra el diagrama de actividades para el proceso “ensamblar sistema”. Ha sido diseñado para

mostrar una visión simplificada del proceso. Muestra los pasos (actividades) así como los puntos de decisión y

bifurcación.

La figura 43b es el diagrama de colaboración para éste mismo proceso; muestra cómo los objetos se colaboran entre sí

tal como sucede en el correspondiente diagrama de secuencias (figura 43).

Los diagramas de colaboración son semánticamente equivalentes a los diagramas de secuencia. Destacan la sucesión

de interacciones. Destacan el contexto y organización general de los objetos que interactúan.

Para resolver el sistema de ecuaciones de la estructura, primero deben eliminarse las filas y columnas de la ecuación

matricial de la estructura (i.e. vector fuerza, matriz de rigidez, vector desplazamiento) según las componentes de los

nudos restringidos (e. g. apoyos). A esto se denomina “aplicar las condiciones de contorno”. Luego, haciendo uso de

un método numérico incluido en la librería JAMA, se resuelve el sistema de ecuaciones reducido de la estructura.

Finalmente, se actualizan los desplazamientos de los nudos de la estructura haciendo uso de la solución del sistema (i.e.

vector desplazamiento generalizado). Los diagramas UML de secuencia, actividades y colaboración, de éste proceso,

se muestran en las figuras 43c-43e.

62

Figura 43. Diagrama de secuencia para proceso “ensamblar el sistema de ecuaciones”.

Seguidamente, el algoritmo del MEF exige que, para el cálculo de las fuerzas internas en los extremos de los

elementos, deben considerarse, evaluarse y sumarse las fuerzas internas de empotramiento debido a cargas puntuales,

distribuidas, etc. que los elementos puedan tener. Los diagramas UML de secuencia, actividades y colaboración de

este proceso se muestran en las figuras 43f, 43g y 43j.

63

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

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

64

Figura 43c. Diagrama de secuencia para el proceso “resolver sistema de ecuaciones” de la estructura.

Para calcular las reacciones en los apoyos de la estructura deben considerarse los nudos restringidos o

apoyos. Nótese que, una vez resuelto el sistema de ecuaciones de la estructura, el vector fuerza

generalizado de la ecuación matricial de la estructura (i.e. vector P) puede calcularse para contener las

reacciones entre sus componentes. Los diagramas de secuencia, actividades y colaboración para éste

proceso se muestran en las figuras 43h, 43i y 43k.

65

Figura 43d. Diagrama de actividades del proceso “resolver sistema de ecuaciones de la estructura”.

Figura 43e. Diagrama de colaboración del proceso “resolver sistema de ecuaciones de la estructura”.

66

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

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

67

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

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

68

Figura 43j. Diagrama de colaboración para el proceso “calcular fuerzas internas”.

Figura 43k. Diagrama de colaboración para el proceso “calcular reacciones”.

El diagrama de estados de la figura 43L refleja el progreso de la ecuación matricial

de la es tructura durante el proceso global “analizar estructura”. Nótese que refleja

también los cambios que sufren los arreglos de las fuerzas internas en los extremos

de los elementos y las reacciones en los apoyos. Recuerde que la parte inferior

contiene las actividades entrada (qué sucede cuando el sistema entra al estado),

hacer (qué sucede cuando el sistema está en el estado) y salida (qué sucede cuando

el sistema sale del estado).

69

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

3.6 DiagramasdeComponentesydeDespliegue

Además del paquete maestro de clases para el análisis de estructuras mediante el MEF que se propone

como punto central de ésta investigación y que se denomina “Estructural” en el diagrama de

componentes de la figura 43m, también intervienen otras clases como herramientas o utilitarios para

que la aplicación resultante pueda cumplir cabalmente con la lista de requerimientos. Es el caso del

paquete JAMA de distribución gratuita que viene con un modelo OO para la mayoría de las

operaciones del álgebra matricial incluyendo métodos de factorización que se necesitan para la

resolución de ecuaciones matriciales como las que se forman con las estructuras.

Un sistema puede abarcar diversos tipos de plataformas en ubicaciones dispersas. Un diseño sólido de

distribución de hardware es básico para el diseño del sistema. El diagrama de distribución se presenta

en la figura 43n y muestra un elemento primordial de hardware como el nudo PC o computadora

personal. Se tienen componentes en el nudo como la aplicación desarrollada en ésta investigación, la

cual depende de la máquina virtual de Java y la cual a su vez depende del sistema operativo. Se exige

70

un software editor de archivos CSV para acceder a la información tabulada de entrada y salida

procesada por la aplicación.

Figura 43m. Diagrama de componentes. Figura 43n. Diagrama de

despliegue.

3.7 Implementación–Generalidades

La implementación del modelo de clases de la figura 42 se la ha llevado a cabo en lenguaje Java según el paquete

“Estructural” de la figura 43m. Todas las clases han sido implementadas con base a la ventaja fundamental de la

programación orientada a objetos: la encapsulación. El ocultamiento de las propiedades y los métodos ha sido aplicado a

todas las clases. El concepto de los “getters” y “setters” para proveer acceso controlado a los datos de un objeto ha sido

completamente aplicado en todos los casos en virtud de evitar que haya manipulación directa de datos (atributos) entre

objetos. Véase la figura 44.

Con el fin de que la aplicación pueda tener acceso a la lectura y escritura de archivos de formato tabulado conforme la lista de

requerimientos, se ha incorporado un paquete de clases de distribución gratuita para la manipulación de archivos de valores

separados por comas extensión CSV (comma separated values). Estos archivos pueden ser editados fácilmente por cualquier

software comercial de hoja de cálculo.

Como se mencionó anteriormente, se ha incluido un paquete de clases de distribución gratuita denominado JAMA que

provee del álgebra matricial al modelo (véase figura 43j).

71

Figura 44. Implementación en Java de la clase abstracta “cargaele00”.

El prototipo de la interfaz de usuario de la aplicación se muestra en la figura 45. El prototipo

proporcionará información valiosa que ayudará a mejorar la aplicación durante las iteraciones del

proceso de diseño. “Para el usuario del sistema, la interfaz de usuario es el sistema.

72

Figura 45. Prototipo para la interfaz de usuario.

3.8 CasosDeEstudio

En ésta parte se va a emplear el programa para analizar estructuras de función real. Y con el fin de comprobar el modelo, se va a

verificar manualmente el equilibrio de cada estructura primero entre las fuerzas internas que concurren en un nudo elegido al azar;

luego, entre fuerzas externas y reacciones en los apoyos.

3.8.1 CerchaTipoTorre

Fuente Bibliográfica

BEER FERDINAND Y JOHNSTON E. RUSELL (1993). “Mecánica Vectorial para Ingenieros”.

Editorial McGraw-Hill. México. Páginas 243 y 469.

Problema 6.40

Determínese la fuerza en el miembro (I-K) de la cercha plana que se muestra en la figura. (Úsese la

sección a-a).

73

Figura 46 – Caso de estudio

Solución

Se crea el archivo de entrada con un software para planillas electrónicas como Microsoft Excel.

Primero, se introduce un metadato de campo DESCRIPCION DE LA ESTRUCTURA y luego un título

para la estructura como ser “BEER Y JOHNSTON Páginas 243 y 469 Problema 6.40”.

Segundo, se introduce un metadato COORDENADAS DE LOS NUDOS; luego, se elige un origen

para el sistema global de coordenadas XY de la estructura como ser en el nudo J de la figura 46. A

continuación se introducen las coordenadas X e Y de los nudos A (nudo 1) hasta la J (nudo 11).

Tercero, se introduce un metadato ELEMENTOS TIPO y abajo se coloca “portico” para indicar que

los elementos de la estructura se corresponden con un pórtico (marco plano). La estructura de la figura

46 es una cercha que puede tratarse como un pórtico de elementos de inercia cero.

Cuarto, se ingresa un metadato PROPIEDADES DE LOS ELEMENTOS; seguidamente, se introducen

las incidencias de los elementos, el módulo de elasticidad, el momento de inercia y el área de la

sección según se muestra en la tabla guía de a continuación.

74

Elemento Nudo inicial i Nudo final j E I A

1 1 2 1 1E-9 1

2 1 4 1 1E-9 1

3 2 3 1 1E-9 1

4 2 4 1 1E-9 1

5 2 6 1 1E-9 1

6 3 6 1 1E-9 1

7 4 5 1 1E-9 1

8 4 7 1 1E-9 1

9 5 6 1 1E-9 1

10 5 7 1 1E-9 1

11 5 9 1 1E-9 1

12 6 9 1 1E-9 1

13 7 8 1 1E-9 1

14 7 10 1 1E-9 1

15 8 9 1 1E-9 1

16 8 10 1 1E-9 1

17 8 11 1 1E-9 1

18 9 11 1 1E-9 1

19 10 11 1 1E-9 1

Quinto, se ingresa un metadato CARGAS EN LOS NUDOS y se introducen las cargas

puntuales aplicadas en los nudos A (nudo 1), D (nudo 4) y G (nudo 7) de la figura 46.

Nótese que siempre se introduce primero la componente horizontal de la carga, luego la

vertical y finalmente la carga de momento flector.

75

Sexto, colóquese un metadato CARGAS EN LOS ELEMENTOS para cumplir con la

integridad del formato de archivo exigido por el programa ya que la estructura que se

está ingresando no tiene cargas sobre elementos.

Séptimo, ingrese un metadato APOYOS para describir las condiciones de contorno de

la estructura. Abajo colóquese primero el número de nudo que corresponde al apoyo,

luego la restricción al desplazamiento horizontal del nudo, al desplazamiento vertical y

finalmente la restricción al giro. Cuando exista restricción en alguna dirección solo se

coloca 1 (uno) y 0 (cero) cuando no. Nótese que para el problema en cuestión, los

nudos J (nudo 10) y K (nudo 11) están parcialmente restringidos.

La figura 47 muestra cómo debiera quedar la introducción de la estructura.

Finalmente, guárdese la hoja electrónica en formato de archivo de valores separados

por comas o CSV (comma separated values). Elíjase un nombre descriptivo que

represente bien a la estructura porque luego los nombres de los archivos de salida CSV

resultantes del análisis estructural se basarán en el nombre del archivo de entrada. La

información de entrada de la estructura de la figura 46 ha sido guardada como

“beerjohnsp243269p640.CSV”.

Análisis y Resultados

Al ejecutar la aplicación, ésta primero recupera el archivo CSV de entrada de la

estructura y en caso de que la información haya sido correctamente ingresada, se

muestra inmediatamente una gráfica para la verificación -por parte del usuario- de la

geometría de la estructura. Una captura de pantalla se muestra en la figura 48.

A continuación, la aplicación realiza el análisis de la estructura y se van guardando

archivos CSV de resultados numéricos importantes a medida del progreso del proceso.

Los nombres de los archivos de salida CSV empiezan con el nombre del archivo de

entrada y llevan un sufijo según el contenido que almacenan.

76

Figura 47. Entrada de la estructura.

Cuando concluye el análisis estructural aparece una ventana con una gráfica exagerada

de la deformada de la estructura. Esto se muestra en la figura 49. Nótese que la

deformada coincide con la tendencia de desplazamiento de la estructura bajo las

condiciones de carga puntual horizontal aplicada.

77

Sufijo de nombre de archivo Contenido del archivo CSV de salida

(K) Matriz de rigidez de la estructura.

(P) Vector generalizado de fuerza.

(D) Vector generalizado de desplazamientos.

(fint) Fuerzas internas en los extremos de los elementos.

(reacciones) Reacciones en los apoyos de la estructura.

( )r Matriz o vector reducida(o).

Nota.- Una matriz o vector reducido(a) es una matriz o vector luego de la aplicación de las condiciones

de contorno.

Figura 48. Geometría de la estructura antes del

análisis.

Figura 49. Deformada de la estructura luego del

análisis.

Es importante recordar que, cada ecuación del sistema de ecuaciones simultáneas de una

estructura, corresponde a cada grado de libertad de la misma. Esta estructura tiene 11 nudos

y cada nudo tiene 3 grados de libertad (i. e. desplazamiento horizontal, vertical y rotacional)

por lo tanto su sistema es de 33 ecuaciones.

78

La matriz global de rigidez de ésta estructura se muestra en la página siguiente. Como se

dijo anteriormente, éstos resultados y otros pueden encontrarse en los archivos CSV de

salida. Como puede comprobarse, la matriz global de rigidez K es cuadrada, tiene 33 filas,

33 columnas y además es simétrica conforme dicta una de sus propiedades. Todo indica que

ha sido ensamblada correctamente por el sistema.

Como se expuso en el marco teórico, el fin es diseñar una estructura y el análisis estructural

es una herramienta para alcanzar tal fin. Los resultados más importantes del análisis son: las

fuerzas internas en los extremos en los elementos y las reacciones en los apoyos.

Información útil también para verificar manualmente el análisis de la estructura.

A razón de que el modelo OO implementado en éste programa está dirigido a mejorar los

resultados del análisis estructural por medio de un elemento finito viga sistema de ejes

locales Kardestuncer, se tienen valores de las fuerzas internas para ambos extremos de los

elementos según se ve en la figura 50.

El hecho de que las fuerzas internas solo se manifiesten en el eje local axial x (Px) coincide

perfectamente con el comportamiento de una cercha como la del problema en cuestión.

Véase figura 50.

Según la figura 50, las fuerzas internas en los extremos i y j del elemento entre los nudos I-

K (nudos 9-11) o sea elemento no. 18 son:

Extremo i

00.0

00.0

64.28

F11-9

Extremo j

00.0

00.0

64.28

F9-11

79

0.23

10.

029

0.00

0-0

.222

0.00

00.

000

0.00

00.

000

0.00

0-0

.009

-0.0

290.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

029

0.09

80.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

-0.0

29-0

.098

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

0-0

.222

0.00

00.

000

0.51

20.

000

0.00

0-0

.222

0.00

00.

000

-0.0

34-0

.042

0.00

00.

000

0.00

00.

000

-0.0

340.

042

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.10

60.

000

0.00

00.

000

0.00

0-0

.042

-0.0

530.

000

0.00

00.

000

0.00

00.

042

-0.0

530.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

0-0

.222

0.00

00.

000

0.23

1-0

.029

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

0-0

.009

0.02

90.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

0-0

.029

0.09

80.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.02

9-0

.098

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

0-0

.009

-0.0

290.

000

-0.0

34-0

.042

0.00

00.

000

0.00

00.

000

0.19

00.

100

0.00

0-0

.140

0.00

00.

000

0.00

00.

000

0.00

0-0

.009

-0.0

290.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

-0.0

29-0

.098

0.00

0-0

.042

-0.0

530.

000

0.00

00.

000

0.00

00.

100

0.24

90.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

-0.0

29-0

.098

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

0-0

.140

0.00

00.

000

0.36

10.

000

0.00

0-0

.140

0.00

00.

000

-0.0

41-0

.037

0.00

00.

000

0.00

00.

000

-0.0

410.

037

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.06

80.

000

0.00

00.

000

0.00

0-0

.037

-0.0

340.

000

0.00

00.

000

0.00

00.

037

-0.0

340.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

-0.0

340.

042

0.00

0-0

.009

0.02

90.

000

0.00

00.

000

0.00

0-0

.140

0.00

00.

000

0.19

0-0

.100

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

0-0

.009

0.02

90.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

042

-0.0

530.

000

0.02

9-0

.098

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

0-0

.100

0.24

90.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.02

9-0

.098

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

0-0

.009

-0.0

290.

000

-0.0

41-0

.037

0.00

00.

000

0.00

00.

000

0.16

00.

095

0.00

0-0

.102

0.00

00.

000

0.00

00.

000

0.00

0-0

.009

-0.0

290.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

-0.0

29-0

.098

0.00

0-0

.037

-0.0

340.

000

0.00

00.

000

0.00

00.

095

0.23

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

-0.0

29-0

.098

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

0-0

.102

0.00

00.

000

0.28

90.

000

0.00

0-0

.102

0.00

00.

000

-0.0

43-0

.031

0.00

0-0

.043

0.03

10.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.04

40.

000

0.00

00.

000

0.00

0-0

.031

-0.0

220.

000

0.03

1-0

.022

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

-0.0

410.

037

0.00

0-0

.009

0.02

90.

000

0.00

00.

000

0.00

0-0

.102

0.00

00.

000

0.16

0-0

.095

0.00

00.

000

0.00

00.

000

-0.0

090.

029

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

037

-0.0

340.

000

0.02

9-0

.098

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

0-0

.095

0.23

00.

000

0.00

00.

000

0.00

00.

029

-0.0

980.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

0-0

.009

-0.0

290.

000

-0.0

43-0

.031

0.00

00.

000

0.00

00.

000

0.09

10.

060

0.00

0-0

.040

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

-0.0

29-0

.098

0.00

0-0

.031

-0.0

220.

000

0.00

00.

000

0.00

00.

060

0.12

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

0-0

.043

0.03

10.

000

-0.0

090.

029

0.00

0-0

.040

0.00

00.

000

0.09

1-0

.060

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.03

1-0

.022

0.00

00.

029

-0.0

980.

000

0.00

00.

000

0.00

0-0

.060

0.12

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

00.

000

0.00

0

MAT

RIZ

GLO

BAL

DE R

IGID

EZ K

PAR

A LA

EST

RUCT

URA

TIPO

CER

CHA

DEL

CASO

DE

ESTU

DIO

80

Figura 50. Fuerzas internas en los extremos de los elementos.

Un signo negativo indica compresión axial en el extremo del elemento conforme el sistema de ejes

locales de Kardestuncer (véase figura 7b).

La respuesta textual de la fuente bibliográfica del problema (no. 6.40), es:

La C indica compresión. Entonces la respuesta del programa es correcta.

Los resultados para las reacciones en los apoyos son:

Nótese que, la sumatoria de componentes verticales (Ry) da 0 (cero) lo cual indica que no existe

componente vertical de carga externa aplicada o sea es correcto.

Elemento Pxi Pyi Mzi Pxj Pyj Mzj

1.00 ‐20.00 0.00 0.00 ‐20.00 0.00 0.00

2.00 0.00 0.00 0.00 0.00 0.00 0.00

3.00 0.00 0.00 0.00 0.00 0.00 0.00

4.00 16.05 0.00 0.00 16.05 0.00 0.00

5.00 ‐16.05 0.00 0.00 ‐16.05 0.00 0.00

6.00 0.00 0.00 0.00 0.00 0.00 0.00

7.00 ‐26.28 0.00 0.00 ‐26.28 0.00 0.00

8.00 13.10 0.00 0.00 13.10 0.00 0.00

9.00 6.28 0.00 0.00 6.28 0.00 0.00

10.00 22.07 0.00 0.00 22.07 0.00 0.00

11.00 ‐22.07 0.00 0.00 ‐22.07 0.00 0.00

12.00 ‐13.10 0.00 0.00 ‐13.10 0.00 0.00

13.00 ‐31.86 0.00 0.00 ‐31.86 0.00 0.00

14.00 28.64 0.00 0.00 28.64 0.00 0.00

15.00 11.86 0.00 0.00 11.86 0.00 0.00

16.00 26.94 0.00 0.00 26.94 0.00 0.00

17.00 ‐26.94 0.00 0.00 ‐26.94 0.00 0.00

18.00 ‐28.64 0.00 0.00 ‐28.64 0.00 0.00

19.00 30.00 0.00 0.00 30.00 0.00 0.00

Apoyo Rx Ry Mz

10.00 ‐60.00 ‐43.20 0.00

11.00 0.00 43.20 0.00

81

Verificación Manual de Resultados

La verificación manual del análisis estructural consiste en: 1) Elegir un nudo al azar

y realizar la comprobación de equil ibrio de las fuerzas internas/externas que

concurren al nudo. 2) Realizar la sumatoria de las fuerzas externas aplicadas

incluyendo las reacciones. Para verificar el equilibrio la suma debe dar 0 (cero).

Por motivos de i lustración procedimental , el nudo elegido para comprobar el

equil ibrio puede ser el nudo D (nudo 4). Se puede usar una tabla para recopilar ,

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

Concurren al nudo D Valor en el nudo Horizontal Vertical

Elemento AD (2) 0.00 0.00 0.00

Elemento BD (4) +16.05 +10.00 +12.56

Elemento ED (7) -26.28 -26.28 0.00

Elemento DG (8) -13.10 -3.72 -12.56

Carga externa + 20.00 +20.00 0.00

Sumatoria 0.00 0.00

Se ha verificado exitosamente el equilibrio en el nudo D de la estructura lo cual

indica que el modelo y su implementación ( i . e. el programa) están produciendo

resultados correctos con relación a las fuerzas internas en los extremos de los

elementos.

Ahora bien, la tabla para la verif icación del equilibrio de las fuerzas externas y

reacciones que actúan en la estructura es la s iguiente:

Descripción Horizontal Vertical

Carga externa nudo A +20.00 0.00

Carga externa nudo D +20.00 0.00

82

Carga externa nudo G +20.00 0.00

Reacción apoyo J -60.00 -43.20

Reacción apoyo K 0.00 +43.20

Sumatoria 0.00 0.00

Se verifica exitosamente el equilibrio de las cargas externas y reacciones aplicadas

en los nudos de la estructura. Con lo que se rat ifica que la implementación del

modelo OO para el análisis estructural mediante elementos fini tos – elemento viga

sistema de ejes locales Kardestuncer, está produciendo resultados correctos.

3.8.2 MarcoRígidoPlano:Edificiode8Plantas

Con el fin de probar las ventajas del modelo OO propuesto en esta investigación, se

va a analizar un pórt ico plano que modela un edificio de 8 plantas. Dicha estructura

será resuelta primero mediante la aplicación desarrollada en ésta investigación y

luego empleando una aplicación de calibre industrial y fama mundial como el

SAP2000 (Structural Analysis Program) versión 15 – 2011 de CSi (Computers and

Structures, Inc.) USA. Los resultados del análisis serán objeto de comparación para

resaltar las mejoras propuestas en ésta investigación.

Nota.- No se va a detallar el manejo del programa de análisis estructural SAP2000

porque los pormenores de la operación de dicha aplicación caen fuera del contexto

de ésta investigación.

Problema

Realizar el análisis estructural de un pórtico plano de 8 plantas y 3 vanos. Los pilares tienen una

altura de 3 m y los vanos de las vigas portantes tienen una longitud de 4 m. Para todos los

elementos, el módulo de elasticidad es de 1000 Kgf/m2; el momento de inercia es 100 m4 y el

área de la sección es 1 m2. Asígnese una carga puntual horizontal de izquierda a derecha de 100

Kgf a todos los nudos de la cara lateral izquierda (a excepción del apoyo) del pórtico. Asígnese

83

una carga rectangular distribuida de 150 Kgf/m en dirección de la gravedad a todas las vigas

pórtico. Asígnese un apoyo empotrado a cada nudo inferior de la planta baja de la estructura.

Solución

Se debe crear un archivo de entrada con un software para hojas electrónicas CSV como

Microsoft Excel.

Primero, se introduce un metadato de campo DESCRIPCION DE LA ESTRUCTURA y luego

un título para la estructura como ser “edificacion 8 plantas”.

Segundo, se introduce un metadato COORDENADAS DE LOS NUDOS; luego, se elige un

origen para el sistema global de coordenadas XY de la estructura como ser en el nudo 1 de la

figura 51. A continuación se introducen las coordenadas X e Y de los nudos 1 a 36.

Tercero, se introduce un metadato ELEMENTOS TIPO y abajo se coloca “portico” para

indicar que los elementos de la estructura se corresponden con un pórtico (marco rígido

plano).

Cuarto, se ingresa un metadato PROPIEDADES DE LOS ELEMENTOS; seguidamente, se

introducen las incidencias para los 56 elementos: nudo inicial, nudo final, módulo de

elasticidad, momento de inercia y área de la sección. Se introducen los elementos en un

orden de abajo hacia arriba empezando por las vigas y continuando con las columnas. Véase

las figuras 51 y 52.

Nota.- La forma en la cual se numeran los nudos y crean los elementos tiene repercusión en

la dispersión de los valores de la matriz de rigidez de la estructura. Se ha recomendado

siempre realizar la numeración de nudos e incidencias de los elementos de tal manera que se

forme una banda centrada en la diagonal de la matriz de rigidez de la estructura.

Antiguamente, debido a limitaciones en capacidad de cómputo, era requisito cuidar la

numeración de nudos e incidencias durante el modelado de la estructura. Actualmente,

puede considerarse un factor de elegancia.

Quinto, se ingresa un metadato CARGAS EN LOS NUDOS y se introducen las cargas

puntuales aplicadas en los nudos: 5, 9, 13, 17, 21, 25, 29 y 33. Ver figura 52. Recuerde que,

se introduce primero la componente horizontal de la carga, luego la vertical y finalmente la

carga de momento flector.

84

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

nudos del pórtico.

Figura 52. Vista en perspectiva de la asignación

de cargas puntuales y distribuidas del pórtico.

Sexto, colóquese un metadato CARGAS EN LOS ELEMENTOS e introdúzcase las cargas distribuidas

sobre las vigas en éste orden: número de elemento, tipo de carga, inicio de aplicación de carga (a),

longitud de aplicación de carga (b), componente horizontal de carga, componente vertical de carga y

momento flector. La figura 53 muestra los códigos para los diversos tipos de carga que pueden

soportar los elementos. En éste trabajo de investigación la aplicación desarrollada soporta cargas

puntuales y cargas distribuidas rectangulares (1 y 2). La inclusión de los tipos de carga 3 a 6 es factible

gracias a que el modelo OO propuesto se brinda a ésta extensibilidad.

Séptimo, ingrese un metadato APOYOS para describir las condiciones de contorno de la estructura.

Abajo colóquese primero el número de nudo que corresponde al apoyo, luego la restricción al

desplazamiento horizontal del nudo, al desplazamiento vertical y finalmente la restricción al giro.

85

Cuando exista restricción en alguna dirección solo se coloca 1 (uno) y 0 (cero) cuando no. Nótese que

para el problema en cuestión, los nudos 1 al 4 están completamente restringidos.

Finalmente, guárdese la hoja electrónica en formato de archivo de valores separados por comas o CSV

(comma separated values). Elíjase un nombre descriptivo que represente bien a la estructura porque los

archivos CSV resultantes del análisis se basarán en el nombre del archivo de entrada.

La información de entrada de la estructura de la figura 51 ha sido guardada como “edificio08”. La

siguiente página muestra cómo debiera quedar la hoja electrónica de introducción de la estructura.

Con relación a la introducción del pórtico en cuestión en el programa SAP2000, se sigue el mismo

procedimiento y orden aunque todo puede llevarse a cabo por medio de una interfaz gráfica muy

elaborada.

1

2

3

5

6

Figura 53. Códigos para tipos de cargas.

87

Análisis y Resultados

Al ejecutar la aplicación, ésta primero recupera el archivo CSV de entrada de la

estructura y en caso de que la información haya sido correctamente ingresada, se

muestra una gráfica para la verif icación de la geometría de la es tructura. Las

figuras 54 y 55 comparan las capturas de pantalla de la verif icación geométrica en

uno y otro programa.

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

según la aplicación desarrollada en ésta

investigación.

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

según la aplicación SAP2000.

A continuación, la aplicación calcula la estructura y va guardando archivos CSV de

resultados numéricos a medida del progreso del proceso. Los nombres de los

archivos de sal ida CSV empiezan con el nombre del archivo de entrada y llevan un

sufi jo según el contenido que almacenan.

88

Sufijo de nombre de archivo Contenido del archivo CSV de salida

(K) Matriz de rigidez de la estructura.

(P) Vector generalizado de fuerza.

(D) Vector generalizado de desplazamientos.

(fint) Fuerzas internas en los extremos de los elementos.

(reacciones) Reacciones en los apoyos de la estructura.

( )r Matriz o vector reducida(o).

Nota.- Una matriz o vector reducido(a) es una matriz o vector luego de la aplicación de las condiciones

de contorno.

Recuerde que, cada ecuación del sistema de ecuaciones simultáneas de una estructura, corresponde a

cada grado de libertad de la misma. Esta estructura tiene 36 nudos y cada nudo tiene 3 grados de

libertad (i. e. desplazamiento horizontal, vertical y rotacional) por lo tanto su sistema es de 108

ecuaciones.

Parte de la matriz global de rigidez de ésta estructura se muestra en la página anterior. La matriz

global de rigidez K es cuadrada, tiene 108 filas, 108 columnas, y es simétrica conforme dicta una de

sus propiedades. Estos resultados intermedios y otros pueden encontrarse en los archivos CSV de

salida.

Cuando concluye el análisis estructural aparece una ventana con una gráfica de la deformada de la

estructura. Esto se muestra en las figuras 56 y 57. Nótese que, la gráfica de la deformada de la figura

56 es más exagerada que la figura 57; no obstante, ambas reflejan un mismo comportamiento de la

estructura bajo las condiciones de carga.

Los resultados más importantes del análisis son: las fuerzas internas en los extremos de los elementos y

las reacciones en los apoyos. Esta información también es útil para verificar manualmente el equilibrio

de la estructura.

89

4444

4.4

0.0

-666

66.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-444

44.4

0.0

-666

66.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

333.

30.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

0-3

33.3

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-666

66.7

0.0

1333

33.3

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

6666

6.7

0.0

6666

6.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

4444

4.4

0.0

-666

66.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-444

44.4

0.0

-666

66.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

333.

30.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

0-3

33.3

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-666

66.7

0.0

1333

33.3

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

6666

6.7

0.0

6666

6.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

4444

4.4

0.0

-666

66.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-444

44.4

0.0

-666

66.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

333.

30.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

0-3

33.3

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-666

66.7

0.0

1333

33.3

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

6666

6.7

0.0

6666

6.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

4444

4.4

0.0

-666

66.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-444

44.4

0.0

-666

66.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

333.

30.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

0-3

33.3

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-666

66.7

0.0

1333

33.3

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

6666

6.7

0.0

6666

6.7

0.0

0.0

0.0

-444

44.4

0.0

6666

6.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

8913

8.9

0.0

0.0

-250

.00.

00.

00.

00.

00.

00.

00.

00.

0-4

4444

.40.

0-6

6666

.70.

0-3

33.3

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

1941

6.7

3750

0.0

0.0

-187

50.0

3750

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-333

.30.

0-6

6666

.70.

066

666.

70.

00.

00.

00.

00.

00.

00.

00.

00.

00.

037

500.

036

6666

.70.

0-3

7500

.050

000.

00.

00.

00.

00.

00.

00.

066

666.

70.

066

666.

70.

00.

00.

0-4

4444

.40.

066

666.

70.

00.

00.

00.

00.

00.

0-2

50.0

0.0

0.0

8938

8.9

0.0

0.0

-250

.00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

0-3

33.3

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-187

50.0

-375

00.0

0.0

3816

6.7

0.0

0.0

-187

50.0

3750

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-666

66.7

0.0

6666

6.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

3750

0.0

5000

0.0

0.0

0.0

4666

66.7

0.0

-375

00.0

5000

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-444

44.4

0.0

6666

6.7

0.0

0.0

0.0

0.0

0.0

0.0

-250

.00.

00.

089

388.

90.

00.

0-2

50.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-333

.30.

00.

00.

00.

00.

00.

00.

00.

0-1

8750

.0-3

7500

.00.

038

166.

70.

00.

0-1

8750

.037

500.

00.

00.

00.

00.

00.

00.

00.

00.

00.

0-6

6666

.70.

066

666.

70.

00.

00.

00.

00.

00.

00.

037

500.

050

000.

00.

00.

046

6666

.70.

0-3

7500

.050

000.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

0-4

4444

.40.

066

666.

70.

00.

00.

00.

00.

00.

0-2

50.0

0.0

0.0

8913

8.9

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-333

.30.

00.

00.

00.

00.

00.

00.

00.

0-1

8750

.0-3

7500

.00.

019

416.

7-3

7500

.00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

0-6

6666

.70.

066

666.

70.

00.

00.

00.

00.

00.

00.

037

500.

050

000.

00.

0-3

7500

.036

6666

.70.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

0-4

4444

.40.

066

666.

70.

00.

00.

00.

00.

00.

00.

00.

00.

089

138.

90.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

0-3

33.3

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

1941

6.7

3750

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-666

66.7

0.0

6666

6.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

3750

0.0

3666

66.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-444

44.4

0.0

6666

6.7

0.0

0.0

0.0

0.0

0.0

0.0

-250

.00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

0-3

33.3

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-187

50.0

-375

00.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-666

66.7

0.0

6666

6.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

3750

0.0

5000

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-444

44.4

0.0

6666

6.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-333

.30.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

0-6

6666

.70.

066

666.

70.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

0-4

4444

.40.

066

666.

70.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

0-3

33.3

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-666

66.7

0.0

6666

6.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-444

44.4

0.0

6666

6.7

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

0.0

-333

.30.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

0-6

6666

.70.

066

666.

70.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

00.

0

MAT

RIZ

GLO

BAL

DE

RIG

IDEZ

K P

ARA

LA E

STR

UC

TUR

A PO

RTI

CO

DE

8 PL

ANTA

S D

EL C

ASO

DE

ESTU

DIO

- F

ILAS

1 A

54

- CO

LUM

NAS

1 A

27

90

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

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

Figura 57. Deformada del pórtico luego del

análisis mediante la aplicación SAP2000.

Como puede apreciarse en las figuras 58 y 59, los resultados de las fuerzas internas en los extremos de

los elementos producidos por la aplicación de ésta investigación, son en valor absoluto exactamente

iguales a aquellos correspondientes producidos por el SAP2000. La diferencia radica precisamente en

la mejora que propone el modelo de ésta investigación: corregir la dirección para cada componente de

las fuerzas internas.

Los resultados de las fuerzas internas del programa SAP2000 versión 15 (año 2011) y de muchos otros

programas de calibre profesional siempre se han basado, como se dijo, en un sistema de ejes locales del

tipo tradicional (véase la figura 7) para ambos extremos de los elementos. La desventaja de este

enfoque simplificado consiste en que la dirección de las componentes de las fuerzas internas puede

muchas veces no coincidir con la concepción correcta de las solicitaciones de tensión y compresión a

las cuales están sometidos los elementos. Esto, a su vez, sin la adecuada interpretación y modificación

del ingeniero, puede implicar un diseño incorrecto de las dimensiones o refuerzos de los elementos de

una estructura; lo cual a su vez, puede derivar en sistemas estructurales de dudoso factor de seguridad o

de diseño contrario al lado de la seguridad.

91

Figura 58. Fuerzas internas por el programa propuesto. Figura 59. F. internas producidas por el SAP2000.

E. Pxi Pyi Mzi Pxj Pyj Mzj1 -7.73 -418.30 25.37 -7.73 181.70 447.812 -3.58 -266.58 -148.93 -3.58 333.42 15.253 -1.69 -129.70 -265.55 -1.69 470.30 -415.644 -22.50 -423.99 -54.15 -22.50 176.01 550.095 -13.37 -268.36 -277.95 -13.37 331.64 151.406 -6.39 -128.08 -345.25 -6.39 471.92 -342.427 -38.03 -428.75 -30.85 -38.03 171.25 545.868 -25.89 -272.60 -319.88 -25.89 327.40 210.299 -12.86 -130.10 -382.67 -12.86 469.90 -296.94

10 -52.52 -433.11 15.40 -52.52 166.89 517.0211 -39.48 -277.41 -330.66 -39.48 322.59 240.2912 -20.34 -133.06 -402.03 -20.34 466.94 -265.7513 -65.79 -437.14 54.40 -65.79 162.86 494.1414 -53.71 -282.38 -340.91 -53.71 317.62 270.4215 -28.54 -136.50 -418.51 -28.54 463.50 -235.4916 -78.25 -440.89 76.68 -78.25 159.11 486.8617 -68.82 -287.38 -364.37 -68.82 312.62 313.9118 -37.55 -140.26 -439.80 -37.55 459.74 -199.1819 -90.42 -444.30 83.13 -90.42 155.70 494.0620 -85.27 -292.36 -401.57 -85.27 307.64 371.0121 -47.54 -144.32 -465.61 -47.54 455.68 -157.1022 -102.68 -447.08 81.62 -102.68 152.92 506.7023 -103.28 -297.12 -437.61 -103.28 302.88 426.1024 -58.53 -148.76 -485.82 -58.53 451.24 -119.1425 -3473.54 -342.09 3162.57 -3473.54 -342.09 -2136.3126 -3055.24 -249.82 2110.93 -3055.24 -249.82 -1361.4827 -2631.26 -172.31 1415.63 -2631.26 -172.31 -898.6928 -2202.50 -110.35 929.54 -2202.50 -110.35 -598.5029 -1769.40 -62.87 583.10 -1769.40 -62.87 -394.4930 -1332.26 -28.66 340.09 -1332.26 -28.66 -254.1131 -891.37 -6.91 177.43 -891.37 -6.91 -156.7132 -447.08 2.68 73.59 -447.08 2.68 -81.6233 -3570.65 -64.49 2197.89 -3570.65 -64.49 -2004.4134 -3122.37 -60.35 1705.52 -3122.37 -60.35 -1524.4835 -2677.99 -51.22 1252.34 -2677.99 -51.22 -1098.6836 -2234.14 -39.08 872.70 -2234.14 -39.08 -755.4637 -1789.85 -26.04 569.10 -1789.85 -26.04 -490.9938 -1344.61 -13.96 337.76 -1344.61 -13.96 -295.8639 -898.11 -4.54 173.38 -898.11 -4.54 -159.7540 -450.04 0.61 67.26 -450.04 0.61 -69.0841 -3646.58 -179.98 1995.00 -3646.58 -179.98 -1455.0542 -3183.46 -178.09 1705.35 -3183.46 -178.09 -1171.1043 -2723.74 -171.11 1364.95 -2723.74 -171.11 -851.6344 -2266.25 -158.08 1024.01 -2266.25 -158.08 -549.7845 -1810.60 -138.93 711.52 -1810.60 -138.93 -294.7346 -1356.47 -113.76 442.82 -1356.47 -113.76 -101.5447 -903.60 -82.49 227.43 -903.60 -82.49 20.0448 -451.64 -44.76 74.56 -451.64 -44.76 59.7249 -3709.22 -213.44 1878.57 -3709.22 -213.44 -1238.2650 -3238.93 -211.75 1653.90 -3238.93 -211.75 -1018.6551 -2767.01 -205.36 1361.07 -2767.01 -205.36 -744.9952 -2297.10 -192.50 1041.94 -2297.10 -192.50 -464.4553 -1830.16 -172.16 730.20 -1830.16 -172.16 -213.7254 -1366.66 -143.62 449.20 -1366.66 -143.62 -18.3555 -906.92 -106.06 217.53 -906.92 -106.06 100.6656 -451.24 -58.53 56.43 -451.24 -58.53 119.14

Element Forces - FramesP V2 M3

Kgf Kgf Kgf-m1 -7.73 -418.3 -25.371 -7.73 181.7 447.812 -3.58 -266.58 148.932 -3.58 333.42 15.253 -1.69 -129.7 265.553 -1.69 470.3 -415.644 -22.5 -423.99 54.154 -22.5 176.01 550.095 -13.37 -268.36 277.955 -13.37 331.64 151.46 -6.39 -128.08 345.256 -6.39 471.92 -342.427 -38.03 -428.75 30.857 -38.03 171.25 545.868 -25.89 -272.6 319.888 -25.89 327.4 210.299 -12.86 -130.1 382.679 -12.86 469.9 -296.9410 -52.52 -433.11 -15.410 -52.52 166.89 517.0211 -39.48 -277.41 330.6611 -39.48 322.59 240.2912 -20.34 -133.06 402.0312 -20.34 466.94 -265.7513 -65.79 -437.14 -54.413 -65.79 162.86 494.1414 -53.71 -282.38 340.9114 -53.71 317.62 270.4215 -28.54 -136.5 418.5115 -28.54 463.5 -235.4916 -78.25 -440.89 -76.6816 -78.25 159.11 486.8617 -68.82 -287.38 364.3717 -68.82 312.62 313.9118 -37.55 -140.26 439.818 -37.55 459.74 -199.1819 -90.42 -444.3 -83.1319 -90.42 155.7 494.0620 -85.27 -292.36 401.5720 -85.27 307.64 371.0121 -47.54 -144.32 465.6121 -47.54 455.68 -157.122 -102.68 -447.08 -81.6222 -102.68 152.92 506.723 -103.28 -297.12 437.6123 -103.28 302.88 426.124 -58.53 -148.76 485.8224 -58.53 451.24 -119.1425 -3473.54 342.09 3162.5725 -3473.54 342.09 2136.3126 -3055.24 249.82 2110.9326 -3055.24 249.82 1361.4827 -2631.26 172.31 1415.6327 -2631.26 172.31 898.6928 -2202.5 110.35 929.5428 -2202.5 110.35 598.5

Element Forces - FramesP V2 M3

Kgf Kgf Kgf-m29 -1769.4 62.87 583.129 -1769.4 62.87 394.4930 -1332.26 28.66 340.0930 -1332.26 28.66 254.1131 -891.37 6.91 177.4331 -891.37 6.91 156.7132 -447.08 -2.68 73.5932 -447.08 -2.68 81.6233 -3570.65 64.49 2197.8933 -3570.65 64.49 2004.4134 -3122.37 60.35 1705.5234 -3122.37 60.35 1524.4835 -2677.99 51.22 1252.3435 -2677.99 51.22 1098.6836 -2234.14 39.08 872.736 -2234.14 39.08 755.4637 -1789.85 26.04 569.137 -1789.85 26.04 490.9938 -1344.61 13.96 337.7638 -1344.61 13.96 295.8639 -898.11 4.54 173.3839 -898.11 4.54 159.7540 -450.04 -0.61 67.2640 -450.04 -0.61 69.0841 -3646.58 179.98 199541 -3646.58 179.98 1455.0542 -3183.46 178.09 1705.3542 -3183.46 178.09 1171.143 -2723.74 171.11 1364.9543 -2723.74 171.11 851.6344 -2266.25 158.08 1024.0144 -2266.25 158.08 549.7845 -1810.6 138.93 711.5245 -1810.6 138.93 294.7346 -1356.47 113.76 442.8246 -1356.47 113.76 101.5447 -903.6 82.49 227.4347 -903.6 82.49 -20.0448 -451.64 44.76 74.5648 -451.64 44.76 -59.7249 -3709.22 213.44 1878.5749 -3709.22 213.44 1238.2650 -3238.93 211.75 1653.950 -3238.93 211.75 1018.6551 -2767.01 205.36 1361.0751 -2767.01 205.36 744.9952 -2297.1 192.5 1041.9452 -2297.1 192.5 464.4553 -1830.16 172.16 730.253 -1830.16 172.16 213.7254 -1366.66 143.62 449.254 -1366.66 143.62 18.3555 -906.92 106.06 217.5355 -906.92 106.06 -100.6656 -451.24 58.53 56.4356 -451.24 58.53 -119.14

92

Por ejemplo, el elemento central localizado entre los nudos 18 y 22 viene a ser la columna 37 que de

acuerdo a las figuras 60 y 61 sufre las siguientes fuerzas internas en sus extremos:

Figura 7. Sistemas de ejes locales: (a)

tradicional (b) Kardestuncer.

Figura 60. Fuerzas

internas de la columna 37

según el SAP2000.

Figura 61. Fuerzas

internas de la columna

37 según el modelo

propuesto.

Los resultados del SAP2000 se pueden representar como en la figura 60 ya que el SAP2000 está

basado en la teoría estructural correspondiente al sistema tradicional de ejes locales de la figura 7a.

Nótese que el sistema de fuerzas ni siquiera aparenta estar en equilibrio. Además, según los resultados

numéricos de la figura 59, las solicitaciones axiales en ambos extremos del elemento son de

compresión; sin embargo, según la representación de la figura 60, el extremo j (inferior) aparenta estar

en tensión. Por todo esto, los resultados basados en un solo sistema de ejes locales para ambos

extremos de los elementos, pueden ser confusos y requerir casi siempre una adecuada interpretación y

modificación de la dirección de las fuerzas.

Los resultados producidos por la aplicación basada en el modelo OO de ésta investigación se grafican

en la figura 61 ya que están basados en el sistema de ejes locales Kardestuncer (véase figura 7b).

Nótese que el sistema de fuerzas se fundamenta por sí mismo demostrando estar en equilibrio. Además

ambos extremos del elemento claramente se ven sufriendo compresión tal cual dictan los resultados

numéricos del análisis. En fin, las fuerzas axiales, cortantes y momentos flectores en ambos extremos

del elemento, se manifiestan en la dirección correcta y no dan lugar a ninguna confusión ni requieren

569 Kgf*m

1790 Kgf

1790 Kgf

491 Kgf*m

26 Kgf

26 Kgf

569 Kgf*m

1790 Kgf

1790 Kgf

491 Kgf*m

26 Kgf

26 Kgf

93

modificación alguna. La figura 61 demuestra el aporte del modelo OO propuesto en ésta

investigación.

Los resultados de las reacciones en los apoyos de la estructura se muestran en las figuras 62 y 63.

Figura 62. Reacciones en los apoyos

calculadas por la aplicación propuesta.

Figura 63. Reacciones en los apoyos calculadas

por el programa SAP2000.

Las reacciones en los apoyos siempre se referencian al sistema de ejes de coordenadas

generales. Junto a los valores de las reacciones se muestra el sistema de ejes generales

XYZ sobre el cual ha sido referenciado el pórtico en cuestión en cada aplicación.

Nótese que, al tomar en cuenta el sistema de ejes correspondiente, los valores de

momento flector son exactamente los mismos para ambos casos.

Verificación Manual de Resultados

El hecho de que ambos programas hayan producido los mismos resultados (cada uno

según su sistema de coordenadas global y local) aparentemente debería bastar para

confirmar que el análisis estructural fue llevado a cabo correctamente; no obstante, es

recomendable siempre realizar una verificación manual de los resultados.

Recuerde que la verificación manual del análisis estructural consiste en: 1) Elegir un

nudo al azar y realizar la comprobación de equilibrio de las fuerzas internas/externas

que concurren al nudo. 2) Realizar la sumatoria de las fuerzas externas aplicadas

incluyendo las reacciones. Para verificar el equilibrio la suma debe ser igual a 0

(cero).

Nudo Rx Ry Mz1 -342.09 3473.54 3162.572 -64.49 3570.65 2197.893 -179.98 3646.58 1995.004 -213.44 3709.22 1878.57

X

Y

Z

TABLE: Joint Reactions

Joint F1 F3 M2

Text Kgf Kgf Kgf‐m

1 ‐342.09 3473.54 ‐3162.57

2 ‐64.49 3570.65 ‐2197.89

3 ‐179.98 3646.58 ‐1995

4 ‐213.44 3709.22 ‐1878.57

X

Z

Y

94

El nudo elegido para comprobar el equilibrio es el nudo 22. Se usa una tabla para

recopilar, ordenar, descomponer y sumar las fuerzas que concurren al nudo 22:

Concurren al nudo 22 Horizontal Vertical

Elemento 13 -65.79 +162.86

Elemento 14 +53.71 +282.38

Elemento 37 +26.04 -1789.85

Elemento 38 -13.96 +1344.61

Suma 0.00 0.00

Se ha verif icado exitosamente el equil ibrio en el nudo 22 de la estructura lo cual

indica que el modelo y su implementación ( i . e. el programa) están produciendo

resultados correctos con relación a las fuerzas internas en los extremos de los

elementos.

Ahora bien, la tabla para la verificación del equilibrio de las componentes

horizontal y vertical de las fuerzas externas y reacciones que actúan en la estructura

es la siguiente:

Descripción Horizontal Vertical

Carga externa nudo 5 a 13 +800.00 0.00

Carga externa elementos 1 a 24 0.00 -14400.00

Reacción apoyo 1 -342.09 +3473.54

Reacción apoyo 2 -64.49 +3570.65

Reacción apoyo 3 -179.98 +3646.58

Reacción apoyo 4 -213.44 +3709.22

Sumatoria 0.00 0.00

95

3.8.3 OtrasConsideraciones

Las figuras 64 y 65 comparan el código para el cálculo de las reacciones en los apoyos escrito en

FORTRAN y Java, respectivamente.

Aunque el FORTRAN se caracteriza por su potencia en los cálculos matemáticos, el orden de

instrucciones debe ser secuencial; es decir, la programación del algoritmo debe ser lineal. Para

producir cualquier alteración del orden de la lógica, se usa la instrucción GOTO. Sigue un modelo de

programación procedimental de contexto global.

En el paradigma OO un módulo cohesivo ejecuta una tarea sencilla y requiere poca interacción con

procedimientos que ejecutan otras partes del programa.

Interesa un cohesión alta y un acoplamiento bajo. El acoplamiento es la medida de la interconexión

entre módulos de un programa.

La independencia funcional se adquiere desarrollando módulos con una clara función evitando una

excesiva interacción con otros módulos. Este concepto está derivado de la abstracción y el

ocultamiento de información.

En Java la unidad fundamental de programación es la clase. Nótese que el código Java de la figura 65

se distinguen objetos y conceptos OO como ser: clases, abstracción, ocultamiento, polimorfismo,

constructores, métodos, etc.

Los sistemas OO son más fáciles de adaptar y escalar (pueden crearse grandes sistemas ensamblando

sistemas reutilizables).

Complejidad Ciclomática

La complejidad ciclomática determina la complejidad de un código estructurado (cíclico). Cuántos

más caminos el código pueda tomar (ya sea por medio de condiciones o bucles), mayor es la cantidad

de pruebas necesarias.

Por ejemplo, en programación estructurada, el código para ensamblar la matriz de rigidez de la

estructura, bien podría estar representado según se muestra en la figura 66.

96

Figura 64. Código FORTRAN.

Figura 65. Código Java.

97

Figura 66. Código JavaScript

Mientras que, en programación OO, el código para ensamblar la matriz de rigidez de la estructura se

muestra en la figura 67.

Figura 67. Código Java.

Nótese que, en programación estructurada se requieren de 3 ciclos anidados explícitos

para ensamblar la matriz de rigidez de una estructura; mientras que, en la programación

OO del modelo propuesto en ésta investigación, se requiere de un solo bucle explícito

de cálculo. Lo mismo sucede con el ensamblado del vector fuerza generalizado y con

el vector desplazamiento generalizado de la estructura. Por consiguiente, el modelo OO

propuesto en ésta investigación minimiza la cantidad de ciclos anidados explícitos de

cálculo.

En lo que respecta al cálculo de los resultados del análisis estructural como el cálculo

de las fuerzas internas en los extremos de los elementos, en un lenguaje estructurado

como el JSCRIPT se necesitan 5 bucles anidados para hallar el vector de las fuerzas

internas en el extremo i del elemento ij (véase figura 66a).

98

Figura 66a. Código JSCRIPT.

En el lenguaje Java a partir de la implementación del modelo OO propuesto, el cálculo de las fuerzas

internas en ambos extremos de los elementos necesita tan solo de un bucle (véase figura 67a).

Figura 67a. Código Java.

Comparación de Tiempo de Cómputo

Para comparar el tiempo de cómputo resultante de la implementación del modelo OO

propuesto, se ha comparado los tiempos de análisis estructural de estructuras

representativas empleando la aplicación de ésta investigación versus una aplicación

basada en la misma teoría estructural pero programada en el lenguaje científico

estructurado RPL (Reverse Polish Language) por el mismo autor de ésta investigación.

99

Plataforma Hardware

Máquina: Dell Optiplex 380 X86-Based PC

Procesador: Intel Core 2 Quad @ 2.66 GHZ

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

Plataforma Software

Sistema Operativo: MS Windows 7 Pro

Máquina Virtual Java: v. 6

Lenguaje RPL: HP48-R v. 1.41

La geometría de las estructuras que fueron objeto para la comparación de tiempo de cómputo

se muestran en la parte superior de la siguiente tabla. Los tiempos mostrados son tiempos

promedios calculados de un conjunto de tiempos tomados durante el análisis.

Reticulado o grilla Pórtico o marco plano Cercha o armadura

Nudos 4 5 11

Elementos 3 4 19

Ecuaciones 12 15 33

Tiempo

RPL

421 ms 527 ms 2069 ms

Tiempo

Java

16 ms 15 ms 53 ms

IEC(*) 96% 97% 97%

(*) Incremento en la eficiencia de cómputo.

El tiempo consumido por la aplicación programada en lenguaje estructurado como el RPL es

notoriamente mayor al tiempo consumido por la aplicación programada bajo el modelo OO

de ésta investigación. Además la complejidad ciclomática de la aplicación RPL hace que el

100

tiempo para el análisis de estructuras más complejas como la cercha sea exponencialmente

mayor. Ahora bien, los tiempos consumidos para estructuras simples empleando la

aplicación OO de ésta investigación, son casi iguales en el rango de los milisegundos; sin

embargo para estructuras más complejas como la cercha el tiempo es mayor pero no

exponencialmente mayor. La complejidad ciclomática que involucra ciclos anidados

explícitos de cálculo eleva notoriamente los tiempos consumidos en lenguaje estructurado.

Complejidad de Algoritmos

¿Cuándo proporciona un algoritmo una solución satisfactoria a un problema? Primero, debe

producir siempre la respuesta correcta. Segundo, deberá ser eficiente.

¿Cómo se puede analizar la eficiencia de los algoritmos? Una medida de eficiencia es el

tiempo que requiere un ordenador para resolver un problema utilizando un algoritmo para

valores de entrada de un tamaño específico.

Un análisis del tiempo requerido para resolver un problema de un tamaño particular está

relacionado con la complejidad en tiempo del algoritmo y un análisis de la memoria de

ordenador requerida involucra la complejidad en espacio del algoritmo. Obviamente, es

importante saber si un algoritmo producirá su respuesta en un milisegundo, en un minuto o

en un millón de años y de manera similar debemos tener suficiente memoria disponible para

poder resolver el problema.

La complejidad del algoritmo se denota según la notación Big-O.

Por ejemplo, O(n) significa que el algoritmo tiene una complejidad lineal. En otras palabras,

toma 10 veces más tiempo en operar un set de 100 datos que en hacerlo con un set de 10

ítems. Si la complejidad fuera O(n2) entonces tomaría 100 veces más tiempo en operar 100

ítems que en hacerlo con 10.

Complejidad Terminología

O(1) Complejidad constante

O(log n) Complejidad logarítmica

O(n) Complejidad lineal

101

O(n log n) Complejidad n log n

O(n^b) Complejidad polinómica

O(b^n) Complejidad exponencial

O(n!) Complejidad factorial

El enfoque empleado para medir la complejidad de un algoritmo será un enfoque

empírico o a posteriori: 1) Se ejecutará el programa con entradas de tamaño y

composición variadas. 2) Se usará un comando para obtener una medida exacta del

t iempo de ejecución real . 3) Se trazarán los resultados

El estudio a posteriori permite hacer una evaluación experimental de los recursos

consumidos que no es posible en un estudio a priori .

Interesa el comportamiento de un algoritmo para tal las relativamente grandes:

complej idades asintóticas. Se ha comparado los t iempos de ejecución del análisis

estructural de pórticos de edificios de varios pisos (véase figura 70). El hardware y

software empleados son los mismos que en el anterior apartado. N es la tal la o bien

la medida del tamaño del problema y ha sido asociada al número de elementos

estructurales que componen cada pórt ico. El t iempo de ejecución es T(N). Los

resultados se muestran a continuación. La aplicación RPL ha quedado sin memoria

para un pórtico de 7 pisos.

* T(N) medida en milisegundos

Plantas Nudos Elementos (N) T1(N) T2(N) T3(N) T(N) Medio T1(N) T2(N) T3(N) T(N) Medio

1 8 7 913 912 924 916 30 29 27 292 12 14 1905 1980 1898 1928 51 49 47 493 16 21 3070 3047 3107 3075 60 62 64 624 20 28 4416 4493 4512 4474 75 74 74 745 24 35 6037 6018 6016 6024 90 90 92 916 28 42 8024 8070 8036 8043 105 102 103 1037 32 49 126 120 123 123

Aplicación RPL Aplicación Java

102

Para apreciar gráficamente la tendencia de la complejidad temporal de cada algoritmo, se ha graficado

los resultados en las curvas de a continuación:

Figura 68. Complejidad del algoritmo

procedimental programado en RPL.

Figura 69. Complejidad del algoritmo resultante del

modelo OO de la aplicación en Java.

De las curvas, se puede deducir que, las estructuras pueden resolverse con distintos grados de

eficiencia.

Se ha realizado el ajuste de curvas para determinar las ecuaciones que gobiernan ambas curvas. Las

ecuaciones resultantes y el coeficiente de relación se muestran a continuación:

Para la curva de la figura 68: Para la curva de la figura 69:

Ecuación: 83.9871 . Ecuación: 15.8095

2.1446

Correlación: 0.9979 Correlación: 0.9977

Orden de

complejidad:

potencial Orden de

complejidad:

lineal

0

1000

2000

3000

4000

5000

6000

7000

8000

9000

0 20 40 60

T(N

) m

ilis

eg

un

do

s

N elementos

0

20

40

60

80

100

120

140

0 20 40 60

T(N

) m

ilis

eg

un

do

s

N elementos

103

Dado que un orden de complejidad lineal implica un algoritmo más eficiente que uno potencial, se

prueba la hipótesis de la mejora de eficiencia de cómputo con el modelo OO propuesto en ésta

investigación.

Hay que elegir siempre algoritmos con el menor orden de complejidad.

Figura 70. Pórticos de varios pisos empleados para el cálculo del orden de complejidad.

104

Parte4–ConclusionesyRecomendaciones

Las estructuras de ingeniería tienen un rol de servicio importante en el Mundo. Una estructura debe

cumplir su misión con resistencia y rigidez.

El análisis estructural se usa para diseñar estructuras. El análisis determina la deformada de la

estructura para verificar si es adecuada para sus cargas de diseño.

El método de los elementos finitos MEF es para simular sistemas de ingeniería en computadora. El

MEF consiste en: elegir un elemento para el modelado, aplicar un proceso para lograr un modelo

global y resolver el sistema de ecuaciones de la estructura.

El método de la matriz de rigidez es el proceso que requiere el MEF al tratar con estructuras. El

método de la rigidez establece la relación entre las cargas externas y los desplazamientos de una

estructura.

Los marcos rígidos planos o pórticos son estructuras 2D cuyas cargas externas están en el mismo

plano. Las cerchas pueden modelarse como marcos planos manteniendo la inercia de sus elementos

casi cero.

Un solo sistema de ejes locales para ambos extremos de un elemento estructural es una opción

simplificada que se ha usado siempre pero que no conviene porque puede inducir a ambigüedades en

la interpretación de los resultados del análisis. El sistema de ejes locales Kardestuncer es mejor porque

provee un sistema de ejes locales para cada extremo de los elementos de una estructura.

Los objetos resuelven los problemas de la programación procedimental al combinar datos y

comportamiento en un solo paquete encapsulado.

Los objetos son estructuras de datos que permiten la reutilización que conduce a un desarrollo rápido

de software.

El análisis y diseño orientado a objetos OO está basado en conceptos como: clases, encapsulación,

ocultamiento, interfaz, implementación, herencia, superclases, subclases, abstracción, polimorfismo,

composición, persistencia, clases abstractas, interfaces java, etc.

El objetivo del análisis OO es producir las clases relevantes al problema que se va a resolver. El

diseño OO transforma el modelo del análisis en un modelo que sirve para el desarrollo de software.

105

El UML es un lenguaje para el modelado OO consistente en diagramas que proporcionan diferente

vistas del modelo OO. El UML es una herramienta para generar y comunicar diseños entre creadores

de sistemas.

Las metodologías de desarrollo consisten en pasos estructurados y de distinta naturaleza. Todas son

una mejora de la interacción entre las etapas: análisis, diseño, codificación y distribución.

Debido a las computadoras el MEF ha sido ampliamente como herramienta de modelado y simulación

de sistemas en ingeniería. Los programas tradicionales siempre han consistido en miles de líneas de

código dificultoso de leer, escribir y mantener en lenguajes procedimentales...

El estado del arte revela nuevos tipos de elementos finitos, esquemas matriciales, modelos generales

OO, aplicaciones de análisis no-lineal, algoritmos de computación evolutiva de diseño estructural con

modelos OO para análisis plástico no-lineal, optimización estructural, plataformas OO para MEF

multipropósito, modelos OO para problemas MEF 3D mediante computación distribuida, librerías

matemáticas para aplicaciones OO de MEF, etc.

El diseño del modelo OO propuesto en ésta investigación emerge de una declaración de trabajo a partir

de la cual se realiza un análisis de requerimientos para poder diseñar las distintas vistas del modelo OO

usando UML.

En los casos de uso se distinguen dos actores: el sistema y el usuario. Del análisis de requerimientos,

los sustantivos se convierten en clases y los verbos en operaciones de los objetos. El modelo OO

resultante está basado en conceptos OO puros como: clases, encapsulación, herencia, superclases,

subclases, abstracción, polimorfismo, composición, clases abstractas, interfaces java, etc. Lo cual

prueba que la naturaleza del análisis estructural mediante el MEF - elemento viga sistema ejes locales

Kardestuncer, es absolutamente orientada a objetos.

El diseño del modelo OO propuesto permite el desarrollo de una aplicación robusta, eficiente y

escalable. La implementación debe cumplir con conceptos fundamentales de la programación OO

como los getters y setters que administran el ocultamiento en una clase. La implementación se la

realizó en Java; sin embargo, el modelo puede programarse en otro lenguaje de objetos como:

Smalltalk, Eiffel, C++, Python, etc.

Los casos de estudio probaron la factibilidad y las ventajas del modelo OO propuesto en cuanto a

concepto y resultados. En cuanto a conceptos porque el modelo mejora las fuerzas internas en los

extremos de los elementos conforme Kardestuncer. En cuanto a resultados porque las verificaciones

manuales basadas en conceptos fundamentales de equilibrio estructural, prueban la exactitud del

modelo y su implementación.

106

Finalmente, hay mejoras que realizar en el modelo OO como la inclusión de cargas distribuidas

triangulares sobre los elementos, apoyos elásticos, etc., en virtud de probar la escalabilidad y extender

su funcionalidad.

107

Referencias

BEER FERDINAND Y JOHNSTON E. RUSELL (1993) “Mecánica Vectorial para Ingenieros”.

Editorial McGraw-Hill. México.

BOREK PATZAK (2008) “Object Oriented Finite Element Solver”. USA.

BRAY, CROXTON AND MARTIN (1976) “Matrix Analysis of Structures”. Editorial Edward

Arnold. England.

CHRISTOS G. BINIARIS (2004) “A Three-Dimensional Object-Oriented Distributed Finite

Element Solver Based on Mobile Agent Technology”. USA.

FRANK MCKENNA (2000) “A New Design for Object-Oriented Finite Element Software”.

USA.

GRAHAM CHARLES ARCHER (1996) “Object-Oriented Finite Element Analysis”. University

of California at Berkeley. USA.

H. ADELI & KAMAL (1993) “Parallel Processing in Structural Engineering”. Editorial Elsevier

Science. England.

H. KARDESTUNCER (1975) "Introducción al Análisis Estructural con Matrices". McGraw-Hill.

USA.

HORSTMANN Y CORNELL (2001) “Core Java 2 Volume II Advanced Features”. Editorial

Prentice-Hall. USA.

JOSEPH SCHMULLER (2002) “Aprendiendo UML en 24 Horas”. Editorial Prentice Hall.

USA.

JUN LU (1994) “An Object-Oriented Application Framework for Finite Element Analysis in

Structural Engineering”. USA.

KEPA RÍOS ALDAY (2008) “Estructura de Datos”. Ingeniería en Informática. Universidad

Carlos III de Madrid. España.

KLAUS-JURGEN BATHE (1996) “Finite Element Procedures”. Editorial Prentice-Hall. USA.

MARTIN AND CAREY (1973) “Introduction to Finite Element Analysis”. Editorial McGraw-

Hill. USA.

108

MARTY HALL (2008) “Java 2D Drawing”. USA.

MATT WEISFELD (2004) “The Object-Oriented Thought Process”. Segunda edición. Editorial

Sams. USA.

MOSHE RUBINSTEIN (1966) “Matrix Analysis of Structures”. Editorial Prentice-Hall. USA.

NELSON TERRAZAS (2007) “Introducción Práctica a UML”. IDELOGIX. LP-BOL.

NICHOLAS BARAN (1988) “Finite Element on Microcomputers”. Editorial McGraw-Hill.

USA.

NORRIS Y WILBUR (1969) “Análisis Elemental De Estructuras”. Editorial McGraw-Hill.

México.

PRZEMIENIECKI (1968) “Theory of Matrix Structural Analysis”. Editorial McGraw-Hill.

USA.

RICHARD GALLAGHER (1975) “Finite Element Analysis”. Editorial Prentice-Hall. USA.

ROBERT MELOSH (1990) “Structural Engineering Analysis by Finite Elements”. Editorial

Prentice-Hall. USA.

ROBERT W. HORNBECK (1975) “Numerical Methods”. Primera Edición. Editorial Quantum

Publishers, Inc. New York, USA.

SAUL J. ESCALERA (1992) “Manual de Tesis de Grado”. Primera Edición. Universidad Mayor

de San Simón. Cochabamba, Bolivia.

TEDDY CUELLAR MULLER (1980) “Cálculo de Placas por el Método de Elementos Finitos

R16”. UMSA. La Paz, Bolivia

YAILE CABALLERO (2007) "Análisis y Diseño Orientado a Objetos". Postgrado en

Informática. Universidad de Camagüey. Cuba.

109

ApendiceA–ListadodeCodigoFuente

La figura A.1 muestra la organización mediante paquetes del código fuente escri to

en Java para la aplicación desarrollada en ésta investigación con el fin de demostrar

el modelo OO propuesto.

El paquete “Jama” que viene de “Java Matrix” contiene una serie de clases que

proveen a la aplicación de herramientas para el álgebra matricial, tal como se

expuso en la parte 3 de éste informe. Jama ha sido elaborado por terceros y es

considerado uno de los mejores productos de distr ibución gratuita para el álgebra de

matrices.

El paquete “com.csvreader” consiste en dos clases para la lectura y escritura de

archivos que contienen valores separados por comas extensión CSV (comma

separated values) . Dicho paquete ha sido elaborado por terceros y es una de las

mejores propuestas que se distr ibuye gratuitamente.

El paquete “estructural” contiene todas las clases para el modelo OO desarrollado

extensamente en éste trabajo.

El paquete “kar07” contiene la clase principal de la aplicación ( i .e. Main) que sirve

como punto de entrada para la ejecución. Y la clase “elegirest01” proporciona el

formulario inicial que permite elegir la estructura a resolver.

El paquete “util01” contiene tres clases util i tar ias importantes: “entsal” para la

lectura y escritura de los archivos de entrada y salida del anális is de la estructura,

respectivamente; “graficar01” para graficar la geometría y la deformada de la

estructura; y “otros01” que facil i ta subrutinas de conversión entre reales, cadenas y

arreglos.

Los paquetes es tructural, kar07 y uti l01 han sido escritos desde cero para ésta

investigación. A continuación se desglosa el l istado de código fuente para todas las

clases de éstos tres paquetes.

110

Figura A.1. Organización del código fuente de la aplicación de análisis estructural.

111

/* * clase abstracta para carga sobre elemento */ package estructural; import Jama.Matrix; /** * rsaravia 2012 */ public abstract class cargaele00 implements interface01 { String id; double a, b, L; double[] c = new double[5]; Matrix F; public void setid(String s) { id = s; } public String getid() { return id; } // inicio de aplicacion de carga public void seta(double v) { a = v; } public double geta() { return a; } // longitud de aplicacion de carga public void setb(double v) {

b = v; } public double getb() { return b; } // longitud del elemento public void setL(double v) { L = v; } public double getL() { return L; } // vector carga en coordenadas generales public void setF(Matrix m) { F = m; } public Matrix getF() { return F; } // coeficientes de empotramiento public abstract double[] getC(int s); } /* * subclase para carga puntual sobre elemento */ package estructural; /** * rsaravia 2012

112

*/ public class cargaele01 extends cargaele00 { // constructor public cargaele01() { id = "puntual"; } // implementacion del calculo de coeficientes de empotramiento public double[] getC(int s) { double a1; if (s > 0) { a1 = a; } else { a1 = L - a; } c[0] = (L - a1) / L; c[1] = Math.pow(L - a1, 2) * (L + 2 * a1) / Math.pow(L, 3); c[2] = a1 * Math.pow(L - a1, 2) / Math.pow(L, 2); return c; } } /* * subclase para carga rectangular distribuida sobre elemento */ package estructural; /** * rsaravia 2012 */ public class cargaele02 extends cargaele00 {

double a1; // constructor public cargaele02() { id = "rectangular"; } // implementacion del calculo de coeficientes de empotramiento public double[] getC(int s) { if (s > 0) { a1 = a; } else { a1 = L - a - b; } c[0] = b * (L - a1 - b / 2) / L; c[1] = (2 * b * L - 2 * f(3) / L + f(4) / Math.pow(L, 2)) / (2 * L); c[2] = (6 * Math.pow(L, 2) * f(2) - 8 * L * f(3) + 3 * f(4)) / (12 * Math.pow(L, 2)); return c; } private double f(double n) { return Math.pow(a1 + b, n) - Math.pow(a1, n); } } /* * clase abstracta para elementos viga * puede usarse para elementos 2D o 3D */ package estructural; import java.util.ArrayList;

113

import Jama.Matrix; /** * rsaravia 2012 */ public abstract class elemento00 implements interface01 { String id; nudo00 ni, nj; double[] pro, d, cosdir, t; ArrayList cargas; double L; int dim2; // dimension de las matrices del elemento public static int calcdim2(int d) { return 3 * (d - 1); } public void setid(String s) { id = s; } public String getid() { return id; } // nudo inicial i public void setni(nudo00 n) { ni = n; } public nudo00 getni() { return ni; }

// nudo final j public void setnj(nudo00 n) { nj = n; } public nudo00 getnj() { return nj; } // propiedades geometricas e inerciales public void setpro(double[] v) { pro = v; } public double[] getpro() { return pro; } // longitud del elemento public double getL() { return L; } // para cargas q actuan sobre el elemento public void setcargas(cargaele00 carga) { cargas.add(carga); } public ArrayList getcargas() { return cargas; } // inicializa valores basicos de calculo public void ini(int v) { dim2 = v; cargas = new ArrayList();

114

calcdelta(); calcL(); calccosdir(); calct(); } // matriz de rotacion de coordenadas Rij // matriz de rigidez directa local kiij, kjji // matriz de rigidez cruzada local kij, kji // matriz de coeficientes de empotramiento Cij public abstract Matrix getRij(int s); public abstract Matrix getkiij(); public abstract Matrix getkij(); public abstract Matrix getkjji(); public abstract Matrix getCij(double[] v); // matriz de rigidez directa global public Matrix getKGiij() { return (getRij(1).transpose()).times(getkiij().times(getRij(1))); } // matriz de rigidez directa global public Matrix getKGjji() { return (getRij(-1).transpose()).times(getkjji().times(getRij(-1))); } // matriz de rigidez cruzada global public Matrix getKGij() { return (getRij(1).transpose()).times(getkij().times(getRij(-1))); } // fuerza de empotramiento

public Matrix getpije(int s) { Matrix pije = new Matrix(dim2, 1); for (int i1 = 0; i1 < cargas.size(); i1++) { cargaele00 carga = (cargaele00) cargas.get(i1); Matrix Cr = getCij(carga.getC(s)); Matrix Fr = carga.getF(); pije.plusEquals(Cr.times(getRij(s).times(Fr))); } return pije; } // carga puntual debido a fuerzas de empotramiento public Matrix getPie(int s) { return getRij(s).transpose().times(getpije(s)).times(-1); } // fuerza interna extremo i public Matrix getpij() { Matrix p1 = getkiij().times(getRij(1).times(ni.getD())); Matrix p2 = getkij().times(getRij(-1).times(nj.getD())); return p1.plus(p2.plus(getpije(1))); } // fuerza interna extremo j public Matrix getpji() { Matrix p1 = getkjji().times(getRij(-1).times(nj.getD())); Matrix p2 = getkij().transpose().times(getRij(1).times(ni.getD())); return p1.plus(p2.plus(getpije(-1))); } // diferencia de coordenadas entre extremos private void calcdelta() { double[] c1 = ni.getcoor(); double[] c2 = nj.getcoor(); d = new double[c1.length];

115

for (int i1 = 0; i1 < d.length; i1++) { d[i1] = c1[i1] - c2[i1]; } } // longitud del elemento private void calcL() { for (int i0 = 0; i0 < d.length; i0++) { L += Math.pow(d[i0], 2); } L = Math.sqrt(L); } // cosenos directores private void calccosdir() { cosdir = new double[d.length]; for (int i0 = 0; i0 < cosdir.length; i0++) { cosdir[i0] = d[i0] / L; } } // valores base de matriz de rigidez local abstract void calct(); } /* * subclase para elementos 2D biempotrados * solo para marcos rigidos planos */ package estructural; import Jama.Matrix; /** * rsaravia 2012 */

public class elemento01 extends elemento00 { // constructor public elemento01(String s1) { id = s1; } // matriz de rotacion de coordenadas Rij public Matrix getRij(int s) { Matrix R = new Matrix(dim2, dim2); R.set(0, 0, cosdir[0] * s); R.set(0, 1, cosdir[1] * s); R.set(1, 0, -cosdir[1] * s); R.set(1, 1, cosdir[0] * s); R.set(2, 2, 1); return R; } // matriz de rigidez directa local kiij public Matrix getkiij() { Matrix k = new Matrix(dim2, dim2); k.set(0, 0, t[0]); k.set(1, 1, t[1]); k.set(1, 2, t[2]); k.set(2, 1, t[2]); k.set(2, 2, 2 * t[3]); return k; } // matriz de rigidez cruzada local kij public Matrix getkij() { Matrix k = new Matrix(dim2, dim2); k.set(0, 0, t[0]); k.set(1, 1, t[1]); k.set(1, 2, t[2]); k.set(2, 1, t[2]);

116

k.set(2, 2, t[3]); return k; } // matriz de rigidez directa local kjji public Matrix getkjji() { return getkiij(); } // matriz de coeficientes de empotramiento Cij public Matrix getCij(double[] v) { Matrix C = new Matrix(dim2, dim2); C.set(0, 0, -v[0]); C.set(1, 1, -v[1]); C.set(1, 2, v[3]); C.set(2, 1, v[2]); C.set(2, 2, -v[4]); return C; } // valores base de matriz de rigidez local void calct() { t = new double[4]; t[0] = pro[0] * pro[2] / L; t[1] = 12 * pro[0] * pro[1] / Math.pow(L, 3); t[2] = -6 * pro[0] * pro[1] / Math.pow(L, 2); t[3] = 2 * pro[0] * pro[1] / L; } } /* * subclase para elementos 2D biempotrados * solo para grillas o parrillas */ package estructural;

import Jama.Matrix; /** * rsaravia 2012 */ public class elemento02 extends elemento00 { // constructor public elemento02(String s1) { id = s1; } // matriz de rotacion de coordenadas Rij public Matrix getRij(int s) { Matrix R = new Matrix(dim2, dim2); R.set(1, 1, cosdir[0] * s); R.set(1, 2, cosdir[1] * s); R.set(2, 1, -cosdir[1] * s); R.set(2, 2, cosdir[0] * s); R.set(0, 0, 1); return R; } // matriz de rigidez directa local kiij public Matrix getkiij() { Matrix k = new Matrix(dim2, dim2); k.set(0, 0, t[0]); k.set(0, 2, t[1]); k.set(1, 1, t[2]); k.set(2, 0, t[1]); k.set(2, 2, 2 * t[3]); return k; } // matriz de rigidez cruzada local kij

117

public Matrix getkij() { Matrix k = new Matrix(dim2, dim2); k.set(0, 0, -t[0]); k.set(0, 2, -t[1]); k.set(1, 1, t[2]); k.set(2, 0, -t[1]); k.set(2, 2, -t[3]); return k; } // matriz de rigidez directa local kjji public Matrix getkjji() { return getkiij(); } // matriz de coeficientes de empotramiento Cij public Matrix getCij(double[] v) { Matrix C = new Matrix(dim2, dim2); C.set(0, 0, -v[1]); C.set(0, 2, -v[3]); C.set(1, 1, -v[0]); C.set(2, 0, -v[2]); C.set(2, 2, -v[4]); return C; } // valores base de matriz de rigidez local void calct() { t = new double[4]; t[0] = 12 * pro[0] * pro[1] / Math.pow(L, 3); t[1] = 6 * pro[0] * pro[1] / Math.pow(L, 2); t[2] = pro[2] / L; t[3] = 2 * pro[0] * pro[1] / L; } }

/* * clase abstracta para sistemas estructurales * puede usarse para estructuras 2D y 3D */ package estructural; import java.util.ArrayList; import Jama.Matrix; import util01.*; /** * rsaravia 2012 */ public abstract class estructura00 implements interface01 { String id, archivo, tipo; int dim1, dim2, dim3, nr; ArrayList nudos, elementos; Matrix P, K, D; public void setid(String s) { id = s; } public String getid() { return id; } // nombre base para los archivos de la estructura public void setarchivo(String s) { archivo = s; } public String getarchivo() { return archivo;

118

} // tipo de estructura public void settipo(String s) { tipo = s; } public String gettipo() { return tipo; } // numero de dimensiones de la estructura public void setdim1(int d) { dim1 = d; } public int getdim1() { return dim1; } // agregar nudo a la estructura public void setnudos(nudo00 nu) { nudos.add(nu); } public ArrayList getnudos() { return nudos; } // agregar elemento a la estructura public void setelementos(elemento00 ele, int i, int j) { ele.setni((nudo00) nudos.get(i - 1)); ele.setnj((nudo00) nudos.get(j - 1)); ele.ini(elemento00.calcdim2(dim1)); elementos.add(ele); }

public ArrayList getelementos() { return elementos; } // getter matriz de rigidez de la estructura public Matrix getK() { return K; } // getter vector fuerza de la estructura public Matrix getP() { return P; } // agregar cargas puntuales en los nudos public void inscarganu(int i, Matrix P) { nudo00 nu = (nudo00) nudos.get(i - 1); nu.setP(P); } // agregar cargas en los elementos public void inscargaele(int i, cargaele00 cargaele) { elemento00 ele = (elemento00) elementos.get(i - 1); cargaele.setL(ele.getL()); ele.setcargas(cargaele); } // insertar restricciones en los nudos (apoyos) public void insres(int i, boolean[] b) { nudo00 nu = (nudo00) nudos.get(i - 1); nu.setid(nu.getid() + "r"); nu.setres(b); } // dimension de las matrices y vectores de la estructura

119

public static int calcdim3(int d, int n) { return elemento00.calcdim2(d) * n; } // ensamblar sistema de ecuaciones de la estructura public void ensamblarsis() { dim2 = elemento00.calcdim2(dim1); dim3 = estructura00.calcdim3(dim1, nudos.size()); P = new Matrix(dim3, 1); K = new Matrix(dim3, dim3); D = new Matrix(dim3, 1); for (int n = 0; n < elementos.size(); n++) { elemento00 ele = (elemento00) elementos.get(n); int i1 = otros01.getindex(ele.getni().getn(), dim2); int j1 = otros01.getindex(ele.getnj().getn(), dim2); otros01.inssumando(K, ele.getKGiij(), i1, i1); otros01.inssumando(K, ele.getKGjji(), j1, j1); Matrix KGij = ele.getKGij(); K.setMatrix(i1, i1 + dim2 - 1, j1, j1 + dim2 - 1, KGij); K.setMatrix(j1, j1 + dim2 - 1, i1, i1 + dim2 - 1, KGij.transpose()); otros01.inssumando(P, ele.getPie(1), i1, 0); otros01.inssumando(P, ele.getPie(-1), j1, 0); } for (int i = 0; i < nudos.size(); i++) { nudo00 nu = (nudo00) nudos.get(i); int i1 = otros01.getindex(nu.getn(), dim2); Matrix Pi = P.getMatrix(i1, i1 + dim2 - 1, 0, 0); ArrayList Pn = nu.getP();

for (int j = 0; j < Pn.size(); j++) { Pi.plusEquals((Matrix) Pn.get(j)); } if (nu.getres().size() > 0) { nu.setP(null); nu.setP(P.getMatrix(i1, i1 + dim2 - 1, 0, 0).times(-1)); } P.setMatrix(i1, i1 + dim2 - 1, 0, 0, Pi); } } // resolver el sistema de ecuaciones de la estructura public void resolversistema() { boolean[] f = new boolean[dim3]; int dim4 = dim3; for (int c = 0; c < nudos.size(); c++) { nudo00 nu = (nudo00) nudos.get(c); ArrayList res = nu.getres(); for (int i = 0; i < res.size(); i++) { boolean[] r = (boolean[]) res.get(i); int i1 = otros01.getindex(nu.getn(), dim2); for (int j = 0; j < r.length; j++) { if (r[j]) { f[i1 + j] = r[j]; dim4--; } } } } entsal.guardarmatsis(archivo + "(K)", K, f); K = null;

120

Matrix Pr = new Matrix(dim4, 1); int o = 0; for (int c = 0; c < f.length; c++) { if (!f[c]) { Pr.set(c - o, 0, P.get(c, 0)); } else { o++; } } P = null; Matrix Kr = entsal.abrirmatsis(archivo + "(K)r", dim4, dim4); Matrix Dr = Kr.solve(Pr); Kr = null; Pr = null; o = 0; for (int c = 0; c < f.length; c++) { if (!f[c]) { D.set(c, 0, Dr.get(c - o, 0)); } else { o++; } } Dr = null; K = entsal.abrirmatsis(archivo + "(K)", dim3, dim3); P = K.times(D); K = null; entsal.guardarmatsis(archivo + "(P)", P, f); entsal.guardarmatsis(archivo + "(D)", D, f); nr = 0; for (int k = 0; k < nudos.size(); k++) { nudo00 nu = (nudo00) nudos.get(k);

int i1 = otros01.getindex(k + 1, dim2); Matrix Di = D.getMatrix(i1, i1 + dim2 - 1, 0, 0); nu.setD(Di); if (nu.getres().size() > 0) { nu.setP(P.getMatrix(i1, i1 + dim2 - 1, 0, 0)); nr++; } } P = null; D = null; } // calcular las fuerzas internas de los elementos de la estructura public void calcfinternas() { Matrix fint = new Matrix(elementos.size(), dim2 * 2); for (int k = 0; k < elementos.size(); k++) { elemento00 ele = (elemento00) elementos.get(k); Matrix pij = ele.getpij().transpose(); Matrix pji = ele.getpji().transpose(); fint.setMatrix(k, k, 0, dim2 - 1, pij); fint.setMatrix(k, k, dim2, 2 * dim2 - 1, pji); } entsal.guardarmat(archivo + "(fint)", fint); } // calcular las reacciones en los apoyos de la estructura public void calcreacciones() { int x = -1; Matrix re = new Matrix(nr, dim2); for (int i = 0; i < nudos.size(); i++) { nudo00 nu = (nudo00) nudos.get(i); if (nu.getres().size() > 0) { x++; ArrayList Pn = nu.getP();

121

Matrix R = new Matrix(dim2, 1); for (int j = Pn.size() - 1; j > -1; j--) { if (!(Pn.get(j) == null)) { R.plusEquals((Matrix) Pn.get(j)); } else { break; } } re.setMatrix(x, x, 0, dim2 - 1, R.transpose()); } } entsal.guardarmat(archivo + "(reacciones)", re); } } /* * subclase para sistemas estructurales * puede usarse para estructuras 2D y 3D */ package estructural; import java.util.ArrayList; /** * rsaravia 2012 */ public class estructura01 extends estructura00 { // constructor public estructura01(String s1) { id = s1; nudos = new ArrayList(); elementos = new ArrayList(); } }

/* * clase abstracta para los nudos de la estructura * se puede usar en estructuras 2D o 3D */ package estructural; import java.util.ArrayList; import Jama.Matrix; /** * rsaravia 2012 */ public abstract class nudo00 implements interface01 { String id; int n; double[] coor; ArrayList P, res; Matrix D; public void setid(String s) { id = s; } public String getid() { return id; } // numero de nudo public void setn(int i) { n = i; } public int getn() { return n;

122

} // coordenadas del nudo public void setcoor(double[] c) { coor = c; } public double[] getcoor() { return coor; } // agregar carga puntual aplicada en el nudo public void setP(Matrix m) { P.add(m); } public ArrayList getP() { return P; } // restringir grado de libertad del nudo public void setres(boolean[] v) { res.add(v); } public ArrayList getres() { return res; } // desplazamiento del nudo public void setD(Matrix m) { D = m; } public Matrix getD() { return D;

} } /* * subclase para los nudos de la estructura * se puede usar en estructuras 2D o 3D */ package estructural; import java.util.ArrayList; /** * rsaravia 2012 */ public class nudo01 extends nudo00 { // constructor public nudo01(String s1) { id = s1; P = new ArrayList(); res = new ArrayList(); } } /* * interface java para dotar de identificacion * se puede usar para cualquier objeto */ package estructural; /** * rsaravia 2012 */ public interface interface01 { // asignar identificacion

123

public void setid(String s); // getter identificacion public String getid(); } /* * clase para lectura y escritura de archivos * puede usarse para formato csv */ package util01; import java.io.FileNotFoundException; import java.io.IOException; import Jama.Matrix; import com.csvreader.*; import estructural.*; /** * rsaravia 2012 */ public class entsal { final static String ext = ".csv"; private static String dir = ""; // carpeta de trabajo public static void setdir(String d) { dir = d; } public static String getdir() { return dir; }

// extension de archivo por defecto public static String getext() { return ext; } // abrir archivo csv de entrada de la estructura public static estructura01 abrirestructura(String archivo) { String campo[] = { "DESCRIPCION DE LA ESTRUCTURA", "COORDENADAS DE LOS NUDOS", "ELEMENTOS TIPO", "PROPIEDADES DE LOS ELEMENTOS", "CARGAS EN LOS NUDOS", "CARGAS EN LOS ELEMENTOS", "APOYOS", "*" }; String ti[] = {"portico", "parrilla"}; estructura01 estructura = null; try { int i1 = -1, i3 = 0, t = 0; String s1; CsvReader csv = new CsvReader(dir + archivo + ext); while (csv.readRecord()) { s1 = csv.get(0); if (!s1.equals("")) { if (s1.equals(campo[i1 + 1])) { i1++; i3 = 0;

124

} else { switch (i1) { case 0: { estructura = new estructura01(s1); estructura.setarchivo(archivo); break; } case 1: { i3++; String id = "Nudo " + Integer.toString(i3); double[] v = otros01.strarray2double(csv.getValues(), 0); nudo00 nudo = new nudo01(id); nudo.setn(i3); nudo.setcoor(v); estructura.setnudos(nudo); if (i3 == 1) { estructura.setdim1(v.length); } break; } case 2: { for (int i2 = 0; i2 < ti.length; i2++) { if (ti[i2].equals(s1)) { t = i2; estructura.settipo(s1); break; } } break; } case 3: { i3++; String id = "Elemento " + Integer.toString(i3); elemento00 ele = null;

switch (t) { case 0: { ele = new elemento01(id); break; } case 1: { ele = new elemento02(id); break; } } ele.setpro(otros01.strarray2double(csv.getValues(), 2)); estructura.setelementos(ele, Integer.valueOf(s1), Integer.valueOf(csv.get(1))); break; } case 4: { int i = Integer.valueOf(s1); double[] v = otros01.strarray2double(csv.getValues(), 1); estructura.inscarganu(i, otros01.doublearray2matrix(v, 0)); break; } case 5: { int i = Integer.valueOf(s1); cargaele00 cargaele = null; switch (Integer.valueOf(csv.get(1))) { case 1: { cargaele = new cargaele01(); break; } case 2: { cargaele = new cargaele02(); break; }

125

} cargaele.seta(Double.valueOf(csv.get(2))); cargaele.setb(Double.valueOf(csv.get(3))); double[] v = otros01.strarray2double(csv.getValues(), 4); cargaele.setF(otros01.doublearray2matrix(v, 0)); estructura.inscargaele(i, cargaele); break; } case 6: { double[] v = otros01.strarray2double(csv.getValues(), 1); boolean[] b = new boolean[v.length]; for (int i4 = 0; i4 < v.length; i4++) { b[i4] = (v[i4] == 1); } estructura.insres(Integer.valueOf(s1), b); } } } } } csv.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } estructura.setarchivo("_" + archivo); return estructura; } // guardar matrices de la estructura en formato csv

public static void guardarmatsis(String archivo, Matrix m, boolean[] x) { try { CsvWriter csv = new CsvWriter(dir + archivo + ext); CsvWriter csv2 = new CsvWriter(dir + archivo + "r" + ext); int r = m.getRowDimension(); int c = m.getColumnDimension(); for (int i = 0; i < r; i++) { boolean b = false; for (int j = 0; j < c; j++) { String s = Double.toString(m.get(i, j)); csv.write(s); if (((!x[i]) && ((c == 1) || (!x[j])))) { csv2.write(s); b = true; } } if (b) { csv2.endRecord(); } csv.endRecord(); } csv2.close(); csv.close(); } catch (IOException e) { e.printStackTrace(); } } // abrir archivos csv de matrices de la estructura

126

public static Matrix abrirmatsis(String archivo, int r, int c) { Matrix a = new Matrix(r, c); try { CsvReader csv = new CsvReader(dir + archivo + ext); for (int m = 0; m < r; m++) { csv.readRecord(); for (int n = 0; n < c; n++) { a.set(m, n, Double.valueOf(csv.get(n))); } } csv.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } return a; } // guarda matrices en general en formato csv public static void guardarmat(String archivo, Matrix m) { try { CsvWriter csv = new CsvWriter(dir + archivo + ext); int r = m.getRowDimension(); int c = m.getColumnDimension(); for (int i = 0; i < r; i++) {

for (int j = 0; j < c; j++) { String s = Double.toString(m.get(i, j)); csv.write(s); } csv.endRecord(); } csv.close(); } catch (IOException e) { e.printStackTrace(); } } } /* * clase para graficar la geometria y la deformada de la estructura * */ package util01; import java.awt.*; // For Graphics, etc. import java.awt.geom.*; // For Ellipse2D, etc. import java.util.ArrayList; import estructural.*; // rsaravia 2012 public class graficar01 extends javax.swing.JFrame { final double fd = 0.2; private ArrayList ele01, nu01; private boolean f; private double ancho, largo, an2, lar2; private double fdx = 0, fdy = 0, ax = 0, ay = 0;

127

// constructor public graficar01(ArrayList ele, ArrayList nu, boolean b, double v1, double v2) { ele01 = ele; nu01 = nu; f = b; an2 = v1; lar2 = v2; calcancholargo(); initComponents(); } // implementacion del metodo de graficado del formulario @Override public void paint(Graphics g) { super.paint(g); Graphics2D g2d = (Graphics2D) g; double mx = g2d.getClipBounds().getMinX() + 5; double my = g2d.getClipBounds().getMinY(); double w = g2d.getClipBounds().getWidth(); double h = g2d.getClipBounds().getHeight(); double fx = 1.1 * ancho / w; double fy = 1.1 * largo / h; g2d.setBackground(Color.white); g2d.setColor(Color.black); g2d.setStroke(new BasicStroke(3)); for (int i1 = 0; i1 < ele01.size(); i1++) { double xi = ((elemento00) ele01.get(i1)).getni().getcoor()[0]; double yi = ((elemento00) ele01.get(i1)).getni().getcoor()[1]; double xj = ((elemento00) ele01.get(i1)).getnj().getcoor()[0]; double yj = ((elemento00) ele01.get(i1)).getnj().getcoor()[1]; if (f) {

xi += ((elemento00) ele01.get(i1)).getni().getD().get(0, 0) / fdx; yi += ((elemento00) ele01.get(i1)).getni().getD().get(1, 0) / fdy; xj += ((elemento00) ele01.get(i1)).getnj().getD().get(0, 0) / fdx; yj += ((elemento00) ele01.get(i1)).getnj().getD().get(1, 0) / fdy; } xi = (mx + (xi + ax) / fx); yi = (my + h - (yi + ay) / fy); xj = (mx + (xj + ax) / fx); yj = (my + h - (yj + ay) / fy); Line2D.Double li = new Line2D.Double(xi, yi, xj, yj); g2d.draw(li); } } // ancho de la grÃ¡fica public double getancho() { return ancho; } // largo de la grÃ¡fica public double getlargo() { return largo; } // calcular el ancho y largo a partir de la geometria de la estructura private void calcancholargo() { double x0 = 0, y0 = 0, x1 = 0, y1 = 0, dx1 = 0, dy1 = 0; if (f) { dx1 = Math.abs(((nudo00) nu01.get(0)).getD().get(0, 0)); dy1 = Math.abs(((nudo00) nu01.get(0)).getD().get(1, 0));

128

for (int i1 = 0; i1 < nu01.size(); i1++) { double dx = Math.abs(((nudo00) nu01.get(i1)).getD().get(0, 0)); double dy = Math.abs(((nudo00) nu01.get(i1)).getD().get(1, 0)); if (dx > dx1) { dx1 = dx; } if (dy > dy1) { dy1 = dy; } } fdx = dx1 / (fd * an2); fdy = dy1 / (fd * lar2); } x0 = ((nudo00) nu01.get(0)).getcoor()[0]; y0 = ((nudo00) nu01.get(0)).getcoor()[1]; if (f) { x0 += ((nudo00) nu01.get(0)).getD().get(0, 0) / fdx; y0 += ((nudo00) nu01.get(0)).getD().get(1, 0) / fdy; } x1 = x0; y1 = y0; for (int i1 = 0; i1 < nu01.size(); i1++) { double xi = ((nudo00) nu01.get(i1)).getcoor()[0]; double yi = ((nudo00) nu01.get(i1)).getcoor()[1]; if (f) { xi += ((nudo00) nu01.get(i1)).getD().get(0, 0) / fdx; yi += ((nudo00) nu01.get(i1)).getD().get(1, 0) / fdy; } if (xi < x0) { x0 = xi; } if (xi > x1) { x1 = xi; }

if (yi < y0) { y0 = yi; } if (yi > y1) { y1 = yi; } } ancho = x1 - x0; largo = y1 - y0; ax = -x0; ay = -y0; } /** This method is called from within the constructor to * initialize the form. * WARNING: Do NOT modify this code. The content of this method is * always regenerated by the Form Editor. */ @SuppressWarnings("unchecked") // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents private void initComponents() { setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane()); getContentPane().setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

129

.addGap(0, 400, Short.MAX_VALUE) ); layout.setVerticalGroup( layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGap(0, 300, Short.MAX_VALUE) ); pack(); }// </editor-fold>//GEN-END:initComponents /** * punto de entrada de la clase */ public static void main(String args[]) { java.awt.EventQueue.invokeLater(new Runnable() { public void run() { new graficar01(null, null, false, 0, 0).setVisible(true); } }); } // Variables declaration - do not modify//GEN-BEGIN:variables // End of variables declaration//GEN-END:variables } /* * clase de utilitarios */ package util01; import Jama.Matrix; /** * rsaravia 2012

*/ public class otros01 { // de cadena a arreglo numerico de doble precision public static double[] strarray2double(String[] s, int i) { int i2 = s.length; for (int i1 = s.length; i1 > i; i1--) { if (s[i1 - 1].equals("")) { i2--; } else { break; } } double[] v = new double[i2 - i]; for (int i1 = i; i1 < i2; i1++) { v[i1 - i] = Double.valueOf(s[i1]); } return v; } // de arreglo doble precision a matriz public static Matrix doublearray2matrix(double[] a, int s) { int d = a.length - s; Matrix m = new Matrix(d, 1); for (int i1 = 0; i1 < d; i1++) { m.set(i1, 0, a[i1 + s]); } return m; } // de la numeracion de la estructura a indice interno del programa public static int getindex(int n, int d) {

130

return (n - 1) * d; } // inserta sumando una submatriz s en una matriz m public static void inssumando(Matrix m, Matrix s, int i, int j) { int p = i + s.getRowDimension() - 1; int q = j + s.getColumnDimension() - 1; m.setMatrix(i, p, j, q, m.getMatrix(i, p, j, q).plusEquals(s)); } } /* * To change this template, choose Tools | Templates * and open the template in the editor. */ /* * elegirest01.java * * Created on 27-09-2012, 09:06:48 PM */ package kar07; import java.io.File; import java.io.IOException; import java.util.logging.Level; import java.util.logging.Logger; /** * * @author admin02 */ public class elegirest01 extends javax.swing.JFrame { /** Creates new form elegirest01 */

public elegirest01() { initComponents(); } /** This method is called from within the constructor to * initialize the form. * WARNING: Do NOT modify this code. The content of this method is * always regenerated by the Form Editor. */ @SuppressWarnings("unchecked") // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents private void initComponents() { jLabel1 = new javax.swing.JLabel(); jLabel2 = new javax.swing.JLabel(); jLabel3 = new javax.swing.JLabel(); jFileChooser1 = new javax.swing.JFileChooser(); jLabel4 = new javax.swing.JLabel(); setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); setResizable(false); jLabel1.setText("Universidad Mayor de San AndrÃ©s - Facultad de Ciencias Puras y Naturales - Postgrado en InformÃ¡tica"); jLabel2.setText("\"Modelo OO Independiente de la Plataforma para el AnÃ¡lisis de Estructuras Planas Mediante el MEF\""); jLabel3.setText("Maestrante: Ing. Roger Saravia Aramayo - Tutor: M. Sc. Ing. Christian Daza Mier");

131

jFileChooser1.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { jFileChooser1ActionPerformed(evt); } }); jLabel4.setForeground(new java.awt.Color(0, 0, 204)); jLabel4.setText("ImplementaciÃ³n del Modelo - Por favor elija el archivo CSV de la estructura a analizar:"); javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane()); getContentPane().setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(layout.createSequentialGroup() .addContainerGap() .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.CENTER) .addComponent(jLabel1) .addComponent(jLabel2) .addComponent(jLabel3) .addComponent(jLabel4) .addComponent(jFileChooser1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)) );

layout.setVerticalGroup( layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(layout.createSequentialGroup() .addContainerGap() .addComponent(jLabel1) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addComponent(jLabel2) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addComponent(jLabel3) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED) .addComponent(jLabel4) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED) .addComponent(jFileChooser1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)) ); pack(); }// </editor-fold>//GEN-END:initComponents

132

private void jFileChooser1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jFileChooser1ActionPerformed // TODO add your handling code here: String s1 = evt.getActionCommand(); if (s1.equals("CancelSelection")) { this.dispose(); } else if (s1.equals("ApproveSelection")) { File f1 = jFileChooser1.getSelectedFile(); String s2 = f1.getParent() + File.separator; String s3 = f1.getName(); String s4 = ""; char ch; for (int j = 0; j < s3.length(); j++) { ch = s3.charAt(j); if (!(ch == '.')) { s4 += ch; } else { break; } } this.dispose(); Main.analizar(s2, s4); } }//GEN-LAST:event_jFileChooser1ActionPerformed /** * @param args the command line arguments */ public static void main(String args[]) { java.awt.EventQueue.invokeLater(new Runnable() { public void run() { new elegirest01().setVisible(true); } }); }

// Variables declaration - do not modify//GEN-BEGIN:variables private javax.swing.JFileChooser jFileChooser1; private javax.swing.JLabel jLabel1; private javax.swing.JLabel jLabel2; private javax.swing.JLabel jLabel3; private javax.swing.JLabel jLabel4; // End of variables declaration//GEN-END:variables } /* * clase principal de la aplicaciion * punto de entrada de la ejecuciÃ³n */ package kar07; import java.util.ArrayList; import Jama.Matrix; import estructural.*; import util01.*; /** * rsaravia 2012 */ public class Main { // apertura de la estructura public static void main(String[] args) { elegirest01 est01 = new elegirest01(); est01.setLocation(50, 50); est01.setVisible(true); } // analisis de la estructura public static void analizar(String c1, String c2) {

133

final String s = " "; entsal.setdir(c1); estructura00 estructura = entsal.abrirestructura(c2); System.out.println("archivo: " + estructura.getarchivo()); System.out.println("id: " + estructura.getid()); System.out.println("dim: " + estructura.getdim1()); System.out.println("tipo: " + estructura.gettipo()); System.out.println(); ArrayList nudos = estructura.getnudos(); for (int i1 = 0; i1 < nudos.size(); i1++) { nudo00 nudo = (nudo00) nudos.get(i1); double[] coor = nudo.getcoor(); System.out.print(nudo.getid() + s); for (int i2 = 0; i2 < coor.length; i2++) { System.out.print(coor[i2] + s); } System.out.println(); } System.out.println(); ArrayList elementos = estructura.getelementos(); for (int i1 = 0; i1 < elementos.size(); i1++) { elemento00 ele = (elemento00) elementos.get(i1); double[] p = ele.getpro(); System.out.print(ele.getid() + s); System.out.print(ele.getni().getid() + s + ele.getnj().getid() + s); for (int i2 = 0; i2 < p.length; i2++) { System.out.print(p[i2] + s); } System.out.println(); } System.out.println();

for (int i1 = 0; i1 < nudos.size(); i1++) { nudo00 nudo = (nudo00) nudos.get(i1); ArrayList cargas = nudo.getP(); for (int i2 = 0; i2 < cargas.size(); i2++) { System.out.print(nudo.getid() + s); Matrix P = (Matrix) cargas.get(i2); for (int i3 = 0; i3 < P.getRowDimension(); i3++) { System.out.print(P.get(i3, 0) + s); } System.out.println(); } } System.out.println(); for (int i1 = 0; i1 < elementos.size(); i1++) { elemento00 ele = (elemento00) estructura.getelementos().get(i1); ArrayList cargas = ele.getcargas(); for (int i2 = 0; i2 < cargas.size(); i2++) { cargaele00 carga = (cargaele00) cargas.get(i2); System.out.print(ele.getid() + s); System.out.print(carga.getid() + s); System.out.print(carga.geta() + s); System.out.print(carga.getb() + s); Matrix F = carga.getF(); for (int i3 = 0; i3 < F.getRowDimension(); i3++) { System.out.print(F.get(i3, 0) + s); } System.out.println(); } } System.out.println(); for (int i1 = 0; i1 < nudos.size(); i1++) { nudo00 nudo = (nudo00) nudos.get(i1);

134

ArrayList res = nudo.getres(); for (int i2 = 0; i2 < res.size(); i2++) { System.out.print(nudo.getid() + s); boolean[] b = (boolean[]) res.get(i2); for (int i3 = 0; i3 < b.length; i3++) { System.out.print(b[i3] + s); } System.out.println(); } } System.out.println(); graficar01 grafica01 = new graficar01(elementos, nudos, false, 0, 0); grafica01.setLocation(50, 50); grafica01.setTitle("estructura " + c2 + " (geometrÃa antes del anÃ¡lisis)"); grafica01.setVisible(true); double w = grafica01.getancho(); double h = grafica01.getlargo(); estructura.ensamblarsis(); Matrix K = estructura.getK(); for (int i1 = 0; i1 < K.getRowDimension(); i1++) { for (int i2 = 0; i2 < K.getColumnDimension(); i2++) { System.out.print(K.get(i1, i2) + s); } System.out.println(); } System.out.println(); Matrix P = estructura.getP(); for (int i1 = 0; i1 < P.getRowDimension(); i1++) { System.out.print(P.get(i1, 0) + s); }

System.out.println(); estructura.resolversistema(); estructura.calcfinternas(); estructura.calcreacciones(); graficar01 grafica02 = new graficar01(elementos, nudos, true, w, h); grafica02.setLocation(grafica01.getX() + grafica01.getWidth() + 10, grafica01.getY()); grafica02.setTitle("estructura " + c2 + " (deformada luego del anÃ¡lisis)"); grafica02.setVisible(true); } }

135

ApendiceB–InstalaciondelSoftware

1) Asegúrese que su computadora tiene instalada la máquina virtual de Java. (JVM).

2) Inserte el CD y haga doble clic en el archivo instalar.

3) Elija un folder para instalar la aplicación de análisis estructural y presione el botón

Unzip (desempacar). Luego, cierre la(s) ventana(s) del instalador.

4) Se ha creado un folder denominado estructuras dentro del folder que Ud. eligió

para la instalación.

5) Vaya al folder estructuras y haga doble clic en el acceso directo aplicación para

ejecutar la aplicación de análisis estructural.

6) Se abre un cuadro de diálogo pidiéndole que elija una estructura para resolver.

Vaya al folder estructuras y elija un archivo CSV de cualquier estructura como

por ejemplo edificio12.csv

7) Posteriormente, se resuelve la estructura y luego del análisis aparecen dos

ventanas: la geometría y la deformada de la estructura, respectivamente. Cuando

haya concluido de apreciarlas, cierre cualquiera de las ventanas.

8) Vaya al folder estructuras y abra con MS Excel (u otro) cualquier archivo de

resultados del análisis estructural como por ejemplo _edificio12(K).csv que

contiene la matriz de rigidez K de la estructura.

Nota.- Los archivos de resultados del análisis estructural tienen como prefijo el guion

bajo _.

136

ApendiceC–CasodeEstudiodeAplicacionPracticaalaRealidadLocal

C.1 Edificio“ElAlcázar”

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

137

La noche del lunes 17 de diciembre de 2012 al promediar las 17.30 un pilar del cuarto nivel de los

parqueos del edificio, situado debajo de una de las dos torres del edificio (Córdoba), colapsó. La

estructura tiene 18 pisos, 2 niveles de oficinas, 4 niveles subterráneos de estacionamientos y un

semisótano. La construcción tiene 16 años y fue construida por la Sociedad de Comercio (SADECO

SA) más conocida como Ormachea.

FICHA TÉCNICA

Nombre: “El Alcázar” (nombre anterior: “Milenio II”)

Dirección: C. Federico Zuazo entre B. Colorados y Tiwanaku (paralela a El Prado)

Torres: 2 – Córdoba (lado norte) y Granada (lado sur)

Antigüedad: 16 años

Planos aprobados: No

Constructora: SADECO (Ormachea)

Representantes: Diego Francisco Ormachea Pacheco, Carlos Ormachea Zalles

Pisos: 18 Dptos.: 172

Pent-house: 2 Parqueos: 168

Bauleras: 155 Depósitos: 16

Sub-sótanos para garajes: 4 Oficinas y locales comerciales: 91

Mezannines: 2 Semisótanos: 1

Número de familias: 174

Representante de copropietarios: Luis Monroy

Elemento colapsado: Pilar 4to nivel parqueo torre Córdoba (Bloque C)

Tipo de falla: Abrupta y total - aplastamiento del hormigón y pandeo del acero de refuerzo

Causas del colapso: diseño, cálculo, construcción, falta de mantenimiento y filtración.

Pilares comprometidos: 6

138

Número de inmuebles aledaños evacuados: mínimo 5

Soluciones propuestas: encamisado y hormigonado

Tiempo de ejecución de soluciones propuestas: de 15 a 90 días

Garantía de la solución: no presenta verificación

ANTECEDENTES

Según la Alcaldía, los documentos de la construcción datan de 1996, cuando se entregó una

autorización provisional para levantar el edificio Milenio II. La autorización edil era para construir un

edificio más chico. Mientras era construido, de “Milenio II” pasó a llamarse “El Alcázar”. Se debieron

edificar 160 dptos. pero se construyeron 172 entre otros cambios. Esto implica una carga adicional de

peso muerto.

El alcalde explico que el hecho de que un edificio termine siendo otro se debe a que este proceso

pasaba por tres etapas: En una primera instancia, la Alcaldía aprobaba los planos a base de leyes

nacionales vigentes desde 1963 y del reglamento de Uso de Suelos y Patrones de Asentamiento

(USPA) de 1993. Ambas normas permitían la aprobación inmediata. Aquí se aprueba la construcción

del “Milenio II”. Luego se hacía una segunda aprobación que permitía la comercialización o venta de

los departamentos. Aquí el edificio pasó a denominarse El Alcázar. Esto permitió a varios

copropietarios obtener títulos de propiedad, pagar impuestos y seguir otros trámites.

Pero además la norma obligaba a la empresa constructora a presentar los planos finales una vez

terminado el edificio. En el 90 se permitían las modificaciones previa presentación de un nuevo

cálculo estructural del edificio que justifique los cambios que hubieran producido. El alcalde

reconoció que éste último paso de la aprobación definitiva nunca se efectuó con “El Alcázar”. Se

presume por dos hipótesis: 1) por los cambios detallados con anterioridad; 2) o que los funcionarios de

hace 16 años no hubieran aceptado las modificaciones.

EL COLAPSO

La noche del lunes el colapso de un pilar del cuarto nivel de parqueos del edificio El Alcázar debajo de

la torre Córdoba obligó a evacuar a las 174 familias que habitaban la infraestructura y a las personas

139

que trabajaban en 91 locales comerciales u oficinas. Adicionalmente se restringió el ingreso de

personas particulares en un área de dos cuadras alrededor del edificio y se solicitó la evacuación de por

lo menos 5 inmuebles contiguos.

Un pilar principal que sostiene el bloque C de El Alcázar de la calle Federico Zuazo de La Paz colapsó

el lunes 17 de diciembre de 2012. El hecho ocurrió al promediar las 17.30. Los habitantes dieron la

voz de alarma a las 16.00 luego de escuchar un estruendo en el edificio que hizo que la gente saliera en

pánico a la calle.

La gigante infraestructura tembló a eso de las 17.30 de ayer y los vecinos del lugar creyeron que se

trató de un movimiento sísmico. La alerta llegó minutos después al identificar problemas en la columna

principal del bloque C.

Figura C2. El pilar colapsado de la torre Córdoba del Edificio El Alcázar.

CAUSAS DEL COLAPSO

El ingeniero especialista en estructuras de la Sociedad de Ingenieros de Bolivia (SIB), Rolando Grandi, explicó que el

colapso de la columna se debió a tres factores: la mala construcción, el mal diseño de la obra y la humedad. Según la SIB,

el colapso de la columna se debe a 3 posibles causas: error de diseño (que tiene que ver con las dimensiones de los

140

pilares), de construcción (mala precisión de ejes, etc.) y de mantenimiento (una fuga de la tubería que bajaba al lado del

pilar colapsado pudo penetrar y oxidar su armadura).

El diagnóstico de la SIB fue demoledor. Hay fallas de construcción, fallas de cálculo y desorden estructural. Un verdadero

caos y una total falta de previsión al colocar bajantes de agua junto a las columnas lo que ocasionó humedad y oxidación

de los refuerzos de acero del hormigón. Estas fallas se suman a la alteración de los planos de construcción detectada por la

Alcaldía que prueban que la constructora edificó adicionalmente sin autorización 12 departamentos, 39 locales y 1

semisótano.

Grandi de la SIB manifestó que la estructura del edificio no es uniforme, simétrica y bien acomodada; es una estructura

deficiente. Una viga grande descansa sobre otra pequeña; no llegan cargas de forma directa a la columna lo que produce

problemas. También cuestionó la desordenación en la instalación del sistema de agua y alcantarillado y observó que por la

columna dañada pasaban las tuberías de agua y alcantarillado que al dañarse remojaron el hormigón armado.

Figura C3. La unión de los 2 elementos viga no fueron construidos sobre el centro de la columna.

EFECTOS DEL COLAPSO: EL TRAUMA SOCIAL

La alcaldía notificó con la orden de evacuación a 5 predios contiguos al edificio “El Alcázar” amenazado de

colapso. “Actualmente cualquier vibración mínima puede generar problemas. Es un área de alto riesgo” dijo un

funcionario municipal. Todos esos predios deberán permanecer evacuados posiblemente durante 3 meses. Además

se instruyó iniciar el empacamiento de aproximadamente 11 mil reliquias del Museo Nacional de Arqueología.

141

“Nadie va a volver a vivir aquí en éste edificio. Sería una irresponsabilidad de nosotros, de la empresa constructora

y de la Alcaldía; ya da miedo vivir aquí” dijo una afectada que no dio su nombre (Diario La Razón 20/dic/2012)

“Todo se ha sentido muy fuerte. Cuando pasó, en la planta baja donde trabajo todo se ha sentido bastante fuerte

todo se ha movido. Temo perder mis pertenencias. Es una pena.” dijo Virginia Parrada, peluquera.

“Nos quedamos sin generar dinero sin trabajar. Soy de la parte comercial en éste edificio y hay deberes con el

Estado que cumplir...” dijo la propietaria de un negocio.

“Con mi nieto he escapado. Luego de que se ha sentido esto y supimos de todo, no hemos podido recoger nuestros

productos de la feria. He tenido que irme rápido con mi nieto en los brazos” dijo Virginia Mamani de la feria

navideña.

“La gente lo va a pensar dos veces antes de comprar un departamento y se están construyendo dos edificios cerca de

éste inmueble” dijo Roberto Jordán de una inmobiliaria.

“Por el momento nadie va a querer comprar un departamento por la zona donde se encuentra el edificio...” dijo el

gerente de una inmobiliaria.

“Nadie nos garantiza que el edificio va a estar estable. El reforzamiento no es una garantía” dijo un copropietario del

edificio.

Con parecidos argumentos 30 copropietarios del edificio El Alcázar demandaron la devolución de su inversión.

Además los inquilinos quedaron a su suerte: “Los contratos de alquiler o anticrético entre los copropietarios del

edificio El Alcázar y terceros es un problema particular entre privados. No intervendrá la Alcaldía” se dijo.

Figura C4. Efectos del colapso: el trauma social.

142

¿HA QUEDADO INCLINADA LA ESTRUCTURA?

Se va a aplicar el modelo OO propuesto en esta investigación para que por medio del programa se

pueda calcular y determinar la deformada de la estructura antes y después del colapso de la columna.

Primero, se ha ingresado las propiedades geométricas e inerciales del sistema estructural

correspondiente a la torre Córdoba del edificio El Alcázar. Luego, se ha realizado el análisis estructural

del edificio intacto. Seguidamente, se ha quitado la columna colapsada del modelo y se ha realizado de

nuevo el análisis estructural.

Como puede apreciarse en la figura C5 (derecha), la deformada exagerada del sistema estructural del

edificio es simétrica y hacia el centro. Esto ocurre cuando el edificio trabaja bajo condiciones

normales de carga.

En la figura C6 (derecha), la deformada exagerada del sistema estructural afectado del edificio

corrobora la inclinación del mismo luego del colapso de la columna del segundo nivel. Nótese que, en

el modelo de elementos finitos, la ausencia de un elemento puede bien representar a la columna

colapsada (figura C6).

La figura C2 muestra la columna colapsada y evidencia el desplazamiento del nudo superior de dicho

elemento; lo cual, confirma el desplazamiento del sistema estructural. Nótese también que, todos los

elementos finitos del sistema estructural afectado sufren algún desplazamiento en mayor o menor

magnitud (figura C6 derecha).

Por consiguiente, luego del colapso de la columna de la torre Córdoba del edificio El Alcázar, la

estructura sí queda inclinada hacia el lado de la columna afectada.

Finalmente, con el propósito de comparar y corroborar los resultados del modelo y el programa de ésta

investigación, se ha elaborado un modelo 3D de elementos finitos en el software SAP2000 V.15 y

según se muestra en las figuras de a continuación los resultados son los mismos (conceptualmente

equivalentes).

143

Pórtico de El Alcázar antes del análisis.

Deformada de El Alcázar luego del análisis:

Figura C5. Geometría antes y después del análisis del sistema estructural intacto (torre Córdoba).

Pórtico de El Alcázar antes del análisis.

Deformada de El Alcázar luego del análisis.

Figura C6. Geometría antes y después del análisis del sistema estructural afectado (torre Córdoba).

144

Figura C7. Deformada del modelo 3D del edificio El Alcázar (torre Córdoba) – Sistema estructural

intacto.

Figura C8. Deformada del modelo 3D del edificio El Alcázar (torre Córdoba) – Sistema estructural

afectado.

modelo orientado a objetos para el analisis de estructuras planas mediante el metodo de los...

Documents