Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Exposición #1 - Informe - Kattan - Cap11 PDF
Exposición #1 - Informe - Kattan - Cap11 PDF
FACULTAD DE INGENIERÍA
1 INTRODUCCIÓN 4
2 OBJETIVOS 4
Objetivo general 4
Objetivos específicos 4
MARCO TEÓRICO 4
METODOLOGÍA 7
ANÁLISIS Y RESULTADOS 7
Ejemplo 1 7
5.2 Ejemplo 2 9
5.3 Ejercicio 1 13
5.4 Ejercicio 2 17
DISCUSIONES 21
CONCLUSIONES 21
BIBLIOGRAFÍA 21
ANEXOS 21
LISTA DE FIGURAS
Figura 2: Ejemplo 1
Figura 4: Ejemplo 2
LISTA DE TABLAS
Tabla 1: Conexión de nodos ejemplo 1
Tabla 2: Resultados de fuerza y desplazamiento para el ejemplo 1
Tabla 3: Resultados de tensiones planas para el ejemplo 1
Tabla 4: Resultados de tensiones principales para el ejemplo 1
Tabla 5: Conexión de nodos ejemplo 2
Tabla 6: Desplazamientos y fuerzas por nodo para el ejemplo 2
Tabla 7: Designación de elementos y nodos para el problema 11.2
Tabla 8: Desplazamientos en cada nodo, problema 11.2
Tabla 9: Fuerzas y reacciones en cada nodo, problema 11.2
Tabla 10: Designación de elementos y nodos para el problema 11.3
RESUMEN
El presente trabajo de investigación es un resumen del capítulo 11 del libro de Petter Kattan:
“Matlab Guide to Finite Elements” [1], el cual trata sobre el Elemento Lineal Triangular. En este
informe se presentan las características de este elemento, así mismo los parámetros a considerar
para cada caso y las ecuaciones principales que dan origen a la serie de algoritmos o funciones
codificadas en Matlab, que servirán de base para la resolución de ejercicios. Además, se presenta
la solución detallada para cada ejemplo presentado en el libro base y la solución de los tres
problemas planteados, así mismo, se realizó cada ejercicio en Matlab, que se pueden revisar en la
sección de anexos.
1 INTRODUCCIÓN
El uso de softwares capaces de realizar cálculos complejos y que requieran grandes matrices, es
cada día más importante en la vida profesional de un ingeniero. Programas como matlab, brindan
herramientas capaces de simplificar, en muchas ocasiones, problemas como los mencionados al
inicio del párrafo. Por ello, el propósito del trabajo es adentrarse un poco más en uno de los
muchos capítulos que presenta el libro guía de Petter Kattan. El principal requerimiento es el
estudio conceptual de la parte teórica y el análisis de ejemplos y ejercicios planteados por el autor.
2 OBJETIVOS
2.1 Objetivo general
Estudiar y aplicar la teoría del elemento finito lineal triangular para elementos bidimensionales.
3 MARCO TEÓRICO
El elemento triangular lineal es un elemento finito bidimensional que utiliza funciones lineales, y
puede ser usado en problemas de tensión plana y deformación plana. Sin embargo, solo toma en
cuenta el análisis de fuerzas, es decir, que no asume momentos ni torsión en sus algoritmos.
Otra característica importante es que, este elemento triangular se aplica a placas delgadas, por lo
que se debe tomar en cuenta su espesor. De este modo, para el planteamiento de ecuaciones y de
los algoritmos, los parámetros que se toman en cuenta son los siguientes:
● E: Módulo de Young
● v: Coeficiente de Poisson
● t: Espesor
De esta forma, se puede obtener la ecuación de la matriz de rigidez del elemento que se define
por:
(1)
(2)
Y B es la matriz:
(3)
(4)
(5)
(6)
Además, una vez obtenidos los desplazamientos nodales se puede determinar el vector de
tensiones o esfuerzos para cada elemento con la siguiente relación:
(7)
Donde σ es el vector de tensiones para cada elemento y tiene un tamaño (3x1). Cabe mencionar,
que se pueden obtener 2 tipos de tensiones: Las tensiones generales que devuelven la tensión en
el eje X y Y, y tensión de corte en XY; y también se pueden obtener las tensiones principales que
devuelven la tensión mínima y máxima, además de su ángulo principal basadas en la teoría del
Círculo de Mohr.
4 METODOLOGÍA
Los ejercicios presentados en la sección 5 fueron resueltos con el software Matlab versión 2018,
en base a las siguientes funciones [1]:
➔ LinearTriangleElementArea(xi, yi, xj, yj, xm, ym): Esta función devuelve el área del
triángulo (siempre debe ser positivo) en base a las coordenadas de los 3 nodos del
triángulo.
➔ LinearTriangleElementStiffness(E, NU, t, xi, yi, xj, yj, xm, ym, p): Esta función devuelve
la matriaz de rigidez del elemento para cada triángulo de tamaño 6x6, en base al módulo
de elasticidad, el coefiniete de Poisson, el espesor de la placa, las coordenadas de los
nodos y p. Para casos de tensión plana p=1, para casos de deformación plana p=2.
➔ LinearTriangleAssemble(K, k,i, j, m): Esta función es la encargada del ensamble de la
matriz de rigidez global del sistema cuyo tamaño es 2nx2n, y utiliza los parámetros de la
anterior matriz global K, la matriz de cada elemento k, y el orden de la posición de nodos.
➔ LinearTriangleElementStresses(E, NU, xi, yi, xj, yj, xm, ym, p, u): Esta función devuelve
las tensiones del elemento utilizando el módulo de elasticidad, el coeficiente de Poisson,
el espesor de la placa, las coordenadas de los nodos, p y el vector de desplazamiento nodal
u. Su tamaño es 3x1 y muestra la tensión en el eje horizontal y vertical, además, el
esfuerzo cortante en el plano.
➔ LinearTriangleElementPStresses(sigma): Esta función devuelve las tensiones principales
utilizando el vector sigma calculado con la anterior función. Su tamaño es 3x1 y muestra
la tensión máxima, mínima el ángulo principal.
5 ANÁLISIS Y RESULTADOS
5.1 Ejemplo 1
Para los siguientes datos E = 210 GPa, ν = 0.3, t = 0.025 m, and w = 3000 kN/m2, se pide
determinar: El desplazamiento nodal del sistema, el vector nodal de fuerzas, la tensión para cada
elemento, y la tensión y ángulo principal de cada elemento.
Figura 2: Ejemplo 1
Solución:
El primer paso es definir los nodos y elementos, para esto se debe dividir la placa en triángulos.
Además, se debe distribuir en los nodos extremos la fuerza aplicada en la cara lateral de la placa
con la siguiente relación:
Cabe mencionar que se debe tomar en cuenta el espesor debido a que la fuerza se aplica en una
sección de área. De esta forma, se obtiene el sistema que servirá de base para el análisis de
elementos finitos:
Se puede observar que en este caso solamente se tomó en cuenta 2 triángulos, sin embargo, es
recomendable utilizar más elementos para obtener mayor precisión y resultados más confiables.
Ahora, se procede a numerar los nodos para cada elemento en sentido antihorario. La tabla de
conexión de elementos y nodos es la siguiente:
Como el sistema tiene 4 nodos, la matriz de rigidez global será de (8x8) y, se sabe que, debido al
tipo de los apoyos y las fuerzas aplicadas, las condiciones son las siguiente:
De este modo, se puede observar que, para calcular el desplazamiento y fuerza nodal, se debe
cortar la matriz K dejando una submatriz en las filas 3 a 6 y columnas 3 a 6, obteniendo los
siguientes resultados:
Se puede observar claramente que, existe un equilibrio estático ya que la sumatoria de fuerzas
resulta 0.
Finalmente, se calculan las tensiones para cada elemento y las tensiones principales con las
funciones mostradas anteriormente, obteniendo los siguientes resultados:
Se puede observar una coherencia en los resultados, ya que los valores de tensión mínima y
máxima obtenidos en el análisis de tensiones principales (círculo de Mohr) coinciden con los
resultados obtenidos en tensiones planas. Además, el signo de los ángulos principales para cada
elemento coincide con el signo de la tensión de corte (τ xy)
Para observar paso a paso la aplicación de los algoritmos mostrados en la sección 4 y comprobar
los resultados obtenidos, se recomienda revisar el código de Matlab para el ejemplo 1 en Anexos
5.2 Ejemplo 2
Para el ejemplo número 2 se usó los siguientes datos, E=210 GPa, v=0,3, t=0,025m,
w=100 kN/m y P=12,5 kN. el ejercicio nos pide determinar:
Figura 4: ejemplo 2
Paso 1
El primer paso es dividir la gráfica de modo que estén triángulos para poder realizar el
ejercicio por lo cual la figura 4 se la divide en 3 cuadrados y cada cuadrado en 4
triángulos, a parte de eso anotar las fuerzas que se están efectuando y si es una fuerza
distribuida se la distribuye en cada nodo usando la siguiente fórmula:
𝐹 ∗ 𝐹 100 ∗ (0,25)
𝐹= = = 12,5 𝐹𝐹
2 2
Como se puede ver en la figura 5 ya se modificó la figura para efectuar el analisis asi que
esta distribuido en triángulos, se crearon nuevos nodos y la fuerza P que era de 12 ,5 kN
en dirección y se anula con la fuerza distribuida que habría en el nodo 10 que tiene un
valor de -12,5 kN. de modo que la estructura queda así con una fuerza de -12,5 en y en el
nodo 5.
Paso 2
Ahora creamos una tabla con los datos de los elementos y de cómo conectan con los nodos
para facilitar el ensamble.
1 1 3 2
2 1 4 3
3 3 5 2
4 3 4 5
5 4 6 5
6 4 7 6
7 5 6 8
8 6 7 8
9 5 8 9
10 5 9 10
11 8 11 9
12 9 11 10
Como el sistema tiene 11 nodos, la matriz de rigidez global sera de 22x22 , debido a los
datos previos y analizando los apoyos sabemos que:
F2x = F2y = F3x = F3y = F6x = F6y = F8x = F8y = F9x = F9y= F10x = F10y = F11x =
F11y = 0
la respuesta del sistema requiere que se efectúan unos cortes de filas y columnas, en este
caso se mantendrán de filas, de las 3 a 6, 9 a 12, 15 a 22 y de las columnas 3 a 6, 9 a 12
y 15 a 22. obteniendo una matriz que es de 16x16 con lo cual se consiguen los siguientes
resultados:
1 0 0 -6.0939 4.3591
2 0.1158 -0.3010 0 0
3 0.0432 -0.1657 0 0
4 0 0 -0.3122 3.9181
6 -0.0409 -0.1762 0 0
7 0 0 6.4061 4.2228
8 -0.1340 -0.3528 0 0
9 -0.0530 -0.4526 0 0
10 0.0083 -0.5114 0 0
11 -0.1270 -0.5290 0 0
de forma que podemos observar los desplazamientos y las fuerzas que se generan en cada
nodo, para comprobar podemos ver que la sumatoria de fuerzas da 0 mostrándonos que
el resultado es correcto.
5.3 Ejercicio 1
Problema 11.2
Con los datos de E=70 GPa, 𝜈=0,25, t=0,02 m y P=20 kN para la siguiente figura, hallar
Solución:
El paso número 1 para resolver este ejercicio, es dividir la placa en sectores o zonas compuestas
por triángulos, teniendo especial cuidado con no tomar en cuenta el agujero. En este caso, no
será necesario distribuir una carga, debido a que el problema presenta una carga puntual en la
parte superior derecha.
En esta parte de la solución, se crea una tabla de elementos con sus respectivas conexiones, es
decir, se cuentan los triángulos y se anotan los nodos que los conforman. es muy importante
que, se anoten en sentido antihorario con respecto al primero que haya sido escogido.
1 1 6 5
2 1 2 6
3 2 7 6
4 2 3 7
5 3 8 7
6 3 4 8
7 5 10 9
8 5 6 10
9 7 12 11
10 7 8 12
11 9 14 13
12 9 10 14
13 10 15 14
14 10 11 15
15 11 16 15
16 11 12 16
Una vez que se tienen los componentes y sus conexiones, se crean las matrices de rigidez para
cada uno de ellos. Dentro de Matlab, el comando utilizado es:
Por definición, la matriz global de rigidez que se genera es de 32x32, aplicando la pequeña
fórmula que indica que el número de elementos de la matriz, es igual a 2n x 2n; donde “n” es el
número de nodos. Es importante recalcar, que se deben reservar espacios para la misma, utilizando
el comando “zeros”.
➔ K=zeros(32,32);
Una vez terminado este paso, las matrices individuales de los triángulos, se ensamblan:
➔ LinearTriangleAssemble(K, k,i, j, m)
La siguiente tarea es determinar y plantear las condiciones iniciales debido a las restricciones de
movimiento en determinados nodos, o a las fuerzas externas que se aplican sobre algunos de ellos.
%Condiciones Iniciales
f16y = - 20 kN
Gracias a estas condiciones, es posible cortar la matriz global de rigidez K y efectuar diversas
operaciones hasta hallar las matrices finales de desplazamiento U y fuerza F, del sistema.
1 0 0
2 -0.02 -0.0225
3 -0.0291 -0.0581
4 -0.0305 -0.0854
5 0 0
6 -0.0008 -0.0173
7 -0.0072 -0.0585
8 -0.0077 -0.0867
9 0 0
10 0.0001 -0.0176
11 0.001 -0.0639
12 0.0064 -0.0960
13 0 0
14 0.0207 -0.0199
15 0.0346 -0.0635
16 0.0356 -0.1167
1 18.8054 1.0788
2 0 0
3 0 0
4 0 0
5 1.3366 9.2538
6 0 0
7 0 0
8 0 0
9 0.9105 0.2247
10 0 0
11 0 0
12 0 0
13 -21.0525 9.4427
14 0 0
15 0 0
16 0 -20
En las tablas, se pueden apreciar los resultados requeridos por los incisos b y c, que están al
comienzo del problema. Para comprobar los resultados, puede realizarse un cálculo rápido de las
sumatorias presentes en la tabla de fuerzas. Si la sumatoria es igual a 0 en ambos casos, el
resultado es correcto.
5.4 Ejercicio 2
Problema 11.3
Se tienen los datos E=200 GPa, v=0.3, t=0.01 m, k=4000 kN/m y w=5000 kN/m^2 para la
estructura de la siguiente figura:
Paso 1:
Se discretiza la fuerza distribuida w, la cual claramente se separaría en los nodos 1 y 2. Para esto
se multiplica el valor de esta fuerza distribuida por el área de la superficie sobre la cual está siendo
aplicada, y se divide entre el número de nodos, es decir 2.
También se establece el sistema de coordenadas de los nodos para su uso en el cálculo de matrices
de rigidez de los triángulos. Se tiene entonces la siguiente figura:
1 (triángulo) 1 3 2
2 (triángulo) 2 3 4
3 (resorte) 3 5
4 (resorte) 4 6
Paso 2:
Se obtienen las matrices de rigidez de elemento. Como se tienen dos tipos de elementos:
triángulos planos y resortes, se usan dos funciones:
Y posteriormente se ensamblan, generando primero una matriz de ceros de 10x10. Esta dimensión
se obtiene a partir del vector de desplazamiento, en el cual los primeros 8 valores corresponden a
los nodos pertenecientes a los triángulos, pues estos tienen dos grados de libertad, y los valores 9
y 10 corresponden a los resortes, los cuales tienen solo un grado de libertad.
Para el ensamblaje se usan las funciones:
Donde los valores de i, j y m se extraen de la tabla (algo) para los triángulos, y los valores de i y
j para los resortes se obtienen considerando el vector de desplazamiento, en el cual i es el elemento
en el eje y de los nodos unidos a 5 y 6, es decir, i adquiere valores de 6 y 8, para 3y y para 4y. Se
obtiene de esta forma la matriz de rigidez global:
Paso 3:
Después se procede a calcular los desplazamientos: Para esto se crean los vectores de
desplazamiento y fuerza según las siguientes condiciones iniciales:
Y como se puede ver, se pueden obtener los valores de todos los desplazamientos considerando
solo los primeros 8 elementos de cada vector, al igual que las primeras 8 filas y columnas de la
matriz de rigidez global. El sistema resultante se resuelve por eliminación Gaussiana en Matlab,
y se obtiene (expresado en metros):
Paso 4:
Para obtener las reacciones en los nodos se multiplica la matriz de rigidez K por el vector de
desplazamientos U, y se obtienen así las reacciones en 5 y 6. Estos resultados tienen sentido pues
se cumple el equilibrio en la estructura.
Paso 5:
Tanto para sacar los esfuerzos en los triángulos como para obtener las fuerzas de los resortes, se
deben obtener los vectores de desplazamiento de cada elemento tomando las componentes en x e
y de los nodos de los triángulos según la tabla (algo), y tomando los elementos del vector U para
los resortes de acuerdo a la explicación del paso 2 (es decir, 6 y 9 para el primer resorte y 8 y 10
para el segundo). Una vez hecho esto se usa la función:
sigma=LinearTriangleElementStresses(E,NU,t,ix,iy,jx,jy,mx,my,p,u)
Y se obtienen los siguientes valores, en los cuales el único esfuerzo ejercido es de tensión:
Paso 6:
s=LinearTriangleElementPStresses(sigma)
Y se obtienen:
Finalmente, para obtener las fuerzas de los resortes se usa la función:
f=SpringElementForces(k,u)
Y se obtienen los vectores de fuerza de resorte siguientes, de los cuales se interpreta que ambos
resortes se encuentran bajo fuerzas de tensión:
6 DISCUSIONES
7 CONCLUSIONES
La investigación se realizó a partir de los conceptos fundamentales del libro guía y los algoritmos
planteados en el mismo. Dichos algoritmos, explicados en el marco teórico del informe, facilitan
bastante el trabajo y la programación para la resolución de ejercicio, puesto que, cuentan con
diversas funciones ya integradas que acortan el código a realizar.
8 BIBLIOGRAFÍA
1. Kattan, Peter. MATLAB Guide to Finite Elements. New York : Springer, 2008. ISBN-13
9 ANEXOS
Código de Matlab para cada uno de los ejercicios realizados en el informe:
Ejemplo 1
E=210e6;
v=0.3;
t=0.025;
K=zeros(8,8);
K=LinearTriangleAssemble(K,k1,1,3,4);
K=LinearTriangleAssemble(K,k2,1,2,3)
k=K(3:6,3:6)
f=[9.375;0;9.375;0];
u=k\f;
U=[0;0;u;0;0]
F=K*U
sigma1=LinearTriangleElementStresses(E,v,t,0,0,0.5,0.25,0,0.25,1,u1)
sigma2=LinearTriangleElementStresses(E,v,t,0,0,0.5,0,0.5,0.25,1,u2)
s1=LinearTriangleElementPStresses(sigma1)
s2=LinearTriangleElementPStresses(sigma2)
Ejemplo 2
E=210e6;
NU=0.3;
t=0.025;
k1=LinearTriangleElementStiffness(E,NU,t,0,0.5,0.125,0.375,0.25,0.5,1);
k2=LinearTriangleElementStiffness(E,NU,t,0,0.5,0,0.25,0.125,0.375,1);
k3=LinearTriangleElementStiffness(E,NU,t,0.125,0.375,0.25,0.25,0.25,0.5,1);
k4=LinearTriangleElementStiffness(E,NU,t,0.125,0.375,0,0.25,0.25,0.25,1);
k5=LinearTriangleElementStiffness(E,NU,t,0,0.25,0.125,0.125,0.25,0.25,1);
k6=LinearTriangleElementStiffness(E,NU,t,0,0.25,0,0,0.125,0.125,1);
k7=LinearTriangleElementStiffness(E,NU,t,0.25,0.25,0.125,0.125,0.25,0,1);
k8=LinearTriangleElementStiffness(E,NU,t,0.125,0.125,0,0,0.25,0,1);
k9=LinearTriangleElementStiffness(E,NU,t,0.25,0.25,0.25,0,0.375,0.125,1);
k10=LinearTriangleElementStiffness(E,NU,t,0.25,0.25,0.375,0.125,0.5,0.25,1);
k11=LinearTriangleElementStiffness(E,NU,t,0.25,0,0.5,0,0.375,0.125,1);
k12=LinearTriangleElementStiffness(E,NU,t,0.375,0.125,0.5,0,0.5,0.25,1);
K=zeros(22,22);
K=LinearTriangleAssemble(K,k1,1,3,2);
K=LinearTriangleAssemble(K,k2,1,4,3);
K=LinearTriangleAssemble(K,k3,3,5,2);
K=LinearTriangleAssemble(K,k4,3,4,5);
K=LinearTriangleAssemble(K,k5,4,6,5);
K=LinearTriangleAssemble(K,k6,4,7,6);
K=LinearTriangleAssemble(K,k7,5,6,8);
K=LinearTriangleAssemble(K,k8,6,7,8);
K=LinearTriangleAssemble(K,k9,5,8,9);
K=LinearTriangleAssemble(K,k10,5,9,10);
K=LinearTriangleAssemble(K,k11,8,11,9);
K=LinearTriangleAssemble(K,k12,9,11,10)
k=[K(3:6,3:6) K(3:6,9:12) K(3:6,15:22) ; K(9:12,3:6) K(9:12,9:12) K(9:12,15:22) ; K(15:22,3:6) K(15:22,9:12)
K(15:22,15:22)];
f=[0;0;0;0;0;-12.5;0;0;0;0;0;0;0;0;0;0];
u=k\f;
U=[0;0;u(1:4);0;0;u(5:8);0;0;u(9:16)]
F=K*U
Problema 11.2
E=70e6; %MPa
NU=0.25;
t=0.02; %m
P=20; %kN
k1=LinearTriangleElementStiffness(E,NU,t,0,0,0.3,0.3,0,0.3,1);
k2=LinearTriangleElementStiffness(E,NU,t,0,0,0.3,0,0.3,0.3,1);
k3=LinearTriangleElementStiffness(E,NU,t,0.3,0,0.6,0.3,0.3,0.3,1);
k4=LinearTriangleElementStiffness(E,NU,t,0.3,0,0.6,0,0.6,0.3,1);
k5=LinearTriangleElementStiffness(E,NU,t,0.6,0,0.9,0.3,0.6,0.3,1);
k6=LinearTriangleElementStiffness(E,NU,t,0.6,0,0.9,0,0.9,0.3,1);
k7=LinearTriangleElementStiffness(E,NU,t,0,0.3,0.3,0.6,0,0.6,1);
k8=LinearTriangleElementStiffness(E,NU,t,0,0.3,0.3,0.3,0.3,0.6,1);
k9=LinearTriangleElementStiffness(E,NU,t,0.6,0.3,0.9,0.6,0.6,0.6,1);
k10=LinearTriangleElementStiffness(E,NU,t,0.6,0.3,0.9,0.3,0.9,0.6,1);
k11=LinearTriangleElementStiffness(E,NU,t,0,0.6,0.3,0.9,0,0.9,1);
k12=LinearTriangleElementStiffness(E,NU,t,0,0.6,0.3,0.6,0.3,0.9,1);
k13=LinearTriangleElementStiffness(E,NU,t,0.3,0.6,0.6,0.9,0.3,0.9,1);
k14=LinearTriangleElementStiffness(E,NU,t,0.3,0.6,0.6,0.6,0.6,0.9,1);
k15=LinearTriangleElementStiffness(E,NU,t,0.6,0.6,0.9,0.9,0.6,0.9,1);
k16=LinearTriangleElementStiffness(E,NU,t,0.6,0.6,0.9,0.6,0.9,0.9,1);
K=zeros(32,32);
K=LinearTriangleAssemble(K,k1,1,6,5);
K=LinearTriangleAssemble(K,k2,1,2,6);
K=LinearTriangleAssemble(K,k3,2,7,6);
K=LinearTriangleAssemble(K,k4,2,3,7);
K=LinearTriangleAssemble(K,k5,3,8,7);
K=LinearTriangleAssemble(K,k6,3,4,8);
K=LinearTriangleAssemble(K,k7,5,10,9);
K=LinearTriangleAssemble(K,k8,5,6,10);
K=LinearTriangleAssemble(K,k9,7,12,11);
K=LinearTriangleAssemble(K,k10,7,8,12);
K=LinearTriangleAssemble(K,k11,9,14,13);
K=LinearTriangleAssemble(K,k12,9,10,14);
K=LinearTriangleAssemble(K,k13,10,15,14);
K=LinearTriangleAssemble(K,k14,10,11,15);
K=LinearTriangleAssemble(K,k15,11,16,15);
K=LinearTriangleAssemble(K,k16,11,12,16)
%Condiciones Iniciales
%u1x=u5x=u9x=u13x=0
%u1y=u5y=u9y=u13y=0
%f16y=-P
k=[K(3:8,3:8) K(3:8,11:16) K(3:8,19:24) K(3:8,27:32) ; K(11:16,3:8) K(11:16,11:16) K(11:16,19:24) K(11:16,27:32) ;
K(19:24,3:8) K(19:24,11:16) K(19:24,19:24) K(19:24,27:32) ; K(27:32,3:8) K(27:32,11:16) K(27:32,19:24)
K(27:32,27:32)];
f=[zeros(23,1);-P];
u=k\f
U=[0;0;u(1:6);0;0;u(7:12);0;0;u(13:18);0;0;u(19:24)];
F=K*U
Problema 11.3
>> E=200e+6
E=
200000000
>> NU=0.3
NU =
0.3000
>> t=0.01
t=
0.0100
>> k1=LinearTriangleElementStiffness(E,NU,t,0,0.4,0,0,0.7,0.4,1)
k1 =
1.0e+06 *
k2 =
1.0e+06 *
>> k3=SpringElementStiffness(4000)
k3 =
4000 -4000
-4000 4000
>> k4=k3
k4 =
4000 -4000
-4000 4000
>> K=zeros(10)
K=
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
>> K=LinearTriangleAssemble(K,k1,1,3,2)
K=
1.0e+06 *
Columns 1 through 8
Columns 9 through 10
0 0
0 0
0 0
0 0
0 0
-0.0040 0
0 0
0 -0.0040
0.0040 0
0 0.0040
>> K=LinearTriangleAssemble(K,k2,2,3,4)
K=
1.0e+06 *
Columns 1 through 8
Columns 9 through 10
0 0
0 0
0 0
0 0
0 0
-0.0040 0
0 0
0 -0.0040
0.0040 0
0 0.0040
>> K=SpringAssemble(K,k3,6,9)
K=
1.0e+06 *
Columns 1 through 8
Columns 9 through 10
0 0
0 0
0 0
0 0
0 0
-0.0080 0
0 0
0 -0.0040
0.0080 0
0 0.0040
>> K=SpringAssemble(K,k4,8,10)
K=
1.0e+06 *
Columns 1 through 8
Columns 9 through 10
0 0
0 0
0 0
0 0
0 0
-0.0080 0
0 0
0 -0.0080
0.0080 0
0 0.0080
>> f=[0;17.5;0;17.5;0;0;0;0]
f=
0
17.5000
0
17.5000
0
0
0
0
>> k=K(1:8,1:8)
k=
1.0e+06 *
>> u=k\f
Warning: Matrix is close to singular or badly scaled. Results may be inaccurate. RCOND = 2.461010e-17.
u=
0.0001
0.0044
0.0001
0.0044
0.0001
0.0044
0.0001
0.0044
>> U=[u;0;0]
U=
0.0001
0.0044
0.0001
0.0044
0.0001
0.0044
0.0001
0.0044
0
0
>> F=K*U
F=
0.0000
17.5000
0.0000
17.5000
0.0000
-0.0000
-0.0000
-0.0000
-17.5000
-17.5000
>> u1=[U(1);U(2);U(5);U(6);U(3);U(4)]
u1 =
0.0001
0.0044
0.0001
0.0044
0.0001
0.0044
>> u2=[U(3);U(4);U(5);U(6);U(7);U(8)]
u2 =
0.0001
0.0044
0.0001
0.0044
0.0001
0.0044
>> u3=[U(6);U(9)]
u3 =
0.0044
0
>> u4=[U(8);U(10)]
u4 =
0.0044
0
>> sigma1=LinearTriangleElementStresses(E,NU,t,0,0.4,0,0,0.7,0.4,1,u1)
sigma1 =
1.0e+03 *
0.0000
5.0000
0.0000
>> sigma2=LinearTriangleElementStresses(E,NU,t,0.7,0.4,0,0,0.7,0,1,u2)
sigma2 =
1.0e+03 *
-0.0000
5.0000
0.0000
>> s1=LinearTriangleElementPStresses(sigma1)
s1 =
1.0e+03 *
5.0000
0.0000
-0.0000
>> s2=LinearTriangleElementPStresses(sigma2)
s2 =
1.0e+03 *
5.0000
-0.0000
-0.0000
>> f3=SpringElementForces(k3,u3)
f3 =
17.5000
-17.5000
>> f4=SpringElementForces(k4,u4)
f4 =
17.5000
-17.5000