Elementos Finitos Con Computadoras PDF

UNIVERSIDAD NACIONAL DE CAJAMARCA
Escuela Acadmico Profesional de Ingenieria Civil
TESIS
Para Obtener Titulo de Ingeniero Civil
Analisis Estructural de Elementos Finitos Asistido por Computadora.
Tesista: Bach.Christian Gonzalo Salcedo Malaver.
Asesor: Ing.Marco Mendoza Linares.
Segundo Informe de Tesis.
Febrero del 2014.
Parte I
SECCIN PRELIMINAR.
Universidad Nacional de Cajamarca.
Asesor:Ing Marco Mendoza Linares.
Mtodo de Elementos Finitos.
Tesista:Christian G. Salcedo Malaver
2014.
AGRADECIMIENTOS:
* A mi madre a la cual le debo la vida, lo que soy y lo que pretendo ser, por que siempre
estubo en mis aciertos y mis fracasos y me enseo la constancia de la vida con su ejemplo.
* A mi padre al que le debo su ejemplo y su coraje para enfrentar los problemas,el que me
demostro que los fracasos de la vida son solo retos para algo mas grande.
* A mis profesores que con su esfuerzo y buen nimo me aconsejaron y me ensearon en

todos estos aos.
2014.
RESUMEN
La presente tesis trata el tema de clculo de Estructuras con el mtodo de elementos
nitos la cual se desarrollara primero con el aprendizaje del mtodo y despues la aplicacin a diferentes sistemas tanto sencillos como complejos la cual se desarrollar un software
en Python en el sistema Windows para ejemplos teoricos y simples.
Se comparara los resultados obtenidos en los scripts programados de Python con softwars ociales como el SAP y se vericara los porcentajes de diferencia entre cada uno de
los resultados.
ndice general
I SECCIN PRELIMINAR.
II INTRODUCCIN Y OBJETIVOS.
1. INTRODUCCIN Y OBJETIVOS.
1.1.
10
INTRODUCCIN. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.1.1.
Elemento Continuo y Discreto.
10
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
1.2.
BREVE HISTORIA DEL METODO DE ELEMENTOS FINITOS. . . . . . . . . . . . . . . . . .
10
1.3.
APLICACIONES DEL METODO. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
1.3.1.
Aplicaciones al Analisis Estructural.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
1.3.2.
Aplicacion en Mecnica de Fluidos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
III MARCO TERICO
15
2. MTODO DE ELEMENTOS FINITOS
16
2.1.
Deformaciones.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
2.2.
Tensiones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
18
2.3.
Fuerzas nodales equivalentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
18
3. ANLISIS DE VIGAS.
19
3.1.
VIGAS SOMETIDAS A FUERZA AXIAL.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.
ANLISIS DE FLEXIN EN UNA VIGA.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
23
3.2.1.
Teoria de Flexion de Viga de Euler y Bernoulli. . . . . . . . . . . . . . . . . . . . . . . . .
23
3.2.2.
Discretizacin de elementos nitos de dos nodos.
3.2.3.
Matriz de Rigidez Viga Bernoulli.
24
27
3.2.4.
Teoria de Flexin de Viga de Timoshenko . . . . . . . . . . . . . . . . . . . . . . . . . . .
28
3.2.5.
Elementos nitos para exin de vigas de Timoshenko. . . . . . . . . . . . . . . . . . . . .
29
3.2.6.
3.3.
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Matriz de Rigidez Total V.Timoshenko y Efecto de Bloqueo.
31
PROGRAMA DE VIGAS HECHA EN PYTHON.
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
33
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
33
3.3.1.
Que es Python?.
3.3.2.
Librerias Principales de python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
34
3.3.3.
Programa hecho en python
35
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4. PROBLEMAS DE ELASTICIDAD BIDIMENCIONAL.
40
4.1.
Introduccin.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
40
4.2.
Teoria de la Elasticidad Bidimensional. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
41
4.2.1.
Campo de Desplazamientos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
41
4.2.2.
Campo de Deformaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
42
4.2.3.
Campo de Tensiones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
42
4.2.4.
Relacin Tensin - Deformacin.
42
4.2.5.
Formulacin de Elementos Finitos.Elemento de tres Nodos.
4.2.6.
Discretzacin del Campo de Desplazamiento.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
45
. . . . . . . . . . . . . . . . . . . . . . . . .
45
2014.
4.2.7.
Discretizacin del campo de tensiones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
49
4.2.9.
4.3.
Discretizacin del campo de deformaciones.
4.2.8.
. . . . . . . . . . . . . . . . . . . . . . . . . .
Ecuaciones de Equilibrio de la Discretizacin. . . . . . . . . . . . . . . . . . . . . . . . . .
49
Otros Elementos Bidimensionales y el Mtodo de Interpolacin de Lagrange.
. . . . . . . . . . .
51
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
54
4.3.1.
Elementos Lineales.
4.3.2.
Interpolacin de alta jerarquia de clase
4.3.3.
Elementos de Transicin.
4.3.4.
4.4.
Elementos Triangulares y tetahedricos de clase
C0 ,Interpolacin
. . . . . . . . . . .
58
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
66
C 0.
Lagrangiana.
. . . . . . . . . . . . . . . . . . . . . .
Calculo Analtico sobre Elementos Triangulares y Rectangulares de lados rectos.
. . . . . . . . .
5. SLIDOS DE REVOLUCIN.
5.1.
Introduccin.
5.2.
Formulacin Bsica.
48
68
71
73
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
73
73
5.2.1.
Campo de Desplazamiento.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
73
5.2.2.
Campo de Deformaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
74
5.2.3.
Campos de Tensiones.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
74
5.2.4.
Ecuacin Constitutiva. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
74
5.2.5.
Expresin del Principio de los Trabajos Virtuales.
. . . . . . . . . . . . . . . . . . . . . .
75
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
76
5.3.1.
Discretizacin del campo de desplazamientos. . . . . . . . . . . . . . . . . . . . . . . . . .
76
5.3.2.
Discretizacin del campo de deformaciones y tensiones.
77
5.3.3.
Matriz de Rigidez del Elemento.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
77
5.3.4.
5.3.
Vectores de fuerzas nodales equivalentes. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
78
Formulacin de Elementos Finitos.
. . . . . . . . . . . . . . . . . . .
IV EJEMPLOS DE CLCULO DE ELEMENTOS FINITOS.
79
6. Ejemplos y Problemas de Elementos Finitos.
80
6.1.
Vigas.
6.1.1.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
80
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
80
Porticos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
85
6.2.1.
6.2.
Problema N01:
85
Problema N02.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
V CRITERIOS DE PROGRAMACIN-(USOS DEL PROGRAMA)
89
7. Programacin general del Femax.
90
7.1.
Caracteristicas del Programa Femax. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
90
7.1.1.
Puesta de Datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
90
7.1.2.
Matriz de Rigidez.
99
7.1.3.
Calculo de Deformaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
7.1.4.
Clculo de Fuerzas Internas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
7.1.5.
Gracos y tablas de Resultados de Momentos,Cortantes,Deformada y Cortantes.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . 107
VI CONCLUSIONES Y RECOMENDACIONES.
112
8. Conclusiones y Recomendaciones.
113
8.1.
Conclusiones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
8.2.
Recomendaciones.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
VII CODIGO FUENTE DEL PROGRAMA FEMAX.
114
ndice de guras
1.1.
Aplicaciones del FEM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12
1.2.
Interaccin suelo Estructura.
12
1.3.
Mecnica de Fluidos FEM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13
1.4.
Idealizacin de un sistema de Fluidos.
13
1.5.
Puente Idealizado con Elementos Finitos.
2.1.
Analisis de un sistema continuo.
2.2.
3.1.
funciones de forma de viga
3.2.
funciones de forma de viga
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
3.3.
funciones del Sistema Natural de tres nodos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22
3.4.
Viga Convencional Euler-Bernulli . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
24
3.5.
Funciones de forma
3.6.
Funciones de forma
3.7.
Viga con giro Adicional
3.8.
Analisis de Vigas tanto en Momento como en Cortante.
. . . . . . . . . . . . . . . . . . . . . . .
29
3.9.
Analisis de Viga en Voladizo V.Timoshenko. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
32
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
Estado general de Esfuerzos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
N1
N2
y
y
C0
C0
N1
N2
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
20
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
26
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.10. Una de las librerias de python.
28
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
33
3.11. Simbolo de Numpy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
35
4.1.
Elementos en Tensin Plana y Deformacin Plana.
40
4.2.
Tension Plana . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.
Material Orttropo con direcciones principales de ortotropia
4.4.
Discretizacion de una Estructura con Elementos Triangulares. . . . . . . . . . . . . . . . . . . . .
46
4.5.
Elemento discretizado en forma Triangular.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
47
4.6.
Funciones de forma del elemento triangular de tres nodos. . . . . . . . . . . . . . . . . . . . . . .
48
4.7.
Fuerza Sobre un elemento triangulo de tres nodos . . . . . . . . . . . . . . . . . . . . . . . . . . .
50
4.8.
Interpolacin de Coordenadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
52
4.9.
Espacios Triangular y Rectangular
52
. . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
41
44
4.10. Mapeo entre los puntos del espacio Natural y el Espacio Cartesiano . . . . . . . . . . . . . . . . .
53
4.11. Mapeo del espacio natural al espacio real para un elemento lineal unidimensional . . . . . . . . .
54
4.12. Funciones de forma para un elemento lineal Unidimensional. . . . . . . . . . . . . . . . . . . . . .
55
4.13. Elemento bilineal de cuatro nodos.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
57
4.14. Mapeo del espacio natural bidimensional al espacio cartesiano real. . . . . . . . . . . . . . . . . .
57
4.15. Elemento Unidimensional de dos nodos.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
59
4.16. Elemento Unidimensional de tres nodos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
60
4.17. Funciones de Forma Cudratica Lagrangiana. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
60
4.18. Elemento bidimensional de cuatro nodos.
61
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.19. Discretizacin del elemento bidimensional de cuatro nodos
N1
N2
N3
N4
. . . . . . . . . . . . . . . . . . . .
62
. . . . . . . . . . . . . . . . . . . .
63
. . . . . . . . . . . . . . . . . . . .
64
. . . . . . . . . . . . . . . . . . . .
64
4.23. Elemento Bidimensional de nueve nodos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
65

2014.
4.24. Elementos de Discretizacin lineal y bidimensional. . . . . . . . . . . . . . . . . . . . . . . . . . .
66
4.25. Transicin de Malla Cuadrtica.
66
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.26. Elemento de transicin lineal cuadrtico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
67
4.27. Elemento Triangular de tres nodos denido en coordenadas triangulares. . . . . . . . . . . . . . .
68
4.28. Patrn para generar elementos de alta jerarquia en coordenadas triangulares.
. . . . . . . . . . .
70
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
70
4.29. Elemento Triangular de 6 nodos.
4.30. Coordenadas x',y' para el clculo analtico de las integrales de elementos triangulares y rectangulares.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
72
5.1.
Slido de Revolucin. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
73
5.2.
Tensiones actuando sobre un elemento diferencial de un solido de revolucin.
5.3.
Elemento slido de Revolucin triangular de tres nodos.
6.1.
Primer Problema para uso del Programa Femax.
6.2.
Puesta de Datos de Materiales.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
80
6.3.
puesta de datos total del esquema a prueba. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
81
6.4.
Puesta de datos en Sap 2000 V14.
6.5.
Matriz de Rigidez obtenida por Femax.
6.6.
Comparacin de Resultados de Desplazamientos.
. . . . . . . . . . . . . . . . . . . . . . . . . . .
83
6.7.
Comparacin de Resultado de Fuerzas Int. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
83
6.8.
Comparacion de Gcos del Femax con Sap 2000 V14. . . . . . . . . . . . . . . . . . . . . . . . .
84
6.9.
Esquema del Problema N02. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
85
6.10. Puesta de Datos en Sap 2000 V14.
. . . . . . . . . . .
75
. . . . . . . . . . . . . . . . . . . . . . .
76
. . . . . . . . . . . . . . . . . . . . . . . . . . .
80
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
81
82
85
6.11. Puesta de Datos en Femax 1.01 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
86
6.12. Comparacin de los desplazamientos en Femax y Sap 2000 V14. . . . . . . . . . . . . . . . . . . .
86
6.13. Matriz de Rigides General del esquema.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
87
6.14. Comparacin de Fuerzas Internas del Femax y el Sap 2000 V14. . . . . . . . . . . . . . . . . . . .
87
6.15. Comparacin Graca del Sap 2000 V14 y el Femax.
88
. . . . . . . . . . . . . . . . . . . . . . . . .
7.1.
Diagrama de ujo del programa Femax.
7.2.
Entorno Grco del Femax y su funcin de Grilla y su resultado
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
91
7.3.
Descripcin de trazo de Barras en Femax.
7.4.
Trazo de las barras en el Programa Femax.
7.5.
Subrutina de Materiales del programa Femax
7.6.
Apoyo Fijo y sus propiedades de contorno. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
96
7.7.
Apoyo Empotrado y sus propiedades de contorno.
. . . . . . . . . . . . . . . . . . . . . . . . . .
97
7.8.
Apoyo Movil y sus propiedades de contorno. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
97
7.9.
Apoyos en el cuadro de dilogo del Femax. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
99
7.10. Marco de Referencia. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
99
. . . . . . . . . . . . . . . . . .
92
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
93
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.11. Procedimiento del ensamblaje global por medio del mtodo

7.12. Tabla de Resultado de la Matriz de Rigidez Total Femax.
94
96
. . . . . . . . . . . . . . . . . . . . 100
. . . . . . . . . . . . . . . . . . . . . . 103
7.13. Generacin de tabla de Resultados de la tabla de las deformadas Femax. . . . . . . . . . . . . . . 105

7.14. Tabla de Resultados para el clculo de Fuerzas Internas del programa Femax. . . . . . . . . . . . 107
7.15. Graca de Resultados del Analisis del Femax de
ui ,i ,Mi ,Vi .
. . . . . . . . . . . . . . . . . . . . . 111
ndice de cuadros
3.1.
Valores por cada caso de discretizacin de la Barra. . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.
Relacin entre nodos de los elementos lineales y sus coordenadas naturales.
. . . . . . . . . . . .
54
4.2.
Relacin de los nodos del elemento bilineal y sus coordenadas naturales. . . . . . . . . . . . . . .
58
4.3.
Ordenamiento de elementos en dos dimensiones. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
62
4.4.
Tabla nodal del problema de nueve nodos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
65
6.1.
Matriz de Rigidez General hallada por el programa Femax.
. . . . . . . . . . . . . . . . . . . . .
82
6.2.
Matriz simplicada copiada del Femax. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
82
6.3.
Tabla de Comparacin del Calculo de los Desplazamientos.
83
6.4.
Comparacin de Resultados de Fuerzas Internas de Sap 2000 V14 y Femax.
. . . . . . . . . . . .
84
6.5.
Tabla de comparacin de las Deformaciones Sap y Femax. . . . . . . . . . . . . . . . . . . . . . .
87
6.6.
Tabla de Comparaciones de Calculo de Reacciones del esquema. . . . . . . . . . . . . . . . . . . .
88
. . . . . . . . . . . . . . . . . . . . .
24
Parte II
INTRODUCCIN Y OBJETIVOS.
Captulo 1
INTRODUCCIN Y OBJETIVOS.
1.1.
INTRODUCCIN.
El Proceso de aproximar el comportamiento de un elemento continuo mediante Elementos nitos que se

comportan de una forma similar a los elementos reales Discretos,se puede introducir mediante aplicaciones
sicas especicas o como un concepto matemtico general.
1.1.1. Elemento Continuo y Discreto.

Las limitaciones de la mente humana son tales que no pueden captar el comportamiento que el complejo
mundo que lo rodea en una sola operacin global.Por ello,una forma natural de proceder de ingenieros consiste
en separar los sistemas en sus componentes individuales,o Elementos,cuyo comportamiento pueden conocerse
sin dicultad,y a continuacin reconstruir el sistema original para estudiarlo a partir de dichos componentes.
En muchos casos se obtiene un modelo adecuado usando un numero nito de componentes bien denidos.A
tales problemas los denominaremos Discretos. En otros,las subdivision prosigue indenidamente y el problema
solo puede denirse haciendo uso de la ccin matemtica innitsimo.
Ello nos conduce a ecuaciones diferenciales o expresiones equivalentes con un numero innito de elementos
implicados. a tales sistemas los llamaremos continuos.
Su campo de aplicacin de este mtodo es muy amplio,y en consecuencia es una herramienta importante en las
nuevas formas de analizar y simular fenmenos estructurales,as como tambien en el campo de la hidraulica y
la geotecnia.
1.2.
BREVE HISTORIA DEL METODO DE ELEMENTOS FINITOS.
Los Conceptos de discretizacin numrica para resolver problemas de Ciencia e ingenieria son la base para la
formulacin del mtodo de elemento nito.La aproximacin geomtrica ms antigua lleva a las piramides egipcias de 5000 aos.Por otro lado la aproximacin Numerica podria registrarse historicamente en china,Egipto y
Grecia.
Los Registros muestran que los chinos calcularon el valor aproximado de
en el primer siglo de nuestra
era,con un valor de 3.1547 siendo usado para calcular el volumen de un cilindro.
142
45 ,en la Dinastia
oriental de Jihn(265-317 E.C) en su comentario de matematicas uso un polgono regular inscrito en una cirEn el segundo siglo E.C el astronomo Chang Heng aproxim el valor de
cunferencia para poder aproximar
como 3.1466
la cual hallo un valor de 3.1416 (3927/1250);es interesante notar que el
uso un poligono de 3072 lados,es decir elementos nitos. De acuerdo con el manuscrito Ahmes, se muestra que
para 1500 A.C. , los Egipcios usaban como valor de
= 3,1416.
10
Un papiro de tiempos mas tempranos, ahora
2014.
en Mosc, indica que los egipcios usaron la frmula para el volumen de una pirmide y el rea de un crculo de
manera aproximada en 1800 A. C.. Arqumedes uso el concepto de elementos nitos para clcular volumenes.
En el contexto estructural, las soluciones tanto en elasticidad como en anlisis estructural tuvieron un inicio del
Mtodo del Elemento Finito con Timoshenko, pero si se considera que el anlisis de marcos establece el inicio
del mtodo del Elemento Finito, entonces los pioneros fueron Castigliano, Mhor y Maxwell, entre otros, en el
periodo 1850-1875.
En 1915, Maney de los Estados Unidos de Norteamrica, present el Metodo Pendiente-Deformacin, expresando los momentos en trminos de desplazamientos lineales y angulares en los nodos de la estructura, lo cual
es una de las formulaciones para plantear el Mtodo de las Rigideces y un desarrollo similar, fue planteado por
Ostenfeld en Dinamarca. En el ao 1929, Hardy Cross hizo pblico un Mtodo para analizar marcos basado en
distribuciones angulares, el cual se utiliz por los siguientes 35 aos.
En forma paralela a los primeros trabajos sobre anlisis de estructuras reticulares, se resolvieron problemas
de Mecnica del Medio continuo usando una analoga con estructuras formadas por barras diagonales para
generar mallas con elementos triangulares. A principios de los aos cuarenta Courant propuso funciones de
interpolacin polinomionales por secciones para formular subregiones triangulares como un caso especial del
Mtodo Variacional de Rayleigh-Ritz, que obtiene soluciones aproximadas. Actualmente, el Mtodo del Elemento Finito es utilizado con la ayuda de las computadoras, lo cual ha contribuido a su desarrollo al mismo ritmo
que las computadoras. Las publicaciones clsicas por Argyris y Kelsey a mediados de los 50-as , hicieron surgir
los conceptos de anlisis de marcos discretizando no solo en nodos sino adems en puntos intermedios de las
barras y anlisis de un continuo, lo que marc un crecimiento explosivo en el Mtodo del Elemento Finito.
Basndose en el planteamiento esttico del Elemento Finito, se han ampliado las aplicaciones que incluyen
diversos efectos fsicos y vibraciones en el Anlisis Dinmico, pandeo y post-pandeo, no linealidades en la geometra y en el material, efectos trmicos, interaccin entre uidos y estructuras, aeroelasticidad, interaccin
acstica-estructura, teora de la fractura, estructuras laminadas, propagacin de oleaje, dinmica estructural,
respuesta dinmica aleatoria, y muchas ms aplicaciones. Como una consecuencia de tantos campos de estudio,
el uso de los programas de computadora orientados a cada caso, se han convertido en una prctica en los sitios
involucrados en el anlisis estructural. [1]
1.3.
APLICACIONES DEL METODO.
Existen gran numero de Estructuras que su paso de revisin tanto como post y pre proceso de diseo,son
sometidos a rigurosos procesos de evaluacin tales como para vericacin de cortantes y ectores y saber si el
diseo dado esta corecto.
1.3.1. Aplicaciones al Analisis Estructural.

En programas como el SAP el STAAD PRO tanto en el analisis de Int-Estructura-Estructura y analisis de
Suelo-Estructura como el SAFE o el Plaxis que son de uso para el Calculo por elementos Finitos.
1.3.2. Aplicacion en Mecnica de Fluidos.

El Mtodo de Elementos nitos tambien puede ser usado en el Analisis de Mecanica de uidos librerias en
python como ECOASTER o el Fenics o Programas como Abaqus,Nastram nos pueden dar una idea de como este
elemento sico se mueve e interacciona con el mundo aplicando soluciones particulares a la formulacin de de la
ecuacin general de los uidos Navier y Stokes,idealizaciones de presas asi como simulaciones de comportamiento
de las turbulencias de los uidos en turbinas hidraulicas.
11
2014.
Figura 1.1: Aplicaciones del FEM.
Figura 1.2: Interaccin suelo Estructura.
12
2014.
Figura 1.3: Mecnica de Fluidos FEM
Figura 1.4: Idealizacin de un sistema de Fluidos.
13
2014.
Figura 1.5: Puente Idealizado con Elementos Finitos.
14
Parte III
MARCO TERICO
15
Captulo 2
MTODO DE ELEMENTOS FINITOS

Las Recetas para deducir las caracteristicas de un elemento nito de un continuo,seran presentadas bajo
una forma matematica mas detallada. Es conveniente obtener los resultados de una forma general aplicable a
cualquier situacin,pero para evitar la introduccin de conceptos mas complicados se ilustraran las expresiones
generales con un ejemplo.
u = N a
Ni xai = [N1 , N2 . . . Nn ]
a1
a2
.
.
.
an
(2.1)
Un elemento tpico e, se dene por sus nodosi, j, m, ...etc y por su contorno formado por lineas rectas.Aproximemos
Figura 2.1: Analisis de un sistema continuo.

los desplazamientos
de cualquier punto del elemnto mediante un vector
u,como
en la formula anterior.
En el caso particular de tensin plana.
u=
u(x, y)
v(x, y)
(2.2)
representa los movimientos horizontales y verticales de un punto cualquiera del elemento.
ai =
ui
vi
16
(2.3)
2014.
Los correspondientes desplazamientos de un nodo

Las funciones
Ni , Nj , Nm
i.
han de escogerse de manera que al sustituir de la ecuacin,las coordenadas de los
nodos se obtengan los correspondientes desplazamientos nodales.
2.1.
Deformaciones.
Una vez conocidos los desplazamientos para todos los puntos del elemento,pueden determinarse las deformaciones en cualquier punto.stas darn siempre resultado en relacin que podr escribirse como sigue en forma
matricial.
Figura 2.2: Estado general de Esfuerzos
= Su
= Ba
(2.5)
B = SN
Donde
(2.4)
(2.6)
es un operador lineal apropiado en los casos de la tensin plana las deformaciones se expresan en
funcion de los desplazamientos mediante las conocidas relaciones que denen al operador
= 0
determinadas ya las funciones de forma es facil obtener la matriz
17
S.
u
v
B.
(2.7)
2014.
2.2.
Tensiones.
Conociendo el contorno del material o elmento puede estar sujeto a deformaciones iniciales,tales como las
debidas a cambios de temperatura etc.Deberan diferenciarse entre Esfuerzos iniciales y Esfuerzos
que muy
bien podrian medirse,pero cuya prediccin seria imposible sin un conocimiento completo de la historia del
material.estas tensiones pueden sencillamente aadirse a las ecuaciones generales asumiendo un comportamiento
elastico lineal.
xy
2.3.
v
1
E x E y
v
1
E y E x
1
G xy
1
E
v
= E
i = D(
i =
v
E 0
1
0
E
1
0
G
0)
+ 0
x
y
xy
x
y
xy
(2.8)
(2.9)
(2.10)
Fuerzas nodales equivalentes
Son fuerzas que estan en la misma direccion de los desplazamientos de posicin
ai
correspondientemente y
deben ordenarse en direccin apropiada.

Las fuerzas distribuidas
b son por denicin las que actuan por unidad de volumen en direccin correspondientes
u de ese punto.
e
q1
e
q2
(2.11)
qi =
.
.
.
e
qn
e
bx
(2.12)
bi =
e
by
a las de desplazamientos
Para mejor entendimiento se debe dar desplazamientos arbitrarios o virtuales a los nodos para darle mas sentido
fsico. e igualando el trabajo exterior con el interior.
( i )dV +
((u)Xi )
(2.13)
([ae ]T (NiT b)dV )) = [ae ]T qi
(2.14)
Ki ai + fi = qi
(2.15)
(B T DB)dV
(2.16)
(N T b)dV
(2.17)
([ae ]T B T DBa)dV ) +
V
(ub)dV =
l
Ki =
V
fi =
V
[2]
18
Captulo 3
ANLISIS DE VIGAS.
El analisis de vigas para el estudio de elementos nitos,se hace para entender en forma elemental las diferentes
tipos de discretizaciones a elementos de simples a complejos,ya que para poder entender los analisis y clculo de
placas y slidos de revolucin es necesario entender los diferentes items del estudio de vigas tanto sometidas a
fuerzas axiales como a exiones que pueden ser tratadas por teorias muy conocidas como Bernully y Timoshenko
sobre todo entendimiento de condiciones de contorno para pasar a estadios mas complejos. [2]
3.1.
VIGAS SOMETIDAS A FUERZA AXIAL.
Una vez deducida las ecuaciones principales tanto de Tension como de deformacion,rigideces y fuerzas nodales,aplicaremos esas formulas generales al caso de vigas sometidas a fuerza axial con la cual empezariamos
los casos de aplicacion y analisis de FEM.
i = E = E
con
du
dx
(3.1)
que es el mdulo de elasticidad de la barra;en la conguracin de equilibrio de la barra,las tensionesy las
fuerzas exteriores satisfacen el
(Principio de Trabajos Virtuales) y en este caso en particular el principio
quedaria expresado de la siguiente manera.
( )dV =
V
(ub)dx +
0
EA
0
Bueno usando la aproximacion de una deformacion
u0 + a1 x,como
du
=
dx
(ui Xi )
ubdx +
0
ui
(3.2)
i=1
p
ui Xi
(3.3)
i=1
la cual estaria aproximada a una ecuacion lineal
ui =
ya se vio en el capitulo anterior lo que tiene es hallar las funciones de forma.
ui = N1 a1 + N2 a2
(3.4)
(3.5)
Analizando la generalizacin de las deformaciones de la ecuacin lineal tendriamos.
u1 = a0 + a1 x1
(3.6)
u2 = a0 + a1 x2
(3.7)
Solucionando el problema de los casos tanto de
a0
a1
se propondria:
u1 u2
x1 x2
x2 u1 x1 u2
a1 =
x2 x1
a0 =
19
(3.8)
(3.9)
2014.
C0
Figura 3.1: funciones de forma de viga
Para una mejor trabajabilidad de los dos casos hay que tomar en cuenta las secciones anteriores donde tendriamos
Ni ...Nm
los cuales son las funciones de forma entonces sabiendo que
x2
(
x1
dN2
dN1
u1 )AE(
u2 )
dx
dx
Agrupando terminos tanto en
u1
como
2 u2 ,se
x2
dN1
dN1
(EA)
u1 +
dx
dx
x1
x2
dN2
dN2
(
(EA)
u1 +
dx
dx
x1
(
x2 x1 = le ,se
tendria que:
x2
[N1 u1 + N2 u2 ] = u1 X1 + u2 X2
(3.10)
x1
obtendria la formula siguiente:
dN1
dN2
(EA)
u2 )dx
dx
dx
dN2
dN1
(EA)
u2 )dx
dx
dx
x2
N1 bdx X1 = 0
(3.11)
N1 bdx X2 = 0
(3.12)
x1
x2
x1
Acomodando con un arreglo matricial:
x2
x1
( dN1 (EA) dN1 )

dx
dx
( dN1 (EA) dN2 )

dx
dx
( dN2 (EA) dN2 )

dx
dx
( dN2 (EA) dN1 )

dx
dx
dx
u1
u2
x2
x1
N1
N2
bdx =
X1
X2
(3.13)
con la cual obtenemos que para este caso de vigas sometidas a tension tendriamos las siguientes formulas:
ki ai + fi = qi
x2
Ki =
x1
( dN1 (EA) dN1 )

dx
dx
( dN2 (EA) dN2 )
dx
dx
( dN1 (EA) dN2 )

dx
dx
( dN2 (EA) dN1 )
dx
dx
(3.14)
x2
T
(Bi DBi)dx
dx =
(3.15)
x1
x2
fi =
x1
N1
N2
bdx
(3.16)
En elementos nitos se hablan de coordenadas naturales,pues se analizan en espacio natural la mayoria de sus
geometrias,llevando esta solucin ah espacio natural.
Por interpolacin del polinomio de lagrange se hace un analisis de interpretacin gemetrica.
Ni =
( 1 )( 2 ) . . . ( n )
(i 1 )(i 2 ) . . . (i n )
n
Ni =
(
i=1
20
j
)
i j
(3.17)
(3.18)
2014.
Figura 3.2: funciones de forma de viga
C0
Resolviendo la formulacin por el polinomio de lagrange para el caso de dos nodos quedaria de la suiguiente
manera.
1
)
2
1+
N2 = (
)
2
N1 = (
Con esto ya tendriamos la posibilidad de calcular tanto el
(3.19)
(3.20)
Ki
fi
de la cual obtendramos los parametros ya
dados en la parte anterior.
x 2 x 1 = le
2(x x1 )
s =
1
(x2 x1 )
d
2
=
dx
le
Se pondria en accin de las funciones
Bi
Di
(3.21)
(3.22)
(3.23)
con ello empezariamos a formular la Matriz de Rigidez y de
fuerza.
N1 2 N2 2
,
]
le
le
(3.24)
(AE)[ N1 2 , N2 2 ])( le )d
le
le 2
(3.25)
Bi = [
1
KI =
1
N1
N2
2
le
2
le
KI =
AE
L
1
1
fe =
ble
2
1
1
(3.26)
1
1
(3.27)
Recordando esto seria la formula clsica de matriz de rigidez sometido a tensin pura.Pero en elmentos nitos
se puede aproximar ms a la solucin real del sistema apoyondonos en mas nodos con la cual tendriamos mas
cercania de la solucin correcta del problema fsico.Por eso resolveremos el mismo problema solo que esta vez
lo haremos con 3 nodos.
21
2014.
Figura 3.3: funciones del Sistema Natural de tres nodos.
Como vemos en la gura el elemento de tres nodos se analizaria de la siguiente manera:
( 1)
( 2 )( 3 )
=
(1 2 )(1 3 )
2
( 1 )( 3 )
( + 1)
L(2,2) =
=
(2 1 )(2 3 )
2
( 1 )( 2 )
L(2,3) =
= (1 2 )
(3 1 )(3 2 )
L(2,1) =
Ahora resolviendo el caso de
(3.28)
(3.29)
(3.30)
para el caso de solucion del caso general de los tres nodos:
x = N1 x1 + N2 x2 + N3 x3
dN1
dN2
dN3
dx
=
x1 +
x2 +
x3
d
d
d
d
2 1
2 + 1
dx
=
x1 +
x2 2x3
d
2
2
d
2
=
dx
2(x1 + x2 2x3 ) + le
d
2
=
dx
le
(3.31)
(3.32)
(3.33)
(3.34)
(3.35)
Usando las Ecuaciones EC(2.16) y EC(2.17) de Matriz de Rigidez para poder solucionar la aproximacin en el
caso de tres nodos la cual quedaria de la siguiente manera:
1 2
( 2 ) le
1 2
2
1 2
le
(2) l2
(
AE{( ) , (2) , ( + )( )}( ))d
e
2 le
le
2 le
2
1
( + 1 )( l2 )
2
e
1
Como estamos asumiento que el elemento es isotropico y es un sistema Elstico lineal donde
22
(3.36)
A,E ,son constantes
2014.
Resolviendo el sistema anterior.
14 16
2
EA
Ke = (
) 16 32 16
6
2
16 14
(1)
1
2
1 2 b le d
fi =
2
(+1)
1
2

1
le
fi = 4 b
6
1
3.2.
(3.37)
(3.38)
(3.39)
ANLISIS DE FLEXIN EN UNA VIGA.
EL clsico problemas de vigas puede ser resuelto con el metodo tradicionales de Resistencia de materiales
sin embargo resolver el problema con el mtodo sosticado del MEF es de gran interes didactico pues en este
particular problema cada nodo puede ser trabajado con dos variables y puede servir como conceptos primarios
para estudio de placas y lminas.
Entre estos principios y conceptos bicos existen dos formas planteadas como estudio generalizado de las mismas
como son el Estudio de vigas por el mtodo Viga Bernoulli y el estudio de vigas por el mtodo Viga Timoshenko.
3.2.1. Teoria de Flexion de Viga de Euler y Bernoulli.

Consideremos una viga de longitud
L,seccin
transversal de area
y mdulo de inercia
actuan una serie de cargas verticales(echas) y momentos contenidos en el plano
dw
dx
d2 w
= y = y 2
dx
d2 w
= Ey 2
dx
d2 w
dFi = (Ey 2 )dA
dx
d2 w 2
dMi = (E 2 )y dA
dx
d2 w
Mi = EI 2
dx
=
23
sobre la cual
XZ .
(3.40)
(3.41)
(3.42)
(3.43)
(3.44)
(3.45)
2014.
Figura 3.4: Viga Convencional Euler-Bernulli
3.2.2. Discretizacin de elementos nitos de dos nodos.

La Incognita fundamental del problema es la echa
virtual interno aparecen segundas derivadas de
w,
w.No
obstante debido a que en la expresin del trabajo
se deben usar elementos continuos de clase
C1 (la
variable
y su primera derivada han de ser continuas) para evitar singularidades en el clculo de las integrales.Esta
dw
dx ,coincide con la pendiente
de la deformada del eje de la viga.Por tanto,dicha derivada debe ser continua para garantizar que la deformada
condicin se puede interpretar fsicamente de manera sencilla teniendo en cuenta
del eje de la viga,de tal manera dicha derivada debe ser continua para garantizar que la deformada del eje
describa una curva suave.
El elemento mas sencillo de la viga clase
C1
es el unidimensional de dos nodos la cual estaria dada de la siguiente
manera:
w = 0 + 1 + 2 2 + 3 3
(3.46)
(3.47)
w = 1 + 22 + 33
Por las condiciones de contorno la ecuacion de deformacin quedaria sintetizada de la siguiente manera:
dw )1 + N2 w2 + N2 ( dw )2
w = N1 w1 + N1 (
dx
dx
(3.48)
Analizaremos para cada caso las Condiciones frontera con la cual sacamos el siguiente cuadro comparativo :
H1
H1
H2
H2
H3
H3
H4
H4
Cuadro 3.1: Valores por cada caso de discretizacin de la Barra.

Empezaremos a resolver las ecuaciones formadas por las condiciones de contorno.
24
2014.
Figura 3.5: Funciones de forma
N1
N1
0 1
1 2 3 1 0
1
1
1 2 0
3
1
2
3
0
1 1 1 0 0
1 2 3 1 1

1
1
1 2 0

0
3
1
2
3

1 1 1 0 0
1 0
1 2 3

1
1
1 2 1

1
2
3
3
0

1 1 1 0 0
1 0
1 2 3

1
1
1 2 0

1
2
3
3
1
(3.49)
(3.50)
(3.51)
(3.52)
Resolviendo las ecuaciones matriciales anteriores se obtendrn los coecientes de la formula general
Hi = 0 + 1 + 2 2 + 3 3
con la cual tendriamos los coecientes para cada caso de las condiciones de
25
2014.
Figura 3.6: Funciones de forma
N2
N2
Contorno .
1
2
4
1
4
(3.53)
1

4
4
1
2
26
1
4
1
4
(3.54)
(3.55)
1
4
1
4
(3.56)
2014.
Viga Bernoulli.
Con esto obtendriamos las funciones de forma para el caso de exin de
1
(2 3 + 3 )
4
N1 =
(3.57)
1
(1 2 + 3 )
4
1
N2 = (2 + 3 3 )
4
1
N2 = (1 + 2 + 3 )
4
N1 =
(3.58)
(3.59)
(3.60)
3.2.3. Matriz de Rigidez Viga Bernoulli.

Con todos los datos anteriores empezaremos con la propuesta de encontrar la Matriz de rigidez para el
T
Bi DBi dv con la cual veremos las particularidades ectores y
V
complementariamos con el sistema Axial de fuerzas para completar la matriz de rigidez de una viga.
caso de viga Bernoulli, aplicaremos la formula
Para ello haremos uso de la discretizacin de dos nodos para los ejes
en la cual estableceriamos lo siguiente:
1+
1
x1 +
x2
2
2
x=
(3.61)
Empezaremos a resolver el paso de un sistema natural al cartesiano de la siguiente manera:
dx
le
=
d
2
(3.62)
Reemplazando en la ecuacin(2.16)para lo cual ya hallamos las funciones de forma y el translado de un sistema

por medio del Jacobiano anterior.
Ki =
1
4
2
le
dN1
d
dN1
d
dN2
d
EI{
dN2
d
dN1 dN1 dN2 dN2 le

,
,
,
} d
d d d d 2
(3.63)
6le
2
2le
6le
2
4le
(3.64)
12
6le
2
EI 6le
4le
Ki = 2
12 6le
le
2
6le
2le
12
6le
12
6le
Como se pueden ver es la matriz de rigidez aprendida en el curso de Analisis Estructural ;estariamos estableciendo ya en este momento la matriz de
AE
le
KT =
AE

le
K(6x6)
para lo cual nos agenciariamos de la Ec(3.26)y Ec(3.64).
AE
le
12 EI
l3
6 EI
l2
6 EI
l2
4 EI
le
AE
le
0
12 EI
l3
6 EI
l2
6 EI
l2
4 EI
le
6 EI
l2
6 EI
l2
2 EI
le
27
6 EI
l2
6 EI
l2
2 EI
le
12 EI
l3
e
12 EI
l3
(3.65)
2014.
Para hallar las fuerzas en las vigas en forma general usaremos la ecuacin general de
es igual a
1
1
3.2.4.
Ki ai + f e = q
la cual
fe
N T qdv que en este caso seria de la siguiente manera:

v i
N1
N1
N2
N2
qdx =
ql
ql2
12
ql
ql2
12
V1
M1
V2
M2
(3.66)
Teoria de Flexin de Viga de Timoshenko
La teoria de vigas de Timoshenko comparte hiptesis de la teoria clsica.Por contrapartida,la nueva hiptesis
Las secciones planas normales al eje de viga antes de la deformacin,permanecen

planas pero no necesariamente normales al eje despus de la deformacin.
establece que
Esta hiptesis representa una mayor aproximacin a la deformacin real de la seccin transversal en vigas de
gran canto.A medida que la relacin longitud/canto disminuye,las secciones transversales dejan de conservarse
planas despus de la deformacin.
Figura 3.7: Viga con giro Adicional
dw
dx
du
d
= z
x =
dx
dx
dw du
dw
=
+
=
=
dx
dz
dx
=+
xz
(3.67)
(3.68)
(3.69)
Por consiguiente la teoria de Timoshenko equivale a considerar el efecto de la deformacin por cortante transversal,coincidiendo la magnitud de dicha deformacin adicional de la norma
28
los dos esfuerzos tanto de
2014.
Figura 3.8: Analisis de Vigas tanto en Momento como en Cortante.
xz
se relacionan con las correspondientes deformaciones por:
d
dx
dw
d
xz = G(
)Mi = EI
dx
dx
dw
Qi = GA(
) = GAxz
dx
x = E
= zE
(3.70)
(3.71)
(3.72)
Ahora aplicando el Principio de Trabajo virtuales pero con la condicion de hacerlo lineal o constante al elemento
cortante de la Viga Timosheko
xz = Gxz ,donde
es la cortante de forma o de distorcin
x + xz xz )dV =
qdx +
l
A = A.
(
i=1
dw
)i Mi +
wi Zi
dx
i=1
(3.73)
Ahora simplicando la Expresin con los datos anteriores deducidos anteriormente quedaria de la siguiente
manera:
[(
l
d
d
dw
dw
)EI( ) + (
)GA (
)]dx
dx
dx
dx
dx
(3.74)
3.2.5. Elementos nitos para exin de vigas de Timoshenko.

La echa de la viga Timoshenko esta en funcin en este caso de
C0
y w variables independientes de continuidad
por lo tanto se pueden interpolar por separado cada una de ellas por:
w() = N1 ()w1 + N2 ()w2
(3.75)
() = N1 ()1 + N2 ()2
(3.76)
29
2014.
Donde
w1 ,1
w2 ,2
son echas y giros de los nodos 1 y 2 del elemento.
d
N1 ()
N2 ()
d
=(
1 +
2 )
dx
dx
dw
d
N1 ()
N2 ()
d
=
=
=(
w1 +
w2 )
N1 1 N2 2
dx
dx
dx
=
xy
(3.77)
(3.78)
Utilizando una formulacin isoparametrica idntica a la empleada para el elemento barra de dos nodos se obtiene
que
d
dx
2
le las ecuaciones Ec.3.79 y Ec.3.78 pueden ser escritas de la siguiente manera:
= Bf a
(3.79)
xz = Bc a
(3.80)
2 N1
2 N2
, 0,
]
le
le
2 N2
2 N1
, N1 ,
, N2 ]
Bc = [
le
le
ai = [w1 , 1 , w2 , 2 ]
Bf = [0,
(3.81)
(3.82)
(3.83)
Resolviendo las derivadas de los vectores se tendria:
1
1
Bf = [0, , 0, ]
le
le
1 1 1 1
, ,
]
Bc = [ ,
le
2
le
2
(3.84)
(3.85)
Con las formulas anteriores calcularemos la Matriz de Rigidez general de la Viga segun teoria Timoshenko. para
esp volveremos a resolver o simplicar la ecuacin Ec(3.74) que segun las formulas deducidas en las ecuaciones
3.79 y 3.80 reemplazando en la formula 2.13 o el Principio de Trabajo Virtual.
[ae ]T
le
T
T
[Bf (EI)Bf + Bc (GA)Bc ]dx(ae ) = [ae ]T
N (q)dx + [ae ]T qe
(3.86)
le
tras Simplicacin de la formula queda de la siguiente manera :
e
e
[Kf + Kc ]ae f e = qe
(3.87)
Deduciendo de la Primera parte de la formula anterior quedaria:
e
Kf =
T
Bf (EI)Bf dx
(3.88)
T
Bc (GA )Bc dx
(3.89)
le
e
Kc =
le
El vector de fuerzas nodales equivalentes debidas a las cargas repartidas q; y
fe =
N qdx
(3.90)
N = [N1 , 0, N2 , 0]
(3.91)
le
El vector de Fuerzas nodales de equilibrio que permite ensamblar las contribuciones de los distintos elementos
de la matriz de rigidez y en el vector de las fuerzas globales.
Todas las integrales anteriores pueden transformarse sobre el dominio normalizado del elemento.As,teniendo
en cuenta que
dx =
le
2 d ,las ecuaciones Ec(3.88,3.89,3.90) se escribirian como:
1
T
Bf (EI)Bf
le
d
2
(3.92)
T
Bg (EI)Bg
Kf =
le
d
2
(3.93)
1
1
Kg =
1
fe =
N
1
30
T le
(3.94)
2014.
3.2.6. Matriz de Rigidez Total V.Timoshenko y Efecto de Bloqueo.

Como en las anteriores ecuaciones se deduce que solo debe existir un solo punto de integracin,ya que todos
los trminos del integrando de
Kf
exige un solo punto de integracin,ya que todos los terminos del integrando
son contantes asi pues tras operar las operaciones obtenemos.
0
EI
Kf = (
)
le
0
0 1
0 0
0 1
1
0
1
(3.95)
Por otra parte la integracin exacta de la matriz de rigidez de cortante precisa dos puntos de integracin por
parecer en el integrando
Kc
trminos de segundo grado
,obteniendose:
le
2
le
2
2
le
3
e
l2
le
2
e
l2
e
l2
le
2
e
l2
2
le
3
le
GA 2
Kc = (
)
l
1
le
2
(3.96)
Ahora sumamos las matrices y obtendremos una matriz general para lo cual la matriz quedar de la siguiente
manera y hallando a la vez un sistema de voladizo y resolviendo con el sistema de V.Timoshenko. [3]
GA
l
GA
GA
GA
2
GA
2
GA
l
( GA l +
3
GA
2
EI
l )
( GA l
3
GA
2
GA
l
EI
l )
GA
2
Por las condiciones de contorno tendriamos que

la deformacin
w2
GA
2
w1 V1
GA
EI

1 M1
( 3 l l )
w2 P
GA
GA
EI
0
2
(
l+ )
3
w1 = 0
(3.97)
y que
1 = 0
con ello analizariamos las soluciones para
para su respectiva comparacin con el sistema V.Bernoulli.
GA
l
GA
2
w2 P
GA
EI
2
0
( 3 l+ l )
GA
2
(3.98)
Resolviendo y desarrollando la matriz el problema quedaria de la siguiente manera:
GA
( 3 l+

=
+1
l2
w2
donde
EI
EI
l )
l2
EI
l
EI
(3.99)
12EI
GA l2 la echa o la deformacin vertical estaria dada por:
w2 =
l
l3
l3
(
+
)P w2 =
P
+ 1 GA
3EI
3EI
(3.100)
Analizando el cociente entre la solucin sin cortante y la solucin con cortante, quedaria de la siguiente manera:
w2
3(42 + 3)
= 2 2
4 ( + 3)
w2
31
(3.101)
2014.
Logicamente el valor de
debera tender a la unidad a medida que o esbeltez aumente pero vemos que segun lo
que la viga de Timoshenko de dos nodos

es incapaz de reproducir en el lmite la teoria clsica de vigas asi a medida que la longitud aumenta
que hemos sacado es totalmente incorrecto eso quiere decir que el
se produce un fenomeno de sobrerigidez curiosamente cuando llega a a tener mayor importancia hasta llegar
ah bloquear la solucin. [3] Para tratar de llegar a una exactitud lgica es visto que se tiene que sub-evaluar
Figura 3.9: Analisis de Viga en Voladizo V.Timoshenko.

es decir integrarlo solo en un solo punto eliminando
=0
y asi tener una solucin que no se distorcione en los
lmites.
1 1 1
1
, , , ]
le 2 le
2
(3.102)
GA [ 1 , 1 , 1 , 1 ]) le d
le 2 le
2 2
(3.103)
Bc = [
1
le
1
2
1
le
1
2
32
2014.
de la cual la matriz de rigides
Kc
quedaria de la siguiente manera es decir la matriz de integracin en un solo
punto: [3]
le
2
le
2
2
le
4
e
l2
2
le
4
le
2
le
2
2
le
4
e
l2
2
le
4
le
2
GA
Kc = (
)
l
1
le
2
(3.104)
Resolviendo igual que en el sistema anterior quedaria de la siguiente manera pues la matrices de Rigidez y
Flexibilidad despues de eliminar los grados de libertad del empotramiento.
GA
l
K=
GA
l
1
( GA
F =
GA
l
( GA l
4
l3
+ 4EI )
(3.105)
+ EI )
l
l2
2EI
(3.106)
l
2EI
l
( EI
La relacin entre este valor y el exacto para las vigas esbeltas es:
=
La variacin de la nueva funcin
con
w2
32 + 3
=
e
(w2)exacta
42
se ha representado en la gura Fig3.9 vemos como la solucin anterior
si se aproxima a la real ya que la otra solucion de las ecuaciones anteriores al

subevaluado
(3.107)
0 es pero con este sistema
es igual a 0.75.
Pero analiizando la anterior solucion vemos que existe un bloqueo ya que al acercarse a 0 esto tiende al innito.
3.3.
PROGRAMA DE VIGAS HECHA EN PYTHON.
Deberiamos empezar esta seccin con la pregunta del rigor por que en python?,conociendo otro paquetes
como el Sap2000,Staad Pro o programas como Matlab,Maple y otros,es que si tomamos en cuentas todos
los lenguajes anteriores son privativos es decir si no compras las lisencias correspondientes tu script o pequeo
programa no sirve y como funcionan como precompilacin pues las lisencias y todo eso se vuelven prcticamente
insostenibles se esta optando por una programacion de software libres pues esto va acompaado a la logica y
a la moralidad de compartir pues en lo personal me parece maligno y egoista guardar el conocimiento pues es
un derecho universal de la educacin mundial en ese sentido quiero empezar este bloque diciendo que el mundo
nesecita una logica y argumentos diferentes para subsistir sobre todo en paises con Sub-Desarrollo como el
nuestro la cual merece una oportunidad de cambio no solo moral si no tambien tecnologico.
Figura 3.10: Una de las librerias de python.
3.3.1. Que es Python?.

Programa Interpretado y de Script.
33
2014.
Un lenguaje interpretado o de script es aquel que se ejecuta utilizando un programa intermedio llamado intrprete, en lugar de compilar el cdigo a lenguaje mquina que pueda comprender y ejecutar
directamente una computadora (lenguajes compilados).
La ventaja de los lenguajes compilados es que su ejecucin es ms rpida. Sin embargo los lenguajes
interpretados son ms exibles y ms portables.
Python tiene, no obstante, muchas de las caractersticas de los lenguajes compilados, por lo que se podra
decir que es semi interpretado. En Python, como en Java y muchos otros lenguajes, el cdigo fuente se
traduce a un pseudo cdigo mquina intermedio llamado bytecode la primera vez que se ejecuta, generando archivos .pyc o .pyo (bytecode optimizado), que son los que se ejecutarn en sucesivas ocasiones.
Tipado Dinmico.
La caracterstica de tipado dinmico se reere a que no es necesario declarar el tipo de dato que va a
contener una determinada variable, sino que su tipo se determinar en tiempo de ejecucin segn el tipo
del valor al que se asigne, y el tipo de esta variable puede cambiar si se le asigna un valor de otro tipo.
Fuertemente Tipado.
No se permite tratar a una variable como si fuera de un tipo distinto al que tiene, es necesario convertir
de forma explcita dicha variable al nuevo tipo previamente. Por ejemplo, si tenemos una variable que
contiene un texto (variable de tipo cadena o string) no podremos tratarla como un nmero . En otros
lenguajes el tipo de la variable cambiara para adaptarse al comportamiento esperado, aunque esto es ms
propenso a errores.
Multiplataforma.
El intrprete de Python est disponible en multitud de plataformas (UNIX, Solaris, Linux, DOS, Windows, OS/2, Mac OS, etc.) por lo que si no utilizamos libreras especcas de cada plataforma nuestro
programa podr correr en todos estos sistemas sin grandes cambios.
Orientado a Objetos.
La orientacin a objetos es un paradigma de programacin en el que los conceptos del mundo real relevantes
para nuestro problema se trasladan a clases y objetos en nuestro programa. La ejecucin del programa
consiste en una serie de interacciones entre los objetos.
Python tambin permite la programacin imperativa, programacin funcional y programacin orientada
a aspectos.
3.3.2. Librerias Principales de python.

Python dispone de una amplia coleccin de libreras, que simplican nuestra tarea a la hora de escribir
cdigo. El objetivo de este tema es ensear cmo funcionan algunas de las libreras, para que los usuarios
noveles de este lenguaje tengan una base para utilizar la mayora de las libreras disponibles, que son muchas,
adems de proporcionar unos consejos que, evitarn ms de un dolor de cabeza o fallos inesperados a la hora
de ejecutar un cdigo.
Numpy
NumPy es el paquete fundamental para la computacin cientca con Python. Contiene entre otras cosas:
un poderoso N-dimensional array de objetos sosticados (radiodifusin) funciones herramientas para la
integracin de cdigo C / C + + y Fortran cdigo lgebra lineal til, la transformada de Fourier, y la
capacidad de nmeros aleatorios
Adems de sus usos cientcos obvias, NumPy tambin se puede utilizar como un eciente multi-dimensional
contenedor de datos genricos. Arbitrarias de tipos de datos pueden ser denidos. Esto permite NumPy
para integrar y rpidamente con una amplia variedad de bases de datos.
34
2014.
Figura 3.11: Simbolo de Numpy
Numpy est licenciado bajo la licencia BSD , lo que permite su reutilizacin con pocas restricciones.
Scipy
Depende directamente de numpy es una libreria de calculo nmerico sirve para establecer todo tipo de
calculo numerico y potencialmente grande para establecer datos de todo tipo matemtico.
Matplotlib
matplotlib es una de las biblioteca de trazado 2D que produce guras de calidad de publicacin,en una
variedad de formatos impresos y entornos interactivos,a travs de plataformas. Matplotlib se puede utilizar
en scripts para python, la pitn y la ipython shell, servidores de aplicaciones web.
Matplotlib trata de hacer las cosas fciles . Puede generar grcos, histogramas, espectro de potencia,
grcos de barras, errorcharts, diagramas de dispersin, etc, con slo unas pocas lneas de cdigo. [5]
3.3.3. Programa hecho en python

Con lo dicho anteriormente vamos ah establecer la primera parte del codigo fuente del sistema y hacer unos
pequeos ejemplos de aplicacion de vigas continuas y esto compararlo con programas como el SAP.
35
2014.
#! / usr / bin / python

# PROGRAMA DE VIGAS_SAMAX PRIMERA PARTE DE TESIS
from numpy import *
from scipy import *
from matrix2d import *
from numpy . linalg import *
from scipy . linalg import *
from FForma import *
from Graficos import *
print ( ' PROGRAMA HECHA EN PYTHON PONER LOS DATOS DE SISTEMAS NODALES [0 ,1. 00000000 ] ')
n= input ( ' Colocar el Numero de Vigas : ')
nodos =n+1
Cord =[]
for i in range ( nodos ):
s= input ( ' Colocar las Coordenadas de los nodos : ')
Cord = Cord + [ s]
Cord1 = array ( Cord )
L=[ ]
for j in range ( nodos ):
if j-i ==1:
L = L + [ norm ( Cord1 [j ]- Cord1 [i]) ]
# COLOCACION DE PROPIEDADES DE LA BARRA O VIGA
Pt =[]
for i in range (n):
Pi = input ( ' Colocar las Propiedades [E ,b ,h ]: ')
Pt = Pt +[ Pi ]
# COEFICIENTES DE ELASTICIDAD DEL SISTEMA
E=[ ]
I=[ ]
for i in range ( len ( Pt )) :
E=E +[ Pt [ i][0]]
# ELEMENTOS DE INERCIA DE LOS ELEMENTOS
I=I +[ Pt [ i][1]* ( Pt [i ][2]** 3)/ 12 .0]
# MATRICES DE RIGIDEZ DE LOS ELEMENTOS
K=[ ]
s= Matrix ( E[i] ,I[i] ,L[i])
K=K +[s. Constructor () ]
# ACOPLAMIENTO DE LA MATRIZ GLOBAL
R1 = range (n)
R2 = range (1 ,n +1)
U1 = ()
for i in range ( len ( R1 )) :
for j in range ( len ( R2 )) :
if i== j:
U1 = U1 +( R1 [i] ,R2 [j] )
U2 = np . array ( [ U1 [i] +1 for i in range ( len ( U1 )) ])
s= len ( U1 )/2
U3 = np . reshape (U2 ,(s ,2 ))
U4 = U3 *2
O=[ ]
WQ = array ([ range ( U4 [i][0 ]-2 , U4 [i][0 ]) for i in range ( len ( U4 )) ])
WR = array ([ range ( U4 [i][1 ]-2 , U4 [i][1 ]) for i in range ( len ( U4 )) ])
36
2014.
for i in range ( len ( WQ )) :

for j in range ( len ( WQ )) :
if i== j:
O = O + [ array ([ WQ [i] ,WR [j] ] ). reshape (4)]
U5 = array (O)
Ord = transpose ( U5 )
""" MATRIZ DE ORDENAMIENTO -----> Ord """
KT = zeros (( 2* nodos , 2* nodos ))
# PROCEDIMIENTO DE ENSAMBLAJE DE LA MATRIZ DE RIGIDEZ .
for i in range (4):
for j in range (4):
for s in range ( len (K )) :
KT [ Ord [ i][s] ][ Ord [ j][s] ] = KT [ Ord [i][s ]][ Ord [j][s ]]+K[ s][i] [j]
# COLOCAR LOS GRADOS DE LIBERTAD DE LOS NODOS O APOYOS .
M=[ ]
u= input ( ' Nodos Empotrados [0 ,0] Nodos Fijos [0 , 1] Nodos Libres [1 , 1] : ')
M = M + [u ]
N= array ( M ). reshape ( 2* nodos ,1)
# COLOCAR LAS FUERZAS TANTO EN NODOS COMO EN ELEMENTOS DE RECURRENCIA .

F=[ ]
y=[ ]
for i in range (n):
w= input ( ' Colocar el Valor de [1] fuerza Puntual o [2] Fuerza Dist : ')
if w== 1:
""" Deducidos en La Tesis """
q= input ( ' Colocar [ Q_i , Xi ] : ')
Q1 = Forma (q[1 ] ,L[i] )
U=[ [q[0]* Q1 . N_1 () , q[ 0]* Q1 . N_2 () ] ,[q[ 0]* Q1 . N_3 () , q[0] * Q1 . N_4 () ]]
y = y + [q ]
F = F + U
if w== 2:
""" Deducidos en La Tesis """
s= input ( ' Colocar el valor de qi : ')
B=[ [s*L[ i]/2.0 ,s*L[ i]**2/ 12 .0] ,[s*L[ i]/2.0 ,-s*L [i]** 2/ 12 . 0]]
F = F + B
y = y + [[s ,0]]
FV = array (y ). reshape (n ,2 )
FI = array (F)
# MATRIZ DE FUERZAS DE LOS ELEMENTOS
# -------------------------------------------------------------------------FR =[]
for i in range (1 , len ( FI )-1 ,2):
for j in range (2 , len ( FI )-1 ,2):
if i!= 0:
if j!= 0:
if i!= len ( FI )-1:
if j!= len ( FI )-1:
if j-i ==1:
QW =[ array ( FI [ i])+ array ( FI [j]) ]
FR = FR + QW
FU = array ([ array ( FI [0])] + FR +[ array ( FI [ len ( FI )- 1])] ). reshape (2* nodos , 1)
# ---------------------------------------------------------------------------# CALCULO DE LA MATRIZ DE RIGIDEZ CORREGIDA .
37
2014.
GDL0 =[]
for i in range ( len (N )) :
if N[i ]==0:
GDL0 = GDL0 +[i]
GDT = array ( GDL0 )
KM1 = delete (KT , GDT , axis = 0)
KM2 = delete ( KM1 , GDT , axis =1)
FGDL =[]
if N[i ]!=0:
FGDL = FGDL +[ FU [i]]
FGDL1 = array ( FGDL ). reshape ( len ( KM2 ),1)
# HALLANDO EL VECTOR DE LOS DESPLAZAMIENTOS
# --------------------------------------------------------------------Desp = dot ( inv ( KM2 ), FGDL1 )
# ---------------------------------------------------------------------# PROCESO DE SEPARACION PROPIEDADES DE VIGAS
UPP =[]
for i in range ( len (M )) :
for j in range ( len (M )) :
if j-i ==1:
UPP = UPP +[M[i ]+M[j ]]
UPP1 = array ( UPP )
AMY =[]
if N[i ]==1:
AMY = AMY +[[i] ]
AMY1 = array ( AMY )
for i in range ( len ( AMY1 )) :
N[ AMY [i] ]= Desp [i]
N2 =N. reshape ( len (N )/2 ,2 )
POR =[]
for i in range ( len ( N2 )) :
for j in range ( len ( N2 )) :
if j-i ==1:
POR = POR +[([ N2 [i]] +[ N2 [j ]])]
POW = np . array ( POR )
# ---------------------------------------------------------------------------------# PARCIALIZAR LOS X [i] PARA DE TAL MOTIVO SACAR LAS GRAFICAS DE LOS ELEMENTOS VIGAS .
X=[ ]
for i in range (n):
x1 = arange (0 , L[i] ,0 .1)
X = X + [ x1 ]
Form =[]
for i in range (n):
QR = Forma (X[i ] ,L[i] )
Form = Form +[ QR ]
Resid =[]
for i in range (n):
QM = Residuo (X [i] ,L[ i] ,FV [i][0 ] ,E[i] ,I[i] )
Resid = Resid + [ QM ]
DEF =[]
for i in range (n):
QT = Form [i]. N_1 () * POW [i] [0][0] + Form [i]. N_2 () * POW [i] [0][1] + Form [i]
. N_3 () * POW [i][ 1][0] + Form [ i]. N_4 () * POW [i][ 1][1]+ Resid [i]. R_1 ()
DEF = DEF +[ QT ]
38
2014.
DEFC =[]
for i in range (n):
QE = Form [i]. Gr_1 () * POW [i ][0][0 ]+ Form [i]. Gr_2 () * POW [ i][0][ 1]+ Form [i]
. Gr_3 () * POW [i] [1][0 ]+ Form [i]. Gr_4 () * POW [i ][1][1 ]+ Resid [i] . R_2 ()
DEFC = DEFC + [ QE ]
Mom =[]
for i in range (n):
QU = Form [i]. M_1 () * POW [i] [0][0] + Form [i]. M_2 () * POW [i] [0][1] + Form [i]
. M_3 () * POW [i][ 1][0] + Form [ i]. M_4 () * POW [i][ 1][1]+ Resid [i]. R_3 ()
Mom = Mom +[ QU ]
Cort =[]
for i in range (n):
QV = Form [i]. V_1 () * POW [i] [0][0] + Form [i]. V_2 () * POW [i] [0][1] + Form [i]
. V_3 () * POW [i][ 1][0] + Form [ i]. V_4 () * POW [i][ 1][1]+ Resid [i]. R_4 ()
Cort = Cort +[ QV ]
# -------------------------------------------------------------------------------------------# GRAFICAS _TERMINAREMOS YA EL PRIMER Y SEGUNDO CAPITULO ;)
# --------------------------------------------------------------------------------------------while True :
p= input ( ' Elegir Viga : ')
i=p -1
DefT . plot (X[i ] , DEF [ i] ,'ro ')
GirT . plot (X[i ] ,- DEFC [i] ,'ro ')
MomT . plot (X[i ] , Mom [ i] ,'ro ')
CorT . plot (X[i ] ,- Cort [i] ,'ro ')
plt . show ()
# ---------------------------------------------------------------------------------------------# CREACION DE TABLAS DE RESULTADOS DE LOS ELEMENTOS
# ----------------------------------------------------------------------------------------------
39
Captulo 4
PROBLEMAS DE ELASTICIDAD
BIDIMENCIONAL.
4.1.
Introduccin.
En este captulo se presenta la aplicacin del mtodo de los elementos nitos al anlisis de estructuras en
las que se cumplen las hiptesis de la elasticidad bidimensional(Tensin o deformacin plana).la mayor parte
de los conceptos que aparecern a lo largo del captulo sern utilizados en el resto de la tesis al tratar otros
problemas de estructuras en dos, e incluso tres dimensiones.Por consiguiente,este captulo puede considerarse,
en gran parte,como introductorio a la metodologa general de aplicacin del mtodo de los elementos nitos a
estructuras bi y tridimensionales. [2]
Existe una gran variedad de estructuras de inters prctico dentro de la ingeniera en las que se puede hacer
uso de las hiptesis de la elasticidad bidimensional.Dichas estructuras se caracterizan por tener una forma
aproximada de prisma recto.No obstante,segn la proporcin que guarden las dimensiones de dicho prisma,y la
disposicin de las cargas,pueden clasicarse en uno de los tipos siguientes:
Figura 4.1: Elementos en Tensin Plana y Deformacin Plana.
40
2014.
Problemas de Tensin Plana.

Se dice que una estructura prismtica est en estado de tensin plana si una de sus dimensiones (espesor) es
mucho menor que las otras dos, y sobre ellas actuan unicamente cargas contenidas en su plano medio.Entre
los problemas de estructuras que se incluyen dentro de esta categora podemos citar los de anlisis de vigas
de gran canto,placas con cargas en su plano,presas contrafuertes,etc.
Problemas de Deformacin Plana.

Una estructura prismtica est en estado de deformacin plana si una de sus dimensiones (Longitud) es
mucho mayor que las otras dos y sobre ella actuan nicamente cargas uniformemente distribuidas a lo
largo de toda su longitud y contenidas en planos ortogonales al eje que une los centros de gravedad de sus
distintas secciones transversales, dentro de esta clasicacin se pueden incluir entre otros,los problemas de
muro de contencin,presas de gravedad,tuberas bajo presin interior y diversos problemas de ingenieria
del terreno (tneles,anlisis de tensiones bajo zapatas,etc) una de las principales ventajas de la teoria
bidimensional es que permite el estudio de los problemas de tensin y deformacin plana. [3]
4.2.
Teoria de la Elasticidad Bidimensional.
Presentemos los conceptos que hay que conocer de la teora de elasticidad bidimensional para la utilizacin
del mtodo de elementos nitos.
4.2.1. Campo de Desplazamientos.

Las caracteristicas geomtricas y de cargas de una estructura en estado de tensin o deformacin plana
permiten establecer la hiptesis de que todas las secciones perpendiculares al eje prismtico
se deforman
en su plano y de manera idntica .Por consiguiente,basta con conocer el comportamiento de cualquiera

de dichas secciones.As ,consideramos una seccin genrica contenida en el plano
xy
de cualquiera
de las guras().El campo de desplazamientos de la seccion est perfectamente denido si se conocen los
desplazamientos en las direcciones
de todos sus puntos.El vector de desplazamientos de un punto se
dene,por tanto,como [2]
Figura 4.2: Tension Plana
u(x, y) =
u(x, y)
41
v(x, y)
(4.1)
2014.
Donde
u(x, y)
v(x, y)
son los desplazamientos del punto en direcciones de los ejes
x , y ,respectivamente.
4.2.2. Campo de Deformaciones.

Analizando el campo de desplazamientos y haciendo uso de la teoria general de elasticidad .
u
x
v
y =
y
u
v
+
xy =
x y
xz = yz = 0
x =
Con respecto a la deformacin longitudinal
ser producto
z z
(4.3)
(4.4)
(4.5)
hay que sealar que en el caso de tensin plana dicha
deformacin no es nula ,pero se supone que lo es la tensin

hay que considerar la deformacin
(4.2)
z .Por consiguiente,en ninguno de los dos casos
ya que no interviene en las ecuaciones de trabajo de deformacin al
nulo.As,pues el vector de deformacin signicativas de un punto se dene para tensin
y deformacin plana como
[4]
= [x , y , xy ]T
(4.6)
4.2.3. Campo de Tensiones.

Se deduce en las ecuaciones Ec.(4.2)... Ec(4.5) que las tensiones tangenciales
xz
yz
parte por los mismos motivos explicados en el apartado anterior para la deformacin
son nulas.Por otra
z ,la
tensin
no
trabaja y el vector de tensiones signicativas es [3]
= [x , y , z ]T
(4.7)
4.2.4. Relacin Tensin - Deformacin.

La relacin entre tensiones y deformaciones se deduce de la ecuacin constitutiva de la elasticidad tridimensional,con la hipotesis simplicativas descritas anteriormente(z
deformacin plana y
xz = yz = 0
=0
para tensin plana,z
=0
para
en ambos casos).Tras realizar las correspondientes operaciones puede
encontrarse la siguiente relacin matricial entre tensiones y deformaciones
= D
En la ecuacin Ec(4.8)
(4.8)
es la matriz de constantes elsticas (o matriz constitutiva)
d11
d12
D = d21
d22
0
d33
(4.9)
Del teorema de Maxwell-Betti se deduce que D es siempre simetrica,y
d12 = d21 .Para
elasticidad isotropa
se tiene:
Tensin Plana
d11 = d22 =
E
1v 2
d12 = d21 =
vE
1v 2
Deformacin Plana
d11 = d22 =
E(1v)
(1+v)(12v)
(4.10)
d33 =
E
v
d12 = d21 = ( 1v2 )( 1v )
E
2(1+v)
d33 =
42
E
2(1+v)
=G
2014.
Siendo
el mdulo de elasticidad y
es el coeciente de Poisson. Para un material orttropo con direc-
ciones principales de ortotropa segun x e y,la matriz D tiene la expresin siguiente:
Tension Plana
D=
1
1vxy vyx
Ey
vx
(1 vxy vyx )Gxy
vxy Ex
vyx Ey
(4.11)
Tension Plana
1
adbc
D=
dEy
aEx
(ad bc)Gxy
bEx
cEy
Donde los diferentes factores estarian dados por:
1
1 + vyx
1 + vxy
=
+
Gxy
Ex
Ey
a = 1 vyz vzy
b = vxy + vxz vzy
c = vyx + vyz vzx
(4.12)
d = 1 vxz vzx
(4.13)
puesto que D debe ser simtrica se cumple
vxy
Ey
=
(Tensin
Ex
vyx
Plana) y
Si las direcciones principales de ortotropa

de la estructura
x ,y
Ey
b
= (Deformacin
Ex
c
Plana)
estn inclinadas un ngulo
(4.14)
con respecto a los ejes globales
la matriz constitutiva se obtiene como sigue.Las deformaciones en eje x' y y',se
expresan en funcin de sus valores en ejes x,y,por: [3]
(P U )u = x
ort
(P U )u
(4.15)
=y
(4.16)
xcos() + ysen() = x
(4.17)
xsen() + ycos() = y
(4.18)
Con esto podemos analizar tambien los desplazamientos en
u y en v
con lo cual tendriamos lo siguiente: [6]
u = ucos() + vsen()
(4.19)
v = ucos() + vcos()
(4.20)
Con los datos Anteriores y usando las formulas general
du
dx con la cual analizaremos los diferentes paso
de coordenadas .
x =
(4.21)
y =
xy =
u
u x
u y
=
+
x
x x
y x
v
v x
v x
=
+
y
x y
x y
(4.22)
u
v
v x
v y
u x
u x
+
=
+
+
+
y
x
x x
y x
x y
x y
(4.23)
43
2014.
Reemplazando las ecuaciones Ec(4.17-4.18-4.19-4.20) en las ecuaciones Ec(4.21-4.22-4.23) con la cual tendriamos lo siguiente:
x = x cos2 () + xy sen()cos() + y sen2 ()

2
(4.24)
y = x sen () xy sen()cos() + y cos ()

2
(4.25)
xy = x 2cos()sen() + y 2cos()sen() + xy (cos () sen ())
(4.26)
Acomodando el sistema en un sistema matricial el sistema quedaria de la siguiente manera:
y
=
xy
cos2 ()
sen2 ()
sen2 ()
cos2 ()
2sen()cos()
sen()cos()
sen()cos()
2sen()cos() cos2 () sen2 ()
xy
(4.27)
La formula quedaria de la siguiente manera con la cual se podria establecer la siguiente formula:
= T
(4.28)
Por otra parte tambien puede demostarse que que las tensiones en los ejes globales se relacionan con sus
valores en ejes
Figura 4.3: Material Orttropo con direcciones principales de ortotropia
= TT
=D
Donde
(4.29)
(4.30)
viene expresada en Ec(4.11) para material ortotrpo.
Finalmente,haciendo uso de las Ecs(4.29)-(4.30) se obtiene:
= T T D T = D
T
D=T DT
44
(4.31)
(4.32)
2014.
Es fcil comprobar que la matriz de D en los ejes globales es tambin simtrica .La expresin de los
coecientes
dij
para el caso de elasticidad anistropa. Si el slido est sometido a un estado de deformacin
inicial,tal como puede suceder en el caso de deformacin trmica,las relaciones pueden modicarse. La
deformacin total es ahora igual a la elstica
ms la inicial.Por otra parte,las tensiones siguen siendo
proporcionales a las deformaciones elsticas,con lo que la ecuacin constitutiva se describe como: [3]
= De = D( 0 )
(4.33)
4.2.5. Formulacin de Elementos Finitos.Elemento de tres Nodos.

Consideraremos en primer lugar el uso del sencillo elemento triangular de tres nodos.Este elemento est
considerado primario en el estudio de problemas estructurales bidimensionales por el mtodo de elementos
nitos.ya hemos comentado que mucho antes de la aparicion de este mtodo Courant sugiri el uso de una
interpolacin polinomica lineal sobre sus subdominios triangulares para aproximar la solucin numrica
de ecuaciones diferenciales. [3]
Aos despus,Turner et al.En un clsico articulo propucieron la divisin de los dominios bidimensionales
en triangulos de tres nodos para facilitar su anlisis matricial.Por ello,dicho elemento es conocido como
elemento de Turner.El triangulo de tres nodos pronto adquiri gran popularidad entre ingenieros estructurales.De las muchas aplicaciones prcticas de dicho elemento en su primera etapa hay que destacar las
relaciones con el clculo de presas de gravedad que constituyeron una autentica innovacion en la metodologia tradicional del anlisis de dichas estructuras
[2].La clave del xito del elmento triangular de
tres nodos fue su gran versatilidad y sencilles que,como veremos,permite asimilar facilmente el proceso de
anlisis de un dominio bidimensional complejo a las etapas del clsico clculo matricial de estructuras de
barras,familiar a la mayor parte de ingenieros estructurales.Por contrapartida,es un elemento de precisin
limitada,como corresponde a su aproximacin lineal lo que obliga usualmente a la utilizacin de mallas
muy tupidas pese a ello,en la actualidad,sigue siendo un elemento popular y competitivo,ademas de servir
de ejemplo exelente para introducir la formulacin de elementos nitos en problemas bidimensionales.
4.2.6. Discretzacin del Campo de Desplazamiento.

En la gura 4.4 se muestra la seccin transversal cualquiera que se analiza bajo la hipotesis de elasticidad
bidimensional.La primera etapa del analisis es como siempre la discretizacin en elementos nitos.En la
misma gura puede verse la discretizacion de la seccion en elementos Triangulares de tres nodos es importante recordar de nuevo que la malla de elementos nitos representa una idealizacin de la geometria
lineal.por consiguiente,el anlisis por elementos nitos reproduce el comportamiento de la malla escogida
y no el de la estructura real.Solamente comprobando la convergencia de la solucin podemos estimar el
grado de aproximacin de la solucin de elementos nitos a la exacta.
N : 1, 2, 3 y sus
(i, j, k) y coordenadas
Un elemento triangular de tres nodos tpico se caracteriza por el numero de sus nodos
coordenadas.Los tres nodos del elemento tienen en la malla la numeracin global
x1 , y1 ,x2 , y2
x3 , y3 .Los numeros globales de los nodos (i, j, k) corresponden con los locales 1,2 y 3,respec-
tivamente en la prctica es usual utilizar la numeracin local para el clculo de las matrices del elemento y
hacer uso de la correspondencia entre numeros locales y globales para el ensamblaje similarmente a como
ocurre en clculo matricial de estructuras.
45
2014.
Figura 4.4: Discretizacion de una Estructura con Elementos Triangulares.
Considerando un elemento aislado como en la gura,podemos expresar los dos desplazamientos cartesianos
de un punto cualquiera del interior del elemento en funcin de los desplazamientos de sus nodos como
u = N1 u1 + N2 u2 + N3 u3
v = N1 v1 + N2 v2 + N3 v3
donde
(ui , vi )
Ni
(4.34)
(4.35)
son los desplazamientos horizontal y vertical y la funcin de forma del nodo
del
elemento,respectivamente.No hay ninguna razn fundamental para escoger las mismas funciones para
denir los desplazamientos en direccin horizontal y vertical.No obstante,por simplicidad, y a menos que
haya claros indicios de que dicha aproximacin debe diferenciarse, es usual utilizar la misma interpolacin
para ambos desplazamientos
u=
u,v .
u
v
[3]
N1
0
0
N1
N2
0
0
N2
N3
0
0
N3
u1
v1
u2
v2
u3
v3
u = Ni ae
u
u=
v
(4.36)
(4.37)
(4.38)
Es el vector de desplazamientos de un punto del elemento.
N = [N1 , N2 , N3 ]
46
Ni =
Ni
0
0
Ni
(4.39)
2014.
i del elemento,respectivamente,y
e
a1
ae
ae =
2
ae
3
Son las funciones de forma del elemento y el nodo
ae =
i
ui
vi
(4.40)
(4.41)
i. Adviertanse que N y ae estn come

puestos de tantas submatrices Ni y subvectores ai ,respectivamente ,como nodos tiene el elemento.Esto es
una propiedad general que se cumple en todos los casos.
Son el vector de desplazamientos nodales del elemento y un nodo
La expresin de las funciones de forma del elemento triangular de tres nodos se puede obtener como sigue.
Los tres nodos del elemento denen una variacin lineal del campo de desplazamientos que puede escribirse
como:
u = 1 + 2 x + 3 y
(4.42)
v = 4 + 5 x + 6 y
(4.43)
Figura 4.5: Elemento discretizado en forma Triangular.
u1 = 1 + 2 x1 + 3 y1
(4.44)
u2 = 1 + 2 x2 + 3 y2
(4.45)
u3 = 1 + 2 x3 + 3 y3
(4.46)
Ahora resolviendo dicho problema se tendria de la siguiente manera:
u=
1
[(a1 + b1 x + c1 y)u1 + (a2 + b2 x + c2 y)u2 + (a3 + b3 x + c3 y)u3 ]
2A
(4.47)
Se deduce que las funciones de forma del elemento triangular tienen la siguiente forma:
Ni =
1
(ai + bi x + ci y)
2A
47
(4.48)
2014.
4.2.7. Discretizacin del campo de deformaciones.

Usando la forma general de la deformacin unitaria en un punto del elemento como:
N1
N2
N3
u1 +
u2 +
u3
x
x
x
N1
N2
N3
y =
v1 +
v2 +
v3
y
y
y
u v
N1
N1
N2
N2
N3
N3
=
+
=
u1 +
v1 +
u2 +
v2 +
u3 +
v3
y
x
y
x
y
x
y
x
x =
xy
(4.49)
(4.50)
(4.51)
Haciendo un arreglo matricial de las ecuaciones planteadas en la parte anterior tendriamos:
Figura 4.6: Funciones de forma del elemento triangular de tres nodos.
u
x
v
y
v
x
u
y
N1
x
0
N1
y
N2
x
0
N1
y
N1
x
0
N2
y
N2
x
0
N2
y
N3
x
0
N3
y
0
N3
y
N3
x
u1
v1
u2
v2
u3
v3
(4.52)
= Bae
(4.53)
B = [B1 , B2 , B3 ]
(4.54)
Es la matriz de deformacin del elemento,y en forma general quedaria de la siguiente manera:
Bi =
Ni
x
Ni
y
Ni
y
Ni
x
48
(4.55)
2014.
es la matriz de deformacin del nodo i.

Adviertanse que
est compuesta de tantas submatrices
Bi
como nodos tiene el elemento,lo que tambin
es una propiedad de caracter general particularizando para los elementos triangular de tres nodos se
obtiene,utilizando [4]
b1
b2
b3
1
0
B=
2A
c1
c2
c1
b1
c2
b2
c3
bi
c3
b3
(4.56)
y por consiguiente
1
0
Bi =
2A
ci
ci
bi
(4.57)
4.2.8. Discretizacin del campo de tensiones.

La expresin discretizada del vector de tensiones en el interior del elemento se obtiene mediante sustitucin
directa de las ecuaciones vistas en la primerra parte de la tesis:
[3]
= D = DBae
(4.58)
Si existiera tensiones o deformaciones iniciales la expresin a utilizar se deduce de la siguiente manera:
= D( 0 ) + 0 = DBae D0 + 0
(4.59)
Puede apreciarse en la ecuacin EC(5.47) que la matriz de deformacin del elemento triangular de tres nodos es constante,lo que implica que las deformaciones y tensiones son constantes en todo el elemento.Esto es
consecuencia directa del campo de desplazamiento lineal escogido,cuyos gradientes son,obviamente,constantes.Por
consiguiente,en zonas de alta concentracin de tensiones ser necesario utilizar una malla tupida para aproximar la solucin de tensiones con suciente precisin.
4.2.9. Ecuaciones de Equilibrio de la Discretizacin.

Para la obtencin de las ecuaciones de equilibrio de la discretizacin partiremos de la expresin del PTV
aplicada al equilibrio de un elemento aislado hay que resaltar que,aunque nos referiremos al elemento
triangular de tres nodos la mayoria de las expresiones que se obtendran en este apartado son completamente
generales y aplicables a cualquier elemento bidimensional.
49
2014.
Figura 4.7: Fuerza Sobre un elemento triangulo de tres nodos
Supondremos ahora que el equilibrio del elemento se establece nicamente en los nodos.Podemos entonces
denir unas fuerzas puntuales que acten sobre los nodos (denominaremos fuerzas nodales de equilibrio)
y que se equilibren las fuerzas debidas a la deformacin del elemento y al resto de las fuerza actuantes del
mismo.Para el clculo de las fuerzas nodales de equilibrio haremos uso de la expresin del P.T.V aplicada
el elemento,que se describe como: [4]
T tdA =
Ae
A
Donde
ui
vi
uT tds +
uT btdA +
le
ui Ui +
i=1
vi Vi
(4.60)
i=1
son los desplazamientos virtuales de los nodos del elemento
Ui
Vi
las fuerzas nodales
de equilibrio que corresponden a dichos desplazamientos .El trabajo virtual de dichas fuerzas pueden
despejarse de la ecuacin anterior como:
T tdA
uT btdA
Ae
uT ttds = [ae ]T qe
(4.61)
Ae
donde para el elemento triangular de tres nodos.
ae = [u1 , v1 , u2 , v2 , u3 , v3 ]T
(4.62)
q = [U1 , V1 , U2 , V2 , U3 , V3 ]
(4.63)
Podemos escribirlo de la siguiente manera:
uT = [aT ]N T
T
= [a ]B
(4.64)
(4.65)
Sustituyendo en la ecuacin EC(4.60) en la EC(4.61) se obtiene ,tras sacar factor comn
aT ,en
el primer
miembro.
[ae ]T [
B T tdA
Ae
N T btdA
Ae
le
N T ttdS] = [ae ]T q e
(4.66)
Teniendo en cuenta que los desplazamientos virtuales son arbitrarios ,se deduce que:
B T tdA
Ae
N T btdA
Ae
le
50
N T ttds = q e
(4.67)
2014.
Las ecuaciones anterior el equilibrio,entre las fuerzas nodales de equilibrio y las fuerzas debidas a la deformacin del elemento(primera integral),las fuerzas msicas (segunda integral) y las de supercie (tercera
integral).Sustituyendo ahora el vector de tensiones
por sus valor en funcin de los desplazamientos
nodales utilizando la forma ms general de la ecuaciones anteriores ya vistas. [3]
B T DBtdA]ae
[
Ae
B T D0 tdA +
B T 0 tdA
Ae
Ae
N T btdA
Ae
N T tds = qe
(4.68)
le
Simplicando la ecuacin en forma general la cual se estaria estableciendo de la siguiente manera:
K e ae f e = q e
(4.69)
B T DBtdA
(4.70)
Ke =
Ae
Es la Matriz de Rigidez del elemento y:
e
e
e
f e = f + f + fb + fte
(4.71)
el vector de fuerzas nodales equivalentes del elemento,siendo:
(e)
f =
B T D0 tdA
(4.72)
B T 0 tdA
(4.73)
N T btdA
(4.74)
N T ttds
(4.75)
Ae
(e)
f =
A(e)
(e)
fb
=
Ae
(e)
ft
=
le
Los vectores de fuerzas nodales equivalentes debidos a deformaciones iniciales,tensiones iniciales,y fuerzas
repartidas por unidad de rea y fuerzas repartidas en el contorno,respectivamente.
La ecuacin de equilibrio global de la malla se obtiene,como en el caso de problemas unidimensionales,estableciendo simplemente que la suma de sus fuerzas nodales de equilibrio en cada nodo debe ser igual
a la fuerza nodal exterior.Es decir: [4]
(e)
qi
= Pj
(4.76)
4.3.
Otros Elementos Bidimensionales y el Mtodo de Interpola-
cin de Lagrange.
La denicin de las funciones de interpolacin o funciones bases que pueden realizarse en el sistema de
coordenadas global que se emplean para denir una estructura;sin embargo,se ha encontrado que ello
no es muy conveniente por que los elementos asi dinidos ,por lo general,dependen de los parmetros
caracteristicos de la geometria y no son faciles de adaptar a nuevas conguraciones .Tal es el caso de uno
de los primeros elementos bidimensional que tienen forma rectangular: [5]
51
2014.
Figura 4.8: Interpolacin de Coordenadas
Una manera de mantener una geometria simple durante la denicin de las funciones de interpolacin,y de
ganar exibilidad en la representacin geomtrica de los problemas ,es la denicin de un espacio Natural
que es independiente del sistema de coordenadas del sistema.
Para denir elementos bidimensionales se emplean ,comunmente ,dos espacios diferentes ,uno es rectangular y otro triangular en las cuales se denen ,respectivamente ,elementos cuadrilaterales y triangulares
. El uso de los espacios naturales para la denicin de los elementos implica,asimismo,la utilizacin de
Figura 4.9: Espacios Triangular y Rectangular

funciones de mapeo hacia el espacio real de aplicacin del elemento implica ,asimismo ,la utilizacin de
funciones de mapeo hacia el espacio cartesiano. [5]
52
2014.
Figura 4.10: Mapeo entre los puntos del espacio Natural y el Espacio Cartesiano
Se inicia relacionando las gemetrias de los espacios,para lo cual en la gura 4.10 anterior se muestra como
un ejemplo de geometra de un cuadrilatero en dos dimensiones .El punto a en el espacio con coordenadas
se relacionan con el punto A de l espacio cartesiano con coordenadas
XA
mediante la expresin:
XA = (a,a ) = a
Un segundo par de puntos,b y B adyacentes a los puntos
y A se relacionan de la misma manera:
XB = (b ,(b) ) = b
Si el punto B se posiciona con respecto al punto A mediante el vector unitario a y la diferencia lineal
el punto b se posiciona respecto al punto
(4.77)
(4.78)
L,y
mediante el vector unitario entonces:
XB = XA + La
(4.79)
b = a + l
(4.80)
Considerando esta ltima relacin ,la ecuacin se puede desarrollar empleando una expansin de la serie
de
Taylor al rededor del punto mediante.
xB = b = a +l = a +
| {l} + O{l2 }
a
(4.81)
Igualando las ecuaciones EC(4.79) con la EC(4.75),se relacionan las distancias entre los puntos AB y ab
en los dos espacios la cual quedaria de la siguiente manera:
La =
| {l} + O(l2 )
a
(4.82)
En el limite,cuando el punto B se aproxima el punto A,y el punto b se aproxima al punto a,los vectores
diferenciales entre los segmentos de linea correspondientes en el espacio natural y cartesiano. [5]
dx =
d = Jd
(4.83)
La matriz que liga los elementos diferenciales de linea se denomina el jacobiano de la transformacin y se
denota por
J.
Una dimensin:
J=
(4.84)
En dos dimensiones.
J =
53
(4.85)
2014.
En tres dimensiones:
J =
(4.86)
4.3.1. Elementos Lineales.

Considere un elemento lineal elstico denido por dos nodos .Este elemento se muestra un espacio natural
y el espacio real. Usando el mtodo de algebra lineal se tendria que la forma de relacionar los dos espacios
Figura 4.11: Mapeo del espacio natural al espacio real para un elemento lineal unidimensional
serian:
x = a0 + a1 = [1, ]
a0
a1
(4.87)
la aproximacin por elementos nitos emplea valores nodales de la funcin misma,de manera que es
importante utilizar la aproximacin nodal sorteando los valores de
,para
distintos casos:
Nodos a
1
-1
+1
Cuadro 4.1: Relacin entre nodos de los elementos lineales y sus coordenadas naturales.
P a = u y tambin a = A1 u.
1 a0
1
a1
esta tabla se emplea para generar mediante la ecuacin
e
x1
xe
2
[1, ]
1
1 e
x1
e
1
x2
(4.88)
[N1 , N2 ]
e
x1
xe
2
1
2
1+
N2 =
2
N1 =
54
(4.89)
(4.90)
(4.91)
(4.92)
2014.
Figura 4.12: Funciones de forma para un elemento lineal Unidimensional.
from numpy import *

import matplotlib . pyplot as plt
from pylab import *
def f( x):
return 0.5*(1 -x)
def g( x):
return 0.5*(1 +x)
x= arange ( -1 ,1 , 0.1)
figure (1 )
subplot ( 211 )
title ( ' Funciones de Forma ')
xlabel (r '$\ xi$ ')
ylabel (r ' $N_ {1 } (\ xi )$ ')
grid ( True )
plot (x ,f (x), 'r -- ')
subplot ( 212 )
xlabel (r '$\ xi$ ')
ylabel (r ' $N_ {2 } (\ xi )$ ')
grid ( True )
plot (x ,g (x), 'r -- ')
show ()
Puesto que el elemento es isoparametrico,se emplear la misma interpolacin para interpolar funciones en
este espacio:
Na ()ua e
u=
(4.93)
a=1
Esta aproximacin ser lineal a partir de los valores nodales ,para que esta interpolacin sea adecuada,es
necesario vericar que se cumplen los requisitos de continuidad ,suavidad y completez.
La continuidad en el dominio de este elemento ser del tipo
55
C0
puesto que las funciones de forma son
2014.
lineales;la primera derivada ser constante,pero la segunda derivada no est ya denida.A travz de la
frontera, la funcin es continua si dos elementos se unen con el mismo nodo,pero la primera derivada es
discontinua.Estas funciones sern adecuadas en problemas que tengan hasta primeras derivadas
(m = 1)
en el integrando de las ecuaciones se nota continuidad en la primera funcion y descontinuidad en la primera

derivada.
La suavidad de la interpolacin se verica grcamente,en donde se observa que las funciones de forma
no tiene ningn punto singular en el dominio del elemento y,por tanto,la funcin interpolada tampoco
tendr y el mapeo se realizar uno a uno y sobre todo el dominio.El jacobiano de transformacin para
este elemento se dene mediante
Le
del elemento como:
xe
1
xe
2
dx
dN1 dN2
x
=
=
,
d
d d
1 1
xe xe
Le
1
,
= 2
=
2 2
2
2
(4.94)
Esto es, el jacobiano es un escalar que representa la distancia o longitud entre los dos nodos del elemento,por lo que la nica posibilidad de que sea cero es que el mapeo se realice por dos nodos coincidentes.Fuera
de ese caso,esta interpolacin siempre ser suave.
Finalmente,la completez se verica al comprobar que la interpolacin es capaz de describir exactamente
en un polinomio de primer grado.Esto es todo lo que nesecita una funcin de la clase
C 0 .Considrese
,entonces,que los grados de libertad nodales se especican de acuerdo con un polinomio de primer grado:
ue = c0 + c1 xe
0
a
Utilizando la interpolacin propuesta en la ecuacin
u=
(4.95)
2
a=1
Na ()ue ,junto
a
con estos valores nodales,se
obtienen:
Na ()ue
a
(4.96)
Na ()(c0 + c1 xe )
a
(4.97)
u=
a=1
2
u=
a=1
2
u=
Na ()xe
a
Na () c0 +
a=1
c1
(4.98)
a=1
El coeciente del primer trmino implica la particin de la unidad:
Na () = N1 () + N2 () =
a=1
1
1
(1 ) + (1 + ) = 1
2
2
(4.99)
Debe notarse que el uso del concepto isoparametrico es el que permite la simplicacin de la ecuacin a
un polinomio lineal.Esta ventaja de los elementos isoparametricos,ya que,basicamente ,para vercar los
requisitos de convergencia de interpolacin lo nico que hace falta es demostrar que se cumpla los requisito
de particin de la unidad. [4]
() = 1
(4.100)
a=1
El elemento que se presenta en esta seccin se emplea para modelar un dominio bidimensional plano que
se dene mediante la posicin de 4 nodos .La numeracin de los nodos y la conguracin gemetrica del
elemento se muestran en la gura 4.14: [4] De nueva cuenta ,como en el caso unidimensional,el espacio de
denicin ser el espacio natural y ser necesario realizar un mapeo al espacio real de la aplicacin ,el cual
se muestra en la siguiente gura: la aproximacin gemetrica se puede expresar mediante polinomios.Dado
que se tiene cuatro nodos para representacin geomtrica,es natural pensar en proponer en aproximaciones
56
2014.
Figura 4.13: Elemento bilineal de cuatro nodos.
Figura 4.14: Mapeo del espacio natural bidimensional al espacio cartesiano real.
no-nodal en trminos de cuatro coecientes indeterminados para
x(, ) = a0 + a1 + a2 + a3 =
y(, ) = 0 + 1 + 2 + 3 =
x,y .
a0
a1
a2
a3
(4.101)
(4.102)
3
La transformacin a una aproximacin nodal se logra al evaluar las coordenadas mediante.
x(a , a , a0 , )
57
(4.103)
2014.
-1
-1
+1
-1
+1
+1
-1
+1
Nodo
Cuadro 4.2: Relacin de los nodos del elemento bilineal y sus coordenadas naturales.
Sustituyendo estas coordenadas de las ecuaciones anteriores se obtienen:
xe
1
+1
+1
+1
+1
+1
+1
e
x2 1

{xe } =
a
e =
x3 1

1
xe
4
e
y1
1

e
y2 1

e

{xa } =
e =
y3 1

e
y4
1
a0
1 a1
= Aai
+1 a2
1
a3
+1 0
1
1
= Ai
+1 2
3
1
+1
+1
+1
(4.104)
(4.105)
Los coecientes indeterminados se pueden obtener de esta ultima expresin:
ai = A1 {xe }
a
i = A
(4.106)
e
{ya }
(4.107)
Finalmente,la interpolacin geomtrica nodal se obtiene como:
x=
x=
x=
1
N1
N2
N3
ai
(4.108)
{xi }
(4.109)
{xi }
(4.110)
N4
Las funciones de forma o interpolacin estan dadas por:
1
(1 )(1 )
4
1
N2 = (1 + )(1 )
4
1
N3 = (1 + )(1 + )
4
1
N4 = (1 )(1 + )
4
N1 =
(4.111)
(4.112)
(4.113)
(4.114)
4.3.2. Interpolacin de alta jerarquia de clase C0 ,Interpolacin Lagrangiana.

Para el tipo de funciones
C0 solo se requiere que las funciones de interpolacin se evalen a partir de valores
nodales.En teoria de interpolacin se encuentran que una familia de polinomios que cumplen precisamente
con ese requisito es la de polinomios de Lagrange.
La interpolacin se plantea de la siguiente forma para problemas unidimensionales.Si tienen
0 n
y la funcin
(n)
puntos
tiene valores conocidos en esos puntos,entonces es posible encontrar un polinomio
58
2014.
() nico,de grado mximo (n1),que al evaluarse en esos puntos ,toma el valor de la funcin .El polinomio
se expresa como:
P () = f (1 )Ln1,1 () + + f (n )Ln1,n ()
(4.115)
en donde los polinomios de lagrange se calculan mediante:
Ln1,k () =
( i )
(k i )
i=1
(4.116)
Comparando la ecuacin EC(4.115) con la forma standard de la interpolacin:
Na ()ua e
u=
(4.117)
a=1
Es posible concluir que los polinomios de lagrange pueden ser las funciones de forma directamente:
Na () = Ln1,a ()
(4.118)
Figura 4.15: Elemento Unidimensional de dos nodos.
Ejemplo de Aplicacin 01.

Considerando el elemento unidimensional de dos nodos que se presentan en el espacio natural en la
gura ,obtenga las funciones de forma mediante el polinomios de Lagrange.
Solucin:
Se considera la siguiente aproximacin:
Na ()ua e
u=
(4.119)
a=1
Las funciones de forma se determinan mediante los polinomios de Lagrange:
( 2 )
(1 )
=
(1 2 )
2
( 1 )
(1 + )
=
=
(2 1 )
2
N1 = L1,1 =
(4.120)
N2 = L1,2
(4.121)
Puede observarse que estas funciones de forma son identicas a las obtenidas por el mtodo de algebra
lineal estudiadas ya anteriormente.

Considere el elemento unidimensional de tres nodos que se presentan en el espacio natural en la gura
obtenga las funciones de forma mediante los polinomios de lagrange.
Solucin: Se considera la siguiente aproximacin:

n
Na ()ue
a
u=
a=1
59
(4.122)
2014.
Figura 4.16: Elemento Unidimensional de tres nodos.
Las funciones de forma se presentan mediante los polinomios de Lagrange.
( 1)( 0)
1
( 2 )( 3 )
=
= ( 1)
(1 2 )(1 3 )
(1 1)(1 0)
2
( 1 )( 3 )
( + 1)( 0)
1
N2 = L2,2 =
=
= ( + 1)
(2 1 )(2 3 )
(+1 + 1)(+1 0)
2
( 1 )( 2 )
( + 1)( 1)
N3 = L2,3 =
=
= 1(1 2 )
(3 1 )(3 2 )
(+0 + 1)(+0 1)
N1 = L2,1 =
Figura 4.17: Funciones de Forma Cudratica Lagrangiana.
60
(4.123)
(4.124)
(4.125)
2014.
# GRAFICO DE FUNCIONES DE FORMA DE SEGUNDO GRADO

from numpy import *
from matplotlib import *
from pylab import *
import matplotlib . pylab as plt
def N1 (x):
return 0.5*x* (x-1)
def N2 (x):
return 0.5*x* (x+1)
def N3 (x):
return (1-x** 2)
x= arange ( -1 ,1 , 0.1)
figure (1 )
title ( ' Funciones de Forma ')
xlabel (r '$\ xi_ {i}$ ')
ylabel (r ' $N_ {i } (\ xi )$ ')
grid ( True )
plot (x , N1 (x), 'r -- ',x , N2 ( x), 'g^ ' ,x , N3 (x), 'bo ')
show ()
Para interpolar en dos y tres dimensiones,simplemente se mezclan los productos de las interpolaciones
unidimensionales de las direcciones correspondientes .Para dos dimensiones si se tienen
en
y(m + 1)
puntos en
,entonces
Na (, ) = Ln,b ()xLm,c ()
(n+1) puntos
las funciones de forma se calcularan mediante: [4]

(4.126)

Considere el elemento bidimensional de cuatro nodos que se presenta en el espacio natural en la gura
obtenga las funciones de forma mediante combinaciones de polinomio de Lagrange.
Figura 4.18: Elemento bidimensional de cuatro nodos.
Solucin.
Se considera la siguiente aproximacin :
Na (, )ue
a
u=
(4.127)
a=1
Las funciones de forma se determinan mediante interpolacin de Lagrange unidimensionalmente en
las direcciones
respectivamente.Debe notarse que,en cada direccin,se tiene dos estaciones de
interpolacin por lo que es posible descomponer la interpolacin bidimensional en dos interpolaciones

unidimensionales como se muestran en la gura.
La siguiente tabla se emplea para relacionar la numeracin nodal del elemento bidimensional con la
numeracin nodal de las interpolaciones unidimensionales:
61
2014.
L()
L()
Cuadro 4.3: Ordenamiento de elementos en dos dimensiones.
La tabla anterior se emplea para relacionar la numeracin nodal del elemento bidimensional con la
numeracin nodal de las interpolaciones unidimensionales.
Las funciones de forma del elemento bidimensional se encuantran aplicando la ecuacin:
1
1
(1 ) ( 1) =
2
2
1
1
N2 = L1,2 ()xL1,1 () = ( + 1) ( 1) =
2
2
1
1
N3 = L1,2 ()xL1,2 () = ( + 1) ( + 1) =
2
2
1
1
N4 = L1,1 ()xL1,2 () = (1 ) ( + 1) =
2
2
N1 = L1,1 ()xL1,1 () =
1
(1 )(1 )
4
1
(1 + )(1 )
4
1
(1 + )(1 + )
4
1
(1 )(1 + )
4
(4.128)
(4.129)
(4.130)
(4.131)
Estas son las funciones de forma halladas anteriormente por el anlisis de Algebra lineal.
El siguiente codigo esta hecho en python v.2.7 la cual esta usando las librerias de ipython(Libreria
de clculo algebraico) y numpy(Libreria de calculo de Matrices),la cual nos resuelve la interpolacin
de lagrange en n puntos.
Figura 4.19: Discretizacin del elemento bidimensional de cuatro nodos
62
N1
2014.
N2
# PROGRAMA DE FUNCIONES DE FORMA LINEALES .

from numpy import *
from sympy import *
def Forma_X (n ,o) :
x= Symbol ( 'x ')
lista_datos = arange (-1 ,1 ,2/ float (n ))
lista_final01 = lista_datos . tolist ()
lista_final02 = lista_final01 + [1. 00 ]
producto01 = 1
producto02 = 1
numero_elegido = lista_final02 [o]
lista_final02 . pop (o)
lista_definitiva = lista_final02
for i in range ( len ( lista_definitiva )) :
producto01 = producto01 * (x- lista_final02 [i])
for i in range ( len ( lista_definitiva )) :
producto02 = producto02 * ( numero_elegido - lista_definitiva [i])
return together ( producto01 /( producto02 ))
Ejemplo 04.
Considere el elemento Bidimensional de nueve nodos que se presenta en el espacio natural en la
siguiente gura,obtener las funciones de forma mediante combinaciones de Lagrange. Se considera la
siguiente aproximacin :
Na (, )ue
a
u=
(4.132)
a=1
Las funciones de forma se determinan mediante interpolacin de Lagrange unidimensionales en las
direcciones
respectivamente.Debe notarse que,en cada direccin,se tiene ahora tres estaciones de
interpolacin.La interpolacin bidimensional se compone de las dos interpolaciones unidimensionales

que se mostro en la gura.
La siguiente tabla se emplea para relacionar la numeracin nodal del elemento bidimensional con la
numeracin nodal de la interpolacin unidimensional.
63
2014.
N3
N4
64
2014.
Figura 4.23: Elemento Bidimensional de nueve nodos.

n
L()
L()
Cuadro 4.4: Tabla nodal del problema de nueve nodos.
Luego analizaremos las funciones de forma para cada nodo,la cual se analizaria el espacio para calculo
de interpolacin nodal general del problema de nueve nodos antes mencionados.
1
1
1
()( 1) ()( 1) = ()( 1)( 1)
2
2
4
1
1
1
N2 (, ) = L2,2 ()xL2,1 () = ()( + 1) ()( 1) = ()( + 1)( 1)
2
2
4
1
1
1
N3 (, ) = L2,2 ()xL2,2 () = ()( + 1) ()( + 1) = ()( + 1)( + 1)
2
2
4
1
1
1
N4 (, ) = L2,1 ()xL2,2 () = ()( 1) ()( + 1) = ()( 1)( + 1)
2
2
4
1
1
N5 (, ) = L2,3 ()xL2,1 () = (1 2 ) ()(1 ) = (1 2 )()(1 )
2
2
1
1
N6 (, ) = L2,2 ()xL2,3 () = (1 2 ) ()(1 + ) = (1 2 )()(1 + )
2
2
1
1
N7 (, ) = L2,3 ()xL2,2 () = (1 2 ) ()(1 + ) = (1 2 )()(1 + )
2
2
1
1
N8 (, ) = L2,1 ()xL2,3 () = (1 2 ) ()(1 ) = (1 2 )()(1 )
2
2
N9 (, ) = L2,3 ()xL2,3 () = (1 2 )(1 2 ) = (1 2 )(1 2 )
N1 (, ) = L2,1 ()xL2,1 () =
65
(4.133)
(4.134)
(4.135)
(4.136)
(4.137)
(4.138)
(4.139)
(4.140)
(4.141)
2014.
Los elementos formados asi generan familias de elementos Lagrangianos,una de las familias de elementos stndard,que se presentan en la siguiente gura: [4]
Figura 4.24: Elementos de Discretizacin lineal y bidimensional.
4.3.3. Elementos de Transicin.

Considere el caso en que una parte de la malla generada para modelar un problema bidimensional
se ha formado con elementos biliniales de cuatro nodos,y otra parte con elementos cuadrticos de
8 nodos.Esto puede haberse hecho para obtener un mayor grado de precisin de la regin donde se
presentan un cambio rpido en el valor de la funcin que se busca,sin tener que renar en exceso las
zonas en las que el valor de la funcin es prcticamente constante.En la gura se muestra la zona en
donde las dos mallas se unen. [4]
Figura 4.25: Transicin de Malla Cuadrtica.
66
2014.
El problema que se presentan en esta unin que la interpolacin no ser continua a trvez de la frontera
entre elementos disimilares, y por tanto,se pierde la convergencia hacia la solucin correcta.Este
problema no se eliminara empleando elementos lineales ms pequeos cuyos nodos coincidieran con
lo nodos intermedios de la malla cuadrtica,porque la interpolacin sobre el lado de los elementos
de cuatro nodos sigue siendo lineal,mientras que,sobre el lado de los elementos de ocho nodos,sigue
siendo parablica.Una forma de resolver este tipo de conexiones es mediante el uso de elementos de
transicin,como el que se muestra en la gura,en donde tres de los lados son lineales mientras que el
otro es cuadrtico. [4]
Figura 4.26: Elemento de transicin lineal cuadrtico.

La funcin de forma correspondiente al nodo 5 se puede obtener al mezclar interpolacin lagrangianas
lineales en
y cuadrticas en
,esto
es:
N5 (, ) = L1,2 ()xL2,3 ()
1
N5 (, ) = (1 + )(1 2 )
2
(4.142)
(4.143)
Esta funcin de forma cumple con los requisitos bsicos de la interpolacin nodal.
N5 (, ) =
j = 1, 2, 3, 4
(4.144)
j=6
Las funciones de forma de 1 al 4 son funciones bilineales ,las cuales ,al evaluarse en la posicin del
nuevo nodo 6, valen:
N1 = N2 = 0
1
N2 = N3 =
2
67
(4.145)
(4.146)
2014.
Las funciones de forma de los nodos 2 y 3 no cumplen con el requisitos de desvanecerse en la posicin de
nodo 5;por lo tanto, es necesario modicarlas para que satisfagan el requisito.Una forma de realizar
esta modicacin consiste en sustraer la funcin
N5
escalada adecuadamente.De esta manera,las
funciones de forma para los cuatro nodos de esquina quedaria:
1
(1 )(1 )
4
1
N2 = N2 N5
2
1
1
1
2
N2 = (1 + )(1 ) (1 + )(1 )N2 = (1 + )( 1)
4
4
4
1
N3 = N3 + N5
2
1
1
N3 = (1 + )(1 + ) (1 + )(1 2 )
4
4
1
N3 = (1 + )( + 1)
4
1
N4 = (1 + )(1 )
4
N1 =
(4.147)
(4.148)
(4.149)
(4.150)
(4.151)
(4.152)
(4.153)
4.3.4. Elementos Triangulares y tetahedricos de clase C 0 .

En secciones anteriores de este capitulo,se ha encontrado que mediante la tcnica de degeneracin es posible crear elementos triangulares y tetrahedricos a partir de cuadrilteros y hexaedros,respectivamente.Se
hizo la observacin de que la generacin produce mapeos que no son uno a uno en los nodos o lados en
donde se colapsan los elementos originales, y por lo tanto, se pierden la convergencia de la solucin sin
embargo,puesto que las ecuaciones de elementos nitos se evaluan numericamente en puntos interiores de
los elementos,en donde siempre estarn bien denidos los mapeos,se ha encontrado que estos elementos
producen tambin convergencia a la solucin correcta en el lmite.No obstante, es adecuado desarrollar
elementos de este tipo en un sistema diferente de coordenadas,llamadas coordenadas triangulares o baromtricas debido a que producen interpolaciones ms simples que las que producen en coordenadas
rectangulares como se observan a continuacin.
Elemento Triangular de 3 nodos.

La conguracin del elemento se muestra en la gura ,se muestra la denicin de un nuevo sistema de
coordenadas ,denominadas coordenadas triangulares ,que puedan denirse con base en las sub-reas que
se generan al trazar lineas de los vertices al punto en cuestin.Se denen tres coordenadas para el punto:
r=
A1
A
s=
A2
A
t=
A3
A
0 r, s, t 1
Figura 4.27: Elemento Triangular de tres nodos denido en coordenadas triangulares.
68
(4.154)
2014.
Cada terna de coordenadas dene una forma nica a cualquier punto del tringulo.Siendo una gura
plana,parece equvoco que se repitan tres coordenadas para denir un punto;esto es correcto,ya que en
realidad las coordenadas no son independientes,sino que estn ligadas por la ecuacin de restriccin:
r+s+t=1
(4.155)
Se observa que el rango de valores para cada coordenada va desde crero hasta uno.Dada la posicin de
los nudos en los vertices del triangulo, es posible emplear directamente estas coordenadas como funciones
como muestran en las siguientes ecuaciones:
x = N1 xe + N2 xe + N3 xe
1
2
3
y=
e
N1 y1
e
N2 y 2
(4.156)
e
N3 y3
(4.157)
(4.158)
con:
N1 = r
N2 = s
N3 = t
(4.159)
La aproximacin a la solucin se propone siguiendo el mismo formato:
u = N1 u1 e + N2 u2 e + N3 u3 e
(4.160)
Debe recordarse que solo se emplean realmente dos coordenadas independientes,por lo que se utiliza la
ecuacin como una ecuacin de restriccin para una de las variables,digamos
t=1rs
t.
(4.161)
La convergencia en este caso,se asegura,como en los elementos cuadrilaterales,vericando que hay continuidad y suavidad en las funciones de interpolacin.En particular,se tendr que vericar que el determinante
del jacobiano de la transformacin es positivo.Debido a la dependencia entre las variables,dada por la
ecuacin:
x
r
y
r
x
s
y
s
J =
(4.162)
Interpolacin de Elementos Triangulares.

Se emplear la interpolacin de lagrange para desarrollar interpolaciones de orden ms alto que el lineal.Se
dene la interpolacin para triangulos mediante.
LI1,I (r) =
(
i=1
r ri
)
rI ri
1
Para todo :I
Para Valores de :
=1
(4.163)
I=1
(4.164)
Para elementos en dos dimensiones,se hace el producto en tres interpolaciones,en direccin de las tres
coordenadas triangulares ,formando una reticula de nodos como la que se muestra en la siguiente gura,de
manera que la funcin de forma para un nodo
se expresa mediante:
Na (r, s, t) = Ti (r)Tj (s)Tk (t)
69
(4.165)
2014.
Figura 4.28: Patrn para generar elementos de alta jerarquia en coordenadas triangulares.
Ejemplo 01.
Como ejemplo,las funciones de forma del elemento triangular de tres nodos que se muestran en la gura
se obtienen con dos estaciones a lo largo de cada coordenada.Para las funciones de interpolacin se aplica
EC(163),EC(164) resultan las mismas funciones que antes:
r ri
=r
r2 r1
s s1
N2 = T1 (r) T2 (s) T1 (t) =
=s
s2 s1
s s1
N3 = T1 (r) T1 (s) T2 (t) =
=t
s2 s1
N1 = T2 (r) T1 (s) T1 (t) =
(4.166)
(4.167)
(4.168)
Ejemplo 02.
Hallar las funciones de forma por el metodo antes mencionado de la siguiente forma Triangular: Este
Figura 4.29: Elemento Triangular de 6 nodos.

elemento se presentan en la gura ,en ella se observa que se tiene 3 estaciones en cada direccin de cada
coordenada.
70
2014.
Las funciones de forma son:
(r r1 )(r r2 )
= r(2r 1)
(r3 r1 )(r3 r2 )
(s s1 )(s s2 )
N2 (r, s, t) = T3 (s) T1 (r) T1 (t) =
= s(2s 1)
(s3 s1 )(s3 s2 )
(t t1 )(t t2 )
N3 (r, s, t) = T3 (t) T1 (r) T1 (s) =
= t(2t 1)
(t3 t1 )(t3 t2 )
r0
s0
1 = 4rs
N4 (r, s, t) = T2 (s) T2 (r) T1 (t) =
0,5 0 0,5 0
s0
t0
N5 (r, s, t) = T2 (s) T2 (s) T1 (r) =
1 = 4st
0,5 0 0,5 0
t0
r0
1 = 4rt
N6 (r, s, t) = T2 (r) T2 (t) T1 (r) =
0,5 0 0,5 0
N1 (r, s, t) = T3 (r) T1 (s) T1 (t) =
(4.169)
(4.170)
(4.171)
(4.172)
(4.173)
(4.174)
(4.175)
4.4.
Calculo Analtico sobre Elementos Triangulares y Rectangu-
lares de lados rectos.

La integracin de polinomios sobre el rea de elementos bidimensionales puede ser laboriosa y en general se
hace uso de integracin numrica.No ostante,en el caso de elementos rectangulares o triangulares de lados
rectos existen expresiones analticas de gran utilidad prctica as,expresando los trminos del integrando
de las diferentes matrices en funcin de las coordenadas cartesianas locales
que se muestran en la
gura ,puede obtenerse que la integral de un trmino tpico ,tal como.
xm y n dA
Kij = D
(4.176)
Ae
venga dada por las expresiones siguientes:
m!n!
Elementos Triangulares
(m + n + 2)!
(2a)m+1 (2b)n+1
Kij = D
Elementos Rectangulares
(m + 1)(n + 1)
Kij = Dcn+1 am+1 (b)m+1
En las ecuaciones anteriores
(4.177)
(4.178)
son enteros, a,b y c dimensiones tipicas del elemento de la gura ; y
D una constante que depende del tipo de elemento,de las propiedades del material y de las derivadas de
las funciones de forma.Una vez obtenida la correspondiente matriz
x,y ,pueden
o el vector
en coordenadas locales
transformarse a ejes globales mediante la clasica expresiones:
Kij = T T Kij T ,fi = T T f i
(4.179)
donde T es la matriz de cambio de ejes:
cos(xx) cos(xy)
T =
cos(yx
siendo(xx) el ngulo que forma el eje
cos(yy)
con el eje global x,etc.
71
(4.180)
2014.
Figura 4.30: Coordenadas x',y' para el clculo analtico de las integrales de elementos triangulares y rectangulares.
El clculo de la matriz de rigidez en elementos triangulares exige obtener derivadas de las funciones de
forma expresadas en coordenadas de area es decir
(r, s, t),con
respecto a las coordenadas cartesianas.As
por ejemplo [3]
N1 r
N1 s
N1 t
(r, s, t)
=
+
+
x
r x
s x
t x
(4.181)
Si el elemento triangular es de lados rectos se deduce que:
(r, s, t)
bi
=
x
2Ae
ci
(r, s, t)
=
y
2Ae
(4.182)
pudiendo obtenerse fcilmente una expresin de los integrandos de la matriz de rigidez en funcin de las
coordenadas de rea.Dichas integrales pueden evaluarse directamente por las expresiones siguientes:
k! l! m!
(2 + k + l + m)!
k! l!
rk sl ds = le
(1 + k + l)!
(e)
l
rk sl tm dA = 2Ae
Ae
(4.183)
(4.184)
Si en las integrales anteriores no aparece alguna de las coordenadas de rea,simplemente se omite el correspondiente exponente en los denominadores de los segundos miembros de la ecuacin anterior y se hace
igual a la unidad de los numeradores. [4]
72
Captulo 5
SLIDOS DE REVOLUCIN.
5.1.
Introduccin.
En este capitulo estudiaremos el anlisis por mtodo de los elementos nitos de slidos con simetria
axial.Es decir,consideremos slidos en los que su geometria y propiedades mcanicas son independientes
de la coordenada circunferencial
i .Aunque
el comportamiento de dichos solidos es tridimensional,pero
su estudio es generalmente bidimensional ya que en la mayoria de los casos puede efectuarse utilizando
variables que dependen nicamente de dos coordenadas cartesianas. [4]
Figura 5.1: Slido de Revolucin.

Si las cargas exteriores son tambin de revolucin,el desplazamiento de un punto de una estructura considerada como slido de revolucin tiene solo componentes en direcciones radial
(u) y el axial (w).El estudio
de dichas estructuras por elementos nitos no es complicado y sigue prcticamente los mismos pasos que
se explicaron en el capitulo anterior para problemas de elasticidad bidimensional.Si las cargas no son de
revolucin hay que realizar un anlisis tridimensional.
5.2.
Formulacin Bsica.
5.2.1. Campo de Desplazamiento.

Sea el slido de revolucin de la gura.Si las cargas son tambin de revolucin el movimiento de un punto
queda perfectamente denido por las componentes de los desplazameintos radiales
73
y el axial
w,siendo
2014.
nula la componente circunferencial
.Por
consiguiente,se puede denir el factor desplazamiento de un
punto por:
u(r, s)
w(r, s)
u=
(5.1)
5.2.2. Campo de Deformaciones.

u y w son independientes de las
.Por consiguiente se deduce de inmediato que las deformaciones tangenciales
Debido a la simetria axial del problema los dos desplazamientos no nulos

coordenadas circunferencial
son nulas.Asimismo,de la teoria de elasticidad se obtiene.
r =
siendo
r ,z
rz
u
r
z =
w
z
rz =
u w
+
z
r
(5.2)
las deformaciones radial,axial,tangencial resepectivamente.
Por otra parte la deformacin axial del cuerpo provoca que los puntos situados sobre una circunferencia
de radio r pasen despus de la deformacin a estar situados sobre otra de radio
deformacin circunferencial
r + u.Por
ello,se dene la
como la variacin relativa de longitud entre dichas circunferencias Es decir:
2(r + u)
u
=
2r
r
(5.3)
El vector de deformaciones de un punto tiene,por tanto,las cuatro componentes siguientes:
rz
u
r
w
z
u
r
u
z
w
r
(5.4)
5.2.3. Campos de Tensiones.

Las tensiones no nulas se corresponden no nulas se corresponden con las deformaciones no nulas As,pues
el vector de tensiones se escribe como:
= {r , z , , rz }
donde
r , z ,
(5.5)
son,respectivamente ,las tensiones radial,axial y circunferencial, y
rz ,
es la tensin tan-
gencial.
5.2.4. Ecuacin Constitutiva.

la Relacin entre tensiones y deformaciones se deduce de la elasticidad tridimensional de forma anloga
al caso de elasticidad bidimensional.En presencia de tensiones y deformaciones iniciales se obtienes:
= D( 0 ) + 0
(5.6)
donde si el material es isotropo:
D=
(1 + )(1 2)
12
2
74
(5.7)
2014.
Figura 5.2: Tensiones actuando sobre un elemento diferencial de un solido de revolucin.
5.2.5. Expresin del Principio de los Trabajos Virtuales.

La expresin del PTV es anloga a la de elasticidad biimensional ,estando ahora todas las integrales
referidas al volumen del slido de revolucin.Se deduce que el diferencial de volumen se puede expresar
como:
dV = (rd)dr.dz = rddA
(5.8)
donde dA es la diferencial de rea de la seccin meridional del slido .As ,pues ,la expresin del PTV en
un slido de revolucin se escribe como:
T rddA =
A
uT brddA +
uT brdds +
uT qi ri d
i
i
(5.9)
donde l es el contorno de la seccin meridional y:
br
b=
bz
t=
tr
tz
qi =
qri
qzi
(5.10)
Son los vectores de fuerzas exteriores msicas ,de supercie y puntuales ,respectivamente .Recordemos de
nuevo que ahora todas las cargas tienen simetria de revolucin.
Haciendo uso de la simetria axial puede efectuarse la integracin sobre la variable circunferencial
para
dar:
T dA = 2
2
A
Se observa que el coeciente
uT brdA + 2
A
uT rds + 2
l
aT qi ri
i
(5.11)
aparece multiplicando todos los trminos ,pudiendo por lo tanto elimi-
narse.No obstante,conviene matenerlo por razones didcticas,y,fundamentalmente ,para recordar que los
valores de las cargas puntuales
qi
se reeren a las intensidades de carga por unidad de longitud circunfe-
rencial. [3]
75
2014.
5.3.
Formulacin de Elementos Finitos.
Presentamos seguidamente la formulacin de elementos nitos utilizando,en primer lugar,el elemento de

slido de revolucin ms sencillo que,analogamente al caso del plano, es el elemento triangular de revolucin
de tres nodos.El elemento,como se puede apreciar en la gura es un anillo de seccin triangular.Hay que
resaltar que un slido de revolucin los elementos son anulares ,aunque en virtud de la ecuaciones anteriores
todas las integrales del elemento se evalen nicamente sobre una seccin maridional operndose,por
tanto,sobre un elemento bidimensional. [3]
Figura 5.3: Elemento slido de Revolucin triangular de tres nodos.
5.3.1. Discretizacin del campo de desplazamientos.

Dentro de la Seccin meridional de un elemento,el campo de desplazamientos se interpola en forma anloga
al caso plano.As,para el elemento triangular de tres nodos.
u=
N1 u1
N2 u2
N3 u3
N1 w1
N2 w2
N3 w3
N1
N2
N3
N1
N2
(5.12)
N3
N = [N1 , N2 , N3 ] =
Ni
(5.13)
a1
e
a2
a =
= [u1, w1, u2, w2, u3, w3]T
a3
Las funciones de forma
(5.14)
se obtienen directamente de las del elemento triangular de tres nodos de
elasticidad plana,sustituyendo simplemente las coordenadas x,y por r,z.La interpolacin de las expresiones
anteriores al caso de un elemento de n nodos.
76
2014.
5.3.2. Discretizacin del campo de deformaciones y tensiones.

Del Vector de deformaciones y las ecuaciones de obtienen.
i=1
Ni
r
Ni
z
Ni
r
Ni
z
Ni
r
a1
ui
a2
= [B1 , B2 , B3 ]
= Bae
wi
a3
(5.15)
siendo B la matriz deformada del elemento del nodos i.

Para un elemento de n nodos se tendria n submatrices
Bi ,observase
que la matriz de deformacin no es

Ni
r que contiene una singularidad en el
origen de coordenadas .Ms adelante comentaremos como puede evitarse este problema.
constante como en el caso de elasticidad plana debido al termino
Para el elemento triangular de tres nodos se obtiene una forma ms explicita de
Bi ,sustituyendo
la expre-
sin de las funciones de forma :
Bi =
2A
bi
0
(ai +bi r+ci z)
r
ci
ci
bi
(5.16)
El vector de tensiones se obtiene sustituyendo por :
Bi Da(e) D0 + 0
(5.17)
i=1
= u en puntos
r
0
del eje z al aparecer el cociente indeterminado .Este problema puede sortearse calculando el en puntos
0
ligeramente alejados def eje, o lo que es ms usual extrapolando las tensiones de puntos del interior del
Durante el clculo de las tensiones puede surgir problemas para encontrar el valor de
elemento(que generalmente son los puntos de Gauss) al eje .Otro procedimiento muy sencillo es utilizar
= r
la propiedad de que
correspondiente a
en el eje , lo que simplemenete implica reemplazar la segunda la de B
por la primera que corresponde a
r .
5.3.3. Matriz de Rigidez del Elemento.

Partiendo del primer miembro de la expresin del PTV particularizando para un elemento utilizado en la
gura ,se hace el analisis de manera identica a como se hizo en el caso de elasticidad plana ,se obtienen
la expresin del equilibrio del elemento como.
K e ae f e = q e
(5.18)
en la que la matriz de rigidez del elemento de la rigidez del elemento tiene la expresin siguiente:
(e)
Kij = 2
A(e)
T
Bi DBj rdrdz
(5.19)
La expresin anterior es vlida para cualquie elemento bidimensional de n nodos.En la gura se muestra
la forma desarrollada
e
Kij
para el elemento triangular de tres nodos .
77
2014.
5.3.4. Vectores de fuerzas nodales equivalentes.

De la expresin de los trabajos virtuales se obtienen el vector de fuerzas nodales equivalentes:
f e = 2
N T brdA + 2
A
N T trds + 2
le
B T D0 rdA 2
78
(5.20)
e
fb ;la segunda a las fuerzas
e
f y la cuarta debida a tensiones
Donde la primera integral corresponde al vector de fuerzas msicas de volumen
e
de supercie ft ;la tercera a la fuerza debida a las tensiones iniciales
e
iniciales f .
B T 0 rdA
Ae
Parte IV
EJEMPLOS DE CLCULO DE
ELEMENTOS FINITOS.
79
Captulo 6
Ejemplos y Problemas de Elementos

Finitos.
6.1.
Vigas.
6.1.1. Problema N01:

Se tiene en la gura donde se trata de una barra continua de 0.30x0.30 m2 de Area y una E=1400000.00,nos
piden resolver el sistema.
Figura 6.1: Primer Problema para uso del Programa Femax.
Puesta de datos en el programa Materiales.
Figura 6.2: Puesta de Datos de Materiales.
80
2014.
puesta total de datos:
Figura 6.3: puesta de datos total del esquema a prueba.
Puesta de Datos en el sap 2000 V14.
Figura 6.4: Puesta de datos en Sap 2000 V14.
El programa Femax te halla la matriz de rigidez,una ventaja sobre el SAP ya que el sap no te da
la matriz,claro que en el fondo es un dato que en el diseo comercial es imprctico mas no en el
entendimiento del mtodo de elementos nitos.
81
2014.
25200
0.00
0.00
-25200
0.00
0.00
0.00
0.00
0.00
0.00
90.72
226.8
0.00
-90.72
226.80
0.00
0.00
0.00
0.00
226.8
756
0.00
-226.80
378.00
0.00
0.00
0.00
-25200
0.00
0.00
67200.00
0.00
0.00
-42000.00
0.00
0.00
0.00
-90.72
-226.8
0.00
510.72
403.2
0.00
-420.00
630
0.00
226.80
378.00
0.00
403.20
2016.00
0.00
-630.00
630.00
0.00
0.00
0.00
-42000.00
0.00
0.00
420000.00
0.00
0.00
0.00
0.00
0.00
0.00
-420.00
-630.00
0.00
420.00
630.00
0.00
0.00
0.00
0.00
630.00
630.00
0.00
-630.00
1260.00
Cuadro 6.1: Matriz de Rigidez General hallada por el programa Femax.
Tambien el programa calcula la matriz simplicada o matriz generada por los grados de libertad.
2016.00
0.00
-630.00
0.00
420000
0.00
630.00
0.00
-630.00
0.00
420.00
-630.00
630.00
0.00
-630.00
1260.00
Cuadro 6.2: Matriz simplicada copiada del Femax.
Figura 6.5: Matriz de Rigidez obtenida por Femax.
82
2014.
Calculo de las deformaciones se dan por medio de la matriz de rigidez disminuida o simplicada
1
ui = KD Fi .
Figura 6.6: Comparacin de Resultados de Desplazamientos.
Haciendo la respectiva comparacin de los resultados del anlisis de los desplazamientos totales en
los nudos.
R
SAP 2000 V14
Femax 1.01
%Comparacin
Nudo A
0.01044200
0.01036155
99.22 %
Nudo B-1
0.069695
0.06917898
99.25 %
Nudo B-2
0.0294900
0.02940917
99.72 %
Cuadro 6.3: Tabla de Comparacin del Calculo de los Desplazamientos.
Clculo de las fuerzas internas en el sap V14 2000 y en el Femax.
Figura 6.7: Comparacin de Resultado de Fuerzas Int.
83
2014.
Cuadro de comparacin y porcentaje de las mismas.

F
Femax
Sap 2000 V14
% Comparacin
F y1
M z1
F y2
2.65
2.6561
99.77 %
0.25
0.28
89.28 %
11.34
11.39
99.56 %
Cuadro 6.4: Comparacin de Resultados de Fuerzas Internas de Sap 2000 V14 y Femax.
Figura 6.8: Comparacion de Gcos del Femax con Sap 2000 V14.
84
2014.
6.2.
Porticos.
6.2.1. Problema N02.
Calcular el siguiente Marco con el Mtodos de elementos nitos.
E=1400000.00
I=0.000675m
Figura 6.9: Esquema del Problema N02.
Poner los datos y las condiciones iniciales del problema las cuales se dar en Femax y SAP al mismo
tiempo para su respectiva comparacin.
Figura 6.10: Puesta de Datos en Sap 2000 V14.
85
2014.
Figura 6.11: Puesta de Datos en Femax 1.01
Comparacin de los desplazamientos en los nudos:
Figura 6.12: Comparacin de los desplazamientos en Femax y Sap 2000 V14.
86
2014.
Sap 2000 V14
Femax
% Comparacin
u2
0.0038200
0.00372745
97.57 %
v2
0.00012800
0.00012827
100.2 %
0.003245
0.0031947
98.44 %
u3
0.003743
0.00364976
97.50 %
v3
0.00015745
0.00015745
100 %
0.0014770
0.00145116
98.25 %
Cuadro 6.5: Tabla de comparacin de las Deformaciones Sap y Femax.
Veremos el Clculo de las matrices de Rigideces y la matriz de rigidez simplicada.
Figura 6.13: Matriz de Rigides General del esquema.
el clculo de los resultados de las Fuerzas Internas.
Figura 6.14: Comparacin de Fuerzas Internas del Femax y el Sap 2000 V14.
87
2014.
Sap 2000 V14.0
Femax
% Comparacin.
F x1
F y1
M z1
F x4
F y4
M z4
0.427000
0.44712991
104.7 %
5.389200
5.387303570
99.96 %
0.38189
0.33563433
87.87 %
2.4270
2.4471
100.8 %
6.6108
6.6126
100.00 %
3.1751
3.2136
101.2 %
Cuadro 6.6: Tabla de Comparaciones de Calculo de Reacciones del esquema.
Figura 6.15: Comparacin Graca del Sap 2000 V14 y el Femax.
88
Parte V
CRITERIOS DE
PROGRAMACIN-(USOS DEL
PROGRAMA)
89
Captulo 7
Programacin general del Femax.

La aplicacin con exito en este caso del mtodo de elementos nitos se reduce a un programa que he elaborado con uso del lenguaje de python y con un sistema de clases y funciones de listas y librerias,conceptos
que fueron desarrollando con teorias de elementos nitos de los capitulos anteriores,el concepto que se
elabor para poder desarrollar el programa fue,en un sistema simple,graco y que tenga un n solo explicativo,pues el programa aun es muy simple para ser usado para clculos complejos,ya que su n es
simplemente el Femax 1.00 es solo para uso docente y para explicacion en si del metodo ya que el lenguaje
fue desarrollado de manera que pueda ser entendida para los que tengan interes en el tema y puedan
seguir investigando en el mtodo la cual se deja a criterio de posteriores tesistas que tengan interes de
investigacin en este mtodo.
7.1.
Caracteristicas del Programa Femax.
En la gura(7.1)se muestra el diagrama de ujo del programa ,en el cual se analizar para los ,sistemas
o bucles mas importantes de ella la cual nos dar una idea total del sistema.Para centrar conceptos
deniremos seguidamente las etapas fundamentales asociadas al anlisis de una estructura por un prorama
de elementos nitos,asi como la relacin de cada etapa con la subrutinas puestas en el diagrama de ujo
principal.
7.1.1. Puesta de Datos.

La puesta de datos se ha desarrollado con dos librerias principales de python a cual es numpy y Tkinter
una es encargada de los datos numericos en arreglos la cual es establecida con listas y matrices en la cual
ya nos estaremos analizando seguidamemte y la otra libreria nos da la oportunidad de entorno grco,con
la cual nos dar la oportunidad de darnos un entorno agradable y trabajable,la subrutina puesta de datos
se basa en tres partes una de ellas es la puesta de grilla o ejes de trabajo la cual nos da la oportunidad
de tener una cierta forma de ejes de referencia la misma est colocado en la parte superior derecha del
programa Femax.
Grilla.
La grilla es un sistema de referencia que se trata de unas lineas de contorno debil y que son aproximadas en
los puntos de interes con un sistema de osnap o de acercamiento cuando los eventos del mause se acercan
a los
(x, y)
de los puntos ya derivados del software o puntos de interes del mismo,todos los puntos son
georeferenciados con el osnap y se traduce en facilidad en el trazo de las barras,fuerzas.
90
2014.
Figura 7.1: Diagrama de ujo del programa Femax.
def grilla () :
global Ubicaciones_Universales
Ubicaciones_Universales =[]
def dibujo_grilla () :
if nx . get () ! =0 and ny . get () !=0:
for i in range ( nx . get () +1) :
dibujo . create_line ( 50 +i* mx . get () *50 , 550 , 50 +i* mx . get () *50 , 550 ny . get () * my . get () * 50
, fill = ' gray ', activefill = ' red ', dash =(3 ,5) , tag = ( ' Recta01 '))
for i in range ( ny . get () +1) :
dibujo . create_line ( 50 , 550 -i* my . get () *50 , 50 +( nx . get ()) * mx . get () *50 ,
550 -i* my . get () *50 ,
fill = ' gray ', activefill = ' red ', dash =(3 ,5), tag =( ' Recta02 '))
for u in range ( nx . get () +1) :
for m in range ( ny . get () +1) :
Ubicaciones_Universales . append ([ 50 +u* mx . get () *50 , 550 -m* my . get () * 50 ] )
dibujo . create_oval ( 50 +u* mx . get () * 50 -2 , 550 -m* my . get () * 50 -2 ,
50 +u* mx . get () * 50 +2 , 550 - m* my . get () * 50 +2 , fill = ' red ', activefill = ' blue ')
else :
tkMessageBox . showinfo ( message = ' Por Favor poner Datos ')
ventana_grilla = Toplevel ()
ventana_grilla . title ( ' DIBUJAR GRILLA P/ ESQUEMA ')
ventana_grilla . minsize ( 500 , 200 )
ventana_grilla . geometry ( ' 500x200 +0+0 ')
# ------------------------------------------------------------------------------nx = IntVar ()
mx = DoubleVar ()
91
2014.
ny = IntVar ()
my = DoubleVar ()
# --------------------------------------------------------------------------------texto_principal = Label ( ventana_grilla , text = ' COORDENADAS EN EL EJE X: Y ')
. place (x= 100 ,y =0)
Texto_01 = Label ( ventana_grilla , text = 'N : Ejes - X '). place (x =10 ,y = 20 )
texto_02 = Label ( ventana_grilla , text = 'Dist - Ejes -X '). place (x= 250 ,y= 20 )
texto03 = Label ( ventana_grilla , text = 'N: Ejes -Y '). place (x=10 ,y= 60 )
texto04 = Label ( ventana_grilla , text = 'Dist - Ejes - Y ' ). place (x = 250 ,y = 60 )
# --------------------------------------------------------------------------------Ejes_Horizontales = Entry ( ventana_grilla , textvariable = nx ). place (x= 80 ,y= 20 )
Distancias_Horizontales = Entry ( ventana_grilla , textvariable = mx ). place (x= 320 ,y= 20 )
# --------------------------------------------------------------------------------Ejes_Verticales = Entry ( ventana_grilla , textvariable = ny ). place ( x=80 , y= 60 )
Distancias_Verticales = Entry ( ventana_grilla , textvariable = my ). place (x= 320 ,y= 60 )
Boton01 = Button ( ventana_grilla , text = ' APLICAR ', command = dibujo_grilla ). place (x= 300 ,y= 150 )
# ---------------------------------------------------------------------------------Boton02 = Button ( ventana_grilla , text = ' CANCELAR ', command = ventana_grilla . destroy )
. place (x= 400 ,y = 150 )
# ---------------------------------------------------------------------------------#
VENTANA DE GRILLAS - LOKITOSAMAX - ELEMENTOS DE VARIABLE
# ---------------------------------------------------------------------------------ventana_grilla . mainloop ()
Figura 7.2: Entorno Grco del Femax y su funcin de Grilla y su resultado
Lineas de Barras.
Subrutina creada para el trazo de barras la cual contiene un algoritmo de eventos consecutivos en dos
puntos
[inicial, nal],las
cuales contienen eventos de posiciones y los dibujos creados en un sistema de
la libreria visual Tkinter,contiene el lienzo o Canvas la cual es un sector de dibujo creado para hacer
representaciones grcas;nos dan una logica de armado del problema con las condiciones iniciales asi como
elementos de frontera o contorno que en el sistema biplanico lineal se basa en los apoyos la cual se ver
92
2014.
mas adelante.
def dibuja_barra () :
tkMessageBox . showinfo ( message = ' Poner el Primero y Segundo punto . ')
global puntos
global longitudes
global u2
global u
start = None
def punto ( evento ) :
global start
global u
start =[ evento .x , evento .y]
def punto2 ( evento ):
global puntos
global longitudes
global start
global u
global u2
if start is not None :
x= start [0 ]
y= start [1 ]
dibujo . create_line (x ,y , evento .x , evento .y , width =4.5 , arrow = LAST ,
activefill = ' gray ', tag = ( ' linea1 '))
dibujo . itemconfig ( ' linea1 ' , fill = ' red ')
u=u +[(x- 50 )/50 ,( 550 - y)/50 ,( evento .x- 50 )/50 ,( 550 - evento .y)/ 50 ]
longitudes = longitudes + [ norm ( array ([( evento .x - 50 )/ 50 ,( 550 - evento .y )/ 50 ])
- array ([( x- 50 ) /50 ,( 550 -y) / 50 ] )) ]
start = None
dibujo . bind ( '< Button -1 > ', punto )
dibujo . bind ( '< Button -3 > ', punto2 )
u1 = array (u)
l1 = len ( u1 )
u2 = u1 . reshape ( l1 /2 ,2)
print u2
print longitudes
Figura 7.3: Descripcin de trazo de Barras en Femax.

Las guras de barras son hechas de color rojo y echas indicando su posicin inicial y nal de las mismas,la
cual nos ayudaran a hallar las matrices o arreglos de sus caracteristicas como longitud,Seno,Coseno de las
barras respectivamente para porder calcular las matrices de transformacin y consecuentemente hallar la
matriz de rigidez.
93
2014.
Figura 7.4: Trazo de las barras en el Programa Femax.
Con el algoritmo descrito nos daran la forma para el calculo del esquema ms aun deniremos tambien
los materiales de las barras la cual estar descrito ms adelante.
Materiales.
Es una subrutina encargada de obtener los materiales tanto de
Ii , Ei , Ai ,el sistema es consecuencia o depende
del numero de las barras con la cual se puede introducir los datos en el arreglo para el respectivo clculo de la
matriz de rigidez,con la cual se hace el arreglo de la matriz general ya calculada y demostrada en el capitulo
3.2 la cual queda segun sus grados de libertad de la siguiente manera:
AE
L
KT =
AE

AE
L
6 EI
L2
12 EI
L3
6 EI
L2
6 EI
L2
4 EI
L
6 EI
L2
2 EI
L
AE
L
12 EI
L3
6 EI
L2
12 EI
L3
6 EI
L2
6 EI
L2
2 EI
L
6 EI
L2
4 EI
L
12 EI
L3
(7.1)
Ser establecido para casos particulares de de barras claro que en este sistema tambin se podr evaluar las
transformadas y de tal manera poder sumar las matrices individuales y acoplarlos en la matriz de rigidez total.
Ku = T T Ki T
esta subrutina genera un bucle de acuerdo a la cantidad de elementos de barra.
94
(7.2)
2014.
def Materiales_Calculo () :
global u2
global numero
global C3_Materiales
global nodos_espacio
nodos_espacio = u2
ventana_Materiales = Toplevel ()
ventana_Materiales . title ( ' Materiales de Elementos ')
lista_1 = [ ' Inercia '+ str (i ) for i in range ( len ( u2 ) /2)]
lista_2 = [ ' Elasticidad '+ str (i) for i in range ( len ( u2 )/ 2)]
lista_3 = [ ' Area '+ str (i) for i in range ( len ( u2 )/2) ]
ventana_Materiales . geometry ( ' 800x300 +0+ 0 ')
numero = len ( u2 ) /2
for i in range ( len ( u2 )/2) :
lista_1 [ i]= DoubleVar ()
for i in range ( len ( u2 )/2) :
u1 = Label ( ventana_Materiales , text = ' Inercia '+ str (i), fg = ' red '). place (x =0 ,y= 20 +i* 20 )
u2 = Label ( ventana_Materiales , text = ' Elasticidad '+ str (i), fg = ' red '). place (x= 200 ,y = 20 +i* 20 )
u3 = Label ( ventana_Materiales , text = ' Area '+ str (i ), fg = ' red '). place (x= 400 ,y= 20 +i* 20 )
for j in range ( numero ):
Entrada_Inercia = Entry ( ventana_Materiales ,
textvariable = lista_1 [j] , width = 10 ). place (x = 100 , y= 20 +j * 20 )
Entrada_Elasticidad = Entry ( ventana_Materiales ,
Entrada_Area = Entry ( ventana_Materiales ,
# -----------------------------------------------------------------------------------------C_Materiales = None
def guardar_datos () :
global C_Materiales
C_Materiales =[ ]
for t in range ( numero ):
C_Materiales = C_Materiales +[ lista_1 [ t]. get () ]+[ lista_2 [t]. get () ] +[ lista_3 [ t]. get () ]
C2_Materiales = array ( C_Materiales )
C3_Materiales = C2_Materiales . reshape ( numero ,3 )
print C3_Materiales
# -----------------------------------------------------------------------------------------# BOTON DE GUARDAR CARACTERISTICAS DE LOS ELEMENTOS
Boton01 = Button ( ventana_Materiales , text = ' GUARDAR ' ,
command = guardar_datos ). place (x = 600 , y= 250 )
# ------------------------------------------------------------------------------------------
95
2014.
Como vemos las caracteristicas del material lo controla un algoritmo que depende del numero de elementos
de barra.
Figura 7.5: Subrutina de Materiales del programa Femax
Apoyos o elementos de Contorno.

Es una subrutina creada para el diagramatizacin e interpretacin matricial de elementos de contorno y tiene
como n obtener los sistemas de condiciones iniciales la cual se da para el respectivo clculo de la matriz de
rigidez disminuida o simplicada ya que este sistema en concepto y en algoritmo nos da la logica de los grados
de libertad restringidos que segun sus tipo de apoyos que pueden ser empotrados,movil o jos contienen,las
restricciones necesarias para interpretarlos como elementos de contorno o condiciones iniciales:
Apoyos Fijos:
apoyos que se representa en el programa con un triangulo y contiene un solo grado de libertad en el sentido
de giro
sin embargo en el sentido de fuerzas internas contiene dos tanto en el eje x como en el eje y.
Figura 7.6: Apoyo Fijo y sus propiedades de contorno.
Apoyos Empotrados.
apoyos que se representa en el programa con una barra en T invertida y no contiene grados de libertad
sin embargo en el sentido de fuerzas internas contiene tres tanto en el eje x , en el eje y el momento
96
Mzz .
2014.
Figura 7.7: Apoyo Empotrado y sus propiedades de contorno.
Apoyos Moviles.
apoyos que se representa en el programa con un triangulo y un circulo perpendicular y tangente al mismo
contiene grados dos libertad en el eje X y la rotacin
sin embargo en el sentido de fuerzas internas
contiene uno en el eje y.
Figura 7.8: Apoyo Movil y sus propiedades de contorno.
Clase Apoyos dibujo. esta clase fu creada para poder establecer los gracos en el lienzo de tkinter ya
que se tenia que ahorrar lineas de codigo y para su mejor manejo de los conceptos a la hora de programar,la
clase necesaria para tal n en este sentido vemos la linea de codigo del paquete nodos.
class Apoyos () :
def __init__ ( self , evento , lienzo ):
self . evento = evento
self . lienzo = lienzo
def Aempotrados ( self ):
self . lienzo . create_line ( self . evento .x , self . evento .y ,
self . evento .x , self . evento .y+10 , fill = ' blue ')
self . lienzo . create_line ( self . evento .x , self . evento .y +10 ,
self . evento .x -10 , self . evento .y +10 , fill = ' blue ')
self . lienzo . create_line ( self . evento .x , self . evento .y +10 ,
self . evento .x +10 , self . evento .y +10 , fill = ' blue ')
def Afijos ( self ):
self . evento .x -10 , self . evento .y +10 , fill = ' blue ')
self . lienzo . create_line ( self . evento .x-10 , self . evento .y+10 ,
def Amoviles ( self ):
self . evento .x -5 , self . evento .y+5 , fill = ' blue ')
self . evento .x +5 , self . evento .y+5 , fill = ' blue ')
self . lienzo . create_line ( self . evento .x-5 , self . evento . y+5 ,
self . evento .x +5 , self . evento .y+5 , fill = ' blue ')
self . lienzo . create_oval ( self . evento .x-2 , self . evento . y+5 ,
self . evento .x +2 , self . evento .y+ 10 , fill = ' blue ')
programacin en el entorno grco.

en el entorno graco nos servimos del paquete apoyos para poder dibujar y representar en arreglos necesarios para poder establecer datos para su repectivo algoritmizacin en el programa en general.
97
2014.
def apoyos_general ( evento ):

global tipo_apoyos
global codigo_apoyos
global tipo_apoyos1
global codigo_apoyos1
if selec . get () ==1 :
Apoyos ( evento , dibujo ). Aempotrados ()
tipo_apoyos = tipo_apoyos +[( evento .x- 50 )/50 ,( 550 - evento . y)/ 50 ]
codigo_apoyos = codigo_apoyos + [1 ,1 , 1]
elif selec . get () == 2:
Apoyos ( evento , dibujo ). Afijos ()
Apoyos ( evento , dibujo ). Amoviles ()
AP = array ( tipo_apoyos )
AM = array ( codigo_apoyos )
codigo_apoyos1 = AM . reshape ( len ( AM )/3 , 3)
tipo_apoyos1 = AP . reshape ( len ( AP )/2 ,2)
print tipo_apoyos1
print codigo_apoyos1
ventana_apoyos = Toplevel ()
# -----------------------------------------------------------------------Im_Fijos = PhotoImage ( file = ' fijo . gif ')
Im_Empotrados = PhotoImage ( file = ' empotrado . gif ')
Im_Moviles = PhotoImage ( file = ' movil . gif ')
# ------------------------------------------------------------------------ventana_apoyos . title ( 'Tipo - Apoyos ')
selec = IntVar ()
Texto_Empotrados = Label ( ventana_apoyos , text = ' Apoyo Empotrado '). place (x= 100 ,y= 20 )
Texto_Fjos = Label ( ventana_apoyos , text = ' Apoyo Fijo '). place (x= 100 ,y = 60 )
Texto_Moviles = Label ( ventana_apoyos , text = ' Apoyo Moviles '). place (x= 100 ,y = 100 )
Empotrados = Radiobutton ( ventana_apoyos , image = Im_Empotrados , value =1 , variable = selec )
Empotrados . place (x=20 , y= 20 )
Fijos = Radiobutton ( ventana_apoyos , image = Im_Fijos , value =2 , variable = selec )
Fijos . place (x=20 ,y= 60 )
Moviles = Radiobutton ( ventana_apoyos , image = Im_Moviles , value =3 , variable = selec )
Moviles . place (x=20 ,y= 100 )
# --------------------------------------------------------------------#
BOTON PARA INCLUIR APOYOS EN LOS PUNTOS
# ---------------------------------------------------------------------botton_01 = Button ( ventana_apoyos , text = ' Ejecutar ',fg = ' blue ' ). place (x = 200 , y= 200 )
dibujo . bind ( '< Button -1 > ', apoyos_general )
ventana_apoyos . geometry ( ' 400x300 +0+0 ')
ventana_apoyos . minsize ( 400 , 300 )
ventana_apoyos . mainloop ()
98
2014.
Figura 7.9: Apoyos en el cuadro de dilogo del Femax.
7.1.2. Matriz de Rigidez.

Esta subrutina se encarga del clculo y acoplamiento de la matriz de rigidez tanto de la general como la
matriz reducida,este sistema de acoplamiento fue resuelta con la matriz de ordenamiento o matriz
que
es un sistema de arreglo basado en los grados de libertad y el numero de barras de anlisis la cual vemos
en la siguiente formula basado en la gura 7.10.
Figura 7.10: Marco de Referencia.
99
2014.
Este metodo ordena los grados de libertad segun el sentido de la barra la cual nos dan la idea de cuales son
los elementos de
K11 , K12 , K21 , K22 ,
la cual est descrito en los puntos de coordenadas globales respecto
del sistema de barras.
f Grados
de Libertad
(7.3)
1 La formula general de ensamblaje tiene mucho que ver con el sentido de la barra ya que en este sentido en
la cual se ordena la matriz de rigidez total;la formula general de ensamblaje seria de la siguiente manera:
n
KT {i [i, n], i [j, n]} Ki [i, j]
Donde el simbolo
(7.4)
signica ensambla dentro o,explicado de otra manera al valor ya existente.En
otras palabras,el coeciete de rigidez
n
Kij
se ensambla en el rengln
(i, n),columna (j, n)
de la matriz
de rigidez global[K].como se ilustra en la siguiente gura:
Figura 7.11: Procedimiento del ensamblaje global por medio del mtodo
1 Esta forma de acoplamiento se encuentra en el libro de Tena Colunga Analisis Estructural con Metodos Matriciales a esta
forma de acoplamiento generalizacin de la matriz de acoplamiento elemento i
100
2014.
Programacin del Mtodo
i .
Se muestra en el codigo fuente del Femax en python para el sistema de
acoplamiento usando el mtodo.
# -----------------------------------------------------------------------------------#
MATRIZ DE ORDENAMIENTO --- --> PI
# -----------------------------------------------------------------------------------for i in range ( len (C )) :
ordenamiento [i ]=C[i ]
print ordenamiento
for i in range ( numero_datos ):
for j in range ( len (C )) :
if ordenamiento [j ][0]= = nodos_espacio [i] [0] and
ordenamiento [j ][1]= = nodos_espacio [i] [1]:
ordenamiento_primario . append (j)
print ordenamiento_primario
ordenamiento2 = array ( ordenamiento_primario )
numero_filas = len ( ordenamiento2 )/2
ultimo_ordenamiento = ordenamiento2 . reshape ( numero_filas ,2)
P_01S = ultimo_ordenamiento +1
P_02S = P_01S *3
WQ = array ([ range ( P_02S [i ][0]-3 , P_02S [i][0 ]) for i in range ( len ( P_02S )) ])
WR = array ([ range ( P_02S [i ][1]-3 , P_02S [i][1 ]) for i in range ( len ( P_02S )) ])
O=[ ]
for j in range ( len ( WR )) :
if i== j:
O=O +[ array ([ WQ [i] ,WR [j]] ). reshape (6) ]
P_03S = array (O)
matriz_ordenamiento = transpose ( P_03S )
print matriz_ordenamiento
Veremos Ahora el calculo de la Matriz de Rigidez y su respectivo globalizacin de la misma usando una
clase y un sistema de libreria llamado Matrix2D, la cual ser clave para el calculo ms rpido claculo de
la matriz de rigidez total y la Matriz simplicada.
from numpy import *

from numpy . linalg import *
class Matrix2D () :
def __init__ ( self ,A ,E ,I ,L):
self .A=A
self .E=E
self .I=I
self .L=L
self . Kt = zeros ((6 ,6 ))
def constructor ( self ):
self . Kt [ 0][0] = self . Kt [3] [3]=( self .A * self . E)/ float ( self .L)
self . Kt [ 0][3] = self . Kt [3] [0]=-( self . A* self .E)/ float ( self .L )
self . Kt [ 1][1] = self . Kt [4] [4]=( 12 * self .E* self .I) / float (( self .L** 3 ))
self . Kt [ 4][1] = self . Kt [1] [4]=-( 12 * self .E* self .I )/ float (( self .L* *3 ))
self . Kt [ 1][2] = self . Kt [2] [1]= self . Kt [1][5] = self . Kt [5 ][1]=
(6* self .E * self .I)/ float (( self . L**2 ))
self . Kt [ 4][2] = self . Kt [2] [4]= self . Kt [4][5] = self . Kt [5 ][4]=
-(6 * self . E* self .I)/ float (( self .L**2 ))
self . Kt [ 2][2] = self . Kt [5] [5]=4* self . E* self .I/ float (( self .L ))
self . Kt [ 2][5] = self . Kt [5] [2]=2* self . E* self .I/ float (( self .L ))
return self . Kt
class Transformada () :
def __init__ ( self ,x1 ,y1 ,x2 , y2 ):
self . x1 = x1
self . x2 = x2
self . y1 = y1
self . y2 = y2
101
2014.
self .L= sqrt (( self . x2 - self . x1 )* *2+( self . y2 - self . y1 )* *2)

self .h= self . y2 - self . y1
self .d= self . x2 - self . x1
def T( self ) :
S= self .h/ float ( self . L)
C= self .d/ float ( self . L)
t= zeros ((6 ,6 ))
t[0 ][0]=t [1][1 ]=t[3] [3]=t [4][4 ]=C
t[0 ][1]=t [3][4 ]=S
t[1 ][0]=t [4][3 ]=-S
t[2 ][2]=t [5][5 ]=1
return t
# -----------------------------------------------------------------------------------#
#
ACOPLAMIENTO FINAL DE LA MATRIZ DE RIGIDEZ TOTAL DE LA ESTRUCTURA
#
k[ PI [i ][ n], PI [j ][ n ]] < - - - - - - - - - - - - - - - - - - K {n}[i ][ n]
# -----------------------------------------------------------------------------------KT = zeros (( 3* len (C) ,3* len (C )))
for i in range ( 6):
for j in range ( 6):
for n in range ( len ( K_Rtodos )) :
KT [ matriz_ordenamiento [ i][n]] [ matriz_ordenamiento [j ][n]]
= KT [ matriz_ordenamiento [i ][n]] [ matriz_ordenamiento [j ][n]]+ K_Rtodos [n] [i][j ]
print KT
# -----------------------------------------------------------------------------------#
#
CALCULO DE MATRIZ REDUCIDA --> Ki
#
# -------------------------------------------------------------------------------------GDL01 =[]
for i in range ( len (C )) :
for j in range ( len ( tipo_apoyos1 )) :
if ordenamiento [i ][0]= = tipo_apoyos1 [j][ 0] and ordenamiento [ i][1]
== tipo_apoyos1 [j][1] :
GDL01 . append (i)
GDL02 = array ( GDL01 )
GDL03 = GDL02 +1
GDL04 = GDL03 *3
MQ = array ([ range ( GDL04 [i ]-3 , GDL04 [i ]) for i in range ( len ( GDL04 )) ])
EL = MQ * codigo_apoyos1
K_reducida_inicial = delete (KT ,EL , axis =0)
K_reducida_final = delete ( K_reducida_inicial ,EL , axis = 1)# calculo de K_reducida
print K_reducida_final
Antes del acoplamiento es bueno saber que las matrices tendran que estar sujetas o calculadas en el sistema
global la cual se calcula por medio de las siguientes formulas las cuales son establecidas por medio de las
siguientes formulas.
AE
L
Ki =
AE

AE
L
12 EI
L3
6 EI
L2
12 EI
L3
6 EI
L2
6 EI
L2
4 EI
L
6 EI
L2
2 EI
L
AE
L
12 EI
L3
6 EI
L2
12 EI
L3
6 EI
L2
6 EI
L2
2 EI
L
6 EI
L2
4 EI
L
102
(7.5)
2014.
La matriz antes mencionada en la formula es establecida como matriz de elementos locales es decir para
ejes que sean paralelos a la barra con la cual nosotros sabemos que en los problemas de anlisis estructural
estan geometricamente basados en barras conectadas en forma geometricas complejas pues para ello nos
basaremos en la matriz de tranformacin:
cos()
sen()
T =
sen()
cos()
0
0
0
cos() sen() 0
sen() cos() 0
0
0
1
0
(7.6)
La formula para llevarlo la matriz local a terminos globales de la matriz general o matriz de rigidez total
est basado en:
Kg = T T Ki T
(7.7)
Figura 7.12: Tabla de Resultado de la Matriz de Rigidez Total Femax.
7.1.3. Calculo de Deformaciones.

Esta subrutina se encarga del clculo de las deformaciones globales y deformaciones locales la cual nos
dan la oportunidad de aplicar las funciones de deformadas por medio de las funciones de interpolacin
103
2014.
o funciones de forma que se usan para hallar las grcas que son halladas por medio de la suma y
multiplicacion de las deformadas en los grados de libertad.
1 , v1 , u1 , 2 , v2 , u2
ug = N1 u1 + N2 v1 + N3 1 + N4 u2 + N5 v2 + N6 2
(7.8)
Asi que se habra forma de calculo respecto de las ecuaciones generales y para poder hallar las ecuaciones
se deben conocer las funciones ya estudiadas en anteriores capitulos sobre todo en el calculo de vigas:
N1 (x, l) = 1
x
l
x
x
N2 (x, l) = 2( )3 3( )2 + 1
l
l
x
N3 (x, l) = x(1 )2
l
x
N4 (x, l) =
l
x 3
x 2
N5 (x, l) = 3( ) 2( )
l
l
x2
x
N6 (x, l) = (1 )
l
l
(7.9)
(7.10)
(7.11)
(7.12)
(7.13)
(7.14)
El clculo de las deformaciones son dadas por las siguientes formulas:
1
KD Fi = ui
# .................................................................................
#
#
Programacion de Calculo de Fuerzas Puntuales
#
# ----------------------------------------------------------------------------------esquema_fuerzasp =[ ]
for i in range ( len ( ordenamiento )) :
for j in range ( len ( Puntos_AFuerzasP1 )) :
if ordenamiento [i ][0]= =
Puntos_AFuerzasP1 [j][ 0] and ordenamiento [ i][1] == Puntos_AFuerzasP1 [j] [1]:
esquema_fuerzasp . append ( i)
print esquema_fuerzasp
esquema_fuerzasp1 = array ( esquema_fuerzasp )
esquema_fuerzasp2 =( esquema_fuerzasp1 + 1)*3
WR = array ([ range ( esquema_fuerzasp2 [ i]3 , esquema_fuerzasp2 [i ]) for i in range ( len ( esquema_fuerzasp2 )) ])
WQ = WR . reshape ( len ( WR )*3 ,1)
Fuerzas_puntuales = zeros (( len ( ordenamiento ) *3 ,1 ))
Puntos_FuerzasP2 = Puntos_FuerzasP1 . reshape ( len ( Puntos_FuerzasP1 )*3 ,1 )
for i in range ( len ( Puntos_FuerzasP1 ) *3):
Fuerzas_puntuales [ WQ [ i]]= Fuerzas_puntuales [ WQ [i] ]+ Puntos_FuerzasP2 [i]
print Fuerzas_puntuales
# ---------------------------------------------------------------------------------#
#
Programacion de calculo de Fuerzas Distribuidas
#
# ----------------------------------------------------------------------------------F5 = F4 . reshape ( len ( F4 )*2 ,2)
esquema_FuerzasD =[ ]
for j in range ( len ( F5 )) :
if ordenamiento [i ][0]= = F5 [j] [0] and
ordenamiento [i ][1]= = F5 [j] [1]:
esquema_FuerzasD . append ( i)
esquema_FuerzasD1 = array ( esquema_FuerzasD )
esquema_FuerzasD2 =( esquema_FuerzasD1 + 1)*3
WU = array ([ range ( esquema_FuerzasD2 [ i]-3 ,
esquema_FuerzasD2 [i]) for i in range ( len ( esquema_FuerzasD2 )) ])
WP = WU . reshape ( len ( WU )*3 ,1)
print ' este es la clave '+ str ( WP )
104
(7.15)
2014.
Fuerzas_Distribuidas = zeros (( len ( ordenamiento )*3 ,1 ))

Fuerzas_DD = []
for i in range ( len ( longitudesFD )) :
Fuerzas_DD = Fuerzas_DD +
[[0 , Valores_FD [i]*( longitudesFD [i])/ float (2),
Valores_FD [ i]*( longitudesFD [i]**2 )/ float ( 12 ) ] ,
[0 , Valores_FD [ i]*( longitudesFD [ i])/ float ( 2),
- Valores_FD [i] *( longitudesFD [i ]**2)/ float ( 12 )]]
FuerzasDD1 = array ( Fuerzas_DD )
FuerzasDD2 = FuerzasDD1 . reshape ( len ( FuerzasDD1 )*3 ,1 )
for i in range ( len ( FuerzasDD2 )) :
Fuerzas_Distribuidas [ WP [i ]]= Fuerzas_Distribuidas [ WP [i ]]+ FuerzasDD2 [i]
# ---------------------------------------------------------------------------------------#
#
Programacion de Fuerzas Nodales Equivalentes
#
# ----------------------------------------------------------------------------------------Fuerzas_nequivalentes = Fuerzas_puntuales - Fuerzas_Distribuidas
Fuerzas_NodD = delete ( Fuerzas_nequivalentes ,EL , axis =0)
print Fuerzas_NodD
# ------------------------------------------------------------------------------------------#
#
Calculo de las deformaciones Nodales
#
# ------------------------------------------------------------------------------------------Deformaciones01 = dot ( inv ( K_reducida_final ), Fuerzas_NodD )
print Deformaciones01
WUP = range (0 , len ( Fuerzas_nequivalentes ))
WUP1 = array ( WUP )
WUP2 = WUP1 . reshape ( len ( WUP ),1)
WUP3 = delete ( WUP2 ,EL , axis =0)
Deformaciones_totales = zeros (( len ( ordenamiento )*3 ,1 ))
for i in range ( len ( WUP3 )) :
Deformaciones_totales [ WUP3 [ i]]=
Deformaciones_totales [ WUP3 [ i]]+ Deformaciones01 [i ]
print Deformaciones_totales
Figura 7.13: Generacin de tabla de Resultados de la tabla de las deformadas Femax.
105
2014.
7.1.4. Clculo de Fuerzas Internas.

Esta subrutina es para el clculo de las fuerzas internas que en este caso es por barra la cual nos dan la
oportunidad de hallar el clculo de las fuerzas internas por barra:
ui = T ui
(7.16)
K i (T ui ) = Fint x Barra
(7.17)
# --------------------------------------------------------------------------------------#
#
Calculo de Fuerzas Internasx - Barras
#
# ---------------------------------------------------------------------------------------us01 = transpose ( matriz_ordenamiento )
ordenamiento_fuerzasU =[]
for i in range ( len ( us01 )) :
sx = us01 [i]. reshape (1 ,6)
ordenamiento_fuerzasU = ordenamiento_fuerzasU +[ sx ]
ordenamiento_ff = array ( ordenamiento_fuerzasU ). reshape ( len ( ordenamiento_fuerzasU ),6)
SMR = array ([[ 0. 000000 ,0. 000000 ,0. 000000 , 0. 000000 ,0. 000000 ,0. 000000 ]
for i in range ( len ( ordenamiento_ff )) ])
for i in range ( len ( ordenamiento_ff )) :
SMR [i][ j]= SMR [i][ j]+
Deformaciones_totales [ ordenamiento_ff [ i][j] ]
print SMR
SMRWW =[]
SMRWW = SMRWW +[ dot (T[i] , SMR [i ]. reshape (6 ,1 )) ]
SMRWW1 = array ( SMRWW )
SMRWW2 = SMRWW1 . reshape ( len ( SMRWW ),6)
print SMRWW2
resultados_fuerzapb =[]
for i in range ( len ( SMR )) :
resultados_fuerzapb = resultados_fuerzapb +
[ dot ( K_Rtodos [ i] , SMR [i]. reshape (6 ,1 )) ]
print resultados_fuerzapb
restar_altotal = Fuerzas_nequivalentes - Fuerzas_puntuales
SMR1 = array ([[ 0. 000000 ,0. 000000 ,0. 000000 ,0 . 000000 ,0. 000000 ,0. 000000 ]
WNN = WP . reshape ( len ( WP )/ 6.00 , 6. 00 )
for j in range ( len ( WNN )) :
if ordenamiento_ff [i][ 0]== WNN [j][ 0] and
ordenamiento_ff [ i][1]= = WNN [ j][1] and
ordenamiento_ff [ i][5]= = WNN [ j][5]:
SMR1 [i][ 0]= ordenamiento_ff [i][ 0]
else :
SMR1 [i][ 0]=0. 000000000
SMR1 [i][ 1]=0. 000000000
SMR1 [i][ 2]=0. 000000000
SMR1 [i][ 3]=0. 000000000
SMR1 [i][ 4]=0. 000000000
SMR1 [i][ 5]=0. 000000000
SMR2 = array ([[ 0. 000000 ,0. 000000 ,0. 000000 ,0 . 000000 ,0. 000000 ,0. 000000 ]
106
2014.

SMR2 [i][ j]= SMR2 [i][ j]+ restar_altotal [ SMR1 [i][j ]]
fuerzas_bfinal =[]
fuerzas_bfinal = fuerzas_bfinal +[ resultados_fuerzapb [i] - SMR2 [i]. reshape (6 ,1) ]
print fuerzas_bfinal
Figura 7.14: Tabla de Resultados para el clculo de Fuerzas Internas del programa Femax.
7.1.5. Gracos y tablas de Resultados de Momentos,Cortantes,Deformada y

Cortantes.
Esta subrutina es encargada del clculo de los grcos de los esquemas usados en los acapites anteriores
de las subrutinas anteriores ,esta parte del programa esta programada con la libreria de Matplotlib,una
lbreria usada para grcos de gran capacidad la cual nos ayudaran para gracar las funciones de Cortantes,Momentos,Deformadas y giros, la cual queda establecida por medio de las funciones de forma.
ui = N1 (u1 ) + N2 (v1 ) + N3 (1 ) + N4 (u2 ) + N5 (v2 ) + N6 (3 ) + Ri (x, l)

(7.18)
N1
N2
N3
N4
N5
N6
i =
(u1 ) +
(v1 ) +
(1 ) +
(u2 ) +
(v2 ) +
(2 ) + Ri (x, l)(7.19)
x
x
x
x
x
x
2u
2 N1
2 N2
2 N3
2 N4
2 N5
2 N6
Mi = EI 2 =
(u1 ) +
(v1 ) +
(1 ) +
(u2 ) +
(v2 ) +
(2 ) + Ri (x, l)(7.20)
x
x2
x2
x2
x2
x2
x2
3
3
3
3
3
3
3
u
N1
N2
N3
N4
N5
N6
Vi = EI 3 =
(u1 ) +
(v1 ) +
(1 ) +
(u2 ) +
(v2 ) +
(2 ) + Ri (x, l) (7.21)
3
3
3
3
3
x
x
x
x
x
x
x3
107
2014.
El algoritmo para la gracacin de la misma se propone en el codigo en el siguiente item.
# ---------------------------------------------------------------------------------#
#
Algoritmo de Graficas de u , a_ {i} ,M_ {i} ,V_ {i}
#
# ----------------------------------------------------------------------------------X=[ ]
xi = arange (0 , longitudes [ i] ,0.1 )
X=X +[ xi ]
print X
VVUW = nodos_espacio . reshape ( len ( nodos_espacio )/2 ,4)
print ' esta mierda es : ', VVUW
P0 =[]
FMMUT = zeros (( len ( VVUW ) ,1 ))
for i in range ( len ( VVUW )) :
if VVUW [i][0 ]== F4 [j][0] and VVUW [i][1 ]== F4 [j][1]
and VVUW [i] [2]== F4 [j] [2] and VVUW [i] [3]== F4 [j][ 3]:
FMMUT [i][0] =- Valores_FD [j]
print FMMUT
F_DD = FMMUT
print F_DD
Form =[]
Form = Form +[ Forma_GG (X[i] , longitudes [i] ,
C3_Materiales [i][ 1] , C3_Materiales [ i][0] , F_DD [i])]
DEFF =[]
DEFF = DEFF +[ Form [i]. N_1 () * SMRWW2 [i][ 0]+ Form [i]. N_2 () * SMRWW2 [i][ 1]+
Form [i]. N_3 () * SMRWW2 [i][ 2]+ Form [i]. N_4 () * SMRWW2 [i][3 ]+
Form [i]. N_5 () * SMRWW2 [i][ 4]+ Form [i]. N_6 () * SMRWW2 [i][5 ]+
Form [i]. R_1 () ]
print DEFF
DEFG =[]
DEFG = DEFG +[( Form [i] . W_1 () * SMRWW2 [i] [0]
+ Form [i]. W_2 () * SMRWW2 [i][ 1]+ Form [i]. W_3 () * SMRWW2 [i][ 2]
+ Form [i]. W_4 () * SMRWW2 [i][ 3]+ Form [i]. W_5 () * SMRWW2 [i][ 4]
+ Form [i]. W_6 () * SMRWW2 [i][ 5]+ Form [i]. R_2 ()) ]
print DEFG
Momenx =[ ]
Momenx = Momenx + [-1*( Form [i ]. M_1 () * SMRWW2 [i ][0]
+ Form [i]. M_2 () * SMRWW2 [i][ 1]+ Form [i]. M_3 () * SMRWW2 [i][ 2]
+ Form [i]. M_4 () * SMRWW2 [i][ 3]+ Form [i]. M_5 () * SMRWW2 [i][ 4]
+ Form [i]. M_6 () * SMRWW2 [i][ 5]+ Form [i]. R_3 ()) ]
print Momenx
Cort =[]
Cort = Cort +[ Form [i]. V_1 () * SMRWW2 [i][ 0]+
Form [i]. V_2 () * SMRWW2 [i][ 1]+ Form [i]. V_3 () * SMRWW2 [i][2 ]+
Form [i]. V_4 () * SMRWW2 [i][ 3]+ Form [i]. V_5 () * SMRWW2 [i][4 ]+
Form [i]. V_6 () * SMRWW2 [i][ 5]+ Form [i]. R_4 () ]
print Cort
print longitudes
# -----------------------------------------------------------------------------#
#
Algoritmo de Presentacion de Resultados .
#
# -------------------------------------------------------------------------------def Diagramasfinales () :
def Diagrama () :
fiig = figure (1)
TDef = fiig . add_subplot ( 221 )
title (r ' $D_ {i}$ ')
grid ( True )
108
2014.
xlabel (r ' $x_ {i }$ ')

ylabel (r '$\ delta$ ')
TDef . plot (X[m. get () ] , DEFF [m. get () ])
TGir = fiig . add_subplot ( 222 )
title (r '$\ theta_ {i}$ ')
xlabel (r ' $x_ {i }$ ')
ylabel (r '$\ theta_ {i }$ ')
grid ( True )
TGir . plot (X[m. get () ] , DEFG [m. get () ])
TMom = fiig . add_subplot ( 223 )
title (r ' $M_ {i}$ ')
xlabel (r ' $x_ {i }$ ')
ylabel (r ' $M_ {i }$ ')
grid ( True )
TMom . plot (X[m. get () ] , Momenx [m. get () ])
TCort = fiig . add_subplot ( 224 )
title (r ' $V_ {i}$ ')
xlabel (r ' $x_ {i }$ ')
ylabel (r ' $V_ {i }$ ')
grid ( True )
TCort . plot ( X[m. get () ] , Cort [ m. get () ])
show ()
ven01 = Toplevel ()
ven01 . title ( ' Diagramas de las Barras ')
textoMM = Label ( ven01 , text = ' Elija la Barra : ',fg = ' blue '). place (x=20 ,y= 20 )
m= IntVar ()
EntradaMM = Entry ( ven01 , textvariable =m , width = 10 ). place (x= 100 ,y = 20 )
BotonMM = Button ( ven01 , text = ' ejecuta ', command = Diagrama ). place (x= 200 ,y = 20 )
ven01 . mainloop ()
def Fuer_Int () :
def VFuerzas01 () :
ventana_alterna01 = Toplevel ()
texto = Label ( ventana_alterna01 , text = fuerzas_bfinal [n. get () ] ). place (x=20 , y= 20 )
ventana_alterna01 . title ( ' Fuerzas Int por Barras . ')
ventana_alterna01 . mainloop ()
ventana_fuerzasint = Toplevel ()
texto_01 = Label ( ventana_fuerzasint , text = ' Elegir Barra : '). place ( x=20 , y= 20 )
n= IntVar ()
entrada01 = Entry ( ventana_fuerzasint , textvariable =n , width =5 ). place ( x= 100 , y= 20 )
Boton01 = Button ( ventana_fuerzasint , text = ' ejecuta ',
command = VFuerzas01 ). place (x= 150 ,y= 20 )
ventana_fuerzasint . mainloop ()
def Deformaciones_FFU () :
ventana_Deformaciones = Toplevel ()
for i in range ( len ( Deformaciones_totales )) :
Label ( ventana_Deformaciones , text = ' Para el Punto : '). place (x=20 ,y=i* 20 + 20 )
Label ( ventana_Deformaciones , text = i+1 ). place (x= 150 ,y=i* 20 + 20 )
Label ( ventana_Deformaciones ,
text = Deformaciones_totales [i] ). place (x= 180 ,y=i * 20 + 20 )
ventana_Deformaciones . mainloop ()
def Matriz_RRIG () :
ventana_matrix = Toplevel ()
ventana_matrix . geometry ( ' 600x600 +0+0 ')
ventana_matrix . title ( ' Matriz de Rigidez ')
textos = Canvas ( ventana_matrix , width = 400 , height = 400 ,
scrollregion =(0 ,0 , 2000 , 2000 ),
highlightcolor = ' black ' , relief = ' solid ', background = ' white ')
for i in range ( len ( KT )) :
for j in range ( len ( KT )) :
textos . create_text ( 100 *i+ 40 , 100 *j+40 , text = KT [i ][j])
textos . create_text ( 100 *i+ 40 ,10 , text =i+1 , fill = ' red ')
textos . create_text ( 10 , 100 *i+40 , text =i+1 , fill = ' red ')
textos01 = Label ( ventana_matrix , text = ' CALCULO DE MATRIZ GENERAL ',fg = ' red ')
textos01 . grid ( row =1 , column = 3)
scrollY = Scrollbar ( ventana_matrix , orient = VERTICAL , command = textos . yview )
scrollY . grid ( row =1 , column =2 , sticky = N+S)
109
2014.
scrollX = Scrollbar ( ventana_matrix , orient = HORIZONTAL , command = textos . xview )

scrollX . grid ( row =2 , column =1 , sticky = E+W)
textos [ ' xscrollcommand ']= scrollX . set
textos [ ' yscrollcommand ']= scrollY . set
textos . grid ( row =1 , column = 1)
ventana_matrix . mainloop ()
def Matriz_DMM () :
ventana_matrixD = Toplevel ()
ventana_matrixD . geometry ( ' 600x600 +0+0 ')
ventana_matrixD . title ( ' Matriz de Rigidez Simplificada ')
textos1 = Canvas ( ventana_matrixD , width = 400 , height = 400 ,
scrollregion =(0 ,0 , 2000 , 2000 ),
highlightcolor = ' black ' , relief = ' solid ', background = ' white ')
for i in range ( len ( K_reducida_final )) :
for j in range ( len ( K_reducida_final )) :
textos1 . create_text ( 100 * i+40 , 100 *j+ 40 , text = K_reducida_final [i] [j])
textos1 . create_text ( 100 * i+40 , 10 , text =i+1 , fill = ' red ')
textos1 . create_text (10 , 100 *i+ 40 , text =i+1 , fill = ' red ')
textos02 = Label ( ventana_matrixD , text = ' CALCULO DE MATRIZ SIMPLIFICADA ', fg = ' red ')
scrollY = Scrollbar ( ventana_matrixD , orient = VERTICAL ,
command = textos1 . yview )
scrollX = Scrollbar ( ventana_matrixD , orient = HORIZONTAL ,
command = textos1 . xview )
textos1 [ ' xscrollcommand ']= scrollX . set
textos1 [ ' yscrollcommand ']= scrollY . set
textos1 . grid ( row =1 , column =1)
ventana_matrixD . mainloop ()
ventana_Resultados = Toplevel ()
ventana_Resultados . geometry ( ' 600x400 +0 +0 ')
ventana_Resultados . title ( ' Resultados de Analisis ')
texto_01 = Label ( ventana_Resultados ,
text = ' Deformaciones Internas : ',fg = ' blue ' ). place (x =20 ,y = 20 )
Boton01 = Button ( ventana_Resultados , text = ' Ejecutar ',fg = ' red ' ,
command = Deformaciones_FFU ). place (x= 180 ,y = 20 )
text = ' Matriz de rigidez ' ,fg = ' blue '). place (x= 20 ,y= 50 )
Boton02 = Button ( ventana_Resultados ,
text = ' Ejecutar ' ,fg = ' red ',
command = Matriz_RRIG ). place (x= 180 ,y= 50 )
texto03 = Label ( ventana_Resultados ,
text = ' Matriz de Rigidez Simplificada ',fg = ' blue '). place (x=20 , y= 80 )
Boton03 = Button ( ventana_Resultados , text = ' Ejecutar ',
command = Matriz_DMM , fg = ' red '). place ( x= 180 ,y= 80 )
text = ' Fuerzas Internas ',fg = ' blue '). place (x=20 ,y= 110 )
command = Fuer_Int , fg = ' red '). place (x= 180 ,y = 110 )
text = ' Diagramas ',fg = ' blue ' ). place (x =20 ,y= 140 )
Boton05 = Button ( ventana_Resultados , text = ' ejecuta ',
command = Diagramasfinales , fg = ' red '). place (x= 180 ,y= 140 )
ventana_Resultados . mainloop ()
En las grcas se dividen en 4,una es la graca de la deformada,la otra de graca de giro o desplazamiento de giro,la otra el Momento, y la ultima la cortante.
110
2014.
Figura 7.15: Graca de Resultados del Analisis del Femax de
Con esta subrutina se termina el programa femax.
111
ui ,i ,Mi ,Vi .
Parte VI
CONCLUSIONES Y
RECOMENDACIONES.
112
Captulo 8
Conclusiones y Recomendaciones.
8.1.
Conclusiones.
Los problemas probados en SAP2000 V14 fueron satisfactorias ya que los resultados son muy similares
a obtenidos al Femax en la cual nos dan la conclusin de haber hecho un trabajo coherente,claro que
el programa es simplemente por el momento de uso didactico en futuro no muy lejano si es que los
estudiantes tesistas desean investigar mas esta tesis quedar como guia para estudios ms profundos del
tema de elementos nitos.
Como se pudo notar,para poder modelar una estructura se requieren los conceptos bsicos del mtodo a
usar,as como los procedimientos de este.Por lo que,si alguna persona deseara analizar una estructura con
la ayuda de un programa comercial como el sap u otros,an considerndose este como el mejor,no podria
interpretar con claridad el trabajo realizado por este programa,ni siquiera cuando el individuo hubiese
tomado un curso para el manejo del mismo.Como opinion personal,me atrevo a escribir estas lineas por
experiencia propia ,con esto no signica que soy capaz de modelar cualquier tipo de estructura ,pero con
estas bases el camino se hace ms corto para lograrlo.
Se concluye que las funcion de acoplamiento
i ,es
una forma ecaz de poder hacer el acoplamiento de las
matrices de rigidez global ya que conjuga tanto la direccin y el grado de libertad.

El uso masivo de lenguaje de programacin por parte de los estudiantes ya no es una curiosidad si no a
mi concepto es una nesecidad ya que da alternativas libres de poder solucionar problemas de ingenieria.
Es fundamental el conocimiento del Mtodo de Elementos nitos para los estudiantes que tengan interes
en el clculo y anlisis estructural.
8.2.
Recomendaciones.
Se recomienda que se dicte el curso de elementos Finitos o que en la curricula de Anlisis Estructural se
la incluya ya que es un elemento importante para entender como funcionan los programas comerciales
de Estructuras y le dar ms facilidad de entendimiento al alumno.
Se da pie a que las investigaciones con elementos nitos sigan adelante ya que es una gran herramienta
para poder calcular problemas complejos en la ingenieria.
Para el clculo de porticos y vigas se uso los sistemas de acoplamiento de matriz
i ,este
metodo
puede ser usado para todo tipo de estructura ya que es un algoritmo universal ya que se establece la
opcin de direccin y grado de libertad.
El uso de las funciones de forma son fundamentales en el anlisis estructurales del mtodo de elementos nitos y se recomienda el estudio minucioso de ello ya que es tambien un sistema universal
para el clculo de las gracas y clculo de
ui , i , Mi , Vi
en cualquier punto estructural.
Se recomienda el uso msivo del lenguaje de programacin como python para alumnos Universitarios
por que nos dan gran alternativos de desarrollos para el clculo de Ingenieria .
113
Parte VII
CODIGO FUENTE DEL PROGRAMA

FEMAX.
114
2014.
# PROGRAMACION FEMAX
from matplotlib import *
from pylab import *
import matplotlib . pylab as plt
from Tkinter import *
from Matrix2D import *
import tkMessageBox
import time
from apoyos import *
from Fuerza2D import *
from Formax import *
# ----------------------------------------------------------------------------------C=[ ]
C3_Materiales =[]
longitudes = []
K_todos =[]
u=[ ]
u2 =[]
nodos_espacio = None
T=[ ]
K_Rtodos =[ ]
ordenamiento = None
puntos =[ ]
tipo_apoyos = None
codigo_apoyos = None
tipo_apoyos1 = None
codigo_apoyos1 = None
Ubicaciones_Universales = None
Puntos_FuerzasP = None
Puntos_AFuerzasP = None
Puntos_FuerzasP1 = None
Puntos_AFuerzasP1 = None
inicio_FuerzasD = None
linea_FuerzasD =[]
F4 =[]
Valores_FD = []
longitudesFD =[ ]
# -----------------------------------------------------------------------------def Fuerzas_puntuales () :
global Puntos_AFuerzasP
global Puntos_FuerzasP
global Puntos_FuerzasP1
global Puntos_AFuerzasP1
Puntos_FuerzasP = []
Puntos_AFuerzasP =[ ]
def dibujar_Fuerzas ( evento ) :
global Puntos_FuerzasP
global Puntos_AFuerzasP
if selec01 . get () = =1:
val = selecP01 . get ()
fuerzas ( evento , dibujo , val ). Fuerza_VP ()
Puntos_FuerzasP = Puntos_FuerzasP +[0 , val ,0]
Puntos_AFuerzasP = Puntos_AFuerzasP +[ ( evento .x- 50 )/50 ,( 550 - evento .y)/ 50 ]
fuerzas ( evento , dibujo , val ). Fuerza_VN ()
Puntos_FuerzasP = Puntos_FuerzasP +[0 ,- val ,0]
fuerzas ( evento , dibujo , val ). Fuerza_HP ()
Puntos_FuerzasP = Puntos_FuerzasP +[ val ,0 ,0]
fuerzas ( evento , dibujo , val ). Fuerza_HN ()
Puntos_FuerzasP = Puntos_FuerzasP +[ - val ,0 ,0]
115
2014.

u= array ( Puntos_FuerzasP )
s= len (u)
u2 = array ( Puntos_AFuerzasP )
s1 = len ( u2 )
Puntos_FuerzasP1 =u . reshape (s/3 ,3)
Puntos_AFuerzasP1 = u2 . reshape ( s1 /2 ,2)
print Puntos_FuerzasP1
print Puntos_AFuerzasP1
ventana_FuerzasP = Toplevel ()
ventana_FuerzasP . title ( ' Fuerzas Puntuales ')
ventana_FuerzasP . geometry ( ' 500x300 + 0+0 ')
ventana_FuerzasP . minsize ( 500 , 300 )
# --------------------------------------------------IM_FVP = PhotoImage ( file = ' FPV . gif ')
IM_FVN = PhotoImage ( file = ' FNV . gif ')
IM_FHP = PhotoImage ( file = ' FHP . gif ')
IM_FHN = PhotoImage ( file = ' FHN . gif ')
# --------------------------------------------------selec01 = IntVar ()
selecP01 = DoubleVar ()
# -----------------------------------------------------------------------------------entrada01 = Entry ( ventana_FuerzasP , textvariable = selecP01 , width = 10 ). place ( x= 300 , y= 20 )
entrada02 = Entry ( ventana_FuerzasP , textvariable = selecP02 , width = 10 ). place ( x= 300 , y= 60 )
# --------------------------------------------------------------------------------------Texto_01 = Label ( ventana_FuerzasP , text = ' Fuerzas Verticales Positivos . '). place (x= 100 ,y= 20 )
FVP = Radiobutton ( ventana_FuerzasP , image = IM_FVP , value =1 , variable = selec01 )
texto02 = Label ( ventana_FuerzasP , text = ' Fuerzas Verticales Negativos '). place (x= 100 ,y= 60 )
FVP . place (x= 20 ,y= 20 )
FVN = Radiobutton ( ventana_FuerzasP , image = IM_FVN , value =2 , variable = selec01 )
FVN . place (x= 20 ,y= 60 )
texto03 = Label ( ventana_FuerzasP , text = ' Fuerzas Horizontales Positivas '). place ( x= 100 , y= 100 )
FHP = Radiobutton ( ventana_FuerzasP , image = IM_FHP , value =3 , variable = selec01 )
FHP . place (x= 20 ,y= 100 )
texto04 = Label ( ventana_FuerzasP , text = ' Fuerzas Horizontales Negativas '). place ( x= 100 , y= 140 )
FHN = Radiobutton ( ventana_FuerzasP , image = IM_FHN , value =4 , variable = selec01 )
FHN . place (x= 20 ,y= 140 )
dibujo . bind ( '< Button -1 > ', dibujar_Fuerzas )
ventana_FuerzasP . mainloop ()
def Fuerzas_distribuidas () :
global longitudesFD
global Valores_FD
global F4
global inicio_FuerzasD
global linea_FuerzasD
inicio_FuerzasD = []
def inicio ( evento ):
global longitudesFD
global Valores_FD
global F4
inicio_FuerzasD = [ evento .x , evento . y]
def final ( evento ) :
global longitudesFD
global Valores_FD
global F4
116
2014.
longitud = sqrt (( evento .x- inicio_FuerzasD [0]) **2+( evento .y- inicio_FuerzasD [1]) **2)
COS =( evento . x- inicio_FuerzasD [0])/ float ( longitud )
SEN =-( evento .y- inicio_FuerzasD [1]) / float ( longitud )
for i in range ( 20 ):
dibujo . create_line ( inicio_FuerzasD [ 0]+ longitud /
20 *i* COS - 50 * SEN , inicio_FuerzasD [1] - longitud / 20 *i* SEN - 50 * COS , inicio_FuerzasD [0
+ longitud / 20 * COS *i , inicio_FuerzasD [1 ]- longitud / 20 * SEN *i , fill = ' green ', arrow = LAST )
dibujo . create_text ( inicio_FuerzasD [ 0]- 50 * SEN , inicio_FuerzasD [1 ]- 25 * COS ,
text = Magnitud . get ())
linea_FuerzasD = linea_FuerzasD +[ ( inicio_FuerzasD [0]- 50 )/50 ,
( 550 - inicio_FuerzasD [1])/ 50 ,( evento . x- 50 ) /50 ,( 550 - evento .y )/ 50 ]
longitudesFD = longitudesFD +
[ norm ( array ([( evento .x- 50 )/50 ,( 550 - evento .y)/ 50 ])array ([( inicio_FuerzasD [0]- 50 )/50 ,( 550 - inicio_FuerzasD [1])/ 50 ] )) ]
F2 = array ( linea_FuerzasD )
F3 = F2 . reshape ( len ( F2 )/4 ,4)
F4 = F3
Valores_FD = Valores_FD + [ Magnitud . get () ]
print F4
print Valores_FD
print longitudesFD
inicio_FuerzasD = None
ventana_distribuida = Toplevel ()
ventana_distribuida . title ( ' Fuerzas Distribuidas ')
ventana_distribuida . geometry ( ' 400x200 +0+ 0 ')
Im_Fdistribuida = PhotoImage ( file = ' FFD . gif ')
selec1 = IntVar ()
texto01 = Label ( ventana_distribuida ,
text = ' Fuerzas Dist Magn : '). place (x= 100 ,y= 20 )
FPP = Radiobutton ( ventana_distribuida ,
image = Im_Fdistribuida , value =1 , variable = selec1 )
FPP . place (x= 20 ,y= 20 )
Magnitud = DoubleVar ()
entrada_general = Entry ( ventana_distribuida ,
textvariable = Magnitud , width = 10 ). place (x= 300 ,y= 20 )
dibujo . bind ( '< Button -1 > ', inicio )
dibujo . bind ( '< Button -3 > ', final )
ventana_distribuida . mainloop ()
def apoyos_universales () :
global tipo_apoyos
global tipo_apoyos1
tipo_apoyos =[]
codigo_apoyos =[]
def apoyos_general ( evento ):
global tipo_apoyos
global tipo_apoyos1
if selec . get () ==1 :
Apoyos ( evento , dibujo ). Aempotrados ()
Apoyos ( evento , dibujo ). Afijos ()
Apoyos ( evento , dibujo ). Amoviles ()
AP = array ( tipo_apoyos )
AM = array ( codigo_apoyos )
codigo_apoyos1 = AM . reshape ( len ( AM )/3 , 3)
tipo_apoyos1 = AP . reshape ( len ( AP )/2 ,2)
117
2014.
print tipo_apoyos1
print codigo_apoyos1
ventana_apoyos = Toplevel ()
# ------------------------------------------------------------------Im_Fijos = PhotoImage ( file = ' fijo . gif ')
Im_Empotrados = PhotoImage ( file = ' empotrado . gif ')
Im_Moviles = PhotoImage ( file = ' movil . gif ')
# --------------------------------------------------------------------ventana_apoyos . title ( 'Tipo - Apoyos ')
selec = IntVar ()
Texto_Empotrados = Label ( ventana_apoyos , text = ' Apoyo Empotrado '). place (x= 100 ,y= 20 )
Texto_Fjos = Label ( ventana_apoyos , text = ' Apoyo Fijo '). place (x= 100 ,y = 60 )
Texto_Moviles = Label ( ventana_apoyos , text = ' Apoyo Moviles '). place (x= 100 ,y = 100 )
Empotrados = Radiobutton ( ventana_apoyos , image = Im_Empotrados , value =1 , variable = selec )
Empotrados . place (x=20 , y= 20 )
Fijos = Radiobutton ( ventana_apoyos , image = Im_Fijos , value =2 , variable = selec )
Fijos . place (x=20 ,y= 60 )
Moviles = Radiobutton ( ventana_apoyos , image = Im_Moviles , value =3 , variable = selec )
Moviles . place (x=20 ,y= 100 )
# ----------------------------------------------------------------------#
BOTON PARA INCLUIR APOYOS EN LOS PUNTOS
# ----------------------------------------------------------------------botton_01 = Button ( ventana_apoyos , text = ' Ejecutar ',fg = ' blue ' ). place (x = 200 , y= 200 )
dibujo . bind ( '< Button -1 > ', apoyos_general )
ventana_apoyos . geometry ( ' 400x300 +0+0 ')
ventana_apoyos . minsize ( 400 , 300 )
ventana_apoyos . mainloop ()
def Materiales_Calculo () :
global u2
global numero
nodos_espacio = u2
ventana_Materiales = Toplevel ()
ventana_Materiales . title ( ' Materiales de Elementos ')
lista_1 =[ ' Inercia '+ str (i ) for i in range ( len ( u2 )/2)]
lista_2 =[ ' Elasticidad '+ str (i) for i in range ( len ( u2 )/ 2)]
lista_3 =[ ' Area '+ str (i) for i in range ( len ( u2 )/2 )]
ventana_Materiales . geometry ( ' 800x300 +0+ 0 ')
numero = len ( u2 ) /2
for i in range ( len ( u2 )/2):
lista_1 [i]= DoubleVar ()
for i in range ( len ( u2 )/2):
u1 = Label ( ventana_Materiales , text = ' Inercia '+ str (i),
fg = ' red '). place (x=0 ,y= 20 +i* 20 )
u2 = Label ( ventana_Materiales , text = ' Elasticidad '+ str ( i),
fg = ' red '). place (x= 200 ,y = 20 +i* 20 )
u3 = Label ( ventana_Materiales , text = ' Area '+ str (i ),
fg = ' red '). place (x= 400 ,y = 20 +i* 20 )
for j in range ( numero ):
Entrada_Inercia = Entry ( ventana_Materiales ,
Entrada_Elasticidad = Entry ( ventana_Materiales ,
Entrada_Area = Entry ( ventana_Materiales ,
# ---------------------------------------------------------------------C_Materiales = None
def guardar_datos () :
global C_Materiales
C_Materiales =[ ]
for t in range ( numero ):
C_Materiales = C_Materiales +
[ lista_1 [ t]. get () ]+[ lista_2 [t] . get () ]+[ lista_3 [ t]. get () ]
118
2014.
C2_Materiales = array ( C_Materiales )

C3_Materiales = C2_Materiales . reshape ( numero ,3 )
print C3_Materiales
# ------------------------------------------------------------------------------------------------# BOTON DE GUARDAR CARACTERISTICAS DE LOS ELEMENTOS

# ------------------------------------------------------------------------------------------------Boton01 = Button ( ventana_Materiales , text = ' GUARDAR ', command = guardar_datos ). place ( x= 600 ,y= 250 )
# ------------------------------------------------------------------------------------------------# ----------------------------------------------------------------------------------------------------#
#
FUNCIONES DE CALCULO DE LA MATRIZ DE RIGIDEZ - CALCULO
#
POR EL METODO DE ELEMENTOS FINITOS
#
# ----------------------------------------------------------------------------------------------------def nodos_calculo () :
global Valores_FD
global F4
global tipo_apoyos1
global ordenamiento
global C
global K_todos
global T
global K_Rtodos
global longitudesFD
numero_datos = len ( nodos_espacio )
numero_barras = numero_datos /2
C=[ ]
U=[ ]
lista_resumen = nodos_espacio . tolist ()
for i in lista_resumen :
if i not in C:
C=C +[i]
print C
for s in range ( numero_barras ):
K_local = Matrix2D ( C3_Materiales [s][2 ] , C3_Materiales [ s][1] , C3_Materiales [s] [0] , longitudes [s ] ). c
K_todos = K_todos +[ K_local ]
Coord_Barras = nodos_espacio . reshape ( numero_barras ,4)
for u in range ( numero_barras ):
transformada_union = Transformada ( Coord_Barras [u][0] , Coord_Barras [u] [1] , Coord_Barras [ u][2] , Coord
T=T +[ transformada_union ]
for r in range ( numero_barras ):
K_ultimo_1 = dot ( K_todos [r] ,T [r])
K_ultimo_2 = dot ( transpose (T[ r]), K_ultimo_1 )
K_Rtodos = K_Rtodos +[ K_ultimo_2 ]
ordenamiento ={ }# Biblioteca de calculo
ordenamiento_primario =[]# ordenamiento final de las barras
# ------------------------------------------------------------------------------------------------#
MATRIZ DE ORDENAMIENTO -- ---> PI
# ------------------------------------------------------------------------------------------------for i in range ( len (C )) :
ordenamiento [i ]=C[i ]
print ordenamiento
for i in range ( numero_datos ):
for j in range ( len (C )) :
if ordenamiento [j ][0]= = nodos_espacio [i] [0] and ordenamiento [j][1 ]== nodos_espacio [ i][1] :
ordenamiento_primario . append (j)
print ordenamiento_primario
ordenamiento2 = array ( ordenamiento_primario )
numero_filas = len ( ordenamiento2 )/2
ultimo_ordenamiento = ordenamiento2 . reshape ( numero_filas ,2)
P_01S = ultimo_ordenamiento +1
P_02S = P_01S *3
119
2014.
WQ = array ([ range ( P_02S [i ][0]-3 , P_02S [i][0 ]) for i in range ( len ( P_02S )) ])
WR = array ([ range ( P_02S [i ][1]-3 , P_02S [i][1 ]) for i in range ( len ( P_02S )) ])
O=[ ]
for j in range ( len ( WR )) :
if i== j:
O=O +[ array ([ WQ [i] ,WR [j]] ). reshape (6) ]
P_03S = array (O)

matriz_ordenamiento = transpose ( P_03S )
print matriz_ordenamiento
# ------------------------------------------------------------------------------------------------#
#
ACOPLAMIENTO FINAL DE LA MATRIZ DE RIGIDEZ TOTAL DE LA
#
ESTRUCTURA
#
k[ PI [i ][ n] , PI [j ][ n ]] < - - - - - - - - - - - - - - - - - - K {n}[i ][ n]
# --------------------------------------------------------------------------------------------------KT = zeros (( 3* len (C) ,3* len (C )))
for i in range ( 6):
for n in range ( len ( K_Rtodos )) :
KT [ matriz_ordenamiento [ i][n]] [ matriz_ordenamiento [j ][n]] = KT [ matriz_ordenamiento [i][ n]]
print KT
# ----------------------------------------------------------------------------------------------------#
#
CALCULO DE MATRIZ REDUCIDA --> Ki
#
# ----------------------------------------------------------------------------------------------------GDL01 =[]
for i in range ( len (C )) :
for j in range ( len ( tipo_apoyos1 )) :
if ordenamiento [i ][0]= = tipo_apoyos1 [j][ 0] and ordenamiento [ i][1] == tipo_apoyos1 [j ][1]:
GDL01 . append (i)
GDL02 = array ( GDL01 )
GDL03 = GDL02 +1
GDL04 = GDL03 *3
MQ = array ([ range ( GDL04 [i ]-3 , GDL04 [i ]) for i in range ( len ( GDL04 )) ])
EL = MQ * codigo_apoyos1
K_reducida_inicial = delete (KT ,EL , axis =0)
K_reducida_final = delete ( K_reducida_inicial ,EL , axis = 1)# calculo de K_reducida
print K_reducida_final
# ----------------------------------------------------------------------------------------#
#
Programacion de Calculo de Fuerzas Puntuales
#
# ----------------------------------------------------------------------------------------esquema_fuerzasp =[ ]
for j in range ( len ( Puntos_AFuerzasP1 )) :
if ordenamiento [i ][0]= = Puntos_AFuerzasP1 [j][ 0] and ordenamiento [ i][1]= = Puntos_AFuerzasP1 [j
esquema_fuerzasp . append ( i)
print esquema_fuerzasp
esquema_fuerzasp1 = array ( esquema_fuerzasp )
esquema_fuerzasp2 =( esquema_fuerzasp1 + 1)*3
WR = array ([ range ( esquema_fuerzasp2 [ i]-3 , esquema_fuerzasp2 [i]) for i in range ( len ( esquema_fuerzasp2 )
WQ = WR . reshape ( len ( WR )*3 ,1)
Fuerzas_puntuales = zeros (( len ( ordenamiento ) *3 ,1 ))
Puntos_FuerzasP2 = Puntos_FuerzasP1 . reshape ( len ( Puntos_FuerzasP1 )*3 ,1 )
for i in range ( len ( Puntos_FuerzasP1 ) *3):
Fuerzas_puntuales [ WQ [ i]]= Fuerzas_puntuales [ WQ [i] ]+ Puntos_FuerzasP2 [i]
print Fuerzas_puntuales
# ------------------------------------------------------------------------------------#
#
Programacion de calculo de Fuerzas Distribuidas
#
# ------------------------------------------------------------------------------------F5 = F4 . reshape ( len ( F4 )*2 ,2)
esquema_FuerzasD =[ ]
120
2014.

if ordenamiento [i ][0]= = F5 [j] [0] and ordenamiento [i][1 ]== F5 [ j][1] :
esquema_FuerzasD . append ( i)
esquema_FuerzasD1 = array ( esquema_FuerzasD )
esquema_FuerzasD2 =( esquema_FuerzasD1 + 1)*3
WU = array ([ range ( esquema_FuerzasD2 [ i]-3 , esquema_FuerzasD2 [i]) for i in range ( len ( esquema_FuerzasD2 )
WP = WU . reshape ( len ( WU )*3 ,1)
print ' este es la clave '+ str ( WP )
Fuerzas_Distribuidas = zeros (( len ( ordenamiento )*3 ,1 ))

Fuerzas_DD = []
for i in range ( len ( longitudesFD )) :
Fuerzas_DD = Fuerzas_DD + [[0 , Valores_FD [i ]*( longitudesFD [ i])/ float (2 ), Valores_FD [i]*( longitudesFD
FuerzasDD1 = array ( Fuerzas_DD )
FuerzasDD2 = FuerzasDD1 . reshape ( len ( FuerzasDD1 )*3 ,1 )
for i in range ( len ( FuerzasDD2 )) :
Fuerzas_Distribuidas [ WP [i ]]= Fuerzas_Distribuidas [ WP [i ]]+ FuerzasDD2 [i]
# ----------------------------------------------------------------------------------#
#
Programacion de Fuerzas Nodales Equivalentes
#
# ------------------------------------------------------------------------------------Fuerzas_nequivalentes = Fuerzas_puntuales - Fuerzas_Distribuidas
Fuerzas_NodD = delete ( Fuerzas_nequivalentes ,EL , axis =0)
print Fuerzas_NodD
# -------------------------------------------------------------------------------------#
#
Calculo de las deformaciones Nodales
#
# --------------------------------------------------------------------------------------Deformaciones01 = dot ( inv ( K_reducida_final ), Fuerzas_NodD )
print Deformaciones01
WUP = range (0 , len ( Fuerzas_nequivalentes ))
WUP1 = array ( WUP )
WUP2 = WUP1 . reshape ( len ( WUP ),1)
WUP3 = delete ( WUP2 ,EL , axis =0)
Deformaciones_totales = zeros (( len ( ordenamiento )*3 ,1 ))
for i in range ( len ( WUP3 )) :
Deformaciones_totales [ WUP3 [ i]]= Deformaciones_totales [ WUP3 [i ]]+ Deformaciones01 [i]
print Deformaciones_totales
# --------------------------------------------------------------------------------------#
#
Calculo de Fuerzas Internasx - Barras
#
# --------------------------------------------------------------------------------------for i in range ( len ( us01 )) :
sx = us01 [i]. reshape (1 ,6)
ordenamiento_fuerzasU = ordenamiento_fuerzasU +[ sx ]
ordenamiento_ff = array ( ordenamiento_fuerzasU ). reshape ( len ( ordenamiento_fuerzasU ),6)
SMR = array ([[ 0. 000000 ,0. 000000 ,0. 000000 , 0. 000000 ,0. 000000 ,0. 000000 ]
SMR [i][ j]= SMR [i][ j]+
Deformaciones_totales [ ordenamiento_ff [ i][j] ]
print SMR
resultados_fuerzapb =[]
for i in range ( len ( SMR )) :
resultados_fuerzapb = resultados_fuerzapb +
[ dot ( K_Rtodos [ i] , SMR [i]. reshape (6 ,1 )) ]
print resultados_fuerzapb
restar_altotal = Fuerzas_nequivalentes - Fuerzas_puntuales
SMR1 = array ([[ 0. 000000 ,0. 000000 ,0. 000000 ,0 . 000000 ,0. 000000 ,0. 000000 ]
WNN = WP . reshape ( len ( WP )/ 6.00 , 6. 00 )
for j in range ( len ( WNN )) :
if ordenamiento_ff [i][ 0]== WNN [j][ 0] and
121
2014.

ordenamiento_ff [ i][4]= = WNN [ j][4] and ordenamiento_ff [ i][5] == WNN [ j][5] :
else :
SMR1 [i][ 0]=0. 000000000
SMR1 [i][ 1]=0. 000000000
SMR1 [i][ 2]=0. 000000000
SMR1 [i][ 3]=0. 000000000
SMR1 [i][ 4]=0. 000000000
SMR1 [i][ 5]=0. 000000000
SMR2 = array ([[ 0. 000000 ,0. 000000 ,0. 000000 ,0 . 000000 ,0. 000000 ,0. 000000 ]
SMR2 [i][ j]= SMR2 [i][ j]+ restar_altotal [ SMR1 [i][j ]]
fuerzas_bfinal =[]
fuerzas_bfinal = fuerzas_bfinal +[ resultados_fuerzapb [i] - SMR2 [i]. reshape (6 ,1) ]
print fuerzas_bfinal
# ------------------------------------------------------------------------------------------#
#
Algoritmo de Graficas de u , a_ {i} ,M_ {i} ,V_ {i}
#
# ------------------------------------------------------------------------------------------X=[ ]
xi = arange (0 , longitudes [ i] ,0.1 )
X=X +[ xi ]
print X
VVUW = nodos_espacio . reshape ( len ( nodos_espacio )/2 ,4)
P0 =[]
for i in range ( len ( VVUW )) :
if VVUW [i][0 ]== F4 [j][0 ] and VVUW [i][1 ]== F4 [j][1]
and VVUW [i] [2]== F4 [j][ 2] and VVUW [i] [3]== F4 [j][ 3]:
P0 . append (- Valores_FD [j ])
else :
P0 . append (0)
F_DD = array ( P0 ). reshape ( len ( P0 ) ,1)
Form =[]
Form = Form +[ Forma_GG (X[i] , longitudes [i] ,
C3_Materiales [i][ 1] , C3_Materiales [i][0] , F_DD [i])]
DEFF =[]
DEFF = DEFF +[ Form [i]. N_1 () * SMR [i ][0]+
Form [i]. N_2 () * SMR [i ][1]+ Form [i ]. N_3 () * SMR [i][2 ]
+ Form [i]. N_4 () * SMR [i ][3]+ Form [ i]. N_5 () * SMR [i][4 ]+
Form [i]. N_6 () * SMR [i ][5]+ Form [i ]. R_1 () ]
print DEFF
DEFG =[]
DEFG = DEFG +[( Form [i] . W_1 () * SMR [ i][0] +
Form [i]. W_2 () * SMR [i ][1]+ Form [i ]. W_3 () * SMR [i][2 ]+
Form [i]. W_4 () * SMR [i ][3]+ Form [i ]. W_5 () * SMR [i][4 ]
+ Form [i]. W_6 () * SMR [i ][5]+ Form [ i]. R_2 ()) ]
print DEFG
Momenx =[ ]
122
2014.
Momenx = Momenx + [-1*( Form [i ]. M_1 () * SMR [i][0 ]+

Form [i]. M_2 () * SMR [i ][1]+ Form [i ]. M_3 () * SMR [i][2 ]+
Form [i]. M_4 () * SMR [i ][3]+ Form [i ]. M_5 () * SMR [i][4 ]+
Form [i]. M_6 () * SMR [i ][5]+ Form [i ]. R_3 ()) ]
print Momenx
Cort =[]
Cort = Cort +[ Form [i]. V_1 () * SMR [i ][0]+
Form [i]. V_2 () * SMR [i ][1]+ Form [i ]. V_3 () * SMR [i][2 ]+
Form [i]. V_4 () * SMR [i ][3]+ Form [i ]. V_5 () * SMR [i][4 ]+
Form [i]. V_6 () * SMR [i ][5]+ Form [i ]. R_4 () ]
print Cort
print longitudes
# -------------------------------------------------------------------------------------#
#
Algoritmo de Presentacion de Resultados .
#
# --------------------------------------------------------------------------------------def Diagramasfinales () :
def Diagrama () :
fiig = figure (1 )
TDef = fiig . add_subplot ( 221 )
title (r ' $D_ {i}$ ')
grid ( True )
xlabel (r ' $x_ {i }$ ')
ylabel (r '$\ delta$ ')
TDef . plot (X[m . get () ] , DEFF [m. get () ] ,'r -- ')
TGir = fiig . add_subplot ( 222 )
title (r '$\ theta_ {i}$ ')
xlabel (r ' $x_ {i }$ ')
ylabel (r '$\ theta_ {i }$ ')
grid ( True )
TGir . plot (X[m . get () ] , DEFG [m. get () ] ,'r -- ')
TMom = fiig . add_subplot ( 223 )
title (r ' $M_ {i}$ ')
xlabel (r ' $x_ {i }$ ')
ylabel (r ' $M_ {i }$ ')
grid ( True )
TMom . plot (X[m . get () ] , Momenx [m. get () ] , 'r -- ')
TCort = fiig . add_subplot ( 224 )
title (r ' $V_ {i}$ ')
xlabel (r ' $x_ {i }$ ')
ylabel (r ' $V_ {i }$ ')
grid ( True )
TCort . plot ( X[m. get () ] , Cort [ m. get () ] ,'r -- ')
show ()
ven01 = Toplevel ()
ven01 . title ( ' Diagramas de las Barras ')
textoMM = Label ( ven01 , text = ' Elija la Barra : ', fg = ' blue '). place (x=20 ,y= 20 )
m= IntVar ()
EntradaMM = Entry ( ven01 , textvariable =m , width = 10 ). place (x= 100 ,y= 20 )
BotonMM = Button ( ven01 , text = ' ejecuta ', command = Diagrama ). place (x= 200 ,y = 20 )
ven01 . mainloop ()
def Fuer_Int () :
def VFuerzas01 () :
ventana_alterna01 = Toplevel ()
texto = Label ( ventana_alterna01 , text = fuerzas_bfinal [n. get () ] ). place (x=20 ,y= 20 )
ventana_alterna01 . title ( ' Fuerzas Int por Barras . ')
ventana_alterna01 . mainloop ()
ventana_fuerzasint = Toplevel ()
texto_01 = Label ( ventana_fuerzasint , text = ' Elegir Barra : '). place ( x=20 , y= 20 )
n= IntVar ()
entrada01 = Entry ( ventana_fuerzasint , textvariable =n , width =5 ). place (x = 100 , y= 20 )
Boton01 = Button ( ventana_fuerzasint ,
text = ' ejecuta ', command = VFuerzas01 ). place ( x= 150 ,y= 20 )
ventana_fuerzasint . mainloop ()
def Deformaciones_FFU () :
ventana_Deformaciones = Toplevel ()
123
2014.
for i in range ( len ( Deformaciones_totales )) :

Label ( ventana_Deformaciones , text = ' Para el Punto : '). place (x=20 ,y=i* 20 + 20 )
Label ( ventana_Deformaciones , text =i+1 ). place (x= 150 ,y=i* 20 + 20 )
Label ( ventana_Deformaciones ,
text = Deformaciones_totales [i] ). place (x= 180 ,y=i * 20 + 20 )
ventana_Deformaciones . mainloop ()
def Matriz_RRIG () :
ventana_matrix = Toplevel ()
ventana_matrix . geometry ( ' 600x600 +0+0 ')
ventana_matrix . title ( ' Matriz de Rigidez ')
textos = Canvas ( ventana_matrix , width = 400 ,
height = 400 , scrollregion =(0 ,0 , 2000 , 2000 ),
highlightcolor = ' black ', relief = ' solid ', background = ' white ')
for j in range ( len ( KT )) :
textos . create_text ( 100 *i +40 , 100 *j+40 , text = KT [i ][j])
textos . create_text ( 100 *i +40 ,10 , text =i+1 , fill = ' red ')
textos . create_text ( 10 , 100 *i+40 , text =i+1 , fill = ' red ')
textos01 = Label ( ventana_matrix , text = ' CALCULO DE MATRIZ GENERAL ', fg = ' red ')
scrollY = Scrollbar ( ventana_matrix , orient = VERTICAL , command = textos . yview )
scrollX = Scrollbar ( ventana_matrix , orient = HORIZONTAL , command = textos . xview )
textos [ ' xscrollcommand '] = scrollX . set
textos [ ' yscrollcommand '] = scrollY . set
textos . grid ( row =1 , column = 1)
ventana_matrix . mainloop ()
def Matriz_DMM () :
ventana_matrixD = Toplevel ()
ventana_matrixD . geometry ( ' 600x600 +0+0 ')
ventana_matrixD . title ( ' Matriz de Rigidez Simplificada ')
textos1 = Canvas ( ventana_matrixD , width = 400 , height = 400 ,
scrollregion =(0 ,0 , 2000 , 2000 ),
for j in range ( len ( K_reducida_final )) :
textos1 . create_text ( 100 * i+40 , 100 *j+ 40 , text = K_reducida_final [i] [j])
textos1 . create_text ( 100 * i+40 , 10 , text =i+1 , fill = ' red ')
textos1 . create_text (10 , 100 *i+ 40 , text =i+1 , fill = ' red ')
textos02 = Label ( ventana_matrixD , text = ' CALCULO DE MATRIZ SIMPLIFICADA ', fg = ' red ')
scrollY = Scrollbar ( ventana_matrixD , orient = VERTICAL , command = textos1 . yview )
scrollX = Scrollbar ( ventana_matrixD , orient = HORIZONTAL , command = textos1 . xview )
textos1 [ ' xscrollcommand ']= scrollX . set
textos1 [ ' yscrollcommand ']= scrollY . set
textos1 . grid ( row =1 , column =1)
ventana_matrixD . mainloop ()
ventana_Resultados = Toplevel ()
ventana_Resultados . geometry ( ' 600x400 +0+ 0 ')
ventana_Resultados . title ( ' Resultados de Analisis ')
texto_01 = Label ( ventana_Resultados , text = ' Deformaciones Internas : ',fg = ' blue ' ). place (x =20 ,y= 20 )
fg = ' red ', command = Deformaciones_FFU ). place (x= 180 ,y= 20 )
text = ' Matriz de rigidez ' ,fg = ' blue '). place (x= 20 ,y= 50 )
Boton02 = Button ( ventana_Resultados , text = ' Ejecutar '
,fg = ' red ' , command = Matriz_RRIG ). place (x= 180 ,y= 50 )
texto03 = Label ( ventana_Resultados , text = ' Matriz de Rigidez Simplificada ',fg = ' blue '). place (x=20 ,y= 80 )
command = Matriz_DMM , fg = ' red '). place ( x= 180 ,y= 80 )
124
2014.

text = ' Fuerzas Internas ',fg = ' blue '). place (x=20 ,y= 110 )
Boton04 = Button ( ventana_Resultados ,
text = ' Ejecutar ' ,
command = Fuer_Int , fg = ' red ' ). place (x= 180 ,y = 110 )
text = ' Diagramas ',fg = ' blue ' ). place (x =20 ,y= 140 )
Boton05 = Button ( ventana_Resultados , text = ' ejecuta ',
command = Diagramasfinales , fg = ' red '). place (x= 180 ,y= 140 )
ventana_Resultados . mainloop ()
def grilla () :
Ubicaciones_Universales =[]
def dibujo_grilla () :
if nx . get () ! =0 and ny . get () !=0:
for i in range ( nx . get () +1) :
dibujo . create_line ( 50 +i* mx . get () *50 , 550 , 50 +
i* mx . get () *50 , 550 - ny . get () * my . get () * 50 ,
fill = ' gray ', activefill = ' red ', dash =(3 ,5), tag =( ' Recta01 '))
for i in range ( ny . get () +1) :
dibujo . create_line ( 50 , 550 -i* my . get ()
*50 , 50 +( nx . get ()) * mx . get () *50 ,
550 -i* my . get () *50 , fill = ' gray ', activefill = ' red '
, dash =(3 ,5), tag =( ' Recta02 '))
for u in range ( nx . get () +1) :
for m in range ( ny . get () +1) :
Ubicaciones_Universales . append ([ 50 +u* mx . get ()
*50 , 550 -m * my . get () * 50 ])
dibujo . create_oval ( 50 +u* mx . get () * 50 -2 ,
550 -m* my . get () * 50 -2 , 50 + u* mx . get ()
* 50 +2 , 550 -m* my . get () * 50 +2 ,
fill = ' red ' , activefill = ' blue ')
else :
tkMessageBox . showinfo ( message = ' Por Favor poner Datos ')
ventana_grilla = Toplevel ()
ventana_grilla . title ( ' DIBUJAR GRILLA P/ ESQUEMA ')
ventana_grilla . minsize ( 500 , 200 )
ventana_grilla . geometry ( ' 500x200 +0+0 ')
# ------------------------------------------------------nx = IntVar ()
mx = DoubleVar ()
ny = IntVar ()
my = DoubleVar ()
# ----------------------------------------------------------texto_principal = Label ( ventana_grilla ,
text = ' COORDENADAS EN EL EJE X:Y '). place (x= 100 ,y= 0)
Texto_01 = Label ( ventana_grilla , text = 'N : Ejes - X '). place (x =10 ,y = 20 )
texto_02 = Label ( ventana_grilla , text = 'Dist - Ejes -X '). place (x= 250 ,y= 20 )
texto03 = Label ( ventana_grilla , text = 'N: Ejes -Y '). place (x=10 ,y= 60 )
texto04 = Label ( ventana_grilla , text = 'Dist - Ejes - Y ' ). place (x = 250 ,y = 60 )
# --------------------------------------------------------------------------------------Ejes_Horizontales = Entry ( ventana_grilla , textvariable = nx ). place (x= 80 ,y= 20 )
Distancias_Horizontales = Entry ( ventana_grilla , textvariable = mx ). place (x= 320 ,y= 20 )
# ----------------------------------------------------------------------------------------Ejes_Verticales = Entry ( ventana_grilla , textvariable = ny ). place ( x=80 , y= 60 )
Distancias_Verticales = Entry ( ventana_grilla , textvariable = my ). place (x= 320 ,y= 60 )
Boton01 = Button ( ventana_grilla , text = ' APLICAR ',
command = dibujo_grilla ). place ( x= 300 , y= 150 )
# ------------------------------------------------------------------------------------------------Boton02 = Button ( ventana_grilla , text = ' CANCELAR ',
command = ventana_grilla . destroy ). place (x= 400 ,y= 150 )
# ------------------------------------------------------------------------------------------------#
VENTANA DE GRILLAS - LOKITOSAMAX - ELEMENTOS DE VARIABLE
# ------------------------------------------------------------------------------------------------ventana_grilla . mainloop ()
125
2014.
def Borrador () :
dibujo . delete ( ALL )
def dibuja_barra () :
tkMessageBox . showinfo ( message = ' Poner el Primero y Segundo punto . ')
global puntos
global longitudes
global u2
global u
start = None
def punto ( evento ) :
global start
global u
start =[ evento .x , evento .y]
def punto2 ( evento ):
global puntos
global longitudes
global start
global u
global u2
if start is not None :
x= start [0 ]
y= start [1 ]
dibujo . create_line (x ,y , evento .x , evento .y , width =4.5 ,
arrow = LAST , activefill = ' gray ', tag = ( ' linea1 '))
dibujo . itemconfig ( ' linea1 ' , fill = ' red ')
u=u +[(x- 50 )/50 ,( 550 - y)/50 ,( evento .x- 50 )/50 ,( 550 - evento .y)/ 50 ]
longitudes = longitudes + [ norm ( array ([( evento .x - 50 )/ 50 ,
( 550 - evento .y) / 50 ])- array ([(x- 50 )/50 ,( 550 -y)/ 50 ] )) ]
start = None
dibujo . bind ( '< Button -1 > ', punto )
dibujo . bind ( '< Button -3 > ', punto2 )
u1 = array (u)
l1 = len ( u1 )
u2 = u1 . reshape ( l1 /2 ,2)
print u2
print longitudes
def kill_XY ( evento = None ):
dibujo . delete ( ' no ')
def Kill_2 ( evento = None ):
dibujo . delete ( ' cuadradito ')
X ,Y= None , None
def coordenadas ( evento ):
global X ,Y
kill_XY ()
X= dibujo . create_line ( evento .x ,0 , evento .x , 1000 , dash =[3 ,2] , tags = 'no ', fill = ' red ')
Y= dibujo . create_line (0 , evento .y , 1000 , evento .y , dash =[3 ,2] , tags = 'no ', fill = ' blue ')
global cuadrado
Coordenada_mause [ ' text '] = 'x ->
'+ str (( evento .x- 50 )/ 50 ) + 'y -> '+ str (( 550 - evento .y)/ 50 )
m= array ([ evento .x , evento . y])
if Ubicaciones_Universales is not None :
for s in range ( len ( Ubicaciones_Universales )) :
if evento .x= =
Ubicaciones_Universales [s][0] and
evento .y == Ubicaciones_Universales [s ][1]:
126
2014.
dibujo . create_rectangle
( Ubicaciones_Universales [ s][0] -10 , Ubicaciones_Universales [ s][1]
-10 , Ubicaciones_Universales [s][ 0]
+10 , Ubicaciones_Universales [s][ 1]
+10 , outline = ' blue ', tag = ' Cuadrado_Identificado '+ str (s ))
else :
dibujo . delete ( ' Cuadrado_Identificado '+ str (s ))
# -----------------------------------------------------------------------ventana = Tk ()
ventana . title ( ' FEMAX ')
ventana . minsize ( 1200 , 800 )
ventana . geometry ( ' 1200x800 +0+ 0 ')
barra_dibujo = Frame ( ventana , width = 200 , height = 100 )
barra_dibujo . grid ( row =0 , column =4)
# -------------------------------------------------------------------------dibujo = Canvas ( ventana , width = 950 , height = 600 , scrollregion =( - 2000 , - 2000 , 2000 , 2000 ) ,
# --------------------------------------------------------------------------------dibujo . bind ( '< Motion > ', coordenadas )
flecha_X = dibujo . create_line (50 , 550 , 100 , 550 , arrow = LAST , fill = ' blue ')
X_sumate = dibujo . create_text ( 125 , 550 , text = ' Eje_X ', fill = ' blue ')
flecha_Y = dibujo . create_line (50 , 550 ,50 , 500 , arrow = LAST , fill = ' blue ')
X_sumate = dibujo . create_text (50 , 480 , text = ' Eje_Y ', fill = ' blue ')
# ---------------------------------------------------------------------------------dibujo . grid ( row =1 , column = 1)
scrollY = Scrollbar ( ventana , orient = VERTICAL , command = dibujo . yview )
scrollX = Scrollbar ( ventana , orient = HORIZONTAL , command = dibujo . xview )
dibujo [ ' xscrollcommand '] = scrollX . set
dibujo [ ' yscrollcommand '] = scrollY . set
# ------------------------------------------------------------------------------------#
# BOTONES Y CONTROLES GENERALES DEL PROGRAMA EN GENERAL ---- ------ ----- --> LOKITOSAMAX
#
# -------------------------------------------------------------------------------------''' TITULO DEL PROGRAMA EN GENERAL '''
Texto_General = Label ( ventana ,
text = ' PROGRAMA DE ESTRUCTURAS - HECHO EN 01 / 2014 - UNIVERSIDAD NACIONAL DE CAJAMARCA ',
fg = ' blue ')
Texto_General . grid ( row =0 , column =1 )
# --------------------------------------------------------------------------------------Im_barra = PhotoImage ( file = ' frame . gif ')
Im_grilla = PhotoImage ( file = ' grilla . gif ')
Im_Borrador = PhotoImage ( file = ' borrador . gif ')
Im_Materiales = PhotoImage ( file = ' materiales_damier . gif ')
Im_Procesos = PhotoImage ( file = ' proceso . gif ')
Im_Apoyosgeneral = PhotoImage ( file = ' movil . gif ')
Im_Fuerzas1 = PhotoImage ( file = 'FP . gif ')
Im_Fuerzas2 = PhotoImage ( file = 'FD . gif ')
# -------------------------------------------------------------------------------------barra_nodal = Button ( barra_dibujo , image = Im_barra ,
command = dibuja_barra , width =30 , height = 30 ). place (x=20 ,y= 20 )
grillas_nodal = Button ( barra_dibujo , image = Im_grilla ,
command = grilla , width =30 , height = 30 ). place (x=55 ,y= 20 )
Borrar = Button ( barra_dibujo , image = Im_Borrador ,
command = Borrador , width =30 , height = 30 ). place (x=20 ,y= 60 )
Materiales_Elementos = Button ( barra_dibujo ,
image = Im_Materiales , width =30 , height =30 , command = Materiales_Calculo ). place (x=55 ,y= 60 )
Prueba_ultima = Button ( barra_dibujo , image = Im_Procesos ,
command = nodos_calculo , width =30 , height = 30 ). place (x=90 ,y= 20 )
127
2014.
Boton_Apoyos = Button ( barra_dibujo , image = Im_Apoyosgeneral ,

command = apoyos_universales , width =30 , height = 30 ). place (x=90 ,y= 60 )
Boton_Fuerzas1 = Button ( barra_dibujo , image = Im_Fuerzas1 , width =30 , height = 30 ,
command = Fuerzas_puntuales ). place (x= 130 ,y = 20 )
Boton_Fuerzas2 = Button ( barra_dibujo , image = Im_Fuerzas2 , width =30 , height = 30 ,
command = Fuerzas_distribuidas ). place (x= 130 ,y= 60 )
# ----------------------------------------------------------------------------------''' MODELADO DEL MAUSE PRIMEROS PROPIEDADES DEL MOUSE '''
Coordenada_mause = Label ( ventana )
Coordenada_mause . grid ( row =4 , column = 1)
ventana . mainloop ()
128
Bibliografa
[1] H. Partl: T Xen Castellano, Tesis de La Unam,Perez Villar Luis Alberto,(2003)
E
[2] H.
partl:
T Xen
E
catellano,
El
Mtodo
de
Elementos
Finitos,O.CZienkiewichz-R.LTaylor,McGraw-
Hill,(1998)
[3] H. partll: Clculo de Estructuras por el mtodo de elementos nitos Analisis Estatico Lineal,Eugenio
Oate,C.I de Metodos Numricos en Ingenieria UPC,(1992)
[4] H. partll: Anlisis de Slidos y Estructural mediante el mtodo de Elementos nitos,Sergio Gallegos Czares,Tecnologico de Monterrey-LIMUSA,(2008)
[5] H. partll: Matplotlib for Python Develops,Sandro Tosi,Birmingham-Noviembre 2009.
[6] H.
partll:
Mecnica
de
Slidos,
Egor
P.Popov(University
of
California-Berkeley),Educational-
Person,Edition(2000)
[7] H. partll: El Mtodo de Elementos Finitos Aplicado al analisis Estructural,Manuel Vasquez,Eloiza Lopez.
[8] H. partll: Anlisis de Estructuras con Mtodos Matriciales ,Arturo Tenna Colunga ,Limusa Mexico-2007.
[9] H. partll: Lenguaje de Programacin Python Orientado a Objetos,Manuel Casado Martin,Santiago Gualadajara Perez,Universidad de Salamanca.
[10] H. partll: Composicin de texos cienticos con LaTeX(Gabriel Valiente Feruglio)
129

Elementos Finitos Con Computadoras PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Elementos Finitos Con Computadoras PDF

Încărcat de

Drepturi de autor:

Formate disponibile

UNIVERSIDAD NACIONAL DE CAJAMARCA

Escuela Acadmico Profesional de Ingenieria Civil

Febrero del 2014.

Universidad Nacional de Cajamarca.

Asesor:Ing Marco Mendoza Linares.

Mtodo de Elementos Finitos.

Tesista:Christian G. Salcedo Malaver

* A mis profesores que con su esfuerzo y buen nimo me aconsejaron y me ensearon en

Universidad Nacional de Cajamarca.

Asesor:Ing Marco Mendoza Linares.

Mtodo de Elementos Finitos.

Tesista:Christian G. Salcedo Malaver

Elemento Continuo y Discreto.

BREVE HISTORIA DEL METODO DE ELEMENTOS FINITOS. . . . . . . . . . . . . . . . . .

APLICACIONES DEL METODO. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Aplicaciones al Analisis Estructural.

Aplicacion en Mecnica de Fluidos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

III MARCO TERICO

2. MTODO DE ELEMENTOS FINITOS

Fuerzas nodales equivalentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

VIGAS SOMETIDAS A FUERZA AXIAL.

ANLISIS DE FLEXIN EN UNA VIGA.

Teoria de Flexion de Viga de Euler y Bernoulli. . . . . . . . . . . . . . . . . . . . . . . . .

Discretizacin de elementos nitos de dos nodos.

Matriz de Rigidez Viga Bernoulli.

Teoria de Flexin de Viga de Timoshenko . . . . . . . . . . . . . . . . . . . . . . . . . . .

Elementos nitos para exin de vigas de Timoshenko. . . . . . . . . . . . . . . . . . . . .

Matriz de Rigidez Total V.Timoshenko y Efecto de Bloqueo.

PROGRAMA DE VIGAS HECHA EN PYTHON.

Librerias Principales de python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Programa hecho en python

4. PROBLEMAS DE ELASTICIDAD BIDIMENCIONAL.

Teoria de la Elasticidad Bidimensional. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Relacin Tensin - Deformacin.

Formulacin de Elementos Finitos.Elemento de tres Nodos.

Discretzacin del Campo de Desplazamiento.

Universidad Nacional de Cajamarca.

Asesor:Ing Marco Mendoza Linares.

Mtodo de Elementos Finitos.

Tesista:Christian G. Salcedo Malaver

Discretizacin del campo de tensiones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Discretizacin del campo de deformaciones.

Ecuaciones de Equilibrio de la Discretizacin. . . . . . . . . . . . . . . . . . . . . . . . . .

Otros Elementos Bidimensionales y el Mtodo de Interpolacin de Lagrange.

Interpolacin de alta jerarquia de clase

Elementos Triangulares y tetahedricos de clase

Calculo Analtico sobre Elementos Triangulares y Rectangulares de lados rectos.

Expresin del Principio de los Trabajos Virtuales.

Discretizacin del campo de desplazamientos. . . . . . . . . . . . . . . . . . . . . . . . . .

Discretizacin del campo de deformaciones y tensiones.

Matriz de Rigidez del Elemento.

Vectores de fuerzas nodales equivalentes. . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Formulacin de Elementos Finitos.

IV EJEMPLOS DE CLCULO DE ELEMENTOS FINITOS.

6. Ejemplos y Problemas de Elementos Finitos.

V CRITERIOS DE PROGRAMACIN-(USOS DEL PROGRAMA)

7. Programacin general del Femax.

Caracteristicas del Programa Femax. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Calculo de Deformaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

Clculo de Fuerzas Internas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

Gracos y tablas de Resultados de Momentos,Cortantes,Deformada y Cortantes.

VII CODIGO FUENTE DEL PROGRAMA FEMAX.

Aplicaciones del FEM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Discretizacin de elementos nitos de dos nodos.

Elementos nitos para exin de vigas de Timoshenko. . . . . . . . . . . . . . . . . . . . .

Gracos y tablas de Resultados de Momentos,Cortantes,Deformada y Cortantes.

4.27. Elemento Triangular de tres nodos denido en coordenadas triangulares. . . . . . . . . . . . . . .

Comparacion de Gcos del Femax con Sap 2000 V14. . . . . . . . . . . . . . . . . . . . . . . . .

6.15. Comparacin Graca del Sap 2000 V14 y el Femax.

Diagrama de ujo del programa Femax.

Entorno Grco del Femax y su funcin de Grilla y su resultado