Aplicación del método de los elementos finitos para cálculo de un PÓRTICO PLANO con 3 grados de libertad por nodo. A partir de dos subprogramas de 1 grado de libertad axial y otro de 2 grados de libertad flexión.

1. TRABAJO MÉTODOS
NUMÉRICOS
Simulación Numérica
11 DE ENERO DE 2018
MARCOS JAVIER HERNÁNDEZ GIL
MÁSTER EN INGENIERÍA BIOMÉDICA

4. P á g i n a | i
ÍNDICE GENERAL.
Capítulo 1. Introducción................................................................................................................ 1
Capítulo 2. Objetivos del trabajo................................................................................................... 2
Capítulo 3. Estructura del programa disponible para la flexión.................................................... 5
3.1. Beam.m .............................................................................................................................. 5
3.2. Preprocessor.m .................................................................................................................. 5
3.3. input file flexion.m ............................................................................................................. 7
3.4. Otras funciones. ............................................................................................................. 8
Capítulo 4. Estructura del programa disponible para la tracción compresión. .......................... 12
4.1. Bar1D.m............................................................................................................................ 12
4.2. Prepocessor.m.................................................................................................................. 12
4.3. input file axil.m................................................................................................................. 13
4.4. Otras funciones. ............................................................................................................... 15
Capítulo 5. Entregables. .............................................................................................................. 19
Capítulo 6. Modo de trabajo recomendado................................................................................ 20
Capítulo 7. Referencias. .............................................................................................................. 21
Capítulo 8. Resultados................................................................................................................. 22
8.1. Resultados obtenidos....................................................................................................... 22
8.1.1. Solución al vector de desplazamiento....................................................................... 23
8.1.2. Vector de reacciones................................................................................................. 24
Capítulo 9. Código final: Pórtico Plano........................................................................................ 25
9.1. Trabajo final: Pórtico Plano.............................................................................................. 25
9.1.1. Include_flags; ...................................................................................................... 25
9.1.2. [K,f,d] = preprocessor.......................................................................................... 26
9.1.3. Beamelem ............................................................................................................... 29
9.1.3.1. NmatrixBeam....................................................................................................... 29
9.1.3.2. BmatrixBeam................................................................................................... 29
9.1.4. Barelem.m............................................................................................................... 30
9.1.4.1. Nmatrix1D ....................................................................................................... 30
9.1.4.2. Bmatrix1D........................................................................................................ 31
9.1.5. Assemblylocal.m...................................................................................................... 31
9.1.6. Assembly.m ............................................................................................................. 32
9.1.7. naturalIBC................................................................................................................ 32
9.1.8. Solvedr.m ................................................................................................................ 32

5. ii | P á g i n a

6. P á g i n a | iii
ÍNDICE DE FIGURAS
Figura 1. Ejemplo de problema de barras sometidas a flexión, donde se toma como rigidez a
flexión 𝐸𝐼 = 104𝑁𝑚2. Las condiciones de contorno naturales en 𝑥 = 12𝑚 son 𝑆 = −20𝑁 y
𝑚 = 20𝑁𝑚. .................................................................................................................................. 2
Figura 2. Ejemplo de problema de barras sometidas a axil.......................................................... 2
Figura 3. Grados de libertad considerados en el problema de flexión y en uno de los códigos
previsto a los alumnos................................................................................................................... 3
Figura 4. Grados de libertad considerados en el problema de axil y en uno de los códigos provistos
a los alumnos................................................................................................................................. 3
Figura 5. Problema Propuesto...................................................................................................... 4
Figura 6. Grados de libertad del elemento a desarrollar............................................................... 4
Figura 7. Matriz de giro elemental............................................................................................. 20
Figura 8. Elemento a formular, en posición genérica................................................................. 20
ÍNDICE DE TABLAS.
No se encuentran elementos de tabla de ilustraciones.

8. P á g i n a | 1
Capítulo 1. Introducción.
El presente trabajo pretende familiarizar al alumno de la asignatura con la estructura de un
programa de elementos finitos. En este caso se ha elegido Matlab/Octave como plataforma por la
sencillez de uso y la facilidad con que se puede representar los resultados de forma gráfica, pero
el alumno es libre de escoger otro lenguaje de programación si lo estima conveniente. Los
ejecutables del software Octave se pueden descargar libremente de
http://www.gnu.org/software/octave/ . Para el desarrollo del trabajo se dispondrá de un par de
programas realizados en Matlab/Octave para elementos finitos: Uno de barras sometidas a flexión
y otro para barras sometidas a esfuerzo axil.

9. 2 | P á g i n a
Capítulo 2. Objetivos del trabajo.
El objetivo primordial del trabajo de la asignatura de la parte de métodos numéricos es el de
familiarizar al alumno con la estructura de un programa de elementos finitos. Se trata de lograr
un código único que unifique dos programas ya existentes y que se facilitará al alumno. Estos
programas resuelven dos problemas vistos en clase, por un lado, el de barras sometidas a flexión
(Fig. 1) y por otro el de barras sometidas a axil (Fig. 2).
Figura 1. Ejemplo de problema de barras sometidas a flexión, donde se toma como rigidez a flexión 𝐸𝐼 = 104
𝑁𝑚2
.
Las condiciones de contorno naturales en 𝑥 = 12𝑚 son 𝑆̅ = −20𝑁 y 𝑚̅ = 20𝑁𝑚.
Figura 2. Ejemplo de problema de barras sometidas a axil.
En el problema de flexión, como se recordará, la formulación empleada para la resolución de este
problema consideraba como variables esenciales del mismo los desplazamientos verticales en los
nudos de las dos barras, así como los giros respectivos (Fig. 3). No consideraba, por tanto, los
desplazamientos horizontales, que permitirían tener en cuenta los esfuerzos axiles vistos también

10. P á g i n a | 3
en clase. Este cálculo si lo resuelve el código de barras sometidas a axil que también se
proporciona al alumno (Fig. 4).
Figura 3. Grados de libertad considerados en el problema de flexión y en uno de los códigos previsto a los alumnos.
Figura 4. Grados de libertad considerados en el problema de axil y en uno de los códigos provistos a los alumnos.
Con el programa unificado que se propone se pretende resolver el problema de la Fig. 5. Se
recomienda comprobar la solución utilizando, por ejemplo, el código MEFI conocido por los
alumnos y que se puede descargar de forma gratuita desde
http://www.upct.es/~deyc/software/Mefi.zip. Recuérdese que, según lo visto en clase, los
problemas de flexión y tracción-compresión están desacoplados, razón por la cual se puede
considerar la formulación para barras sometidas a axil, junto con la formulación para flexión y,
conjuntamente, desarrollar una formulación que tenga en cuenta ambos fenómenos (Fig. 6).

11. 4 | P á g i n a
Figura 5. Problema Propuesto.
Figura 6. Grados de libertad del elemento a desarrollar.

12. P á g i n a | 5
Capítulo 3. Estructura del programa disponible para la flexión.
El primero de los programas disponibles a través de la página de la asignatura en Moodle
https://moodle2.unizar.es/add/ permite resolver barras planas sometidas a flexión únicamente. En
el que los nudos tienen dos grados de libertad (desplazamiento vertical y giro, según lo visto en
la Fig. 3) y se pretende combinarlo con el código que resuelve el problema de tracción-compresión
para que tengan tres grados de libertad (desplazamientos vertical y horizontal, y giro). De esta
forma se tendrán en consideración los esfuerzos axiles presentes en el problema que el alumno
debe resolver. Las funciones del programa se describen a continuación.
3.1. Beam.m
El programa principal o raíz se encuentra en Beam.m.
Las flags a que hace referencia la llamada de la función son las siguientes:
3.2. Preprocessor.m
La función preprocessor.m construye los vectores ID y LM del código. El vector LM proporciona
la numeración global de un grado de libertad (gdl) local.

13. 6 | P á g i n a
Así, por ejemplo, para el problema anterior definido en la figura 5, el vector LM tiene la siguiente
estructura:
𝐿𝑀 = [
1 3
2 4
3 5
4 6
]
El vector debe usarse en la siguiente forma:
𝑔𝑑𝑙 𝑔𝑙𝑜𝑏𝑎𝑙 = 𝐿𝑀 (𝑔𝑑𝑙 𝑙𝑜𝑐𝑎𝑙, 𝑛ú𝑚𝑒𝑟𝑜 𝑑𝑒 𝑒𝑙𝑒𝑚𝑒𝑛𝑡𝑜𝑠)
De forma que, si se quiere conocer, por ejemplo, cuál es el grado de libertad golbal después de
renumerar, que se corresponde con el desplazamiento vertical del segundo nudo del primer
elemento, realizaremos una llamada en la forma
𝑔𝑑𝑙 𝑔𝑙𝑜𝑏𝑎𝑙 = 𝐿𝑀 (4 ,1)
El elemento (4,1) de la matriz LM proporciona el valor 4, indicando que el gdl buscado es el cuarto
en la estructura global del problema, una vez que el programa los ha renumerado.
El vector ID hace lo propio con las numeraciones originales y renumerada, respectivamente.
function [K ,f ,d] = preprocessor
include_flags ;
input_file_flexion ; % fichero de entrada con todas las variables
count = 0; count1 = 0; % generar el vector LM
for i1 = 1: neq
if flags ( i1 ) == 2 % mira si hay una condicion esencial
count = count + 1;
ID ( i1 ) = count ; % primero los gdl en el contorno
esencial
D( count )= e_bc ( i1 ); % guarda los gdl reordenados
else
count1 = count1 + 1;
ID ( i1 ) = nd + count1 ;
end
end
for e = 1: nel
for j1 = 1: nen
for m = 1: ndof
ind = (j1 -1)* ndof + m;
% crea la matriz LM
LM (ind ,e) = ID ( ndof * IEN (j1 ,e) - ndof + m );
end
end
end

14. P á g i n a | 7
3.3. input file flexion.m
Este fichero incluye la entrada para la resolución del problema anterior.
%% Datos para el ejemplo de flexión del trabajo
nsd = 2; % número de dimensiones espaciales
ndof = 2; % grados de libertad por nodo
nnp = 3; % número de nodos globales
nel = 2; % número de elementos
nen = 2; % número de nodos en cada elementos
neq = ndof * nnp ; % número de ecuaciones
neqe = ndof * nen ; % número de ecuaciones para cada elemento
f = zeros (neq ,1); % inicializa el vector de fuerzas
d = zeros (neq ,1); % inicializa el vector de desplazamientos
K = zeros ( neq ); % inicializa la matriz de rigidez
flags = zeros (neq ,1); % inicializa el vector de banderas
e_bc = zeros (neq ,1); % inicializa el vector de bcs esenciales
n_bc = zeros (neq ,1); % inicializa el vector de bcs naturales
% propiedades del elemento.
CArea = [1 1 1] '; % área de la sección transversal
leng = [8 4]; % longitud del elemento
body = [ -1 0] '; % fuerzas por u. de longitud
E = [1 e4 1 e4 ] '; % módulo de Young.
% integracion de Gauss
ngp = 2; % número de puntos
% condiciones esenciales de contorno
% numeros impares para desplazamientos ; numeros pares para giros
flags (1) = 2; % Bandera que marca los gdl en el contorno esencial
flags (2) = 2; % Bandera que marca los gdl en el contorno esencial
e_bc (1) = 0; % valor del desplazamiento prescrito
e_bc (2) = 0; % valor del giro prescrito
nd = 2; % numero de grados de libertad en el contorno esencial
% CC naturales
% numeros impares para cortante ; numeros pares para momentos
flags (5) = 1; % Bandera que marca los gdl en el contorno natural
n_bc (5) = -20; % valor de la fuerza
flags (6) = 1; % Bandera que marca los gdl en el contorno natural
n_bc (6) = 20; % valor del momento
% Cargas puntuales
P = [ -10 5] '; % vector de cargas puntuales
xp = [4 8] '; % vector de coordenadas de aplicacion de las fuerzas
np = 2; % numero de cargas puntuales
% control de la salida
plot_beam = 'yes ';
plot_nod = 'yes ';
% generacion de la malla
beam_mesh_flexion ;
% numero de puntos a pintar
nplot =300;

15. 8 | P á g i n a
3.4. Otras funciones.
function beam_mesh_flexion
include_flags ;
% Nodos : 1 2 3 ( el origen esta en el nodo 2)
x = [0.0 8.0 12.0]; % X coordinate
y = [0.0 0.0 0.0]; % Y coordinate
IEN = [1 2; 2 3]; % vector de conectividad
plotbeam ; % pintar la barra
function [ke , fe ] = beamelem (e)
% genera la matriz de rigidez de cada elemento
include_flags ;
IENe = IEN (: ,e ); % extrae la conectividad
xe = x( IENe ); % extrae las coordenadas
J = ( xe ( nen ) - xe (1))/2; % calcula el jacobiano
[w , gp ] = gauss ( ngp ); % calcula puntos de Gauss
ke = zeros ( neqe , neqe ); % inicializa la matriz elemental
fe = zeros ( neqe ,1); % inicializa el vector de fuerzas elemental
for i1 = 1: ngp
N = NmatrixBeam ( gp ( i1 ), xe );% Matriz de funciones de forma
% derivada de funciones de forma
B = BmatrixBeam ( gp ( i1 ), xe ) *1/ J ^2;
% Calcula el area de la secci on en los puntos de Gauss
Ae = [N (1) N (3)]* CArea ( IENe );
Ee = E(e ); % calcula el modulo de Young
be = body (e ); % calcula las fuerzas volum etricas
% calcula la matriz de rigidez elemental
ke = ke + w( i1 )*(B '* Ae * Ee *B );
fe = fe + w( i1 )*N '* be; % calcula el vector de fuerzas elemental
end
ke = J* ke ;
fe = J* fe ;
% búsqueda de cargas puntuales en el elemento.
for i1 =1: np % bucle en todas las cargas nodales
Pi = P( i1 ); % extracción de la fuerza
% extracción de la localización de la carga en el elemento
xpi = xp ( i1 );
if xe (1) <= xpi & xpi < xe ( nen )
fe = fe + Pi *[ NmatrixBeam (((2* xpi - xe (1) - xe ( nen ))/...
( xe ( nen )- xe (1))) , xe )] ';
% añade al vector elemental de fuerzas
end
end
function [K ,f] = assembly (K ,f ,e ,ke , fe )
% Ensamblaje de matriz de rigidez y vector de cargas
include_flags ;
for loop1 = 1: nen
i = LM ( loop1 ,e );
f(i) = f(i) + fe ( loop1 );
for loop2 = 1: nen
j = LM ( loop2 ,e );
K(i ,j) = K(i ,j) + ke ( loop1 , loop2 );
end
end

16. P á g i n a | 9
function [d , f_E ] = solvedr (K ,f ,d)
% particiona y resuelve el sistema de ecuaciones
include_flags ;
% particiona K , f y d
K_E = K (1: nd ,1: nd ); % extrae K_E
K_F = K( nd +1: neq , nd +1: neq ); % extrae K_F
K_EF = K (1: nd , nd +1: neq ); % extrae K_EF
f_F = f( nd +1: neq ); % extrae f_F
d_E = d (1: nd ); % extrae d_E
% despeja d_F
d_F = K_F ( f_F - K_EF '* d_E );
% reconstruye d
d = [ d_E
d_F ];
% calcula la reacci on f_E
f_E = K_E * d_E + K_EF *d_F -( f (1: nd ));
% Soluci on por pantalla
solution_vector_d = d
reactions_vector = f_E
function N = NmatrixBeam (s , xe )
% funciones de forma en coordenadas naturales
L= xe (2) - xe (1);
N (1)=1/4*(1 - s )^2*(2+ s );
N (2)= L /8*(1 - s )^2*(1+ s );
N (3)=1/4*(1+ s )^2*(2 - s );
N (4)= L /8*(1+ s )^2*( s -1);
function B = BmatrixBeam (s , xe )
% Derivada de las funciones de forma en coordenadas naturales
L= xe (2) - xe (1);
B (1)=3/2* s;
B (2)= L *(3/4* s -1/4);
B (3)= -3/2* s;
B (4)= L *(3/4* s +1/4);
function f = naturalBC (f );
% calcula el vector de fuerzas relativo al contorno
include_flags ;
for i1 = 1: neq
if flags ( i1 ) == 1
dof = ID ( i1 );
f( dof ) = f( dof ) + n_bc ( dof );
end
end

17. 10 | P á g i n a
function postprocessor (d)
% postproceso
include_flags ;
% bucle en elementos para pintar resultados
for e = 1: nel
de = d( LM (: ,e )); % desplazamientos nodales
IENe = IEN (: ,e ); % conectividad elemental
xe = x( IENe ); % coordenadas elementales
J = ( xe ( nen ) - xe (1))/2; % Jacobiano
[w , gp ] = gauss ( ngp ); % puntos y pesos de Gauss
% calcula desplazamientos , momentos y cortantes
% coordenadas igualmente espaciadas dentro del elemento
xplot = linspace ( xe (1) , xe ( nen ), nplot );
xplotgauss = (2* xplot - xe (1) - xe ( nen ))/( xe ( nen ) - xe (1));
for i1 = 1: nplot
xi = xplotgauss ( i1 ); % coordenada actual
N = NmatrixBeam (xi , xe ); % funciones de forma
B = BmatrixBeam (xi , xe )*1/ J ^2; % primera derivada de las ff
S = SmatrixBeam (xi , xe )*1/ J ^3; % segunda derivada de las ff
Ee = E(e ); % modulo de Young
displacement ( i1 ) = N* de ; % desplazamiento
moment ( i1 ) = Ee *B* de ; % momento
shear ( i1 ) = Ee *S* de ; % cortante
end
% pinta desplazamientos , momentos y cortantes
[ x_plot , S_ex , M_ex , w_ex ] = exact ;
figure (2)
plot ( xplot , displacement , ' -. r '); hold on ;
plot ( x_plot , w_ex , '-k '); legend ( 'EF ',' Solucion exacta ');
hold on ;
ylabel ( ' desplazamiento '); xlabel ( 'x ');
title ( ' Desplazamiento : EF vs . solucion exacta ');
figure (3)
plot ( xplot , moment , ' -. r '); hold on ;
plot ( x_plot , M_ex , '-k '); legend ( 'EF ',' solucion exacta ');
hold on ;
ylabel ( ' momento '); xlabel ( 'x ');
title ( ' momento : EF vs . solucion exacta ');
figure (4)
plot ( xplot , shear , ' -. r '); hold on ;
plot ( x_plot , S_ex , '-k '); legend ( 'EF ',' Solucion exacta ');
hold on ;
ylabel ( ' cortante '); xlabel ( 'x ');
title ( ' Cortante : EF vs . solucion exacta ');
end
function S = SmatrixBeam (s , xe )
% segunda derivada de las ff
L= xe (2) - xe (1);
S (1)=3/2;
S (2)=3/4* L;
S (3)= -3/2;
S (4)= 3/4* L;

18. P á g i n a | 11
Las funciones assembly.m, solvedr.m y gauss.m no necesitan, en principio, ser retocadas y
aceptarán sin problemas los cambios realizados, si fuesen necesarios, en las funciones anteriores.

19. 12 | P á g i n a
Capítulo 4. Estructura del programa disponible para la tracción
compresión.
Las funciones del programa se describen a continuación.
4.1. Bar1D.m
El programa principal o raíz se encuentra en bar1D.m.
%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
% Programa de elementos finitos de barra ( solo axil ) %
% Simulación numérica - Master en Ingeniería Biomédica %
% Universidad de Zaragoza %
%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
clear all ; close all ; clc ;
% Incluimos las variables globales
include_flags ;
% Preproceso
[K ,f ,d] = preprocessor ;
% Ensamblaje de la matriz de rigidez
for e = 1: nel
[ke , fe ] = barelem (e );
[K , f] = assembly (K ,f ,e ,ke , fe );
End
% Vector de fuerzas nodales
f = naturalBC (f );
% Solución
[d , f_E ] = solvedr (K ,f ,d );
% Postproceso
postprocessor (d );
% Representación de la solución exacta
ExactSolution ;
Las flags a que hace referencia la llamada de la función son las siguientes:
% Variables globales
global nsd ndof nnp nel nen neq nd CArea E
global flags ID IEN LM body x y
global xp P ngp xplot n_bc e_bc np
global plot_bar plot_nod nplot
4.2. Prepocessor.m
La función preprocessor.m construye los vectores ID y LM del código. El vector LM proporciona
la numeración global de un grado de libertad (gdl) local. Este vector debe usarse en la siguiente
forma:
𝑔𝑑𝑙 𝑔𝑙𝑜𝑏𝑎𝑙 = 𝐿𝑀 (𝑔𝑑𝑙 𝑙𝑜𝑐𝑎𝑙, 𝑛𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑒𝑙𝑒𝑚𝑒𝑛𝑡𝑜).

20. P á g i n a | 13
El vector ID hace lo propio con las numeraciones originales y renumerada, respectivamente. De
forma que, si se quiere conocer, por ejemplo, cuál es el grado de libertad global después de
renumerar, hay que tener en cuenta:
𝐿𝑀(𝐼, 𝑒) = 𝐼𝐷(𝐼𝐸𝑁(𝐼, 𝑒))
function [K ,f ,d] = preprocessor
% Preproceso
% Lectura de la informaci on del problema
include_flags ;
% Incluimos las variables del problema
input_file_axil ;
% Genera vectores LM y ID
count = 0; count1 = 0;
for i1 = 1: neq
if flags ( i1 ) == 2 % Chequeo si hay contorno esencial
count = count + 1;
% Se numera primero los nodos del contorno esencial
ID ( i1 ) = count ;
% Se almacena reordenado los valores del contorno
d( count ) = e_bc ( i1 );
else
count1 = count1 + 1;
ID ( i1 ) = nd + count1 ;
end
end
for i1 = 1: nel
for j1 = 1: nen
LM (j1,i1) = ID ( IEN (j1 , i1 ));%Creación de la matriz LM
end
end
4.3. input file axil.m
Este fichero incluye la entrada para la resolución del problema de tracción - compresión.
% Datos de entrada para el ejemplo de Axil
nsd = 1; % Número de dimensiones
ndof = 1; % Número de grados de libertad por nodo
%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
% % CASO : 2 ELEMENTOS CUADRATICOS
% nnp = 5; % N umero de nodos
% nel = 2; % N umero de elementos
% nen = 3; % N umero de nodos por elemento
% % CASO : 1 ELEMENTO CUADRATICO
nnp = 3; % N umero de nodos
nel = 1; % N umero de elementos
nen = 3; % N umero de nodos por elemento
% % CASO : 4 ELEMENTOS LINEALES
% nnp = 5; % N umero de nodos
% nel = 4; % N umero de elementos
% nen = 2; % N umero de nodos por elemento

21. 14 | P á g i n a
%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
neq = ndof * nnp ; % Número de ecuaciones
f = zeros (neq ,1); % Se inicializa el vector de fuerzas
d = zeros (neq ,1); % Se inicializan los desplazamientos nodales
K = zeros ( neq ); % Se inicializa la matriz de rigidez
flags = zeros (neq ,1); % Se inicializa el vector de banderas
e_bc = zeros (neq ,1); % Se inicializa el vector de BCs esenciales
n_bc = zeros (neq ,1); % Se inicializa el vector de BCs naturales
% Datos elementos y material ( Por elemento )
E = 8* ones (nnp ,1); % M odulo de Young
body = 8* ones (nnp ,1); % Valores nodales de fuerzas volum etricas
%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
% % CASO : 2 ELEMENTOS CUADRATICOS
% CArea = [4 7 10 11 12] '; % Valores nodales de area = 2 X
% CASO : 1 ELEMENTO CUADRATICO
CArea = [4 8 12] '; % Valores nodales de area = 2 X
% % CASO : 4 ELEMENTOS LINEALES
% CArea = [4 6 8 10 12] '; % Valores nodales de area = 2 X
%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
% Integración nodal - gauss
ngp = 2; % Número de puntos de integración
%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
% % CASO : 2 ELEMENTOS CUADRATICOS
% % BCs esenciales
% flags (1) = 2; % Marcación de nodos del BC esencial
% e_bc (1) = 0; % Valor de la condición de contorno
% nd = 1; % Número de nodos del contorno esencial
% % BCs naturales
% flags (5) = 1; % Marcación de nodos del BC natural
% n_bc (5) = 0; % Valor de la condición de contorno
% CASO : ELEMENTO CUADRATICO
% BCs esenciales
flags (1) = 2; % Marcación de nodos del BC esencial
e_bc (1) = 0; % Valor de la condición de contorno
nd = 1; % Número de nodos del contorno esencial
% BCs naturales
flags (3) = 1; % Marcación de nodos del BC natural
n_bc (3) = 0; % Valor de la condición de contorno
% % CASO : 4 ELEMENTOS LINEALES
% flags (1) = 2; % Marcación de nodos del BC esencial
% e_bc (1) = 0; % Valor de la condición de contorno
% nd = 1; % Número de nodos del contorno esencial
% % BCs naturales
% flags (5) = 1; % Marcación de nodos del BC natural
% n_bc (5) = 0; % Valor de la condición de contorno

22. P á g i n a | 15
%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
% Fuerzas
P = 24; % Vector de fuerzas puntuales
xp = 5; % Coordenadas donde se aplica la fuerza
np = 1; % Número de puntos con fuerza puntual
% Represetación
plot_bar = 'yes ';
plot_nod = 'yes ';
% No . puntos por elemento para representar desplazamiento y tensión
nplot = nnp *10;
% Generación de la malla
bar_mesh_axil ;
4.4. Otras funciones.
function bar_mesh_axil
include_flags ;
%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
% CASO : 2 ELEMENTOS CUADRATICOS ( de 3 nodos )
% Nodos : 1 2 3 4 5
% x = [2.0 3.5 5.0 5.5 6.0]; % Coordenada x
% y = 2* x; % Y se usa solo para representación
% IEN = [1 3; 2 4; 3 5]; % Vector de conectividades
% CASO : 1 ELEMENTO CUADRATICO ( de 3 nodos )
% Nodos : 1 2 3
x = [2.0 4.0 6.0]; % Coordenada x
y = 2* x; % Y se usa solo para representación
IEN = [1; 2; 3]; % Vector de conectividades
% % CASO : 4 ELEMENTOS LINEALES
% Nodos : 1 2 3 4 5
% x = [2.0 3.0 4.0 5.0 6.0]; % Coordenada x
% y = 2* x; % Y se usa solo para representación
% IEN = [1 2 3 4; 2 3 4 5]; % Vector de conectividades
%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
%% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
plotbar ;
function [ke , fe ] = barelem (e)
% Genera matriz de rigidez elemental y vector de fuerzas elemental
include_flags ;
IENe = IEN (: ,e ); % Informaci on conectividad local
xe = x( IENe ); % Coordenadas X del elemento
J = ( xe ( nen ) - xe (1))/2; % Jacobiano
[w , gp ] = gauss ( ngp ); % Pesos y puntos de Gauss
ke = zeros (nen , nen );
fe = zeros (nen ,1);

23. 16 | P á g i n a
for i1 = 1: ngp
% Punto de Gauss en coordenadas f sicas
xt = 0.5*( xe (1)+ xe ( nen ))+ J* gp ( i1 );
N = Nmatrix1D (xt , xe ); % Matriz de funciones de forma
B = Bmatrix1D (xt , xe ); % Matriz de derivadas
Ae = N* CArea ( IENe ); %Área de la sección en el punto de Gauss
Ee = N*E( IENe ); % M odulo de Young
be = N* body ( IENe ); % Fuerza volumétrica en el punto de Gauss
ke = ke + w( i1 )*(B '* Ae * Ee *B );% Matriz de rigidez elemental
% Vector de fuerzas volum etricas elementales
fe = fe + w( i1 )*N '* be ;
end
ke = J* ke ;
fe = J* fe ;
% Chequeo de fuerzas puntuales en este elemento
for i1 =1: np
Pi = P( i1 );
xpi = xp ( i1 );
if xe (1) <= xpi & xpi < xe ( nen )
% Se a~ nade al vector de fuerzas
fe = fe + Pi *[ Nmatrix1D (xpi , xe )] ';
end
end
function N = Nmatrix1D (xt , xe )
% Funciones de forma en coordenadas f sicas
include_flags ;
if nen == 2 % Funciones de forma lineales
N (1) = (xt - xe (2))/( xe (1) - xe (2));
N (2) = (xt - xe (1))/( xe (2) - xe (1));
elseif nen == 3 % Funciones de forma cuadr aticas
N (1)=( xt - xe (2))*( xt - xe (3))/(( xe (1) - xe (2))*( xe (1) - xe (3)));
N (2)=( xt - xe (1))*( xt - xe (3))/(( xe (2) - xe (1))*( xe (2) - xe (3)));
N (3)=( xt - xe (1))*( xt - xe (2))/(( xe (3) - xe (1))*( xe (3) - xe (2)));
end
function B = Bmatrix1D (xt , xe )
% Derivadas de funciones de forma en coordenadas f sicas
include_flags ;
if nen == 2 % Funciones de forma lineales - derivada constante
B = 1/( xe (1) - xe (2))*[ -1 1];
elseif nen == 3 % Derivada de funciones de forma cuadráticas
B (1)=(2* xt - xe (2) - xe (3))/(( xe (1) - xe (2))*( xe (1) - xe (3)));
B (2)=(2* xt - xe (1) - xe (3))/(( xe (2) - xe (1))*( xe (2) - xe (3)));
B (3)=(2* xt - xe (1) - xe (2))/(( xe (3) - xe (1))*( xe (3) - xe (2)));
end
function f = naturalBC (f)
% C alculo y ensamblaje del vector de fuerzas
include_flags ;
for i1 = 1: nnp
if flags ( i1 ) == 1
node = ID ( i1 );
f( node ) = f( node ) + CArea ( node )* n_bc ( node );
end
end

24. P á g i n a | 17
function [w , gp ] = gauss ( ngp )
% Puntos de gauss y pesos para elemento de referencia [ -1 , 1]
if ngp == 1
gp = 0;
w = 2;
elseif ngp == 2
gp = [ -0.57735027 , 0.57735027];
w = [1 , 1];
elseif ngp == 3
gp = [ -0.7745966692 , 0.7745966692 , 0.0];
w = [0.5555555556 , 0.5555555556 , 0.8888888889];
end
function [K ,f] = assembly (K ,f ,e ,ke , fe )
% Ensamblaje de matriz de rigidez y vector de cargas
include_flags ;
for loop1 = 1: nen
i = LM ( loop1 ,e );
f(i) = f(i) + fe ( loop1 );
for loop2 = 1: nen
j = LM ( loop2 ,e );
K(i ,j) = K(i ,j) + ke ( loop1 , loop2 );
end
end
function postprocessor (d)
% postproceso
include_flags ;
fprintf (1 , 'n Tensiones en los puntos de Gauss n ');
fprintf (1 , ' Elemento tt x( gauss1 ) tt x( gauss2 ) tt ...
tension ( gauss1 ) tt tension ( gauss2 ) n ');
fprintf (1 , ' ---------------------------------------------------...
------------------------------ n ');
for e = 1: nel
% C alculo de desplazamiento y tension en cada elemento
disp_and_stress (e ,d );
end
function disp_and_stress (e ,d)
% cálculo de desplazamiento y tensión
include_flags ;
de = d( LM (: ,e )); % Desplazamiento nodal
IENe = IEN (: ,e ); % Conectividad
xe = x( IENe ); % Coordenadas nodos
J = ( xe ( nen ) - xe (1))/2; % Jacobiano
[w , gp ] = gauss ( ngp ); % Puntos de Gauss
% C alculo de tensi on en puntos de gauss
for i1 = 1: ngp
% Punto de Gauss en coordenadas f sicas
xt = 0.5*( xe (1)+ xe ( nen ))+ J* gp ( i1 );
gauss_pt ( i1 ) = xt ;
N = Nmatrix1D (xt , xe ); % Funci on de forma
B = Bmatrix1D (xt , xe ); % Derivadas

25. 18 | P á g i n a
Ee = N*E( IENe ); % M odulo de Young
stress_gauss ( i1 ) = Ee *B* de ;
end
% Tensi on por elemento en puntos de Gauss
fprintf (1 , ' %dttt %fttt %fttt %fttt %fn ',e , gauss_pt (1) ,...
gauss_pt (2) , stress_gauss (1) , stress_gauss (2));
% C alculo de desplazamiento y tensi on
xplot = linspace ( xe (1) , xe ( nen ), nplot );
for i1 = 1: nplot
xi = xplot ( i1 );
N = Nmatrix1D (xi , xe );
B = Bmatrix1D (xi , xe );
Ee = N*E( IENe );
displacement ( i1 ) = N* de ;
stress ( i1 ) = Ee *B* de ;
end
% Representaci on
figure (2); subplot (2 ,1 ,1);
plot ( xplot , displacement ); legend ( 'sdf '); hold on ;
ylabel ( ' displacement '); title ( 'FE analysis of 1D bar ');
subplot (2 ,1 ,2); plot ( xplot , stress ); hold on ;
ylabel ( ' stress '); xlabel ( 'x ');
legend ( 'FE ');
function ExactSolution
% Representa la tensión exacta
include_flags ;
% Divide la regi on del problema en dos regiones
xa = 2:0.01:5;
xb = 5:0.01:6;
subplot (2 ,1 ,1);
% Desplazamiento exacto para xa
c1 = 72; c2 = 1 - ( c1 /16)* log (2);
u1 = -.5* xa + ( c1 /16)* log ( xa ) + c2 ;
% Desplazamiento exacto para xb
c3 = 48; c4 = log (5)/16*( c1 - c3 ) + c2 ;
u2 = -.5* xb + ( c3 /16)* log ( xb ) + c4 ;
% Representaci on del desplazamiento
h = plot ([ xa xb ] ,[ u1 u2 ], '--r ' );
legend (h , ' exact ');
subplot (2 ,1 ,2);
% tensión exacta para xa
ya = (36 -4* xa )./ xa ;
% tensión exacta para xb
yb = (24 -4* xb )./ xb ;
% representación de la tensión
plot ([ xa xb ] ,[ ya yb ], '--r ' );

26. P á g i n a | 19
Capítulo 5. Entregables.
El alumno, bien de forma individual o bien por parejas, entregar a los siguientes resultados:
1. Código modificado (empaquetar todos los ficheros en un mismo archivo .zip).
2. Desplazamiento sufrido por cada nodo de la estructura de la Fig. 5.

27. 20 | P á g i n a
Capítulo 6. Modo de trabajo recomendado.
Se recomienda encarecidamente que, antes de generar el programa unificado, se estudie a fondo
la modificación que ser a necesaria establecer en el programa final . Para ello lo mejor ser a que
el alumno desarrollase analíticamente (como se ha hecho en clase) la solución del problema
propuesto. La principal modificación final radicará en la matriz de rigidez del elemento, que será
ahora de tamaño 6x6 en vez de 4x4 para el problema de flexión o de 2x2 para el de axil, que se
corresponden precisamente a los desplazamientos a lo largo del eje de la barra, relacionados con
el esfuerzo axil.
Como ayuda adicional se proporciona la matriz de giro (Fig. 7) para una barra a flexión y axil,
puesto que el problema propuesto incorpora cuatro barras verticales (Fig. 8).
Figura 7. Matriz de giro elemental.
Figura 8. Elemento a formular, en posición genérica.

28. P á g i n a | 21
Capítulo 7. Referencias.
[1] J. Fish and T. Belytschko. A first course in Finite Elements. John Wiley & Sons, LTD., 2007.

29. 22 | P á g i n a
Capítulo 8. Resultados.
8.1. Resultados obtenidos.
Al iniciar el programa obtenemos:
Parámetros
No. de elementos 6
No. de nodos 6
No. de ecuaciones 18

30. P á g i n a | 23
8.1.1. Solución al vector de desplazamiento
solution_vector_d =
0
0
0
0
0
0
0.0022
-0.0037
-0.0009
0.0054
-0.0053
-0.0008
0.0066
-0.0019
-0.0013
0.0027
-0.0011
-0.0012
Lo que equivale a:
𝑢 𝑥
1
𝑢 𝑦
1
𝜃1
𝑢 𝑥
2
𝑢 𝑦
2
𝜃2
𝑢 𝑥
3
𝑢 𝑦
3
𝜃3
𝑢 𝑥
4
𝑢 𝑦
4
𝜃4
𝑢 𝑥
5
𝑢 𝑦
5
𝜃5
𝑢 𝑥
6
𝑢 𝑦
6
𝜃6
=
0′0000
0′0000
0′0000
0′0022
−0′0037
−0′0009
0′0054
−0′0053
−0′0008
0′0066
−0′0019
−0′0013
0′0027
−0′0011
−0′0012
0′0000
0′0000
0′0000

31. 24 | P á g i n a
Resultados a priori coherentes en signo y orden de magnitud. (mm)
En el eje X la estructura se desplaza hacia la derecha (por eso son (+))
En el eje Y la estructura se desplaza hacia abajo (se comprime (-))
Los giros son a favor de las agujas del reloj (-), lo que tiene sentido por el valor de las
cargas en Y.
8.1.2. Vector de reacciones.
reactions_vector =
-4.0689
12.2941
8.9753
-3.9311
3.7059
9.8483
Lo que equivale a:
𝑓𝑥
1
𝑓𝑦
1
𝑀𝑧
1
𝑓𝑥
6
𝑓𝑦
6
𝑀𝑧
6
=
−4′0689 𝑘𝑁
12′
2941𝑘𝑁
8′9753 𝑘𝑁𝑚
−3′9311 𝑘𝑁
3′
7059 𝑘𝑁
9′8483 𝑘𝑁𝑚

32. P á g i n a | 25
Capítulo 9. Código final: Pórtico Plano
9.1. Trabajo final: Pórtico Plano.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Programa de elementos finitos de barra (Pórtico Plano)%
% %
% Simulación numérica - Master en Ingeniería Biomédica %
% Universidad de Zaragoza %
% Marcos J. Hernández Gil. 2017-2018 %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
clear all;
close all;
clc;
include_flags; % incluye las variables globales
[K,f,d] = preprocessor; % Preproceso
% Calculo de matrices elementales y ensamblado
for e = 1:nel
[keF,feF] = beamelem(e);
[keA,feA] = barelem(e);
Ke=zeros(6); % se supone que ya está definida en
input_file_flexion
fe=zeros(6,1); % se supone que ya está definida en
input_file_flexion
[Ke, fe] = assemblylocal(Ke,fe,e,keF,feF,keA,feA);
[K, f] = assembly(K,f,e,Ke,fe);
end
f = naturalBC(f); % Vector de fuerzas en el contorno
[d,f_E] = solvedr(K,f,d); % Particion y solucion
%postprocessor(d); % Postproceso
fprintf(1,'Fin de la simulaciónn');
A continuación, analizaremos las distintas partes del código.
9.1.1. Include_flags;
% Include global variables
global nsd ndof nnp nel nen neq nd CArea E I
global flags ID IEN LM body x y
global xp P ngp xplot n_bc e_bc np
global plot_bar plot_beam plot_nod nplot Vang
global L beA

33. 26 | P á g i n a
9.1.2. [K,f,d] = preprocessor
function [K,f,d] = preprocessor
include_flags;
input_file_flexion; % fichero de entrada con todas las variables
count = 0; count1 = 0; % generar el vector LM
for i1 = 1:neq
if flags(i1) == 2 % mira si hay una condicion esencial
count = count + 1;
ID(i1) = count; % primero los gdl en el contorno esencial
d(count)= e_bc(i1); % guarda los gdl reordenados
else
count1 = count1 + 1;
ID(i1) = nd + count1;
end
end
for e = 1:nel
for j1 = 1:nen
for m = 1:ndof
ind = (j1-1)*ndof + m;
LM(ind,e) = ID(ndof*IEN(j1,e) - ndof + m); % crea la
matriz LM
end
end
end
9.1.2.1. input_file_flexion;
nsd = 2; % numero de dimensiones espaciales 2 o 3 ¿?¿?
ndof= 3; % grados de libertad por nodo
nnp = 6; % numero de nodos globales
nel = 6; % numero de elementos
nen = 2; % numero de nodos en cada elementos
neq = ndof*nnp; % numero de ecuaciones 3·6 = 18 -> 18x18
neqe = ndof*nen; % numero de ecuaciones para cada elemento 3·2=6 ->
6x6
f = zeros(neq,1); % inicializa el vector de fuerzas
d = zeros(neq,1); % inicializa el vector de desplazamientos
K = zeros(neq); % inicializa la matriz de rigidez
Ke = zeros(ndof*nen); % Matriz de rigidez ensamblada LOCAL
fe = zeros(ndof*nen,1); %vector de fuerzas ensamblada LOCAL
flags = zeros(neq,1); % inicializa el vector de banderas
e_bc = zeros(neq,1); % inicializa el vector de bcs esenciales
n_bc = zeros(neq,1); % inicializa el vector de bcs naturales
% propiedades del elemento
CArea = [1 1 1 1 1 1]'; % area de la seccion transversal
I=[1 1 1 1 1 1]';
leng = [3 3 4 3 4 3]; % longitud del elemento *
body = [0 0 -2 0 -2 0]'; % fuerzas por u. de longitud *
beA=zeros(1,6);
% En el elemento 3 y en el elmento 5
Vang=[pi/2 pi/2 0 pi/2 0 pi/2];
E = [1e4 1e4 1e4 1e4 1e4 1e4] ; % modulo de Young (Cte) *

34. P á g i n a | 27
% integracion de Gauss
ngp = 2; % numero de puntos
% condiciones esenciales de contorno
flags(1) = 2; % Bandera que marca los gdl en el contorno esencial
flags(2) = 2; % Bandera que marca los gdl en el contorno esencial
flags(3) = 2; % Bandera que marca los gdl en el contorno esencial
flags(16)= 2; % Bandera que marca los gdl en el contorno esencial
flags(17)= 2; % Bandera que marca los gdl en el contorno esencial
flags(18)= 2; % Bandera que marca los gdl en el contorno esencial
e_bc(1) = 0; % valor del desplazamiento x prescrito
e_bc(2) = 0; % valor del desplazamiento y prescrito
e_bc(3) = 0; % valor del giro O prescrito
e_bc(16) = 0; % valor del desplazamiento x prescrito
e_bc(17) = 0; % valor del desplazamiento y prescrito
e_bc(18) = 0; % valor del giro O prescrito
nd = 6; % numero de grados de libertad en el contorno esencial
% CC naturales
flags(10) = 1; % Bandera que marca los gdl en el contorno natural
n_bc(10) = 4; % valor de la fuerza x nodo 4
flags(13) = 1; % Bandera que marca los gdl en el contorno natural
n_bc(13) = 4; % valor de la fuerza x nodo 5
% Cargas puntuales (Este apartado ya no haría falta ?)
%P = [4 4]'; % vector de cargas puntuales
%xp = [0 0]'; % vector con las coordenadas de aplicacion de las
fuerzas
%yp = [3 6]';
%np = 2; % numero de cargas puntuales
% control de la salida
plot_beam = 'yes';
plot_nod = 'yes';
% generacion de la malla
beam_mesh_flexion;
%numero de puntos a pintar
nplot=300;

35. 28 | P á g i n a
9.1.2.1.1. beam_mesh_flexion
function beam_mesh_flexion
include_flags;
% Nodos: 1 2 3 4 5 6 (origen en el nodo 6)
%--------------------
x = [4.0 4.0 4.0 0.0 0.0 0.0]; % X coordinate
y = [0.0 3.0 6.0 6.0 3.0 0.0]; % Y coordinate
% vector de conectividad
IEN = [1 2;2 3;4 3;5 4;5 2;6 5]';
% pintar la barra
plotbeam;
9.1.2.1.1.1. Plotbeam;
function plotbeam
include_flags;
% mira si el usuario ha escogido pintar la barra
if strcmpi(plot_beam,'yes')==1
for i1 = 1:nel
XX = [x(IEN(:,i1)) x(IEN(1,i1))];
YY = [y(IEN(:,i1)) y(IEN(1,i1))];
line(XX,YY);hold on;
%line(XX,-YY);hold on;
plot(XX,YY , '+r');
% mira si el usuario ha escogido pintar la numeraci—n
global
if strcmpi(plot_nod,'yes')==1
for j1=1:size(IEN,1)
text(XX(j1),YY(j1),sprintf('%0.5g',IEN(j1,i1)));
end
end
end
title('Grafico de la barra');
end
% pinta los parametro de la malla
fprintf(1,'Par‡metros n');
fprintf(1,'No. de elementos %d n',nel);
fprintf(1,'No. de nodos %d n',nnp);
fprintf(1,'No. de ecuaciones %d nn',neq);

36. P á g i n a | 29
9.1.3. Beamelem
% genera la matriz de rigidez de cada elemento
function [keF, feF] = beamelem(e)
include_flags;
IENe = IEN(:,e); % extrae la conectividad
xe = x(IENe).*cos(Vang(e)) + y(IENe).*sin(Vang(e));
% extrae las coordenadas
J = (xe(nen) - xe(1))/2; % calcula el jacobiano
[w , gp] = gauss(ngp); % calcula puntos de Gauss
keF = zeros(4,4); % inicializa la matriz elemental
feF = zeros(4,1); % inicializa el vector de fuerzas
elemental
for i1 = 1:ngp
N = NmatrixBeam(gp(i1),xe); % Matriz de funciones de forma
B = BmatrixBeam(gp(i1),xe) *1/J^2;
% derivada de las funciones de forma
Ie = I(e); %[N(1) N(3)]*CArea(IENe); %Calcula el area de la
seccion en los puntos de Gauss
Ee = E(e); % calcula el modulo de
Young
%Ie = I(e); %Inercia de la barra
be = body(e); % calcula las fuerzas
volumetricas
keF = keF + w(i1)*(B'*Ie*Ee*B); % calcula la matriz de
rigidez elemental
feF = feF + w(i1)*N'*be; % calcula el vector de
fuerzas elemental
end
keF = J*keF;
feF = J*feF;
% busqueda de cargas puntuales en el elemento
for i1=1:np % bucle en todas las cargas nodales
Pi = P(i1); % extraccion de la fuerza
xpi = xp(i1); % extraccion de la localizacion de la carga
en el elemento
if xe(1)<=xpi & xpi<xe(nen)
feF = feF + Pi*[NmatrixBeam( ( (2*xpi-xe(1)-xe(nen))/(xe(nen)
- xe(1)) ) ,xe)]';
% anade al vector elemental de fuerzas
end
end
9.1.3.1.NmatrixBeam
% funciones de forma en coordenadas naturales
function N = NmatrixBeam(s,xe)
L=xe(2)-xe(1);
N(1)=1/4*(1-s)^2*(2+s);
N(2)=L/8*(1-s)^2*(1+s);
N(3)=1/4*(1+s)^2*(2-s);
N(4)=L/8*(1+s)^2*(s-1);
9.1.3.2. BmatrixBeam
% Derivada de las funciones de forma en coordenadas naturales
function B = BmatrixBeam(s,xe,L)

37. 30 | P á g i n a
L=xe(2)-xe(1);
B(1)=3/2*s;
B(2)=L*(3/4*s-1/4);
B(3)=-3/2*s;
B(4)= L*(3/4*s+1/4);
9.1.4. Barelem.m
function [keA, feA] = barelem(e)
% Genera matriz de rigidez elemental y vector de fuerzas elemental
include_flags;
IENe = IEN(:,e); % Información conectividad local
xe = x(IENe).*cos(Vang(e)) + y(IENe).*sin(Vang(e)); % Coordenadas X
del elemento
J = (xe(nen) - xe(1))/2; % Jacobiano
[w , gp] = gauss(ngp); % Pesos y puntos de Gauss
keA = zeros(nen,nen);
feA = zeros(nen,1);
for i1 = 1:ngp
xt = 0.5*(xe(1)+xe(nen))+J*gp(i1); % Punto de Gauss en coordenadas
físicas
N = Nmatrix1D(xt,xe); % Matriz de funciones de forma
B = Bmatrix1D(xt,xe); % Matriz de derivadas
Ae = N*CArea(IENe); % Área de la sección en el punto de Gauss
Ee =E(e); %N*E(IENe); Módulo de Young
be = N*body(IENe); % Fuerza volumétrica en el punto de Gauss
keA = keA + w(i1)*(B'*Ae*Ee*B); % Matriz de rigidez elemental
feA = feA + w(i1)*N'*beA; % Vector de fuerzas volumétricas
elementales
end
keA = J*keA;
feA = J*feA;
% Chequeo de fuerzas puntuales en este elemento
for i1=1:np
Pi = P(i1);
xpi = xp(i1);
if xe(1)<=xpi & xpi<xe(nen)
feA = feA + Pi*[Nmatrix1D(xpi,xe)]'; % Se añade al vector de
fuerzas
end
end
9.1.4.1. Nmatrix1D
% shape functions computed in the physical coordinate - xt
function N = Nmatrix1D(xt,xe)
include_flags;
if nen == 2 % linear shape functions
N(1) = (xt-xe(2))/(xe(1)-xe(2));
N(2) = (xt-xe(1))/(xe(2)-xe(1));
elseif nen == 3 % quadratic shape functions
N(1)=(xt-xe(2))*(xt-xe(3))/((xe(1)-xe(2))*(xe(1)-xe(3)));
N(2)=(xt-xe(1))*(xt-xe(3))/((xe(2)-xe(1))*(xe(2)-xe(3)));
N(3)=(xt-xe(1))*(xt-xe(2))/((xe(3)-xe(1))*(xe(3)-xe(2)));
end

38. P á g i n a | 31
9.1.4.2. Bmatrix1D
function B = Bmatrix1D(xt,xe)
% Derivadas de funciones de forma en coordenadas físicas
include_flags;
if nen == 2 % Funciones de forma lineales - derivada constante
B = 1/(xe(1)-xe(2))*[-1 1];
elseif nen == 3 % Derivada de funciones de forma cuadráticas
B(1)=(2*xt-xe(2)-xe(3))/((xe(1)-xe(2))*(xe(1)-xe(3)));
B(2)=(2*xt-xe(1)-xe(3))/((xe(2)-xe(1))*(xe(2)-xe(3)));
B(3)=(2*xt-xe(1)-xe(2))/((xe(3)-xe(1))*(xe(3)-xe(2)));
end
9.1.5. Assemblylocal.m
function [Ke,fe] = assemblylocal(Ke,fe,e,keF,feF,keA,feA)
% Ensambla la matriz de rigidez local y el vector de fuerzas
include_flags;
%Otra forma de hacerlo más reducido..
%Ke=zeros(6);
%indices=[1,4];
%Ke(indices, indices)= keA;
%indices=[2,3,5,6];
%ke(indices, indices)= keF;
%Matriz de Rotación rt.
a=Vang(e);
r0=zeros(3);
r1=[+cos(a) -sin(a) 0; +sin(a) cos(a) 0; 0 0 1];
rt=[r1 r0; r0 r1];
%Ke=zeros(6);
Ke(1,1)=keA(1,1);
Ke(4,4)=keA(2,2);
Ke(1,4)=keA(1,2);
Ke(4,1)=keA(2,1);
%k1
Ke(2,2)=keF(1,1);
Ke(2,3)=keF(1,2);
Ke(3,2)=keF(2,1);
Ke(3,3)=keF(2,2);
%k2
Ke(2,5)= keF(1,3);
Ke(2,6)= keF(1,4);
Ke(3,5)= keF(2,3);
Ke(3,6)= keF(2,4);
%K3
Ke(5,2)= keF(3,1);
Ke(5,3)=keF(3,2);
Ke(6,2)=keF(4,1);
Ke(6,3)=keF(4,2);
%K4
Ke(5,5)= keF(3,3);
Ke(5,6)=keF(3,4);
Ke(6,5)=keF(4,3);

39. 32 | P á g i n a
Ke(6,6)=keF(4,4);
%fe
fe(1)= feA(1);
fe(2)= feF(1);
fe(3)= feF(2);
fe(4)= feA(2);
fe(5)= feF(3);
fe(6)= feF(4);
%coordenadas locales, Ke en globales.:
Ke=rt*Ke*rt';
9.1.6. Assembly.m
function [K,f] = assembly(K,f,e,Ke,fe)
% Ensambla la matriz de rigidez global y el vector de fuerzas
include_flags;
for loop1 = 1:nen*ndof
i = LM(loop1,e);
f(i) = f(i) + fe(loop1); % vector de fuerzas
for loop2 = 1:nen*ndof
j = LM(loop2,e);
K(i,j) = K(i,j) + Ke(loop1,loop2);
end
end
9.1.7. naturalIBC
% calcula el vector de fuerzas relativo al contorno
function f = naturalBC(f);
include_flags;
for i1 = 1:neq
if flags(i1) == 1
dof = ID(i1);
f(dof) = f(dof) + n_bc(i1); %n_bc(i1)
end
end
9.1.8. Solvedr.m
function [d,f_E] = solvedr(K,f,d)
% particiona y resuelve el sistema de ecuaciones
include_flags;
% particiona K, f y d
K_E = K(1:nd,1:nd); % extrae K_E
K_F = K(nd+1:neq,nd+1:neq); % extrae K_F
K_EF = K(1:nd,nd+1:neq); % extrae K_EF
f_F = f(nd+1:neq); % extrae f_F
d_E = d(1:nd); % extrae d_E
% despeja d_F
d_F =K_F( f_F - K_EF'* d_E);
% reconstruye d
d = [d_E
d_F];

40. P á g i n a | 33
% calcula la reaccion f_E
f_E = K_E*d_E+K_EF*d_F-(f(1:nd));
% escribe en el workspace
solution_vector_d = d
reactions_vector = f_E
Para la comprobación de la matriz de rigidez ensamblada, hemos obtenido los valores de las
matrices elementales y ensamblarla manualmente, obteniéndose:
Elemento 1
k1 1 2
1
0,44 0,00 -0,67 -0,44 0,00 -0,67
0,00 0,33 0,00 0,00 -0,33 0,00
-0,67 0,00 1,33 0,67 0,00 0,67
2
-0,44 0,00 0,67 0,44 0,00 0,67
0,00 -0,33 0,00 0,00 0,33 0,00
-0,67 0,00 0,67 0,67 0,00 1,33
Elemento 2 2 3
2
0,44 0,00 -0,67 -0,44 0,00 -0,67
0,00 0,33 0,00 0,00 -0,33 0,00
-0,67 0,00 1,33 0,67 0,00 0,67
3
-0,44 0,00 0,67 0,44 0,00 0,67
0,00 -0,33 0,00 0,00 0,33 0,00
-0,67 0,00 0,67 0,67 0,00 1,33
Elemento 3 3 4
3
0,25 0,00 0,00 -0,25 0,00 0,00
0,00 0,19 -0,38 0,00 -0,19 -0,38
0,00 -0,38 1,00 0,00 0,38 0,50
4
-0,25 0,00 0,00 0,25 0,00 0,00
0,00 -0,19 0,38 0,00 0,19 0,38
0,00 -0,38 0,50 0,00 0,38 1,00
Elemento 4 4 5
3
0,44 0,00 0,67 -0,44 0,00 0,67
0,00 0,33 0,00 0,00 -0,33 0,00
0,67 0,00 1,33 -0,67 0,00 0,67
4
-0,44 0,00 -0,67 0,44 0,00 -0,67
0,00 -0,33 0,00 0,00 0,33 0,00
0,67 0,00 0,67 -0,67 0,00 1,33

41. 34 | P á g i n a
Elemento 5 5 2
5
-0,25 0,00 0,00 0,25 0,00 0,00
0,00 -0,19 -0,38 0,00 0,19 -0,38
0,00 -0,38 -1,00 0,00 0,38 -0,50
2
0,25 0,00 0,00 0,25 0,00 0,00
0,00 0,19 0,38 0,00 -0,19 0,38
0,00 -0,38 -0,50 0,00 0,38 -1,00
Elemento 6 5 6
5
0,44 0,00 0,67 -0,44 0,00 0,67
0,00 0,33 0,00 0,00 -0,33 0,00
0,67 0,00 1,33 -0,67 0,00 0,67
6
-0,44 0,00 -0,67 0,44 0,00 -0,67
0,00 -0,33 0,00 0,00 0,33 0,00
0,67 0,00 0,67 -0,67 0,00 1,33
1 6 2 3 4 5
1
0,44 0,00 -0,67 -0,44 0,00 -0,67
0,00 0,33 0,00 0,00 -0,33 0,00
-0,67 0,00 1,33 0,67 0,00 0,67
6
0,44 0,00 -0,67 -0,44 0,00 -0,67
0,00 0,33 0,00 0,00 -0,33 0,00
-0,67 0,00 1,33 0,67 0,00 0,67
2
-0,44 0,00 0,67 1,13 0,00 0,00 -0,44 0,00 -0,67 0,25 0,00 0,00
0,00 -0,33 0,00 0,00 0,85 -0,38 0,00 -0,33 0,00 0,00 -0,19 0,38
-0,67 0,00 0,67 0,00 0,38 3,66 0,67 0,00 0,67 0,00 -0,38 0,50
3
-0,44 0,00 0,67 0,69 0,00 0,67 -0,25 0,00 0,00
0,00 -0,33 0,00 0,00 0,52 -0,38 0,00 -0,19 -0,38
-0,67 0,00 0,67 0,67 -0,38 2,33 0,00 0,38 0,50
4
-0,25 0,00 0,00 0,69 0,00 0,67 -0,44 0,00 0,67
0,00 -0,19 0,38 0,00 0,52 0,38 0,00 -0,33 0,00
0,00 -0,38 0,50 0,67 0,38 2,33 -0,67 0,00 0,67
5
-0,44 0,00 0,67 0,25 0,00 0,00 -0,44 0,00 -0,67 1,13 0,00 0,00
0,00 -0,33 0,00 0,00 -0,19 0,38 0,00 -0,33 0,00 0,00 0,85 0,38
-0,67 0,00 0,67 0,00 -0,38 0,50 0,67 0,00 0,67 0,00 0,38 3,66
Este valor se ha comprobado con lo que da el programa y ha salido satisfactorio.
NOTA: Se ha sacado factor común (104
) en todos los valores de K, por comodidad.

42. P á g i n a | 35
Además se ha utilizado como comprobación adicional el programa MEFI. Obteniéndose los
mismos valores.

43. 36 | P á g i n a
En resumen, se ha obtenido la siguiente matriz de rigidez

44. P á g i n a | 37
1 2 3 4 5 6
1
0,44 0,00 -0,67 -0,44 0,00 -0,67
0,00 0,33 0,00 0,00 -0,33 0,00
-0,67 0,00 1,33 0,67 0,00 0,67
2
-0,44 0,00 0,67 1,13 0,00 0,00 -0,44 0,00 -0,67 0,25 0,00 0,00
0,00 -0,33 0,00 0,00 0,85 -0,37 0,00 -0,33 0,00 0,00 -0,18 0,38
-0,67 0,00 0,67 0,00 -0,37 3,66 0,67 0,00 0,67 0,00 -0,38 0,50
3
-0,44 0,00 0,67 0,69 0,00 0,67 -0,25 0,00 0,00
0,00 -0,33 0,00 0,00 0,52 -0,37 0,00 k34 -0,38
-0,67 0,00 0,67 0,67 -0,37 2,33 0,00 0,38 0,50
4
-0,25 0,00 0,00 0,69 0,00 0,67 -0,44 0,00 0,67
0,00 -0,18 0,38 0,00 0,52 0,38 0,00 -0,33 0,00
0,00 -0,38 0,50 0,67 0,38 2,33 -0,67 0,00 0,67
5
0,25 0,00 0,00 -0,44 0,00 -0,67 1,13 0,00 0,00 -0,44 0,00 0,67
0,00 -0,18 0,38 0,00 -0,33 0,00 0,00 0,85 0,38 0,00 -0,33 0,00
0,00 -0,38 0,50 0,67 0,00 0,67 0,00 0,38 3,66 -0,67 0,00 0,67
6
-0,44 0,00 -0,67 0,44 0,00 -0,67
0,00 -0,33 0,00 0,00 0,33 0,00
0,67 0,00 0,67 -0,67 0,00 1,33
Se ha tenido que reordenar la matriz, para tener el mismo orden de los valores de MATLAB.
Como resultados obtenemos:

45. 38 | P á g i n a
Podemos observar que los valores obtenidos son iguales a los que ofrece MEFI (Arriba las
reaxiones en el nodo 1, abajo las reacciones en el nodo 6).
reactions_vector =
-4’0689 12’2941 8’9753
-3’9311 3’7059 9,8483

46. P á g i n a | 39
Así como el valor de los desplazamientos
solution_vector_d =
0.0000 0.0000 0.0000
0.0022 -0.0037 -0.0009
0.0054 -0.0053 -0.0008
0.0066 -0.0019 -0.0013
0.0027 -0.0011 -0.0012
0.0000 0.0000 0.0000