Análisis Estructural de una Armadura por medio de Matlab y Robot Structural

Analysis

Morales Castillo, Rodrigo Andrés

Aguilar Alzamora, Rosmery
Abanto Torres, Edwar Franklin
Santé Pisconti, Bruno Alonso

Departamento: Lima
Institución: Universidad Peruana de Ciencias Aplicadas
Fecha: martes 9 de junio de 2019
Análisis Estructural de una Armadura por medio de Matlab y
Robot Structural Analysis

Morales Castillo Rodrigo Andrés

Aguilar Alzamora Rosmery
Abanto Torres, Edwar Franklin
Santé Pisconti, Bruno Alonso
Departamento: Lima
Institución: Universidad Peruana de Ciencias Aplicadas
Fecha: martes 9 de junio de 2020

Resumen

Para el presente análisis estructural se trabajó tanto con el Software Matlab, así como
Dynamo, un programa dentro de Revit, y Robot Structural Analysis Professional, programas
comerciales de cálculo y diseño estructural, aplicados en el campo de la ingeniería en general y en
este caso en particular en la rama estructural. Matlab es un sistema de cómputo numérico que
ofrece un entorno de desarrollo integrado con un lenguaje de programación propio; es más,
comprende el análisis numérico, el cálculo matricial, el procesamiento de señales y los gráficos; por
otro lado Robot Structural Analysis Professional es un software especializado en el cálculo,
simulación y diseño de estructuras de ingeniería civil y arquitectura que permite realizar un análisis
exhaustivo del comportamiento estructural de una edificación o de cualquiera de sus partes,
utilizando el método de los elementos finitos (FEM) y varios tipos de algoritmos no lineales y
Dynamo es un programa de scripts visuales que permite crear algoritmos personalizados a fin de
procesar datos y generar geometrías. En otras palabras, Dynamo nos permite programar mediante la
utilización de elementos visuales (nodos), en vez de usar las típicas líneas de código

Detail such as name of institution ii Detail such as date

Contents

Resumen ii

Introducción al Elemento a Estudiar 1

Marco Teórico 2
Matriz de Rígidez 3
Metodología 5
Modelo matemático
Programación en Matlab
Análisis estructural en Robot Analysis

Resultados
Matriz de rigidez en Matlab
Diagrama en Matlab
Diagrama en Robot
Envolvente
24
Anexo 1: Código en Matlab

Anexo 2: Guide de Matlab

Referencias Bibliográfica

Universidad Peruana de Ciencias Aplicadas iii martes 9 de junio de 2020

Introducción al Elemento a estudiar

Normas a Utilizar

E.020:
Las edificaciones y todas sus partes deberán ser capaces de resistir las cargas que se les imponga
como consecuencia de su uso previsto. Estas actuarán en las combinaciones prescritas y no deben
causar esfuerzos ni deformaciones que excedan los señalados para cada material estructural en su
norma de diseño específica. En ningún caso las cargas empleadas en el diseño serán menores que
los valores mínimos establecidos en esta Norma.

Descripción de la Estructura
Se pide analizar el eje E-E del pórtico de un restaurante. La estructura soportará una carga sísmica
de 75 toneladas, además de acabados y un muro de tabiquería ubicado encima del pórtico. Además,
se tendrá consideración de la sobrecarga por uso, en este caso restaurante, según la norma E.020.
Las medidas del pórtico se expondrán en la tabla 1.

Table 1. Tabla de datos para los grupos, el presente trabajo es realizado por el grupo 8. Fuente: Ing.
Elvis Jony Mamani Yana.

Imagen 1. Elevación del pórtico. Fuente: Ing. Elvis Jony Mamani Yana.

Universidad Peruana de Ciencias Aplicadas 1 28 de junio de 2020

Imagen 2. Vista en planta de la losa. Fuente: Ing. Elvis Jony Mamani Yana.

Imagen 3. Extracto de la tabla 1 de la norma E.020, la sobrecarga de uso a usar para el pórtico es 400 kg/m2. Fuente: Ing. Elvis Jony
Mamani Yana.

Resumen de datos del grupo 8

 L1(m): 5.50 m
 L3(m): 4.50 m
 L4(m): 5.00 m
  L5(m): 4.50 m
 L6(m): 6.00 m
 h1(m): 3.50 m
 Peso de tabiquería: 6.75 kg/cm
 Peso de acabado: 120 kg/m2
 Peso de losa: 350 kg/m2
 Sobrecarga de uso según la Norma E.020: 400 kg/m2
 Sección de columna: 30x30 cm
 Sección de viga: 30x60 cm

Objetivo
El objetivo del trabajo planteado es familiarizar al alumno en la resolución de problemas estructurales de
pórticos implementado Softwares (Matlab y Robot).

Marco Teórico

Matriz de Rigidez

El análisis de una estructura es entendido como un proceso sistemático que sirve para obtener las características de su
comportamiento bajo cierto estado de cargas. Su objetivo principal se basa en la predicción del comportamiento de la
estructura analizada, bajo diversas acciones para las cuales se establezca que la estructura deba tener capacidad. Para
la estructura a analizar se solicita; primeramente, calcular la matriz de rigidez de cada elemento, y con esto llegar a la
matriz general, el método empleado en este trabajo será el método matricial de rigidez de un elemento.

Imagen 4: Matriz de rigidez para un Sistema de coordenadas global, dónde E representa el módulo de Elasticidad del material e I la inercia
del elemento. Fuente: Ing. Elvis Jony Mamani Yana.
La aplicación del método de la rigidez requiere identificar los elementos que tiene el pórtico, en nuestro trabajo se
identificó vigas y columnas a estudiar. Para el análisis del pórtico, los elementos finitos se representan mediante cada
uno de los elementos de que la compones y los nodos representan las juntas. Se determinan las propiedades de la
fuerza-desplazamiento en cada elemento y después se relacionan entre si usando las ecuaciones de equilibrio de
fuerzas escritas en los nodos. Luego estas relaciones, para toda la estructura, se agrupan en lo que se denomina matriz
de rigidez de la estructura K. Con esto, se determinan los desplazamientos desconocidos de los nodos para cualquier
carga dada sobre la estructura y con estos se pueden obtener las fuerzas externas e internas en la estructura utilizando
las relaciones de fuerza y desplazamiento para cada elemento.

Imagen 5: Grados de libertad para una matriz local de cada elemento evaluado . Fuente: Ing. Elvis Jony Mamani Yana.

Metodología

Modelo Matemático
Para realizar el modelo matemático se toma en cuenta las longitudes entre ejes de los elementos. En la
imagen 4 se muestra el modelo matemático a trabajar en los programas.

Imagen 6. Modelo matemático del eje E-E del pórtico. Fuente: Propia, AutoCAD.
 Imagen 7. Sentido de los elementos para las matrices. Fuente: Propia, AutoCAD.

Metrado de cargas
Carga Muerta:
5.50
∗350+ 120
2
+6.75=19.675 kg/cm …(ec . 1)
100

Carga Viva:
400
∗5.50
100
=11 kg /cm… (ec .2)
2

Carga Sismo:

75000 kg …(ec .3)

Programación en Matlab
A continuación, se pasará a explicar a detalle el proceso de programación que hemos tenido
en cuenta para la resolución del problema planteado. Se adjuntan imágenes para que el lector tenga
una mejor comprensión y sea más didáctico.

a. Empezamos creando un guide capaz de mostrar correctamente los resultados obtenidos (Ver
anexo 2).

b. Dentro del script, procedemos a la recolección de datos del guide.

 Imagen 8. Código para la recolección de datos y cálculo de inercias. Fuente: Propia, Matlab.

c. Procedemos a colocar las coordenadas y los grados de libertad en una matriz.

Imagen 9. Código para la introducción de coordenadas de los extremos de los elementos. Fuente: Propia, Matlab.

d. Realizamos la topología y determinamos la longitud de los elementos.

Imagen 10. Código para establecer la topología y las longitudes. Fuente: Propia, Matlab.

e. Realizamos el arreglo para determinar la matriz de rigidez y su ensamble.

Imagen 11. Determinación de la matriz de desplazamientos. Fuente: Propia, Matlab.

f. Procedemos a realizar nuestra matriz de fuerzas. Para ello, metramos las cargas según la
combinación a usar, introduciendo los valores dentro de la matriz de fuerzas según el GDL
en la que actúan.
Imagen 12. Selección de combinación en un pop-up menu. Fuente: Propia, Matlab.

Imagen 13. Asignación de cargas. Fuente: Propia, Matlab.

Imagen 14. Metrado de cargas según la combinación escogida. Fuente: Propia, Matlab.

Imagen 15. Relleno de matriz de fuerzas. Fuente: Propia, Matlab.

g. Procedemos a calcular la matriz de desplazamientos.

Imagen 16 y 17. Determinación de la matriz de desplazamientos. Fuente: Propia, Matlab.

h. Determinamos las fuerzas internas.

Imagen 18. Primera iteración para determinar las fuerzas internas. Fuente: Propia, Matlab.

i. Realizamos los diagramas de momento flector y fuerza cortante

Para la obtención de todos los resultados provenientes del código programado en Matlab se
procede a ejecutar el programa, seleccionando el tipo de combinación a analizar, finalmente
apretamos el botón calcular y obtendremos los resultados, así como los diagramas de momento
flector y fuerza cortante (Este código no contempla el peso propio ni la carga de sismo y sus
combinaciones).
Imagen 19. Resultados obtenidos por el código cuando se analiza la combinación de carga viva y muerta. Fuente:
Propia, Matlab.

Análisis Estructural en Robot Structural Analysis

Para realizar el análisis en Robot, trazamos vigas y columnas según el modelo matemático
que se muestra en la imagen 3. La imagen 13 muestra el resultado del trazado. Lo siguiente que
vamos a hacer es crear las secciones de vigas y columnas y las asignamos a los elementos.

Imagen 20. Vista frontal del dibujo del pórtico sin asignar secciones. Fuente: Propia, Robot Structural Analysis.
Imagen 21 y 22. Creación de secciones de columna y viga. Fuente: Propia, Robot Structural Analysis.

Imagen 23. Elevación del pórtico con sus secciones asignadas. Fuente: Propia, Robot Structural Analysis.

Lo que sigue es crear los 3 casos de carga: carga muerta, viva y sísmica. Luego colocamos
las cargas según el metrado (ver ecuaciones 1, 2 y 3) y su ubicación.

Imagen 24. Carga Muerta aplicada al pórtico. Fuente: Propia, Robot Structural Analysis.
Imagen 25. Carga Viva aplicada al pórtico. Fuente: Propia, Robot Structural Analysis.

Imagen 26. Carga Viva aplicada al pórtico. Fuente: Propia, Robot Structural Analysis.

Una vez colocadas las cargas procedemos a realizar la combinación de cargas y

finalmente determinar la envolvente.

Imagen 27. Cuadro de combinaciones de cargas. Fuente: Propia, Robot Structural Analysis.

Resultados
Matriz de Rigidez en Matlab
Cuando oprimimos el botón “Calcular” dentro del programa realizado en Matlab, se
ejecutará el código para el análisis. Una tabla nos mostrará la matriz de rigidez de la sección con
dimensión de 10x10, ya que fueron 10 grados que se ingresaron. La mitad de los grados están
restringidos. La matriz resultante es simétrica y presenta una diagonal positiva, características
propias de la matriz de rigidez. La imagen 18 muestra la matriz del elemento.
Imagen 28. Matriz de rigidez del pórtico. Fuente: Propia, Matlab.

Matriz de Fuerzas y desplazamientos en Matlab

Cuando oprimimos el botón “Calcular” dentro del programa realizado en Matlab, se
ejecutará el código para el análisis. Un par de tablas muestran las matrices de desplazamiento
calculadas y la matriz de fuerza global.

Imagen 29. Matriz de fuerzas, en kg.cm, y de desplazamientos, en cm, cuando solo actúa la carga muerta. Fuente:
Propia, Matlab.
Imagen 30. Matriz de fuerzas, en kg.cm, y de desplazamientos, en cm, cuando solo actúa la carga viva. Fuente: Propia,
Matlab.

Imagen 31. Matriz de fuerzas, en kg.cm, y de desplazamientos, en cm, cuando se ejecuta la combinación de cargas.
Fuente: Propia, Matlab.

Diagramas en Matlab
Para obtener los diagramas se debe escoger la combinación a analizar y apretar el botón
calcular.
Imagen 32. Diagrama de fuerza cortante y momento flector cuando solo actúa la carga muerta. Fuente: Propia, Matlab.
Imagen 33. Diagrama de fuerza cortante y momento flector cuando solo actúa la carga viva. Fuente: Propia, Matlab.
Imagen 34. Diagrama de fuerza cortante y momento flector cuando se ejecuta la combinación de cargas. Fuente:
Propia, Matlab.

De los diagramas se puede observar que es la columna del extremo izquierdo y la viga
del extremo derecho las que se ven más afectadas por los esfuerzos cortantes. Además, la viga
del extremo derecho es la que más se ve afectada por el momento flector.

Diagramas en ROBOT
Para obtener los resultados se aprieta el botón “calculate” y se selecciona los diagramas
que se desean mostrar. Las siguientes imágenes muestran los diagramas por casos.
Caso 1: Carga Muerta (Incluyendo peso propio)
Imagen 33. Diagrama de fuerzas cortantes en kg resultado de las cargas muertas. Fuente: Propia, Robot Structural Analysis.

Imagen 35. Diagrama de momento flector en tn/n resultado de las cargas vivas. Fuente: Propia, Robot Structural Analysis.

Caso 2: Carga Viva

Imagen 36. Diagrama de fuerzas cortantes en kg resultado de las cargas vivas. Fuente: Propia, Robot Structural Analysis.

Imagen 37. Diagrama de momento flector en tn/n resultado de las cargas muertas. Fuente: Propia, Robot Structural Analysis.
 Caso 3: Carga Sísmica

Imagen 38. Diagrama de fuerzas cortantes en kg resultado de las cargas sísmica. Fuente: Propia, Robot Structural Analysis.

Imagen 39. Diagrama de momento flector en tn/n resultado de las cargas sísmica. Fuente: Propia, Robot Structural Analysis.

De la misma forma calculamos los diagramas para las combinaciones.

Combinación 1: 1.4CM+1.7CV

Imagen 40. Diagrama de fuerzas cortantes en kg resultado de combinación 1. Fuente: Propia, Robot Structural Analysis.
Imagen 41. Diagrama de momento flector en tn/n resultado de combinación 1. Fuente: Propia, Robot Structural Analysis.

Combinación 2: 1.25(CM+CV) +CS

Imagen 42. Diagrama de fuerzas cortantes en kg resultado de combinación 1. Fuente: Propia, Robot Structural Analysis.

Imagen 43. Diagrama de momento flector en tn/n resultado de combinación 1. Fuente: Propia, Robot Structural Analysis.

Combinación 3: 1.25(CM+CV)-CS
Imagen 44. Diagrama de fuerzas cortantes en kg resultado de combinación 1. Fuente: Propia, Robot Structural Analysis.

Imagen 45. Diagrama de momento flector en tn/n resultado de combinación 1. Fuente: Propia, Robot Structural Analysis.

Combinación 4: 0.9CM+CS

Imagen 46. Diagrama de fuerzas cortantes en kg resultado de combinación 1. Fuente: Propia, Robot Structural Analysis.
Imagen 47. Diagrama de momento flector en tn/n resultado de combinación 1. Fuente: Propia, Robot Structural Analysis.

Combinación 4: 0.9CM-CS

Imagen 48. Diagrama de fuerzas cortantes en kg resultado de combinación 1. Fuente: Propia, Robot Structural Analysis.

Imagen 49. Diagrama de momento flector en tn/n resultado de combinación 1. Fuente: Propia, Robot Structural Analysis.
 ENVOLVENTE

Imagen 50. Diagrama de fuerzas cortantes en kg resultado de combinación 1. Fuente: Propia, Robot Structural Analysis.

Imagen 51. Diagrama de momento flector en tn/m resultado de combinación 1. Fuente: Propia, Robot Structural Analysis.

Anexo 1: Código en Matlab

% --- Executes on button press in CALCULAR.

%---O---O---O---O---O---O---O---O---O---O---O---O---O---O---
% Propiedades del Pórtico
% E: Módulo de Elasticidad, en kg/cm^2.
cla(handles.axes1,'reset');
cla(handles.axes2,'reset');
E=str2double(get(handles.ME,'string'));

%Matrices vacía de Inercias

I=zeros(9,1);
% Dimensiones de las vigas, en centímetros.
vb=str2double(get(handles.Vb,'string'));
vh=str2double(get(handles.Vh,'string'));
iv=vb*vh^3/12;

% Dimensiones de las columnas, en centímetros.

cb=str2double(get(handles.Cb,'string'));
ch=str2double(get(handles.Ch,'string'));
ic=cb*ch^3/12;

%Matrices de Inercias
I=[iv; iv; iv; iv; iv
ic; ic; ic; ic; ic; ic];

%---O---O---O---O---O---O---O---O---O---O---O---O---O---O---
% Organización de Datos
% XY_GL: Matriz de coordenadas de los nodos y
% sus grados de libertad en cm.
% [x y GLx GLy GLm]
XY_GL=[0 320 1
450 320 2
950 320 3
1400 320 4
2000 320 5
0 0 6
450 0 7
950 0 8
1400 0 9
2000 0 10];

% Matriz de coordenadas X, en cm.

x=XY_GL(:,1);
% Matriz de coordenadas Y, en cm.
y=XY_GL(:,2);

% Topología de los elementos

% EL=[4 Vigas
% 5 Columnas]
EL=[1 2; 2 3; 3 4; 4 5
6 1; 7 2; 8 3; 9 4; 10 5];

%---O---O---O---O---O---O---O---O---O---O---O---O---O---O---
% Longitud de Barras
% Matriz vacía de longitudes, en cm.
l=zeros(9,1);

% Determinación de la longitud de las barras.

for e=1:9
l(e)=sqrt((x(EL(e,2))-x(EL(e,1)))^2 +(y(EL(e,2))-y(EL(e,1)))^2);
end
%---O---O---O---O---O---O---O---O---O---O---O---O---O---O---
% Determinación de la Matriz de Rigidez Global
K=zeros(10);
%Despreciando Fuerzas Cortantes
phi=0;

for e=1:9
% Matriz de rigidez local por cada elemento.
% K=[GL1 GL2]
K_e(:,:,e)=E*I(e)/l(e)*[4 2; 2 4];

% Relación entre GDL.

g_e=[XY_GL(EL(e,1),3) XY_GL(EL(e,2),3)];

% Ensamble de la matriz de rigidez global.

K(g_e,g_e)=K(g_e,g_e)+K_e(:,:,e);
end
set(handles.mrigidez,'data',K);

%---O---O---O---O---O---O---O---O---O---O---O---O---O---O---
% Determinación de la Matriz Fuerzas Globales
% Matriz de fuerzas globales vacía, en kg.
P=zeros(10);

%---O---O---O---O---O---O---O---O---O---O---O---O---O---O---
% Metrado de Cargas
% Long tributaria, en m.
Lt=5.5/2;

% Peso de Losa, en kg/m2.

pl=350;

% Peso de Acabados en kg/m2.

pa=120;

% Tabiquería encima del pórtico en kg/cm.

pt=6.75;

%Peso de sobrecarga (E.020->Restaurant)

sc=400;

%Metrado de Losa (distribuida), en kg/cm.

ver=get(handles.car,'value');
switch ver
case 2
wl=Lt*sc/100;

case 3
wl=1.4*(Lt*(pl+pa)/100+pt)+1.7*Lt*sc/100;
 otherwise
wl=Lt*(pl+pa)/100+pt;
end

%Matriz de Cargas
for e=1:4
P_e(:,:,e)=[-wl*l(e)^2/12
wl*l(e)^2/12];

% Relación entre GDL.

h_e=[XY_GL(EL(e,1),3) XY_GL(EL(e,2),3)];

% Ensamble de la matriz de rigidez global.

P(h_e,1)=P(h_e,1)+P_e(:,:,e);
end
P=P(:,1)

%---O---O---O---O---O---O---O---O---O---O---O---O---O---O---
% Cálculo de Desplazamientos y Reacciones en Apoyos
% Matriz de grados restringidos (GDR).
a=(6:10)';
% Matriz de grados no restringidos (GDL).
b=(1:5)';

K_ab=K(a,b); % => [G]

K_bb=K(b,b); % => [S]
K_ba=K(b,a);

% Matriz de desplazamientos globales vacía, en cm.

D=zeros(10,1);

% Matriz de fuerzas conocidas, en kg.

P_b=P(b);

% Matriz de desplazamientos conocidos, en cm.

D_a=D(a);

% Matriz de desplazamientos en los grados no restringidos, en cm.

D_b=K_bb\P_b;
D(b)=D_b;

% Matriz de las reacciones en los apoyos, en kg.

P_a=K_ab*D_b;
P(a)=P_a-P([6 7 8 9 10]);
P_a=P([6 7 8 9 10]);
set(handles.desplazamiento,'data',D);

%---O---O---O---O---O---O---O---O---O---O---O---O---O---O---
% Fuerzas Internas
% Matriz de fuerzas internas vacía, en kg.
F=zeros(5,1);

% Antes de realizar un "For"...

% Realizamos un armado de matriz para i=1.
% Aquí usé otro índice porque con el "e" ...
% habían interferencias cuando hice pruebas.
i=1;
k=E*I(i)/l(i)*[4 2; 2 4];
g_i=[XY_GL(EL(i,1),3) XY_GL(EL(i,2),3)];

f=[wl*l(i)^2/12; -wl*l(i)^2/12];
D_i=D(g_i);
esf=+k*D_i+f;

F(i,1)=esf(1,1);
F(i+1,1)=esf(2,1);

%Ya teninendo una matriz previa, realizamos la iteración.

axes(handles.axes1)
for i=1:4
e1=12*E*I(i)/l(i)^3;
e2=6*E*I(i)/l(i)^2;
e3=4*E*I(i)/l(i);
e4=2*E*I(i)/l(i);
k=[e1 e2 -e1 e2;e2 e3 -e2 e4;-e1 -e2 e1 -e2;e2 e4 -e2 e3];
g_i=[XY_GL(EL(i,1),3) XY_GL(EL(i,2),3)];
f=[wl*l(i)/2 wl*l(i)^2/12 wl*l(i)/2 -wl*l(i)^2/12]';
D_i=D(g_i);
DD=[0; D_i(1);0;D_i(2)];
esf=k*DD+f
xx=0:1:l(i);
M=esf(1).*xx-esf(2)-wl*xx.^2*0.5;
xxx=[0 xx(1:end) xx(end)];
yyy=-[0 M(1:end) 0]*0.0002;
asd=polyshape(xxx,yyy);
F(i,1)=F(i,1)+esf(1,1);
F(i+1,1)=esf(2,1);
asd=translate(asd,[x(EL(i,1)) y(EL(i,1))]);
plot(asd)
hold on
axis equal
end

for i=5:9
e1=12*E*I(i)/l(i)^3;
e2=6*E*I(i)/l(i)^2;
e3=4*E*I(i)/l(i);
e4=2*E*I(i)/l(i);
 k=[e1 -e2 -e1 -e2;-e2 e3 e2 e4;-e1 e2 e1 e2;-e2 e4 e2 e3];
g_i=[XY_GL(EL(i,1),3) XY_GL(EL(i,2),3)];
D_i=D(g_i);
DD=[0; D_i(1);0;D_i(2)];
esf=k*DD
xx=0:1:l(i);
M=esf(1).*xx+esf(2);
xxx=[0 xx(1:end) xx(end)];
yyy=[0 M(1:end) 0]*0.0002;
asd=polyshape(xxx,yyy);
asd = rotate(asd,-90,[0 0]);
F(i,1)=F(i,1)+esf(1,1);
F(i+1,1)=esf(2,1);
asd=translate(asd,[x(EL(i,2)) y(EL(i,2))]);
plot(asd)
hold on
axis equal
end

% Matriz de momentos en kg*cm.

set(handles.esfuerzos,'data',F);

%---O---O---O---O---O---O---O---O---O---O---O---O---O---O---
% Dibujo de la armadura y su posición deformada
XY_GLdef=zeros(size(XY_GL));
fac=1;

% Modificación de las coordenadas factor

for e=1:10

XY_GLdef(e,1)=XY_GL(e,1)+fac*D(e);

XY_GLdef(e,2)=XY_GL(e,2)+fac*D(e);
end

% Gráfica
for e=1:9

Q=[XY_GL(EL(e,1),1) XY_GL(EL(e,1),2);...
XY_GL(EL(e,2),1) XY_GL(EL(e,2),2)];

Qdef=[XY_GLdef(EL(e,1),1) XY_GLdef(EL(e,1),2);...
XY_GLdef(EL(e,2),1) XY_GLdef(EL(e,2),2)];

%Axes
plot(Q(:,1),Q(:,2),':b',Qdef(:,1),Qdef(:,2),'-r')

title('Diagrama de Momento Flector');

end
xlabel('x')
ylabel('y')
axis equal

axes(handles.axes2)
XY_GLdef=zeros(size(XY_GL));
fac=1;

% Modificación de las coordenadas factor

for e=1:10

XY_GLdef(e,1)=XY_GL(e,1)+fac*D(e);

XY_GLdef(e,2)=XY_GL(e,2)+fac*D(e);
end
for e=1:9
Q=[XY_GL(EL(e,1),1) XY_GL(EL(e,1),2);...
XY_GL(EL(e,2),1) XY_GL(EL(e,2),2)];

Qdef=[XY_GLdef(EL(e,1),1) XY_GLdef(EL(e,1),2);...
XY_GLdef(EL(e,2),1) XY_GLdef(EL(e,2),2)];
hold on
%Axes
plot(Q(:,1),Q(:,2),':b',Qdef(:,1),Qdef(:,2),'-r')
end
xlabel('x')
ylabel('y')
axis equal

for i=1:4
e1=12*E*I(i)/l(i)^3;
e2=6*E*I(i)/l(i)^2;
e3=4*E*I(i)/l(i);
e4=2*E*I(i)/l(i);
k=[e1 e2 -e1 e2;e2 e3 -e2 e4;-e1 -e2 e1 -e2;e2 e4 -e2 e3];
g_i=[XY_GL(EL(i,1),3) XY_GL(EL(i,2),3)];
f=[wl*l(i)/2 wl*l(i)^2/12 wl*l(i)/2 -wl*l(i)^2/12]';
D_i=D(g_i);
DD=[0; D_i(1);0;D_i(2)];
esf=k*DD+f
xx=0:1:l(i);
M=esf(1)-wl*xx;
xxx=[0 xx(1:end) xx(end)];
yyy=-[0 M(1:end) 0]*0.02;
asd=polyshape(xxx,yyy);
F(i,1)=F(i,1)+esf(1,1);
F(i+1,1)=esf(2,1);
asd=translate(asd,[x(EL(i,1)) y(EL(i,1))]);
plot(asd)
end

for i=5:9
e1=12*E*I(i)/l(i)^3;
e2=6*E*I(i)/l(i)^2;
e3=4*E*I(i)/l(i);
e4=2*E*I(i)/l(i);
k=[e1 -e2 -e1 -e2;-e2 e3 e2 e4;-e1 e2 e1 e2;-e2 e4 e2 e3];
g_i=[XY_GL(EL(i,1),3) XY_GL(EL(i,2),3)];
D_i=D(g_i);
DD=[0; D_i(1);0;D_i(2)];
esf=k*DD
xx=0:1:l(i);
M=esf(1)*ones(1,length(xx))*0.2;
xxx=[0 xx(1:end) xx(end)];
yyy=[0 M(1:end) 0];
asd=polyshape(xxx,yyy);
asd = rotate(asd,-90,[0 0]);
F(i,1)=F(i,1)+esf(1,1);
F(i+1,1)=esf(2,1);
asd=translate(asd,[x(EL(i,2)) y(EL(i,2))]);
plot(asd)
end
axis equal
title('Diagrama de Fuerzas Cortantes');

% --- Executes on button press in LIMPIAR.

cla(handles.axes1)
cla(handles.axes2)
set(handles.esfuerzos,'data','');
set(handles.desplazamiento,'data','');
set(handles.mrigidez,'data','');
clear
clc

% --- Executes on button press in CERRAR.

close

Anexo 2: Guide de Matlab

Imagen 52. Guide realizado para mostrar y ejecutar el código. El guide presenta un par de axes para la proyección de
las gráficas, un popupmenu para escoger el tipo de carga, 3 tablas para mostrar la matriz de rigidez, los
desplazamientos y las fuerzas axiales; y 3 botones: Calcular ejecuta el código, Nuevo limpia el guide, dejándolo listo
para otro análisis; y Salir sirve para cerrar el programa. Fuente: Propia, Matlab.
 Bibliografia

1. Análisis y Diseño de Estructuras con AUTODESK ROBOT STRUCTURAL ANALYSIS 2016, 3 th ed. by
Carlos Villaroel, https://drive.google.com/file/d/1PTEC- xZlGOITuwtTpado_EkpP2_hpNL5/view?
fbclid=IwAR3d1Hijt0k5AHCqVTTqxHEvaVlw0ygs pCh-5dR8FpYtzKyYjc0lDCrLGm4(accessed 01 June
2020).

2. Marc E. Herniter, “Programing in Matlab,” (Thomson learning , 2001)

3. Peregrina Estevez, “Matemáticas en Ingeniería con Matlab,” (Universidade de Santiago de Compostela , 2000)

4. ME 340 Teaching Team, “Lab 6: Functional Decomposition and Analytic Hierarchy Process,” presentation
(University Park: Mechanical Engineering Department, Penn State, 2016).

5. Desmond J. Higham, Nicolas J. Higham, “Matlab guide 3th ed,” (Siam, January 2017)

6. Análisis y Diseño de Estructuras con AUTODESK ROBOT STRUCTURAL ANALYSIS 2016, 3 th ed. by
Carlos Villaroel, https://drive.google.com/file/d/1PTEC-xZlGOITuwtTpado_EkpP2_hpNL5/view?
fbclid=IwAR3d1Hijt0k5AHCqVTTqxHEvaVlw0ygspCh-5dR8FpYtzKyYjc0lDCrLGm4(accessed 01 June
2020).

7. Marc E. Herniter, “Programing in Matlab,” (Thomson learning , 2001)

8. Peregrina Estevez, “Matemáticas en Ingeniería con Matlab,” (Universidade de Santiago de Compostela , 2000)

9. Autodesk, “Dynamo Language Manual” (https://dynamobim.org/wp-content/uploads/forum-assets/colin-

mccroneautodesk-com/07/10/Dynamo_language_guide_version_1.pdf) (accessed 02 June 2020).