Modelo orientado a objetos para el analisis de estructuras planas mediante el metodo de los elementos finitos

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

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

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

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

5. 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 FUNCIONALES ................................................................................................................................. 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

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

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

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

9. 6
Parte 1 – Marco Referencial
1.1 Introducción
Las estructuras materializadas en obras civiles, herramientas mecánicas, medios de transporte
terrestres, aeroespaciales, navales, etc. juegan un rol de servicio a diario muy importante para la
humanidad. Las estructuras se presentan en todo el Mundo a diversas escalas y complejidades de
diseño como ser: cimentaciones, edificaciones, puentes, muros, carreteras, torres de transmisión,
presas, canales, vehículos, aviones, barcos, máquinas, reactores nucleares, etc.
Figura 1. Ejemplo de estructura de transporte
El fuselaje del avión Boeing 747 es un ejemplo de
estructura de transporte aéreo que fue analizado y
diseñado mediante el método de los elementos finitos.
Su cálculo involucró un sistema de ecuaciones de más
de 7000 incógnitas. [Gallagher 1975]
1.1.1 ¿Qué es el análisis estructural y para qué sirve?
El análisis estructural es una rama de las ciencias físicas que trata sobre el comportamiento de las
estructuras bajo ciertas condiciones de diseño. Las estructuras son sistemas que soportan carga y el
comportamiento se entiende como su tendencia a deformarse, vibrar, pandearse o fluir dependiendo a
las condiciones a las cuales estén sometidas. Los resultados del análisis se usan para determinar la
deformación de la estructura y verificar si son adecuadas para las cargas para las cuales se las ha
diseñado. El resultado es único y depende solamente de las condiciones iniciales. Véase figuras 2 y 3.

10. 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é es el método de los elementos finitos y para qué sirve?
El método de los elementos finitos (MEF) es la manera más extendida para simular sistemas de
ingeniería en computadoras. El MEF ha sido usado para predecir el comportamiento de sistemas
estructurales, mecánicos, térmicos, de flujo de fluidos, eléctricos y químicos. El MEF ha sido aplicado
tanto a sistemas lineales o no lineales sean o no tiempo dependientes. El MEF se aplica a sistemas
formados por cualquier material y geometría. En el Mundo se emplea anualmente más de un billón de
dólares en gastos concernientes al uso del MEF. El MEF ha sido desarrollado por Jon Turner,
ingeniero líder de la compañía BOEING, entre 1956 y 1962 con el fin de lograr un mejor cálculo para
la rigidez de las alas de un avión destinado a vuelo supersónico. [Baran 1987]

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

12. 9
Figura 5. Sistema estructural
plano: un pórtico o marco rígido
de 20 nudos, 28 elementos viga y
4 apoyos fijos.
Enlafigura6setieneunelementofinitovigadoblementeempotrado3D. Seusaráunelementofinitoviga2Denelplanoxy.
Conforme se puede corroborar en el estado del arte a la fecha, todos los trabajos así como los programas realizados, por
cuestionesdesimplificación,hanempleadoampliamenteunmismosistemadeejeslocalesenambosextremosdelelemento
(figura7a). Entonces,cuandosellegaalosresultadosdelanálisis,hayquehacerunaseriedeinterpretacionesparallegaralas
fuerzasinternasrealesporqueelusodeunmismosistemadeejesenambosextremosgeneraciertasambigüedadescomoser:
¿enquéextremoelejelocalxindicaladireccióndelatensión?algunossuponenquevadeizquierdaaderechaperoquedael
interrogante de cuál es el extremo izquierdo y así. Para evitar cualquier ambigüedad, en esta investigación se propone un
sistemadeejeslocalesindependienteparacadaextremodelelementosegúnlateoríaestructuraldeKardestuncer(figura7b).
Figura 6. Elemento finito 3D viga doblemente
empotrado.
Figura 7. Sistemas de ejes locales: (a) tradicional
(b) Kardestuncer.

13. 10
1.1.3 ¿Qué es el método matricial de la rigidez y para qué sirve?
El método matricial de la rigidez es un proceso universalmente aceptado para el análisis estructural en
computadoras que proporciona un algoritmo rápido y preciso para el análisis de estructuras complejas.
El objetivo del método de la rigidez es establecer la relación entre las cargas externas y los
desplazamientos en los nudos de la estructura. El método directo de la rigidez sustituye la actual
estructura continua por un modelo equivalente compuesto por elementos discretos (i.e. finitos) cuyas
propiedades elásticas e inerciales están expresadas matricialmente. Estas matrices conocidas como
matrices de rigidez de los elementos constituyen los bloques constructivos básicos que al ser
combinados en conjunto de acuerdo a una serie de reglas derivadas de la teoría de la elasticidad
conforman la matriz de rigidez global que representa a las propiedades estáticas y dinámicas del
sistema estructural. Los principios fundamentales sobre los cuales se sustenta el método matricial de la
rigidez son: los principios de los desplazamientos y fuerzas virtuales, los teoremas de Castigliano, el
teorema de la mínima energía, el teorema de la mínima energía complementaria y los teoremas del
desplazamiento y carga unitarios(as). [Kardestuncer 1974]
Por ejemplo, el ensamblado de la matriz de rigidez global del marco plano de la figura 8 (izq.) está
compuesto a su vez por las matrices de rigidez de cada elemento de la estructura. Cada componente Kij
de la matriz global K es una matriz 3x3 correspondiente a la viga o elemento que está entre los nudos i
y j. En consecuencia la matriz de rigidez global para esta estructura es de orden 21. Cada sub-matriz
Kii de la diagonal principal representa la rigidez del nudo i o sea la sumatoria de todas las matrices de
rigideces de los elementos que parten del nudo i. La matriz global K siempre es simétrica. Si no
existen elementos entre los nudos i y j entonces Kij es cero
Figura 8. Modelo completo de la matriz de rigidez global (der.) de un determinado marco rígido plano
(izq.)

14. 11
1.1.4 ¿Qué es un objeto y para qué sirve?
Un objeto se define en dos términos: atributos y comportamiento. Un objeto es una entidad que
contiene ambos: datos y comportamiento. Los objetos son los bloques constructivos básicos de un
programa orientado a objetos (OO). Un software que usa el paradigma OO consiste básicamente en una
colección de objetos. En la programación procedimental tanto el código como los datos están
localizados de manera separada. En un diseño OO, los atributos y el comportamiento están contenidos
en un solo objeto. Por consiguiente, como en la programación procedimental los datos están separados
de los procedimientos, muchas veces los datos están a nivel de contexto global de tal manera que
pueden ser modificados por cualquier subrutina o función implicando que el acceso a los datos pueda
ser incontrolado e impredecible. Entonces, como uno no tiene el control de que subrutinas podrían
haber accedido a los datos, las pruebas y depuración del software son muy difíciles. Los objetos
resuelven todos estos problemas al combinar datos y comportamiento en un paquete completo. La
combinación de datos y comportamiento (métodos) en una misma entidad se denomina encapsulación
(figura 9). Otros conceptos adicionales del paradigma OO son: herencia, polimorfismo, composición,
abstracción, dependencia, etc.
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

15. 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ón del Problema
ProgramartópicoscomoelanálisisdeestructurasmedianteelMEFenlenguajesestructuralesobasadosenprocedimientos,implica
una gran extensión de código distribuido en subrutinas y funciones. Puesto que el análisis estructural involucra operaciones
matricialesqueincluyenatodaslaspropiedadesdelelemento,éstasdebenimplementarsemedianteciclosexplícitos. Eningeniería
del software, se denomina “complejidad ciclomática” al grado de profundidad de las anidaciones. Otras operaciones como las
asignacionesvectorialestambiéndebenprogramarsedimensiónadimensióngenerandoasíineficiencia. Además,debereservarse
considerablecantidaddevariablesparaalmacenar-porejemplo-laconfiguracióngeométrica,laspropiedadesdelosmaterialesylas
cargasaplicadasenlaestructura;esto,debidoaunafaltadetiposdedatosespecíficosquepermitanunaltoniveldeabstracció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
mantenimientoyextensiónrequierendeunaltogradodeconocimientodelprogramaenteroreflejadoenelesfuerzohoras-hombrey
siendounobstáculoparafuturosingenieroseinvestigadores.
1.2.1 Formulación del Problema
¿Existe un modelo conceptual orientado a objetos que pueda abstraer y simplificar la complicada
codificación del cálculo estructural matricial de pórticos planos mediante MEF que a su vez sea capaz
de producir resultados completos según la teoría de ejes locales de Kardestuncer?
1.3 Objetivos
13.1 General
El objetivo de ésta investigación es proveer y probar una nueva arquitectura orientada a
objetos para que el software de análisis estructural de pórticos planos mediante
elementos finitos – elemento viga y sistema de ejes locales Kardestuncer, sea fácil de
entender, implementar, extender y modificar.

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

17. 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 Alcances y Limitaciones
El alcance de ésta investigación es de carácter exploratorio porque se pretende indagar el tema desde
una nueva perspectiva y porque se desea ampliar una área existente.
El modelo orientado a objetos que llegue a diseñarse se limitará al análisis estático lineal de estructuras
en dos dimensiones, elemento viga doblemente empotrada, cargas puntuales en los nudos, cargas
distribuidas sobre los elementos y apoyos fijos.
La implementación de la aplicación resultante del modelo OO será de carácter inicial y estará limitada
a computadoras de escritorio o portátiles con el complemento de la máquina virtual de Java instalado.

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

19. 16
Parte 2 – Marco Teórico
2.1 Estructuras de Ingeniería
Para el ingeniero es muy importante el proyecto de puentes, edificios, torres y otras
estructuras fijas. Tales estructuras están compuestas por elementos unidos entre sí y
sustentados de modo que puedan soportar en equilibrio estático las fuerzas externas
aplicadas. Pero una estructura también debe estar en equilibrio con las fuerzas de la
gravedad que le son aplicadas como consecuencia de su propio peso. Por ejemplo,
sobre una torre de línea de transmisión actúan su propio peso, las cargas de viento y
hielo aplicadas directamente a la torre y las fuerzas aplicadas a ella por los cables que
soporta. Debe entonces calcularse los elementos de la torre de modo que puedan
soportar las cargas en equilibrio estático y transferir así sus efectos a la cimentación.
Además de las ya mencionadas, hay muchas otras estructuras: presas, muelles, losas de
pavimento de aeropuertos y carreteras, tuberías a presión, depósitos reguladores
(estanques), viaductos, etc. Pero no solo hay estructuras de importancia para el
ingeniero civil: la estructura de un avión es importante para el ingeniero aeronáutico,
la de un barco para el ingeniero naval, recipientes de alta presión y otro equipo
industrial para el ingeniero químico, partes de máquinas y soportes de adecuada
resistencia estructural serán tema del ingeniero mecánico y el ingeniero eléctrico estará
ocupado con el equipo eléctrico y sus bastidores.
El análisis de todas estas estructuras está basado en los mismos principios
fundamentales. En ésta investigación, los ejemplos que se usan para mostrar la
aplicación de dichos principios casi siempre tratan de estructuras de ingeniería civil
pero los métodos de análisis descritos pueden usarse para estructuras que tengan
aplicación en otras ramas de la ingeniería (véase figura 10).
Una estructura se proyecta para que cumpla con una misión determinada para lo cual
debe tener la suficiente resistencia y rigidez. Otros aspectos de gran importancia son la
economía y el buen aspecto.

20. 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álisis Estructural
La historia del análisis estructural comienza mucho antes de la era de los egipcios,
romanos y griegos. Las ruinas actuales indican que ciertos principios de la estática del
análisis estructural fueron conocidos por sus constructores. Arquímedes (287-212
A.C.) introdujo el concepto de centro de gravedad y llevo a su más simple expresión
los principios fundamentales de la estática y equilibrio.
(10a) Puente metálico.
(10b) Cimentación: zapata de concreto.

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

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

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

24. 21
2.1.2 Método de los Elementos Finitos (MEF)
[Reddy 1984] La idea de representar un determinado dominio como una colección de elementos
discretos no es nueva. Antiguos matemáticos estimaron el valor de pi (π) mediante el perímetro de un
polígono inscrito en un círculo. Predijeron al menos 40 dígitos de π representando el círculo con un
polígono de gran número finito de lados. A mitades del siglo XX el método de los elementos finitos
emerge del análisis estructural de una aeronave en la cual las alas y el fuselaje fueron modeladas a
partir de elementos tipo paneles (véase figura 10f). La presentación formal del MEF se atribuye a
Argyris y Kelsey (1960), y a Turner, Clough, Martin y Topp (1956). El término “método de los
elementos finitos” se atribuye a Clough en 1960.
En general, el objetivo del MEF es calcular con suficiente grado de precisión los valores de las
incógnitas de las ecuaciones diferenciales que gobiernan ciertos puntos del dominio de un sistema o
estructura continua. Se crea un modelo matemático del sistema físico o estructura dividido en nudos y
elementos finitos. A este modelo se aplican las ecuaciones que gobiernan el sistema. Se resuelve el
sistema de ecuaciones hallando así los resultados para cada nudo. Los pasos que involucra el MEF son:
1 El usuario crea el modelo de elementos finitos
a. Define la geometría, los nudos y elementos.
b. Especifica las propiedades de los materiales, las condiciones de carga y las condiciones de
contorno.
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.

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

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

27. 24
2.1.3 Método Matricial de la Rigidez de Kardestuncer
Para calcular estructuras mediante el método de elementos finitos debe aplicarse un proceso de análisis
estructural: el método matricial de la rigidez conocido también como el método de los desplazamientos
o como el método del equilibrio (porque llega a producir una ecuación matricial de equilibrio de la
estructura).
El método de la matriz de rigidez determina primero los desplazamientos en ciertos puntos (nudos) y
luego las fuerzas internas en los elementos (figura 13b). Para calcular los desplazamientos de una
determinada estructura bajo ciertas condiciones de carga, se debe hallar la rigidez de la estructura a
partir de sus elementos. Las rigideces individuales de los elementos se combinan mediante un
procedimiento matricial produciendo finalmente una ecuación matricial que relaciona las cargas
aplicadas con los desplazamientos de los nudos correspondientes (ecuación 1). La principal
suposición del método de la rigidez es que, la estructura pueda ser satisfactoriamente representada por
un ensamblado de elementos discretos (i. e. finitos) interconectados que representan a la estructura
continua.
Figura 13a. Pórtico o marco rígido 2D (4
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)

28. 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álisis de Marcos Rígidos Planos
Los marcos rígidos planos o pórticos son estructuras bidimensionales cuyas cargas externas están en el
mismo plano de la estructura (figura 15b). Tienen uniones (nudos) perfectamente rígidos y los ángulos
entre los elementos no cambian. Un nudo puede rotar siempre y cuando roten también los elementos
asociados al nudo. La deformada de un pórtico debido a una condición de carga induce momentos
flectores, fuerzas axiales y cortantes.

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

30. 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 0
0 12 / 6 /
0 6 / 4 /
/ 0 0
0 12 / 6 /
0 6 / 2 /
(2)
El siguiente paso será transformar las matrices de la ecuación (2) de coordenadas locales
a coordenadas generales. Para esto es necesario el cálculo de la matriz de rotación R
entre estos sistemas de coordenadas. Si Rij es la matriz de rotación para rotar un vector
de coordenadas generales a locales (véase ecuación 3), entonces la inversa de R hace la
transformación inversa. Ya que ambos, el sistema general y el sistema local de
coordenadas, son ortogonales, la inversa de R es igual a su transpuesta.
R
0
0
0 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).

31. 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.2 Análisis y Diseño Orientado a Objetos ADOO
La primera vez que se propuso un enfoque orientado a objetos para el desarrollo de
software fue a finales de los años 60. Sin embargo, las tecnologías de objetos han
necesitado casi 20 años para llegar a ser ampliamente usadas.
El propósito del ADOO es definir todas las clases que son relevantes al problema que se
va a resolver, las operaciones y atributos asociados, las relaciones y comportamientos
asociados con ellos. El diseño orientado a objetos transforma el modelo de análisis
creado usando análisis orientado a objetos, en un modelo de diseño que sirve como
anteproyecto para la construcción de software.

32. 29
2.2.1 ¿Qué es un Objeto?
Un objeto es la representación de una entidad. Un objeto puede representar algo concreto como una
estructura, etc. Un objeto es una abstracción. Un objeto tiene estado y comportamiento. Véase figura
17. ESTADO: El estado cambia con el tiempo y está definido por un conjunto de propiedades
(atributos). COMPORTAMIENTO: El comportamiento es todo lo que un objeto puede hacer.
Figura 17. Objeto: estructura; comportamiento: deformarse.
2.2.2 ¿Qué es una Clase?
Una clase es la plantilla de un grupo de objetos con propiedades comunes (atributos) y
comportamientos comunes (operaciones). Cada objeto es la instancia de una clase (véase figura 18).
Los mensajes son los mecanismos de comunicación entre objetos.
Figura 18. Ejemplo: clase automóvil.
2.2.3 Encapsulación
Encapsular datos y comportamiento en un simple objeto es de vital importancia en el desarrollo OO. La encapsulación
garantiza que los usuarios de un objeto no puedan modificar su estado sin usar su interfaz (métodos accesibles por otros
objetos). Laventajadelaencapsulación radicaenquesise modificaalgo deunmódulo internosin alterarsu interfaz,dicho
cambionoimplicaríaningunamodificaciónenelsistema.Véaselafigura9.

33. 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 atributosy métodospúblicos son considerados interfaces. Elusuariodeun objetodebería interactuar con el mismo
únicamentepormediodelasinterfacesynodeberíapodervernadadelaimplementación.Véasefigura19.
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
plantapuedeserhidroeléctricaonuclearlocualnoimportamientrassedéenergíaeléctricaalacomputadora.
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.

34. 31
2.2.6 Superclases y Subclases
La superclase (o clase padre) contiene todos los atributos y comportamientos que son comunes a las
clases que heredan de ella. Estas clases que heredan de ella se denominan subclases. Véase figura 20.
2.2.7 Abstracción
En la tecnología OO las clases son la abstracción fundamental. Mediante la abstracción separte de algunos casos concretos
de entidades (objetos) y se generan clases. La abstracción consiste en estudiar los conceptos fundamentales del dominio de
estudioobviandotemporalmentelasdecisionesdediseñoeimplementació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éasefigura20.
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,

35. 32
circunferencias, elipses y polígonos), la operación fundamental del cálculo del área se brinda al polimorfismo. Véase
figura21.
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
objetossiemprecontienenotrosobjetos. Porejemplo,uncarrotieneunmotor,tienesuspensiónytienetransmisión.Véasela
figura22.
Relación “tiene un”
Aunque la relación de herencia es considerada una relación “es un tipo de” por razones discutidas
anteriormente, una composición es referida como una relación “tiene un”.
Figura 22. La jerarquía de la clase Carro.
+calcArea() : double
‐area : double
Figura
+calcArea() : double
‐largo : double
‐ancho : double
Rectangulo
+calcArea() : double
‐radio : double
Circulo

36. 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 Clases Abstractas
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 Interface Java
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.

37. 34
Figura 23. El proceso de análisis en la ingeniería del software.
2.3 Lenguaje Unificado de Modelado (Unified Modeling Language
UML)
El UML es un lenguaje para el modelado orientado a objetos. El UML permite a los
creadores de sistemas generar diseños que capturan sus ideas en forma convencional y
fácil de comprender para comunicarlas a otras personas. Esto se lleva a cabo mediante un
conjunto de símbolos y diagramas. Un modelo UML describe lo que supuestamente hará
el sistema pero no dice cómo implementar dicho sistema. El UML está compuesto por
diversos elementos gráficos que se combinan para conformar diagramas.
El UML es la creación de Grady Booch, James Rumbaugh e Ivar Jaacobson. En 1997 se
produjo la versión 1.0 del UML. El UML ha llegado a ser el estándar de facto en la
industria del software y su evolución continúa. Actualmente ya se ha superado la versión
2 del UML.
2.3.1 Diagramas de UML
Se trata de herramientas para modelar las diferentes vistas de un sistema OO. Cada diagrama tiene
fines distintos dentro del proceso de desarrollo.

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

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

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

41. 38
Figura 29. Diagrama de componentes.
Figura 30. Diagrama de distribución.
2.4 Metodologías de Desarrollo
La estructura y naturaleza de los pasos en un esfuerzo de desarrollo es lo que se entiende
como metodología. Antes del desarrollo de un programa, se debe comprender con
claridad el problema lo cual requiere un análisis de requerimientos. Luego, dicho análisis
tiene que convertirse en diseño. De ésta manera se puede comenzar a producir el código
a partir del diseño. Véase también la figura 23.
Las metodologías de desarrollo iniciales como el método en cascada establece que el
análisis, diseño, codificación y distribución van uno después de otro. Esta metodología
antigua tiene la desventaja de tender a la realización de tareas individuales. Existe la
posibilidad de que el analista, el diseñador y el desarrollador rara vez trabajen juntos
para compartir puntos importantes.
Métodos recientes
En contraste con el método en cascada, la ingeniería del software tiende a la
colaboración entre las fases de desarrollo. La ventaja es que conforme crece la
comprensión, el equipo incorpora nuevas ideas y genera un sistema más confiable.

42. 39
Figura 31. Metodología en cascada.
2.4.1 Proceso Racional Unificado (RUP)
RUP es un proceso de desarrollo de software para asegurar la producción de software de calidad dentro
de plazos y presupuestos predecibles. Dirigido por casos de uso, centrado en la arquitectura, iterativo e
incremental (versiones). RUP es una guía de cómo usar UML de la forma más efectiva. UML es la
base del modelamiento visual de RUP.
RUP divide el proceso de desarrollo en ciclos teniendo un producto al final de cada ciclo. Cada ciclo se
divide en cuatro Fases: 1) Inicio 2) Elaboración 3) Construcción 4) Transición. Cada fase concluye con
un hito bien definido donde deben tomarse ciertas decisiones. Véase figura 32.
En la fase inicio se producen requerimientos generales del proyecto, características principales,
restricciones y un modelo inicial de casos de uso.
En la fase de elaboración se tienen como objetivos: analizar el dominio del problema, establecer una
arquitectura base sólida y desarrollar un plan de proyecto. Es la parte más crítica del proceso.
En la fase construcción todas las componentes restantes se desarrollan e incorporan al producto. Todo
es probado en profundidad. El énfasis está en la producción eficiente y no en la creación intelectual.
El objetivo de la fase transición es traspasar el software desarrollado a la comunidad de usuarios. Una
vez instalado surgirán nuevos elementos que implicarán nuevos desarrollos (ciclos).

43. 40
Figura 32. Metodología RUP
2.4.2 Métodos Agiles
Las metodologías ágiles imponen un proceso disciplinado sobre el desarrollo de software
con el fin de hacerlo más eficiente. Los métodos ágiles son adaptables en lugar de
predictivos. Los métodos ágiles son orientados a la gente y no orientados al proceso.
Están a favor de la naturaleza humana y enfatizan que el desarrollo de software debe ser
una actividad agradable.
Desarrollo Adaptable de Software (ASD)
Esta metodología se adapta al cambio en lugar de luchar contra él. Se basa en la
adaptación continua a circunstancias cambiantes. En ella no hay un ciclo de
planificación-diseño-construcción del software. En el corazón de ASD hay tres fases
solapadas no lineales: especulación, colaboración, y aprendizaje. ASD es un método
iterativo, orientado a componentes de software, tolerante a cambios, guiado por riesgos
donde la revisión de los componentes sirve para aprender de los errores y volver a iniciar
el ciclo de desarrollo. Véase figura 33.

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

45. 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ón Orientada a Objetos
De la exposición anterior, se deduce que, la programación orientada a objetos es una filosofía de la que
surge una cultura nueva que incorpora técnicas y metodologías diferentes. En ella el universo
computacional está poblado por objetos, cada uno responsable de sí mismo, y comunicándose con los
demás por medio de mensajes. Cada objeto representa una instancia de alguna clase, y estas clases son

46. 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ón de Lenguajes
Lenguajes imperativos: Son aquellos basados en sentencias, ya sean procedurales, orientados a objetos
puros o mixtos. Entre ellos se cuentan Pascal, C, C++, Java, Fortran, Perl y Python.
Lenguajes procedurales: Son lenguajes imperativos basados en procedimientos (o rutinas) y funciones.
Entre ellos podemos nombrar a C, Fortran, Pascal (estándar) y Basic.
Lenguajes orientados a objetos: Son lenguajes imperativos basados en clases (algunos, llamados mixtos
soportan también el modelo procedural). Entre los lenguajes orientados a objetos puros podemos
nombrar a Smalltalk, Eiffel y Java. Entre los mixtos se encuentran C++ y Python.
Lenguajes funcionales: Son aquellos basados en funciones matemáticas (y no en comandos o
sentencias). Podemos nombrar aquí a ML, Haskell y Lisp.
2.6 Estado del Arte
Debido a la revolución de las computadoras, durante los últimos 40 años, el método de los elementos
finitos MEF ha sido ampliamente aceptado como herramienta para el modelado y simulación de
estructuras en la ingeniería.
Los programas de MEF siempre han consistido en miles de líneas de código mayormente escritos en
lenguajes basados en procedimientos como FORTRAN y C. Todas las herramientas conocidas hasta la
fecha producen los resultados del cálculo estructural (las fuerzas internas) usando un solo sistema de
ejes locales para ambos extremos de los elementos (elemento viga) dejando al ingeniero la
interpretación y modificación del resultados. En ésta investigación se pretende llegar a la
implementación de un modelo MEF que produzca resultados exactos para ambos extremos de los
elementos.

47. 44
2.6.1 Antecedentes y Trabajos Previos
[Archer 2000] diseñó e implementó un sistema para el MEF. Su diseño describe la
abstracción para cada clase y especifica su interfaz para tal abstracción. Se verifica que la
implementación de cada clase y la interacción entre objetos cumplan con la interfaz definida.
Además reconoce que el desarrollo de elementos infinitos involucra la adición de nuevos
elementos, nuevas estrategias de solución o nuevos esquemas de almacenamiento
matriciales; razón por la cual, presta especial cuidado a hacer las interfaces lo más flexibles
posibles.
La transformación entre sistemas de coordenadas es muy tomada en cuenta. Véase la figura
34. Recuerde que DOF se traduce como grados de libertad (degrees of freedom en inglés).
Archer planteó un modelo OO generalizado para elementos finitos. En ésta investigación se
propone un modelo OO específico - elemento viga con un sistema de ejes locales
Kardestuncer.
Figura 34. Modelo orientado a objetos propuesto por Archer.

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

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

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

51. 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_SpaceProgramming2008]desarrollóenC++unalibreríamatemáticaconunconjuntodeobjetosmatemáticamente
integrablesy diferenciables. La librería es una herramienta para desarrollar rápidamente aplicaciones de cálculo. La librería
estádirigidaaaplicacionesOOparaelFEMqueinvolucrenanálisisnuméricoavanzado,programaciónlineal,optimización,
métodosdelasdiferenciasfinitasymétodosvariacionales.
SetratadeunalibreríaenC++paraprogramasOOsobreelFEMqueademásdisponedemétodosnuméricosavanzados. En
ésta investigación se implementará en Java una librería OO específica para problemas estructurales mediante elementos
finitos. Noseprogramaránmétodosnuméricosavanzados.

52. 49
Parte 3 ‐ Desarrollo Teórico Práctico
El desarrollo teórico práctico que se presenta en éste artículo corresponde al avance actual de ésta
investigación. El estado actual de ésta investigación es más que inicial y completamente funcional.
3.1 Declaración de Trabajo
Una estructura se compone de nudos y elementos (elemento viga doblemente
empotrada). Cada elemento parte de un solo nudo y termina en un solo nudo. Puede
haber varios elementos que parten de un mismo nudo o que terminan en un mismo
nudo. Un elemento puede tener solo un conjunto de propiedades de la sección (módulo
de elasticidad, área y momento de inercia). Puede haber varios elementos que tengan
las mismas propiedades de la sección. Un elemento puede tener solo un conjunto de
fuerzas internas (fuerza axial, fuerza cortante y momento flector). 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.

53. 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
literal de la estructura, un listado de las coordenadas globales (X, Y) de sus nudos,
un listado de las incidencias de sus elementos, un listado de las cargas puntuales
sobre sus nudos, un listado de las cargas puntuales y/o distribuidas sobre sus
elementos, y un listado de las condiciones de contorno (restricciones o apoyos).
La información que se requiere luego del cálculo de una estructura consiste en: la
matriz global de rigidez, el vector generalizado de fuerza, el vector generalizado de
desplazamiento, las fuerzas internas en los extremos de los elementos según el
sistema 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á llevarse a cabo por medio del método de los
elementos finitos empleado en ingeniería estructural conforme el extenso desarrollo
de la sección “marco teórico” de éste informe.

54. 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 literal de la estructura.
3. Al usuario se le deberá proveer de un campo que permita la introducción de las
coordenadas (X, Y) de los nudos de la estructura.
4. Al usuario se le deberá proveer de un campo que permita la introducción de las
incidencias, de las propiedades geométricas y de las propiedades inerciales de
los elementos de la estructura.
5. Al usuario se le deberá proveer de campo que permita la introducción de las
cargas puntuales aplicadas en los nudos de la estructura.
6. Al usuario se le deberá proveer de un campo que permita la introducción de las
cargas puntuales y/o distribuidas que actúan sobre los elementos de la
estructura.
7. Al usuario se le deberá proveer de un campo que permita la introducción de las
condiciones de borde (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 solicitar el análisis de la
estructura.
10. Al usuario se le deberá proveer archivos de un formato estándar que permita
acceder de manera tabulada a los resultados numéricos del análisis de la
estructura.
11. Al usuario se le deberá proveer de un archivo para acceder a los resultados
numéricos de la matriz global de rigidez de la estructura.

55. 52
12. Al usuario se le deberá proveer de un archivo para acceder a los resultados
numéricos del vector generalizado de fuerza de la estructura.
13. Al usuario se le deberá proveer de un archivo para acceder a los resultados
numéricos del vector generalizado de desplazamiento de la estructura.
14. Al usuario se le deberá proveer de un archivo para acceder a los resultados
numéricos de las fuerzas internas en los extremos de los elementos de la
estructura.
15. Al usuario se le deberá proveer de un archivo para acceder a los resultados
numéricos de las reacciones en los apoyos (i. e. nudos restringidos mediante las
condiciones de contorno) de la estructura.
16. Al usuario se le deberá proveer de una interfaz gráfica para verificar la
deformada resultante del análisis de la estructura.
17. Al sistema se le deberá proveer la implementación de un modelo que permita el
análisis de la estructura mediante el método de los elementos finitos - elemento
viga doblemente empotrada sistema de ejes locales Kardestuncer según el
extenso desarrollo 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
rigidez la estructura.
22. Al sistema se le deberá proveer una rutina para aplicar las condiciones de
contorno de la estructura.
23. Al sistema se le deberá proveer una rutina para resolver el sistema de ecuaciones
de la estructura.
24. Al sistema se le deberá proveer una rutina para calcular las fuerzas internas en
los extremos de los elementos de la estructura.

56. 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 sistema.
1. La aplicación debe ser desarrollada utilizando Java para permitir que en el futuro
usuarios familiarizados con este lenguaje puedan añadir más funcionalidades y
mantenerlo.
2. El sistema debe accederse a través de la máquina virtual de Java.
3. Periféricos disponibles para la usabilidad: teclado y ratón.
4. El sistema 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álisis de requerimientos son “el usuario” y “el
sistema” conforme se muestran en los casos de uso de las figuras 39 a la 41. En
general, es posible detallar con mayor profundidad la mayoría de los casos uso. En
la figura 41 se detalla el caso de uso “introducir condiciones de contorno”. A este
concepto se conoce como “inclusión de caso de uso”.

57. 54
Figura 39. Caso de uso – actor “el usuario”
Figura 40. Inclusión de caso de uso “introducir condiciones de contorno”.
Usuario
Introducir las
condiciones de frontera
Introducir código
de nudo
Introducir restricción
al desplazamiento
horizontal
Introducir restricción
al desplazamiento
vertical
« incluir »
« incluir »
« incluir »
Introducir
restricción al giro
« incluir »

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

59. 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 las
propiedades de los elementos
Introducir módulo de
elasticidad (E)« incluir »
Introducir momento
de inercia (I)
« incluir »
Introducir área de
la sección (A)
« incluir »
Introducir código de
nudo de partida
« incluir »
Introducir código de
nudo de llegada
« incluir »
Usuario
Introducir las cargas
puntuales en los nudos
Introducir código
de nudo
Introducir la
componente horizontal
Introducir la
componente vertical
« incluir »
« incluir »
« incluir »
Introducir el
momento flector
« incluir »

60. 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 cargas
sobre los elementos
Introducir código
de elemento
Introducir tipo de
carga
Introducir carga
puntual
« incluir »
« incluir »
« incluir »
Introducir inicio
de aplicación« incluir »
Introducir longitud
de aplicación
« incluir »
Usuario
Solicitar el
cálculo estructural
Verificar
gráficamente la estructura
Autorizar el
análisis estructural
« incluir »
« incluir »